Stop injection when injections are invalidated

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"
@@ skipping 135 matching lines @@
   if (current_location < run_location_)
     return INJECTION_WAITING;  // Wait for the right location.
 
   if (request_id_ != kInvalidRequestId) {
     // We're waiting for permission right now, try again later.
     return INJECTION_WAITING;
   }
 
   if (!injection_host_) {
     NotifyWillNotInject(ScriptInjector::EXTENSION_REMOVED);
-    return INJECTION_FINISHED;  // We're done.
+    return INJECTION_CANCELED;  // We're done.
   }
 
   blink::WebLocalFrame* web_frame = render_frame_->GetWebFrame();
   switch (injector_->CanExecuteOnFrame(
       injection_host_.get(), web_frame,
       ExtensionFrameHelper::Get(render_frame_)->tab_id())) {
     case PermissionsData::ACCESS_DENIED:
       NotifyWillNotInject(ScriptInjector::NOT_ALLOWED);
       return INJECTION_FINISHED;  // We're done.
     case PermissionsData::ACCESS_WITHHELD:
       RequestPermissionFromBrowser();
       return INJECTION_WAITING;  // Wait around for permission.
     case PermissionsData::ACCESS_ALLOWED:
       InjectionResult result = Inject(scripts_run_info);
       // If the injection is blocked, we need to set the manager so we can
       // notify it upon completion.
       if (result == INJECTION_BLOCKED)
         async_completion_callback_ = async_completion_callback;
+      else if (result == INJECTION_CANCELED)
+        NotifyWillNotInject(ScriptInjector::EXTENSION_REMOVED);
       return result;
   }
 
   NOTREACHED();
   return INJECTION_FINISHED;
 }
 
 ScriptInjection::InjectionResult ScriptInjection::OnPermissionGranted(
     ScriptsRunInfo* scripts_run_info) {
   if (!injection_host_) {
@@ skipping 19 matching lines @@
 
 void ScriptInjection::NotifyWillNotInject(
     ScriptInjector::InjectFailureReason reason) {
   complete_ = true;
   injector_->OnWillNotInject(reason, render_frame_);
 }
 
 ScriptInjection::InjectionResult ScriptInjection::Inject(
     ScriptsRunInfo* scripts_run_info) {
   DCHECK(injection_host_);
+  DCHECK(render_frame_);
   DCHECK(scripts_run_info);
   DCHECK(!complete_);
 
   bool should_inject_js = injector_->ShouldInjectJs(run_location_);
   bool should_inject_css = injector_->ShouldInjectCss(run_location_);
   DCHECK(should_inject_js || should_inject_css);
 
-  if (should_inject_js)
+  if (should_inject_js) {
     InjectJs();
+    // InjectJs() may run arbitrary blocking JavaScript code for an unspecified
+    // amount of time and destroy the frame and/or injection host.
+    if (!injection_host_)
+      return INJECTION_CANCELED;
+    if (!render_frame_)
+      return INJECTION_FINISHED;
+  }
   if (should_inject_css)
     InjectCss();
 
   complete_ = did_inject_js_ || !should_inject_js;
 
   injector_->GetRunInfo(scripts_run_info, run_location_);
 
   if (complete_) {
     injector_->OnInjectionComplete(std::move(execution_result_), run_location_,
                                    render_frame_);
@@ skipping 34 matching lines @@
   } else {
     web_frame->requestExecuteScriptInIsolatedWorld(
         world_id,
         &sources.front(),
         sources.size(),
         EXTENSION_GROUP_CONTENT_SCRIPTS,
         is_user_gesture,
         callback.release());
   }
 
-  if (injection_host_->id().type() == HostID::EXTENSIONS)
+  if (injection_host_ && injection_host_->id().type() == HostID::EXTENSIONS)
     UMA_HISTOGRAM_TIMES("Extensions.InjectScriptTime", exec_timer.Elapsed());
 }
 
 void ScriptInjection::OnJsInjectionCompleted(
     const blink::WebVector<v8::Local<v8::Value> >& results) {
   DCHECK(!did_inject_js_);
 
   bool expects_results = injector_->ExpectsResults();
   if (expects_results) {
     if (!results.isEmpty() && !results[0].IsEmpty()) {
@@ skipping 25 matching lines @@
 
 void ScriptInjection::InjectCss() {
   std::vector<std::string> css_sources =
       injector_->GetCssSources(run_location_);
   blink::WebLocalFrame* web_frame = render_frame_->GetWebFrame();
   for (const std::string& css : css_sources)
     web_frame->document().insertStyleSheet(blink::WebString::fromUTF8(css));
 }
 
 }  // namespace extensions