Refactoring: de-couple Extensions from "script injection System" [render side]:3

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 "base/memory/ref_counted.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/renderer/extension_injection_host.h"
 #include "extensions/renderer/extensions_renderer_client.h"
+#include "extensions/renderer/injection_host.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_injection.h"
 #include "extensions/renderer/user_script_injector.h"
+#include "extensions/renderer/web_ui_injection_host.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 GURL GetDocumentUrlForFrame(blink::WebFrame* frame) {
   GURL data_source_url = ScriptContext::GetDataSourceURLForFrame(frame);
@@ skipping 20 matching lines @@
 
 void UserScriptSet::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void UserScriptSet::GetActiveExtensionIds(
     std::set<std::string>* ids) const {
   for (ScopedVector<UserScript>::const_iterator iter = scripts_.begin();
        iter != scripts_.end();
        ++iter) {
+    if ((*iter)->host_id().type() != HostID::EXTENSIONS)
+      continue;
     DCHECK(!(*iter)->extension_id().empty());
     ids->insert((*iter)->extension_id());
   }
 }
 
 void UserScriptSet::GetInjections(
     ScopedVector<ScriptInjection>* injections,
     blink::WebFrame* web_frame,
     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<InjectionHost> injection_host;
+    const HostID& host_id = (*iter)->host_id();
+
+    if (host_id.type() == HostID::EXTENSIONS) {
+      const Extension* extension  = extensions_->GetByID(host_id.id());
+      if (!extension)
+        continue;
+      injection_host.reset(new ExtensionInjectionHost(extension));
+    } else if (host_id.type() == HostID::WEBUI) {
+      injection_host.reset(new WebUIInjectionHost(host_id));
+    }
+
     scoped_ptr<ScriptInjection> injection = GetInjectionForScript(
         *iter,
         web_frame,
         tab_id,
         run_location,
         document_url,
-        extension,
+        injection_host.get(),
         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 =
@@ skipping 57 matching lines @@
                     OnUserScriptsUpdated(changed_extensions, scripts_.get()));
   return true;
 }
 
 scoped_ptr<ScriptInjection> UserScriptSet::GetDeclarativeScriptInjection(
     int script_id,
     blink::WebFrame* web_frame,
     int tab_id,
     UserScript::RunLocation run_location,
     const GURL& document_url,
-    const Extension* extension) {
+    const InjectionHost* injection_host) {
   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,
+                                   injection_host,
                                    true /* is_declarative */);
     }
   }
   return scoped_ptr<ScriptInjection>();
 }
 
 // TODO(dcheng): Scripts can't be injected on a remote frame, so this function
 // signature needs to be updated.
 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 InjectionHost* injection_host,

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

We should probably just create the injection host in this function (since we
pass in the script), rather than passing it around everywhere.

[Xi Han, 2015/02/18 21:11:46]

Done.

     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();
 
   scoped_ptr<ScriptInjector> injector(new UserScriptInjector(script,
                                                              this,
                                                              is_declarative));
-  HostID host_id(HostID::EXTENSIONS, extension->id());
-  ExtensionInjectionHost extension_injection_host(
-      make_scoped_refptr<const Extension>(extension));
   if (injector->CanExecuteOnFrame(
-          &extension_injection_host,
+          injection_host,
           web_frame,
           -1,  // Content scripts are not tab-specific.
           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(
         injector.Pass(),
         web_frame->toWebLocalFrame(),
-        host_id,
+        make_scoped_ptr(injection_host),
         script->consumer_instance_type(),
         run_location,
         tab_id));
   }
   return injection.Pass();
 }
 
 }  // namespace extensions