uriloader/preload/gtest/TestFetchPreloader.cpp

   1 #include "gtest/gtest.h"
   2
   3 #include "mozilla/CORSMode.h"
   4 #include "mozilla/dom/XMLDocument.h"
   5 #include "mozilla/dom/ReferrerPolicyBinding.h"
   6 #include "mozilla/FetchPreloader.h"
   7 #include "mozilla/gtest/MozAssertions.h"
   8 #include "mozilla/Maybe.h"
   9 #include "mozilla/PreloadHashKey.h"
  10 #include "mozilla/SpinEventLoopUntil.h"
  11 #include "nsNetUtil.h"
  12 #include "nsIChannel.h"
  13 #include "nsIStreamListener.h"
  14 #include "nsISupportsPriority.h"
  15 #include "nsThreadUtils.h"
  16 #include "nsStringStream.h"
  17
  18 namespace {
  19
  20 auto const ERROR_CANCEL = NS_ERROR_ABORT;
  21 auto const ERROR_ONSTOP = NS_ERROR_NET_INTERRUPT;
  22 auto const ERROR_THROW = NS_ERROR_FAILURE;
  23
  24 class FakeChannel : public nsIChannel {
  25  public:
  26   NS_DECL_ISUPPORTS
  27   NS_DECL_NSICHANNEL
  28   NS_DECL_NSIREQUEST
  29
  30   nsresult Start() { return mListener->OnStartRequest(this); }
  31   nsresult Data(const nsACString& aData) {
  32     if (NS_FAILED(mStatus)) {
  33       return mStatus;
  34     }
  35     nsCOMPtr<nsIInputStream> is;
  36     NS_NewCStringInputStream(getter_AddRefs(is), aData);
  37     return mListener->OnDataAvailable(this, is, 0, aData.Length());
  38   }
  39   nsresult Stop(nsresult status) {
  40     if (NS_SUCCEEDED(mStatus)) {
  41       mStatus = status;
  42     }
  43     mListener->OnStopRequest(this, mStatus);
  44     mListener = nullptr;
  45     return mStatus;
  46   }
  47
  48  private:
  49   virtual ~FakeChannel() = default;
  50   bool mIsPending = false;
  51   bool mCanceled = false;
  52   nsresult mStatus = NS_OK;
  53   nsCOMPtr<nsIStreamListener> mListener;
  54 };
  55
  56 NS_IMPL_ISUPPORTS(FakeChannel, nsIChannel, nsIRequest)
  57
  58 NS_IMETHODIMP FakeChannel::GetName(nsACString& result) { return NS_OK; }
  59 NS_IMETHODIMP FakeChannel::IsPending(bool* result) {
  60   *result = mIsPending;
  61   return NS_OK;
  62 }
  63 NS_IMETHODIMP FakeChannel::GetStatus(nsresult* status) {
  64   *status = mStatus;
  65   return NS_OK;
  66 }
  67 NS_IMETHODIMP FakeChannel::SetCanceledReason(const nsACString& aReason) {
  68   return SetCanceledReasonImpl(aReason);
  69 }
  70 NS_IMETHODIMP FakeChannel::GetCanceledReason(nsACString& aReason) {
  71   return GetCanceledReasonImpl(aReason);
  72 }
  73 NS_IMETHODIMP FakeChannel::CancelWithReason(nsresult aStatus,
  74                                             const nsACString& aReason) {
  75   return CancelWithReasonImpl(aStatus, aReason);
  76 }
  77 NS_IMETHODIMP FakeChannel::Cancel(nsresult status) {
  78   if (!mCanceled) {
  79     mCanceled = true;
  80     mStatus = status;
  81   }
  82   return NS_OK;
  83 }
  84 NS_IMETHODIMP FakeChannel::Suspend() { return NS_OK; }
  85 NS_IMETHODIMP FakeChannel::Resume() { return NS_OK; }
  86 NS_IMETHODIMP FakeChannel::GetLoadFlags(nsLoadFlags* aLoadFlags) {
  87   *aLoadFlags = 0;
  88   return NS_OK;
  89 }
  90 NS_IMETHODIMP FakeChannel::SetLoadFlags(nsLoadFlags aLoadFlags) {
  91   return NS_OK;
  92 }
  93 NS_IMETHODIMP FakeChannel::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
  94   return NS_ERROR_NOT_IMPLEMENTED;
  95 }
  96 NS_IMETHODIMP FakeChannel::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
  97   return NS_ERROR_NOT_IMPLEMENTED;
  98 }
  99 NS_IMETHODIMP FakeChannel::GetLoadGroup(nsILoadGroup** aLoadGroup) {
 100   return NS_OK;
 101 }
 102 NS_IMETHODIMP FakeChannel::SetLoadGroup(nsILoadGroup* aLoadGroup) {
 103   return NS_OK;
 104 }
 105 NS_IMETHODIMP FakeChannel::GetOriginalURI(nsIURI** aURI) { return NS_OK; }
 106 NS_IMETHODIMP FakeChannel::SetOriginalURI(nsIURI* aURI) { return NS_OK; }
 107 NS_IMETHODIMP FakeChannel::GetURI(nsIURI** aURI) { return NS_OK; }
 108 NS_IMETHODIMP FakeChannel::GetOwner(nsISupports** aOwner) { return NS_OK; }
 109 NS_IMETHODIMP FakeChannel::SetOwner(nsISupports* aOwner) { return NS_OK; }
 110 NS_IMETHODIMP FakeChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) { return NS_OK; }
 111 NS_IMETHODIMP FakeChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) {
 112   return NS_OK;
 113 }
 114 NS_IMETHODIMP FakeChannel::GetIsDocument(bool* aIsDocument) {
 115   *aIsDocument = false;
 116   return NS_OK;
 117 }
 118 NS_IMETHODIMP FakeChannel::GetNotificationCallbacks(
 119     nsIInterfaceRequestor** aCallbacks) {
 120   return NS_OK;
 121 }
 122 NS_IMETHODIMP FakeChannel::SetNotificationCallbacks(
 123     nsIInterfaceRequestor* aCallbacks) {
 124   return NS_OK;
 125 }
 126 NS_IMETHODIMP FakeChannel::GetSecurityInfo(
 127     nsITransportSecurityInfo** aSecurityInfo) {
 128   return NS_OK;
 129 }
 130 NS_IMETHODIMP FakeChannel::GetContentType(nsACString& aContentType) {
 131   return NS_OK;
 132 }
 133 NS_IMETHODIMP FakeChannel::SetContentType(const nsACString& aContentType) {
 134   return NS_OK;
 135 }
 136 NS_IMETHODIMP FakeChannel::GetContentCharset(nsACString& aContentCharset) {
 137   return NS_OK;
 138 }
 139 NS_IMETHODIMP FakeChannel::SetContentCharset(
 140     const nsACString& aContentCharset) {
 141   return NS_OK;
 142 }
 143 NS_IMETHODIMP FakeChannel::GetContentDisposition(
 144     uint32_t* aContentDisposition) {
 145   return NS_OK;
 146 }
 147 NS_IMETHODIMP FakeChannel::SetContentDisposition(uint32_t aContentDisposition) {
 148   return NS_OK;
 149 }
 150 NS_IMETHODIMP FakeChannel::GetContentDispositionFilename(
 151     nsAString& aContentDispositionFilename) {
 152   return NS_OK;
 153 }
 154 NS_IMETHODIMP FakeChannel::SetContentDispositionFilename(
 155     const nsAString& aContentDispositionFilename) {
 156   return NS_OK;
 157 }
 158 NS_IMETHODIMP FakeChannel::GetContentDispositionHeader(
 159     nsACString& aContentDispositionHeader) {
 160   return NS_ERROR_NOT_AVAILABLE;
 161 }
 162 NS_IMETHODIMP FakeChannel::GetContentLength(int64_t* aContentLength) {
 163   return NS_OK;
 164 }
 165 NS_IMETHODIMP FakeChannel::SetContentLength(int64_t aContentLength) {
 166   return NS_OK;
 167 }
 168 NS_IMETHODIMP FakeChannel::GetCanceled(bool* aCanceled) {
 169   *aCanceled = mCanceled;
 170   return NS_OK;
 171 }
 172 NS_IMETHODIMP FakeChannel::Open(nsIInputStream** aStream) {
 173   return NS_ERROR_NOT_IMPLEMENTED;
 174 }
 175 NS_IMETHODIMP
 176 FakeChannel::AsyncOpen(nsIStreamListener* aListener) {
 177   mIsPending = true;
 178   mListener = aListener;
 179   return NS_OK;
 180 }
 181
 182 class FakePreloader : public mozilla::FetchPreloader {
 183  public:
 184   explicit FakePreloader(FakeChannel* aChannel) : mDrivingChannel(aChannel) {}
 185
 186  private:
 187   RefPtr<FakeChannel> mDrivingChannel;
 188
 189   virtual nsresult CreateChannel(
 190       nsIChannel** aChannel, nsIURI* aURI, const mozilla::CORSMode aCORSMode,
 191       const mozilla::dom::ReferrerPolicy& aReferrerPolicy,
 192       mozilla::dom::Document* aDocument, nsILoadGroup* aLoadGroup,
 193       nsIInterfaceRequestor* aCallbacks, uint64_t aHttpChannelId,
 194       int32_t aSupportsPriorityValue) override {
 195     mDrivingChannel.forget(aChannel);
 196     return NS_OK;
 197   }
 198 };
 199
 200 class FakeListener : public nsIStreamListener {
 201   NS_DECL_ISUPPORTS
 202   NS_DECL_NSIREQUESTOBSERVER
 203   NS_DECL_NSISTREAMLISTENER
 204
 205   enum { Never, OnStart, OnData, OnStop } mCancelIn = Never;
 206
 207   nsresult mOnStartResult = NS_OK;
 208   nsresult mOnDataResult = NS_OK;
 209   nsresult mOnStopResult = NS_OK;
 210
 211   bool mOnStart = false;
 212   nsCString mOnData;
 213   mozilla::Maybe<nsresult> mOnStop;
 214
 215  private:
 216   virtual ~FakeListener() = default;
 217 };
 218
 219 NS_IMPL_ISUPPORTS(FakeListener, nsIStreamListener, nsIRequestObserver)
 220
 221 NS_IMETHODIMP FakeListener::OnStartRequest(nsIRequest* request) {
 222   EXPECT_FALSE(mOnStart);
 223   mOnStart = true;
 224
 225   if (mCancelIn == OnStart) {
 226     request->Cancel(ERROR_CANCEL);
 227   }
 228
 229   return mOnStartResult;
 230 }
 231 NS_IMETHODIMP FakeListener::OnDataAvailable(nsIRequest* request,
 232                                             nsIInputStream* input,
 233                                             uint64_t offset, uint32_t count) {
 234   nsAutoCString data;
 235   data.SetLength(count);
 236
 237   uint32_t read;
 238   input->Read(data.BeginWriting(), count, &read);
 239   mOnData += data;
 240
 241   if (mCancelIn == OnData) {
 242     request->Cancel(ERROR_CANCEL);
 243   }
 244
 245   return mOnDataResult;
 246 }
 247 NS_IMETHODIMP FakeListener::OnStopRequest(nsIRequest* request,
 248                                           nsresult status) {
 249   EXPECT_FALSE(mOnStop);
 250   mOnStop.emplace(status);
 251
 252   if (mCancelIn == OnStop) {
 253     request->Cancel(ERROR_CANCEL);
 254   }
 255
 256   return mOnStopResult;
 257 }
 258
 259 bool eventInProgress = true;
 260
 261 void Await() {
 262   MOZ_ALWAYS_TRUE(mozilla::SpinEventLoopUntil(
 263       "uriloader:TestFetchPreloader:Await"_ns, [&]() {
 264         bool yield = !eventInProgress;
 265         eventInProgress = true;  // Just for convenience
 266         return yield;
 267       }));
 268 }
 269
 270 // WinBase.h defines this.
 271 #undef Yield
 272 void Yield() { eventInProgress = false; }
 273
 274 }  // namespace
 275
 276 // ****************************************************************************
 277 // Test body
 278 // ****************************************************************************
 279
 280 // Caching with all good results (data + NS_OK)
 281 TEST(TestFetchPreloader, CacheNoneBeforeConsume)
 282 {
 283   nsCOMPtr<nsIURI> uri;
 284   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 285   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 286
 287   RefPtr<FakeChannel> channel = new FakeChannel();
 288   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 289   RefPtr<mozilla::dom::Document> doc;
 290   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 291
 292   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 293       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 294       0, nsISupportsPriority::PRIORITY_NORMAL)));
 295
 296   RefPtr<FakeListener> listener = new FakeListener();
 297   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 298   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 299
 300   EXPECT_NS_SUCCEEDED(channel->Start());
 301   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 302   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 303   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 304   EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 305
 306   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 307     EXPECT_TRUE(listener->mOnStart);
 308     EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
 309     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
 310
 311     Yield();
 312   }));
 313
 314   Await();
 315
 316   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 317 }
 318
 319 TEST(TestFetchPreloader, CacheStartBeforeConsume)
 320 {
 321   nsCOMPtr<nsIURI> uri;
 322   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 323   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 324
 325   RefPtr<FakeChannel> channel = new FakeChannel();
 326   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 327   RefPtr<mozilla::dom::Document> doc;
 328   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 329
 330   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 331       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 332       0, nsISupportsPriority::PRIORITY_NORMAL)));
 333
 334   EXPECT_NS_SUCCEEDED(channel->Start());
 335
 336   RefPtr<FakeListener> listener = new FakeListener();
 337   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 338   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 339
 340   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 341     EXPECT_TRUE(listener->mOnStart);
 342
 343     EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 344     EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 345     EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 346     EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
 347
 348     EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 349     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
 350
 351     Yield();
 352   }));
 353
 354   Await();
 355
 356   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 357 }
 358
 359 TEST(TestFetchPreloader, CachePartOfDataBeforeConsume)
 360 {
 361   nsCOMPtr<nsIURI> uri;
 362   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 363   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 364
 365   RefPtr<FakeChannel> channel = new FakeChannel();
 366   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 367   RefPtr<mozilla::dom::Document> doc;
 368   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 369
 370   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 371       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 372       0, nsISupportsPriority::PRIORITY_NORMAL)));
 373
 374   EXPECT_NS_SUCCEEDED(channel->Start());
 375   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 376   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 377
 378   RefPtr<FakeListener> listener = new FakeListener();
 379   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 380   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 381
 382   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 383     EXPECT_TRUE(listener->mOnStart);
 384
 385     EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 386     EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
 387
 388     EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 389     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
 390
 391     Yield();
 392   }));
 393
 394   Await();
 395
 396   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 397 }
 398
 399 TEST(TestFetchPreloader, CacheAllDataBeforeConsume)
 400 {
 401   nsCOMPtr<nsIURI> uri;
 402   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 403   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 404
 405   RefPtr<FakeChannel> channel = new FakeChannel();
 406   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 407   RefPtr<mozilla::dom::Document> doc;
 408   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 409
 410   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 411       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 412       0, nsISupportsPriority::PRIORITY_NORMAL)));
 413
 414   EXPECT_NS_SUCCEEDED(channel->Start());
 415   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 416   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 417   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 418
 419   // Request consumation of the preload...
 420   RefPtr<FakeListener> listener = new FakeListener();
 421   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 422   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 423
 424   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 425     EXPECT_TRUE(listener->mOnStart);
 426     EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
 427
 428     EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 429     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
 430
 431     Yield();
 432   }));
 433
 434   Await();
 435
 436   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 437 }
 438
 439 TEST(TestFetchPreloader, CacheAllBeforeConsume)
 440 {
 441   nsCOMPtr<nsIURI> uri;
 442   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 443   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 444
 445   RefPtr<FakeChannel> channel = new FakeChannel();
 446   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 447   RefPtr<mozilla::dom::Document> doc;
 448   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 449
 450   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 451       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 452       0, nsISupportsPriority::PRIORITY_NORMAL)));
 453
 454   EXPECT_NS_SUCCEEDED(channel->Start());
 455   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 456   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 457   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 458   EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 459
 460   RefPtr<FakeListener> listener = new FakeListener();
 461   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 462   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 463
 464   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 465     EXPECT_TRUE(listener->mOnStart);
 466     EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
 467     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
 468
 469     Yield();
 470   }));
 471
 472   Await();
 473
 474   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 475 }
 476
 477 // Get data before the channel fails
 478 TEST(TestFetchPreloader, CacheAllBeforeConsumeWithChannelError)
 479 {
 480   nsCOMPtr<nsIURI> uri;
 481   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 482   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 483
 484   RefPtr<FakeChannel> channel = new FakeChannel();
 485   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 486   RefPtr<mozilla::dom::Document> doc;
 487   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 488
 489   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 490       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 491       0, nsISupportsPriority::PRIORITY_NORMAL)));
 492
 493   EXPECT_NS_SUCCEEDED(channel->Start());
 494   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 495   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 496   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 497   EXPECT_NS_FAILED(channel->Stop(ERROR_ONSTOP));
 498
 499   RefPtr<FakeListener> listener = new FakeListener();
 500   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 501   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 502
 503   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 504     EXPECT_TRUE(listener->mOnStart);
 505     EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
 506     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_ONSTOP);
 507
 508     Yield();
 509   }));
 510
 511   Await();
 512
 513   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 514 }
 515
 516 // Cancel the channel between caching and consuming
 517 TEST(TestFetchPreloader, CacheAllBeforeConsumeWithChannelCancel)
 518 {
 519   nsCOMPtr<nsIURI> uri;
 520   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 521   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 522
 523   RefPtr<FakeChannel> channel = new FakeChannel();
 524   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 525   RefPtr<mozilla::dom::Document> doc;
 526   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 527
 528   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 529       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 530       0, nsISupportsPriority::PRIORITY_NORMAL)));
 531
 532   EXPECT_NS_SUCCEEDED(channel->Start());
 533   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 534   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 535   channel->Cancel(ERROR_CANCEL);
 536   EXPECT_NS_FAILED(channel->Stop(ERROR_CANCEL));
 537
 538   RefPtr<FakeListener> listener = new FakeListener();
 539   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 540   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 541
 542   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 543     EXPECT_TRUE(listener->mOnStart);
 544     // XXX - This is hard to solve; the data is there but we won't deliver it.
 545     // This is a bit different case than e.g. a network error.  We want to
 546     // deliver some data in that case.  Cancellation probably happens because of
 547     // navigation or a demand to not consume the channel anyway.
 548     EXPECT_TRUE(listener->mOnData.IsEmpty());
 549     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_CANCEL);
 550
 551     Yield();
 552   }));
 553
 554   Await();
 555
 556   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 557 }
 558
 559 // Let the listener throw while data is already cached
 560 TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnStartRequest)
 561 {
 562   nsCOMPtr<nsIURI> uri;
 563   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 564   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 565
 566   RefPtr<FakeChannel> channel = new FakeChannel();
 567   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 568   RefPtr<mozilla::dom::Document> doc;
 569   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 570
 571   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 572       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 573       0, nsISupportsPriority::PRIORITY_NORMAL)));
 574
 575   EXPECT_NS_SUCCEEDED(channel->Start());
 576   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 577   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 578   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 579   EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 580
 581   RefPtr<FakeListener> listener = new FakeListener();
 582   listener->mOnStartResult = ERROR_THROW;
 583
 584   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 585   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 586
 587   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 588     EXPECT_TRUE(listener->mOnStart);
 589     EXPECT_TRUE(listener->mOnData.IsEmpty());
 590     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_THROW);
 591
 592     Yield();
 593   }));
 594
 595   Await();
 596
 597   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 598 }
 599
 600 TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnDataAvailable)
 601 {
 602   nsCOMPtr<nsIURI> uri;
 603   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 604   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 605
 606   RefPtr<FakeChannel> channel = new FakeChannel();
 607   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 608   RefPtr<mozilla::dom::Document> doc;
 609   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 610
 611   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 612       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 613       0, nsISupportsPriority::PRIORITY_NORMAL)));
 614
 615   EXPECT_NS_SUCCEEDED(channel->Start());
 616   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 617   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 618   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 619   EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 620
 621   RefPtr<FakeListener> listener = new FakeListener();
 622   listener->mOnDataResult = ERROR_THROW;
 623
 624   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 625   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 626
 627   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 628     EXPECT_TRUE(listener->mOnStart);
 629     EXPECT_TRUE(listener->mOnData.EqualsLiteral("one"));
 630     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_THROW);
 631
 632     Yield();
 633   }));
 634
 635   Await();
 636
 637   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 638 }
 639
 640 TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnStopRequest)
 641 {
 642   nsCOMPtr<nsIURI> uri;
 643   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 644   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 645
 646   RefPtr<FakeChannel> channel = new FakeChannel();
 647   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 648   RefPtr<mozilla::dom::Document> doc;
 649   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 650
 651   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 652       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 653       0, nsISupportsPriority::PRIORITY_NORMAL)));
 654
 655   EXPECT_NS_SUCCEEDED(channel->Start());
 656   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 657   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 658   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 659   EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 660
 661   RefPtr<FakeListener> listener = new FakeListener();
 662   listener->mOnStopResult = ERROR_THROW;
 663
 664   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 665   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 666
 667   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 668     EXPECT_TRUE(listener->mOnStart);
 669     EXPECT_TRUE(listener->mOnData.EqualsLiteral("onetwothree"));
 670     // Throwing from OnStopRequest is generally ignored.
 671     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == NS_OK);
 672
 673     Yield();
 674   }));
 675
 676   Await();
 677
 678   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 679 }
 680
 681 // Cancel the channel in various callbacks
 682 TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnStartRequest)
 683 {
 684   nsCOMPtr<nsIURI> uri;
 685   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 686   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 687
 688   RefPtr<FakeChannel> channel = new FakeChannel();
 689   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 690   RefPtr<mozilla::dom::Document> doc;
 691   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 692
 693   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 694       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 695       0, nsISupportsPriority::PRIORITY_NORMAL)));
 696
 697   EXPECT_NS_SUCCEEDED(channel->Start());
 698   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 699   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 700   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 701   EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 702
 703   RefPtr<FakeListener> listener = new FakeListener();
 704   listener->mCancelIn = FakeListener::OnStart;
 705   // check that throwing from OnStartRequest doesn't affect the cancellation
 706   // status.
 707   listener->mOnStartResult = ERROR_THROW;
 708
 709   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 710   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 711
 712   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 713     EXPECT_TRUE(listener->mOnStart);
 714     EXPECT_TRUE(listener->mOnData.IsEmpty());
 715     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_CANCEL);
 716
 717     Yield();
 718   }));
 719
 720   Await();
 721
 722   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 723 }
 724
 725 TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnDataAvailable)
 726 {
 727   nsCOMPtr<nsIURI> uri;
 728   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 729   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 730
 731   RefPtr<FakeChannel> channel = new FakeChannel();
 732   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 733   RefPtr<mozilla::dom::Document> doc;
 734   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 735
 736   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 737       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 738       0, nsISupportsPriority::PRIORITY_NORMAL)));
 739
 740   EXPECT_NS_SUCCEEDED(channel->Start());
 741   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 742   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 743   EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 744   EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 745
 746   RefPtr<FakeListener> listener = new FakeListener();
 747   listener->mCancelIn = FakeListener::OnData;
 748   // check that throwing from OnStartRequest doesn't affect the cancellation
 749   // status.
 750   listener->mOnDataResult = ERROR_THROW;
 751
 752   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 753   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 754
 755   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 756     EXPECT_TRUE(listener->mOnStart);
 757     EXPECT_TRUE(listener->mOnData.EqualsLiteral("one"));
 758     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_CANCEL);
 759
 760     Yield();
 761   }));
 762
 763   Await();
 764
 765   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 766 }
 767
 768 // Corner cases
 769 TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnDataAvailable)
 770 {
 771   nsCOMPtr<nsIURI> uri;
 772   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 773   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 774
 775   RefPtr<FakeChannel> channel = new FakeChannel();
 776   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 777   RefPtr<mozilla::dom::Document> doc;
 778   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 779
 780   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 781       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 782       0, nsISupportsPriority::PRIORITY_NORMAL)));
 783
 784   EXPECT_NS_SUCCEEDED(channel->Start());
 785   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 786   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 787
 788   RefPtr<FakeListener> listener = new FakeListener();
 789   listener->mCancelIn = FakeListener::OnData;
 790
 791   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 792   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 793
 794   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 795     EXPECT_NS_FAILED(channel->Data("three"_ns));
 796     EXPECT_NS_FAILED(channel->Stop(NS_OK));
 797
 798     EXPECT_TRUE(listener->mOnStart);
 799     EXPECT_TRUE(listener->mOnData.EqualsLiteral("one"));
 800     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_CANCEL);
 801
 802     Yield();
 803   }));
 804
 805   Await();
 806
 807   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 808 }
 809
 810 TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnStartRequestAndRace)
 811 {
 812   nsCOMPtr<nsIURI> uri;
 813   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 814   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 815
 816   RefPtr<FakeChannel> channel = new FakeChannel();
 817   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 818   RefPtr<mozilla::dom::Document> doc;
 819   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 820
 821   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 822       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 823       0, nsISupportsPriority::PRIORITY_NORMAL)));
 824
 825   EXPECT_NS_SUCCEEDED(channel->Start());
 826   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 827   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 828
 829   // This has to simulate a possibiilty when stream listener notifications from
 830   // the channel are already pending in the queue while AsyncConsume is called.
 831   // At this moment the listener has not been notified yet.
 832   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 833     EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 834     EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 835   }));
 836
 837   RefPtr<FakeListener> listener = new FakeListener();
 838   listener->mCancelIn = FakeListener::OnStart;
 839
 840   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 841   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 842
 843   // Check listener's been fed properly.  Expected is to NOT get any data and
 844   // propagate the cancellation code and not being called duplicated
 845   // OnStopRequest.
 846   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 847     EXPECT_TRUE(listener->mOnStart);
 848     EXPECT_TRUE(listener->mOnData.IsEmpty());
 849     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_CANCEL);
 850
 851     Yield();
 852   }));
 853
 854   Await();
 855
 856   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 857 }
 858
 859 TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnDataAvailableAndRace)
 860 {
 861   nsCOMPtr<nsIURI> uri;
 862   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 863   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 864
 865   RefPtr<FakeChannel> channel = new FakeChannel();
 866   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 867   RefPtr<mozilla::dom::Document> doc;
 868   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 869
 870   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 871       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 872       0, nsISupportsPriority::PRIORITY_NORMAL)));
 873
 874   EXPECT_NS_SUCCEEDED(channel->Start());
 875   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 876   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 877
 878   // This has to simulate a possibiilty when stream listener notifications from
 879   // the channel are already pending in the queue while AsyncConsume is called.
 880   // At this moment the listener has not been notified yet.
 881   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 882     EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 883     EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 884   }));
 885
 886   RefPtr<FakeListener> listener = new FakeListener();
 887   listener->mCancelIn = FakeListener::OnData;
 888
 889   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 890   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 891
 892   // Check listener's been fed properly.  Expected is to NOT get anything after
 893   // the first OnData and propagate the cancellation code and not being called
 894   // duplicated OnStopRequest.
 895   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 896     EXPECT_TRUE(listener->mOnStart);
 897     EXPECT_TRUE(listener->mOnData.EqualsLiteral("one"));
 898     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_CANCEL);
 899
 900     Yield();
 901   }));
 902
 903   Await();
 904
 905   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 906 }
 907
 908 TEST(TestFetchPreloader, CachePartlyBeforeConsumeThrowFromOnStartRequestAndRace)
 909 {
 910   nsCOMPtr<nsIURI> uri;
 911   NS_NewURI(getter_AddRefs(uri), "https://example.com"_ns);
 912   auto key = mozilla::PreloadHashKey::CreateAsFetch(uri, mozilla::CORS_NONE);
 913
 914   RefPtr<FakeChannel> channel = new FakeChannel();
 915   RefPtr<FakePreloader> preloader = new FakePreloader(channel);
 916   RefPtr<mozilla::dom::Document> doc;
 917   NS_NewXMLDocument(getter_AddRefs(doc), nullptr, nullptr);
 918
 919   EXPECT_TRUE(NS_SUCCEEDED(preloader->OpenChannel(
 920       key, uri, mozilla::CORS_NONE, mozilla::dom::ReferrerPolicy::_empty, doc,
 921       0, nsISupportsPriority::PRIORITY_NORMAL)));
 922
 923   EXPECT_NS_SUCCEEDED(channel->Start());
 924   EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
 925   EXPECT_NS_SUCCEEDED(channel->Data("two"_ns));
 926
 927   // This has to simulate a possibiilty when stream listener notifications from
 928   // the channel are already pending in the queue while AsyncConsume is called.
 929   // At this moment the listener has not been notified yet.
 930   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 931     EXPECT_NS_SUCCEEDED(channel->Data("three"_ns));
 932     EXPECT_NS_SUCCEEDED(channel->Stop(NS_OK));
 933   }));
 934
 935   RefPtr<FakeListener> listener = new FakeListener();
 936   listener->mOnStartResult = ERROR_THROW;
 937
 938   EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
 939   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 940
 941   // Check listener's been fed properly.  Expected is to NOT get any data and
 942   // propagate the throwing code and not being called duplicated OnStopRequest.
 943   NS_DispatchToMainThread(NS_NewRunnableFunction("test", [&]() {
 944     EXPECT_TRUE(listener->mOnStart);
 945     EXPECT_TRUE(listener->mOnData.IsEmpty());
 946     EXPECT_TRUE(listener->mOnStop && *listener->mOnStop == ERROR_THROW);
 947
 948     Yield();
 949   }));
 950
 951   Await();
 952
 953   EXPECT_FALSE(NS_SUCCEEDED(preloader->AsyncConsume(listener)));
 954 }