Introduce ClassicPendingScript::is_external_ explicitly

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"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/LocalFrame.h"
 #include "core/loader/SubresourceIntegrityHelper.h"
 #include "platform/bindings/ScriptState.h"
 #include "platform/loader/fetch/MemoryCache.h"
 
 namespace blink {
 
 ClassicPendingScript* ClassicPendingScript::Create(ScriptElementBase* element,
                                                    ScriptResource* resource) {
+  CHECK(resource);
   return new ClassicPendingScript(element, resource, TextPosition());
 }
 
 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),
+      is_external_(resource),
       ready_state_(resource ? kWaitingForResource : kReady),
       integrity_failure_(false) {
+  CHECK(GetElement());
+  SetResource(resource);
   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_);
   CHECK(GetElement());
+  CHECK_EQ(is_external_, !!GetResource());
   CHECK(GetResource() || !streamer_);
   CHECK(!streamer_ || streamer_->GetResource() == GetResource());
 }
 
 void ClassicPendingScript::Prefinalize() {
   // TODO(hiroshige): Consider moving this to ScriptStreamer's prefinalizer.
   // https://crbug.com/715309
   if (streamer_)
     streamer_->Cancel();
   prefinalizer_called_ = true;
@@ skipping 101 matching lines @@
   MemoryCoordinatorClient::Trace(visitor);
   PendingScript::Trace(visitor);
 }
 
 ClassicScript* ClassicPendingScript::GetSource(const KURL& document_url,
                                                bool& error_occurred) const {
   CheckState();
   DCHECK(IsReady());
 
   error_occurred = ErrorOccurred();
-  if (!GetResource()) {
+  if (!is_external_) {
     return ClassicScript::Create(ScriptSourceCode(
         GetElement()->TextFromChildren(), document_url, StartingPosition()));
   }
 
   DCHECK(GetResource()->IsLoaded());
   bool streamer_ready = (ready_state_ == kReady) && streamer_ &&
                         !streamer_->StreamingSuppressed();
   return ClassicScript::Create(
       ScriptSourceCode(streamer_ready ? streamer_ : nullptr, GetResource()));
 }
@@ skipping 127 matching lines @@
 
 bool ClassicPendingScript::IsCurrentlyStreaming() const {
   // We could either check our local state, or ask the streamer. Let's
   // double-check these are consistent.
   DCHECK_EQ(streamer_ && !streamer_->IsStreamingFinished(),
             ready_state_ == kReadyStreaming || (streamer_ && !IsReady()));
   return ready_state_ == kReadyStreaming || (streamer_ && !IsReady());
 }
 
 bool ClassicPendingScript::WasCanceled() const {
-  if (!GetResource())
+  if (!is_external_)
     return false;
   return GetResource()->WasCanceled();
 }
 
 KURL ClassicPendingScript::UrlForClassicScript() const {
   return GetResource()->Url();
 }
 
 void ClassicPendingScript::RemoveFromMemoryCache() {
   GetMemoryCache()->Remove(GetResource());
 }
 
 }  // namespace blink