<webview>: Implement declarativeWebRequest API

chrome/browser/extensions/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 "chrome/browser/extensions/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 "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/declarative/initializing_rules_registry.h"
 #include "chrome/browser/extensions/api/declarative_content/content_rules_registry.h"
+#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/common/extensions/extension.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/render_process_host.h"
 
 namespace extensions {
 
 namespace {
 
 // Registers |web_request_rules_registry| on the IO thread.
 void RegisterToExtensionWebRequestEventRouterOnIO(
     void* profile,
+    const RulesRegistryService::WebViewKey& webview_key,
     scoped_refptr<WebRequestRulesRegistry> web_request_rules_registry) {
   ExtensionWebRequestEventRouter::GetInstance()->RegisterRulesRegistry(
-      profile, web_request_rules_registry);
+      profile, webview_key, web_request_rules_registry);
 }
 
 }  // namespace
 
 RulesRegistryService::RulesRegistryService(Profile* profile)
     : content_rules_registry_(NULL),
       profile_(profile) {
   if (profile) {
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
         content::Source<Profile>(profile->GetOriginalProfile()));
-    RegisterDefaultRulesRegistries();
+    registrar_.Add(
+        this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+        content::NotificationService::AllBrowserContextsAndSources());
   }
 }
 
 RulesRegistryService::~RulesRegistryService() {}
 
-void RulesRegistryService::RegisterDefaultRulesRegistries() {
+void RulesRegistryService::RegisterDefaultRulesRegistriesIfNotAvailable(
+    const WebViewKey& webview_key) {
+  if (!profile_)
+    return;
+
+  RulesRegistryKey key(declarative_webrequest_constants::kOnRequest,
+                       webview_key);
+  RulesRegistryMap::const_iterator i = rule_registries_.find(key);
+  // If we can find the key in the |rule_registries_| then we have already
+  // installed the default registries.
+  if (i != rule_registries_.end())
+    return;
+
   scoped_ptr<RulesRegistryWithCache::RuleStorageOnUI> ui_part;
   scoped_refptr<WebRequestRulesRegistry> web_request_rules_registry(
-      new WebRequestRulesRegistry(profile_, &ui_part));
+      new WebRequestRulesRegistry(profile_, &ui_part, webview_key));
   ui_parts_of_registries_.push_back(ui_part.release());
 
   RegisterRulesRegistry(web_request_rules_registry);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&RegisterToExtensionWebRequestEventRouterOnIO,
-          profile_, web_request_rules_registry));
+          profile_, webview_key, web_request_rules_registry));
 
 #if defined(ENABLE_EXTENSIONS)
-  scoped_refptr<ContentRulesRegistry> content_rules_registry(
-      new ContentRulesRegistry(profile_, &ui_part));
-  ui_parts_of_registries_.push_back(ui_part.release());
+  // Only create a ContentRulesRegistry for regular pages and not webviews.

[vabr (Chromium), 2013/10/25 20:40:24]

Is this a permanent design? In that case I find it confusing that
GetContentRulesRegistry has the |webview_key| argument. And even if there are
plans to add the content rules registry per-webview later, for now we should be
consistent with content_rules_registry_ being a single pointer.

[Fady Samuel, 2013/10/25 22:48:08]

There are no immediate plans to support content rules in webview. I'm not even
sure what that would mean. <webview> doesn't have page actions. Done.

+  if (!webview_key.first && !webview_key.second) {
+    scoped_refptr<ContentRulesRegistry> content_rules_registry(
+        new ContentRulesRegistry(profile_, &ui_part, webview_key));
+    ui_parts_of_registries_.push_back(ui_part.release());
 
-  RegisterRulesRegistry(content_rules_registry);
-  content_rules_registry_ = content_rules_registry.get();
+    RegisterRulesRegistry(content_rules_registry);
+    content_rules_registry_ = content_rules_registry.get();
+  }
 #endif  // defined(ENABLE_EXTENSIONS)
 }
 
 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,
