Move most of FrameLoader::CheckCompleted() to Document

third_party/WebKit/Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
@@ skipping 2769 matching lines @@
     return;
   parser_->Detach();
   parser_.Clear();
   DocumentParserTiming::From(*this).MarkParserDetached();
 }
 
 void Document::CancelParsing() {
   DetachParser();
   SetParsingState(kFinishedParsing);
   SetReadyState(kComplete);
+  SuppressLoadEvent();

[Nate Chapin, 2017/04/11 23:25:49]

Instead of the early-exit for a nullptr parser_ in Document::ImplicitClose().

 }
 
 DocumentParser* Document::ImplicitOpen(
     ParserSynchronizationPolicy parser_sync_policy) {
-  DetachParser();
-
   RemoveChildren();

[Nate Chapin, 2017/04/11 23:25:50]

This can trigger events, which can in turn call document.open()/document.close()
and cause reentrant parser state confusion. Just DetachParser() after.

   DCHECK(!focused_element_);
 
   SetCompatibilityMode(kNoQuirksMode);
 
   if (!ThreadedParsingEnabledForTesting()) {
     parser_sync_policy = kForceSynchronousParsing;
   } else if (parser_sync_policy == kAllowAsynchronousParsing &&
              IsPrefetchOnly()) {
     // Prefetch must be synchronous.
     parser_sync_policy = kForceSynchronousParsing;
   }
 
+  DetachParser();
   parser_sync_policy_ = parser_sync_policy;
   parser_ = CreateParser();
   DocumentParserTiming::From(*this).MarkParserStart();
   SetParsingState(kParsing);
   SetReadyState(kLoading);
 
   return parser_;
 }
 
 HTMLElement* Document::body() const {
@@ skipping 126 matching lines @@
 
   close();
 }
 
 void Document::close() {
   if (!GetScriptableDocumentParser() ||
       !GetScriptableDocumentParser()->WasCreatedByScript() ||
       !GetScriptableDocumentParser()->IsParsing())
     return;
 
-  if (DocumentParser* parser = parser_)
-    parser->Finish();
-
-  if (!frame_) {
-    // Because we have no frame, we don't know if all loading has completed,
-    // so we just call implicitClose() immediately. FIXME: This might fire
-    // the load event prematurely
-    // <http://bugs.webkit.org/show_bug.cgi?id=14568>.
-    ImplicitClose();
-    return;
-  }
-
-  frame_->Loader().CheckCompleted();
+  parser_->Finish();
+  if (!parser_ || !parser_->IsParsing())
+    SetReadyState(kComplete);

[Nate Chapin, 2017/04/11 23:25:50]

There are cases where we want to SetReadyState(kComplete) while
ProcessingLoadEvent() (wtf?)

Instead of making parts of CheckCompleted() re-entrant so that we can enable
this insanity, just call SetReadyState(kComplete) here, unless of course,
parser_->Finish() triggered an event that re-open()ed the Document.

+  CheckCompleted();
 }
 
 void Document::ImplicitClose() {
   DCHECK(!InStyleRecalc());
-  if (ProcessingLoadEvent() || !parser_)
-    return;
-  if (GetFrame() &&
-      GetFrame()->GetNavigationScheduler().LocationChangePending()) {
-    SuppressLoadEvent();
-    return;
-  }
+  DCHECK(parser_);
 
   load_event_progress_ = kLoadEventInProgress;
 
   ScriptableDocumentParser* parser = GetScriptableDocumentParser();
   well_formed_ = parser && parser->WellFormed();
 
   // We have to clear the parser, in case someone document.write()s from the
   // onLoad event handler, as in Radar 3206524.
   DetachParser();
 
@@ skipping 59 matching lines @@
     if (AXObjectCache* cache = AxObjectCache()) {
       if (this == &AxObjectCacheOwner())
         cache->HandleLoadComplete(this);
       else
         cache->HandleLayoutComplete(this);
     }
   }
 
   if (SvgExtensions())
     AccessSVGExtensions().StartAnimations();
+
+  View()->HandleLoadCompleted();

[Nate Chapin, 2017/04/11 23:25:50]

From FrameLoader::CheckCompleted(). It just needs to happen sometime around the
load event, not very timing-sensitive.

[yhirano, 2017/04/14 10:33:35]

Hmm, there are cases where this line is not executed.
 - LoadEventStillNeeded() may return false in CheckCompleted()
 - There are two early returns.

Could you give me some explanation why it's OK?

[Nate Chapin, 2017/04/18 21:56:38]

I'm not absolutely sure it's OK (though all the tests did pass), and it harms
nothing to return it to CheckCompleted(), so I'll do that.

