Refactor RulesRegistryWithCache to RulesRegistry

chrome/browser/extensions/api/declarative/rules_registry_with_cache_unittest.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_with_cache.h"
+#include "chrome/browser/extensions/api/declarative/rules_registry.h"
 
 // Here we test the TestRulesRegistry which is the simplest possible
 // implementation of RulesRegistryWithCache as a proxy for
 // RulesRegistryWithCache.
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
+#include "chrome/browser/extensions/api/declarative/rules_cache_delegate.h"
 #include "chrome/browser/extensions/api/declarative/test_rules_registry.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/value_store/testing_value_store.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_test_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 79 matching lines @@
 
 TEST_F(RulesRegistryWithCacheTest, AddRules) {
   // Check that nothing happens if the concrete RulesRegistry refuses to insert
   // the rules.
   registry_->SetResult("Error");
   EXPECT_EQ("Error", AddRule(kExtensionId, kRuleId));
   EXPECT_EQ(0, GetNumberOfRules(kExtensionId));
   registry_->SetResult(std::string());
 
   // Check that rules can be inserted.
-  EXPECT_EQ("", AddRule(kExtensionId, kRuleId));
+  EXPECT_EQ("", AddRule(kExtensionId, kRule2Id));
   EXPECT_EQ(1, GetNumberOfRules(kExtensionId));
 
   // Check that rules cannot be inserted twice with the same kRuleId.
   EXPECT_NE("", AddRule(kExtensionId, kRuleId));
   EXPECT_EQ(1, GetNumberOfRules(kExtensionId));
 
   // Check that different extensions may use the same kRuleId.
   EXPECT_EQ("", AddRule(kExtension2Id, kRuleId));
   EXPECT_EQ(1, GetNumberOfRules(kExtensionId));
   EXPECT_EQ(1, GetNumberOfRules(kExtension2Id));
@@ skipping 99 matching lines @@
           extensions::ExtensionSystem::Get(&profile));
   ExtensionPrefs* extension_prefs = system->CreateExtensionPrefs(
       CommandLine::ForCurrentProcess(), base::FilePath());
   system->CreateExtensionService(
       CommandLine::ForCurrentProcess(), base::FilePath(), false);
   // The value store is first created during CreateExtensionService.
   TestingValueStore* store = system->value_store();
 
   const std::string event_name("testEvent");
   const std::string rules_stored_key(
-      RulesRegistryWithCache::RuleStorageOnUI::GetRulesStoredKey(
+      RulesCacheDelegate::GetRulesStoredKey(
           event_name, profile.IsOffTheRecord()));
-  scoped_ptr<RulesRegistryWithCache::RuleStorageOnUI> ui_part;
-  scoped_refptr<RulesRegistryWithCache> registry(new TestRulesRegistry(
+  scoped_ptr<RulesCacheDelegate> ui_part;
+  scoped_refptr<RulesRegistry> registry(new TestRulesRegistry(
       &profile, event_name, content::BrowserThread::UI, &ui_part));
 
   // 1. Test the handling of preferences.
   // Default value is always true.
   EXPECT_TRUE(ui_part->GetDeclarativeRulesStored(kExtensionId));
 
   extension_prefs->UpdateExtensionPref(
       kExtensionId, rules_stored_key, new base::FundamentalValue(false));
   EXPECT_FALSE(ui_part->GetDeclarativeRulesStored(kExtensionId));
 
@@ skipping 48 matching lines @@
   // extension system creates a TestExtensionSystem.
   extensions::TestExtensionSystem* system =
       static_cast<extensions::TestExtensionSystem*>(
           extensions::ExtensionSystem::Get(&profile));
   ExtensionPrefs* extension_prefs = system->CreateExtensionPrefs(
       CommandLine::ForCurrentProcess(), base::FilePath());
 
   const std::string event_name1("testEvent1");
   const std::string event_name2("testEvent2");
   const std::string rules_stored_key1(
-      RulesRegistryWithCache::RuleStorageOnUI::GetRulesStoredKey(
+      RulesCacheDelegate::GetRulesStoredKey(
           event_name1, profile.IsOffTheRecord()));
   const std::string rules_stored_key2(
-      RulesRegistryWithCache::RuleStorageOnUI::GetRulesStoredKey(
+      RulesCacheDelegate::GetRulesStoredKey(
           event_name2, profile.IsOffTheRecord()));
-  scoped_ptr<RulesRegistryWithCache::RuleStorageOnUI> ui_part1;
-  scoped_refptr<RulesRegistryWithCache> registry1(new TestRulesRegistry(
+  scoped_ptr<RulesCacheDelegate> ui_part1;
+  scoped_refptr<RulesRegistry> registry1(new TestRulesRegistry(
       &profile, event_name1, content::BrowserThread::UI, &ui_part1));
-  scoped_ptr<RulesRegistryWithCache::RuleStorageOnUI> ui_part2;
-  scoped_refptr<RulesRegistryWithCache> registry2(new TestRulesRegistry(
+  scoped_ptr<RulesCacheDelegate> ui_part2;
+  scoped_refptr<RulesRegistry> registry2(new TestRulesRegistry(
       &profile, event_name2, content::BrowserThread::UI, &ui_part2));
 
   // Checkt the correct default values.
   EXPECT_TRUE(ui_part1->GetDeclarativeRulesStored(kExtensionId));
   EXPECT_TRUE(ui_part2->GetDeclarativeRulesStored(kExtensionId));
 
   // Update the flag for the first registry.
   extension_prefs->UpdateExtensionPref(
       kExtensionId, rules_stored_key1, new base::FundamentalValue(false));
   EXPECT_FALSE(ui_part1->GetDeclarativeRulesStored(kExtensionId));
@@ skipping 18 matching lines @@
                             "web_request_all_host_permissions.json",
                             Manifest::INVALID_LOCATION,
                             Extension::NO_FLAGS,
                             kExtensionId,
                             &error));
   ASSERT_TRUE(error.empty());
   extension_service->AddExtension(extension.get());
   system->SetReady();
 
   // 2. First run, adding a rule for the extension.
-  scoped_ptr<RulesRegistryWithCache::RuleStorageOnUI> ui_part;
+  scoped_ptr<RulesCacheDelegate> ui_part;
   scoped_refptr<TestRulesRegistry> registry(new TestRulesRegistry(
       &profile, "testEvent", content::BrowserThread::UI, &ui_part));
   AddRule(kExtensionId, kRuleId, registry.get());
   message_loop_.RunUntilIdle();  // Posted tasks store the added rule.
   EXPECT_EQ(1, GetNumberOfRules(kExtensionId, registry.get()));
 
   // 3. Restart the TestRulesRegistry and see the rule still there.
   registry = new TestRulesRegistry(
       &profile, "testEvent", content::BrowserThread::UI, &ui_part);
   message_loop_.RunUntilIdle();  // Posted tasks retrieve the stored rule.
   EXPECT_EQ(1, GetNumberOfRules(kExtensionId, registry.get()));
 }
 
 }  //  namespace extensions