Decouple RulesCacheDelegate from RulesRegistry

chrome/browser/extensions/api/declarative/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/rules_registry.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 57 matching lines @@
 
 
 namespace extensions {
 
 // RulesRegistry
 
 RulesRegistry::RulesRegistry(
     Profile* profile,
     const std::string& event_name,
     content::BrowserThread::ID owner_thread,
-    bool log_storage_init_delay,
-    scoped_ptr<RulesCacheDelegate>* ui_part)
-    : owner_thread_(owner_thread),
+    RulesCacheDelegate* cache_delegate)
+    : profile_(profile),
+      owner_thread_(owner_thread),
       event_name_(event_name),
       weak_ptr_factory_(profile ? this : NULL),
-      cache_delegate_(
-          (profile ? (new RulesCacheDelegate(profile,
-                                          event_name,
-                                          owner_thread,
-                                          weak_ptr_factory_.GetWeakPtr(),
-                                          log_storage_init_delay))->GetWeakPtr()
-                   : base::WeakPtr<RulesCacheDelegate>())),
       process_changed_rules_requested_(profile ? NOT_SCHEDULED_FOR_PROCESSING
                                                : NEVER_PROCESS),
       last_generated_rule_identifier_id_(0) {
-  if (!profile) {
-    CHECK(!ui_part);
-    return;
+  if (cache_delegate) {
+    cache_delegate_ = cache_delegate->GetWeakPtr();
+    cache_delegate->Init(this);
+  } else {
+    ready_.Signal();
   }
-
-  ui_part->reset(cache_delegate_.get());
-
-  cache_delegate_->Init();
 }
 
 std::string RulesRegistry::AddRules(
     const std::string& extension_id,
     const std::vector<linked_ptr<Rule> >& rules) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
   std::string error = CheckAndFillInOptionalRules(extension_id, rules);
   if (!error.empty())
     return error;
@@ skipping 113 matching lines @@
            used_rule_identifiers_.begin();
        extension != used_rule_identifiers_.end();
        ++extension) {
     // Each extension is counted as 1 just for being there. Otherwise we miss
     // keys with empty values.
     entry_count += 1u + extension->second.size();
   }
   return entry_count;
 }
 
+void RulesRegistry::DeserializeAndAddRules(
+    const std::string& extension_id,
+    scoped_ptr<base::Value> rules) {
+  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+
+  AddRules(extension_id, RulesFromValue(rules.get()));
+}
+
 RulesRegistry::~RulesRegistry() {
 }
 
 void RulesRegistry::MarkReady(base::Time storage_init_time) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
   if (!storage_init_time.is_null()) {
     UMA_HISTOGRAM_TIMES("Extensions.DeclarativeRulesStorageInitialization",
                         base::Time::Now() - storage_init_time);
   }
 
   ready_.Signal();
 }
 
-void RulesRegistry::DeserializeAndAddRules(
-    const std::string& extension_id,
-    scoped_ptr<base::Value> rules) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
-
-  AddRules(extension_id, RulesFromValue(rules.get()));
-}
-
 void RulesRegistry::ProcessChangedRules(const std::string& extension_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
   process_changed_rules_requested_ = NOT_SCHEDULED_FOR_PROCESSING;
 
   std::vector<linked_ptr<RulesRegistry::Rule> > new_rules;
   std::string error = GetAllRules(extension_id, &new_rules);
   DCHECK_EQ(std::string(), error);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
@@ skipping 79 matching lines @@
   for (i = identifiers.begin(); i != identifiers.end(); ++i)
     used_rule_identifiers_[extension_id].erase(*i);
 }
 
 void RulesRegistry::RemoveAllUsedRuleIdentifiers(
     const std::string& extension_id) {
   used_rule_identifiers_.erase(extension_id);
 }
 
 }  // namespace extensions