uriloader/prefetch/nsPrefetchService.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 "nsPrefetchService.h"
   6 #include "nsICacheEntry.h"
   7 #include "nsIServiceManager.h"
   8 #include "nsICategoryManager.h"
   9 #include "nsIObserverService.h"
  10 #include "nsIWebProgress.h"
  11 #include "nsCURILoader.h"
  12 #include "nsICachingChannel.h"
  13 #include "nsIHttpChannel.h"
  14 #include "nsIURL.h"
  15 #include "nsISimpleEnumerator.h"
  16 #include "nsNetUtil.h"
  17 #include "nsString.h"
  18 #include "nsXPIDLString.h"
  19 #include "nsReadableUtils.h"
  20 #include "nsStreamUtils.h"
  21 #include "nsAutoPtr.h"
  22 #include "prtime.h"
  23 #include "prlog.h"
  24 #include "plstr.h"
  25 #include "nsIAsyncVerifyRedirectCallback.h"
  26 #include "mozilla/Preferences.h"
  27 #include "mozilla/Attributes.h"
  28 #include "nsIDOMNode.h"
  29 #include "nsINode.h"
  30 #include "nsIDocument.h"
  31 #include "nsContentUtils.h"
  32
  33 using namespace mozilla;
  34
  35 #if defined(PR_LOGGING)
  36 //
  37 // To enable logging (see prlog.h for full details):
  38 //
  39 //    set NSPR_LOG_MODULES=nsPrefetch:5
  40 //    set NSPR_LOG_FILE=prefetch.log
  41 //
  42 // this enables PR_LOG_ALWAYS level information and places all output in
  43 // the file http.log
  44 //
  45 static PRLogModuleInfo *gPrefetchLog;
  46 #endif
  47
  48 #undef LOG
  49 #define LOG(args) PR_LOG(gPrefetchLog, 4, args)
  50
  51 #undef LOG_ENABLED
  52 #define LOG_ENABLED() PR_LOG_TEST(gPrefetchLog, 4)
  53
  54 #define PREFETCH_PREF "network.prefetch-next"
  55
  56 //-----------------------------------------------------------------------------
  57 // helpers
  58 //-----------------------------------------------------------------------------
  59
  60 static inline uint32_t
  61 PRTimeToSeconds(PRTime t_usec)
  62 {
  63     PRTime usec_per_sec = PR_USEC_PER_SEC;
  64     return uint32_t(t_usec /= usec_per_sec);
  65 }
  66
  67 #define NowInSeconds() PRTimeToSeconds(PR_Now())
  68
  69 //-----------------------------------------------------------------------------
  70 // nsPrefetchQueueEnumerator
  71 //-----------------------------------------------------------------------------
  72 class nsPrefetchQueueEnumerator MOZ_FINAL : public nsISimpleEnumerator
  73 {
  74 public:
  75     NS_DECL_ISUPPORTS
  76     NS_DECL_NSISIMPLEENUMERATOR
  77     explicit nsPrefetchQueueEnumerator(nsPrefetchService *aService);
  78
  79 private:
  80     ~nsPrefetchQueueEnumerator();
  81
  82     void Increment();
  83
  84     nsRefPtr<nsPrefetchService> mService;
  85     nsRefPtr<nsPrefetchNode> mCurrent;
  86     bool mStarted;
  87 };
  88
  89 //-----------------------------------------------------------------------------
  90 // nsPrefetchQueueEnumerator <public>
  91 //-----------------------------------------------------------------------------
  92 nsPrefetchQueueEnumerator::nsPrefetchQueueEnumerator(nsPrefetchService *aService)
  93     : mService(aService)
  94     , mStarted(false)
  95 {
  96     Increment();
  97 }
  98
  99 nsPrefetchQueueEnumerator::~nsPrefetchQueueEnumerator()
 100 {
 101 }
 102
 103 //-----------------------------------------------------------------------------
 104 // nsPrefetchQueueEnumerator::nsISimpleEnumerator
 105 //-----------------------------------------------------------------------------
 106 NS_IMETHODIMP
 107 nsPrefetchQueueEnumerator::HasMoreElements(bool *aHasMore)
 108 {
 109     *aHasMore = (mCurrent != nullptr);
 110     return NS_OK;
 111 }
 112
 113 NS_IMETHODIMP
 114 nsPrefetchQueueEnumerator::GetNext(nsISupports **aItem)
 115 {
 116     if (!mCurrent) return NS_ERROR_FAILURE;
 117
 118     NS_ADDREF(*aItem = static_cast<nsIStreamListener*>(mCurrent.get()));
 119
 120     Increment();
 121
 122     return NS_OK;
 123 }
 124
 125 //-----------------------------------------------------------------------------
 126 // nsPrefetchQueueEnumerator <private>
 127 //-----------------------------------------------------------------------------
 128
 129 void
 130 nsPrefetchQueueEnumerator::Increment()
 131 {
 132   if (!mStarted) {
 133     // If the service is currently serving a request, it won't be in
 134     // the pending queue, so we return it first.  If it isn't, we'll
 135     // just start with the pending queue.
 136     mStarted = true;
 137     mCurrent = mService->GetCurrentNode();
 138     if (!mCurrent)
 139       mCurrent = mService->GetQueueHead();
 140     return;
 141   }
 142
 143   if (mCurrent) {
 144     if (mCurrent == mService->GetCurrentNode()) {
 145       // If we just returned the node being processed by the service,
 146       // start with the pending queue
 147       mCurrent = mService->GetQueueHead();
 148     }
 149     else {
 150       // Otherwise just advance to the next item in the queue
 151       mCurrent = mCurrent->mNext;
 152     }
 153   }
 154 }
 155
 156 //-----------------------------------------------------------------------------
 157 // nsPrefetchQueueEnumerator::nsISupports
 158 //-----------------------------------------------------------------------------
 159
 160 NS_IMPL_ISUPPORTS(nsPrefetchQueueEnumerator, nsISimpleEnumerator)
 161
 162 //-----------------------------------------------------------------------------
 163 // nsPrefetchNode <public>
 164 //-----------------------------------------------------------------------------
 165
 166 nsPrefetchNode::nsPrefetchNode(nsPrefetchService *aService,
 167                                nsIURI *aURI,
 168                                nsIURI *aReferrerURI,
 169                                nsIDOMNode *aSource)
 170     : mNext(nullptr)
 171     , mURI(aURI)
 172     , mReferrerURI(aReferrerURI)
 173     , mService(aService)
 174     , mChannel(nullptr)
 175     , mBytesRead(0)
 176 {
 177     mSource = do_GetWeakReference(aSource);
 178 }
 179
 180 nsresult
 181 nsPrefetchNode::OpenChannel()
 182 {
 183     nsCOMPtr<nsINode> source = do_QueryReferent(mSource);
 184     if (!source) {
 185         // Don't attempt to prefetch if we don't have a source node
 186         // (which should never happen).
 187         return NS_ERROR_FAILURE;
 188     }
 189     nsCOMPtr<nsILoadGroup> loadGroup = source->OwnerDoc()->GetDocumentLoadGroup();
 190     nsresult rv = NS_NewChannel(getter_AddRefs(mChannel),
 191                                 mURI,
 192                                 nsContentUtils::GetSystemPrincipal(),
 193                                 nsILoadInfo::SEC_NORMAL,
 194                                 nsIContentPolicy::TYPE_OTHER,
 195                                 loadGroup, // aLoadGroup
 196                                 this,      // aCallbacks
 197                                 nsIRequest::LOAD_BACKGROUND |
 198                                 nsICachingChannel::LOAD_ONLY_IF_MODIFIED);
 199
 200     NS_ENSURE_SUCCESS(rv, rv);
 201
 202     // configure HTTP specific stuff
 203     nsCOMPtr<nsIHttpChannel> httpChannel =
 204         do_QueryInterface(mChannel);
 205     if (httpChannel) {
 206         httpChannel->SetReferrer(mReferrerURI);
 207         httpChannel->SetRequestHeader(
 208             NS_LITERAL_CSTRING("X-Moz"),
 209             NS_LITERAL_CSTRING("prefetch"),
 210             false);
 211     }
 212
 213     rv = mChannel->AsyncOpen(this, nullptr);
 214     NS_ENSURE_SUCCESS(rv, rv);
 215
 216     return NS_OK;
 217 }
 218
 219 nsresult
 220 nsPrefetchNode::CancelChannel(nsresult error)
 221 {
 222     mChannel->Cancel(error);
 223     mChannel = nullptr;
 224
 225     return NS_OK;
 226 }
 227
 228 //-----------------------------------------------------------------------------
 229 // nsPrefetchNode::nsISupports
 230 //-----------------------------------------------------------------------------
 231
 232 NS_IMPL_ISUPPORTS(nsPrefetchNode,
 233                   nsIRequestObserver,
 234                   nsIStreamListener,
 235                   nsIInterfaceRequestor,
 236                   nsIChannelEventSink,
 237                   nsIRedirectResultListener)
 238
 239 //-----------------------------------------------------------------------------
 240 // nsPrefetchNode::nsIStreamListener
 241 //-----------------------------------------------------------------------------
 242
 243 NS_IMETHODIMP
 244 nsPrefetchNode::OnStartRequest(nsIRequest *aRequest,
 245                                nsISupports *aContext)
 246 {
 247     nsresult rv;
 248
 249     nsCOMPtr<nsICachingChannel> cachingChannel =
 250         do_QueryInterface(aRequest, &rv);
 251     if (NS_FAILED(rv)) return rv;
 252
 253     // no need to prefetch a document that is already in the cache
 254     bool fromCache;
 255     if (NS_SUCCEEDED(cachingChannel->IsFromCache(&fromCache)) &&
 256         fromCache) {
 257         LOG(("document is already in the cache; canceling prefetch\n"));
 258         return NS_BINDING_ABORTED;
 259     }
 260
 261     //
 262     // no need to prefetch a document that must be requested fresh each
 263     // and every time.
 264     //
 265     nsCOMPtr<nsISupports> cacheToken;
 266     cachingChannel->GetCacheToken(getter_AddRefs(cacheToken));
 267     if (!cacheToken)
 268         return NS_ERROR_ABORT; // bail, no cache entry
 269
 270     nsCOMPtr<nsICacheEntry> entryInfo =
 271         do_QueryInterface(cacheToken, &rv);
 272     if (NS_FAILED(rv)) return rv;
 273
 274     uint32_t expTime;
 275     if (NS_SUCCEEDED(entryInfo->GetExpirationTime(&expTime))) {
 276         if (NowInSeconds() >= expTime) {
 277             LOG(("document cannot be reused from cache; "
 278                  "canceling prefetch\n"));
 279             return NS_BINDING_ABORTED;
 280         }
 281     }
 282
 283     return NS_OK;
 284 }
 285
 286 NS_IMETHODIMP
 287 nsPrefetchNode::OnDataAvailable(nsIRequest *aRequest,
 288                                 nsISupports *aContext,
 289                                 nsIInputStream *aStream,
 290                                 uint64_t aOffset,
 291                                 uint32_t aCount)
 292 {
 293     uint32_t bytesRead = 0;
 294     aStream->ReadSegments(NS_DiscardSegment, nullptr, aCount, &bytesRead);
 295     mBytesRead += bytesRead;
 296     LOG(("prefetched %u bytes [offset=%llu]\n", bytesRead, aOffset));
 297     return NS_OK;
 298 }
 299
 300
 301 NS_IMETHODIMP
 302 nsPrefetchNode::OnStopRequest(nsIRequest *aRequest,
 303                               nsISupports *aContext,
 304                               nsresult aStatus)
 305 {
 306     LOG(("done prefetching [status=%x]\n", aStatus));
 307
 308     if (mBytesRead == 0 && aStatus == NS_OK) {
 309         // we didn't need to read (because LOAD_ONLY_IF_MODIFIED was
 310         // specified), but the object should report loadedSize as if it
 311         // did.
 312         mChannel->GetContentLength(&mBytesRead);
 313     }
 314
 315     mService->NotifyLoadCompleted(this);
 316     mService->ProcessNextURI();
 317     return NS_OK;
 318 }
 319
 320 //-----------------------------------------------------------------------------
 321 // nsPrefetchNode::nsIInterfaceRequestor
 322 //-----------------------------------------------------------------------------
 323
 324 NS_IMETHODIMP
 325 nsPrefetchNode::GetInterface(const nsIID &aIID, void **aResult)
 326 {
 327     if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
 328         NS_ADDREF_THIS();
 329         *aResult = static_cast<nsIChannelEventSink *>(this);
 330         return NS_OK;
 331     }
 332
 333     if (aIID.Equals(NS_GET_IID(nsIRedirectResultListener))) {
 334         NS_ADDREF_THIS();
 335         *aResult = static_cast<nsIRedirectResultListener *>(this);
 336         return NS_OK;
 337     }
 338
 339     return NS_ERROR_NO_INTERFACE;
 340 }
 341
 342 //-----------------------------------------------------------------------------
 343 // nsPrefetchNode::nsIChannelEventSink
 344 //-----------------------------------------------------------------------------
 345
 346 NS_IMETHODIMP
 347 nsPrefetchNode::AsyncOnChannelRedirect(nsIChannel *aOldChannel,
 348                                        nsIChannel *aNewChannel,
 349                                        uint32_t aFlags,
 350                                        nsIAsyncVerifyRedirectCallback *callback)
 351 {
 352     nsCOMPtr<nsIURI> newURI;
 353     nsresult rv = aNewChannel->GetURI(getter_AddRefs(newURI));
 354     if (NS_FAILED(rv))
 355         return rv;
 356
 357     bool match;
 358     rv = newURI->SchemeIs("http", &match);
 359     if (NS_FAILED(rv) || !match) {
 360         rv = newURI->SchemeIs("https", &match);
 361         if (NS_FAILED(rv) || !match) {
 362             LOG(("rejected: URL is not of type http/https\n"));
 363             return NS_ERROR_ABORT;
 364         }
 365     }
 366
 367     // HTTP request headers are not automatically forwarded to the new channel.
 368     nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aNewChannel);
 369     NS_ENSURE_STATE(httpChannel);
 370
 371     httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("X-Moz"),
 372                                   NS_LITERAL_CSTRING("prefetch"),
 373                                   false);
 374
 375     // Assign to mChannel after we get notification about success of the
 376     // redirect in OnRedirectResult.
 377     mRedirectChannel = aNewChannel;
 378
 379     callback->OnRedirectVerifyCallback(NS_OK);
 380     return NS_OK;
 381 }
 382
 383 //-----------------------------------------------------------------------------
 384 // nsPrefetchNode::nsIRedirectResultListener
 385 //-----------------------------------------------------------------------------
 386
 387 NS_IMETHODIMP
 388 nsPrefetchNode::OnRedirectResult(bool proceeding)
 389 {
 390     if (proceeding && mRedirectChannel)
 391         mChannel = mRedirectChannel;
 392
 393     mRedirectChannel = nullptr;
 394
 395     return NS_OK;
 396 }
 397
 398 //-----------------------------------------------------------------------------
 399 // nsPrefetchService <public>
 400 //-----------------------------------------------------------------------------
 401
 402 nsPrefetchService::nsPrefetchService()
 403     : mQueueHead(nullptr)
 404     , mQueueTail(nullptr)
 405     , mStopCount(0)
 406     , mHaveProcessed(false)
 407     , mDisabled(true)
 408 {
 409 }
 410
 411 nsPrefetchService::~nsPrefetchService()
 412 {
 413     Preferences::RemoveObserver(this, PREFETCH_PREF);
 414     // cannot reach destructor if prefetch in progress (listener owns reference
 415     // to this service)
 416     EmptyQueue();
 417 }
 418
 419 nsresult
 420 nsPrefetchService::Init()
 421 {
 422 #if defined(PR_LOGGING)
 423     if (!gPrefetchLog)
 424         gPrefetchLog = PR_NewLogModule("nsPrefetch");
 425 #endif
 426
 427     nsresult rv;
 428
 429     // read prefs and hook up pref observer
 430     mDisabled = !Preferences::GetBool(PREFETCH_PREF, !mDisabled);
 431     Preferences::AddWeakObserver(this, PREFETCH_PREF);
 432
 433     // Observe xpcom-shutdown event
 434     nsCOMPtr<nsIObserverService> observerService =
 435       mozilla::services::GetObserverService();
 436     if (!observerService)
 437       return NS_ERROR_FAILURE;
 438
 439     rv = observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
 440     NS_ENSURE_SUCCESS(rv, rv);
 441
 442     if (!mDisabled)
 443         AddProgressListener();
 444
 445     return NS_OK;
 446 }
 447
 448 void
 449 nsPrefetchService::ProcessNextURI()
 450 {
 451     nsresult rv;
 452     nsCOMPtr<nsIURI> uri, referrer;
 453
 454     mCurrentNode = nullptr;
 455
 456     do {
 457         rv = DequeueNode(getter_AddRefs(mCurrentNode));
 458
 459         if (NS_FAILED(rv)) break;
 460
 461 #if defined(PR_LOGGING)
 462         if (LOG_ENABLED()) {
 463             nsAutoCString spec;
 464             mCurrentNode->mURI->GetSpec(spec);
 465             LOG(("ProcessNextURI [%s]\n", spec.get()));
 466         }
 467 #endif
 468
 469         //
 470         // if opening the channel fails, then just skip to the next uri
 471         //
 472         nsRefPtr<nsPrefetchNode> node = mCurrentNode;
 473         rv = node->OpenChannel();
 474     }
 475     while (NS_FAILED(rv));
 476 }
 477
 478 void
 479 nsPrefetchService::NotifyLoadRequested(nsPrefetchNode *node)
 480 {
 481     nsCOMPtr<nsIObserverService> observerService =
 482       mozilla::services::GetObserverService();
 483     if (!observerService)
 484       return;
 485
 486     observerService->NotifyObservers(static_cast<nsIStreamListener*>(node),
 487                                      "prefetch-load-requested", nullptr);
 488 }
 489
 490 void
 491 nsPrefetchService::NotifyLoadCompleted(nsPrefetchNode *node)
 492 {
 493     nsCOMPtr<nsIObserverService> observerService =
 494       mozilla::services::GetObserverService();
 495     if (!observerService)
 496       return;
 497
 498     observerService->NotifyObservers(static_cast<nsIStreamListener*>(node),
 499                                      "prefetch-load-completed", nullptr);
 500 }
 501
 502 //-----------------------------------------------------------------------------
 503 // nsPrefetchService <private>
 504 //-----------------------------------------------------------------------------
 505
 506 void
 507 nsPrefetchService::AddProgressListener()
 508 {
 509     // Register as an observer for the document loader
 510     nsCOMPtr<nsIWebProgress> progress =
 511         do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID);
 512     if (progress)
 513         progress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_DOCUMENT);
 514 }
 515
 516 void
 517 nsPrefetchService::RemoveProgressListener()
 518 {
 519     // Register as an observer for the document loader
 520     nsCOMPtr<nsIWebProgress> progress =
 521         do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID);
 522     if (progress)
 523         progress->RemoveProgressListener(this);
 524 }
 525
 526 nsresult
 527 nsPrefetchService::EnqueueNode(nsPrefetchNode *aNode)
 528 {
 529     NS_ADDREF(aNode);
 530
 531     if (!mQueueTail) {
 532         mQueueHead = aNode;
 533         mQueueTail = aNode;
 534     }
 535     else {
 536         mQueueTail->mNext = aNode;
 537         mQueueTail = aNode;
 538     }
 539
 540     return NS_OK;
 541 }
 542
 543 nsresult
 544 nsPrefetchService::EnqueueURI(nsIURI *aURI,
 545                               nsIURI *aReferrerURI,
 546                               nsIDOMNode *aSource,
 547                               nsPrefetchNode **aNode)
 548 {
 549     nsPrefetchNode *node = new nsPrefetchNode(this, aURI, aReferrerURI,
 550                                               aSource);
 551     if (!node)
 552         return NS_ERROR_OUT_OF_MEMORY;
 553
 554     NS_ADDREF(*aNode = node);
 555
 556     return EnqueueNode(node);
 557 }
 558
 559 nsresult
 560 nsPrefetchService::DequeueNode(nsPrefetchNode **node)
 561 {
 562     if (!mQueueHead)
 563         return NS_ERROR_NOT_AVAILABLE;
 564
 565     // give the ref to the caller
 566     *node = mQueueHead;
 567     mQueueHead = mQueueHead->mNext;
 568     (*node)->mNext = nullptr;
 569
 570     if (!mQueueHead)
 571         mQueueTail = nullptr;
 572
 573     return NS_OK;
 574 }
 575
 576 void
 577 nsPrefetchService::EmptyQueue()
 578 {
 579     do {
 580         nsRefPtr<nsPrefetchNode> node;
 581         DequeueNode(getter_AddRefs(node));
 582     } while (mQueueHead);
 583 }
 584
 585 void
 586 nsPrefetchService::StartPrefetching()
 587 {
 588     //
 589     // at initialization time we might miss the first DOCUMENT START
 590     // notification, so we have to be careful to avoid letting our
 591     // stop count go negative.
 592     //
 593     if (mStopCount > 0)
 594         mStopCount--;
 595
 596     LOG(("StartPrefetching [stopcount=%d]\n", mStopCount));
 597
 598     // only start prefetching after we've received enough DOCUMENT
 599     // STOP notifications.  we do this inorder to defer prefetching
 600     // until after all sub-frames have finished loading.
 601     if (mStopCount == 0 && !mCurrentNode) {
 602         mHaveProcessed = true;
 603         ProcessNextURI();
 604     }
 605 }
 606
 607 void
 608 nsPrefetchService::StopPrefetching()
 609 {
 610     mStopCount++;
 611
 612     LOG(("StopPrefetching [stopcount=%d]\n", mStopCount));
 613
 614     // only kill the prefetch queue if we've actually started prefetching.
 615     if (!mCurrentNode)
 616         return;
 617
 618     mCurrentNode->CancelChannel(NS_BINDING_ABORTED);
 619     mCurrentNode = nullptr;
 620     EmptyQueue();
 621 }
 622
 623 //-----------------------------------------------------------------------------
 624 // nsPrefetchService::nsISupports
 625 //-----------------------------------------------------------------------------
 626
 627 NS_IMPL_ISUPPORTS(nsPrefetchService,
 628                   nsIPrefetchService,
 629                   nsIWebProgressListener,
 630                   nsIObserver,
 631                   nsISupportsWeakReference)
 632
 633 //-----------------------------------------------------------------------------
 634 // nsPrefetchService::nsIPrefetchService
 635 //-----------------------------------------------------------------------------
 636
 637 nsresult
 638 nsPrefetchService::Prefetch(nsIURI *aURI,
 639                             nsIURI *aReferrerURI,
 640                             nsIDOMNode *aSource,
 641                             bool aExplicit)
 642 {
 643     nsresult rv;
 644
 645     NS_ENSURE_ARG_POINTER(aURI);
 646     NS_ENSURE_ARG_POINTER(aReferrerURI);
 647
 648 #if defined(PR_LOGGING)
 649     if (LOG_ENABLED()) {
 650         nsAutoCString spec;
 651         aURI->GetSpec(spec);
 652         LOG(("PrefetchURI [%s]\n", spec.get()));
 653     }
 654 #endif
 655
 656     if (mDisabled) {
 657         LOG(("rejected: prefetch service is disabled\n"));
 658         return NS_ERROR_ABORT;
 659     }
 660
 661     //
 662     // XXX we should really be asking the protocol handler if it supports
 663     // caching, so we can determine if there is any value to prefetching.
 664     // for now, we'll only prefetch http links since we know that's the
 665     // most common case.  ignore https links since https content only goes
 666     // into the memory cache.
 667     //
 668     // XXX we might want to either leverage nsIProtocolHandler::protocolFlags
 669     // or possibly nsIRequest::loadFlags to determine if this URI should be
 670     // prefetched.
 671     //
 672     bool match;
 673     rv = aURI->SchemeIs("http", &match);
 674     if (NS_FAILED(rv) || !match) {
 675         rv = aURI->SchemeIs("https", &match);
 676         if (NS_FAILED(rv) || !match) {
 677             LOG(("rejected: URL is not of type http/https\n"));
 678             return NS_ERROR_ABORT;
 679         }
 680     }
 681
 682     //
 683     // the referrer URI must be http:
 684     //
 685     rv = aReferrerURI->SchemeIs("http", &match);
 686     if (NS_FAILED(rv) || !match) {
 687         rv = aReferrerURI->SchemeIs("https", &match);
 688         if (NS_FAILED(rv) || !match) {
 689             LOG(("rejected: referrer URL is neither http nor https\n"));
 690             return NS_ERROR_ABORT;
 691         }
 692     }
 693
 694     // skip URLs that contain query strings, except URLs for which prefetching
 695     // has been explicitly requested.
 696     if (!aExplicit) {
 697         nsCOMPtr<nsIURL> url(do_QueryInterface(aURI, &rv));
 698         if (NS_FAILED(rv)) return rv;
 699         nsAutoCString query;
 700         rv = url->GetQuery(query);
 701         if (NS_FAILED(rv) || !query.IsEmpty()) {
 702             LOG(("rejected: URL has a query string\n"));
 703             return NS_ERROR_ABORT;
 704         }
 705     }
 706
 707     //
 708     // cancel if being prefetched
 709     //
 710     if (mCurrentNode) {
 711         bool equals;
 712         if (NS_SUCCEEDED(mCurrentNode->mURI->Equals(aURI, &equals)) && equals) {
 713             LOG(("rejected: URL is already being prefetched\n"));
 714             return NS_ERROR_ABORT;
 715         }
 716     }
 717
 718     //
 719     // cancel if already on the prefetch queue
 720     //
 721     nsPrefetchNode *node = mQueueHead;
 722     for (; node; node = node->mNext) {
 723         bool equals;
 724         if (NS_SUCCEEDED(node->mURI->Equals(aURI, &equals)) && equals) {
 725             LOG(("rejected: URL is already on prefetch queue\n"));
 726             return NS_ERROR_ABORT;
 727         }
 728     }
 729
 730     nsRefPtr<nsPrefetchNode> enqueuedNode;
 731     rv = EnqueueURI(aURI, aReferrerURI, aSource,
 732                     getter_AddRefs(enqueuedNode));
 733     NS_ENSURE_SUCCESS(rv, rv);
 734
 735     NotifyLoadRequested(enqueuedNode);
 736
 737     // if there are no pages loading, kick off the request immediately
 738     if (mStopCount == 0 && mHaveProcessed)
 739         ProcessNextURI();
 740
 741     return NS_OK;
 742 }
 743
 744 NS_IMETHODIMP
 745 nsPrefetchService::PrefetchURI(nsIURI *aURI,
 746                                nsIURI *aReferrerURI,
 747                                nsIDOMNode *aSource,
 748                                bool aExplicit)
 749 {
 750     return Prefetch(aURI, aReferrerURI, aSource, aExplicit);
 751 }
 752
 753 NS_IMETHODIMP
 754 nsPrefetchService::EnumerateQueue(nsISimpleEnumerator **aEnumerator)
 755 {
 756     *aEnumerator = new nsPrefetchQueueEnumerator(this);
 757     if (!*aEnumerator) return NS_ERROR_OUT_OF_MEMORY;
 758
 759     NS_ADDREF(*aEnumerator);
 760
 761     return NS_OK;
 762 }
 763
 764 //-----------------------------------------------------------------------------
 765 // nsPrefetchService::nsIWebProgressListener
 766 //-----------------------------------------------------------------------------
 767
 768 NS_IMETHODIMP
 769 nsPrefetchService::OnProgressChange(nsIWebProgress *aProgress,
 770                                   nsIRequest *aRequest,
 771                                   int32_t curSelfProgress,
 772                                   int32_t maxSelfProgress,
 773                                   int32_t curTotalProgress,
 774                                   int32_t maxTotalProgress)
 775 {
 776     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 777     return NS_OK;
 778 }
 779
 780 NS_IMETHODIMP
 781 nsPrefetchService::OnStateChange(nsIWebProgress* aWebProgress,
 782                                  nsIRequest *aRequest,
 783                                  uint32_t progressStateFlags,
 784                                  nsresult aStatus)
 785 {
 786     if (progressStateFlags & STATE_IS_DOCUMENT) {
 787         if (progressStateFlags & STATE_STOP)
 788             StartPrefetching();
 789         else if (progressStateFlags & STATE_START)
 790             StopPrefetching();
 791     }
 792
 793     return NS_OK;
 794 }
 795
 796
 797 NS_IMETHODIMP
 798 nsPrefetchService::OnLocationChange(nsIWebProgress* aWebProgress,
 799                                     nsIRequest* aRequest,
 800                                     nsIURI *location,
 801                                     uint32_t aFlags)
 802 {
 803     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 804     return NS_OK;
 805 }
 806
 807 NS_IMETHODIMP
 808 nsPrefetchService::OnStatusChange(nsIWebProgress* aWebProgress,
 809                                   nsIRequest* aRequest,
 810                                   nsresult aStatus,
 811                                   const char16_t* aMessage)
 812 {
 813     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 814     return NS_OK;
 815 }
 816
 817 NS_IMETHODIMP
 818 nsPrefetchService::OnSecurityChange(nsIWebProgress *aWebProgress,
 819                                     nsIRequest *aRequest,
 820                                     uint32_t state)
 821 {
 822     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 823     return NS_OK;
 824 }
 825
 826 //-----------------------------------------------------------------------------
 827 // nsPrefetchService::nsIObserver
 828 //-----------------------------------------------------------------------------
 829
 830 NS_IMETHODIMP
 831 nsPrefetchService::Observe(nsISupports     *aSubject,
 832                            const char      *aTopic,
 833                            const char16_t *aData)
 834 {
 835     LOG(("nsPrefetchService::Observe [topic=%s]\n", aTopic));
 836
 837     if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
 838         StopPrefetching();
 839         EmptyQueue();
 840         mDisabled = true;
 841     }
 842     else if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
 843         if (Preferences::GetBool(PREFETCH_PREF, false)) {
 844             if (mDisabled) {
 845                 LOG(("enabling prefetching\n"));
 846                 mDisabled = false;
 847                 AddProgressListener();
 848             }
 849         }
 850         else {
 851             if (!mDisabled) {
 852                 LOG(("disabling prefetching\n"));
 853                 StopPrefetching();
 854                 EmptyQueue();
 855                 mDisabled = true;
 856                 RemoveProgressListener();
 857             }
 858         }
 859     }
 860
 861     return NS_OK;
 862 }
 863
 864 // vim: ts=4 sw=4 expandtab