Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       5             : 
       6             : #include "mozilla/HashFunctions.h"
       7             : 
       8             : #include "ProfileJSONWriter.h"
       9             : 
      10             : void
      11           0 : ChunkedJSONWriteFunc::Write(const char* aStr)
      12             : {
      13           0 :   MOZ_ASSERT(mChunkPtr >= mChunkList.back().get() && mChunkPtr <= mChunkEnd);
      14           0 :   MOZ_ASSERT(mChunkEnd >= mChunkList.back().get() + mChunkLengths.back());
      15           0 :   MOZ_ASSERT(*mChunkPtr == '\0');
      16             : 
      17           0 :   size_t len = strlen(aStr);
      18             : 
      19             :   // Most strings to be written are small, but subprocess profiles (e.g.,
      20             :   // from the content process in e10s) may be huge. If the string is larger
      21             :   // than a chunk, allocate its own chunk.
      22             :   char* newPtr;
      23           0 :   if (len >= kChunkSize) {
      24           0 :     AllocChunk(len + 1);
      25           0 :     newPtr = mChunkPtr + len;
      26             :   } else {
      27           0 :     newPtr = mChunkPtr + len;
      28           0 :     if (newPtr >= mChunkEnd) {
      29           0 :       AllocChunk(kChunkSize);
      30           0 :       newPtr = mChunkPtr + len;
      31             :     }
      32             :   }
      33             : 
      34           0 :   memcpy(mChunkPtr, aStr, len);
      35           0 :   *newPtr = '\0';
      36           0 :   mChunkPtr = newPtr;
      37           0 :   mChunkLengths.back() += len;
      38           0 : }
      39             : 
      40             : mozilla::UniquePtr<char[]>
      41           0 : ChunkedJSONWriteFunc::CopyData() const
      42             : {
      43           0 :   MOZ_ASSERT(mChunkLengths.length() == mChunkList.length());
      44           0 :   size_t totalLen = 1;
      45           0 :   for (size_t i = 0; i < mChunkLengths.length(); i++) {
      46           0 :     MOZ_ASSERT(strlen(mChunkList[i].get()) == mChunkLengths[i]);
      47           0 :     totalLen += mChunkLengths[i];
      48             :   }
      49           0 :   mozilla::UniquePtr<char[]> c = mozilla::MakeUnique<char[]>(totalLen);
      50           0 :   char* ptr = c.get();
      51           0 :   for (size_t i = 0; i < mChunkList.length(); i++) {
      52           0 :     size_t len = mChunkLengths[i];
      53           0 :     memcpy(ptr, mChunkList[i].get(), len);
      54           0 :     ptr += len;
      55             :   }
      56           0 :   *ptr = '\0';
      57           0 :   return c;
      58             : }
      59             : 
      60             : void
      61           0 : ChunkedJSONWriteFunc::Take(ChunkedJSONWriteFunc&& aOther)
      62             : {
      63           0 :   for (size_t i = 0; i < aOther.mChunkList.length(); i++) {
      64           0 :     MOZ_ALWAYS_TRUE(mChunkLengths.append(aOther.mChunkLengths[i]));
      65           0 :     MOZ_ALWAYS_TRUE(mChunkList.append(mozilla::Move(aOther.mChunkList[i])));
      66             :   }
      67           0 :   mChunkPtr = mChunkList.back().get() + mChunkLengths.back();
      68           0 :   mChunkEnd = mChunkPtr;
      69           0 :   aOther.mChunkPtr = nullptr;
      70           0 :   aOther.mChunkEnd = nullptr;
      71           0 :   aOther.mChunkList.clear();
      72           0 :   aOther.mChunkLengths.clear();
      73           0 : }
      74             : 
      75             : void
      76           0 : ChunkedJSONWriteFunc::AllocChunk(size_t aChunkSize)
      77             : {
      78           0 :   MOZ_ASSERT(mChunkLengths.length() == mChunkList.length());
      79           0 :   mozilla::UniquePtr<char[]> newChunk = mozilla::MakeUnique<char[]>(aChunkSize);
      80           0 :   mChunkPtr = newChunk.get();
      81           0 :   mChunkEnd = mChunkPtr + aChunkSize;
      82           0 :   *mChunkPtr = '\0';
      83           0 :   MOZ_ALWAYS_TRUE(mChunkLengths.append(0));
      84           0 :   MOZ_ALWAYS_TRUE(mChunkList.append(mozilla::Move(newChunk)));
      85           0 : }
      86             : 
      87             : void
      88           0 : SpliceableJSONWriter::TakeAndSplice(ChunkedJSONWriteFunc* aFunc)
      89             : {
      90           0 :   Separator();
      91           0 :   for (size_t i = 0; i < aFunc->mChunkList.length(); i++) {
      92           0 :     WriteFunc()->Write(aFunc->mChunkList[i].get());
      93             :   }
      94           0 :   aFunc->mChunkPtr = nullptr;
      95           0 :   aFunc->mChunkEnd = nullptr;
      96           0 :   aFunc->mChunkList.clear();
      97           0 :   aFunc->mChunkLengths.clear();
      98           0 :   mNeedComma[mDepth] = true;
      99           0 : }
     100             : 
     101             : void
     102           0 : SpliceableJSONWriter::Splice(const char* aStr)
     103             : {
     104           0 :   Separator();
     105           0 :   WriteFunc()->Write(aStr);
     106           0 :   mNeedComma[mDepth] = true;
     107           0 : }
     108             : 
     109             : void
     110           0 : SpliceableChunkedJSONWriter::TakeAndSplice(ChunkedJSONWriteFunc* aFunc)
     111             : {
     112           0 :   Separator();
     113           0 :   WriteFunc()->Take(mozilla::Move(*aFunc));
     114           0 :   mNeedComma[mDepth] = true;
     115           0 : }