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/bind.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"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 35 matching lines @@
 
 using base::UserMetricsAction;
 using content::RenderFrameHost;
 using content::ResourceType;
 using content::WebContents;
 
 namespace extensions {
 
 namespace {
 
+using GetNextUniqueIDFunction = base::Callback<int(void)>;

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

remove

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

Done.

+
+using WebViewKey = std::pair<int, int>;
+using WebViewKeyToIDMap = std::map<WebViewKey, int>;
+base::LazyInstance<WebViewKeyToIDMap> web_view_key_to_id_map =
+    LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<WebViewKeyToIDMap> unique_instance_id_map =
+     LAZY_INSTANCE_INITIALIZER;
+
+int current_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";
 }
 
+bool GetIDFromMap(const WebViewKey& key,

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

Add a comment - something like "Looks up the id for the given |key| in |map|,
setting |result| with the value.  If |key| is invalid, |result| is set to
|default_id|. Returns true if |result| was set."

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

Thanks:)

+                   const WebViewKeyToIDMap& map,

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

indentation

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

Done.

+                   int default_id,
+                   int* result) {
+  WebViewKeyToIDMap::const_iterator iter = map.end();
+  if (!key.first || !key.second)
+    *result = default_id;
+  else if ((iter = map.find(key)) != map.end())
+    *result = iter->second;
+  else
+    return false;
+  return true;
+}
+
 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 61 matching lines @@
   // The partition name is user supplied value, which we have encoded when the
   // URL was created, so it needs to be decoded.
   *partition_name =
       net::UnescapeURLComponent(site.query(), net::UnescapeRule::NORMAL);
   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
 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;
+    int web_view_instance_id) {
+  WebViewKey key(embedder_process_id, web_view_instance_id);
+  WebViewKeyToIDMap& map = web_view_key_to_id_map.Get();
+  int id = 0;
+  if (!GetIDFromMap(
+      key, map, RulesRegistryService::kDefaultRulesRegistryID, &id)) {
+    auto rph = content::RenderProcessHost::FromID(embedder_process_id);
+    id = RulesRegistryService::Get(rph->GetBrowserContext())->
+        GetNextRulesRegistryID();
+    map[key] = id;
+  }
+  return id;
 }
 
 // static
+int WebViewGuest::GetOrGenerateUniqueInstanceID(
+    int embedder_process_id,
+    int guest_instance_id ) {
+  WebViewKey key(embedder_process_id, guest_instance_id);
+  WebViewKeyToIDMap& map = unique_instance_id_map.Get();
+  int id = 0;
+  if (!GetIDFromMap(key, map, HostID::kDefaultInstanceId, &id)) {
+    id = ++current_instance_id;
+    map[key] = id;
+  }
+  return 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());
 
+  GetOrGenerateUniqueInstanceID(
+      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);
+  unique_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