[Extensions] Adjust script injection reporting to the browser side

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 "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/extension_messages.h"
-#include "extensions/common/feature_switch.h"
 #include "extensions/common/host_id.h"
 #include "extensions/common/manifest_handlers/csp_info.h"
 #include "extensions/renderer/dom_activity_logger.h"
 #include "extensions/renderer/extension_groups.h"
 #include "extensions/renderer/extension_injection_host.h"
 #include "extensions/renderer/extensions_renderer_client.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"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 using IsolatedWorldMap = std::map<std::string, int>;
 base::LazyInstance<IsolatedWorldMap> g_isolated_worlds =
     LAZY_INSTANCE_INITIALIZER;
 
 const int64 kInvalidRequestId = -1;
 
 // The id of the next pending injection.
 int64 g_next_pending_id = 0;
 
-bool ShouldNotifyBrowserOfInjections() {
-  return !FeatureSwitch::scripts_require_action()->IsEnabled();
-}
-
 // Append all the child frames of |parent_frame| to |frames_vector|.
 void AppendAllChildFrames(blink::WebFrame* parent_frame,
                           std::vector<blink::WebFrame*>* frames_vector) {
   DCHECK(parent_frame);
   for (blink::WebFrame* child_frame = parent_frame->firstChild(); child_frame;
        child_frame = child_frame->nextSibling()) {
     frames_vector->push_back(child_frame);
     AppendAllChildFrames(child_frame, frames_vector);
   }
 }
@@ skipping 85 matching lines @@
     NotifyWillNotInject(ScriptInjector::EXTENSION_REMOVED);
     return true;  // We're done.
   }
 
   switch (injector_->CanExecuteOnFrame(injection_host, web_frame_, tab_id_,
                                        web_frame_->top()->document().url())) {
     case PermissionsData::ACCESS_DENIED:
       NotifyWillNotInject(ScriptInjector::NOT_ALLOWED);
       return true;  // We're done.
     case PermissionsData::ACCESS_WITHHELD:
-      RequestPermission();
+      SendInjectionMessage(true /* request permission */);
       return false;  // Wait around for permission.
     case PermissionsData::ACCESS_ALLOWED:
       Inject(injection_host, scripts_run_info);
       return true;  // We're done!
   }
 
-  // Some compilers don't realize that we always return from the switch() above.
-  // Make them happy.
+  NOTREACHED();
   return false;
 }
 
 bool ScriptInjection::OnPermissionGranted(const InjectionHost* injection_host,
                                           ScriptsRunInfo* scripts_run_info) {
   if (!injection_host) {
     NotifyWillNotInject(ScriptInjector::EXTENSION_REMOVED);
     return false;
   }
 
   Inject(injection_host, scripts_run_info);
   return true;
 }
 
-void ScriptInjection::RequestPermission() {
+void ScriptInjection::SendInjectionMessage(bool request_permission) {
   content::RenderView* render_view =
       content::RenderView::FromWebView(web_frame()->top()->view());
 
   // If we are just notifying the browser of the injection, then send an
   // invalid request (which is treated like a notification).
-  request_id_ = ShouldNotifyBrowserOfInjections() ? kInvalidRequestId
-                                                  : g_next_pending_id++;
+  request_id_ = request_permission ? g_next_pending_id++ : kInvalidRequestId;
   render_view->Send(new ExtensionHostMsg_RequestScriptInjectionPermission(
       render_view->GetRoutingID(),
       host_id_.id(),
       injector_->script_type(),
       request_id_));
 }
 
 void ScriptInjection::NotifyWillNotInject(
     ScriptInjector::InjectFailureReason reason) {
   complete_ = true;
   injector_->OnWillNotInject(reason);
 }
 
 void ScriptInjection::Inject(const InjectionHost* injection_host,
                              ScriptsRunInfo* scripts_run_info) {
   DCHECK(injection_host);
   DCHECK(scripts_run_info);
   DCHECK(!complete_);
 
-  if (ShouldNotifyBrowserOfInjections() &&
-      injection_host->id().type() == HostID::EXTENSIONS)
-    RequestPermission();
+  if (injection_host->ShouldNotifyBrowserOfInjection())
+    SendInjectionMessage(false /* don't request permission */);
 
   std::vector<blink::WebFrame*> frame_vector;
   frame_vector.push_back(web_frame_);
   if (injector_->ShouldExecuteInChildFrames())
     AppendAllChildFrames(web_frame_, &frame_vector);
 
   scoped_ptr<blink::WebScopedUserGesture> gesture;
   if (injector_->IsUserGesture())
     gesture.reset(new blink::WebScopedUserGesture());
 
@@ skipping 100 matching lines @@
   std::vector<std::string> css_sources =
       injector_->GetCssSources(run_location_);
   for (std::vector<std::string>::const_iterator iter = css_sources.begin();
        iter != css_sources.end();
        ++iter) {
     frame->document().insertStyleSheet(blink::WebString::fromUTF8(*iter));
   }
 }
 
 }  // namespace extensions