-          profile_, scoped_refptr<WebRequestRulesRegistry>(NULL)));
+          profile_, WebViewKey(0, 0),
+          scoped_refptr<WebRequestRulesRegistry>(NULL)));
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<RulesRegistryService> >
 g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 ProfileKeyedAPIFactory<RulesRegistryService>*
 RulesRegistryService::GetFactoryInstance() {
   return &g_factory.Get();
 }
 
 // static
 RulesRegistryService* RulesRegistryService::Get(Profile* profile) {
   return ProfileKeyedAPIFactory<RulesRegistryService>::GetForProfile(profile);
 }
 
 void RulesRegistryService::RegisterRulesRegistry(
     scoped_refptr<RulesRegistry> rule_registry) {
   const std::string event_name(rule_registry->event_name());
-  DCHECK(rule_registries_.find(event_name) == rule_registries_.end());
-  rule_registries_[event_name] =
+  RulesRegistryKey key(event_name, rule_registry->webview_key());
+  DCHECK(rule_registries_.find(key) == rule_registries_.end());
+  rule_registries_[key] =
       make_scoped_refptr(new InitializingRulesRegistry(rule_registry));
 }
 
 scoped_refptr<RulesRegistry> RulesRegistryService::GetRulesRegistry(
-    const std::string& event_name) const {
-  RulesRegistryMap::const_iterator i = rule_registries_.find(event_name);
+    const WebViewKey& webview_key,
+    const std::string& event_name) {
+  RegisterDefaultRulesRegistriesIfNotAvailable(webview_key);
+
+  RulesRegistryKey key(event_name, webview_key);
+  RulesRegistryMap::const_iterator i = rule_registries_.find(key);
   if (i == rule_registries_.end())
     return scoped_refptr<RulesRegistry>();
   return i->second;
 }
 
+ContentRulesRegistry* RulesRegistryService::GetContentRulesRegistry(
+    const WebViewKey& webview_key) {
+  RegisterDefaultRulesRegistriesIfNotAvailable(webview_key);

[vabr (Chromium), 2013/10/25 20:40:24]

If somebody calls this with a webview_key other than <0,0>, no
content_rules_registry will be returned, by the corresponding webrequest
registry will be created. Is this expected? If yes, it should be documented at
the declaration of GetContentRulesRegistry.

[vabr (Chromium), 2013/10/25 20:40:24]

Also, is GetContentRulesRegistry called often? I'm concerned that the time
RegisterDefaultRulesRegistriesIfNotAvailable takes to realise that the content
registry has already been created is significantly longer than a simple check
whether content_rules_registry_ is NULL.

[Fady Samuel, 2013/10/25 22:48:08]

Done.

[Fady Samuel, 2013/10/25 22:48:08]

Done.

+  return content_rules_registry_;
+}
+
+void RulesRegistryService::RemoveWebViewRulesRegistries(int process_id) {
+  DCHECK_NE(0, process_id);
+
+  RulesRegistryKeySet 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.second;
+    int embedder_process_id = webview_key.first;
+    // |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);

[vabr (Chromium), 2013/10/25 20:40:24]

Is there a reason to first build the set of registries to delete, and then
RemoveRulesRegistry them? (Also, delete vs. remove may be confusing.) I think we
should RemoveRulesRegistry(key) directly, to avoid the overhead of creating a
set. Am I missing something?

[Fady Samuel, 2013/10/25 22:48:08]

Yes, I am iterating over a map |rules_registries_|. RemoveRulesRegistry modifies
that map. Modifying a map while iterating produces undefined behavior. Thus, we
find out which keys we need to delete, store them in a separate set and then
modify the original map.

[vabr (Chromium), 2013/10/28 14:46:09]

Ah, good point. That's all right then.

+  }
+  for (RulesRegistryKeySet::iterator it = registries_to_delete.begin();
+       it != registries_to_delete.end(); ++it) {
+    RemoveRulesRegistry(*it);
+  }
+}
+
 void RulesRegistryService::SimulateExtensionUnloaded(
     const std::string& extension_id) {
   OnExtensionUnloaded(extension_id);
 }
 
 void RulesRegistryService::OnExtensionUnloaded(
     const std::string& extension_id) {
   RulesRegistryMap::iterator i;
   for (i = rule_registries_.begin(); i != rule_registries_.end(); ++i) {
     scoped_refptr<RulesRegistry> registry = i->second;
     if (content::BrowserThread::CurrentlyOn(registry->owner_thread())) {
       registry->OnExtensionUnloaded(extension_id);
     } else {
       content::BrowserThread::PostTask(
           registry->owner_thread(),
           FROM_HERE,
           base::Bind(
               &RulesRegistry::OnExtensionUnloaded, registry, extension_id));
     }
   }
 }
 
+void RulesRegistryService::RemoveRulesRegistry(const RulesRegistryKey& key) {
+  rule_registries_.erase(key);
+}
+
 void RulesRegistryService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const Extension* extension =
           content::Details<UnloadedExtensionInfo>(details)->extension;
       OnExtensionUnloaded(extension->id());
       break;
     }
+    case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
+      content::RenderProcessHost* process =
+          content::Source<content::RenderProcessHost>(source).ptr();
+      RemoveWebViewRulesRegistries(process->GetID());
+      break;
+    }
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace extensions