uriloader/prefetch/nsPrefetchService.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is Mozilla.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Netscape Communications Corporation.
  18  * Portions created by the Initial Developer are Copyright (C) 2002
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *   Darin Fisher <darin@netscape.com> (original author)
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include "nsPrefetchService.h"
  39 #include "nsICacheSession.h"
  40 #include "nsICacheService.h"
  41 #include "nsIServiceManager.h"
  42 #include "nsICategoryManager.h"
  43 #include "nsIObserverService.h"
  44 #include "nsIPrefService.h"
  45 #include "nsIPrefBranch2.h"
  46 #include "nsIDocCharset.h"
  47 #include "nsIWebProgress.h"
  48 #include "nsCURILoader.h"
  49 #include "nsICachingChannel.h"
  50 #include "nsICacheVisitor.h"
  51 #include "nsIHttpChannel.h"
  52 #include "nsIURL.h"
  53 #include "nsISimpleEnumerator.h"
  54 #include "nsNetUtil.h"
  55 #include "nsString.h"
  56 #include "nsXPIDLString.h"
  57 #include "nsReadableUtils.h"
  58 #include "nsStreamUtils.h"
  59 #include "nsAutoPtr.h"
  60 #include "prtime.h"
  61 #include "prlog.h"
  62 #include "plstr.h"
  63
  64 #if defined(PR_LOGGING)
  65 //
  66 // To enable logging (see prlog.h for full details):
  67 //
  68 //    set NSPR_LOG_MODULES=nsPrefetch:5
  69 //    set NSPR_LOG_FILE=prefetch.log
  70 //
  71 // this enables PR_LOG_ALWAYS level information and places all output in
  72 // the file http.log
  73 //
  74 static PRLogModuleInfo *gPrefetchLog;
  75 #endif
  76 #define LOG(args) PR_LOG(gPrefetchLog, 4, args)
  77 #define LOG_ENABLED() PR_LOG_TEST(gPrefetchLog, 4)
  78
  79 #define PREFETCH_PREF "network.prefetch-next"
  80
  81 //-----------------------------------------------------------------------------
  82 // helpers
  83 //-----------------------------------------------------------------------------
  84
  85 static inline PRUint32
  86 PRTimeToSeconds(PRTime t_usec)
  87 {
  88     PRTime usec_per_sec;
  89     PRUint32 t_sec;
  90     LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
  91     LL_DIV(t_usec, t_usec, usec_per_sec);
  92     LL_L2I(t_sec, t_usec);
  93     return t_sec;
  94 }
  95
  96 #define NowInSeconds() PRTimeToSeconds(PR_Now())
  97
  98 //-----------------------------------------------------------------------------
  99 // nsPrefetchQueueEnumerator
 100 //-----------------------------------------------------------------------------
 101 class nsPrefetchQueueEnumerator : public nsISimpleEnumerator
 102 {
 103 public:
 104     NS_DECL_ISUPPORTS
 105     NS_DECL_NSISIMPLEENUMERATOR
 106     nsPrefetchQueueEnumerator(nsPrefetchService *aService);
 107     ~nsPrefetchQueueEnumerator();
 108
 109 private:
 110     void Increment();
 111
 112     nsRefPtr<nsPrefetchService> mService;
 113     nsRefPtr<nsPrefetchNode> mCurrent;
 114     PRBool mStarted;
 115 };
 116
 117 //-----------------------------------------------------------------------------
 118 // nsPrefetchQueueEnumerator <public>
 119 //-----------------------------------------------------------------------------
 120 nsPrefetchQueueEnumerator::nsPrefetchQueueEnumerator(nsPrefetchService *aService)
 121     : mService(aService)
 122     , mStarted(PR_FALSE)
 123 {
 124     Increment();
 125 }
 126
 127 nsPrefetchQueueEnumerator::~nsPrefetchQueueEnumerator()
 128 {
 129 }
 130
 131 //-----------------------------------------------------------------------------
 132 // nsPrefetchQueueEnumerator::nsISimpleEnumerator
 133 //-----------------------------------------------------------------------------
 134 NS_IMETHODIMP
 135 nsPrefetchQueueEnumerator::HasMoreElements(PRBool *aHasMore)
 136 {
 137     *aHasMore = (mCurrent != nsnull);
 138     return NS_OK;
 139 }
 140
 141 NS_IMETHODIMP
 142 nsPrefetchQueueEnumerator::GetNext(nsISupports **aItem)
 143 {
 144     if (!mCurrent) return NS_ERROR_FAILURE;
 145
 146     NS_ADDREF(*aItem = static_cast<nsIDOMLoadStatus*>(mCurrent.get()));
 147
 148     Increment();
 149
 150     return NS_OK;
 151 }
 152
 153 //-----------------------------------------------------------------------------
 154 // nsPrefetchQueueEnumerator <private>
 155 //-----------------------------------------------------------------------------
 156
 157 void
 158 nsPrefetchQueueEnumerator::Increment()
 159 {
 160     do {
 161         if (!mStarted) {
 162             // If the service is currently serving a request, it won't be
 163             // in the pending queue, so we return it first.  If it isn't,
 164             // we'll just start with the pending queue.
 165             mStarted = PR_TRUE;
 166             mCurrent = mService->GetCurrentNode();
 167             if (!mCurrent)
 168                 mCurrent = mService->GetQueueHead();
 169         }
 170         else if (mCurrent) {
 171             if (mCurrent == mService->GetCurrentNode()) {
 172                 // If we just returned the node being processed by the service,
 173                 // start with the pending queue
 174                 mCurrent = mService->GetQueueHead();
 175             }
 176             else {
 177                 // Otherwise just advance to the next item in the queue
 178                 mCurrent = mCurrent->mNext;
 179             }
 180         }
 181     } while (mCurrent);
 182 }
 183
 184 //-----------------------------------------------------------------------------
 185 // nsPrefetchQueueEnumerator::nsISupports
 186 //-----------------------------------------------------------------------------
 187
 188 NS_IMPL_ISUPPORTS1(nsPrefetchQueueEnumerator, nsISimpleEnumerator)
 189
 190 //-----------------------------------------------------------------------------
 191 // nsPrefetchNode <public>
 192 //-----------------------------------------------------------------------------
 193
 194 nsPrefetchNode::nsPrefetchNode(nsPrefetchService *aService,
 195                                nsIURI *aURI,
 196                                nsIURI *aReferrerURI,
 197                                nsIDOMNode *aSource)
 198     : mNext(nsnull)
 199     , mURI(aURI)
 200     , mReferrerURI(aReferrerURI)
 201     , mService(aService)
 202     , mChannel(nsnull)
 203     , mState(nsIDOMLoadStatus::UNINITIALIZED)
 204     , mBytesRead(0)
 205 {
 206     mSource = do_GetWeakReference(aSource);
 207 }
 208
 209 nsresult
 210 nsPrefetchNode::OpenChannel()
 211 {
 212     nsresult rv = NS_NewChannel(getter_AddRefs(mChannel),
 213                                 mURI,
 214                                 nsnull, nsnull, this,
 215                                 nsIRequest::LOAD_BACKGROUND |
 216                                 nsICachingChannel::LOAD_ONLY_IF_MODIFIED);
 217     NS_ENSURE_SUCCESS(rv, rv);
 218
 219     // configure HTTP specific stuff
 220     nsCOMPtr<nsIHttpChannel> httpChannel =
 221         do_QueryInterface(mChannel);
 222     if (httpChannel) {
 223         httpChannel->SetReferrer(mReferrerURI);
 224         httpChannel->SetRequestHeader(
 225             NS_LITERAL_CSTRING("X-Moz"),
 226             NS_LITERAL_CSTRING("prefetch"),
 227             PR_FALSE);
 228     }
 229
 230     rv = mChannel->AsyncOpen(this, nsnull);
 231     NS_ENSURE_SUCCESS(rv, rv);
 232
 233     mState = nsIDOMLoadStatus::REQUESTED;
 234
 235     return NS_OK;
 236 }
 237
 238 nsresult
 239 nsPrefetchNode::CancelChannel(nsresult error)
 240 {
 241     mChannel->Cancel(error);
 242     mChannel = nsnull;
 243
 244     mState = nsIDOMLoadStatus::UNINITIALIZED;
 245
 246     return NS_OK;
 247 }
 248
 249 //-----------------------------------------------------------------------------
 250 // nsPrefetchNode::nsISupports
 251 //-----------------------------------------------------------------------------
 252
 253 NS_IMPL_ISUPPORTS5(nsPrefetchNode,
 254                    nsIDOMLoadStatus,
 255                    nsIRequestObserver,
 256                    nsIStreamListener,
 257                    nsIInterfaceRequestor,
 258                    nsIChannelEventSink)
 259
 260 //-----------------------------------------------------------------------------
 261 // nsPrefetchNode::nsIStreamListener
 262 //-----------------------------------------------------------------------------
 263
 264 NS_IMETHODIMP
 265 nsPrefetchNode::OnStartRequest(nsIRequest *aRequest,
 266                                nsISupports *aContext)
 267 {
 268     nsresult rv;
 269
 270     nsCOMPtr<nsICachingChannel> cachingChannel =
 271         do_QueryInterface(aRequest, &rv);
 272     if (NS_FAILED(rv)) return rv;
 273
 274     // no need to prefetch a document that is already in the cache
 275     PRBool fromCache;
 276     if (NS_SUCCEEDED(cachingChannel->IsFromCache(&fromCache)) &&
 277         fromCache) {
 278         LOG(("document is already in the cache; canceling prefetch\n"));
 279         return NS_BINDING_ABORTED;
 280     }
 281
 282     //
 283     // no need to prefetch a document that must be requested fresh each
 284     // and every time.
 285     //
 286     nsCOMPtr<nsISupports> cacheToken;
 287     cachingChannel->GetCacheToken(getter_AddRefs(cacheToken));
 288     if (!cacheToken)
 289         return NS_ERROR_ABORT; // bail, no cache entry
 290
 291     nsCOMPtr<nsICacheEntryInfo> entryInfo =
 292         do_QueryInterface(cacheToken, &rv);
 293     if (NS_FAILED(rv)) return rv;
 294
 295     PRUint32 expTime;
 296     if (NS_SUCCEEDED(entryInfo->GetExpirationTime(&expTime))) {
 297         if (NowInSeconds() >= expTime) {
 298             LOG(("document cannot be reused from cache; "
 299                  "canceling prefetch\n"));
 300             return NS_BINDING_ABORTED;
 301         }
 302     }
 303
 304     mState = nsIDOMLoadStatus::RECEIVING;
 305
 306     return NS_OK;
 307 }
 308
 309 NS_IMETHODIMP
 310 nsPrefetchNode::OnDataAvailable(nsIRequest *aRequest,
 311                                 nsISupports *aContext,
 312                                 nsIInputStream *aStream,
 313                                 PRUint32 aOffset,
 314                                 PRUint32 aCount)
 315 {
 316     PRUint32 bytesRead = 0;
 317     aStream->ReadSegments(NS_DiscardSegment, nsnull, aCount, &bytesRead);
 318     mBytesRead += bytesRead;
 319     LOG(("prefetched %u bytes [offset=%u]\n", bytesRead, aOffset));
 320     return NS_OK;
 321 }
 322
 323
 324 NS_IMETHODIMP
 325 nsPrefetchNode::OnStopRequest(nsIRequest *aRequest,
 326                               nsISupports *aContext,
 327                               nsresult aStatus)
 328 {
 329     LOG(("done prefetching [status=%x]\n", aStatus));
 330
 331     mState = nsIDOMLoadStatus::LOADED;
 332
 333     if (mBytesRead == 0 && aStatus == NS_OK) {
 334         // we didn't need to read (because LOAD_ONLY_IF_MODIFIED was
 335         // specified), but the object should report loadedSize as if it
 336         // did.
 337         mChannel->GetContentLength(&mBytesRead);
 338     }
 339
 340     mService->NotifyLoadCompleted(this);
 341     mService->ProcessNextURI();
 342     return NS_OK;
 343 }
 344
 345 //-----------------------------------------------------------------------------
 346 // nsPrefetchNode::nsIInterfaceRequestor
 347 //-----------------------------------------------------------------------------
 348
 349 NS_IMETHODIMP
 350 nsPrefetchNode::GetInterface(const nsIID &aIID, void **aResult)
 351 {
 352     if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
 353         NS_ADDREF_THIS();
 354         *aResult = static_cast<nsIChannelEventSink *>(this);
 355         return NS_OK;
 356     }
 357
 358     return NS_ERROR_NO_INTERFACE;
 359 }
 360
 361 //-----------------------------------------------------------------------------
 362 // nsPrefetchNode::nsIChannelEventSink
 363 //-----------------------------------------------------------------------------
 364
 365 NS_IMETHODIMP
 366 nsPrefetchNode::OnChannelRedirect(nsIChannel *aOldChannel,
 367                                   nsIChannel *aNewChannel,
 368                                   PRUint32 aFlags)
 369 {
 370     nsCOMPtr<nsIURI> newURI;
 371     nsresult rv = aNewChannel->GetURI(getter_AddRefs(newURI));
 372     if (NS_FAILED(rv))
 373         return rv;
 374
 375     nsCOMPtr<nsICachingChannel> oldCachingChannel =
 376         do_QueryInterface(aOldChannel);
 377
 378     PRBool match;
 379     rv = newURI->SchemeIs("http", &match);
 380     if (NS_FAILED(rv) || !match) {
 381         rv = newURI->SchemeIs("https", &match);
 382         if (NS_FAILED(rv) || !match) {
 383             LOG(("rejected: URL is not of type http/https\n"));
 384             return NS_ERROR_ABORT;
 385         }
 386     }
 387
 388     // HTTP request headers are not automatically forwarded to the new channel.
 389     nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aNewChannel);
 390     NS_ENSURE_STATE(httpChannel);
 391
 392     httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("X-Moz"),
 393                                   NS_LITERAL_CSTRING("prefetch"),
 394                                   PR_FALSE);
 395
 396     mChannel = aNewChannel;
 397
 398     return NS_OK;
 399 }
 400
 401
 402 //-----------------------------------------------------------------------------
 403 // nsPrefetchService <public>
 404 //-----------------------------------------------------------------------------
 405
 406 nsPrefetchService::nsPrefetchService()
 407     : mQueueHead(nsnull)
 408     , mQueueTail(nsnull)
 409     , mStopCount(0)
 410     , mHaveProcessed(PR_FALSE)
 411     , mDisabled(PR_TRUE)
 412 {
 413 }
 414
 415 nsPrefetchService::~nsPrefetchService()
 416 {
 417     // cannot reach destructor if prefetch in progress (listener owns reference
 418     // to this service)
 419     EmptyQueue();
 420 }
 421
 422 nsresult
 423 nsPrefetchService::Init()
 424 {
 425 #if defined(PR_LOGGING)
 426     if (!gPrefetchLog)
 427         gPrefetchLog = PR_NewLogModule("nsPrefetch");
 428 #endif
 429
 430     nsresult rv;
 431
 432     // read prefs and hook up pref observer
 433     nsCOMPtr<nsIPrefBranch2> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
 434     if (NS_SUCCEEDED(rv)) {
 435       PRBool enabled;
 436       rv = prefs->GetBoolPref(PREFETCH_PREF, &enabled);
 437       if (NS_SUCCEEDED(rv) && enabled)
 438         mDisabled = PR_FALSE;
 439
 440       prefs->AddObserver(PREFETCH_PREF, this, PR_TRUE);
 441     }
 442
 443     // Observe xpcom-shutdown event
 444     nsCOMPtr<nsIObserverService> observerServ(
 445             do_GetService("@mozilla.org/observer-service;1", &rv));
 446     if (NS_FAILED(rv)) return rv;
 447
 448     rv = observerServ->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_TRUE);
 449     if (NS_FAILED(rv)) return rv;
 450
 451     if (!mDisabled)
 452         AddProgressListener();
 453
 454     return NS_OK;
 455 }
 456
 457 void
 458 nsPrefetchService::ProcessNextURI()
 459 {
 460     nsresult rv;
 461     nsCOMPtr<nsIURI> uri, referrer;
 462
 463     mCurrentNode = nsnull;
 464
 465     do {
 466         rv = DequeueNode(getter_AddRefs(mCurrentNode));
 467
 468         if (NS_FAILED(rv)) break;
 469
 470 #if defined(PR_LOGGING)
 471         if (LOG_ENABLED()) {
 472             nsCAutoString spec;
 473             mCurrentNode->mURI->GetSpec(spec);
 474             LOG(("ProcessNextURI [%s]\n", spec.get()));
 475         }
 476 #endif
 477
 478         //
 479         // if opening the channel fails, then just skip to the next uri
 480         //
 481         rv = mCurrentNode->OpenChannel();
 482     }
 483     while (NS_FAILED(rv));
 484 }
 485
 486 void
 487 nsPrefetchService::NotifyLoadRequested(nsPrefetchNode *node)
 488 {
 489     nsresult rv;
 490
 491     nsCOMPtr<nsIObserverService> observerService =
 492         do_GetService("@mozilla.org/observer-service;1", &rv);
 493     if (NS_FAILED(rv)) return;
 494
 495     observerService->NotifyObservers(static_cast<nsIDOMLoadStatus*>(node),
 496                                      "prefetch-load-requested", nsnull);
 497 }
 498
 499 void
 500 nsPrefetchService::NotifyLoadCompleted(nsPrefetchNode *node)
 501 {
 502     nsresult rv;
 503
 504     nsCOMPtr<nsIObserverService> observerService =
 505         do_GetService("@mozilla.org/observer-service;1", &rv);
 506     if (NS_FAILED(rv)) return;
 507
 508     observerService->NotifyObservers(static_cast<nsIDOMLoadStatus*>(node),
 509                                      "prefetch-load-completed", nsnull);
 510 }
 511
 512 //-----------------------------------------------------------------------------
 513 // nsPrefetchService <private>
 514 //-----------------------------------------------------------------------------
 515
 516 void
 517 nsPrefetchService::AddProgressListener()
 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->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_DOCUMENT);
 524 }
 525
 526 void
 527 nsPrefetchService::RemoveProgressListener()
 528 {
 529     // Register as an observer for the document loader
 530     nsCOMPtr<nsIWebProgress> progress =
 531         do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID);
 532     if (progress)
 533         progress->RemoveProgressListener(this);
 534 }
 535
 536 nsresult
 537 nsPrefetchService::EnqueueNode(nsPrefetchNode *aNode)
 538 {
 539     NS_ADDREF(aNode);
 540
 541     if (!mQueueTail) {
 542         mQueueHead = aNode;
 543         mQueueTail = aNode;
 544     }
 545     else {
 546         mQueueTail->mNext = aNode;
 547         mQueueTail = aNode;
 548     }
 549
 550     return NS_OK;
 551 }
 552
 553 nsresult
 554 nsPrefetchService::EnqueueURI(nsIURI *aURI,
 555                               nsIURI *aReferrerURI,
 556                               nsIDOMNode *aSource,
 557                               nsPrefetchNode **aNode)
 558 {
 559     nsPrefetchNode *node = new nsPrefetchNode(this, aURI, aReferrerURI,
 560                                               aSource);
 561     if (!node)
 562         return NS_ERROR_OUT_OF_MEMORY;
 563
 564     NS_ADDREF(*aNode = node);
 565
 566     return EnqueueNode(node);
 567 }
 568
 569 nsresult
 570 nsPrefetchService::DequeueNode(nsPrefetchNode **node)
 571 {
 572     if (!mQueueHead)
 573         return NS_ERROR_NOT_AVAILABLE;
 574
 575     // give the ref to the caller
 576     *node = mQueueHead;
 577     mQueueHead = mQueueHead->mNext;
 578     (*node)->mNext = nsnull;
 579
 580     if (!mQueueHead)
 581         mQueueTail = nsnull;
 582
 583     return NS_OK;
 584 }
 585
 586 void
 587 nsPrefetchService::EmptyQueue()
 588 {
 589     nsPrefetchNode *prev = 0;
 590     nsPrefetchNode *node = mQueueHead;
 591
 592     while (node) {
 593         nsPrefetchNode *next = node->mNext;
 594         if (prev)
 595             prev->mNext = next;
 596         else
 597             mQueueHead = next;
 598         NS_RELEASE(node);
 599
 600         node = next;
 601     }
 602 }
 603
 604 void
 605 nsPrefetchService::StartPrefetching()
 606 {
 607     //
 608     // at initialization time we might miss the first DOCUMENT START
 609     // notification, so we have to be careful to avoid letting our
 610     // stop count go negative.
 611     //
 612     if (mStopCount > 0)
 613         mStopCount--;
 614
 615     LOG(("StartPrefetching [stopcount=%d]\n", mStopCount));
 616
 617     // only start prefetching after we've received enough DOCUMENT
 618     // STOP notifications.  we do this inorder to defer prefetching
 619     // until after all sub-frames have finished loading.
 620     if (mStopCount == 0 && !mCurrentNode) {
 621         mHaveProcessed = PR_TRUE;
 622         ProcessNextURI();
 623     }
 624 }
 625
 626 void
 627 nsPrefetchService::StopPrefetching()
 628 {
 629     mStopCount++;
 630
 631     LOG(("StopPrefetching [stopcount=%d]\n", mStopCount));
 632
 633     // only kill the prefetch queue if we've actually started prefetching.
 634     if (!mCurrentNode)
 635         return;
 636
 637     mCurrentNode->CancelChannel(NS_BINDING_ABORTED);
 638     mCurrentNode = nsnull;
 639     EmptyQueue();
 640 }
 641
 642 //-----------------------------------------------------------------------------
 643 // nsPrefetchService::nsISupports
 644 //-----------------------------------------------------------------------------
 645
 646 NS_IMPL_ISUPPORTS4(nsPrefetchService,
 647                    nsIPrefetchService,
 648                    nsIWebProgressListener,
 649                    nsIObserver,
 650                    nsISupportsWeakReference)
 651
 652 //-----------------------------------------------------------------------------
 653 // nsPrefetchService::nsIPrefetchService
 654 //-----------------------------------------------------------------------------
 655
 656 nsresult
 657 nsPrefetchService::Prefetch(nsIURI *aURI,
 658                             nsIURI *aReferrerURI,
 659                             nsIDOMNode *aSource,
 660                             PRBool aExplicit)
 661 {
 662     nsresult rv;
 663
 664     NS_ENSURE_ARG_POINTER(aURI);
 665     NS_ENSURE_ARG_POINTER(aReferrerURI);
 666
 667 #if defined(PR_LOGGING)
 668     if (LOG_ENABLED()) {
 669         nsCAutoString spec;
 670         aURI->GetSpec(spec);
 671         LOG(("PrefetchURI [%s]\n", spec.get()));
 672     }
 673 #endif
 674
 675     if (mDisabled) {
 676         LOG(("rejected: prefetch service is disabled\n"));
 677         return NS_ERROR_ABORT;
 678     }
 679
 680     //
 681     // XXX we should really be asking the protocol handler if it supports
 682     // caching, so we can determine if there is any value to prefetching.
 683     // for now, we'll only prefetch http links since we know that's the
 684     // most common case.  ignore https links since https content only goes
 685     // into the memory cache.
 686     //
 687     // XXX we might want to either leverage nsIProtocolHandler::protocolFlags
 688     // or possibly nsIRequest::loadFlags to determine if this URI should be
 689     // prefetched.
 690     //
 691     PRBool match;
 692     rv = aURI->SchemeIs("http", &match);
 693     if (NS_FAILED(rv) || !match) {
 694         rv = aURI->SchemeIs("https", &match);
 695         if (NS_FAILED(rv) || !match) {
 696             LOG(("rejected: URL is not of type http/https\n"));
 697             return NS_ERROR_ABORT;
 698         }
 699     }
 700
 701     //
 702     // the referrer URI must be http:
 703     //
 704     rv = aReferrerURI->SchemeIs("http", &match);
 705     if (NS_FAILED(rv) || !match) {
 706         rv = aReferrerURI->SchemeIs("https", &match);
 707         if (NS_FAILED(rv) || !match) {
 708             LOG(("rejected: referrer URL is neither http nor https\n"));
 709             return NS_ERROR_ABORT;
 710         }
 711     }
 712
 713     // skip URLs that contain query strings, except URLs for which prefetching
 714     // has been explicitly requested.
 715     if (!aExplicit) {
 716         nsCOMPtr<nsIURL> url(do_QueryInterface(aURI, &rv));
 717         if (NS_FAILED(rv)) return rv;
 718         nsCAutoString query;
 719         rv = url->GetQuery(query);
 720         if (NS_FAILED(rv) || !query.IsEmpty()) {
 721             LOG(("rejected: URL has a query string\n"));
 722             return NS_ERROR_ABORT;
 723         }
 724     }
 725
 726     //
 727     // cancel if being prefetched
 728     //
 729     if (mCurrentNode) {
 730         PRBool equals;
 731         if (NS_SUCCEEDED(mCurrentNode->mURI->Equals(aURI, &equals)) && equals) {
 732             LOG(("rejected: URL is already being prefetched\n"));
 733             return NS_ERROR_ABORT;
 734         }
 735     }
 736
 737     //
 738     // cancel if already on the prefetch queue
 739     //
 740     nsPrefetchNode *node = mQueueHead;
 741     for (; node; node = node->mNext) {
 742         PRBool equals;
 743         if (NS_SUCCEEDED(node->mURI->Equals(aURI, &equals)) && equals) {
 744             LOG(("rejected: URL is already on prefetch queue\n"));
 745             return NS_ERROR_ABORT;
 746         }
 747     }
 748
 749     nsRefPtr<nsPrefetchNode> enqueuedNode;
 750     rv = EnqueueURI(aURI, aReferrerURI, aSource,
 751                     getter_AddRefs(enqueuedNode));
 752     NS_ENSURE_SUCCESS(rv, rv);
 753
 754     NotifyLoadRequested(enqueuedNode);
 755
 756     // if there are no pages loading, kick off the request immediately
 757     if (mStopCount == 0 && mHaveProcessed)
 758         ProcessNextURI();
 759
 760     return NS_OK;
 761 }
 762
 763 NS_IMETHODIMP
 764 nsPrefetchService::PrefetchURI(nsIURI *aURI,
 765                                nsIURI *aReferrerURI,
 766                                nsIDOMNode *aSource,
 767                                PRBool aExplicit)
 768 {
 769     return Prefetch(aURI, aReferrerURI, aSource, aExplicit);
 770 }
 771
 772 NS_IMETHODIMP
 773 nsPrefetchService::PrefetchURIForOfflineUse(nsIURI *aURI,
 774                                             nsIURI *aReferrerURI,
 775                                             nsIDOMNode *aSource,
 776                                             PRBool aExplicit)
 777 {
 778     return NS_ERROR_NOT_IMPLEMENTED;
 779 }
 780
 781 NS_IMETHODIMP
 782 nsPrefetchService::EnumerateQueue(PRBool aIncludeNormalItems,
 783                                   PRBool aIncludeOfflineItems,
 784                                   nsISimpleEnumerator **aEnumerator)
 785 {
 786     NS_ENSURE_TRUE(aIncludeNormalItems && !aIncludeOfflineItems,
 787                    NS_ERROR_NOT_IMPLEMENTED);
 788
 789     *aEnumerator = new nsPrefetchQueueEnumerator(this);
 790     if (!*aEnumerator) return NS_ERROR_OUT_OF_MEMORY;
 791
 792     NS_ADDREF(*aEnumerator);
 793
 794     return NS_OK;
 795 }
 796
 797 //-----------------------------------------------------------------------------
 798 // nsPrefetchNode::nsIDOMLoadStatus
 799 //-----------------------------------------------------------------------------
 800 NS_IMETHODIMP
 801 nsPrefetchNode::GetSource(nsIDOMNode **aSource)
 802 {
 803     *aSource = nsnull;
 804     nsCOMPtr<nsIDOMNode> source = do_QueryReferent(mSource);
 805     if (source)
 806         source.swap(*aSource);
 807
 808     return NS_OK;
 809 }
 810
 811 NS_IMETHODIMP
 812 nsPrefetchNode::GetUri(nsAString &aURI)
 813 {
 814     nsCAutoString spec;
 815     nsresult rv = mURI->GetSpec(spec);
 816     NS_ENSURE_SUCCESS(rv, rv);
 817
 818     CopyUTF8toUTF16(spec, aURI);
 819     return NS_OK;
 820 }
 821
 822 NS_IMETHODIMP
 823 nsPrefetchNode::GetTotalSize(PRInt32 *aTotalSize)
 824 {
 825     if (mChannel) {
 826         return mChannel->GetContentLength(aTotalSize);
 827     }
 828
 829     *aTotalSize = -1;
 830     return NS_OK;
 831 }
 832
 833 NS_IMETHODIMP
 834 nsPrefetchNode::GetLoadedSize(PRInt32 *aLoadedSize)
 835 {
 836     *aLoadedSize = mBytesRead;
 837     return NS_OK;
 838 }
 839
 840 NS_IMETHODIMP
 841 nsPrefetchNode::GetReadyState(PRUint16 *aReadyState)
 842 {
 843     *aReadyState = mState;
 844     return NS_OK;
 845 }
 846
 847 NS_IMETHODIMP
 848 nsPrefetchNode::GetStatus(PRUint16 *aStatus)
 849 {
 850     if (!mChannel) {
 851         *aStatus = 0;
 852         return NS_OK;
 853     }
 854
 855     nsresult rv;
 856     nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel, &rv);
 857     NS_ENSURE_SUCCESS(rv, rv);
 858
 859     PRUint32 httpStatus;
 860     rv = httpChannel->GetResponseStatus(&httpStatus);
 861     if (rv == NS_ERROR_NOT_AVAILABLE) {
 862         // Someone's calling this before we got a response... Check our
 863         // ReadyState.  If we're at RECEIVING or LOADED, then this means the
 864         // connection errored before we got any data; return a somewhat
 865         // sensible error code in that case.
 866         if (mState >= nsIDOMLoadStatus::RECEIVING) {
 867             *aStatus = NS_ERROR_NOT_AVAILABLE;
 868             return NS_OK;
 869         }
 870
 871         *aStatus = 0;
 872         return NS_OK;
 873     }
 874
 875     NS_ENSURE_SUCCESS(rv, rv);
 876     *aStatus = PRUint16(httpStatus);
 877     return NS_OK;
 878 }
 879
 880 //-----------------------------------------------------------------------------
 881 // nsPrefetchService::nsIWebProgressListener
 882 //-----------------------------------------------------------------------------
 883
 884 NS_IMETHODIMP
 885 nsPrefetchService::OnProgressChange(nsIWebProgress *aProgress,
 886                                   nsIRequest *aRequest,
 887                                   PRInt32 curSelfProgress,
 888                                   PRInt32 maxSelfProgress,
 889                                   PRInt32 curTotalProgress,
 890                                   PRInt32 maxTotalProgress)
 891 {
 892     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 893     return NS_OK;
 894 }
 895
 896 NS_IMETHODIMP
 897 nsPrefetchService::OnStateChange(nsIWebProgress* aWebProgress,
 898                                  nsIRequest *aRequest,
 899                                  PRUint32 progressStateFlags,
 900                                  nsresult aStatus)
 901 {
 902     if (progressStateFlags & STATE_IS_DOCUMENT) {
 903         if (progressStateFlags & STATE_STOP)
 904             StartPrefetching();
 905         else if (progressStateFlags & STATE_START)
 906             StopPrefetching();
 907     }
 908
 909     return NS_OK;
 910 }
 911
 912
 913 NS_IMETHODIMP
 914 nsPrefetchService::OnLocationChange(nsIWebProgress* aWebProgress,
 915                                     nsIRequest* aRequest,
 916                                     nsIURI *location)
 917 {
 918     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 919     return NS_OK;
 920 }
 921
 922 NS_IMETHODIMP
 923 nsPrefetchService::OnStatusChange(nsIWebProgress* aWebProgress,
 924                                   nsIRequest* aRequest,
 925                                   nsresult aStatus,
 926                                   const PRUnichar* aMessage)
 927 {
 928     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 929     return NS_OK;
 930 }
 931
 932 NS_IMETHODIMP
 933 nsPrefetchService::OnSecurityChange(nsIWebProgress *aWebProgress,
 934                                     nsIRequest *aRequest,
 935                                     PRUint32 state)
 936 {
 937     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
 938     return NS_OK;
 939 }
 940
 941 //-----------------------------------------------------------------------------
 942 // nsPrefetchService::nsIObserver
 943 //-----------------------------------------------------------------------------
 944
 945 NS_IMETHODIMP
 946 nsPrefetchService::Observe(nsISupports     *aSubject,
 947                            const char      *aTopic,
 948                            const PRUnichar *aData)
 949 {
 950     LOG(("nsPrefetchService::Observe [topic=%s]\n", aTopic));
 951
 952     if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
 953         StopPrefetching();
 954         mDisabled = PR_TRUE;
 955     }
 956     else if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
 957         nsCOMPtr<nsIPrefBranch> prefs(do_QueryInterface(aSubject));
 958         PRBool enabled;
 959         nsresult rv = prefs->GetBoolPref(PREFETCH_PREF, &enabled);
 960         if (NS_SUCCEEDED(rv) && enabled) {
 961             if (mDisabled) {
 962                 LOG(("enabling prefetching\n"));
 963                 mDisabled = PR_FALSE;
 964                 AddProgressListener();
 965             }
 966         }
 967         else {
 968             if (!mDisabled) {
 969                 LOG(("disabling prefetching\n"));
 970                 StopPrefetching();
 971                 mDisabled = PR_TRUE;
 972                 RemoveProgressListener();
 973             }
 974         }
 975     }
 976
 977     return NS_OK;
 978 }
 979
 980 // vim: ts=4 sw=4 expandtab