Extensions: suspend extension's scripts when V8 is paused

extensions/renderer/script_injection_manager.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_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
@@ skipping 210 matching lines @@
 void ScriptInjectionManager::RVOHelper::InvalidateFrame(
     blink::WebFrame* frame) {
   pending_idle_frames_.erase(frame);
   manager_->InvalidateForFrame(frame);
 }
 
 ScriptInjectionManager::ScriptInjectionManager(
     const ExtensionSet* extensions,
     UserScriptSetManager* user_script_set_manager)
     : extensions_(extensions),
-      injecting_scripts_(false),
       user_script_set_manager_(user_script_set_manager),
       user_script_set_manager_observer_(this) {
   user_script_set_manager_observer_.Add(user_script_set_manager_);
 }
 
 ScriptInjectionManager::~ScriptInjectionManager() {
 }
 
 void ScriptInjectionManager::OnRenderViewCreated(
     content::RenderView* render_view) {
   rvo_helpers_.push_back(new RVOHelper(render_view, this));
 }
 
 void ScriptInjectionManager::OnExtensionUnloaded(
     const std::string& extension_id) {
   for (auto iter = pending_injections_.begin();
       iter != pending_injections_.end();) {
     if ((*iter)->host_id().id() == extension_id) {
       (*iter)->OnHostRemoved();
       iter = pending_injections_.erase(iter);
     } else {
       ++iter;
     }
   }
-  // If we are currently injection scripts, we need to make a note that this
-  // extension is "dirty" (invalidated).
-  if (injecting_scripts_)
-    invalidated_while_injecting_.insert(extension_id);
+}
+
+void ScriptInjectionManager::OnInjectionFinished(
+    ScriptInjection* injection) {
+  ScopedVector<ScriptInjection>::iterator iter =
+      std::find(running_injections_.begin(),
+                running_injections_.end(),
+                injection);
+  if (iter != running_injections_.end())
+    running_injections_.erase(iter);
 }
 
 void ScriptInjectionManager::OnUserScriptsUpdated(
     const std::set<std::string>& changed_extensions,
     const std::vector<UserScript*>& scripts) {
   for (ScopedVector<ScriptInjection>::iterator iter =
            pending_injections_.begin();
        iter != pending_injections_.end();) {
     if (changed_extensions.count((*iter)->host_id().id()) > 0)
       iter = pending_injections_.erase(iter);
     else
       ++iter;
   }
-
-  // If we are currently injecting scripts, we need to make a note that these
-  // extensions were updated.
-  if (injecting_scripts_) {
-    invalidated_while_injecting_.insert(changed_extensions.begin(),
-                                        changed_extensions.end());
-  }
 }
 
 void ScriptInjectionManager::RemoveObserver(RVOHelper* helper) {
   for (ScopedVector<RVOHelper>::iterator iter = rvo_helpers_.begin();
        iter != rvo_helpers_.end();
        ++iter) {
     if (*iter == helper) {
       rvo_helpers_.erase(iter);
       break;
     }
   }
 }
 
 void ScriptInjectionManager::InvalidateForFrame(blink::WebFrame* frame) {
   for (ScopedVector<ScriptInjection>::iterator iter =
            pending_injections_.begin();
        iter != pending_injections_.end();) {
     if ((*iter)->web_frame() == frame)
       iter = pending_injections_.erase(iter);
     else
       ++iter;
   }
 
   frame_statuses_.erase(frame);
 }
 
-bool ScriptInjectionManager::IsFrameValid(blink::WebFrame* frame) const {
-  return frame_statuses_.find(frame) != frame_statuses_.end();
-}
-
 void ScriptInjectionManager::StartInjectScripts(
     blink::WebFrame* frame, UserScript::RunLocation run_location) {
   FrameStatusMap::iterator iter = frame_statuses_.find(frame);
   // We also don't execute if we detect that the run location is somehow out of
   // order. This can happen if:
   // - The first run location reported for the frame isn't DOCUMENT_START, or
   // - The run location reported doesn't immediately follow the previous
   //   reported run location.
   // We don't want to run because extensions may have requirements that scripts
   // running in an earlier run location have run by the time a later script
@@ skipping 10 matching lines @@
     InvalidateForFrame(frame);
     return;
   } else if (iter != frame_statuses_.end() && iter->second >= run_location) {
     // Certain run location signals (like DidCreateDocumentElement) can happen
     // multiple times. Ignore the subsequent signals.
     return;
   }
 
   // Otherwise, all is right in the world, and we can get on with the
   // injections!
