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

extensions/browser/guest_view/web_view/web_view_guest.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/browser/guest_view/web_view/web_view_guest.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 41 matching lines @@
 
 using base::UserMetricsAction;
 using content::RenderFrameHost;
 using content::ResourceType;
 using content::WebContents;
 
 namespace extensions {
 
 namespace {
 
+int current_script_injection_instance_id = 0;
+
 std::string WindowOpenDispositionToString(
   WindowOpenDisposition window_open_disposition) {
   switch (window_open_disposition) {
     case IGNORE_ACTION:
       return "ignore";
     case SAVE_TO_DISK:
       return "save_to_disk";
     case CURRENT_TAB:
       return "current_tab";
     case NEW_BACKGROUND_TAB:
@@ skipping 21 matching lines @@
       return "killed";
     case base::TERMINATION_STATUS_PROCESS_CRASHED:
       return "crashed";
     case base::TERMINATION_STATUS_MAX_ENUM:
       break;
   }
   NOTREACHED() << "Unknown Termination Status.";
   return "unknown";
 }
 
+int GetNextScriptInjectionInstanceID() {
+  return ++current_script_injection_instance_id;
+}
+
 std::string GetStoragePartitionIdFromSiteURL(const GURL& site_url) {
   const std::string& partition_id = site_url.query();
   bool persist_storage = site_url.path().find("persist") != std::string::npos;
   return (persist_storage ? webview::kPersistPrefix : "") + partition_id;
 }
 
 void ParsePartitionParam(const base::DictionaryValue& create_params,
                          std::string* storage_partition_id,
                          bool* persist_storage) {
   std::string partition_str;
@@ skipping 65 matching lines @@
   return true;
 }
 
 // static
 const char WebViewGuest::Type[] = "webview";
 
 using WebViewKey = std::pair<int, int>;
 using WebViewKeyToIDMap = std::map<WebViewKey, int>;
 static base::LazyInstance<WebViewKeyToIDMap> web_view_key_to_id_map =
     LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<WebViewKeyToIDMap> script_injection_instance_id_map =

[Devlin, 2015/02/06 00:28:41]

It bothers me that we have multiple different maps of "webview to unique id". 
We should only ever need one unique id per webview, right?

[Xi Han, 2015/02/06 17:21:45]

We would like to have just one function, but the implementation of the Rule
Registry part calls RulesRegistryService::GetNextRulesRegistryID() to generate
the rule registry id, since the assignment of id is done by
RulesRegistryService. To generate the script_injection_instance_id, however, we
don't need the RulesRegistryService to make a decision, so we have to use
another map to stored the kv pairs, since the value may be different for the
same key in two maps. 

[Devlin, 2015/02/06 18:48:36]

But the RulesRegistry one is going away, right?

[Xi Han, 2015/02/06 19:45:33]

Hmmm, I don't think so, because the declarative webrequest still needs this map
to get an rule registry id for <webview>. 

[Devlin, 2015/02/09 17:40:24]

Ah, right.  In that case, can we make GetRulesRegistryId more generic, and just
say GetUniqueWebviewId, and use that for both rules registry and script
injection?  It just seems silly to have two maps used for generating a unique id
for a webview.

[Xi Han, 2015/02/09 23:28:11]

As discussed offline, we will still keeps two maps but will reorganize the code
and make it more generic.

+     LAZY_INSTANCE_INITIALIZER;
 
 // static
 int WebViewGuest::GetOrGenerateRulesRegistryID(
     int embedder_process_id,
     int webview_instance_id) {
   bool is_web_view = embedder_process_id && webview_instance_id;
   if (!is_web_view)
     return RulesRegistryService::kDefaultRulesRegistryID;
 
   WebViewKey key = std::make_pair(embedder_process_id, webview_instance_id);
   auto it = web_view_key_to_id_map.Get().find(key);
   if (it != web_view_key_to_id_map.Get().end())
     return it->second;
 
   auto rph = content::RenderProcessHost::FromID(embedder_process_id);
   int rules_registry_id =
       RulesRegistryService::Get(rph->GetBrowserContext())->
           GetNextRulesRegistryID();
   web_view_key_to_id_map.Get()[key] = rules_registry_id;
   return rules_registry_id;
 }
 
 // static
+int WebViewGuest:: GetOrGenerateScriptInjectionInstanceID(
+    int embedder_process_id,
+    int guest_instance_id ) {
+  if (!(embedder_process_id && guest_instance_id))
+    return Host::kDefaultInstanceId;
+
+  WebViewKey key = std::make_pair(embedder_process_id, guest_instance_id);
+  WebViewKeyToIDMap& script_injection_ids =
+      script_injection_instance_id_map.Get();
+  auto it = script_injection_ids.find(key);
+  if (it != script_injection_ids.end())
+    return it->second;
+
+  int script_injection_instance_id = GetNextScriptInjectionInstanceID();
+  script_injection_ids[key] = script_injection_instance_id;
+  return script_injection_instance_id;
+}
+
+// static
 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
   auto guest = FromWebContents(contents);
   if (!guest)
     return guestview::kInstanceIDNone;
 
   return guest->view_instance_id();
 }
 
 bool WebViewGuest::CanRunInDetachedState() const {
   return true;
@@ skipping 66 matching lines @@
                               content::Source<WebContents>(web_contents()));
 
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnDidInitialize();
   AttachWebViewHelpers(web_contents());
 
   rules_registry_id_ = GetOrGenerateRulesRegistryID(
       owner_web_contents()->GetRenderProcessHost()->GetID(),
       view_instance_id());
 
+  GetOrGenerateScriptInjectionInstanceID(
+      owner_web_contents()->GetRenderProcessHost()->GetID(),
+      guest_instance_id());
+
   // We must install the mapping from guests to WebViews prior to resuming
   // suspended resource loads so that the WebRequest API will catch resource
   // requests.
   PushWebViewStateToIOThread();
 
   ApplyAttributes(create_params);
 }
 
 void WebViewGuest::AttachWebViewHelpers(WebContents* contents) {
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnAttachWebViewHelpers(contents);
   web_view_permission_helper_.reset(new WebViewPermissionHelper(this));
 }
 
 void WebViewGuest::DidStopLoading() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEventToView(
       new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::EmbedderWillBeDestroyed() {
   // Clean up rules registries for the webview.
   RulesRegistryService::Get(browser_context())
       ->RemoveRulesRegistriesByID(rules_registry_id_);
   WebViewKey key(owner_web_contents()->GetRenderProcessHost()->GetID(),
                  view_instance_id());
   web_view_key_to_id_map.Get().erase(key);
+  script_injection_instance_id_map.Get().erase(key);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &RemoveWebViewEventListenersOnIOThread,
           browser_context(),
           owner_extension_id(),
           owner_web_contents()->GetRenderProcessHost()->GetID(),
           view_instance_id()));
@@ skipping 881 matching lines @@
       WebViewGuest::From(owner_web_contents()->GetRenderProcessHost()->GetID(),
                          new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }
 
 }  // namespace extensions