Generate all extension schema namespaces as "api" and instead vary the generated bundle names.

chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_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_webrequest/webrequest_rules_registry.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 78 matching lines @@
 
   void SetUp() override;
 
   void TearDown() override {
     // Make sure that deletion traits of all registries are executed.
     message_loop_.RunUntilIdle();
   }
 
   // Returns a rule that roughly matches http://*.example.com and
   // https://www.example.com and cancels it
-  linked_ptr<core_api::events::Rule> CreateRule1() {
+  linked_ptr<api::events::Rule> CreateRule1() {
     base::ListValue* scheme_http = new base::ListValue();
     scheme_http->Append(new base::StringValue("http"));
     base::DictionaryValue* http_condition_dict = new base::DictionaryValue();
     http_condition_dict->Set(keys2::kSchemesKey, scheme_http);
     http_condition_dict->SetString(keys2::kHostSuffixKey, "example.com");
     base::DictionaryValue http_condition_url_filter;
     http_condition_url_filter.Set(keys::kUrlKey, http_condition_dict);
     http_condition_url_filter.SetString(keys::kInstanceTypeKey,
                                         keys::kRequestMatcherType);
 
     base::ListValue* scheme_https = new base::ListValue();
     scheme_http->Append(new base::StringValue("https"));
     base::DictionaryValue* https_condition_dict = new base::DictionaryValue();
     https_condition_dict->Set(keys2::kSchemesKey, scheme_https);
     https_condition_dict->SetString(keys2::kHostSuffixKey, "example.com");
     https_condition_dict->SetString(keys2::kHostPrefixKey, "www");
     base::DictionaryValue https_condition_url_filter;
     https_condition_url_filter.Set(keys::kUrlKey, https_condition_dict);
     https_condition_url_filter.SetString(keys::kInstanceTypeKey,
                                          keys::kRequestMatcherType);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kCancelRequestType);
 
-    linked_ptr<core_api::events::Rule> rule(new core_api::events::Rule);
+    linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId1));
     rule->priority.reset(new int(100));
     rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
     rule->conditions.push_back(
         linked_ptr<base::Value>(http_condition_url_filter.DeepCopy()));
     rule->conditions.push_back(
         linked_ptr<base::Value>(https_condition_url_filter.DeepCopy()));
     return rule;
   }
 
   // Returns a rule that matches anything and cancels it.
-  linked_ptr<core_api::events::Rule> CreateRule2() {
+  linked_ptr<api::events::Rule> CreateRule2() {
     base::DictionaryValue condition_dict;
     condition_dict.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kCancelRequestType);
 
-    linked_ptr<core_api::events::Rule> rule(new core_api::events::Rule);
+    linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId2));
     rule->priority.reset(new int(100));
     rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
     rule->conditions.push_back(
         linked_ptr<base::Value>(condition_dict.DeepCopy()));
     return rule;
   }
 
-  linked_ptr<core_api::events::Rule> CreateRedirectRule(
+  linked_ptr<api::events::Rule> CreateRedirectRule(
       const std::string& destination) {
     base::DictionaryValue condition_dict;
     condition_dict.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kRedirectRequestType);
     action_dict.SetString(keys::kRedirectUrlKey, destination);
 
-    linked_ptr<core_api::events::Rule> rule(new core_api::events::Rule);
+    linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId3));
     rule->priority.reset(new int(100));
     rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
     rule->conditions.push_back(
         linked_ptr<base::Value>(condition_dict.DeepCopy()));
     return rule;
   }
 
   // Create a rule to ignore all other rules for a destination that
   // contains index.html.
-  linked_ptr<core_api::events::Rule> CreateIgnoreRule() {
+  linked_ptr<api::events::Rule> CreateIgnoreRule() {
     base::DictionaryValue condition_dict;
     base::DictionaryValue* http_condition_dict = new base::DictionaryValue();
     http_condition_dict->SetString(keys2::kPathContainsKey, "index.html");
     condition_dict.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
     condition_dict.Set(keys::kUrlKey, http_condition_dict);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kIgnoreRulesType);
     action_dict.SetInteger(keys::kLowerPriorityThanKey, 150);
 
-    linked_ptr<core_api::events::Rule> rule(new core_api::events::Rule);
+    linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId4));
     rule->priority.reset(new int(200));
     rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
     rule->conditions.push_back(
         linked_ptr<base::Value>(condition_dict.DeepCopy()));
     return rule;
   }
 
   // Create a condition with the attributes specified. An example value of
   // |attributes| is: "\"resourceType\": [\"stylesheet\"], \n".
   linked_ptr<base::Value> CreateCondition(const std::string& attributes) {
     std::string json_description =
         "{ \n"
         "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n";
     json_description += attributes;
     json_description += "}";
 
     return linked_ptr<base::Value>(
         base::test::ParseJson(json_description).release());
   }
 
   // Create a rule with the ID |rule_id| and with conditions created from the
   // |attributes| specified (one entry one condition). An example value of a
   // string from |attributes| is: "\"resourceType\": [\"stylesheet\"], \n".
