Commit 8c60fc5a authored by Kershaw Chang's avatar Kershaw Chang
Browse files

Bug 1893075 - Refactor CacheFileIOManager::Write, r=necko-reviewers,valentin 

Differential Revision: https://phabricator.services.mozilla.com/D208739
parent 75e5a088

netwerk/cache2/CacheFileIOManager.cpp

+32 −12
Original line number Diff line number Diff line
@@ -2026,26 +2026,46 @@ nsresult CacheFileIOManager::Write(CacheFileHandle* aHandle, int64_t aOffset, 
       "validate=%d, truncate=%d, listener=%p]",

       aHandle, aOffset, aCount, aValidate, aTruncate, aCallback));



  nsresult rv;

  MOZ_ASSERT(aCallback);



  RefPtr<CacheFileIOManager> ioMan = gInstance;



  if (aHandle->IsClosed() || (aCallback && aCallback->IsKilled()) || !ioMan) {

    if (!aCallback) {

      // When no callback is provided, CacheFileIOManager is responsible for

      // releasing the buffer. We must release it even in case of failure.

      free(const_cast<char*>(aBuf));

    }

  if (aHandle->IsClosed() || aCallback->IsKilled() || !ioMan) {

    return NS_ERROR_NOT_INITIALIZED;

  }



  RefPtr<WriteEvent> ev = new WriteEvent(aHandle, aOffset, aBuf, aCount,

                                         aValidate, aTruncate, aCallback);

  rv = ioMan->mIOThread->Dispatch(ev, aHandle->mPriority

  return ioMan->mIOThread->Dispatch(ev, aHandle->mPriority

                                            ? CacheIOThread::WRITE_PRIORITY

                                            : CacheIOThread::WRITE);

  NS_ENSURE_SUCCESS(rv, rv);

}



  return NS_OK;

// static

nsresult CacheFileIOManager::WriteWithoutCallback(CacheFileHandle* aHandle,

                                                  int64_t aOffset, char* aBuf,

                                                  int32_t aCount,

                                                  bool aValidate,

                                                  bool aTruncate) {

  LOG(("CacheFileIOManager::WriteWithoutCallback() [handle=%p, offset=%" PRId64

       ", count=%d, "

       "validate=%d, truncate=%d]",

       aHandle, aOffset, aCount, aValidate, aTruncate));



  RefPtr<CacheFileIOManager> ioMan = gInstance;



  if (aHandle->IsClosed() || !ioMan) {

    // When no callback is provided, CacheFileIOManager is responsible for

    // releasing the buffer. We must release it even in case of failure.

    free(aBuf);

    return NS_ERROR_NOT_INITIALIZED;

  }



  RefPtr<WriteEvent> ev = new WriteEvent(aHandle, aOffset, aBuf, aCount,

                                         aValidate, aTruncate, nullptr);

  return ioMan->mIOThread->Dispatch(ev, aHandle->mPriority

                                            ? CacheIOThread::WRITE_PRIORITY

                                            : CacheIOThread::WRITE);

}



static nsresult TruncFile(PRFileDesc* aFD, int64_t aEOF) {

netwerk/cache2/CacheFileIOManager.h

+8 −0
Original line number Diff line number Diff line
@@ -287,9 +287,17 @@ class CacheFileIOManager final : public nsITimerCallback, public nsINamed { 
                           CacheFileIOListener* aCallback);

  static nsresult Read(CacheFileHandle* aHandle, int64_t aOffset, char* aBuf,

                       int32_t aCount, CacheFileIOListener* aCallback);

  // This function must be called with a callback. The caller is responsible for

  // releasing |aBuf|.

  static nsresult Write(CacheFileHandle* aHandle, int64_t aOffset,

                        const char* aBuf, int32_t aCount, bool aValidate,

                        bool aTruncate, CacheFileIOListener* aCallback);

  // Similar to the above, but without the callback. Note that |aBuf| will be

  // released by CacheFileIOManager.

  static nsresult WriteWithoutCallback(CacheFileHandle* aHandle,

                                       int64_t aOffset, char* aBuf,

                                       int32_t aCount, bool aValidate,

                                       bool aTruncate);

  // PinningDoomRestriction:

  // NO_RESTRICTION

  //    no restriction is checked, the file is simply always doomed

netwerk/cache2/CacheFileMetadata.cpp

+4 −2
Original line number Diff line number Diff line
@@ -257,14 +257,16 @@ nsresult CacheFileMetadata::WriteMetadata( 
  char* writeBuffer = mWriteBuf;

  if (aListener) {

    mListener = aListener;

    rv = CacheFileIOManager::Write(mHandle, aOffset, writeBuffer,

                                   p - writeBuffer, true, true, this);

  } else {

    // We are not going to pass |this| as a callback so the buffer will be

    // released by CacheFileIOManager. Just null out mWriteBuf here.

    mWriteBuf = nullptr;

    rv = CacheFileIOManager::WriteWithoutCallback(mHandle, aOffset, writeBuffer,

                                                  p - writeBuffer, true, true);

  }



  rv = CacheFileIOManager::Write(mHandle, aOffset, writeBuffer, p - writeBuffer,

                                 true, true, aListener ? this : nullptr);

  if (NS_FAILED(rv)) {

    LOG(

        ("CacheFileMetadata::WriteMetadata() - CacheFileIOManager::Write() "

netwerk/cache2/CacheIndex.cpp

+4 −10
Original line number Diff line number Diff line
@@ -2213,16 +2213,10 @@ void CacheIndex::ParseRecords(const StaticMutexAutoLock& aProofOfLock) { 
          reinterpret_cast<uint32_t*>(moz_xmalloc(sizeof(uint32_t)));

      NetworkEndian::writeUint32(isDirty, 1);



      // Mark index dirty. The buffer is freed by CacheFileIOManager when

      // nullptr is passed as the listener and the call doesn't fail

      // synchronously.

      rv = CacheFileIOManager::Write(mIndexHandle, 2 * sizeof(uint32_t),

                                     reinterpret_cast<char*>(isDirty),

                                     sizeof(uint32_t), true, false, nullptr);

      if (NS_FAILED(rv)) {

        // This is not fatal, just free the memory

        free(isDirty);

      }

      // Mark index dirty. The buffer will be freed by CacheFileIOManager.

      CacheFileIOManager::WriteWithoutCallback(

          mIndexHandle, 2 * sizeof(uint32_t), reinterpret_cast<char*>(isDirty),

          sizeof(uint32_t), true, false);

    }

    pos += sizeof(uint32_t);