Explicitly track the lifecycle of PendingScript.

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

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 39 matching lines @@
 }
 
 PendingScript* PendingScript::CreateForTesting(ScriptResource* resource) {
   return new PendingScript(nullptr, resource, TextPosition(), true);
 }
 
 PendingScript::PendingScript(ScriptElementBase* element,
                              ScriptResource* resource,
                              const TextPosition& starting_position,
                              bool is_for_testing)
-    : watching_for_load_(false),
+    : ready_state_(resource ? kWaitingForResource : kReady),
       element_(element),
       starting_position_(starting_position),
       integrity_failure_(false),
       parser_blocking_load_start_time_(0),
       client_(nullptr),
       is_for_testing_(is_for_testing) {
   CheckState();
   SetResource(resource);
   MemoryCoordinator::Instance().RegisterClient(this);
 }
 
 PendingScript::~PendingScript() {}
 
 NOINLINE void PendingScript::CheckState() const {
   // TODO(hiroshige): Turn these CHECK()s into DCHECK() before going to beta.
   CHECK(is_for_testing_ || element_);
   CHECK(GetResource() || !streamer_);
   CHECK(!streamer_ || streamer_->GetResource() == GetResource());
 }
 
 void PendingScript::Dispose() {
   StopWatchingForLoad();
-  DCHECK(!client_);
-  DCHECK(!watching_for_load_);
+  DCHECK(!WatchingForLoad());
 
   MemoryCoordinator::Instance().UnregisterClient(this);
   SetResource(nullptr);
   starting_position_ = TextPosition::BelowRangePosition();
   integrity_failure_ = false;
   parser_blocking_load_start_time_ = 0;
   if (streamer_)
     streamer_->Cancel();
   streamer_ = nullptr;
   element_ = nullptr;
 }
 
 void PendingScript::WatchForLoad(PendingScriptClient* client) {
   CheckState();
 
-  DCHECK(!watching_for_load_);
+  DCHECK(!WatchingForLoad());
+  DCHECK(client);
   // addClient() will call streamingFinished() if the load is complete. Callers
   // who do not expect to be re-entered from this call should not call
   // watchForLoad for a PendingScript which isReady. We also need to set
   // m_watchingForLoad early, since addClient() can result in calling
   // notifyFinished and further stopWatchingForLoad().
-  watching_for_load_ = true;
   client_ = client;
   if (IsReady())
     client_->PendingScriptFinished(this);
 }
 
 void PendingScript::StopWatchingForLoad() {
-  if (!watching_for_load_)
+  if (!WatchingForLoad())
     return;
   CheckState();
   DCHECK(GetResource());
   client_ = nullptr;
-  watching_for_load_ = false;
 }
 
 ScriptElementBase* PendingScript::GetElement() const {
   // As mentioned in the comment at |m_element| declaration,
   // |m_element|  must point to the corresponding ScriptLoader's
   // client.
   CHECK(element_);
   return element_.Get();
 }
 
 void PendingScript::StreamingFinished() {
   CheckState();
   DCHECK(GetResource());

[hiroshige, 2017/04/24 19:16:53]

DCHECK_EQ(ready_state_, kWaitingForStreaming);

[jbroman, 2017/05/01 15:08:01]

Done.

-  if (client_)
-    client_->PendingScriptFinished(this);
+
+  bool error_occurred = GetResource()->ErrorOccurred() || integrity_failure_;
+  AdvanceReadyState(error_occurred ? kErrorOccurred : kReady);
 }
 
 void PendingScript::MarkParserBlockingLoadStartTime() {
   DCHECK_EQ(parser_blocking_load_start_time_, 0.0);
   parser_blocking_load_start_time_ = MonotonicallyIncreasingTime();
 }
 
 // Returns true if SRI check passed.
 static bool CheckScriptResourceIntegrity(Resource* resource,
                                          ScriptElementBase* element) {
@@ skipping 33 matching lines @@
                  : ResourceIntegrityDisposition::kFailed);
       return passed;
     }
   }
 
   NOTREACHED();
   return true;
 }
 
 void PendingScript::NotifyFinished(Resource* resource) {
+  DCHECK_EQ(ready_state_, kWaitingForResource);
+
   // 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
   // several pending requests all tied to the identical object, and the
   // actual requests are not stored).
   //
   // In order to simulate the correct behavior, Blink explicitly does the SRI
   // checks here, when a PendingScript tied to a particular request is
   // finished (and in the case of a StyleSheet, at the point of execution),
   // while having proper Fetch checks in the fetch module for use in the
   // 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 (element_) {
     integrity_failure_ = !CheckScriptResourceIntegrity(resource, element_);
   }
 
-  // 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 PendingScript::NotifyAppendData(ScriptResource* resource) {
   if (streamer_)
     streamer_->NotifyAppendData(resource);
 }
 
 DEFINE_TRACE(PendingScript) {
   visitor->Trace(element_);
   visitor->Trace(streamer_);
   visitor->Trace(client_);
   ResourceOwner<ScriptResource>::Trace(visitor);
   MemoryCoordinatorClient::Trace(visitor);
 }
 
 ClassicScript* PendingScript::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(
       element_->TextContent(), document_url, StartingPosition()));
 }
 
 void PendingScript::SetStreamer(ScriptStreamer* streamer) {
   DCHECK(!streamer_);
-  DCHECK(!watching_for_load_);
+  DCHECK(!WatchingForLoad());
+  DCHECK(!streamer->IsFinished());
+  DCHECK_LT(ready_state_, kWaitingForStreaming);
   streamer_ = streamer;
   CheckState();
 }
 
-bool PendingScript::IsReady() const {
-  CheckState();
-  if (GetResource()) {
-    return GetResource()->IsLoaded() && (!streamer_ || streamer_->IsFinished());
-  }
-
-  return true;
-}
-
-bool PendingScript::ErrorOccurred() const {
-  CheckState();
-  if (GetResource())
-    return GetResource()->ErrorOccurred() || integrity_failure_;
-
-  return false;
-}
-
 void PendingScript::OnPurgeMemory() {
   CheckState();
   if (!streamer_)
     return;
   streamer_->Cancel();
   streamer_ = nullptr;
 }
 
 void PendingScript::StartStreamingIfPossible(
     Document* document,
     ScriptStreamer::Type streamer_type) {
   if (!document->GetFrame())
     return;
 
   ScriptState* script_state = ToScriptStateForMainWorld(document->GetFrame());
   if (!script_state)
     return;
 
   ScriptStreamer::StartStreaming(
       this, streamer_type, document->GetFrame()->GetSettings(), script_state,
       TaskRunnerHelper::Get(TaskType::kNetworking, document));
 }
 
+void PendingScript::AdvanceReadyState(ReadyState ready_state) {
+  // The ready state should monotonically advance.
+  DCHECK_GT(ready_state, ready_state_);
+
+  // The state should not advance from one completed state to another.
+  if (ready_state >= kReady)
+    DCHECK_LT(ready_state_, kReady);
+
+  ready_state_ = ready_state;
+  if (ready_state >= kReady && client_)
+    client_->PendingScriptFinished(this);
+}
+
 }  // namespace blink