-  linked_ptr<core_api::events::Rule> CreateCancellingRule(
+  linked_ptr<api::events::Rule> CreateCancellingRule(
       const char* rule_id,
       const std::vector<const std::string*>& attributes) {
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kCancelRequestType);
 
-    linked_ptr<core_api::events::Rule> rule(new core_api::events::Rule);
+    linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(rule_id));
     rule->priority.reset(new int(1));
     rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
     for (std::vector<const std::string*>::const_iterator it =
              attributes.begin();
          it != attributes.end(); ++it)
       rule->conditions.push_back(CreateCondition(**it));
     return rule;
   }
 
@@ skipping 38 matching lines @@
                                     false /*incognito_enabled*/,
                                     false /*notifications_disabled*/);
 }
 
 
 TEST_F(WebRequestRulesRegistryTest, AddRulesImpl) {
   scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   std::string error;
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules;
+  std::vector<linked_ptr<api::events::Rule>> rules;
   rules.push_back(CreateRule1());
   rules.push_back(CreateRule2());
 
   error = registry->AddRules(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   std::set<const WebRequestRule*> matches;
 
   GURL http_url("http://www.example.com");
@@ skipping 21 matching lines @@
       std::make_pair(kExtensionId, kRuleId2);
   EXPECT_EQ(expected_pair, (*matches.begin())->id());
 }
 
 TEST_F(WebRequestRulesRegistryTest, RemoveRulesImpl) {
   scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   std::string error;
 
   // Setup RulesRegistry to contain two rules.
-  std::vector<linked_ptr<core_api::events::Rule>> rules_to_add;
+  std::vector<linked_ptr<api::events::Rule>> rules_to_add;
   rules_to_add.push_back(CreateRule1());
   rules_to_add.push_back(CreateRule2());
   error = registry->AddRules(kExtensionId, rules_to_add);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   // Verify initial state.
-  std::vector<linked_ptr<core_api::events::Rule>> registered_rules;
+  std::vector<linked_ptr<api::events::Rule>> registered_rules;
   registry->GetAllRules(kExtensionId, &registered_rules);
   EXPECT_EQ(2u, registered_rules.size());
   EXPECT_EQ(1u, registry->RulesWithoutTriggers());
 
   // Remove first rule.
   std::vector<std::string> rules_to_remove;
   rules_to_remove.push_back(kRuleId1);
   error = registry->RemoveRules(kExtensionId, rules_to_remove);
   EXPECT_EQ("", error);
   EXPECT_EQ(2, registry->num_clear_cache_calls());
@@ skipping 19 matching lines @@
 
   EXPECT_TRUE(registry->IsEmpty());
 }
 
 TEST_F(WebRequestRulesRegistryTest, RemoveAllRulesImpl) {
   scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   std::string error;
 
   // Setup RulesRegistry to contain two rules, one for each extension.
-  std::vector<linked_ptr<core_api::events::Rule>> rules_to_add(1);
+  std::vector<linked_ptr<api::events::Rule>> rules_to_add(1);
   rules_to_add[0] = CreateRule1();
   error = registry->AddRules(kExtensionId, rules_to_add);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   rules_to_add[0] = CreateRule2();
   error = registry->AddRules(kExtensionId2, rules_to_add);
   EXPECT_EQ("", error);
   EXPECT_EQ(2, registry->num_clear_cache_calls());
 
   // Verify initial state.
-  std::vector<linked_ptr<core_api::events::Rule>> registered_rules;
+  std::vector<linked_ptr<api::events::Rule>> registered_rules;
   registry->GetAllRules(kExtensionId, &registered_rules);
   EXPECT_EQ(1u, registered_rules.size());
   registered_rules.clear();
   registry->GetAllRules(kExtensionId2, &registered_rules);
   EXPECT_EQ(1u, registered_rules.size());
 
   // Remove rule of first extension.
   error = registry->RemoveAllRules(kExtensionId);
   EXPECT_EQ("", error);
   EXPECT_EQ(3, registry->num_clear_cache_calls());
@@ skipping 18 matching lines @@
 
   EXPECT_TRUE(registry->IsEmpty());
 }
 
 // Test precedences between extensions.
 TEST_F(WebRequestRulesRegistryTest, Precedences) {
   scoped_refptr<WebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   std::string error;
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules_to_add_1(1);
+  std::vector<linked_ptr<api::events::Rule>> rules_to_add_1(1);
   rules_to_add_1[0] = CreateRedirectRule("http://www.foo.com");
   error = registry->AddRules(kExtensionId, rules_to_add_1);
   EXPECT_EQ("", error);
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules_to_add_2(1);
+  std::vector<linked_ptr<api::events::Rule>> rules_to_add_2(1);
   rules_to_add_2[0] = CreateRedirectRule("http://www.bar.com");
   error = registry->AddRules(kExtensionId2, rules_to_add_2);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com");
   net::TestURLRequestContext context;
   scoped_ptr<net::URLRequest> request(context.CreateRequest(
       url, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
@@ skipping 18 matching lines @@
             loser->extension_install_time);
   EXPECT_EQ(GURL("http://www.foo.com"), loser->new_url);
 }
 
 // Test priorities of rules within one extension.
 TEST_F(WebRequestRulesRegistryTest, Priorities) {
   scoped_refptr<WebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   std::string error;
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules_to_add_1(1);
+  std::vector<linked_ptr<api::events::Rule>> rules_to_add_1(1);
   rules_to_add_1[0] = CreateRedirectRule("http://www.foo.com");
   error = registry->AddRules(kExtensionId, rules_to_add_1);
   EXPECT_EQ("", error);
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules_to_add_2(1);
+  std::vector<linked_ptr<api::events::Rule>> rules_to_add_2(1);
   rules_to_add_2[0] = CreateRedirectRule("http://www.bar.com");
   error = registry->AddRules(kExtensionId2, rules_to_add_2);
   EXPECT_EQ("", error);
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules_to_add_3(1);
+  std::vector<linked_ptr<api::events::Rule>> rules_to_add_3(1);
   rules_to_add_3[0] = CreateIgnoreRule();
   error = registry->AddRules(kExtensionId, rules_to_add_3);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com/index.html");
   net::TestURLRequestContext context;
   scoped_ptr<net::URLRequest> request(context.CreateRequest(
       url, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
@@ skipping 46 matching lines @@
       "    }                                                             \n"
       "  ],                                                              \n"
       "  \"priority\": 300                                               \n"
       "}                                                                 ";
 
   scoped_ptr<base::Value> value1 = base::JSONReader::Read(kRule1);
   ASSERT_TRUE(value1.get());
   scoped_ptr<base::Value> value2 = base::JSONReader::Read(kRule2);
   ASSERT_TRUE(value2.get());
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules;
-  rules.push_back(make_linked_ptr(new core_api::events::Rule));
-  rules.push_back(make_linked_ptr(new core_api::events::Rule));
-  ASSERT_TRUE(core_api::events::Rule::Populate(*value1, rules[0].get()));
-  ASSERT_TRUE(core_api::events::Rule::Populate(*value2, rules[1].get()));
+  std::vector<linked_ptr<api::events::Rule>> rules;
+  rules.push_back(make_linked_ptr(new api::events::Rule));
+  rules.push_back(make_linked_ptr(new api::events::Rule));
+  ASSERT_TRUE(api::events::Rule::Populate(*value1, rules[0].get()));
+  ASSERT_TRUE(api::events::Rule::Populate(*value2, rules[1].get()));
 
   scoped_refptr<WebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   std::string error = registry->AddRulesImpl(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_FALSE(registry->IsEmpty());
 
   GURL url("http://www.foo.com/test");
   net::TestURLRequestContext context;
   scoped_ptr<net::URLRequest> request(context.CreateRequest(
@@ skipping 14 matching lines @@
   scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   const std::string kMatchingUrlAttribute(
       "\"url\": { \"pathContains\": \"\" }, \n");
   const std::string kNonMatchingNonUrlAttribute(
       "\"resourceType\": [\"stylesheet\"], \n");
   const std::string kBothAttributes(kMatchingUrlAttribute +
                                     kNonMatchingNonUrlAttribute);
   std::string error;
   std::vector<const std::string*> attributes;
-  std::vector<linked_ptr<core_api::events::Rule>> rules;
+  std::vector<linked_ptr<api::events::Rule>> rules;
 
   // Rules 1 and 2 have one condition, neither of them should fire.
   attributes.push_back(&kNonMatchingNonUrlAttribute);
   rules.push_back(CreateCancellingRule(kRuleId1, attributes));
 
   attributes.clear();
   attributes.push_back(&kBothAttributes);
   rules.push_back(CreateCancellingRule(kRuleId2, attributes));
 
   // Rule 3 has two conditions, one with a matching URL attribute, and one
@@ skipping 26 matching lines @@
 // differ.
 TEST_F(WebRequestRulesRegistryTest, GetMatchesDifferentUrls) {
   scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
   const std::string kUrlAttribute(
       "\"url\": { \"hostContains\": \"url\" }, \n");
   const std::string kFirstPartyUrlAttribute(
       "\"firstPartyForCookiesUrl\": { \"hostContains\": \"fpfc\" }, \n");
   std::string error;
   std::vector<const std::string*> attributes;
-  std::vector<linked_ptr<core_api::events::Rule>> rules;
+  std::vector<linked_ptr<api::events::Rule>> rules;
 
   // Rule 1 has one condition, with a url attribute
   attributes.push_back(&kUrlAttribute);
   rules.push_back(CreateCancellingRule(kRuleId1, attributes));
 
   // Rule 2 has one condition, with a firstPartyForCookiesUrl attribute
   attributes.clear();
   attributes.push_back(&kFirstPartyUrlAttribute);
   rules.push_back(CreateCancellingRule(kRuleId2, attributes));
 
@@ skipping 60 matching lines @@
       "      \"name\": \"Content-Type\",                                  \n"
       "      \"value\": \"text/plain\"                                    \n"
       "    }                                                              \n"
       "  ],                                                               \n"
       "  \"priority\": 200                                                \n"
       "}                                                                  ";
 
   scoped_ptr<base::Value> value = base::JSONReader::Read(kRule);
   ASSERT_TRUE(value);
 
-  core_api::events::Rule rule;
-  ASSERT_TRUE(core_api::events::Rule::Populate(*value, &rule));
+  api::events::Rule rule;
+  ASSERT_TRUE(api::events::Rule::Populate(*value, &rule));
 
   std::string error;
   URLMatcher matcher;
   scoped_ptr<WebRequestConditionSet> conditions =
       WebRequestConditionSet::Create(
           NULL, matcher.condition_factory(), rule.conditions, &error);
   ASSERT_TRUE(error.empty()) << error;
   ASSERT_TRUE(conditions);
 
   bool bad_message = false;
@@ skipping 68 matching lines @@
       "      \"instanceType\": \"declarativeWebRequest.RedirectRequest\",\n"
       "      \"redirectUrl\": \"http://bar.com\"                         \n"
       "    }                                                             \n"
       "  ],                                                              \n"
       "  \"priority\": 200                                               \n"
       "}                                                                 ";
 
   scoped_ptr<base::Value> value = base::JSONReader::Read(kRule);
   ASSERT_TRUE(value.get());
 
-  std::vector<linked_ptr<core_api::events::Rule>> rules;
-  rules.push_back(make_linked_ptr(new core_api::events::Rule));
-  ASSERT_TRUE(core_api::events::Rule::Populate(*value, rules.back().get()));
+  std::vector<linked_ptr<api::events::Rule>> rules;
+  rules.push_back(make_linked_ptr(new api::events::Rule));
+  ASSERT_TRUE(api::events::Rule::Populate(*value, rules.back().get()));
 
   scoped_refptr<WebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry(extension_info_map_));
 
   URLMatcher matcher;
   std::string error = registry->AddRulesImpl(kExtensionId, rules);
   EXPECT_EQ("", error);
 
   net::TestURLRequestContext context;
   std::list<LinkedPtrEventResponseDelta> deltas;
 
   // No match because match is in the query parameter.
   GURL url1("http://bar.com/index.html?foo.com");
   scoped_ptr<net::URLRequest> request1(context.CreateRequest(
       url1, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data1(request1.get(), ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data1, false);
   EXPECT_EQ(0u, deltas.size());
 
   // This is a correct match.
   GURL url2("http://foo.com/index.html");
   scoped_ptr<net::URLRequest> request2(context.CreateRequest(
       url2, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data2(request2.get(), ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data2, false);
   EXPECT_EQ(1u, deltas.size());
 }
 
 }  // namespace extensions