chromium/src/third_party/blink/renderer/core/script/script_runner.cc

/*
 * 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
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "third_party/blink/renderer/core/script/script_runner.h"

#include <algorithm>
#include "base/feature_list.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/public/platform/task_type.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/frame/local_dom_window.h"
#include "third_party/blink/renderer/core/loader/document_loader.h"
#include "third_party/blink/renderer/core/script/script_loader.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/runtime_enabled_features.h"
#include "third_party/blink/renderer/platform/scheduler/public/cooperative_scheduling_manager.h"
#include "third_party/blink/renderer/platform/scheduler/public/thread.h"
#include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
#include "third_party/blink/renderer/platform/wtf/casting.h"

namespace blink {

ScriptRunner::ScriptRunner(Document* document)
    : ExecutionContextLifecycleStateObserver(document->GetExecutionContext()),
      document_(document),
      task_runner_(document->GetTaskRunner(TaskType::kNetworking)) {
  DCHECK(document);
  UpdateStateIfNeeded();
}

void ScriptRunner::QueueScriptForExecution(PendingScript* pending_script) {
  DCHECK(pending_script);
  document_->IncrementLoadEventDelayCount();
  switch (pending_script->GetSchedulingType()) {
    case ScriptSchedulingType::kAsync:
      pending_async_scripts_.insert(pending_script);
      break;

    case ScriptSchedulingType::kInOrder:
      pending_in_order_scripts_.push_back(pending_script);
      number_of_in_order_scripts_with_pending_notification_++;
      break;

    default:
      NOTREACHED();
      break;
  }
}

void ScriptRunner::PostTask(const base::Location& web_trace_location) {
  task_runner_->PostTask(
      web_trace_location,
      WTF::Bind(&ScriptRunner::ExecuteTask, WrapWeakPersistent(this)));
}

void ScriptRunner::ContextLifecycleStateChanged(
    mojom::FrameLifecycleState state) {
  if (!IsExecutionSuspended())
    PostTasksForReadyScripts(FROM_HERE);
}

bool ScriptRunner::IsExecutionSuspended() {
  return !GetExecutionContext() || GetExecutionContext()->IsContextPaused() ||
         is_force_deferred_;
}

void ScriptRunner::SetForceDeferredExecution(bool force_deferred) {
  DCHECK(force_deferred != is_force_deferred_);

  is_force_deferred_ = force_deferred;
  if (!IsExecutionSuspended())
    PostTasksForReadyScripts(FROM_HERE);
}

void ScriptRunner::PostTasksForReadyScripts(
    const base::Location& web_trace_location) {
  DCHECK(!IsExecutionSuspended());

  for (size_t i = 0; i < async_scripts_to_execute_soon_.size(); ++i) {
    PostTask(web_trace_location);
  }
  for (size_t i = 0; i < in_order_scripts_to_execute_soon_.size(); ++i) {
    PostTask(web_trace_location);
  }
}

void ScriptRunner::ScheduleReadyInOrderScripts() {
  while (!pending_in_order_scripts_.IsEmpty() &&
         pending_in_order_scripts_.front()
             ->IsReady()) {
    in_order_scripts_to_execute_soon_.push_back(
        pending_in_order_scripts_.TakeFirst());
    PostTask(FROM_HERE);
  }
}

void ScriptRunner::DelayAsyncScriptUntilMilestoneReached(
    PendingScript* pending_script) {
  DCHECK(!delay_async_script_milestone_reached_);
  SECURITY_CHECK(pending_async_scripts_.Contains(pending_script));
  pending_async_scripts_.erase(pending_script);

  // When the ScriptRunner is notified via
  // |NotifyDelayedAsyncScriptsMilestoneReached()|, the scripts in
  // |pending_delayed_async_scripts_| will be scheduled for execution.
  pending_delayed_async_scripts_.push_back(pending_script);
}

void ScriptRunner::NotifyDelayedAsyncScriptsMilestoneReached() {
  delay_async_script_milestone_reached_ = true;
  while (!pending_delayed_async_scripts_.IsEmpty()) {
    PendingScript* pending_script = pending_delayed_async_scripts_.TakeFirst();
    DCHECK_EQ(pending_script->GetSchedulingType(),
              ScriptSchedulingType::kAsync);

    async_scripts_to_execute_soon_.push_back(pending_script);
    PostTask(FROM_HERE);
  }
}

bool ScriptRunner::CanDelayAsyncScripts() {
  if (delay_async_script_milestone_reached_)
    return false;

  // We first check to see if the base::Feature is enabled, before the
  // RuntimeEnabledFeatures. This is because the RuntimeEnabledFeatures simply
  // exist for testing, so if they are enabled *and* the base::Feature is
  // enabled, we should log UKM via DocumentLoader::DidObserveLoadingBehavior,
  // which is associated with the experiment running the base::Feature flag.
  static bool feature_enabled =
      base::FeatureList::IsEnabled(features::kDelayAsyncScriptExecution);
  bool optimization_guide_hints_unknown =
      !document_->GetFrame() ||
      !document_->GetFrame()->GetOptimizationGuideHints() ||
      !document_->GetFrame()
           ->GetOptimizationGuideHints()
           ->delay_async_script_execution_hints ||
      document_->GetFrame()
              ->GetOptimizationGuideHints()
              ->delay_async_script_execution_hints->delay_type ==
          mojom::blink::DelayAsyncScriptExecutionDelayType::kUnknown;
  if (feature_enabled) {
    if (document_->Parsing() && document_->Loader()) {
      document_->Loader()->DidObserveLoadingBehavior(
          kLoadingBehaviorAsyncScriptReadyBeforeDocumentFinishedParsing);
    }

    // If the base::Feature is enabled, we always want to delay async scripts,
    // unless we delegate to the OptimizationGuide, but the hints aren't
    // available.
    if (features::kDelayAsyncScriptExecutionDelayParam.Get() !=
            features::DelayAsyncScriptDelayType::kUseOptimizationGuide ||
        !optimization_guide_hints_unknown) {
      return true;
    }
  }

  // Delay milestone has not been reached yet. We have to check the feature flag
  // configuration to see if we are able to delay async scripts or not:
  if (RuntimeEnabledFeatures::
          DelayAsyncScriptExecutionUntilFinishedParsingEnabled() ||
      RuntimeEnabledFeatures::
          DelayAsyncScriptExecutionUntilFirstPaintOrFinishedParsingEnabled()) {
    return true;
  }

  return false;
}

void ScriptRunner::NotifyScriptReady(PendingScript* pending_script) {
  SECURITY_CHECK(pending_script);

  switch (pending_script->GetSchedulingType()) {
    case ScriptSchedulingType::kAsync:
      // SECURITY_CHECK() makes us crash in a controlled way in error cases
      // where the PendingScript is associated with the wrong ScriptRunner
      // (otherwise we'd cause a use-after-free in ~ScriptRunner when it tries
      // to detach).
      SECURITY_CHECK(pending_async_scripts_.Contains(pending_script));

      if (pending_script->IsEligibleForDelay() && CanDelayAsyncScripts()) {
        DelayAsyncScriptUntilMilestoneReached(pending_script);
        return;
      }

      pending_async_scripts_.erase(pending_script);
      async_scripts_to_execute_soon_.push_back(pending_script);

      PostTask(FROM_HERE);
      break;

    case ScriptSchedulingType::kInOrder:
      SECURITY_CHECK(number_of_in_order_scripts_with_pending_notification_ > 0);
      number_of_in_order_scripts_with_pending_notification_--;

      ScheduleReadyInOrderScripts();

      break;

    default:
      NOTREACHED();
      break;
  }
}

bool ScriptRunner::RemovePendingInOrderScript(PendingScript* pending_script) {
  auto it = std::find(pending_in_order_scripts_.begin(),
                      pending_in_order_scripts_.end(), pending_script);
  if (it == pending_in_order_scripts_.end())
    return false;
  pending_in_order_scripts_.erase(it);
  SECURITY_CHECK(number_of_in_order_scripts_with_pending_notification_ > 0);
  number_of_in_order_scripts_with_pending_notification_--;
  return true;
}

void ScriptRunner::MovePendingScript(Document& old_document,
                                     Document& new_document,
                                     ScriptLoader* script_loader) {
  Document* new_context_document =
      new_document.GetExecutionContext()
          ? To<LocalDOMWindow>(new_document.GetExecutionContext())->document()
          : &new_document;
  Document* old_context_document =
      old_document.GetExecutionContext()
          ? To<LocalDOMWindow>(old_document.GetExecutionContext())->document()
          : &old_document;
  if (old_context_document == new_context_document)
    return;

  PendingScript* pending_script =
      script_loader
          ->GetPendingScriptIfControlledByScriptRunnerForCrossDocMove();
  if (!pending_script) {
    // The ScriptLoader is not controlled by ScriptRunner. This can happen
    // because MovePendingScript() is called for all <script> elements
    // moved between Documents, not only for those controlled by ScriptRunner.
    return;
  }

  old_context_document->GetScriptRunner()->MovePendingScript(
      new_context_document->GetScriptRunner(), pending_script);
}

void ScriptRunner::MovePendingScript(ScriptRunner* new_runner,
                                     PendingScript* pending_script) {
  auto it = pending_async_scripts_.find(pending_script);
  if (it != pending_async_scripts_.end()) {
    new_runner->QueueScriptForExecution(pending_script);
    pending_async_scripts_.erase(it);
    document_->DecrementLoadEventDelayCount();
    return;
  }
  if (RemovePendingInOrderScript(pending_script)) {
    new_runner->QueueScriptForExecution(pending_script);
    document_->DecrementLoadEventDelayCount();
  }
}

bool ScriptRunner::ExecuteInOrderTask() {
  TRACE_EVENT0("blink", "ScriptRunner::ExecuteInOrderTask");
  if (in_order_scripts_to_execute_soon_.IsEmpty())
    return false;

  PendingScript* pending_script = in_order_scripts_to_execute_soon_.TakeFirst();
  DCHECK(pending_script);
  DCHECK_EQ(pending_script->GetSchedulingType(), ScriptSchedulingType::kInOrder)
      << "In-order scripts queue should not contain any async script.";

  pending_script->ExecuteScriptBlock(NullURL());

  document_->DecrementLoadEventDelayCount();
  return true;
}

bool ScriptRunner::ExecuteAsyncTask() {
  TRACE_EVENT0("blink", "ScriptRunner::ExecuteAsyncTask");
  if (async_scripts_to_execute_soon_.IsEmpty())
    return false;

  // Remove the async script loader from the ready-to-exec set and execute.
  PendingScript* pending_script = async_scripts_to_execute_soon_.TakeFirst();

  DCHECK_EQ(pending_script->GetSchedulingType(), ScriptSchedulingType::kAsync)
      << "Async scripts queue should not contain any in-order script.";

  pending_script->ExecuteScriptBlock(NullURL());

  document_->DecrementLoadEventDelayCount();
  return true;
}

void ScriptRunner::ExecuteTask() {
  // This method is triggered by ScriptRunner::PostTask, and runs directly from
  // the scheduler. So, the call stack is safe to reenter.
  scheduler::CooperativeSchedulingManager::AllowedStackScope
      allowed_stack_scope(scheduler::CooperativeSchedulingManager::Instance());

  if (IsExecutionSuspended())
    return;

  if (ExecuteAsyncTask())
    return;

  if (ExecuteInOrderTask())
    return;
}

void ScriptRunner::Trace(Visitor* visitor) const {
  ExecutionContextLifecycleStateObserver::Trace(visitor);
  visitor->Trace(document_);
  visitor->Trace(pending_in_order_scripts_);
  visitor->Trace(pending_async_scripts_);
  visitor->Trace(pending_delayed_async_scripts_);
  visitor->Trace(async_scripts_to_execute_soon_);
  visitor->Trace(in_order_scripts_to_execute_soon_);
}

}  // namespace blink