Remove WebViewKey in rules registry.

extensions/browser/api/declarative/rules_registry_service.cc

 // Copyright (c) 2012 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/api/declarative/rules_registry_service.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/api/declarative/rules_cache_delegate.h"
 #include "extensions/browser/api/declarative_content/content_rules_registry.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/web_request/web_request_api.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/guest_view/web_view/web_view_guest.h"

[Fady Samuel, 2014/11/26 23:39:40]

Avoid this include.

[Xi Han, 2014/11/27 23:25:25]

Done.

 #include "extensions/common/extension.h"
 
 namespace extensions {
 
 namespace {
 
 // Registers |web_request_rules_registry| on the IO thread.
 void RegisterToExtensionWebRequestEventRouterOnIO(
     content::BrowserContext* browser_context,
-    const RulesRegistryService::WebViewKey& webview_key,
+    int rules_registry_id,
     scoped_refptr<WebRequestRulesRegistry> web_request_rules_registry) {
   ExtensionWebRequestEventRouter::GetInstance()->RegisterRulesRegistry(
-      browser_context, webview_key, web_request_rules_registry);
-}
-
-bool IsWebView(const RulesRegistryService::WebViewKey& webview_key) {
-  return webview_key.embedder_process_id && webview_key.webview_instance_id;
+      browser_context, rules_registry_id, web_request_rules_registry);
 }
 
 }  // namespace
 
 RulesRegistryService::RulesRegistryService(content::BrowserContext* context)
-    : content_rules_registry_(NULL),
+    : current_rules_registry_id_(0),
+      content_rules_registry_(NULL),
       extension_registry_observer_(this),
       browser_context_(context) {
   if (browser_context_) {
     extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
     registrar_.Add(
         this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
         content::NotificationService::AllBrowserContextsAndSources());
-    EnsureDefaultRulesRegistriesRegistered(WebViewKey(0, 0));
+    EnsureDefaultRulesRegistriesRegistered(kDefultRulesRegistryID, false);
   }
 }
 
 RulesRegistryService::~RulesRegistryService() {}
 
+int RulesRegistryService::GetNextRulesRegistryId() {

[Fady Samuel, 2014/11/26 23:39:40]

GetNextRulesRegistryID

[Xi Han, 2014/11/27 23:25:25]

Done.

+  return ++current_rules_registry_id_;
+}
+
 void RulesRegistryService::EnsureDefaultRulesRegistriesRegistered(
-    const WebViewKey& webview_key) {
+    int rules_registry_id,
+    bool is_web_view) {

[Fady Samuel, 2014/11/26 23:39:40]

bool cache_rules

[Xi Han, 2014/11/27 23:25:25]

Done.

   if (!browser_context_)
     return;
-
   RulesRegistryKey key(declarative_webrequest_constants::kOnRequest,
-                       webview_key);
+                       rules_registry_id);
   // If we can find the key in the |rule_registries_| then we have already
   // installed the default registries.
   if (ContainsKey(rule_registries_, key))
     return;
 
 
   RulesCacheDelegate* web_request_cache_delegate = NULL;
-  if (!IsWebView(webview_key)) {
+  if (!is_web_view) {

[Fady Samuel, 2014/11/26 23:39:40]

if (!cache_rules)

[Xi Han, 2014/11/27 23:25:25]

Done.

     web_request_cache_delegate =
         new RulesCacheDelegate(true /*log_storage_init_delay*/);
     cache_delegates_.push_back(web_request_cache_delegate);
   }
   scoped_refptr<WebRequestRulesRegistry> web_request_rules_registry(
-      new WebRequestRulesRegistry(browser_context_,
-                                  web_request_cache_delegate,
-                                  webview_key));
+      new WebRequestRulesRegistry(browser_context_, web_request_cache_delegate,
+                                  rules_registry_id));
 
   RegisterRulesRegistry(web_request_rules_registry);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&RegisterToExtensionWebRequestEventRouterOnIO,
-          browser_context_, webview_key, web_request_rules_registry));
+                 browser_context_, rules_registry_id,
+                 web_request_rules_registry));
 
   // Only create a ContentRulesRegistry for regular pages and not webviews.
