Create withheld permissions

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"
@@ skipping 22 matching lines @@
 
 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 ShouldDelayForPermission() {
-  return FeatureSwitch::scripts_require_action()->IsEnabled();
+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 83 matching lines @@
   if (request_id_ != kInvalidRequestId)
     return false;  // We're waiting for permission right now, try again later.
 
   if (!extension) {
     NotifyWillNotInject(ScriptInjector::EXTENSION_REMOVED);
     return true;  // We're done.
   }
 
   switch (injector_->CanExecuteOnFrame(
       extension, web_frame_, tab_id_, web_frame_->top()->document().url())) {
-    case ScriptInjector::DENY_ACCESS:
+    case PermissionsData::ACCESS_DENIED:
       NotifyWillNotInject(ScriptInjector::NOT_ALLOWED);
       return true;  // We're done.
-    case ScriptInjector::REQUEST_ACCESS:
+    case PermissionsData::ACCESS_WITHHELD:
       RequestPermission();
-      if (ShouldDelayForPermission())
-        return false;  // Wait around for permission.
-      // else fall through
-    case ScriptInjector::ALLOW_ACCESS:
+      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.
   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() {
   content::RenderView* render_view =
       content::RenderView::FromWebView(web_frame()->top()->view());
 
-  // If the feature to delay for permission isn't enabled, then just send an
+  // If we are just notifying the browser of the injection, then send an
   // invalid request (which is treated like a notification).
-  request_id_ =
-      ShouldDelayForPermission() ? g_next_pending_id++ : kInvalidRequestId;
+  request_id_ = ShouldNotifyBrowserOfInjections() ? kInvalidRequestId
+                                                  : g_next_pending_id++;
   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::Inject(const Extension* extension,
                              ScriptsRunInfo* scripts_run_info) {
   DCHECK(extension);
   DCHECK(scripts_run_info);
   DCHECK(!complete_);
 
+  if (ShouldNotifyBrowserOfInjections())
+    RequestPermission();
+
   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());
 
   bool inject_js = injector_->ShouldInjectJs(run_location_);
   bool inject_css = injector_->ShouldInjectCss(run_location_);
   DCHECK(inject_js || inject_css);
 
   scoped_ptr<base::ListValue> execution_results(new base::ListValue());
   GURL top_url = web_frame_->top()->document().url();
   for (std::vector<blink::WebFrame*>::iterator iter = frame_vector.begin();
        iter != frame_vector.end();
        ++iter) {
     blink::WebFrame* frame = *iter;
 
     // We recheck access here in the renderer for extra safety against races
     // with navigation, but different frames can have different URLs, and the
     // extension might only have access to a subset of them.
     // For child frames, we just skip ones the extension doesn't have access
     // to and carry on.
-    // Note: we don't consider REQUEST_ACCESS because there is nowhere to
+    // Note: we don't consider ACCESS_WITHHELD because there is nowhere to
     // surface a request for a child frame.
     // TODO(rdevlin.cronin): We should ask for permission somehow.
     if (injector_->CanExecuteOnFrame(extension, frame, tab_id_, top_url) ==
-        ScriptInjector::DENY_ACCESS) {
+        PermissionsData::ACCESS_DENIED) {
       DCHECK(frame->parent());
       continue;
     }
     if (inject_js)
       InjectJs(extension, frame, execution_results.get());
     if (inject_css)
       InjectCss(frame);
   }
 
   complete_ = true;
@@ skipping 63 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