1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/extensions/api/declarative/initializing_rules_registry.h" 6 7 #include <algorithm> 8 9 #include "base/message_loop/message_loop.h" 10 #include "chrome/browser/extensions/api/declarative/test_rules_registry.h" 11 #include "content/public/test/test_browser_thread.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 namespace { 15 const char kExtensionId[] = "foobar"; 16 const char kRuleId[] = "foo"; 17 } // namespace 18 19 namespace extensions { 20 21 TEST(InitializingRulesRegistryTest, FillOptionalIdentifiers) { 22 base::MessageLoopForUI message_loop; 23 content::TestBrowserThread thread(content::BrowserThread::UI, &message_loop); 24 25 std::string error; 26 scoped_refptr<RulesRegistry> registry = new InitializingRulesRegistry( 27 new TestRulesRegistry(content::BrowserThread::UI, "" /*event_name*/)); 28 InitializingRulesRegistry* init_registry = 29 static_cast<InitializingRulesRegistry*>(registry.get()); 30 31 // Add rules and check that their identifiers are filled and unique. 32 33 std::vector<linked_ptr<RulesRegistry::Rule> > add_rules; 34 add_rules.push_back(make_linked_ptr(new RulesRegistry::Rule)); 35 add_rules.push_back(make_linked_ptr(new RulesRegistry::Rule)); 36 error = registry->AddRules(kExtensionId, add_rules); 37 EXPECT_TRUE(error.empty()); 38 39 std::vector<linked_ptr<RulesRegistry::Rule> > get_rules; 40 error = registry->GetAllRules(kExtensionId, &get_rules); 41 EXPECT_TRUE(error.empty()); 42 43 ASSERT_EQ(2u, get_rules.size()); 44 45 ASSERT_TRUE(get_rules[0]->id.get()); 46 EXPECT_NE("", *get_rules[0]->id); 47 48 ASSERT_TRUE(get_rules[1]->id.get()); 49 EXPECT_NE("", *get_rules[1]->id); 50 51 EXPECT_NE(*get_rules[0]->id, *get_rules[1]->id); 52 53 EXPECT_EQ(1u /*extensions*/ + 2u /*rules*/, 54 init_registry->GetNumberOfUsedRuleIdentifiersForTesting()); 55 56 // Check that we cannot add a new rule with the same ID. 57 58 std::vector<linked_ptr<RulesRegistry::Rule> > add_rules_2; 59 add_rules_2.push_back(make_linked_ptr(new RulesRegistry::Rule)); 60 add_rules_2[0]->id.reset(new std::string(*get_rules[0]->id)); 61 error = registry->AddRules(kExtensionId, add_rules_2); 62 EXPECT_FALSE(error.empty()); 63 64 std::vector<linked_ptr<RulesRegistry::Rule> > get_rules_2; 65 error = registry->GetAllRules(kExtensionId, &get_rules_2); 66 EXPECT_TRUE(error.empty()); 67 ASSERT_EQ(2u, get_rules_2.size()); 68 EXPECT_EQ(1u /*extensions*/ + 2u /*rules*/, 69 init_registry->GetNumberOfUsedRuleIdentifiersForTesting()); 70 71 // Check that we can register the old rule IDs once they were unregistered. 72 73 std::vector<std::string> remove_rules_3; 74 remove_rules_3.push_back(*get_rules[0]->id); 75 error = registry->RemoveRules(kExtensionId, remove_rules_3); 76 EXPECT_TRUE(error.empty()); 77 78 EXPECT_EQ(1u /*extensions*/ + 1u /*rules*/, 79 init_registry->GetNumberOfUsedRuleIdentifiersForTesting()); 80 81 std::vector<linked_ptr<RulesRegistry::Rule> > get_rules_3a; 82 error = registry->GetAllRules(kExtensionId, &get_rules_3a); 83 EXPECT_TRUE(error.empty()); 84 ASSERT_EQ(1u, get_rules_3a.size()); 85 86 std::vector<linked_ptr<RulesRegistry::Rule> > add_rules_3; 87 add_rules_3.push_back(make_linked_ptr(new RulesRegistry::Rule)); 88 add_rules_3[0]->id.reset(new std::string(*get_rules[0]->id)); 89 error = registry->AddRules(kExtensionId, add_rules_3); 90 EXPECT_TRUE(error.empty()); 91 EXPECT_EQ(1u /*extensions*/ + 2u /*rules*/, 92 init_registry->GetNumberOfUsedRuleIdentifiersForTesting()); 93 94 std::vector<linked_ptr<RulesRegistry::Rule> > get_rules_3b; 95 error = registry->GetAllRules(kExtensionId, &get_rules_3b); 96 EXPECT_TRUE(error.empty()); 97 ASSERT_EQ(2u, get_rules_3b.size()); 98 99 // Check that we can register a rule with an ID that is not modified. 100 101 error = registry->RemoveAllRules(kExtensionId); 102 EXPECT_TRUE(error.empty()); 103 EXPECT_EQ(0u /*extensions*/ + 0u /*rules*/, 104 init_registry->GetNumberOfUsedRuleIdentifiersForTesting()); 105 106 std::vector<linked_ptr<RulesRegistry::Rule> > get_rules_4a; 107 error = registry->GetAllRules(kExtensionId, &get_rules_4a); 108 EXPECT_TRUE(error.empty()); 109 ASSERT_TRUE(get_rules_4a.empty()); 110 111 std::vector<linked_ptr<RulesRegistry::Rule> > add_rules_4; 112 add_rules_4.push_back(make_linked_ptr(new RulesRegistry::Rule)); 113 add_rules_4[0]->id.reset(new std::string(kRuleId)); 114 error = registry->AddRules(kExtensionId, add_rules_4); 115 EXPECT_TRUE(error.empty()); 116 117 EXPECT_EQ(1u /*extensions*/ + 1u /*rules*/, 118 init_registry->GetNumberOfUsedRuleIdentifiersForTesting()); 119 120 std::vector<linked_ptr<RulesRegistry::Rule> > get_rules_4b; 121 error = registry->GetAllRules(kExtensionId, &get_rules_4b); 122 EXPECT_TRUE(error.empty()); 123 124 ASSERT_EQ(1u, get_rules_4b.size()); 125 126 ASSERT_TRUE(get_rules_4b[0]->id.get()); 127 EXPECT_EQ(kRuleId, *get_rules_4b[0]->id); 128 129 registry->OnExtensionUnloaded(kExtensionId); 130 EXPECT_EQ(0u /*extensions*/ + 0u /*rules*/, 131 init_registry->GetNumberOfUsedRuleIdentifiersForTesting()); 132 133 // Make sure that deletion traits of registry are executed. 134 registry = NULL; 135 message_loop.RunUntilIdle(); 136 } 137 138 TEST(InitializingRulesRegistryTest, FillOptionalPriority) { 139 base::MessageLoopForUI message_loop; 140 content::TestBrowserThread thread(content::BrowserThread::UI, &message_loop); 141 142 std::string error; 143 scoped_refptr<RulesRegistry> registry = new InitializingRulesRegistry( 144 new TestRulesRegistry(content::BrowserThread::UI, "" /*event_name*/)); 145 146 // Add rules and check that their priorities are filled if they are empty. 147 148 std::vector<linked_ptr<RulesRegistry::Rule> > add_rules; 149 add_rules.push_back(make_linked_ptr(new RulesRegistry::Rule)); 150 add_rules[0]->priority.reset(new int(2)); 151 add_rules.push_back(make_linked_ptr(new RulesRegistry::Rule)); 152 error = registry->AddRules(kExtensionId, add_rules); 153 EXPECT_TRUE(error.empty()); 154 155 std::vector<linked_ptr<RulesRegistry::Rule> > get_rules; 156 error = registry->GetAllRules(kExtensionId, &get_rules); 157 EXPECT_TRUE(error.empty()); 158 159 ASSERT_EQ(2u, get_rules.size()); 160 161 ASSERT_TRUE(get_rules[0]->priority.get()); 162 ASSERT_TRUE(get_rules[1]->priority.get()); 163 164 // Verify the precondition so that the following EXPECT_EQ statements work. 165 EXPECT_GT(InitializingRulesRegistry::DEFAULT_PRIORITY, 2); 166 EXPECT_EQ(2, std::min(*get_rules[0]->priority, *get_rules[1]->priority)); 167 EXPECT_EQ(InitializingRulesRegistry::DEFAULT_PRIORITY, 168 std::max(*get_rules[0]->priority, *get_rules[1]->priority)); 169 170 // Make sure that deletion traits of registry are executed. 171 registry = NULL; 172 message_loop.RunUntilIdle(); 173 } 174 175 } // namespace extensions 176