-  if (!IsWebView(webview_key)) {
+  if (!is_web_view) {

[Fady Samuel, 2014/11/26 23:39:41]

!cache_rules

[Xi Han, 2014/11/27 23:25:25]

Done.

     RulesCacheDelegate* content_rules_cache_delegate =
         new RulesCacheDelegate(false /*log_storage_init_delay*/);
     cache_delegates_.push_back(content_rules_cache_delegate);
     scoped_refptr<ContentRulesRegistry> content_rules_registry =
         ExtensionsAPIClient::Get()->CreateContentRulesRegistry(
             browser_context_, content_rules_cache_delegate);
     if (content_rules_registry.get() != nullptr) {
       RegisterRulesRegistry(content_rules_registry);
       content_rules_registry_ = content_rules_registry.get();
     }
   }
 }
 
 void RulesRegistryService::Shutdown() {
   // Release the references to all registries. This would happen soon during
   // destruction of |*this|, but we need the ExtensionWebRequestEventRouter to
   // be the last to reference the WebRequestRulesRegistry objects, so that
   // the posted task below causes their destruction on the IO thread, not on UI
   // where the destruction of |*this| takes place.
   // TODO(vabr): Remove once http://crbug.com/218451#c6 gets addressed.
   rule_registries_.clear();
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&RegisterToExtensionWebRequestEventRouterOnIO,
-          browser_context_, WebViewKey(0, 0),
-          scoped_refptr<WebRequestRulesRegistry>(NULL)));
+                 browser_context_, 0 /* not for web_view*/,

[Fady Samuel, 2014/11/26 23:39:41]

Use kDefaultRulesRegistryID

[Xi Han, 2014/11/27 23:25:25]

Done.

+                 scoped_refptr<WebRequestRulesRegistry>(NULL)));
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<RulesRegistryService> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<RulesRegistryService>*
 RulesRegistryService::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 RulesRegistryService* RulesRegistryService::Get(
     content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<RulesRegistryService>::Get(context);
 }
 
 void RulesRegistryService::RegisterRulesRegistry(
     scoped_refptr<RulesRegistry> rule_registry) {
   const std::string event_name(rule_registry->event_name());
-  RulesRegistryKey key(event_name, rule_registry->webview_key());
+  RulesRegistryKey key(event_name, rule_registry->rules_registry_id());

[Fady Samuel, 2014/11/26 23:39:40]

This seems really redundant. How about just calling it rule_registry->id()

[Xi Han, 2014/11/27 23:25:25]

Done.

   DCHECK(rule_registries_.find(key) == rule_registries_.end());
   rule_registries_[key] = rule_registry;
 }
 
 scoped_refptr<RulesRegistry> RulesRegistryService::GetRulesRegistry(
-    const WebViewKey& webview_key,
+    int rules_registry_id,
+    bool is_web_view,

[Fady Samuel, 2014/11/26 23:39:41]

bool cache_rules

[Xi Han, 2014/11/27 23:25:25]

Done.

     const std::string& event_name) {
-  EnsureDefaultRulesRegistriesRegistered(webview_key);
+  EnsureDefaultRulesRegistriesRegistered(rules_registry_id, is_web_view);
 
-  RulesRegistryKey key(event_name, webview_key);
+  RulesRegistryKey key(event_name, rules_registry_id);
   RulesRegistryMap::const_iterator i = rule_registries_.find(key);
   if (i == rule_registries_.end())
     return scoped_refptr<RulesRegistry>();
   return i->second;
 }
 
 void RulesRegistryService::RemoveWebViewRulesRegistries(int process_id) {

[Fady Samuel, 2014/11/26 23:39:41]

Can we move this to WebViewGuest?

[Xi Han, 2014/11/27 23:25:24]

Moved.

   DCHECK_NE(0, process_id);
 
   std::set<RulesRegistryKey> registries_to_delete;
   for (RulesRegistryMap::iterator it = rule_registries_.begin();
        it != rule_registries_.end(); ++it) {
     const RulesRegistryKey& key = it->first;
-    const WebViewKey& webview_key = key.webview_key;
-    int embedder_process_id = webview_key.embedder_process_id;
+    int rules_registry_id = key.rules_registry_id;
+    int embedder_process_id =
+        WebViewGuest::GetEmbedderProcessID(rules_registry_id);
     // |process_id| will always be non-zero.
     // |embedder_process_id| will only be non-zero if the key corresponds to a
     // webview registry.
     // Thus, |embedder_process_id| == |process_id| ==> the process ID is a
     // webview embedder.
     if (embedder_process_id != process_id)
       continue;
 
     // Modifying the container while iterating is bad so we'll save the keys we
     // wish to delete in another container, and delete them in another loop.
     registries_to_delete.insert(key);
   }
   for (std::set<RulesRegistryKey>::iterator it = registries_to_delete.begin();
        it != registries_to_delete.end(); ++it) {
+    WebViewGuest::RemoveRulesRegistryID(it->rules_registry_id);
     rule_registries_.erase(*it);
   }
 }
 
 void RulesRegistryService::SimulateExtensionUninstalled(
     const std::string& extension_id) {
   NotifyRegistriesHelper(&RulesRegistry::OnExtensionUninstalled, extension_id);
 }
 
 void RulesRegistryService::NotifyRegistriesHelper(
@@ skipping 39 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(content::NOTIFICATION_RENDERER_PROCESS_TERMINATED, type);
 
   content::RenderProcessHost* process =
       content::Source<content::RenderProcessHost>(source).ptr();
   RemoveWebViewRulesRegistries(process->GetID());
 }
 
 }  // namespace extensions