netwerk/cache2/CacheFileInputStream.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "CacheLog.h"
   6 #include "CacheFileInputStream.h"
   7
   8 #include "CacheFile.h"
   9 #include "nsStreamUtils.h"
  10 #include "nsThreadUtils.h"
  11 #include "mozilla/IntegerPrintfMacros.h"
  12 #include <algorithm>
  13
  14 namespace mozilla::net {
  15
  16 NS_IMPL_ADDREF(CacheFileInputStream)
  17 NS_IMETHODIMP_(MozExternalRefCountType)
  18 CacheFileInputStream::Release() {
  19   MOZ_ASSERT(0 != mRefCnt, "dup release");
  20   nsrefcnt count = --mRefCnt;
  21   NS_LOG_RELEASE(this, count, "CacheFileInputStream");
  22
  23   if (0 == count) {
  24     mRefCnt = 1;
  25     delete (this);
  26     return 0;
  27   }
  28
  29   if (count == 1) {
  30     CacheFileAutoLock lock(mFile);
  31     mFile->RemoveInput(this, mStatus);
  32   }
  33
  34   return count;
  35 }
  36
  37 NS_INTERFACE_MAP_BEGIN(CacheFileInputStream)
  38   NS_INTERFACE_MAP_ENTRY(nsIInputStream)
  39   NS_INTERFACE_MAP_ENTRY(nsIAsyncInputStream)
  40   NS_INTERFACE_MAP_ENTRY(nsISeekableStream)
  41   NS_INTERFACE_MAP_ENTRY(nsITellableStream)
  42   NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileChunkListener)
  43   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
  44 NS_INTERFACE_MAP_END
  45
  46 CacheFileInputStream::CacheFileInputStream(CacheFile* aFile,
  47                                            nsISupports* aEntry,
  48                                            bool aAlternativeData)
  49     : mFile(aFile),
  50       mPos(0),
  51       mStatus(NS_OK),
  52       mClosed(false),
  53       mInReadSegments(false),
  54       mWaitingForUpdate(false),
  55       mAlternativeData(aAlternativeData),
  56       mListeningForChunk(-1),
  57       mCallbackFlags(0),
  58       mCacheEntryHandle(aEntry) {
  59   LOG(("CacheFileInputStream::CacheFileInputStream() [this=%p]", this));
  60
  61   if (mAlternativeData) {
  62     mPos = mFile->mAltDataOffset;
  63   }
  64 }
  65
  66 CacheFileInputStream::~CacheFileInputStream() {
  67   LOG(("CacheFileInputStream::~CacheFileInputStream() [this=%p]", this));
  68   MOZ_ASSERT(!mInReadSegments);
  69 }
  70
  71 // nsIInputStream
  72 NS_IMETHODIMP
  73 CacheFileInputStream::Close() {
  74   LOG(("CacheFileInputStream::Close() [this=%p]", this));
  75   return CloseWithStatus(NS_OK);
  76 }
  77
  78 NS_IMETHODIMP
  79 CacheFileInputStream::Available(uint64_t* _retval) {
  80   CacheFileAutoLock lock(mFile);
  81
  82   if (mClosed) {
  83     LOG(
  84         ("CacheFileInputStream::Available() - Stream is closed. [this=%p, "
  85          "status=0x%08" PRIx32 "]",
  86          this, static_cast<uint32_t>(mStatus)));
  87     return NS_FAILED(mStatus) ? mStatus : NS_BASE_STREAM_CLOSED;
  88   }
  89
  90   EnsureCorrectChunk(false);
  91   if (NS_FAILED(mStatus)) {
  92     LOG(
  93         ("CacheFileInputStream::Available() - EnsureCorrectChunk failed. "
  94          "[this=%p, status=0x%08" PRIx32 "]",
  95          this, static_cast<uint32_t>(mStatus)));
  96     return mStatus;
  97   }
  98
  99   nsresult rv = NS_OK;
 100   *_retval = 0;
 101
 102   if (mChunk) {
 103     int64_t canRead = mFile->BytesFromChunk(mChunk->Index(), mAlternativeData);
 104     canRead -= (mPos % kChunkSize);
 105
 106     if (canRead > 0) {
 107       *_retval = canRead;
 108     } else if (canRead == 0 && !mFile->OutputStreamExists(mAlternativeData)) {
 109       rv = NS_BASE_STREAM_CLOSED;
 110     }
 111   }
 112
 113   LOG(("CacheFileInputStream::Available() [this=%p, retval=%" PRIu64
 114        ", rv=0x%08" PRIx32 "]",
 115        this, *_retval, static_cast<uint32_t>(rv)));
 116
 117   return rv;
 118 }
 119
 120 NS_IMETHODIMP
 121 CacheFileInputStream::StreamStatus() {
 122   CacheFileAutoLock lock(mFile);
 123
 124   if (mClosed) {
 125     LOG(
 126         ("CacheFileInputStream::StreamStatus() - Stream is closed. [this=%p, "
 127          "status=0x%08" PRIx32 "]",
 128          this, static_cast<uint32_t>(mStatus)));
 129     return NS_FAILED(mStatus) ? mStatus : NS_BASE_STREAM_CLOSED;
 130   }
 131
 132   return NS_OK;
 133 }
 134
 135 NS_IMETHODIMP
 136 CacheFileInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* _retval) {
 137   LOG(("CacheFileInputStream::Read() [this=%p, count=%d]", this, aCount));
 138   return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, _retval);
 139 }
 140
 141 NS_IMETHODIMP
 142 CacheFileInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure,
 143                                    uint32_t aCount, uint32_t* _retval) {
 144   CacheFileAutoLock lock(mFile);
 145
 146   LOG(("CacheFileInputStream::ReadSegments() [this=%p, count=%d]", this,
 147        aCount));
 148
 149   nsresult rv = NS_OK;
 150
 151   *_retval = 0;
 152
 153   if (mInReadSegments) {
 154     LOG(
 155         ("CacheFileInputStream::ReadSegments() - Cannot be called while the "
 156          "stream is in ReadSegments!"));
 157     return NS_ERROR_UNEXPECTED;
 158   }
 159
 160   if (mClosed) {
 161     LOG(
 162         ("CacheFileInputStream::ReadSegments() - Stream is closed. [this=%p, "
 163          "status=0x%08" PRIx32 "]",
 164          this, static_cast<uint32_t>(mStatus)));
 165
 166     if (NS_FAILED(mStatus)) {
 167       return mStatus;
 168     }
 169
 170     return NS_OK;
 171   }
 172
 173   if (aCount == 0) {
 174     return NS_OK;
 175   }
 176
 177   EnsureCorrectChunk(false);
 178
 179   while (true) {
 180     if (NS_FAILED(mStatus)) return mStatus;
 181
 182     if (!mChunk) {
 183       if (mListeningForChunk == -1) {
 184         return NS_OK;
 185       }
 186       return NS_BASE_STREAM_WOULD_BLOCK;
 187     }
 188
 189     CacheFileChunkReadHandle hnd = mChunk->GetReadHandle();
 190     int64_t canRead = CanRead(&hnd);
 191     if (NS_FAILED(mStatus)) {
 192       return mStatus;
 193     }
 194
 195     if (canRead < 0) {
 196       // file was truncated ???
 197       MOZ_ASSERT(false, "SetEOF is currenty not implemented?!");
 198       rv = NS_OK;
 199     } else if (canRead > 0) {
 200       uint32_t toRead = std::min(static_cast<uint32_t>(canRead), aCount);
 201       uint32_t read;
 202       const char* buf = hnd.Buf() + (mPos - hnd.Offset());
 203
 204       mInReadSegments = true;
 205       lock.Unlock();
 206
 207       rv = aWriter(this, aClosure, buf, *_retval, toRead, &read);
 208
 209       lock.Lock();
 210       mInReadSegments = false;
 211
 212       if (NS_SUCCEEDED(rv)) {
 213         MOZ_ASSERT(read <= toRead,
 214                    "writer should not write more than we asked it to write");
 215
 216         *_retval += read;
 217         mPos += read;
 218         aCount -= read;
 219
 220         if (!mClosed) {
 221           // The last chunk is released after the caller closes this stream.
 222           EnsureCorrectChunk(false);
 223
 224           if (mChunk && aCount) {
 225             // Check whether there is more data available to read.
 226             continue;
 227           }
 228         }
 229       }
 230
 231       if (mClosed) {
 232         // The stream was closed from aWriter, do the cleanup.
 233         CleanUp();
 234       }
 235
 236       rv = NS_OK;
 237     } else {
 238       if (*_retval == 0 && mFile->OutputStreamExists(mAlternativeData)) {
 239         rv = NS_BASE_STREAM_WOULD_BLOCK;
 240       } else {
 241         rv = NS_OK;
 242       }
 243     }
 244
 245     break;
 246   }
 247
 248   LOG(("CacheFileInputStream::ReadSegments() [this=%p, rv=0x%08" PRIx32
 249        ", retval=%d]",
 250        this, static_cast<uint32_t>(rv), *_retval));
 251
 252   return rv;
 253 }
 254
 255 NS_IMETHODIMP
 256 CacheFileInputStream::IsNonBlocking(bool* _retval) {
 257   *_retval = true;
 258   return NS_OK;
 259 }
 260
 261 // nsIAsyncInputStream
 262 NS_IMETHODIMP
 263 CacheFileInputStream::CloseWithStatus(nsresult aStatus) {
 264   CacheFileAutoLock lock(mFile);
 265
 266   LOG(("CacheFileInputStream::CloseWithStatus() [this=%p, aStatus=0x%08" PRIx32
 267        "]",
 268        this, static_cast<uint32_t>(aStatus)));
 269
 270   CloseWithStatusLocked(aStatus);
 271   return NS_OK;
 272 }
 273
 274 void CacheFileInputStream::CloseWithStatusLocked(nsresult aStatus) {
 275   LOG(
 276       ("CacheFileInputStream::CloseWithStatusLocked() [this=%p, "
 277        "aStatus=0x%08" PRIx32 "]",
 278        this, static_cast<uint32_t>(aStatus)));
 279
 280   if (mClosed) {
 281     // We notify listener and null out mCallback immediately after closing
 282     // the stream. If we're in ReadSegments we postpone notification until we
 283     // step out from ReadSegments. So if the stream is already closed the
 284     // following assertion must be true.
 285     MOZ_ASSERT(!mCallback || mInReadSegments);
 286     return;
 287   }
 288
 289   mClosed = true;
 290   mStatus = NS_FAILED(aStatus) ? aStatus : NS_BASE_STREAM_CLOSED;
 291
 292   if (!mInReadSegments) {
 293     CleanUp();
 294   }
 295 }
 296
 297 void CacheFileInputStream::CleanUp() {
 298   MOZ_ASSERT(!mInReadSegments);
 299   MOZ_ASSERT(mClosed);
 300
 301   if (mChunk) {
 302     ReleaseChunk();
 303   }
 304
 305   // TODO propagate error from input stream to other streams ???
 306
 307   MaybeNotifyListener();
 308
 309   mFile->ReleaseOutsideLock(std::move(mCacheEntryHandle));
 310 }
 311
 312 NS_IMETHODIMP
 313 CacheFileInputStream::AsyncWait(nsIInputStreamCallback* aCallback,
 314                                 uint32_t aFlags, uint32_t aRequestedCount,
 315                                 nsIEventTarget* aEventTarget) {
 316   CacheFileAutoLock lock(mFile);
 317
 318   LOG(
 319       ("CacheFileInputStream::AsyncWait() [this=%p, callback=%p, flags=%d, "
 320        "requestedCount=%d, eventTarget=%p]",
 321        this, aCallback, aFlags, aRequestedCount, aEventTarget));
 322
 323   if (mInReadSegments) {
 324     LOG(
 325         ("CacheFileInputStream::AsyncWait() - Cannot be called while the stream"
 326          " is in ReadSegments!"));
 327     MOZ_ASSERT(false,
 328                "Unexpected call. If it's a valid usage implement it. "
 329                "Otherwise fix the caller.");
 330     return NS_ERROR_UNEXPECTED;
 331   }
 332
 333   mCallback = aCallback;
 334   mCallbackFlags = aFlags;
 335   mCallbackTarget = aEventTarget;
 336
 337   if (!mCallback) {
 338     if (mWaitingForUpdate) {
 339       mChunk->CancelWait(this);
 340       mWaitingForUpdate = false;
 341     }
 342     return NS_OK;
 343   }
 344
 345   if (mClosed) {
 346     NotifyListener();
 347     return NS_OK;
 348   }
 349
 350   EnsureCorrectChunk(false);
 351
 352   MaybeNotifyListener();
 353
 354   return NS_OK;
 355 }
 356
 357 // nsISeekableStream
 358 NS_IMETHODIMP
 359 CacheFileInputStream::Seek(int32_t whence, int64_t offset) {
 360   CacheFileAutoLock lock(mFile);
 361   mFile->AssertOwnsLock();  // For thread-safety analysis
 362
 363   LOG(("CacheFileInputStream::Seek() [this=%p, whence=%d, offset=%" PRId64 "]",
 364        this, whence, offset));
 365
 366   if (mInReadSegments) {
 367     LOG(
 368         ("CacheFileInputStream::Seek() - Cannot be called while the stream is "
 369          "in ReadSegments!"));
 370     return NS_ERROR_UNEXPECTED;
 371   }
 372
 373   if (mClosed) {
 374     LOG(("CacheFileInputStream::Seek() - Stream is closed. [this=%p]", this));
 375     return NS_BASE_STREAM_CLOSED;
 376   }
 377
 378   int64_t newPos = offset;
 379   switch (whence) {
 380     case NS_SEEK_SET:
 381       if (mAlternativeData) {
 382         newPos += mFile->mAltDataOffset;
 383       }
 384       break;
 385     case NS_SEEK_CUR:
 386       newPos += mPos;
 387       break;
 388     case NS_SEEK_END:
 389       if (mAlternativeData) {
 390         newPos += mFile->mDataSize;
 391       } else {
 392         newPos += mFile->mAltDataOffset;
 393       }
 394       break;
 395     default:
 396       NS_ERROR("invalid whence");
 397       return NS_ERROR_INVALID_ARG;
 398   }
 399   mPos = newPos;
 400   EnsureCorrectChunk(false);
 401
 402   LOG(("CacheFileInputStream::Seek() [this=%p, pos=%" PRId64 "]", this, mPos));
 403   return NS_OK;
 404 }
 405
 406 NS_IMETHODIMP
 407 CacheFileInputStream::SetEOF() {
 408   MOZ_ASSERT(false, "Don't call SetEOF on cache input stream");
 409   return NS_ERROR_NOT_IMPLEMENTED;
 410 }
 411
 412 // nsITellableStream
 413 NS_IMETHODIMP
 414 CacheFileInputStream::Tell(int64_t* _retval) {
 415   CacheFileAutoLock lock(mFile);
 416   mFile->AssertOwnsLock();  // For thread-safety analysis
 417
 418   if (mClosed) {
 419     LOG(("CacheFileInputStream::Tell() - Stream is closed. [this=%p]", this));
 420     return NS_BASE_STREAM_CLOSED;
 421   }
 422
 423   *_retval = mPos;
 424
 425   if (mAlternativeData) {
 426     *_retval -= mFile->mAltDataOffset;
 427   }
 428
 429   LOG(("CacheFileInputStream::Tell() [this=%p, retval=%" PRId64 "]", this,
 430        *_retval));
 431   return NS_OK;
 432 }
 433
 434 // CacheFileChunkListener
 435 nsresult CacheFileInputStream::OnChunkRead(nsresult aResult,
 436                                            CacheFileChunk* aChunk) {
 437   MOZ_CRASH("CacheFileInputStream::OnChunkRead should not be called!");
 438   return NS_ERROR_UNEXPECTED;
 439 }
 440
 441 nsresult CacheFileInputStream::OnChunkWritten(nsresult aResult,
 442                                               CacheFileChunk* aChunk) {
 443   MOZ_CRASH("CacheFileInputStream::OnChunkWritten should not be called!");
 444   return NS_ERROR_UNEXPECTED;
 445 }
 446
 447 nsresult CacheFileInputStream::OnChunkAvailable(nsresult aResult,
 448                                                 uint32_t aChunkIdx,
 449                                                 CacheFileChunk* aChunk) {
 450   CacheFileAutoLock lock(mFile);
 451
 452   LOG(("CacheFileInputStream::OnChunkAvailable() [this=%p, result=0x%08" PRIx32
 453        ", "
 454        "idx=%d, chunk=%p]",
 455        this, static_cast<uint32_t>(aResult), aChunkIdx, aChunk));
 456
 457   MOZ_ASSERT(mListeningForChunk != -1);
 458
 459   if (mListeningForChunk != static_cast<int64_t>(aChunkIdx)) {
 460     // This is not a chunk that we're waiting for
 461     LOG(
 462         ("CacheFileInputStream::OnChunkAvailable() - Notification is for a "
 463          "different chunk. [this=%p, listeningForChunk=%" PRId64 "]",
 464          this, mListeningForChunk));
 465
 466     return NS_OK;
 467   }
 468
 469   MOZ_ASSERT(!mChunk);
 470   MOZ_ASSERT(!mWaitingForUpdate);
 471   MOZ_ASSERT(!mInReadSegments);
 472   mListeningForChunk = -1;
 473
 474   if (mClosed) {
 475     MOZ_ASSERT(!mCallback);
 476
 477     LOG(
 478         ("CacheFileInputStream::OnChunkAvailable() - Stream is closed, "
 479          "ignoring notification. [this=%p]",
 480          this));
 481
 482     return NS_OK;
 483   }
 484
 485   if (NS_SUCCEEDED(aResult)) {
 486     mChunk = aChunk;
 487   } else if (aResult != NS_ERROR_NOT_AVAILABLE) {
 488     // Close the stream with error. The consumer will receive this error later
 489     // in Read(), Available() etc. We need to handle NS_ERROR_NOT_AVAILABLE
 490     // differently since it is returned when the requested chunk is not
 491     // available and there is no writer that could create it, i.e. it means that
 492     // we've reached the end of the file.
 493     CloseWithStatusLocked(aResult);
 494
 495     return NS_OK;
 496   }
 497
 498   MaybeNotifyListener();
 499
 500   return NS_OK;
 501 }
 502
 503 nsresult CacheFileInputStream::OnChunkUpdated(CacheFileChunk* aChunk) {
 504   CacheFileAutoLock lock(mFile);
 505
 506   LOG(("CacheFileInputStream::OnChunkUpdated() [this=%p, idx=%d]", this,
 507        aChunk->Index()));
 508
 509   if (!mWaitingForUpdate) {
 510     LOG(
 511         ("CacheFileInputStream::OnChunkUpdated() - Ignoring notification since "
 512          "mWaitingforUpdate == false. [this=%p]",
 513          this));
 514
 515     return NS_OK;
 516   }
 517
 518   mWaitingForUpdate = false;
 519
 520   MOZ_ASSERT(mChunk == aChunk);
 521
 522   MaybeNotifyListener();
 523
 524   return NS_OK;
 525 }
 526
 527 void CacheFileInputStream::ReleaseChunk() {
 528   mFile->AssertOwnsLock();
 529
 530   LOG(("CacheFileInputStream::ReleaseChunk() [this=%p, idx=%d]", this,
 531        mChunk->Index()));
 532
 533   MOZ_ASSERT(!mInReadSegments);
 534
 535   if (mWaitingForUpdate) {
 536     LOG(
 537         ("CacheFileInputStream::ReleaseChunk() - Canceling waiting for update. "
 538          "[this=%p]",
 539          this));
 540
 541     mChunk->CancelWait(this);
 542     mWaitingForUpdate = false;
 543   }
 544
 545   mFile->ReleaseOutsideLock(std::move(mChunk));
 546 }
 547
 548 void CacheFileInputStream::EnsureCorrectChunk(bool aReleaseOnly) {
 549   mFile->AssertOwnsLock();
 550
 551   LOG(("CacheFileInputStream::EnsureCorrectChunk() [this=%p, releaseOnly=%d]",
 552        this, aReleaseOnly));
 553
 554   nsresult rv;
 555
 556   uint32_t chunkIdx = mPos / kChunkSize;
 557
 558   if (mInReadSegments) {
 559     // We must have correct chunk
 560     MOZ_ASSERT(mChunk);
 561     MOZ_ASSERT(mChunk->Index() == chunkIdx);
 562     return;
 563   }
 564
 565   if (mChunk) {
 566     if (mChunk->Index() == chunkIdx) {
 567       // we have a correct chunk
 568       LOG(
 569           ("CacheFileInputStream::EnsureCorrectChunk() - Have correct chunk "
 570            "[this=%p, idx=%d]",
 571            this, chunkIdx));
 572
 573       return;
 574     }
 575     ReleaseChunk();
 576   }
 577
 578   MOZ_ASSERT(!mWaitingForUpdate);
 579
 580   if (aReleaseOnly) return;
 581
 582   if (mListeningForChunk == static_cast<int64_t>(chunkIdx)) {
 583     // We're already waiting for this chunk
 584     LOG(
 585         ("CacheFileInputStream::EnsureCorrectChunk() - Already listening for "
 586          "chunk %" PRId64 " [this=%p]",
 587          mListeningForChunk, this));
 588
 589     return;
 590   }
 591
 592   rv = mFile->GetChunkLocked(chunkIdx, CacheFile::READER, this,
 593                              getter_AddRefs(mChunk));
 594   if (NS_FAILED(rv)) {
 595     LOG(
 596         ("CacheFileInputStream::EnsureCorrectChunk() - GetChunkLocked failed. "
 597          "[this=%p, idx=%d, rv=0x%08" PRIx32 "]",
 598          this, chunkIdx, static_cast<uint32_t>(rv)));
 599     if (rv != NS_ERROR_NOT_AVAILABLE) {
 600       // Close the stream with error. The consumer will receive this error later
 601       // in Read(), Available() etc. We need to handle NS_ERROR_NOT_AVAILABLE
 602       // differently since it is returned when the requested chunk is not
 603       // available and there is no writer that could create it, i.e. it means
 604       // that we've reached the end of the file.
 605       CloseWithStatusLocked(rv);
 606
 607       return;
 608     }
 609   } else if (!mChunk) {
 610     mListeningForChunk = static_cast<int64_t>(chunkIdx);
 611   }
 612
 613   MaybeNotifyListener();
 614 }
 615
 616 int64_t CacheFileInputStream::CanRead(CacheFileChunkReadHandle* aHandle) {
 617   mFile->AssertOwnsLock();
 618
 619   MOZ_ASSERT(mChunk);
 620   MOZ_ASSERT(mPos / kChunkSize == mChunk->Index());
 621
 622   int64_t retval = aHandle->Offset() + aHandle->DataSize();
 623
 624   if (!mAlternativeData && mFile->mAltDataOffset != -1 &&
 625       mFile->mAltDataOffset < retval) {
 626     retval = mFile->mAltDataOffset;
 627   }
 628
 629   retval -= mPos;
 630   if (retval <= 0 && NS_FAILED(mChunk->GetStatus())) {
 631     CloseWithStatusLocked(mChunk->GetStatus());
 632   }
 633
 634   LOG(("CacheFileInputStream::CanRead() [this=%p, canRead=%" PRId64 "]", this,
 635        retval));
 636
 637   return retval;
 638 }
 639
 640 void CacheFileInputStream::NotifyListener() {
 641   mFile->AssertOwnsLock();
 642
 643   LOG(("CacheFileInputStream::NotifyListener() [this=%p]", this));
 644
 645   MOZ_ASSERT(mCallback);
 646   MOZ_ASSERT(!mInReadSegments);
 647
 648   if (!mCallbackTarget) {
 649     mCallbackTarget = CacheFileIOManager::IOTarget();
 650     if (!mCallbackTarget) {
 651       LOG(
 652           ("CacheFileInputStream::NotifyListener() - Cannot get Cache I/O "
 653            "thread! Using main thread for callback."));
 654       mCallbackTarget = GetMainThreadSerialEventTarget();
 655     }
 656   }
 657
 658   nsCOMPtr<nsIInputStreamCallback> asyncCallback = NS_NewInputStreamReadyEvent(
 659       "CacheFileInputStream::NotifyListener", mCallback, mCallbackTarget);
 660
 661   mCallback = nullptr;
 662   mCallbackTarget = nullptr;
 663
 664   asyncCallback->OnInputStreamReady(this);
 665 }
 666
 667 void CacheFileInputStream::MaybeNotifyListener() {
 668   mFile->AssertOwnsLock();
 669
 670   LOG(
 671       ("CacheFileInputStream::MaybeNotifyListener() [this=%p, mCallback=%p, "
 672        "mClosed=%d, mStatus=0x%08" PRIx32
 673        ", mChunk=%p, mListeningForChunk=%" PRId64 ", "
 674        "mWaitingForUpdate=%d]",
 675        this, mCallback.get(), mClosed, static_cast<uint32_t>(mStatus),
 676        mChunk.get(), mListeningForChunk, mWaitingForUpdate));
 677
 678   MOZ_ASSERT(!mInReadSegments);
 679
 680   if (!mCallback) return;
 681
 682   if (mClosed || NS_FAILED(mStatus)) {
 683     NotifyListener();
 684     return;
 685   }
 686
 687   if (!mChunk) {
 688     if (mListeningForChunk == -1) {
 689       // EOF, should we notify even if mCallbackFlags == WAIT_CLOSURE_ONLY ??
 690       NotifyListener();
 691     }
 692     return;
 693   }
 694
 695   MOZ_ASSERT(mPos / kChunkSize == mChunk->Index());
 696
 697   if (mWaitingForUpdate) return;
 698
 699   CacheFileChunkReadHandle hnd = mChunk->GetReadHandle();
 700   int64_t canRead = CanRead(&hnd);
 701   if (NS_FAILED(mStatus)) {
 702     // CanRead() called CloseWithStatusLocked() which called
 703     // MaybeNotifyListener() so the listener was already notified. Stop here.
 704     MOZ_ASSERT(!mCallback);
 705     return;
 706   }
 707
 708   if (canRead > 0) {
 709     if (!(mCallbackFlags & WAIT_CLOSURE_ONLY)) NotifyListener();
 710   } else if (canRead == 0) {
 711     if (!mFile->OutputStreamExists(mAlternativeData)) {
 712       // EOF
 713       NotifyListener();
 714     } else {
 715       mChunk->WaitForUpdate(this);
 716       mWaitingForUpdate = true;
 717     }
 718   } else {
 719     // Output have set EOF before mPos?
 720     MOZ_ASSERT(false, "SetEOF is currenty not implemented?!");
 721     NotifyListener();
 722   }
 723 }
 724
 725 // Memory reporting
 726
 727 size_t CacheFileInputStream::SizeOfIncludingThis(
 728     mozilla::MallocSizeOf mallocSizeOf) const {
 729   // Everything the stream keeps a reference to is already reported somewhere
 730   // else. mFile reports itself. mChunk reported as part of CacheFile. mCallback
 731   // is usually CacheFile or a class that is reported elsewhere.
 732   return mallocSizeOf(this);
 733 }
 734
 735 }  // namespace mozilla::net