-
   frame_statuses_[frame] = run_location;
-
-  // If a content script injects blocking code (such as a javascript alert()),
-  // then there is a chance that we are running in a nested message loop, and
-  // shouldn't inject scripts right now (to avoid conflicts).
-  if (!injecting_scripts_) {
-    InjectScripts(frame, run_location);
-    // As above, we might have been blocked, but that means that, in the mean
-    // time, it's possible the frame advanced. Inject any scripts for run
-    // locations that were registered, but never ran.
-    while ((iter = frame_statuses_.find(frame)) != frame_statuses_.end() &&
-           iter->second > run_location) {
-      run_location = NextRunLocation(run_location);
-      DCHECK_LE(run_location, UserScript::DOCUMENT_IDLE);
-      InjectScripts(frame, run_location);
-    }
-  }
+  InjectScripts(frame, run_location);
 }
 
 void ScriptInjectionManager::InjectScripts(
     blink::WebFrame* frame,
     UserScript::RunLocation run_location) {
-  DCHECK(!injecting_scripts_);
-  DCHECK(invalidated_while_injecting_.empty());
-  base::AutoReset<bool>(&injecting_scripts_, true);
-
   // Find any injections that want to run on the given frame.
-  // We create a separate vector for these because there is a chance that
-  // injected scripts can block, which can create a nested message loop. When
-  // this happens, other signals (like IPCs) can cause |pending_injections_| to
-  // be changed, so we don't want to risk that.
   ScopedVector<ScriptInjection> frame_injections;
   for (ScopedVector<ScriptInjection>::iterator iter =
            pending_injections_.begin();
        iter != pending_injections_.end();) {
     if ((*iter)->web_frame() == frame) {
       frame_injections.push_back(*iter);
       iter = pending_injections_.weak_erase(iter);
     } else {
       ++iter;
     }
   }
 
   // Add any injections for user scripts.
   int tab_id = ExtensionHelper::Get(content::RenderView::FromWebView(
                                         frame->top()->view()))->tab_id();
   user_script_set_manager_->GetAllInjections(
       &frame_injections, frame, tab_id, run_location);
 
   ScriptsRunInfo scripts_run_info;
-  for (ScopedVector<ScriptInjection>::iterator iter = frame_injections.begin();
-       iter != frame_injections.end();) {
-    // If a blocking script was injected, there is potentially a possibility
-    // that the frame has been invalidated in the time since. Check.
-    if (!IsFrameValid(frame))
+  std::vector<ScriptInjection*> released_injections;
+  frame_injections.release(&released_injections);
+  for (ScriptInjection* injection : released_injections)
+    TryToInject(make_scoped_ptr(injection), run_location, &scripts_run_info);
+
+  scripts_run_info.LogRun(frame, run_location);
+}
+
+void ScriptInjectionManager::TryToInject(
+    scoped_ptr<ScriptInjection> injection,
+    UserScript::RunLocation run_location,
+    ScriptsRunInfo* scripts_run_info) {
+  // Try to inject the script. If the injection is waiting (i.e., for
+  // permission), add it to the list of pending injections. If the injection
+  // has blocked, add it to the list of running injections.
+  switch (injection->TryToInject(
+      run_location,
+      scripts_run_info,
+      this)) {
+    case ScriptInjection::INJECTION_WAITING:
+      pending_injections_.push_back(injection.release());
       break;
-
-    // Try to inject the script if the injection host is not "dirty"
-    // (invalidated by an update). If the injection does not finish
-    // (i.e., it is waiting for permission), add it to the list of pending
-    // injections.
-    if (invalidated_while_injecting_.count((*iter)->host_id().id()) == 0 &&
-        !(*iter)->TryToInject(run_location,
-                              &scripts_run_info)) {
-      pending_injections_.insert(pending_injections_.begin(), *iter);
-      iter = frame_injections.weak_erase(iter);
-    } else {
-      ++iter;
-    }
+    case ScriptInjection::INJECTION_BLOCKED:
+      running_injections_.push_back(injection.release());
+      break;
+    case ScriptInjection::INJECTION_FINISHED:
+      break;
   }
-
-  if (IsFrameValid(frame))
-    scripts_run_info.LogRun(frame, run_location);
-
-  invalidated_while_injecting_.clear();
 }
 
 void ScriptInjectionManager::HandleExecuteCode(
     const ExtensionMsg_ExecuteCode_Params& params,
     content::RenderView* render_view) {
   // TODO(dcheng): Not sure how this can happen today. In an OOPI world, it
   // would indicate a logic error--the browser must direct this request to the
   // right renderer process to begin with.
   blink::WebLocalFrame* main_frame =
       render_view->GetWebView()->mainFrame()->toWebLocalFrame();
@@ skipping 17 matching lines @@
       scoped_ptr<ScriptInjector>(
           new ProgrammaticScriptInjector(params, main_frame)),
       main_frame,
       extension_injection_host.Pass(),
       static_cast<UserScript::RunLocation>(params.run_at),
       ExtensionHelper::Get(render_view)->tab_id()));
 
   ScriptsRunInfo scripts_run_info;
   FrameStatusMap::const_iterator iter = frame_statuses_.find(main_frame);
 
