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

extensions/renderer/script_injection_manager.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_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/renderer/extension_helper.h"
+#include "extensions/renderer/extension_injection_host.h"
 #include "extensions/renderer/programmatic_script_injector.h"
 #include "extensions/renderer/script_injection.h"
 #include "extensions/renderer/scripts_run_info.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "url/gurl.h"
 
@@ skipping 17 matching lines @@
     case UserScript::UNDEFINED:
     case UserScript::RUN_DEFERRED:
     case UserScript::BROWSER_DRIVEN:
     case UserScript::RUN_LOCATION_LAST:
       break;
   }
   NOTREACHED();
   return UserScript::RUN_LOCATION_LAST;
 }
 
+
+// TODO(hanxi): let ScriptInjection own an InjectionHost to avoid constructing
+// an ExtensionInjectionHost many times.
+// Note: the ScriptInjection should be able to know when the backing extension
+// is removed.
+scoped_ptr<ExtensionInjectionHost> GetExtensionInjectionHost(
+    const std::string& extension_id, const ExtensionSet* extensions) {
+  const Extension* extension = extensions->GetByID(extension_id);
+  if (!extension)
+    return scoped_ptr<ExtensionInjectionHost>();
+  return scoped_ptr<ExtensionInjectionHost>(
+      new ExtensionInjectionHost(extension));
+}
+
 }  // namespace
 
 class ScriptInjectionManager::RVOHelper : public content::RenderViewObserver {
  public:
   RVOHelper(content::RenderView* render_view, ScriptInjectionManager* manager);
   ~RVOHelper() override;
 
  private:
   // RenderViewObserver implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
@@ skipping 175 matching lines @@
     content::RenderView* render_view) {
   rvo_helpers_.push_back(new RVOHelper(render_view, this));
 }
 
 void ScriptInjectionManager::OnUserScriptsUpdated(
     const std::set<std::string>& changed_extensions,
     const std::vector<UserScript*>& scripts) {
   for (ScopedVector<ScriptInjection>::iterator iter =
            pending_injections_.begin();
        iter != pending_injections_.end();) {
-    if (changed_extensions.count((*iter)->extension_id()) > 0)
+    if (changed_extensions.count((*iter)->host_id().id()) > 0)
       iter = pending_injections_.erase(iter);
     else
       ++iter;
   }
 
   // If we are currently injecting scripts, we need to make a note that these
   // extensions were updated.
   if (injecting_scripts_) {
     invalidated_while_injecting_.insert(changed_extensions.begin(),
                                         changed_extensions.end());
@@ skipping 109 matching lines @@
       &frame_injections, frame, tab_id, run_location);
 
   ScriptsRunInfo scripts_run_info;
   for (ScopedVector<ScriptInjection>::iterator iter = frame_injections.begin();
        iter != frame_injections.end();) {
     // If a blocking script was injected, there is potentially a possibility
     // that the frame has been invalidated in the time since. Check.
     if (!IsFrameValid(frame))
       break;
 
+    const std::string extension_id = (*iter)->host_id().id();
+    scoped_ptr<ExtensionInjectionHost> extension_injection_host =
+        GetExtensionInjectionHost(extension_id, extensions_);
     // Try to inject the script if the extension is not "dirty" (invalidated by
     // an update). If the injection does not finish (i.e., it is waiting for
     // permission), add it to the list of pending injections.
-    if (invalidated_while_injecting_.count((*iter)->extension_id()) == 0 &&
+    if (invalidated_while_injecting_.count(extension_id) == 0 &&
         !(*iter)->TryToInject(run_location,
-                              extensions_->GetByID((*iter)->extension_id()),
+                              extension_injection_host.get(),
                               &scripts_run_info)) {
       pending_injections_.insert(pending_injections_.begin(), *iter);
       iter = frame_injections.weak_erase(iter);
     } else {
       ++iter;
     }
   }
 
   if (IsFrameValid(frame))
     scripts_run_info.LogRun(frame, run_location);
@@ skipping 16 matching lines @@
                                                  "No main frame",
                                                  GURL(std::string()),
                                                  base::ListValue()));
     return;
   }
 
   scoped_ptr<ScriptInjection> injection(new ScriptInjection(
       scoped_ptr<ScriptInjector>(
           new ProgrammaticScriptInjector(params, main_frame)),
       main_frame,
-      params.extension_id,
+      HostID(HostID::EXTENSIONS, params.extension_id),
+      params.is_web_view ? params.instance_id : HostID::kDefaultInstanceId,

[Devlin, 2015/02/11 00:00:48]

I think there was a thread on this part that I lost somewhere.  Anyway....
We can make this just params.instance_id, since instance_id is always set in
ScriptExecutor (to either be a unique instance id or
HostID::kDefaultInstanceId).  Right?

[Xi Han, 2015/02/11 16:00:24]

Sorry I might not make myself clear. I add this check just in case
HostID::kDefaultInstanceId is assigned to a different value (not 0) in the
future, the instance_id for non-webview can always sync with
HostID::kDefaultInstanceId and be set a correctly value. This is because we
didn't explicitly set instance_id for non-webview, so its value is always 0, but
maybe different from HostID::kDefaultInstanceId.

[Devlin, 2015/02/11 20:19:44]

But we already explicitly set params.instance_id to be
HostID::kDefaultInstanceId (whether or not it's 0) on the browser side (in
ScriptExecutor, passed in the value from the tabs api and execute code
function).  So we already know that params.instance_id will either be
HostID::kDefaultInstanceId or will be a unique webview id.  We don't need this
check here.  Right?

[Xi Han, 2015/02/11 21:19:09]

As discussed offline, we will remove this check here. Instead, explicitly set
instance_id in accessibility_manager.cc.

       static_cast<UserScript::RunLocation>(params.run_at),
       ExtensionHelper::Get(render_view)->tab_id()));
 
   ScriptsRunInfo scripts_run_info;
   FrameStatusMap::const_iterator iter = frame_statuses_.find(main_frame);
