Split content script injections into multiple tasks

third_party/WebKit/Source/web/SuspendableScriptExecutor.cpp

 // Copyright 2014 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 "web/SuspendableScriptExecutor.h"
 
 #include <memory>
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 112 matching lines @@
                                      m_receiver.newLocal(isolate), args.size(),
                                      args.data(), toIsolate(frame))
             .ToLocal(&singleResult))
       results.push_back(singleResult);
   }
   return results;
 }
 
 }  // namespace
 
-void SuspendableScriptExecutor::createAndRun(
+SuspendableScriptExecutor* SuspendableScriptExecutor::create(
     LocalFrame* frame,
     int worldID,
     const HeapVector<ScriptSourceCode>& sources,
     bool userGesture,
     WebScriptExecutionCallback* callback) {
   // TODO(devlin): Passing in a v8::Isolate* directly would be better than
   // toIsolate() here.
   ScriptState* scriptState = ScriptState::forWorld(
       frame, *DOMWrapperWorld::fromWorldId(toIsolate(frame), worldID));
-  SuspendableScriptExecutor* executor = new SuspendableScriptExecutor(
+  return new SuspendableScriptExecutor(
       frame, scriptState, callback,
       new WebScriptExecutor(sources, worldID, userGesture));
-  executor->run();
 }
 
 void SuspendableScriptExecutor::createAndRun(
     LocalFrame* frame,
     v8::Isolate* isolate,
     v8::Local<v8::Context> context,
     v8::Local<v8::Function> function,
     v8::Local<v8::Value> receiver,
     int argc,
     v8::Local<v8::Value> argv[],
@@ skipping 19 matching lines @@
 }
 
 SuspendableScriptExecutor::SuspendableScriptExecutor(
     LocalFrame* frame,
     ScriptState* scriptState,
     WebScriptExecutionCallback* callback,
     Executor* executor)
     : SuspendableTimer(frame->document(), TaskType::Timer),
       m_scriptState(scriptState),
       m_callback(callback),
+      m_blockingOption(NonBlocking),
       m_keepAlive(this),
       m_executor(executor) {}
 
 SuspendableScriptExecutor::~SuspendableScriptExecutor() {}
 
 void SuspendableScriptExecutor::fired() {
   executeAndDestroySelf();
 }
 
 void SuspendableScriptExecutor::run() {
   ExecutionContext* context = getExecutionContext();
   DCHECK(context);
   if (!context->isContextSuspended()) {
     suspendIfNeeded();
     executeAndDestroySelf();
     return;
   }
   startOneShot(0, BLINK_FROM_HERE);
   suspendIfNeeded();
 }
 
+void SuspendableScriptExecutor::runAsync(BlockingOption blocking) {
+  ExecutionContext* context = getExecutionContext();
+  DCHECK(context);
+  m_blockingOption = blocking;
+  if (m_blockingOption == OnloadBlocking)
+    toDocument(getExecutionContext())->incrementLoadEventDelayCount();
+
+  startOneShot(0, BLINK_FROM_HERE);
+  suspendIfNeeded();
+}
+
 void SuspendableScriptExecutor::executeAndDestroySelf() {
   CHECK(m_scriptState->contextIsValid());
 
+  if (m_callback)
+    m_callback->willExecute();
+
   ScriptState::Scope scriptScope(m_scriptState.get());
   Vector<v8::Local<v8::Value>> results =
       m_executor->execute(toDocument(getExecutionContext())->frame());
 
   // The script may have removed the frame, in which case contextDestroyed()
   // will have handled the disposal/callback.
   if (!m_scriptState->contextIsValid())
     return;
 
+  if (m_blockingOption == OnloadBlocking)
+    toDocument(getExecutionContext())->decrementLoadEventDelayCount();
+
   if (m_callback)
     m_callback->completed(results);
 
   dispose();
 }
 
 void SuspendableScriptExecutor::dispose() {
   // Remove object as a ContextLifecycleObserver.
   SuspendableObject::clearContext();
   m_keepAlive.clear();
   stop();
 }
 
 DEFINE_TRACE(SuspendableScriptExecutor) {
   visitor->trace(m_executor);
   SuspendableTimer::trace(visitor);
 }
 
 }  // namespace blink