Split content script injections into multiple tasks

extensions/renderer/script_injection.cc

 // 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 "extensions/renderer/script_injection.h"
 
 #include <map>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/renderer/render_frame.h"
 #include "extensions/common/extension_messages.h"
+#include "extensions/common/feature_switch.h"
 #include "extensions/common/host_id.h"
 #include "extensions/renderer/dom_activity_logger.h"
 #include "extensions/renderer/extension_frame_helper.h"
 #include "extensions/renderer/extensions_renderer_client.h"
 #include "extensions/renderer/script_injection_callback.h"
 #include "extensions/renderer/scripts_run_info.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ skipping 42 matching lines @@
       id, blink::WebSecurityOrigin::create(injection_host->url()));
   frame->setIsolatedWorldContentSecurityPolicy(
       id, blink::WebString::fromUTF8(
           injection_host->GetContentSecurityPolicy()));
   frame->setIsolatedWorldHumanReadableName(
       id, blink::WebString::fromUTF8(injection_host->name()));
 
   return id;
 }
 
+// This class manages its own lifetime.
+class TimedScriptInjectionCallback : public ScriptInjectionCallback {
+ public:
+  explicit TimedScriptInjectionCallback(
+      base::WeakPtr<ScriptInjection> injection)
+      : ScriptInjectionCallback(
+            base::Bind(&TimedScriptInjectionCallback::OnCompleted,
+                       base::Unretained(this))),
+        injection_(injection) {}
+  ~TimedScriptInjectionCallback() override {}
+
+  void OnCompleted(const std::vector<v8::Local<v8::Value>>& result) {
+    if (injection_) {
+      base::TimeDelta elapsed = base::TimeTicks::Now() - start_time_;
+      injection_->OnJsInjectionCompleted(result, elapsed);
+    }
+  }
+
+  void willExecute() override { start_time_ = base::TimeTicks::Now(); }
+
+ private:
+  base::WeakPtr<ScriptInjection> injection_;
+  base::TimeTicks start_time_;
+};
+
 }  // namespace
 
 // Watches for the deletion of a RenderFrame, after which is_valid will return
 // false.
 class ScriptInjection::FrameWatcher : public content::RenderFrameObserver {
  public:
   FrameWatcher(content::RenderFrame* render_frame,
                ScriptInjection* injection)
       : content::RenderFrameObserver(render_frame),
         injection_(injection) {}
@@ skipping 161 matching lines @@
       run_location_, executing_scripts, num_injected_js_scripts);
   DCHECK(!sources.empty());
   bool in_main_world = injector_->ShouldExecuteInMainWorld();
   int world_id = in_main_world
                      ? DOMActivityLogger::kMainWorldId
                      : GetIsolatedWorldIdForInstance(injection_host_.get(),
                                                      web_frame);
   bool is_user_gesture = injector_->IsUserGesture();
 
   std::unique_ptr<blink::WebScriptExecutionCallback> callback(
-      new ScriptInjectionCallback(
-          base::Bind(&ScriptInjection::OnJsInjectionCompleted,
-                     weak_ptr_factory_.GetWeakPtr())));
+      new TimedScriptInjectionCallback(weak_ptr_factory_.GetWeakPtr()));
 
   base::ElapsedTimer exec_timer;
   if (injection_host_->id().type() == HostID::EXTENSIONS && log_activity_)
     DOMActivityLogger::AttachToWorld(world_id, injection_host_->id().id());
   if (in_main_world) {
     // We only inject in the main world for javascript: urls.
     DCHECK_EQ(1u, sources.size());
 
     web_frame->requestExecuteScriptAndReturnValue(sources.front(),
                                                   is_user_gesture,
                                                   callback.release());
   } else {
+    blink::WebLocalFrame::ScriptExecutionType option;
+    if (injector_->script_type() == UserScript::CONTENT_SCRIPT &&
+        FeatureSwitch::yield_between_content_script_runs()->IsEnabled()) {
+      switch (run_location_) {
+        case UserScript::DOCUMENT_END:
+        case UserScript::DOCUMENT_IDLE:
+          option = blink::WebLocalFrame::AsynchronousBlockingOnload;
+          break;
+        default:
+          option = blink::WebLocalFrame::Synchronous;
+          break;
+      }
+    } else {
+      option = blink::WebLocalFrame::Synchronous;
+    }
     web_frame->requestExecuteScriptInIsolatedWorld(
-        world_id,
-        &sources.front(),
-        sources.size(),
-        is_user_gesture,
+        world_id, &sources.front(), sources.size(), is_user_gesture, option,
         callback.release());
   }
 
   if (injection_host_->id().type() == HostID::EXTENSIONS)
     UMA_HISTOGRAM_TIMES("Extensions.InjectScriptTime", exec_timer.Elapsed());
 }
 
 void ScriptInjection::OnJsInjectionCompleted(
-    const std::vector<v8::Local<v8::Value>>& results) {
+    const std::vector<v8::Local<v8::Value>>& results,
+    base::TimeDelta elapsed) {
   DCHECK(!did_inject_js_);
 
+  if (injection_host_->id().type() == HostID::EXTENSIONS)
+    UMA_HISTOGRAM_TIMES("Extensions.InjectedScriptExecutionTime", elapsed);
+
   bool expects_results = injector_->ExpectsResults();
   if (expects_results) {
     if (!results.empty() && !results[0].IsEmpty()) {
       // Right now, we only support returning single results (per frame).
       std::unique_ptr<content::V8ValueConverter> v8_converter(
           content::V8ValueConverter::create());
       // It's safe to always use the main world context when converting
       // here. V8ValueConverterImpl shouldn't actually care about the
       // context scope, and it switches to v8::Object's creation context
       // when encountered.
       v8::Local<v8::Context> context =
           render_frame_->GetWebFrame()->mainWorldScriptContext();
       execution_result_ = v8_converter->FromV8Value(results[0], context);
     }
     if (!execution_result_.get())
       execution_result_ = base::Value::CreateNullValue();
   }
   did_inject_js_ = true;
 
   // If |async_completion_callback_| is set, it means the script finished
   // asynchronously, and we should run it.
   if (!async_completion_callback_.is_null()) {
+    complete_ = true;
     injector_->OnInjectionComplete(std::move(execution_result_), run_location_,
                                    render_frame_);
     // Warning: this object can be destroyed after this line!
     async_completion_callback_.Run(this);
   }
 }
 
 void ScriptInjection::InjectCss(std::set<std::string>* injected_stylesheets,
                                 size_t* num_injected_stylesheets) {
   std::vector<blink::WebString> css_sources = injector_->GetCssSources(
       run_location_, injected_stylesheets, num_injected_stylesheets);
   blink::WebLocalFrame* web_frame = render_frame_->GetWebFrame();
   for (const blink::WebString& css : css_sources)
     web_frame->document().insertStyleSheet(css);
 }
 
 }  // namespace extensions