Make ClassicPendingScript always become ready asynchronously.

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/ScriptStreamer.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "core/dom/Document.h"
@@ skipping 14 matching lines @@
     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),
-      ready_state_(resource ? kWaitingForResource : kReady),
+      ready_state_(kInConstructor),
       integrity_failure_(false) {
   CheckState();
   SetResource(resource);
   MemoryCoordinator::Instance().RegisterClient(this);
+  AdvanceReadyState(resource ? kWaitingForResource : kReady);
 }
 
 ClassicPendingScript::~ClassicPendingScript() {}
 
 NOINLINE void ClassicPendingScript::CheckState() const {
   // TODO(hiroshige): Turn these CHECK()s into DCHECK() before going to beta.
   CHECK(!prefinalizer_called_);
   CHECK(GetElement());
   CHECK(GetResource() || !streamer_);
   CHECK(!streamer_ || streamer_->GetResource() == GetResource());
@@ skipping 64 matching lines @@
                  : ResourceIntegrityDisposition::kFailed);
       return passed;
     }
   }
 
   NOTREACHED();
   return true;
 }
 
 void ClassicPendingScript::NotifyFinished(Resource* resource) {
+  // If we're notified that the resource is synchronously ready, defer the
+  // notification until later anyway.
+  if (ready_state_ == kInConstructor) {
+    TaskRunnerHelper::Get(TaskType::kNetworking, &GetElement()->GetDocument())
+        ->PostTask(BLINK_FROM_HERE,
+                   WTF::Bind(&ClassicPendingScript::NotifyFinished,
+                             WrapPersistent(this), WrapPersistent(resource)));
+    return;
+  }
+
   // The following SRI checks need to be here because, unfortunately, fetches
   // are not done purely according to the Fetch spec. In particular,
   // different requests for the same resource do not have different
   // responses; the memory cache can (and will) return the exact same
   // Resource object.
   //
   // For different requests, the same Resource object will be returned and
   // will not be associated with the particular request.  Therefore, when the
   // body of the response comes in, there's no way to validate the integrity
   // of the Resource object against a particular request (since there may be
@@ skipping 115 matching lines @@
 
 KURL ClassicPendingScript::UrlForClassicScript() const {
   return GetResource()->Url();
 }
 
 void ClassicPendingScript::RemoveFromMemoryCache() {
   GetMemoryCache()->Remove(GetResource());
 }
 
 }  // namespace blink