Introduce HostID and de-couple Extensions from "script injection System" [browser side]

chrome/browser/extensions/api/declarative_content/content_action_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_content/content_action.h"
 
 #include "base/base64.h"
 #include "base/run_loop.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/extensions/extension_action.h"
@@ skipping 55 matching lines @@
 
 TEST(DeclarativeContentActionTest, InvalidCreation) {
   TestExtensionEnvironment env;
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result;
 
   // Test wrong data type passed.
   error.clear();
   result = ContentAction::Create(
-      NULL, NULL, *ParseJson("[]"), &error, &bad_message);
+      NULL, HostID(), NULL, *ParseJson("[]"), &error, &bad_message);
   EXPECT_TRUE(bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(result.get());
 
   // Test missing instanceType element.
   error.clear();
   result = ContentAction::Create(
-      NULL, NULL, *ParseJson("{}"), &error, &bad_message);
+      NULL, HostID(), NULL, *ParseJson("{}"), &error, &bad_message);
   EXPECT_TRUE(bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(result.get());
 
   // Test wrong instanceType element.
   error.clear();
-  result = ContentAction::Create(NULL, NULL, *ParseJson(
+  result = ContentAction::Create(NULL, HostID(), NULL, *ParseJson(
       "{\n"
       "  \"instanceType\": \"declarativeContent.UnknownType\",\n"
       "}"),
                                  &error, &bad_message);
   EXPECT_THAT(error, HasSubstr("invalid instanceType"));
   EXPECT_FALSE(result.get());
 }
 
 TEST(DeclarativeContentActionTest, ShowPageActionWithoutPageAction) {
   TestExtensionEnvironment env;
 
   const Extension* extension = env.MakeExtension(base::DictionaryValue());
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       NULL,
+      HostID(HostID::EXTENSIONS, extension->id()),
       extension,
       *ParseJson(
            "{\n"
            "  \"instanceType\": \"declarativeContent.ShowPageAction\",\n"
            "}"),
       &error,
       &bad_message);
   EXPECT_THAT(error, testing::HasSubstr("without a page action"));
   EXPECT_FALSE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
 TEST(DeclarativeContentActionTest, ShowPageAction) {
   TestExtensionEnvironment env;
 
   const Extension* extension = env.MakeExtension(
       *ParseJson("{\"page_action\": { \"default_title\": \"Extension\" } }"));
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       NULL,
+      HostID(HostID::EXTENSIONS, extension->id()),
       extension,
       *ParseJson(
            "{\n"
            "  \"instanceType\": \"declarativeContent.ShowPageAction\",\n"
            "}"),
       &error,
       &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
@@ skipping 38 matching lines @@
       DictionaryBuilder().Set("instanceType", "declarativeContent.SetIcon")
                          .Set("imageData",
                               DictionaryBuilder().Set("19", data64)).Build();
 
   const Extension* extension = env.MakeExtension(
       *ParseJson("{\"page_action\": { \"default_title\": \"Extension\" } }"));
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       NULL,
+      HostID(HostID::EXTENSIONS, extension->id()),
       extension,
       *dict,
       &error,
       &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
   EXPECT_EQ(ContentAction::ACTION_SET_ICON, result->GetType());
 
   ExtensionAction* page_action =
@@ skipping 12 matching lines @@
   result->Revert(extension->id(), base::Time(), &apply_info);
   EXPECT_TRUE(page_action->GetDeclarativeIcon(tab_id).bitmap()->empty());
 }
 
 TEST_F(RequestContentScriptTest, MissingScripts) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"allFrames\": true,\n"
           "  \"matchAboutBlank\": true\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_THAT(error, testing::HasSubstr("Missing parameter is required"));
   EXPECT_FALSE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
 TEST_F(RequestContentScriptTest, CSS) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"css\": [\"style.css\"]\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
   EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType());
 }
 
 TEST_F(RequestContentScriptTest, JS) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"js\": [\"script.js\"]\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
   EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType());
 }
 
 TEST_F(RequestContentScriptTest, CSSBadType) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"css\": \"style.css\"\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_TRUE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
 TEST_F(RequestContentScriptTest, JSBadType) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"js\": \"script.js\"\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_TRUE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
 TEST_F(RequestContentScriptTest, AllFrames) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"js\": [\"script.js\"],\n"
           "  \"allFrames\": true\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
   EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType());
 }
 
 TEST_F(RequestContentScriptTest, MatchAboutBlank) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"js\": [\"script.js\"],\n"
           "  \"matchAboutBlank\": true\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
   EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType());
 }
 
 TEST_F(RequestContentScriptTest, AllFramesBadType) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"js\": [\"script.js\"],\n"
           "  \"allFrames\": null\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_TRUE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
 TEST_F(RequestContentScriptTest, MatchAboutBlankBadType) {
   Init();
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
       profile(),
+      HostID(HostID::EXTENSIONS, extension()->id()),
       extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"js\": [\"script.js\"],\n"
           "  \"matchAboutBlank\": null\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_TRUE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
 }  // namespace
 }  // namespace extensions