Decouple RulesCacheDelegate from RulesRegistry

chrome/browser/extensions/api/declarative_content/content_rules_registry.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_content/content_rules_registry.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/declarative_content/content_action.h"
 #include "chrome/browser/extensions/api/declarative_content/content_condition.h"
 #include "chrome/browser/extensions/api/declarative_content/content_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/navigation_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 "content/public/browser/web_contents.h"
 
 namespace extensions {
 
-ContentRulesRegistry::ContentRulesRegistry(
-    Profile* profile,
-    scoped_ptr<RulesCacheDelegate>* cache_delegate)
-    : RulesRegistry((cache_delegate ? profile : NULL),
+ContentRulesRegistry::ContentRulesRegistry(Profile* profile)
+    : RulesRegistry(profile,
                     declarative_content_constants::kOnPageChanged,
-                    content::BrowserThread::UI,
-                    false /*log_storage_init_delay*/,
-                    cache_delegate),
-      profile_(profile) {
+                    content::BrowserThread::UI) {
   extension_info_map_ = ExtensionSystem::Get(profile)->info_map();
 
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 void ContentRulesRegistry::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
       content::RenderProcessHost* process =
           content::Source<content::RenderProcessHost>(source).ptr();
-      if (process->GetBrowserContext() == profile_)
+      if (process->GetBrowserContext() == profile())
         InstructRenderProcess(process);
       break;
     }
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
       content::WebContents* tab =
           content::Source<content::WebContents>(source).ptr();
       // GetTabId() returns -1 for non-tab WebContents, which won't be
       // in the map.  Similarly, tabs from other profiles won't be in
       // the map.
       active_rules_.erase(ExtensionTabUtil::GetTabId(tab));
       break;
     }
   }
 }
 
 void ContentRulesRegistry::Apply(
     content::WebContents* contents,
     const std::vector<std::string>& matching_css_selectors) {
   const int tab_id = ExtensionTabUtil::GetTabId(contents);
   RendererContentMatchData renderer_data;
   renderer_data.page_url_matches = url_matcher_.MatchURL(contents->GetURL());
   renderer_data.css_selectors.insert(matching_css_selectors.begin(),
                                      matching_css_selectors.end());
   std::set<ContentRule*> matching_rules = GetMatches(renderer_data);
   if (matching_rules.empty() && !ContainsKey(active_rules_, tab_id))
     return;
 
   std::set<ContentRule*>& prev_matching_rules = active_rules_[tab_id];
   ContentAction::ApplyInfo apply_info = {
-    profile_, contents
+    profile(), contents
   };
   for (std::set<ContentRule*>::const_iterator it = matching_rules.begin();
        it != matching_rules.end(); ++it) {
     if (!ContainsKey(prev_matching_rules, *it))
       (*it)->actions().Apply((*it)->extension_id(), base::Time(), &apply_info);
   }
   for (std::set<ContentRule*>::const_iterator it = prev_matching_rules.begin();
        it != prev_matching_rules.end(); ++it) {
     if (!ContainsKey(matching_rules, *it))
       (*it)->actions().Revert((*it)->extension_id(), base::Time(), &apply_info);
@@ skipping 42 matching lines @@
     if (rule->conditions().IsFulfilled(*url_match, renderer_data))
       result.insert(rule);
   }
   return result;
 }
 
 std::string ContentRulesRegistry::AddRulesImpl(
     const std::string& extension_id,
     const std::vector<linked_ptr<RulesRegistry::Rule> >& rules) {
   ExtensionService* service =
-      ExtensionSystem::Get(profile_)->extension_service();
+      ExtensionSystem::Get(profile())->extension_service();
   const Extension* extension = service->GetInstalledExtension(extension_id);
   DCHECK(extension) << "Must have extension with id " << extension_id;
 
   base::Time extension_installation_time =
       GetExtensionInstallationTime(extension_id);
 
   std::string error;
   RulesMap new_content_rules;
 
   for (std::vector<linked_ptr<RulesRegistry::Rule> >::const_iterator rule =
@@ skipping 71 matching lines @@
       match_id_to_rule_.erase((*j)->id());
     }
 
     // Remove the ContentRule from active_rules_.
     for (std::map<int, std::set<ContentRule*> >::iterator
              it = active_rules_.begin();
          it != active_rules_.end(); ++it) {
       if (ContainsKey(it->second, rule)) {
         content::WebContents* tab;
         if (!ExtensionTabUtil::GetTabById(
-                 it->first, profile_, true, NULL, NULL, &tab, NULL)) {
+                 it->first, profile(), true, NULL, NULL, &tab, NULL)) {
           LOG(DFATAL) << "Tab id " << it->first
                       << " still in active_rules_, but tab has been destroyed";
           continue;
         }
-        ContentAction::ApplyInfo apply_info = {profile_, tab};
+        ContentAction::ApplyInfo apply_info = {profile(), tab};
         rule->actions().Revert(rule->extension_id(), base::Time(), &apply_info);
         it->second.erase(rule);
       }
     }
 
     // Remove reference to actual rule.
     content_rules_.erase(content_rules_entry);
   }
 
   // Clear URLMatcher based on condition_set_ids that are not needed any more.
@@ skipping 35 matching lines @@
 
   if (css_selectors.size() != watched_css_selectors_.size() ||
       !std::equal(css_selectors.begin(), css_selectors.end(),
                   watched_css_selectors_.begin())) {
     watched_css_selectors_.assign(css_selectors.begin(), css_selectors.end());
 
     for (content::RenderProcessHost::iterator it(
              content::RenderProcessHost::AllHostsIterator());
          !it.IsAtEnd(); it.Advance()) {
       content::RenderProcessHost* process = it.GetCurrentValue();
-      if (process->GetBrowserContext() == profile_)
+      if (process->GetBrowserContext() == profile())
         InstructRenderProcess(process);
     }
   }
 }
 
 void ContentRulesRegistry::InstructRenderProcess(
     content::RenderProcessHost* process) {
   process->Send(new ExtensionMsg_WatchPages(watched_css_selectors_));
 }
 
 bool ContentRulesRegistry::IsEmpty() const {
   return match_id_to_rule_.empty() && content_rules_.empty() &&
       url_matcher_.IsEmpty();
 }
 
 ContentRulesRegistry::~ContentRulesRegistry() {}
 
 base::Time ContentRulesRegistry::GetExtensionInstallationTime(
     const std::string& extension_id) const {
   if (!extension_info_map_.get())  // May be NULL during testing.
     return base::Time();
 
   return extension_info_map_->GetInstallTime(extension_id);
 }
 
 }  // namespace extensions