Forbid accessing ScriptLoader from PendingScript

This CL makes ScriptElementBase::Loader() protected, and thus
after this CL PendingScript no longer has access to ScriptLoader,
making separation between PendingScript and ScriptLoader more strict.

XML/HTMLParserScriptRunner previously get ScriptLoader via
ScriptElementBase, but after this CL they get ScriptLoader
directly via ScriptLoaderFromElement().

No behavior changes.

Bug: 842349
Change-Id: I5104c0817669e871a68b8d8286d037e3e23622cc
Reviewed-on: https://chromium-review.googlesource.com/1054855
Commit-Queue: Hiroshige Hayashizaki <hiroshige@chromium.org>
Reviewed-by: Kouhei Ueno <kouhei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#561379}

third_party/blink/renderer/core/script/html_parser_script_runner.cc

@@ -50,18 +50,18 @@ namespace {
 // TODO(bmcquade): move this to a shared location if we find ourselves wanting
 // to trace similar data elsewhere in the codebase.
 std::unique_ptr<TracedValue> GetTraceArgsForScriptElement(
-    ScriptElementBase* element,
+    Document& document,
     const TextPosition& text_position,
     const KURL& url) {
   std::unique_ptr<TracedValue> value = TracedValue::Create();
   if (!url.IsNull())
     value->SetString("url", url.GetString());
-  if (element->GetDocument().GetFrame()) {
+  if (document.GetFrame()) {
     value->SetString(
         "frame",
         String::Format("0x%" PRIx64,
-                       static_cast<uint64_t>(reinterpret_cast<intptr_t>(
-                           element->GetDocument().GetFrame()))));
+                       static_cast<uint64_t>(
+                           reinterpret_cast<intptr_t>(document.GetFrame()))));
   }
   if (text_position.line_.ZeroBasedInt() > 0 ||
       text_position.column_.ZeroBasedInt() > 0) {
@@ -74,9 +74,9 @@ std::unique_ptr<TracedValue> GetTraceArgsForScriptElement(
 std::unique_ptr<TracedValue> GetTraceArgsForScriptElement(
     const PendingScript* pending_script) {
   DCHECK(pending_script);
-  return GetTraceArgsForScriptElement(pending_script->GetElement(),
-                                      pending_script->StartingPosition(),
-                                      pending_script->UrlForTracing());
+  return GetTraceArgsForScriptElement(
+      pending_script->GetElement()->GetDocument(),
+      pending_script->StartingPosition(), pending_script->UrlForTracing());
 }
 
 void DoExecuteScript(PendingScript* pending_script, const KURL& document_url) {
@@ -221,7 +221,7 @@ void HTMLParserScriptRunner::ExecutePendingScriptAndDispatchEvent(
     parser_blocking_script_ = nullptr;
   }
 
-  if (pending_script->GetElement()->Loader()) {
+  {
     // <spec label="scriptEndTag" step="B.7">Increment the parser's script
     // nesting level by one (it should be zero before this step, so this sets it
     // to one).</spec>
@@ -477,15 +477,11 @@ void HTMLParserScriptRunner::ProcessScriptElementInternal(
   DCHECK(document_);
   DCHECK(!HasParserBlockingScript());
   {
-    ScriptElementBase* element =
-        ScriptElementBase::FromElementIfPossible(script);
-    DCHECK(element);
-    ScriptLoader* script_loader = element->Loader();
-    DCHECK(script_loader);
+    ScriptLoader* script_loader = ScriptLoaderFromElement(script);
 
     // FIXME: Align trace event name and function name.
     TRACE_EVENT1("blink", "HTMLParserScriptRunner::execute", "data",
-                 GetTraceArgsForScriptElement(element, script_start_position,
+                 GetTraceArgsForScriptElement(*document_, script_start_position,
                                               NullURL()));
     DCHECK(script_loader->IsParserInserted());
 

third_party/blink/renderer/core/script/script_element_base.cc

@@ -9,12 +9,14 @@
 
 namespace blink {
 
-ScriptElementBase* ScriptElementBase::FromElementIfPossible(Element* element) {
+ScriptLoader* ScriptLoaderFromElement(Element* element) {
+  ScriptLoader* script_loader = nullptr;
   if (auto* html_script = ToHTMLScriptElementOrNull(*element))
-    return html_script;
-  if (auto* svg_script = ToSVGScriptElementOrNull(*element))
-    return svg_script;
-  return nullptr;
+    script_loader = html_script->Loader();
+  else if (auto* svg_script = ToSVGScriptElementOrNull(*element))
+    script_loader = svg_script->Loader();
+  DCHECK(script_loader);
+  return script_loader;
 }
 
 ScriptLoader* ScriptElementBase::InitializeScriptLoader(bool parser_inserted,

third_party/blink/renderer/core/script/script_element_base.h

@@ -35,10 +35,10 @@ class Element;
 class HTMLScriptElementOrSVGScriptElement;
 class ScriptLoader;
 
+ScriptLoader* ScriptLoaderFromElement(Element*);
+
 class CORE_EXPORT ScriptElementBase : public GarbageCollectedMixin {
  public:
-  static ScriptElementBase* FromElementIfPossible(Element*);
-
   virtual bool AsyncAttributeValue() const = 0;
   virtual String CharsetAttributeValue() const = 0;
   virtual String CrossOriginAttributeValue() const = 0;
@@ -66,16 +66,14 @@ class CORE_EXPORT ScriptElementBase : public GarbageCollectedMixin {
   virtual void SetScriptElementForBinding(
       HTMLScriptElementOrSVGScriptElement&) = 0;
 
-  virtual ScriptLoader* Loader() const = 0;
+  virtual void DispatchLoadEvent() = 0;
+  virtual void DispatchErrorEvent() = 0;
 
  protected:
   ScriptLoader* InitializeScriptLoader(bool parser_inserted,
                                        bool already_started);
 
-  friend class ScriptLoader;
-  friend class PendingScript;
-  virtual void DispatchLoadEvent() = 0;
-  virtual void DispatchErrorEvent() = 0;
+  virtual ScriptLoader* Loader() const = 0;
 };
 
 }  // namespace blink

third_party/blink/renderer/core/script/script_loader.cc

@@ -762,7 +762,6 @@ void ScriptLoader::PendingScriptFinished(PendingScript* pending_script) {
     return;
   }
 
-  DCHECK_EQ(pending_script->GetElement()->Loader(), this);
   context_document->GetScriptRunner()->NotifyScriptReady(pending_script);
   pending_script_->StopWatchingForLoad();
   pending_script_ = nullptr;

third_party/blink/renderer/core/script/xml_parser_script_runner.cc

@@ -67,12 +67,7 @@ void XMLParserScriptRunner::ProcessScriptElement(
   DCHECK(element);
   DCHECK(!parser_blocking_script_);
 
-  ScriptElementBase* script_element_base =
-      ScriptElementBase::FromElementIfPossible(element);
-  CHECK(script_element_base);
-
-  ScriptLoader* script_loader = script_element_base->Loader();
-  DCHECK(script_loader);
+  ScriptLoader* script_loader = ScriptLoaderFromElement(element);
 
   // [Parsing] When the element's end tag is subsequently parsed, the user agent
   // must perform a microtask checkpoint, and then prepare the script element.