Prepare declarativeContent API for new script injection feature. Added Javascript types and functio…

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 <utility>
+
 #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/rules_cache_delegate.h"
+#include "chrome/browser/extensions/api/declarative_content/content_constants.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/browser/profiles/profile.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"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/watched_pages_recipient.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, webview_key, web_request_rules_registry);
 }
 
 bool IsWebView(const RulesRegistryService::WebViewKey& webview_key) {
   return webview_key.embedder_process_id && webview_key.webview_instance_id;
 }
 
 }  // namespace
 
 RulesRegistryService::RulesRegistryService(content::BrowserContext* context)
-    : content_rules_registry_(NULL),
-      extension_registry_observer_(this),
+    : extension_registry_observer_(this),
       profile_(Profile::FromBrowserContext(context)) {
   if (profile_) {
     extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
     registrar_.Add(
         this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
         content::NotificationService::AllBrowserContextsAndSources());
     EnsureDefaultRulesRegistriesRegistered(WebViewKey(0, 0));
   }
 }
 
@@ skipping 24 matching lines @@
                                   webview_key));
 
   RegisterRulesRegistry(web_request_rules_registry);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&RegisterToExtensionWebRequestEventRouterOnIO,
           profile_, webview_key, web_request_rules_registry));
 
   // Only create a ContentRulesRegistry for regular pages and not webviews.
   if (!IsWebView(webview_key)) {
-    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(
-        new ContentRulesRegistry(profile_, content_rules_cache_delegate));
-    RegisterRulesRegistry(content_rules_registry);
-    content_rules_registry_ = content_rules_registry.get();
+    namespace dcc = declarative_content_constants;
+    typedef std::vector< std::pair<std::string, WatchedPagesRecipient> >

[Jeffrey Yasskin, 2014/06/27 22:03:41]

For something with a constant set of elements, I'd just use a C array. It's also
almost always more readable to use a locally-defined struct type, rather than
std::pair. You can't use a local type as a template argument, but that problem
goes away with an array.

[Mark Dittmer, 2014/06/30 12:34:02]

Done.

+        ContentRegistryIDList;
+    ContentRegistryIDList content_registry_ids;
+
+    // onPageChanged supports browser-side ShowPageAction. Browser-side rules
+    // registry must be notified.
+    content_registry_ids.push_back(
+        std::make_pair(dcc::kOnPageChanged, CONTENT_RULES_REGISTRY));
+
+    // onDocument- Start/End/Idle supports renderer-side RequestContentScript.
+    // Renderer-side user script manager must be notified.
+    content_registry_ids.push_back(
+        std::make_pair(dcc::kOnDocumentStart, USER_SCRIPT_MANAGER));
+    content_registry_ids.push_back(
+        std::make_pair(dcc::kOnDocumentEnd, USER_SCRIPT_MANAGER));
+    content_registry_ids.push_back(
+        std::make_pair(dcc::kOnDocumentIdle, USER_SCRIPT_MANAGER));
+
+    for (ContentRegistryIDList::const_iterator it =
+             content_registry_ids.begin();
+         it != content_registry_ids.end(); ++it) {
+      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(
+          new ContentRulesRegistry(profile_,
+                                   it->first, // event_name.
+                                   it->second, // watched_pages_recipient.
+                                   content_rules_cache_delegate));
+      RegisterRulesRegistry(content_rules_registry);
+      content_rules_registry_map_.insert(
+          std::make_pair(it->first,  // event_name.
+                         content_rules_registry.get()));

[Jeffrey Yasskin, 2014/06/27 22:03:41]

This is going to use the registry after it's been freed, since the
content_rules_registry_map_ stores a raw pointer.

[Mark Dittmer, 2014/06/30 11:50:35]

How is this different from how the code was before? I thought the idea was that
we keep a "convenient" raw pointer to the content rules registry/registries that
is only accessed in code paths that are outlived by the scoped (managed)
pointer.

[Jeffrey Yasskin, 2014/07/15 17:12:58]

Whoops, you're right. Never mind.

+    }
   }
 }
 
 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.
@@ skipping 33 matching lines @@
     const std::string& event_name) {
   EnsureDefaultRulesRegistriesRegistered(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 std::string& event_name) {
+  ContentRulesRegistryMap::iterator it =
+      content_rules_registry_map_.find(event_name);
+  if (it == content_rules_registry_map_.end())
+    return NULL;
+
+  return content_rules_registry_map_[event_name];
+}
+
+
 void RulesRegistryService::RemoveWebViewRulesRegistries(int process_id) {
   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;
     // |process_id| will always be non-zero.
@@ skipping 61 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