+
+  scoped_ptr<ExtensionInjectionHost> extension_injection_host =
+      GetExtensionInjectionHost(injection->host_id().id(), extensions_);
+
   if (!injection->TryToInject(
           iter == frame_statuses_.end() ? UserScript::UNDEFINED : iter->second,
-          extensions_->GetByID(injection->extension_id()),
+          extension_injection_host.get(),
           &scripts_run_info)) {
     pending_injections_.push_back(injection.release());
   }
 }
 
 void ScriptInjectionManager::HandleExecuteDeclarativeScript(
     blink::WebFrame* web_frame,
     int tab_id,
     const ExtensionId& extension_id,
     int script_id,
     const GURL& url) {
+  scoped_ptr<ExtensionInjectionHost> extension_injection_host =
+      GetExtensionInjectionHost(extension_id, extensions_);
   const Extension* extension = extensions_->GetByID(extension_id);
   // TODO(dcheng): This function signature should really be a WebLocalFrame,
   // rather than trying to coerce it here.
   scoped_ptr<ScriptInjection> injection =
       user_script_set_manager_->GetInjectionForDeclarativeScript(
           script_id,
           web_frame->toWebLocalFrame(),
           tab_id,
           url,
           extension);
   if (injection.get()) {
     ScriptsRunInfo scripts_run_info;
     // TODO(markdittmer): Use return value of TryToInject for error handling.
     injection->TryToInject(UserScript::BROWSER_DRIVEN,
-                           extension,
+                           extension_injection_host.get(),
                            &scripts_run_info);
     scripts_run_info.LogRun(web_frame, UserScript::BROWSER_DRIVEN);
   }
 }
 
 void ScriptInjectionManager::HandlePermitScriptInjection(int64 request_id) {
   ScopedVector<ScriptInjection>::iterator iter =
       pending_injections_.begin();
   for (; iter != pending_injections_.end(); ++iter) {
     if ((*iter)->request_id() == request_id)
       break;
   }
   if (iter == pending_injections_.end())
     return;
 
   // At this point, because the request is present in pending_injections_, we
   // know that this is the same page that issued the request (otherwise,
   // RVOHelper's DidStartProvisionalLoad callback would have caused it to be
   // cleared out).
 
   scoped_ptr<ScriptInjection> injection(*iter);
   pending_injections_.weak_erase(iter);
 
   ScriptsRunInfo scripts_run_info;
-  if (injection->OnPermissionGranted(extensions_->GetByID(
-                                         injection->extension_id()),
+  scoped_ptr<ExtensionInjectionHost> extension_injection_host =
+      GetExtensionInjectionHost(injection->host_id().id(), extensions_);
+  if (injection->OnPermissionGranted(extension_injection_host.get(),
                                      &scripts_run_info)) {
     scripts_run_info.LogRun(injection->web_frame(), UserScript::RUN_DEFERRED);
   }
 }
 
 }  // namespace extensions