Remove WebViewKey in rules registry.

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 "extensions/browser/api/declarative/rules_registry.h"
 
 // Here we test the TestRulesRegistry which is the simplest possible
 // implementation of RulesRegistryWithCache as a proxy for
 // RulesRegistryWithCache.
 
@@ skipping 14 matching lines @@
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extension_test_util::LoadManifestUnchecked;
 
 namespace {
 const char kRuleId[] = "rule";
 const char kRule2Id[] = "rule2";
+const int kRulesRegistryID = 0;
 }
 
 namespace extensions {
 
 class RulesRegistryWithCacheTest : public testing::Test {
  public:
   RulesRegistryWithCacheTest()
       : cache_delegate_(/*log_storage_init_delay=*/false),
         registry_(new TestRulesRegistry(profile(),
                                         /*event_name=*/"",
                                         content::BrowserThread::UI,
                                         &cache_delegate_,
-                                        RulesRegistry::WebViewKey(0, 0))) {}
+                                        kRulesRegistryID)) {}
 
   void SetUp() override {
     env_.GetExtensionPrefs();  // Force creation before adding extensions.
     // Note that env_.MakeExtension below also forces the creation of
     // ExtensionService.
 
     base::DictionaryValue manifest_extra;
     std::string key;
     CHECK(Extension::ProducePEM("test extension 1", &key));
     manifest_extra.SetString(manifest_keys::kPublicKey, key);
@@ skipping 168 matching lines @@
 TEST_F(RulesRegistryWithCacheTest, DeclarativeRulesStored) {
   ExtensionPrefs* extension_prefs = env_.GetExtensionPrefs();
   // The value store is first created during GetExtensionService.
   TestingValueStore* store = env_.GetExtensionSystem()->value_store();
 
   const std::string event_name("testEvent");
   const std::string rules_stored_key(
       RulesCacheDelegate::GetRulesStoredKey(
           event_name, profile()->IsOffTheRecord()));
   scoped_ptr<RulesCacheDelegate> cache_delegate(new RulesCacheDelegate(false));
-  scoped_refptr<RulesRegistry> registry(new TestRulesRegistry(
-      profile(), event_name, content::BrowserThread::UI,
-      cache_delegate.get(),
-      RulesRegistry::WebViewKey(0, 0)));
+  scoped_refptr<RulesRegistry> registry(
+      new TestRulesRegistry(profile(), event_name, content::BrowserThread::UI,
+                            cache_delegate.get(), kRulesRegistryID));
 
   // 1. Test the handling of preferences.
   // Default value is always true.
   EXPECT_TRUE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
 
   extension_prefs->UpdateExtensionPref(
       extension1_->id(), rules_stored_key, new base::FundamentalValue(false));
   EXPECT_FALSE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
 
   extension_prefs->UpdateExtensionPref(
@@ skipping 46 matching lines @@
 
   const std::string event_name1("testEvent1");
   const std::string event_name2("testEvent2");
   const std::string rules_stored_key1(
       RulesCacheDelegate::GetRulesStoredKey(
           event_name1, profile()->IsOffTheRecord()));
   const std::string rules_stored_key2(
       RulesCacheDelegate::GetRulesStoredKey(
           event_name2, profile()->IsOffTheRecord()));
   scoped_ptr<RulesCacheDelegate> cache_delegate1(new RulesCacheDelegate(false));
-  scoped_refptr<RulesRegistry> registry1(new TestRulesRegistry(
-      profile(), event_name1, content::BrowserThread::UI,
-      cache_delegate1.get(),
-      RulesRegistry::WebViewKey(0, 0)));
+  scoped_refptr<RulesRegistry> registry1(
+      new TestRulesRegistry(profile(), event_name1, content::BrowserThread::UI,
+                            cache_delegate1.get(), kRulesRegistryID));
 
   scoped_ptr<RulesCacheDelegate> cache_delegate2(new RulesCacheDelegate(false));
-  scoped_refptr<RulesRegistry> registry2(new TestRulesRegistry(
-      profile(), event_name2, content::BrowserThread::UI,
-      cache_delegate2.get(),
-      RulesRegistry::WebViewKey(0, 0)));
+  scoped_refptr<RulesRegistry> registry2(
+      new TestRulesRegistry(profile(), event_name2, content::BrowserThread::UI,
+                            cache_delegate2.get(), kRulesRegistryID));
 
   // Checkt the correct default values.
   EXPECT_TRUE(cache_delegate1->GetDeclarativeRulesStored(extension1_->id()));
   EXPECT_TRUE(cache_delegate2->GetDeclarativeRulesStored(extension1_->id()));
 
   // Update the flag for the first registry.
   extension_prefs->UpdateExtensionPref(
       extension1_->id(), rules_stored_key1, new base::FundamentalValue(false));
   EXPECT_FALSE(cache_delegate1->GetDeclarativeRulesStored(extension1_->id()));
   EXPECT_TRUE(cache_delegate2->GetDeclarativeRulesStored(extension1_->id()));
@@ skipping 22 matching lines @@
   extension_service->AddExtension(extension.get());
   EXPECT_TRUE(extensions::ExtensionRegistry::Get(env_.profile())
                   ->enabled_extensions()
                   .Contains(extension->id()));
   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
       APIPermission::kDeclarativeWebRequest));
   env_.GetExtensionSystem()->SetReady();
 
   // 2. First run, adding a rule for the extension.
   scoped_ptr<RulesCacheDelegate> cache_delegate(new RulesCacheDelegate(false));
-  scoped_refptr<TestRulesRegistry> registry(new TestRulesRegistry(
-      profile(),
-      "testEvent",
-      content::BrowserThread::UI,
-      cache_delegate.get(),
-      RulesRegistry::WebViewKey(0, 0)));
+  scoped_refptr<TestRulesRegistry> registry(
+      new TestRulesRegistry(profile(), "testEvent", content::BrowserThread::UI,
+                            cache_delegate.get(), kRulesRegistryID));
 
   AddRule(extension1_->id(), kRuleId, registry.get());
   base::RunLoop().RunUntilIdle();  // Posted tasks store the added rule.
   EXPECT_EQ(1, GetNumberOfRules(extension1_->id(), registry.get()));
 
   // 3. Restart the TestRulesRegistry and see the rule still there.
   cache_delegate.reset(new RulesCacheDelegate(false));
-  registry = new TestRulesRegistry(
-      profile(),
-      "testEvent",
-      content::BrowserThread::UI,
-      cache_delegate.get(),
-      RulesRegistry::WebViewKey(0, 0));
+  registry =
+      new TestRulesRegistry(profile(), "testEvent", content::BrowserThread::UI,
+                            cache_delegate.get(), kRulesRegistryID);
 
   base::RunLoop().RunUntilIdle();  // Posted tasks retrieve the stored rule.
   EXPECT_EQ(1, GetNumberOfRules(extension1_->id(), registry.get()));
 }
 
 TEST_F(RulesRegistryWithCacheTest, ConcurrentStoringOfRules) {
   // When an extension updates its rules, the new set of rules is stored to disk
   // with some delay. While it is acceptable for a quick series of updates for a
   // single extension to only write the last one, we should never forget to
   // write a rules update for extension A, just because it is immediately
   // followed by a rules update for extension B.
   extensions::TestExtensionSystem* system = env_.GetExtensionSystem();
   TestingValueStore* store = system->value_store();
 
   int write_count = store->write_count();
   EXPECT_EQ("", AddRule(extension1_->id(), kRuleId));
   EXPECT_EQ("", AddRule(extension2_->id(), kRule2Id));
   env_.GetExtensionSystem()->SetReady();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(write_count + 2, store->write_count());
 }
 
 }  //  namespace extensions