[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.h"
 #include "extensions/common/extension_messages.h"
-#include "extensions/common/feature_switch.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/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 {
 
 typedef std::map<std::string, int> IsolatedWorldMap;
 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 88 matching lines @@
     NotifyWillNotInject(ScriptInjector::EXTENSION_REMOVED);
     return true;  // We're done.
   }
 
   switch (injector_->CanExecuteOnFrame(
       extension, 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(extension, scripts_run_info);
       return true;  // We're done!
   }
 
   // Some compilers don't realize that we always return from the switch() above.
   // Make them happy.

[not at google - send to devlin, 2015/02/13 23:09:32]

(btw: not really, it's possible to case any random number to a RunLocation. This
isn't Java so the compiler can't guarantee it. The comment is rather unnecessary
- but it's good to NOTREACH()).

[Devlin, 2015/02/17 21:52:18]

Done.

   return false;
 }
 
 bool ScriptInjection::OnPermissionGranted(const Extension* extension,
                                           ScriptsRunInfo* scripts_run_info) {
   if (!extension) {
     NotifyWillNotInject(ScriptInjector::EXTENSION_REMOVED);
     return false;
   }
 
   Inject(extension, 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(),
       extension_id_,
       injector_->script_type(),
       request_id_));
 }
 
 void ScriptInjection::NotifyWillNotInject(
     ScriptInjector::InjectFailureReason reason) {
   complete_ = true;
   injector_->OnWillNotInject(reason);
 }
 
+void ScriptInjection::NotifyBrowserOfInjection(const Extension* extension) {
+  // We notify the browser of any injection if the extension has no withheld
+  // permissions (i.e., the permissions weren't restricted), but would have
+  // otherwise been affected by the scripts-require-action feature.
+  if (extension->permissions_data()->withheld_permissions()->IsEmpty() &&
+      PermissionsData::ScriptsMayRequireActionForExtension(
+          extension,
+          extension->permissions_data()->active_permissions().get())) {
+    SendInjectionMessage(false /* don't request permission */);
+  }
+}
+
 void ScriptInjection::Inject(const Extension* extension,
                              ScriptsRunInfo* scripts_run_info) {
   DCHECK(extension);
   DCHECK(scripts_run_info);
   DCHECK(!complete_);
 
-  if (ShouldNotifyBrowserOfInjections())
-    RequestPermission();
+  NotifyBrowserOfInjection(extension);
 
   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 96 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