uriloader/base/nsDocLoader.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nspr.h"
   7 #include "prlog.h"
   8
   9 #include "nsDocLoader.h"
  10 #include "nsCURILoader.h"
  11 #include "nsNetUtil.h"
  12 #include "nsIHttpChannel.h"
  13 #include "nsIWebProgressListener2.h"
  14
  15 #include "nsIServiceManager.h"
  16 #include "nsXPIDLString.h"
  17
  18 #include "nsIURL.h"
  19 #include "nsCOMPtr.h"
  20 #include "nscore.h"
  21 #include "nsWeakPtr.h"
  22 #include "nsAutoPtr.h"
  23
  24 #include "nsIDOMWindow.h"
  25
  26 #include "nsIStringBundle.h"
  27 #include "nsIScriptSecurityManager.h"
  28
  29 #include "nsITransport.h"
  30 #include "nsISocketTransport.h"
  31
  32 #include "nsIDOMDocument.h"
  33 #include "nsIDocument.h"
  34 #include "nsPresContext.h"
  35 #include "nsIAsyncVerifyRedirectCallback.h"
  36
  37 static NS_DEFINE_CID(kThisImplCID, NS_THIS_DOCLOADER_IMPL_CID);
  38
  39 #if defined(PR_LOGGING)
  40 //
  41 // Log module for nsIDocumentLoader logging...
  42 //
  43 // To enable logging (see prlog.h for full details):
  44 //
  45 //    set NSPR_LOG_MODULES=DocLoader:5
  46 //    set NSPR_LOG_FILE=nspr.log
  47 //
  48 // this enables PR_LOG_DEBUG level information and places all output in
  49 // the file nspr.log
  50 //
  51 PRLogModuleInfo* gDocLoaderLog = nullptr;
  52 #endif /* PR_LOGGING */
  53
  54
  55 #if defined(DEBUG)
  56 void GetURIStringFromRequest(nsIRequest* request, nsACString &name)
  57 {
  58     if (request)
  59         request->GetName(name);
  60     else
  61         name.AssignLiteral("???");
  62 }
  63 #endif /* DEBUG */
  64
  65
  66
  67 bool
  68 nsDocLoader::RequestInfoHashInitEntry(PLDHashTable* table,
  69                                       PLDHashEntryHdr* entry,
  70                                       const void* key)
  71 {
  72   // Initialize the entry with placement new
  73   new (entry) nsRequestInfo(key);
  74   return true;
  75 }
  76
  77 void
  78 nsDocLoader::RequestInfoHashClearEntry(PLDHashTable* table,
  79                                        PLDHashEntryHdr* entry)
  80 {
  81   nsRequestInfo* info = static_cast<nsRequestInfo *>(entry);
  82   info->~nsRequestInfo();
  83 }
  84
  85 struct nsListenerInfo {
  86   nsListenerInfo(nsIWeakReference *aListener, unsigned long aNotifyMask)
  87     : mWeakListener(aListener),
  88       mNotifyMask(aNotifyMask)
  89   {
  90   }
  91
  92   // Weak pointer for the nsIWebProgressListener...
  93   nsWeakPtr mWeakListener;
  94
  95   // Mask indicating which notifications the listener wants to receive.
  96   unsigned long mNotifyMask;
  97 };
  98
  99
 100 nsDocLoader::nsDocLoader()
 101   : mParent(nullptr),
 102     mListenerInfoList(8),
 103     mCurrentSelfProgress(0),
 104     mMaxSelfProgress(0),
 105     mCurrentTotalProgress(0),
 106     mMaxTotalProgress(0),
 107     mCompletedTotalProgress(0),
 108     mIsLoadingDocument(false),
 109     mIsRestoringDocument(false),
 110     mDontFlushLayout(false),
 111     mIsFlushingLayout(false)
 112 {
 113 #if defined(PR_LOGGING)
 114   if (nullptr == gDocLoaderLog) {
 115       gDocLoaderLog = PR_NewLogModule("DocLoader");
 116   }
 117 #endif /* PR_LOGGING */
 118
 119   static const PLDHashTableOps hash_table_ops =
 120   {
 121     PL_DHashAllocTable,
 122     PL_DHashFreeTable,
 123     PL_DHashVoidPtrKeyStub,
 124     PL_DHashMatchEntryStub,
 125     PL_DHashMoveEntryStub,
 126     RequestInfoHashClearEntry,
 127     PL_DHashFinalizeStub,
 128     RequestInfoHashInitEntry
 129   };
 130
 131   if (!PL_DHashTableInit(&mRequestInfoHash, &hash_table_ops, nullptr,
 132                          sizeof(nsRequestInfo), 16)) {
 133     mRequestInfoHash.ops = nullptr;
 134   }
 135
 136   ClearInternalProgress();
 137
 138   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 139          ("DocLoader:%p: created.\n", this));
 140 }
 141
 142 nsresult
 143 nsDocLoader::SetDocLoaderParent(nsDocLoader *aParent)
 144 {
 145   mParent = aParent;
 146   return NS_OK;
 147 }
 148
 149 nsresult
 150 nsDocLoader::Init()
 151 {
 152   if (!mRequestInfoHash.ops) {
 153     return NS_ERROR_OUT_OF_MEMORY;
 154   }
 155
 156   nsresult rv = NS_NewLoadGroup(getter_AddRefs(mLoadGroup), this);
 157   if (NS_FAILED(rv)) return rv;
 158
 159   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 160          ("DocLoader:%p: load group %x.\n", this, mLoadGroup.get()));
 161
 162   return NS_OK;
 163 }
 164
 165 nsDocLoader::~nsDocLoader()
 166 {
 167                 /*
 168                         |ClearWeakReferences()| here is intended to prevent people holding weak references
 169                         from re-entering this destructor since |QueryReferent()| will |AddRef()| me, and the
 170                         subsequent |Release()| will try to destroy me.  At this point there should be only
 171                         weak references remaining (otherwise, we wouldn't be getting destroyed).
 172
 173                         An alternative would be incrementing our refcount (consider it a compressed flag
 174                         saying "Don't re-destroy.").  I haven't yet decided which is better. [scc]
 175                 */
 176   // XXXbz now that NS_IMPL_RELEASE stabilizes by setting refcount to 1, is
 177   // this needed?
 178   ClearWeakReferences();
 179
 180   Destroy();
 181
 182   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 183          ("DocLoader:%p: deleted.\n", this));
 184
 185   if (mRequestInfoHash.ops) {
 186     PL_DHashTableFinish(&mRequestInfoHash);
 187   }
 188 }
 189
 190
 191 /*
 192  * Implementation of ISupports methods...
 193  */
 194 NS_IMPL_ADDREF(nsDocLoader)
 195 NS_IMPL_RELEASE(nsDocLoader)
 196
 197 NS_INTERFACE_MAP_BEGIN(nsDocLoader)
 198    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRequestObserver)
 199    NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
 200    NS_INTERFACE_MAP_ENTRY(nsIDocumentLoader)
 201    NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 202    NS_INTERFACE_MAP_ENTRY(nsIWebProgress)
 203    NS_INTERFACE_MAP_ENTRY(nsIProgressEventSink)
 204    NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
 205    NS_INTERFACE_MAP_ENTRY(nsIChannelEventSink)
 206    NS_INTERFACE_MAP_ENTRY(nsISecurityEventSink)
 207    NS_INTERFACE_MAP_ENTRY(nsISupportsPriority)
 208    if (aIID.Equals(kThisImplCID))
 209      foundInterface = static_cast<nsIDocumentLoader *>(this);
 210    else
 211 NS_INTERFACE_MAP_END
 212
 213
 214 /*
 215  * Implementation of nsIInterfaceRequestor methods...
 216  */
 217 NS_IMETHODIMP nsDocLoader::GetInterface(const nsIID& aIID, void** aSink)
 218 {
 219   nsresult rv = NS_ERROR_NO_INTERFACE;
 220
 221   NS_ENSURE_ARG_POINTER(aSink);
 222
 223   if(aIID.Equals(NS_GET_IID(nsILoadGroup))) {
 224     *aSink = mLoadGroup;
 225     NS_IF_ADDREF((nsISupports*)*aSink);
 226     rv = NS_OK;
 227   } else {
 228     rv = QueryInterface(aIID, aSink);
 229   }
 230
 231   return rv;
 232 }
 233
 234 /* static */
 235 already_AddRefed<nsDocLoader>
 236 nsDocLoader::GetAsDocLoader(nsISupports* aSupports)
 237 {
 238   nsRefPtr<nsDocLoader> ret = do_QueryObject(aSupports);
 239   return ret.forget();
 240 }
 241
 242 /* static */
 243 nsresult
 244 nsDocLoader::AddDocLoaderAsChildOfRoot(nsDocLoader* aDocLoader)
 245 {
 246   nsresult rv;
 247   nsCOMPtr<nsIDocumentLoader> docLoaderService =
 248     do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID, &rv);
 249   NS_ENSURE_SUCCESS(rv, rv);
 250
 251   nsRefPtr<nsDocLoader> rootDocLoader = GetAsDocLoader(docLoaderService);
 252   NS_ENSURE_TRUE(rootDocLoader, NS_ERROR_UNEXPECTED);
 253
 254   return rootDocLoader->AddChildLoader(aDocLoader);
 255 }
 256
 257 NS_IMETHODIMP
 258 nsDocLoader::Stop(void)
 259 {
 260   nsresult rv = NS_OK;
 261
 262   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 263          ("DocLoader:%p: Stop() called\n", this));
 264
 265   NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(mChildList, nsDocLoader, Stop, ());
 266
 267   if (mLoadGroup)
 268     rv = mLoadGroup->Cancel(NS_BINDING_ABORTED);
 269
 270   // Don't report that we're flushing layout so IsBusy returns false after a
 271   // Stop call.
 272   mIsFlushingLayout = false;
 273
 274   // Clear out mChildrenInOnload.  We want to make sure to fire our
 275   // onload at this point, and there's no issue with mChildrenInOnload
 276   // after this, since mDocumentRequest will be null after the
 277   // DocLoaderIsEmpty() call.
 278   mChildrenInOnload.Clear();
 279
 280   // Make sure to call DocLoaderIsEmpty now so that we reset mDocumentRequest,
 281   // etc, as needed.  We could be getting into here from a subframe onload, in
 282   // which case the call to DocLoaderIsEmpty() is coming but hasn't quite
 283   // happened yet, Canceling the loadgroup did nothing (because it was already
 284   // empty), and we're about to start a new load (which is what triggered this
 285   // Stop() call).
 286
 287   // XXXbz If the child frame loadgroups were requests in mLoadgroup, I suspect
 288   // we wouldn't need the call here....
 289
 290   NS_ASSERTION(!IsBusy(), "Shouldn't be busy here");
 291   DocLoaderIsEmpty(false);
 292
 293   return rv;
 294 }
 295
 296
 297 bool
 298 nsDocLoader::IsBusy()
 299 {
 300   nsresult rv;
 301
 302   //
 303   // A document loader is busy if either:
 304   //
 305   //   1. One of its children is in the middle of an onload handler.  Note that
 306   //      the handler may have already removed this child from mChildList!
 307   //   2. It is currently loading a document and either has parts of it still
 308   //      loading, or has a busy child docloader.
 309   //   3. It's currently flushing layout in DocLoaderIsEmpty().
 310   //
 311
 312   if (mChildrenInOnload.Count() || mIsFlushingLayout) {
 313     return true;
 314   }
 315
 316   /* Is this document loader busy? */
 317   if (!mIsLoadingDocument) {
 318     return false;
 319   }
 320
 321   bool busy;
 322   rv = mLoadGroup->IsPending(&busy);
 323   if (NS_FAILED(rv)) {
 324     return false;
 325   }
 326   if (busy) {
 327     return true;
 328   }
 329
 330   /* check its child document loaders... */
 331   uint32_t count = mChildList.Length();
 332   for (uint32_t i=0; i < count; i++) {
 333     nsIDocumentLoader* loader = ChildAt(i);
 334
 335     // This is a safe cast, because we only put nsDocLoader objects into the
 336     // array
 337     if (loader && static_cast<nsDocLoader*>(loader)->IsBusy())
 338       return true;
 339   }
 340
 341   return false;
 342 }
 343
 344 NS_IMETHODIMP
 345 nsDocLoader::GetContainer(nsISupports** aResult)
 346 {
 347    NS_ADDREF(*aResult = static_cast<nsIDocumentLoader*>(this));
 348
 349    return NS_OK;
 350 }
 351
 352 NS_IMETHODIMP
 353 nsDocLoader::GetLoadGroup(nsILoadGroup** aResult)
 354 {
 355   nsresult rv = NS_OK;
 356
 357   if (nullptr == aResult) {
 358     rv = NS_ERROR_NULL_POINTER;
 359   } else {
 360     *aResult = mLoadGroup;
 361     NS_IF_ADDREF(*aResult);
 362   }
 363   return rv;
 364 }
 365
 366 void
 367 nsDocLoader::Destroy()
 368 {
 369   Stop();
 370
 371   // Remove the document loader from the parent list of loaders...
 372   if (mParent)
 373   {
 374     mParent->RemoveChildLoader(this);
 375   }
 376
 377   // Release all the information about network requests...
 378   ClearRequestInfoHash();
 379
 380   // Release all the information about registered listeners...
 381   int32_t count = mListenerInfoList.Count();
 382   for(int32_t i = 0; i < count; i++) {
 383     nsListenerInfo *info =
 384       static_cast<nsListenerInfo*>(mListenerInfoList.ElementAt(i));
 385
 386     delete info;
 387   }
 388
 389   mListenerInfoList.Clear();
 390   mListenerInfoList.Compact();
 391
 392   mDocumentRequest = 0;
 393
 394   if (mLoadGroup)
 395     mLoadGroup->SetGroupObserver(nullptr);
 396
 397   DestroyChildren();
 398 }
 399
 400 void
 401 nsDocLoader::DestroyChildren()
 402 {
 403   uint32_t count = mChildList.Length();
 404   // if the doc loader still has children...we need to enumerate the
 405   // children and make them null out their back ptr to the parent doc
 406   // loader
 407   for (uint32_t i=0; i < count; i++)
 408   {
 409     nsIDocumentLoader* loader = ChildAt(i);
 410
 411     if (loader) {
 412       // This is a safe cast, as we only put nsDocLoader objects into the
 413       // array
 414       static_cast<nsDocLoader*>(loader)->SetDocLoaderParent(nullptr);
 415     }
 416   }
 417   mChildList.Clear();
 418 }
 419
 420 NS_IMETHODIMP
 421 nsDocLoader::OnStartRequest(nsIRequest *request, nsISupports *aCtxt)
 422 {
 423   // called each time a request is added to the group.
 424
 425 #ifdef PR_LOGGING
 426   if (PR_LOG_TEST(gDocLoaderLog, PR_LOG_DEBUG)) {
 427     nsAutoCString name;
 428     request->GetName(name);
 429
 430     uint32_t count = 0;
 431     if (mLoadGroup)
 432       mLoadGroup->GetActiveCount(&count);
 433
 434     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 435            ("DocLoader:%p: OnStartRequest[%p](%s) mIsLoadingDocument=%s, %u active URLs",
 436             this, request, name.get(),
 437             (mIsLoadingDocument ? "true" : "false"),
 438             count));
 439   }
 440 #endif /* PR_LOGGING */
 441   bool bJustStartedLoading = false;
 442
 443   nsLoadFlags loadFlags = 0;
 444   request->GetLoadFlags(&loadFlags);
 445
 446   if (!mIsLoadingDocument && (loadFlags & nsIChannel::LOAD_DOCUMENT_URI)) {
 447       bJustStartedLoading = true;
 448       mIsLoadingDocument = true;
 449       ClearInternalProgress(); // only clear our progress if we are starting a new load....
 450   }
 451
 452   //
 453   // Create a new nsRequestInfo for the request that is starting to
 454   // load...
 455   //
 456   AddRequestInfo(request);
 457
 458   //
 459   // Only fire a doStartDocumentLoad(...) if the document loader
 460   // has initiated a load...  Otherwise, this notification has
 461   // resulted from a request being added to the load group.
 462   //
 463   if (mIsLoadingDocument) {
 464     if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI) {
 465       //
 466       // Make sure that the document channel is null at this point...
 467       // (unless its been redirected)
 468       //
 469       NS_ASSERTION((loadFlags & nsIChannel::LOAD_REPLACE) ||
 470                    !(mDocumentRequest.get()),
 471                    "Overwriting an existing document channel!");
 472
 473       // This request is associated with the entire document...
 474       mDocumentRequest = request;
 475       mLoadGroup->SetDefaultLoadRequest(request);
 476
 477       // Only fire the start document load notification for the first
 478       // document URI...  Do not fire it again for redirections
 479       //
 480       if (bJustStartedLoading) {
 481         // Update the progress status state
 482         mProgressStateFlags = nsIWebProgressListener::STATE_START;
 483
 484         // Fire the start document load notification
 485         doStartDocumentLoad();
 486         return NS_OK;
 487       }
 488     }
 489   }
 490
 491   NS_ASSERTION(!mIsLoadingDocument || mDocumentRequest,
 492                "mDocumentRequest MUST be set for the duration of a page load!");
 493
 494   doStartURLLoad(request);
 495
 496   return NS_OK;
 497 }
 498
 499 NS_IMETHODIMP
 500 nsDocLoader::OnStopRequest(nsIRequest *aRequest,
 501                            nsISupports *aCtxt,
 502                            nsresult aStatus)
 503 {
 504   nsresult rv = NS_OK;
 505
 506 #ifdef PR_LOGGING
 507   if (PR_LOG_TEST(gDocLoaderLog, PR_LOG_DEBUG)) {
 508     nsAutoCString name;
 509     aRequest->GetName(name);
 510
 511     uint32_t count = 0;
 512     if (mLoadGroup)
 513       mLoadGroup->GetActiveCount(&count);
 514
 515     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 516            ("DocLoader:%p: OnStopRequest[%p](%s) status=%x mIsLoadingDocument=%s, %u active URLs",
 517            this, aRequest, name.get(),
 518            aStatus, (mIsLoadingDocument ? "true" : "false"),
 519            count));
 520   }
 521 #endif
 522
 523   bool bFireTransferring = false;
 524
 525   //
 526   // Set the Maximum progress to the same value as the current progress.
 527   // Since the URI has finished loading, all the data is there.  Also,
 528   // this will allow a more accurate estimation of the max progress (in case
 529   // the old value was unknown ie. -1)
 530   //
 531   nsRequestInfo *info = GetRequestInfo(aRequest);
 532   if (info) {
 533     // Null out mLastStatus now so we don't find it when looking for
 534     // status from now on.  This destroys the nsStatusInfo and hence
 535     // removes it from our list.
 536     info->mLastStatus = nullptr;
 537
 538     int64_t oldMax = info->mMaxProgress;
 539
 540     info->mMaxProgress = info->mCurrentProgress;
 541
 542     //
 543     // If a request whose content-length was previously unknown has just
 544     // finished loading, then use this new data to try to calculate a
 545     // mMaxSelfProgress...
 546     //
 547     if ((oldMax < int64_t(0)) && (mMaxSelfProgress < int64_t(0))) {
 548       mMaxSelfProgress = CalculateMaxProgress();
 549     }
 550
 551     // As we know the total progress of this request now, save it to be part
 552     // of CalculateMaxProgress() result. We need to remove the info from the
 553     // hash, see bug 480713.
 554     mCompletedTotalProgress += info->mMaxProgress;
 555
 556     //
 557     // Determine whether a STATE_TRANSFERRING notification should be
 558     // 'synthesized'.
 559     //
 560     // If nsRequestInfo::mMaxProgress (as stored in oldMax) and
 561     // nsRequestInfo::mCurrentProgress are both 0, then the
 562     // STATE_TRANSFERRING notification has not been fired yet...
 563     //
 564     if ((oldMax == 0) && (info->mCurrentProgress == 0)) {
 565       nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
 566
 567       // Only fire a TRANSFERRING notification if the request is also a
 568       // channel -- data transfer requires a nsIChannel!
 569       //
 570       if (channel) {
 571         if (NS_SUCCEEDED(aStatus)) {
 572           bFireTransferring = true;
 573         }
 574         //
 575         // If the request failed (for any reason other than being
 576         // redirected or retargeted), the TRANSFERRING notification can
 577         // still be fired if a HTTP connection was established to a server.
 578         //
 579         else if (aStatus != NS_BINDING_REDIRECTED &&
 580                  aStatus != NS_BINDING_RETARGETED) {
 581           //
 582           // Only if the load has been targeted (see bug 268483)...
 583           //
 584           uint32_t lf;
 585           channel->GetLoadFlags(&lf);
 586           if (lf & nsIChannel::LOAD_TARGETED) {
 587             nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aRequest));
 588             if (httpChannel) {
 589               uint32_t responseCode;
 590               rv = httpChannel->GetResponseStatus(&responseCode);
 591               if (NS_SUCCEEDED(rv)) {
 592                 //
 593                 // A valid server status indicates that a connection was
 594                 // established to the server... So, fire the notification
 595                 // even though a failure occurred later...
 596                 //
 597                 bFireTransferring = true;
 598               }
 599             }
 600           }
 601         }
 602       }
 603     }
 604   }
 605
 606   if (bFireTransferring) {
 607     // Send a STATE_TRANSFERRING notification for the request.
 608     int32_t flags;
 609
 610     flags = nsIWebProgressListener::STATE_TRANSFERRING |
 611             nsIWebProgressListener::STATE_IS_REQUEST;
 612     //
 613     // Move the WebProgress into the STATE_TRANSFERRING state if necessary...
 614     //
 615     if (mProgressStateFlags & nsIWebProgressListener::STATE_START) {
 616       mProgressStateFlags = nsIWebProgressListener::STATE_TRANSFERRING;
 617
 618       // Send STATE_TRANSFERRING for the document too...
 619       flags |= nsIWebProgressListener::STATE_IS_DOCUMENT;
 620     }
 621
 622     FireOnStateChange(this, aRequest, flags, NS_OK);
 623   }
 624
 625   //
 626   // Fire the OnStateChange(...) notification for stop request
 627   //
 628   doStopURLLoad(aRequest, aStatus);
 629
 630   // Clear this request out of the hash to avoid bypass of FireOnStateChange
 631   // when address of the request is reused.
 632   RemoveRequestInfo(aRequest);
 633
 634   //
 635   // Only fire the DocLoaderIsEmpty(...) if the document loader has initiated a
 636   // load.  This will handle removing the request from our hashtable as needed.
 637   //
 638   if (mIsLoadingDocument) {
 639     DocLoaderIsEmpty(true);
 640   }
 641
 642   return NS_OK;
 643 }
 644
 645
 646 nsresult nsDocLoader::RemoveChildLoader(nsDocLoader* aChild)
 647 {
 648   nsresult rv = mChildList.RemoveElement(aChild) ? NS_OK : NS_ERROR_FAILURE;
 649   if (NS_SUCCEEDED(rv)) {
 650     aChild->SetDocLoaderParent(nullptr);
 651   }
 652   return rv;
 653 }
 654
 655 nsresult nsDocLoader::AddChildLoader(nsDocLoader* aChild)
 656 {
 657   nsresult rv = mChildList.AppendElement(aChild) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 658   if (NS_SUCCEEDED(rv)) {
 659     aChild->SetDocLoaderParent(this);
 660   }
 661   return rv;
 662 }
 663
 664 NS_IMETHODIMP nsDocLoader::GetDocumentChannel(nsIChannel ** aChannel)
 665 {
 666   if (!mDocumentRequest) {
 667     *aChannel = nullptr;
 668     return NS_OK;
 669   }
 670
 671   return CallQueryInterface(mDocumentRequest, aChannel);
 672 }
 673
 674
 675 void nsDocLoader::DocLoaderIsEmpty(bool aFlushLayout)
 676 {
 677   if (mIsLoadingDocument) {
 678     /* In the unimagineably rude circumstance that onload event handlers
 679        triggered by this function actually kill the window ... ok, it's
 680        not unimagineable; it's happened ... this deathgrip keeps this object
 681        alive long enough to survive this function call. */
 682     nsCOMPtr<nsIDocumentLoader> kungFuDeathGrip(this);
 683
 684     // Don't flush layout if we're still busy.
 685     if (IsBusy()) {
 686       return;
 687     }
 688
 689     NS_ASSERTION(!mIsFlushingLayout, "Someone screwed up");
 690
 691     // The load group for this DocumentLoader is idle.  Flush if we need to.
 692     if (aFlushLayout && !mDontFlushLayout) {
 693       nsCOMPtr<nsIDOMDocument> domDoc = do_GetInterface(GetAsSupports(this));
 694       nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
 695       if (doc) {
 696         // We start loads from style resolution, so we need to flush out style
 697         // no matter what.  If we have user fonts, we also need to flush layout,
 698         // since the reflow is what starts font loads.
 699         mozFlushType flushType = Flush_Style;
 700         nsIPresShell* shell = doc->GetShell();
 701         if (shell) {
 702           // Be safe in case this presshell is in teardown now
 703           nsPresContext* presContext = shell->GetPresContext();
 704           if (presContext && presContext->GetUserFontSet()) {
 705             flushType = Flush_Layout;
 706           }
 707         }
 708         mDontFlushLayout = mIsFlushingLayout = true;
 709         doc->FlushPendingNotifications(flushType);
 710         mDontFlushLayout = mIsFlushingLayout = false;
 711       }
 712     }
 713
 714     // And now check whether we're really busy; that might have changed with
 715     // the layout flush.
 716     if (!IsBusy()) {
 717       // Clear out our request info hash, now that our load really is done and
 718       // we don't need it anymore to CalculateMaxProgress().
 719       ClearInternalProgress();
 720
 721       PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 722              ("DocLoader:%p: Is now idle...\n", this));
 723
 724       nsCOMPtr<nsIRequest> docRequest = mDocumentRequest;
 725
 726       NS_ASSERTION(mDocumentRequest, "No Document Request!");
 727       mDocumentRequest = 0;
 728       mIsLoadingDocument = false;
 729
 730       // Update the progress status state - the document is done
 731       mProgressStateFlags = nsIWebProgressListener::STATE_STOP;
 732
 733
 734       nsresult loadGroupStatus = NS_OK;
 735       mLoadGroup->GetStatus(&loadGroupStatus);
 736
 737       //
 738       // New code to break the circular reference between
 739       // the load group and the docloader...
 740       //
 741       mLoadGroup->SetDefaultLoadRequest(nullptr);
 742
 743       // Take a ref to our parent now so that we can call DocLoaderIsEmpty() on
 744       // it even if our onload handler removes us from the docloader tree.
 745       nsRefPtr<nsDocLoader> parent = mParent;
 746
 747       // Note that if calling ChildEnteringOnload() on the parent returns false
 748       // then calling our onload handler is not safe.  That can only happen on
 749       // OOM, so that's ok.
 750       if (!parent || parent->ChildEnteringOnload(this)) {
 751         // Do nothing with our state after firing the
 752         // OnEndDocumentLoad(...). The document loader may be loading a *new*
 753         // document - if LoadDocument() was called from a handler!
 754         //
 755         doStopDocumentLoad(docRequest, loadGroupStatus);
 756
 757         if (parent) {
 758           parent->ChildDoneWithOnload(this);
 759         }
 760       }
 761     }
 762   }
 763 }
 764
 765 void nsDocLoader::doStartDocumentLoad(void)
 766 {
 767
 768 #if defined(DEBUG)
 769   nsAutoCString buffer;
 770
 771   GetURIStringFromRequest(mDocumentRequest, buffer);
 772   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 773          ("DocLoader:%p: ++ Firing OnStateChange for start document load (...)."
 774           "\tURI: %s \n",
 775           this, buffer.get()));
 776 #endif /* DEBUG */
 777
 778   // Fire an OnStatus(...) notification STATE_START.  This indicates
 779   // that the document represented by mDocumentRequest has started to
 780   // load...
 781   FireOnStateChange(this,
 782                     mDocumentRequest,
 783                     nsIWebProgressListener::STATE_START |
 784                     nsIWebProgressListener::STATE_IS_DOCUMENT |
 785                     nsIWebProgressListener::STATE_IS_REQUEST |
 786                     nsIWebProgressListener::STATE_IS_WINDOW |
 787                     nsIWebProgressListener::STATE_IS_NETWORK,
 788                     NS_OK);
 789 }
 790
 791 void nsDocLoader::doStartURLLoad(nsIRequest *request)
 792 {
 793 #if defined(DEBUG)
 794   nsAutoCString buffer;
 795
 796   GetURIStringFromRequest(request, buffer);
 797     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 798           ("DocLoader:%p: ++ Firing OnStateChange start url load (...)."
 799            "\tURI: %s\n",
 800             this, buffer.get()));
 801 #endif /* DEBUG */
 802
 803   FireOnStateChange(this,
 804                     request,
 805                     nsIWebProgressListener::STATE_START |
 806                     nsIWebProgressListener::STATE_IS_REQUEST,
 807                     NS_OK);
 808 }
 809
 810 void nsDocLoader::doStopURLLoad(nsIRequest *request, nsresult aStatus)
 811 {
 812 #if defined(DEBUG)
 813   nsAutoCString buffer;
 814
 815   GetURIStringFromRequest(request, buffer);
 816     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 817           ("DocLoader:%p: ++ Firing OnStateChange for end url load (...)."
 818            "\tURI: %s status=%x\n",
 819             this, buffer.get(), aStatus));
 820 #endif /* DEBUG */
 821
 822   FireOnStateChange(this,
 823                     request,
 824                     nsIWebProgressListener::STATE_STOP |
 825                     nsIWebProgressListener::STATE_IS_REQUEST,
 826                     aStatus);
 827
 828   // Fire a status change message for the most recent unfinished
 829   // request to make sure that the displayed status is not outdated.
 830   if (!mStatusInfoList.isEmpty()) {
 831     nsStatusInfo* statusInfo = mStatusInfoList.getFirst();
 832     FireOnStatusChange(this, statusInfo->mRequest,
 833                        statusInfo->mStatusCode,
 834                        statusInfo->mStatusMessage.get());
 835   }
 836 }
 837
 838 void nsDocLoader::doStopDocumentLoad(nsIRequest *request,
 839                                          nsresult aStatus)
 840 {
 841 #if defined(DEBUG)
 842   nsAutoCString buffer;
 843
 844   GetURIStringFromRequest(request, buffer);
 845   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
 846          ("DocLoader:%p: ++ Firing OnStateChange for end document load (...)."
 847          "\tURI: %s Status=%x\n",
 848           this, buffer.get(), aStatus));
 849 #endif /* DEBUG */
 850
 851   // Firing STATE_STOP|STATE_IS_DOCUMENT will fire onload handlers.
 852   // Grab our parent chain before doing that so we can still dispatch
 853   // STATE_STOP|STATE_IS_WINDW_STATE_IS_NETWORK to them all, even if
 854   // the onload handlers rearrange the docshell tree.
 855   WebProgressList list;
 856   GatherAncestorWebProgresses(list);
 857
 858   //
 859   // Fire an OnStateChange(...) notification indicating the the
 860   // current document has finished loading...
 861   //
 862   int32_t flags = nsIWebProgressListener::STATE_STOP |
 863                   nsIWebProgressListener::STATE_IS_DOCUMENT;
 864   for (uint32_t i = 0; i < list.Length(); ++i) {
 865     list[i]->DoFireOnStateChange(this, request, flags, aStatus);
 866   }
 867
 868   //
 869   // Fire a final OnStateChange(...) notification indicating the the
 870   // current document has finished loading...
 871   //
 872   flags = nsIWebProgressListener::STATE_STOP |
 873           nsIWebProgressListener::STATE_IS_WINDOW |
 874           nsIWebProgressListener::STATE_IS_NETWORK;
 875   for (uint32_t i = 0; i < list.Length(); ++i) {
 876     list[i]->DoFireOnStateChange(this, request, flags, aStatus);
 877   }
 878 }
 879
 880 ////////////////////////////////////////////////////////////////////////////////////
 881 // The following section contains support for nsIWebProgress and related stuff
 882 ////////////////////////////////////////////////////////////////////////////////////
 883
 884 NS_IMETHODIMP
 885 nsDocLoader::AddProgressListener(nsIWebProgressListener *aListener,
 886                                      uint32_t aNotifyMask)
 887 {
 888   nsresult rv;
 889
 890   nsListenerInfo* info = GetListenerInfo(aListener);
 891   if (info) {
 892     // The listener is already registered!
 893     return NS_ERROR_FAILURE;
 894   }
 895
 896   nsWeakPtr listener = do_GetWeakReference(aListener);
 897   if (!listener) {
 898     return NS_ERROR_INVALID_ARG;
 899   }
 900
 901   info = new nsListenerInfo(listener, aNotifyMask);
 902   if (!info) {
 903     return NS_ERROR_OUT_OF_MEMORY;
 904   }
 905
 906   rv = mListenerInfoList.AppendElement(info) ? NS_OK : NS_ERROR_FAILURE;
 907   return rv;
 908 }
 909
 910 NS_IMETHODIMP
 911 nsDocLoader::RemoveProgressListener(nsIWebProgressListener *aListener)
 912 {
 913   nsresult rv;
 914
 915   nsListenerInfo* info = GetListenerInfo(aListener);
 916   if (info) {
 917     rv = mListenerInfoList.RemoveElement(info) ? NS_OK : NS_ERROR_FAILURE;
 918     delete info;
 919   } else {
 920     // The listener is not registered!
 921     rv = NS_ERROR_FAILURE;
 922   }
 923   return rv;
 924 }
 925
 926 NS_IMETHODIMP
 927 nsDocLoader::GetDOMWindow(nsIDOMWindow **aResult)
 928 {
 929   return CallGetInterface(this, aResult);
 930 }
 931
 932 NS_IMETHODIMP
 933 nsDocLoader::GetDOMWindowID(uint64_t *aResult)
 934 {
 935   *aResult = 0;
 936
 937   nsCOMPtr<nsIDOMWindow> window;
 938   nsresult rv = GetDOMWindow(getter_AddRefs(window));
 939   NS_ENSURE_SUCCESS(rv, rv);
 940
 941   nsCOMPtr<nsPIDOMWindow> piwindow = do_QueryInterface(window);
 942   NS_ENSURE_STATE(piwindow);
 943
 944   MOZ_ASSERT(piwindow->IsOuterWindow());
 945   *aResult = piwindow->WindowID();
 946   return NS_OK;
 947 }
 948
 949 NS_IMETHODIMP
 950 nsDocLoader::GetIsTopLevel(bool *aResult)
 951 {
 952   *aResult = false;
 953
 954   nsCOMPtr<nsIDOMWindow> window;
 955   GetDOMWindow(getter_AddRefs(window));
 956   if (window) {
 957     nsCOMPtr<nsPIDOMWindow> piwindow = do_QueryInterface(window);
 958     NS_ENSURE_STATE(piwindow);
 959
 960     nsCOMPtr<nsIDOMWindow> topWindow;
 961     nsresult rv = piwindow->GetTop(getter_AddRefs(topWindow));
 962     NS_ENSURE_SUCCESS(rv, rv);
 963
 964     *aResult = piwindow == topWindow;
 965   }
 966
 967   return NS_OK;
 968 }
 969
 970 NS_IMETHODIMP
 971 nsDocLoader::GetIsLoadingDocument(bool *aIsLoadingDocument)
 972 {
 973   *aIsLoadingDocument = mIsLoadingDocument;
 974
 975   return NS_OK;
 976 }
 977
 978 NS_IMETHODIMP
 979 nsDocLoader::GetLoadType(uint32_t *aLoadType)
 980 {
 981   *aLoadType = 0;
 982
 983   return NS_ERROR_NOT_IMPLEMENTED;
 984 }
 985
 986 int64_t nsDocLoader::GetMaxTotalProgress()
 987 {
 988   int64_t newMaxTotal = 0;
 989
 990   uint32_t count = mChildList.Length();
 991   nsCOMPtr<nsIWebProgress> webProgress;
 992   for (uint32_t i=0; i < count; i++)
 993   {
 994     int64_t individualProgress = 0;
 995     nsIDocumentLoader* docloader = ChildAt(i);
 996     if (docloader)
 997     {
 998       // Cast is safe since all children are nsDocLoader too
 999       individualProgress = ((nsDocLoader *) docloader)->GetMaxTotalProgress();
1000     }
1001     if (individualProgress < int64_t(0)) // if one of the elements doesn't know it's size
1002                                          // then none of them do
1003     {
1004        newMaxTotal = int64_t(-1);
1005        break;
1006     }
1007     else
1008      newMaxTotal += individualProgress;
1009   }
1010
1011   int64_t progress = -1;
1012   if (mMaxSelfProgress >= int64_t(0) && newMaxTotal >= int64_t(0))
1013     progress = newMaxTotal + mMaxSelfProgress;
1014
1015   return progress;
1016 }
1017
1018 ////////////////////////////////////////////////////////////////////////////////////
1019 // The following section contains support for nsIProgressEventSink which is used to
1020 // pass progress and status between the actual request and the doc loader. The doc loader
1021 // then turns around and makes the right web progress calls based on this information.
1022 ////////////////////////////////////////////////////////////////////////////////////
1023
1024 NS_IMETHODIMP nsDocLoader::OnProgress(nsIRequest *aRequest, nsISupports* ctxt,
1025                                       uint64_t aProgress, uint64_t aProgressMax)
1026 {
1027   nsRequestInfo *info;
1028   int64_t progressDelta = 0;
1029
1030   //
1031   // Update the RequestInfo entry with the new progress data
1032   //
1033   info = GetRequestInfo(aRequest);
1034   if (info) {
1035     // suppress sending STATE_TRANSFERRING if this is upload progress (see bug 240053)
1036     if (!info->mUploading && (int64_t(0) == info->mCurrentProgress) && (int64_t(0) == info->mMaxProgress)) {
1037       //
1038       // If we receive an OnProgress event from a toplevel channel that the URI Loader
1039       // has not yet targeted, then we must suppress the event.  This is necessary to
1040       // ensure that webprogresslisteners do not get confused when the channel is
1041       // finally targeted.  See bug 257308.
1042       //
1043       nsLoadFlags lf = 0;
1044       aRequest->GetLoadFlags(&lf);
1045       if ((lf & nsIChannel::LOAD_DOCUMENT_URI) && !(lf & nsIChannel::LOAD_TARGETED)) {
1046         PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
1047             ("DocLoader:%p Ignoring OnProgress while load is not targeted\n", this));
1048         return NS_OK;
1049       }
1050
1051       //
1052       // This is the first progress notification for the entry.  If
1053       // (aMaxProgress > 0) then the content-length of the data is known,
1054       // so update mMaxSelfProgress...  Otherwise, set it to -1 to indicate
1055       // that the content-length is no longer known.
1056       //
1057       if (uint64_t(aProgressMax) != UINT64_MAX) {
1058         mMaxSelfProgress  += int64_t(aProgressMax);
1059         info->mMaxProgress = int64_t(aProgressMax);
1060       } else {
1061         mMaxSelfProgress   =  int64_t(-1);
1062         info->mMaxProgress =  int64_t(-1);
1063       }
1064
1065       // Send a STATE_TRANSFERRING notification for the request.
1066       int32_t flags;
1067
1068       flags = nsIWebProgressListener::STATE_TRANSFERRING |
1069               nsIWebProgressListener::STATE_IS_REQUEST;
1070       //
1071       // Move the WebProgress into the STATE_TRANSFERRING state if necessary...
1072       //
1073       if (mProgressStateFlags & nsIWebProgressListener::STATE_START) {
1074         mProgressStateFlags = nsIWebProgressListener::STATE_TRANSFERRING;
1075
1076         // Send STATE_TRANSFERRING for the document too...
1077         flags |= nsIWebProgressListener::STATE_IS_DOCUMENT;
1078       }
1079
1080       FireOnStateChange(this, aRequest, flags, NS_OK);
1081     }
1082
1083     // Update the current progress count...
1084     progressDelta = int64_t(aProgress) - info->mCurrentProgress;
1085     mCurrentSelfProgress += progressDelta;
1086
1087     info->mCurrentProgress = int64_t(aProgress);
1088   }
1089   //
1090   // The request is not part of the load group, so ignore its progress
1091   // information...
1092   //
1093   else {
1094 #if defined(DEBUG)
1095     nsAutoCString buffer;
1096
1097     GetURIStringFromRequest(aRequest, buffer);
1098     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
1099            ("DocLoader:%p OOPS - No Request Info for: %s\n",
1100             this, buffer.get()));
1101 #endif /* DEBUG */
1102
1103     return NS_OK;
1104   }
1105
1106   //
1107   // Fire progress notifications out to any registered nsIWebProgressListeners
1108   //
1109   FireOnProgressChange(this, aRequest, aProgress, aProgressMax, progressDelta,
1110                        mCurrentTotalProgress, mMaxTotalProgress);
1111
1112   return NS_OK;
1113 }
1114
1115 NS_IMETHODIMP nsDocLoader::OnStatus(nsIRequest* aRequest, nsISupports* ctxt,
1116                                         nsresult aStatus, const char16_t* aStatusArg)
1117 {
1118   //
1119   // Fire progress notifications out to any registered nsIWebProgressListeners
1120   //
1121   if (aStatus != NS_OK) {
1122     // Remember the current status for this request
1123     nsRequestInfo *info;
1124     info = GetRequestInfo(aRequest);
1125     if (info) {
1126       bool uploading = (aStatus == NS_NET_STATUS_WRITING ||
1127                         aStatus == NS_NET_STATUS_SENDING_TO);
1128       // If switching from uploading to downloading (or vice versa), then we
1129       // need to reset our progress counts.  This is designed with HTTP form
1130       // submission in mind, where an upload is performed followed by download
1131       // of possibly several documents.
1132       if (info->mUploading != uploading) {
1133         mCurrentSelfProgress  = mMaxSelfProgress  = 0;
1134         mCurrentTotalProgress = mMaxTotalProgress = 0;
1135         mCompletedTotalProgress = 0;
1136         info->mUploading = uploading;
1137         info->mCurrentProgress = 0;
1138         info->mMaxProgress = 0;
1139       }
1140     }
1141
1142     nsCOMPtr<nsIStringBundleService> sbs =
1143       mozilla::services::GetStringBundleService();
1144     if (!sbs)
1145       return NS_ERROR_FAILURE;
1146     nsXPIDLString msg;
1147     nsresult rv = sbs->FormatStatusMessage(aStatus, aStatusArg,
1148                                            getter_Copies(msg));
1149     if (NS_FAILED(rv))
1150       return rv;
1151
1152     // Keep around the message. In case a request finishes, we need to make sure
1153     // to send the status message of another request to our user to that we
1154     // don't display, for example, "Transferring" messages for requests that are
1155     // already done.
1156     if (info) {
1157       if (!info->mLastStatus) {
1158         info->mLastStatus = new nsStatusInfo(aRequest);
1159       } else {
1160         // We're going to move it to the front of the list, so remove
1161         // it from wherever it is now.
1162         info->mLastStatus->remove();
1163       }
1164       info->mLastStatus->mStatusMessage = msg;
1165       info->mLastStatus->mStatusCode = aStatus;
1166       // Put the info at the front of the list
1167       mStatusInfoList.insertFront(info->mLastStatus);
1168     }
1169     FireOnStatusChange(this, aRequest, aStatus, msg);
1170   }
1171   return NS_OK;
1172 }
1173
1174 void nsDocLoader::ClearInternalProgress()
1175 {
1176   ClearRequestInfoHash();
1177
1178   mCurrentSelfProgress  = mMaxSelfProgress  = 0;
1179   mCurrentTotalProgress = mMaxTotalProgress = 0;
1180   mCompletedTotalProgress = 0;
1181
1182   mProgressStateFlags = nsIWebProgressListener::STATE_STOP;
1183 }
1184
1185
1186 void nsDocLoader::FireOnProgressChange(nsDocLoader *aLoadInitiator,
1187                                        nsIRequest *request,
1188                                        int64_t aProgress,
1189                                        int64_t aProgressMax,
1190                                        int64_t aProgressDelta,
1191                                        int64_t aTotalProgress,
1192                                        int64_t aMaxTotalProgress)
1193 {
1194   if (mIsLoadingDocument) {
1195     mCurrentTotalProgress += aProgressDelta;
1196     mMaxTotalProgress = GetMaxTotalProgress();
1197
1198     aTotalProgress    = mCurrentTotalProgress;
1199     aMaxTotalProgress = mMaxTotalProgress;
1200   }
1201
1202 #if defined(DEBUG)
1203   nsAutoCString buffer;
1204
1205   GetURIStringFromRequest(request, buffer);
1206   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
1207          ("DocLoader:%p: Progress (%s): curSelf: %d maxSelf: %d curTotal: %d maxTotal %d\n",
1208           this, buffer.get(), aProgress, aProgressMax, aTotalProgress, aMaxTotalProgress));
1209 #endif /* DEBUG */
1210
1211   /*
1212    * First notify any listeners of the new progress info...
1213    *
1214    * Operate the elements from back to front so that if items get
1215    * get removed from the list it won't affect our iteration
1216    */
1217   nsCOMPtr<nsIWebProgressListener> listener;
1218   int32_t count = mListenerInfoList.Count();
1219
1220   while (--count >= 0) {
1221     nsListenerInfo *info;
1222
1223     info = static_cast<nsListenerInfo*>(mListenerInfoList.SafeElementAt(count));
1224     if (!info || !(info->mNotifyMask & nsIWebProgress::NOTIFY_PROGRESS)) {
1225       continue;
1226     }
1227
1228     listener = do_QueryReferent(info->mWeakListener);
1229     if (!listener) {
1230       // the listener went away. gracefully pull it out of the list.
1231       mListenerInfoList.RemoveElementAt(count);
1232       delete info;
1233       continue;
1234     }
1235
1236     // XXX truncates 64-bit to 32-bit
1237     listener->OnProgressChange(aLoadInitiator,request,
1238                                int32_t(aProgress), int32_t(aProgressMax),
1239                                int32_t(aTotalProgress), int32_t(aMaxTotalProgress));
1240   }
1241
1242   mListenerInfoList.Compact();
1243
1244   // Pass the notification up to the parent...
1245   if (mParent) {
1246     mParent->FireOnProgressChange(aLoadInitiator, request,
1247                                   aProgress, aProgressMax,
1248                                   aProgressDelta,
1249                                   aTotalProgress, aMaxTotalProgress);
1250   }
1251 }
1252
1253 void nsDocLoader::GatherAncestorWebProgresses(WebProgressList& aList)
1254 {
1255   for (nsDocLoader* loader = this; loader; loader = loader->mParent) {
1256     aList.AppendElement(loader);
1257   }
1258 }
1259
1260 void nsDocLoader::FireOnStateChange(nsIWebProgress *aProgress,
1261                                     nsIRequest *aRequest,
1262                                     int32_t aStateFlags,
1263                                     nsresult aStatus)
1264 {
1265   WebProgressList list;
1266   GatherAncestorWebProgresses(list);
1267   for (uint32_t i = 0; i < list.Length(); ++i) {
1268     list[i]->DoFireOnStateChange(aProgress, aRequest, aStateFlags, aStatus);
1269   }
1270 }
1271
1272 void nsDocLoader::DoFireOnStateChange(nsIWebProgress * const aProgress,
1273                                       nsIRequest * const aRequest,
1274                                       int32_t &aStateFlags,
1275                                       const nsresult aStatus)
1276 {
1277   //
1278   // Remove the STATE_IS_NETWORK bit if necessary.
1279   //
1280   // The rule is to remove this bit, if the notification has been passed
1281   // up from a child WebProgress, and the current WebProgress is already
1282   // active...
1283   //
1284   if (mIsLoadingDocument &&
1285       (aStateFlags & nsIWebProgressListener::STATE_IS_NETWORK) &&
1286       (this != aProgress)) {
1287     aStateFlags &= ~nsIWebProgressListener::STATE_IS_NETWORK;
1288   }
1289
1290   // Add the STATE_RESTORING bit if necessary.
1291   if (mIsRestoringDocument)
1292     aStateFlags |= nsIWebProgressListener::STATE_RESTORING;
1293
1294 #if defined(DEBUG)
1295   nsAutoCString buffer;
1296
1297   GetURIStringFromRequest(aRequest, buffer);
1298   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
1299          ("DocLoader:%p: Status (%s): code: %x\n",
1300          this, buffer.get(), aStateFlags));
1301 #endif /* DEBUG */
1302
1303   NS_ASSERTION(aRequest, "Firing OnStateChange(...) notification with a NULL request!");
1304
1305   /*
1306    * First notify any listeners of the new state info...
1307    *
1308    * Operate the elements from back to front so that if items get
1309    * get removed from the list it won't affect our iteration
1310    */
1311   nsCOMPtr<nsIWebProgressListener> listener;
1312   int32_t count = mListenerInfoList.Count();
1313   int32_t notifyMask = (aStateFlags >> 16) & nsIWebProgress::NOTIFY_STATE_ALL;
1314
1315   while (--count >= 0) {
1316     nsListenerInfo *info;
1317
1318     info = static_cast<nsListenerInfo*>(mListenerInfoList.SafeElementAt(count));
1319     if (!info || !(info->mNotifyMask & notifyMask)) {
1320       continue;
1321     }
1322
1323     listener = do_QueryReferent(info->mWeakListener);
1324     if (!listener) {
1325       // the listener went away. gracefully pull it out of the list.
1326       mListenerInfoList.RemoveElementAt(count);
1327       delete info;
1328       continue;
1329     }
1330
1331     listener->OnStateChange(aProgress, aRequest, aStateFlags, aStatus);
1332   }
1333
1334   mListenerInfoList.Compact();
1335 }
1336
1337
1338
1339 void
1340 nsDocLoader::FireOnLocationChange(nsIWebProgress* aWebProgress,
1341                                   nsIRequest* aRequest,
1342                                   nsIURI *aUri,
1343                                   uint32_t aFlags)
1344 {
1345   /*
1346    * First notify any listeners of the new state info...
1347    *
1348    * Operate the elements from back to front so that if items get
1349    * get removed from the list it won't affect our iteration
1350    */
1351   nsCOMPtr<nsIWebProgressListener> listener;
1352   int32_t count = mListenerInfoList.Count();
1353
1354   while (--count >= 0) {
1355     nsListenerInfo *info;
1356
1357     info = static_cast<nsListenerInfo*>(mListenerInfoList.SafeElementAt(count));
1358     if (!info || !(info->mNotifyMask & nsIWebProgress::NOTIFY_LOCATION)) {
1359       continue;
1360     }
1361
1362     listener = do_QueryReferent(info->mWeakListener);
1363     if (!listener) {
1364       // the listener went away. gracefully pull it out of the list.
1365       mListenerInfoList.RemoveElementAt(count);
1366       delete info;
1367       continue;
1368     }
1369
1370     PR_LOG(gDocLoaderLog, PR_LOG_DEBUG, ("DocLoader [%p] calling %p->OnLocationChange", this, listener.get()));
1371     listener->OnLocationChange(aWebProgress, aRequest, aUri, aFlags);
1372   }
1373
1374   mListenerInfoList.Compact();
1375
1376   // Pass the notification up to the parent...
1377   if (mParent) {
1378     mParent->FireOnLocationChange(aWebProgress, aRequest, aUri, aFlags);
1379   }
1380 }
1381
1382 void
1383 nsDocLoader::FireOnStatusChange(nsIWebProgress* aWebProgress,
1384                                 nsIRequest* aRequest,
1385                                 nsresult aStatus,
1386                                 const char16_t* aMessage)
1387 {
1388   /*
1389    * First notify any listeners of the new state info...
1390    *
1391    * Operate the elements from back to front so that if items get
1392    * get removed from the list it won't affect our iteration
1393    */
1394   nsCOMPtr<nsIWebProgressListener> listener;
1395   int32_t count = mListenerInfoList.Count();
1396
1397   while (--count >= 0) {
1398     nsListenerInfo *info;
1399
1400     info = static_cast<nsListenerInfo*>(mListenerInfoList.SafeElementAt(count));
1401     if (!info || !(info->mNotifyMask & nsIWebProgress::NOTIFY_STATUS)) {
1402       continue;
1403     }
1404
1405     listener = do_QueryReferent(info->mWeakListener);
1406     if (!listener) {
1407       // the listener went away. gracefully pull it out of the list.
1408       mListenerInfoList.RemoveElementAt(count);
1409       delete info;
1410       continue;
1411     }
1412
1413     listener->OnStatusChange(aWebProgress, aRequest, aStatus, aMessage);
1414   }
1415   mListenerInfoList.Compact();
1416
1417   // Pass the notification up to the parent...
1418   if (mParent) {
1419     mParent->FireOnStatusChange(aWebProgress, aRequest, aStatus, aMessage);
1420   }
1421 }
1422
1423 bool
1424 nsDocLoader::RefreshAttempted(nsIWebProgress* aWebProgress,
1425                               nsIURI *aURI,
1426                               int32_t aDelay,
1427                               bool aSameURI)
1428 {
1429   /*
1430    * Returns true if the refresh may proceed,
1431    * false if the refresh should be blocked.
1432    *
1433    * First notify any listeners of the refresh attempt...
1434    *
1435    * Iterate the elements from back to front so that if items
1436    * get removed from the list it won't affect our iteration
1437    */
1438   bool allowRefresh = true;
1439   int32_t count = mListenerInfoList.Count();
1440
1441   while (--count >= 0) {
1442     nsListenerInfo *info;
1443
1444     info = static_cast<nsListenerInfo*>(mListenerInfoList.SafeElementAt(count));
1445     if (!info || !(info->mNotifyMask & nsIWebProgress::NOTIFY_REFRESH)) {
1446       continue;
1447     }
1448
1449     nsCOMPtr<nsIWebProgressListener> listener =
1450       do_QueryReferent(info->mWeakListener);
1451     if (!listener) {
1452       // the listener went away. gracefully pull it out of the list.
1453       mListenerInfoList.RemoveElementAt(count);
1454       delete info;
1455       continue;
1456     }
1457
1458     nsCOMPtr<nsIWebProgressListener2> listener2 =
1459       do_QueryReferent(info->mWeakListener);
1460     if (!listener2)
1461       continue;
1462
1463     bool listenerAllowedRefresh;
1464     nsresult listenerRV = listener2->OnRefreshAttempted(
1465         aWebProgress, aURI, aDelay, aSameURI, &listenerAllowedRefresh);
1466     if (NS_FAILED(listenerRV))
1467       continue;
1468
1469     allowRefresh = allowRefresh && listenerAllowedRefresh;
1470   }
1471
1472   mListenerInfoList.Compact();
1473
1474   // Pass the notification up to the parent...
1475   if (mParent) {
1476     allowRefresh = allowRefresh &&
1477       mParent->RefreshAttempted(aWebProgress, aURI, aDelay, aSameURI);
1478   }
1479
1480   return allowRefresh;
1481 }
1482
1483 nsListenerInfo *
1484 nsDocLoader::GetListenerInfo(nsIWebProgressListener *aListener)
1485 {
1486   int32_t i, count;
1487   nsListenerInfo *info;
1488
1489   nsCOMPtr<nsISupports> listener1 = do_QueryInterface(aListener);
1490   count = mListenerInfoList.Count();
1491   for (i=0; i<count; i++) {
1492     info = static_cast<nsListenerInfo*>(mListenerInfoList.SafeElementAt(i));
1493
1494     NS_ASSERTION(info, "There should NEVER be a null listener in the list");
1495     if (info) {
1496       nsCOMPtr<nsISupports> listener2 = do_QueryReferent(info->mWeakListener);
1497       if (listener1 == listener2)
1498         return info;
1499     }
1500   }
1501   return nullptr;
1502 }
1503
1504 nsresult nsDocLoader::AddRequestInfo(nsIRequest *aRequest)
1505 {
1506   if (!PL_DHashTableOperate(&mRequestInfoHash, aRequest, PL_DHASH_ADD)) {
1507     return NS_ERROR_OUT_OF_MEMORY;
1508   }
1509
1510   return NS_OK;
1511 }
1512
1513 void nsDocLoader::RemoveRequestInfo(nsIRequest *aRequest)
1514 {
1515   PL_DHashTableOperate(&mRequestInfoHash, aRequest, PL_DHASH_REMOVE);
1516 }
1517
1518 nsDocLoader::nsRequestInfo* nsDocLoader::GetRequestInfo(nsIRequest* aRequest)
1519 {
1520   nsRequestInfo* info =
1521     static_cast<nsRequestInfo*>
1522                (PL_DHashTableOperate(&mRequestInfoHash, aRequest,
1523                                         PL_DHASH_LOOKUP));
1524
1525   if (PL_DHASH_ENTRY_IS_FREE(info)) {
1526     // Nothing found in the hash, return null.
1527
1528     return nullptr;
1529   }
1530
1531   // Return what we found in the hash...
1532
1533   return info;
1534 }
1535
1536 // PLDHashTable enumeration callback that just removes every entry
1537 // from the hash.
1538 static PLDHashOperator
1539 RemoveInfoCallback(PLDHashTable *table, PLDHashEntryHdr *hdr, uint32_t number,
1540                    void *arg)
1541 {
1542   return PL_DHASH_REMOVE;
1543 }
1544
1545 void nsDocLoader::ClearRequestInfoHash(void)
1546 {
1547   if (!mRequestInfoHash.ops || !mRequestInfoHash.entryCount) {
1548     // No hash, or the hash is empty, nothing to do here then...
1549
1550     return;
1551   }
1552
1553   PL_DHashTableEnumerate(&mRequestInfoHash, RemoveInfoCallback, nullptr);
1554 }
1555
1556 // PLDHashTable enumeration callback that calculates the max progress.
1557 PLDHashOperator
1558 nsDocLoader::CalcMaxProgressCallback(PLDHashTable* table, PLDHashEntryHdr* hdr,
1559                                      uint32_t number, void* arg)
1560 {
1561   const nsRequestInfo* info = static_cast<const nsRequestInfo*>(hdr);
1562   int64_t* max = static_cast<int64_t* >(arg);
1563
1564   if (info->mMaxProgress < info->mCurrentProgress) {
1565     *max = int64_t(-1);
1566
1567     return PL_DHASH_STOP;
1568   }
1569
1570   *max += info->mMaxProgress;
1571
1572   return PL_DHASH_NEXT;
1573 }
1574
1575 int64_t nsDocLoader::CalculateMaxProgress()
1576 {
1577   int64_t max = mCompletedTotalProgress;
1578   PL_DHashTableEnumerate(&mRequestInfoHash, CalcMaxProgressCallback, &max);
1579   return max;
1580 }
1581
1582 NS_IMETHODIMP nsDocLoader::AsyncOnChannelRedirect(nsIChannel *aOldChannel,
1583                                                   nsIChannel *aNewChannel,
1584                                                   uint32_t aFlags,
1585                                                   nsIAsyncVerifyRedirectCallback *cb)
1586 {
1587   if (aOldChannel)
1588   {
1589     nsLoadFlags loadFlags = 0;
1590     int32_t stateFlags = nsIWebProgressListener::STATE_REDIRECTING |
1591                          nsIWebProgressListener::STATE_IS_REQUEST;
1592
1593     aOldChannel->GetLoadFlags(&loadFlags);
1594     // If the document channel is being redirected, then indicate that the
1595     // document is being redirected in the notification...
1596     if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI)
1597     {
1598       stateFlags |= nsIWebProgressListener::STATE_IS_DOCUMENT;
1599
1600 #if defined(DEBUG)
1601       nsCOMPtr<nsIRequest> request(do_QueryInterface(aOldChannel));
1602       NS_ASSERTION(request == mDocumentRequest, "Wrong Document Channel");
1603 #endif /* DEBUG */
1604     }
1605
1606     OnRedirectStateChange(aOldChannel, aNewChannel, aFlags, stateFlags);
1607     FireOnStateChange(this, aOldChannel, stateFlags, NS_OK);
1608   }
1609
1610   cb->OnRedirectVerifyCallback(NS_OK);
1611   return NS_OK;
1612 }
1613
1614 /*
1615  * Implementation of nsISecurityEventSink method...
1616  */
1617
1618 NS_IMETHODIMP nsDocLoader::OnSecurityChange(nsISupports * aContext,
1619                                             uint32_t aState)
1620 {
1621   //
1622   // Fire progress notifications out to any registered nsIWebProgressListeners.
1623   //
1624
1625   nsCOMPtr<nsIRequest> request = do_QueryInterface(aContext);
1626   nsIWebProgress* webProgress = static_cast<nsIWebProgress*>(this);
1627
1628   /*
1629    * First notify any listeners of the new state info...
1630    *
1631    * Operate the elements from back to front so that if items get
1632    * get removed from the list it won't affect our iteration
1633    */
1634   nsCOMPtr<nsIWebProgressListener> listener;
1635   int32_t count = mListenerInfoList.Count();
1636
1637   while (--count >= 0) {
1638     nsListenerInfo *info;
1639
1640     info = static_cast<nsListenerInfo*>(mListenerInfoList.SafeElementAt(count));
1641     if (!info || !(info->mNotifyMask & nsIWebProgress::NOTIFY_SECURITY)) {
1642       continue;
1643     }
1644
1645     listener = do_QueryReferent(info->mWeakListener);
1646     if (!listener) {
1647       // the listener went away. gracefully pull it out of the list.
1648       mListenerInfoList.RemoveElementAt(count);
1649       delete info;
1650       continue;
1651     }
1652
1653     listener->OnSecurityChange(webProgress, request, aState);
1654   }
1655
1656   mListenerInfoList.Compact();
1657
1658   // Pass the notification up to the parent...
1659   if (mParent) {
1660     mParent->OnSecurityChange(aContext, aState);
1661   }
1662   return NS_OK;
1663 }
1664
1665 /*
1666  * Implementation of nsISupportsPriority methods...
1667  *
1668  * The priority of the DocLoader _is_ the priority of its LoadGroup.
1669  *
1670  * XXX(darin): Once we start storing loadgroups in loadgroups, this code will
1671  * go away.
1672  */
1673
1674 NS_IMETHODIMP nsDocLoader::GetPriority(int32_t *aPriority)
1675 {
1676   nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(mLoadGroup);
1677   if (p)
1678     return p->GetPriority(aPriority);
1679
1680   *aPriority = 0;
1681   return NS_OK;
1682 }
1683
1684 NS_IMETHODIMP nsDocLoader::SetPriority(int32_t aPriority)
1685 {
1686   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
1687          ("DocLoader:%p: SetPriority(%d) called\n", this, aPriority));
1688
1689   nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(mLoadGroup);
1690   if (p)
1691     p->SetPriority(aPriority);
1692
1693   NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(mChildList, nsDocLoader,
1694                                            SetPriority, (aPriority));
1695
1696   return NS_OK;
1697 }
1698
1699 NS_IMETHODIMP nsDocLoader::AdjustPriority(int32_t aDelta)
1700 {
1701   PR_LOG(gDocLoaderLog, PR_LOG_DEBUG,
1702          ("DocLoader:%p: AdjustPriority(%d) called\n", this, aDelta));
1703
1704   nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(mLoadGroup);
1705   if (p)
1706     p->AdjustPriority(aDelta);
1707
1708   NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(mChildList, nsDocLoader,
1709                                            AdjustPriority, (aDelta));
1710
1711   return NS_OK;
1712 }
1713
1714
1715
1716
1717 #if 0
1718 void nsDocLoader::DumpChannelInfo()
1719 {
1720   nsChannelInfo *info;
1721   int32_t i, count;
1722   int32_t current=0, max=0;
1723
1724
1725   printf("==== DocLoader=%x\n", this);
1726
1727   count = mChannelInfoList.Count();
1728   for(i=0; i<count; i++) {
1729     info = (nsChannelInfo *)mChannelInfoList.ElementAt(i);
1730
1731 #if defined(DEBUG)
1732     nsAutoCString buffer;
1733     nsresult rv = NS_OK;
1734     if (info->mURI) {
1735       rv = info->mURI->GetSpec(buffer);
1736     }
1737
1738     printf("  [%d] current=%d  max=%d [%s]\n", i,
1739            info->mCurrentProgress,
1740            info->mMaxProgress, buffer.get());
1741 #endif /* DEBUG */
1742
1743     current += info->mCurrentProgress;
1744     if (max >= 0) {
1745       if (info->mMaxProgress < info->mCurrentProgress) {
1746         max = -1;
1747       } else {
1748         max += info->mMaxProgress;
1749       }
1750     }
1751   }
1752
1753   printf("\nCurrent=%d   Total=%d\n====\n", current, max);
1754 }
1755 #endif /* 0 */