-  if (!injection->TryToInject(
-          iter == frame_statuses_.end() ? UserScript::UNDEFINED : iter->second,
-          &scripts_run_info)) {
-    pending_injections_.push_back(injection.release());
-  }
+  TryToInject(
+      injection.Pass(),
+      iter == frame_statuses_.end() ? UserScript::UNDEFINED : iter->second,
+      &scripts_run_info);
 }
 
 void ScriptInjectionManager::HandleExecuteDeclarativeScript(
     blink::WebFrame* web_frame,
     int tab_id,
     const ExtensionId& extension_id,
     int script_id,
     const GURL& url) {
   // TODO(dcheng): This function signature should really be a WebLocalFrame,
   // rather than trying to coerce it here.
   scoped_ptr<ScriptInjection> injection =
       user_script_set_manager_->GetInjectionForDeclarativeScript(
           script_id,
           web_frame->toWebLocalFrame(),
           tab_id,
           url,
           extension_id);
-  if (injection) {
+  if (injection.get()) {
     ScriptsRunInfo scripts_run_info;
     // TODO(markdittmer): Use return value of TryToInject for error handling.
-    injection->TryToInject(UserScript::BROWSER_DRIVEN,
-                           &scripts_run_info);
+    TryToInject(injection.Pass(),
+                UserScript::BROWSER_DRIVEN,
+                &scripts_run_info);
+
     scripts_run_info.LogRun(web_frame, UserScript::BROWSER_DRIVEN);
   }
 }
 
 void ScriptInjectionManager::HandlePermitScriptInjection(int64 request_id) {
   ScopedVector<ScriptInjection>::iterator iter =
       pending_injections_.begin();
   for (; iter != pending_injections_.end(); ++iter) {
     if ((*iter)->request_id() == request_id) {
       DCHECK((*iter)->host_id().type() == HostID::EXTENSIONS);
       break;
     }
   }
   if (iter == pending_injections_.end())
     return;
 
   // At this point, because the request is present in pending_injections_, we
   // know that this is the same page that issued the request (otherwise,
   // RVOHelper's DidStartProvisionalLoad callback would have caused it to be
   // cleared out).
 
   scoped_ptr<ScriptInjection> injection(*iter);
   pending_injections_.weak_erase(iter);
 
   ScriptsRunInfo scripts_run_info;
-  if (injection->OnPermissionGranted(&scripts_run_info)) {
-    scripts_run_info.LogRun(injection->web_frame(), UserScript::RUN_DEFERRED);
-  }
+  ScriptInjection::InjectionResult res = injection->OnPermissionGranted(
+      &scripts_run_info);
+  if (res == ScriptInjection::INJECTION_BLOCKED)
+    running_injections_.push_back(injection.Pass());
+  scripts_run_info.LogRun(injection->web_frame(), UserScript::RUN_DEFERRED);
 }
 
 }  // namespace extensions