Explicitly track the lifecycle of PendingScript.

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

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/ClassicPendingScript.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptStreamer.h"
 #include "bindings/core/v8/V8BindingForCore.h"
@@ skipping 13 matching lines @@
 ClassicPendingScript* ClassicPendingScript::Create(
     ScriptElementBase* element,
     const TextPosition& starting_position) {
   return new ClassicPendingScript(element, nullptr, starting_position);
 }
 
 ClassicPendingScript::ClassicPendingScript(
     ScriptElementBase* element,
     ScriptResource* resource,
     const TextPosition& starting_position)
-    : PendingScript(element, starting_position), integrity_failure_(false) {
+    : PendingScript(element, starting_position),
+      ready_state_(resource ? kWaitingForResource : kReady),
+      integrity_failure_(false) {
   CheckState();
   SetResource(resource);
   MemoryCoordinator::Instance().RegisterClient(this);
 }
 
 ClassicPendingScript::~ClassicPendingScript() {}
 
 NOINLINE void ClassicPendingScript::CheckState() const {
   // TODO(hiroshige): Turn these CHECK()s into DCHECK() before going to beta.
   CHECK(!prefinalizer_called_);
@@ skipping 15 matching lines @@
   SetResource(nullptr);
   integrity_failure_ = false;
   if (streamer_)
     streamer_->Cancel();
   streamer_ = nullptr;
 }
 
 void ClassicPendingScript::StreamingFinished() {
   CheckState();
   DCHECK(GetResource());
-  if (Client())
-    Client()->PendingScriptFinished(this);
+  DCHECK_EQ(ready_state_, kWaitingForStreaming);
+
+  bool error_occurred = GetResource()->ErrorOccurred() || integrity_failure_;
+  AdvanceReadyState(error_occurred ? kErrorOccurred : kReady);
 }
 
 // Returns true if SRI check passed.
 static bool CheckScriptResourceIntegrity(Resource* resource,
                                          ScriptElementBase* element) {
   DCHECK_EQ(resource->GetType(), Resource::kScript);
   ScriptResource* script_resource = ToScriptResource(resource);
   String integrity_attr = element->IntegrityAttributeValue();
 
   // It is possible to get back a script resource with integrity metadata
@@ skipping 55 matching lines @@
   // fetch JavaScript API. In a future world where the ResourceFetcher uses
   // the Fetch algorithm, this should be fixed by having separate Response
   // objects (perhaps attached to identical Resource objects) per request.
   //
   // See https://crbug.com/500701 for more information.
   CheckState();
   if (GetElement()) {
     integrity_failure_ = !CheckScriptResourceIntegrity(resource, GetElement());
   }
 
-  // If script streaming is in use, the client will be notified in
-  // streamingFinished.
+  // We are now waiting for script streaming to finish.
+  // If there is no script streamer, this step completes immediately.
+  AdvanceReadyState(kWaitingForStreaming);
   if (streamer_)
     streamer_->NotifyFinished(resource);
-  else if (Client())
-    Client()->PendingScriptFinished(this);
+  else
+    StreamingFinished();
 }
 
 void ClassicPendingScript::NotifyAppendData(ScriptResource* resource) {
   if (streamer_)
     streamer_->NotifyAppendData(resource);
 }
 
 DEFINE_TRACE(ClassicPendingScript) {
   visitor->Trace(streamer_);
   ResourceOwner<ScriptResource>::Trace(visitor);
   MemoryCoordinatorClient::Trace(visitor);
   PendingScript::Trace(visitor);
 }
 
 ClassicScript* ClassicPendingScript::GetSource(const KURL& document_url,
                                                bool& error_occurred) const {
   CheckState();
+  DCHECK(IsReady());
 
-  error_occurred = this->ErrorOccurred();
+  error_occurred = ErrorOccurred();
   if (GetResource()) {
     DCHECK(GetResource()->IsLoaded());
     if (streamer_ && !streamer_->StreamingSuppressed())
       return ClassicScript::Create(ScriptSourceCode(streamer_, GetResource()));
     return ClassicScript::Create(ScriptSourceCode(GetResource()));
   }
 
   return ClassicScript::Create(ScriptSourceCode(
       GetElement()->TextContent(), document_url, StartingPosition()));
 }
 
 void ClassicPendingScript::SetStreamer(ScriptStreamer* streamer) {
   DCHECK(!streamer_);
   DCHECK(!IsWatchingForLoad());
+  DCHECK(!streamer->IsFinished());
+  DCHECK_LT(ready_state_, kWaitingForStreaming);
   streamer_ = streamer;
   CheckState();
 }
 
 bool ClassicPendingScript::IsReady() const {
   CheckState();
-  if (GetResource()) {
-    return GetResource()->IsLoaded() && (!streamer_ || streamer_->IsFinished());
-  }
-
-  return true;
+  return ready_state_ >= kReady;
 }
 
 bool ClassicPendingScript::ErrorOccurred() const {
   CheckState();
-  if (GetResource())
-    return GetResource()->ErrorOccurred() || integrity_failure_;
+  return ready_state_ == kErrorOccurred;
+}
 
-  return false;
+void ClassicPendingScript::AdvanceReadyState(ReadyState new_ready_state) {
+  CHECK_GT(new_ready_state, ready_state_)
+      << "The ready state should monotonically advance.";
+
+  if (new_ready_state >= kReady) {
+    CHECK_LT(ready_state_, kReady)
+        << "The state should not advance from one completed state to another.";
+  }
+
+  ready_state_ = new_ready_state;
+
+  if (ready_state_ >= kReady && IsWatchingForLoad())
+    Client()->PendingScriptFinished(this);
 }
 
 void ClassicPendingScript::OnPurgeMemory() {
   CheckState();
   if (!streamer_)
     return;
   streamer_->Cancel();
   streamer_ = nullptr;
 }
 
@@ skipping 18 matching lines @@
 
 KURL ClassicPendingScript::UrlForClassicScript() const {
   return GetResource()->Url();
 }
 
 void ClassicPendingScript::RemoveFromMemoryCache() {
   GetMemoryCache()->Remove(GetResource());
 }
 
 }  // namespace blink