Renderer changes for wiring up shared memory with declarative injection

extensions/renderer/user_script_set.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/user_script_set.h"
 
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
@@ skipping 54 matching lines @@
     int tab_id,
     UserScript::RunLocation run_location) {
   GURL document_url = GetDocumentUrlForFrame(web_frame);
   for (ScopedVector<UserScript>::const_iterator iter = scripts_.begin();
        iter != scripts_.end();
        ++iter) {
     const Extension* extension = extensions_->GetByID((*iter)->extension_id());
     if (!extension)
       continue;
     scoped_ptr<ScriptInjection> injection = GetInjectionForScript(
-        *iter, web_frame, tab_id, run_location, document_url, extension);
+        *iter,
+        web_frame,
+        tab_id,
+        run_location,
+        document_url,
+        extension,
+        false /* is_declarative */);
     if (injection.get())
       injections->push_back(injection.release());
   }
 }
 
 bool UserScriptSet::UpdateUserScripts(
     base::SharedMemoryHandle shared_memory,
     const std::set<std::string>& changed_extensions) {
   bool only_inject_incognito =
       ExtensionsRendererClient::Get()->IsIncognitoProcess();
@@ skipping 50 matching lines @@
 
     scripts_.push_back(script.release());
   }
 
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnUserScriptsUpdated(changed_extensions, scripts_.get()));
   return true;
 }
 
+scoped_ptr<ScriptInjection> UserScriptSet::GetInjectionByScriptID(
+    int script_id,
+    blink::WebFrame* web_frame,
+    int tab_id,
+    UserScript::RunLocation run_location,
+    const GURL& document_url,
+    const Extension* extension) {
+  for (ScopedVector<UserScript>::const_iterator it = scripts_.begin();
+       it != scripts_.end();
+       ++it) {
+    if ((*it)->id() == script_id) {
+      return GetInjectionForScript(*it,
+                                   web_frame,
+                                   tab_id,
+                                   run_location,
+                                   document_url,
+                                   extension,
+                                   true /* is_declarative */);
+    }
+  }
+  return scoped_ptr<ScriptInjection>();
+}
+
 scoped_ptr<ScriptInjection> UserScriptSet::GetInjectionForScript(
     UserScript* script,
     blink::WebFrame* web_frame,
     int tab_id,
     UserScript::RunLocation run_location,
     const GURL& document_url,
-    const Extension* extension) {
+    const Extension* extension,
+    bool is_declarative) {
   scoped_ptr<ScriptInjection> injection;
   if (web_frame->parent() && !script->match_all_frames())
     return injection.Pass();  // Only match subframes if the script declared it.
 
   GURL effective_document_url = ScriptContext::GetEffectiveDocumentURL(
       web_frame, document_url, script->match_about_blank());
 
   if (!script->MatchesURL(effective_document_url))
     return injection.Pass();
 
-  if (extension->permissions_data()->GetContentScriptAccess(
+  scoped_ptr<ScriptInjector> injector(new UserScriptInjector(script,
+                                                             this,
+                                                             is_declarative));
+  if (injector->CanExecuteOnFrame(
           extension,
-          effective_document_url,
-          web_frame->top()->document().url(),
+          web_frame,
           -1,  // Content scripts are not tab-specific.
-          -1,  // We don't have a process id in this context.
-          NULL /* ignore error */) == PermissionsData::ACCESS_DENIED) {
+          web_frame->top()->document().url()) ==
+      PermissionsData::ACCESS_DENIED) {
     return injection.Pass();
   }
 
   bool inject_css = !script->css_scripts().empty() &&
                     run_location == UserScript::DOCUMENT_START;
   bool inject_js =
       !script->js_scripts().empty() && script->run_location() == run_location;
   if (inject_css || inject_js) {
     injection.reset(new ScriptInjection(
-        scoped_ptr<ScriptInjector>(new UserScriptInjector(script, this)),
+        injector.Pass(),
         web_frame,
         extension->id(),
         run_location,
         tab_id));
   }
   return injection.Pass();
 }
 
 }  // namespace extensions