+}
+
+static bool AllDescendantsAreComplete(Frame* frame) {
+  if (!frame)

[Nate Chapin, 2017/04/11 23:25:50]

Vacuously true! You can't have any descendants if you're already nullptr!

This cases needs to be handled in ShouldComplete() so that detached Documents
can fire onload, and doing it here means ShouldComplete() is all && clauses, no
paren-nesting required.

+    return true;
+  for (Frame* child = frame->Tree().FirstChild(); child;
+       child = child->Tree().TraverseNext(frame)) {
+    if (child->IsLoading())
+      return false;
+  }
+  return true;
+}
+
+bool Document::ShouldComplete() {
+  return parsing_state_ == kFinishedParsing && HaveImportsLoaded() &&
+         !fetcher_->BlockingRequestCount() && !IsDelayingLoadEvent() &&
+         load_event_progress_ != kLoadEventInProgress &&
+         AllDescendantsAreComplete(frame_);
+}
+
+void Document::CheckCompleted() {
+  if (!ShouldComplete())
+    return;
+
+  if (frame_) {
+    frame_->Client()->RunScriptsAtDocumentIdle();
+
+    // Injected scripts may have disconnected this frame.
+    if (!frame_)
+      return;
+
+    // Check again, because runScriptsAtDocumentIdle() may have delayed the load
+    // event.
+    if (!ShouldComplete())
+      return;
+  }
+
+  // OK, completed. Fire load completion events as needed.
+  SetReadyState(kComplete);
+  if (LoadEventStillNeeded())
+    ImplicitClose();
+
+  // The readystatechanged or load event may have disconnected this frame.
+  if (!frame_ || !frame_->IsAttached())
+    return;
+  frame_->GetNavigationScheduler().StartTimer();
+  // The document itself is complete, but if a child frame was restarted due to
+  // an event, this document is still considered to be in progress.
+  if (!AllDescendantsAreComplete(frame_))
+    return;
+
+  // No need to repeat if we've already notified this load as finished.
+  if (!Loader()->SentDidFinishLoad()) {
+    if (frame_->IsMainFrame())
+      ViewportDescription().ReportMobilePageStats(frame_);
+    Loader()->SetSentDidFinishLoad();
+    frame_->Client()->DispatchDidFinishLoad();
+    if (!frame_)
+      return;
+  }
+
+  frame_->Loader().DidFinishNavigation();
 }
 
 bool Document::DispatchBeforeUnloadEvent(ChromeClient& chrome_client,
                                          bool is_reload,
                                          bool& did_allow_navigation) {
   if (!dom_window_)
     return true;
 
   if (!body())
     return true;
@@ skipping 2896 matching lines @@
   --load_event_delay_count_;
 
   if (!load_event_delay_count_)
     CheckLoadEventSoon();
 }
 
 void Document::DecrementLoadEventDelayCountAndCheckLoadEvent() {
   DCHECK(load_event_delay_count_);
   --load_event_delay_count_;
 
   if (!load_event_delay_count_ && GetFrame())

[yhirano, 2017/04/14 10:33:35]

Is checking GetFrame() needed here?

[Nate Chapin, 2017/04/18 21:56:38]

This is needed to ensure the DCHECK(parser_) isn't triggered in CheckCompleted()
in the case where a Document *never* has a parser (cloneNode seems to be the
main way this can happen).

Instead of checking GetFrame() here, this patch now sets load_event_progress_ to
kLoadEventCompleted in the constructor, and moves resetting the progress to
kLoadEventNotRun to implicitOpen() instead of open(), so that it runs for
document.open() as well as parser creation during DocumentWriter initialization.

-    GetFrame()->Loader().CheckCompleted();
+    CheckCompleted();
 }
 
 void Document::CheckLoadEventSoon() {
   if (GetFrame() && !load_event_delay_timer_.IsActive())
     load_event_delay_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 bool Document::IsDelayingLoadEvent() {
   // Always delay load events until after garbage collection.
   // This way we don't have to explicitly delay load events via
   // incrementLoadEventDelayCount and decrementLoadEventDelayCount in
   // Node destructors.
   if (ThreadState::Current()->SweepForbidden()) {
     if (!load_event_delay_count_)
       CheckLoadEventSoon();
     return true;
   }
   return load_event_delay_count_;
 }
 
 void Document::LoadEventDelayTimerFired(TimerBase*) {
-  if (GetFrame())
-    GetFrame()->Loader().CheckCompleted();
+  CheckCompleted();
 }
 
 void Document::LoadPluginsSoon() {
   // FIXME: Remove this timer once we don't need to compute layout to load
   // plugins.
   if (!plugin_loading_timer_.IsActive())
     plugin_loading_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 void Document::PluginLoadingTimerFired(TimerBase*) {
@@ skipping 655 matching lines @@
 }
 
 void showLiveDocumentInstances() {
   WeakDocumentSet& set = liveDocumentSet();
   fprintf(stderr, "There are %u documents currently alive:\n", set.size());
   for (blink::Document* document : set)
     fprintf(stderr, "- Document %p URL: %s\n", document,
             document->Url().GetString().Utf8().Data());
 }
 #endif