Browser changes for wiring up RequestContentScript API to shared memory

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/run_loop.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
+#include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
+#include "chrome/browser/extensions/test_extension_system.h"
+#include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/web_contents.h"
+#include "extensions/browser/extension_registry.h"

[Devlin, 2014/08/27 21:22:05]

don't need.

[Mark Dittmer, 2014/08/28 19:57:08]

Done.

+#include "extensions/browser/extension_system.h"
+#include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 namespace {
 
 using base::test::ParseJson;
 using testing::HasSubstr;
 
+
+scoped_ptr<base::DictionaryValue> SimpleManifest() {
+  return DictionaryBuilder()
+      .Set("name", "extension")
+      .Set("manifest_version", 2)
+      .Set("version", "1.0")
+      .Build();
+}
+
+class RequestContentScriptTest : public ExtensionServiceTestBase {
+ public:
+  RequestContentScriptTest();
+
+  Profile* profile() { return profile_.get(); }
+  Extension* extension() { return extension_.get(); }
+
+ private:
+  scoped_refptr<Extension> extension_;
+};
+
+RequestContentScriptTest::RequestContentScriptTest()
+    : extension_(ExtensionBuilder().SetManifest(SimpleManifest()).Build()) {
+  profile_.reset(TestingProfile::Builder().Build().release());

[Devlin, 2014/08/27 21:22:05]

Two things:
1. These should almost certainly not go here.  Instead, look at
testing::Test::SetUp().
2. The profile you're referencing is a member of ExtensionServiceTestBase (yes,
there's a TODO to make it private so this can't happen).  This profile will
actually be reset as part of ExtensionServiceTestBase's initing.  So it's really
not doing anything.

The only initialization you should need to do is:
a) maybe call InitializeEmptyExtensionService() from within your test.
b) maybe call TestExtensionSystem::SetReady().

[Mark Dittmer, 2014/08/28 12:22:17]

Done. I'm not sure what you meant by "within your test". I put both calls in
SetUp() because the former creates a profile and the latter is called using a
getter that needs a profile.

[Devlin, 2014/08/28 17:58:10]

Sometimes, there's a problem with calling InitializeEmptyExtensionService() from
SetUp() (haven't had a chance to investigate why), so we typically call if from
within the test body itself, e.g.
TEST(Foo, Bar) {
  InitializeEmptyExtensionService()...
}

[Mark Dittmer, 2014/08/28 19:57:07]

Very unfortunate. The subsequent lines depend on it. Refactored.

+  static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile_.get()))->
+      SetReady();
+  base::RunLoop().RunUntilIdle();
+}
+
 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, *ParseJson("[]"), &error, &bad_message);
+  result = ContentAction::Create(
+      NULL, 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, *ParseJson("{}"), &error, &bad_message);
+  result = ContentAction::Create(
+      NULL, 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, *ParseJson(
+  result = ContentAction::Create(NULL, 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,
       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,
       extension,
       *ParseJson(
            "{\n"
            "  \"instanceType\": \"declarativeContent.ShowPageAction\",\n"
            "}"),
       &error,
       &bad_message);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad_message);
   ASSERT_TRUE(result.get());
@@ skipping 10 matching lines @@
   result->Apply(extension->id(), base::Time(), &apply_info);
   EXPECT_TRUE(page_action->GetIsVisible(tab_id));
   result->Apply(extension->id(), base::Time(), &apply_info);
   EXPECT_TRUE(page_action->GetIsVisible(tab_id));
   result->Revert(extension->id(), base::Time(), &apply_info);
   EXPECT_TRUE(page_action->GetIsVisible(tab_id));
   result->Revert(extension->id(), base::Time(), &apply_info);
   EXPECT_FALSE(page_action->GetIsVisible(tab_id));
 }
 
-TEST(DeclarativeContentActionTest, RequestContentScriptMissingScripts) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, MissingScripts) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      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(DeclarativeContentActionTest, RequestContentScriptCSS) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, CSS) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      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(DeclarativeContentActionTest, RequestContentScriptJS) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, JS) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      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(DeclarativeContentActionTest, RequestContentScriptCSSBadType) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, CSSBadType) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"css\": \"style.css\"\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_TRUE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
-TEST(DeclarativeContentActionTest, RequestContentScriptJSBadType) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, JSBadType) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      extension(),
       *ParseJson(
           "{\n"
           "  \"instanceType\": \"declarativeContent.RequestContentScript\",\n"
           "  \"js\": \"script.js\"\n"
           "}"),
       &error,
       &bad_message);
   EXPECT_TRUE(bad_message);
   ASSERT_FALSE(result.get());
 }
 
-TEST(DeclarativeContentActionTest, RequestContentScriptAllFrames) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, AllFrames) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      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(DeclarativeContentActionTest, RequestContentScriptMatchAboutBlank) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, MatchAboutBlank) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      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(DeclarativeContentActionTest, RequestContentScriptAllFramesBadType) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, AllFramesBadType) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      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(DeclarativeContentActionTest, RequestContentScriptMatchAboutBlankBadType) {
-  TestExtensionEnvironment env;
-
+TEST_F(RequestContentScriptTest, MatchAboutBlankBadType) {
   std::string error;
   bool bad_message = false;
   scoped_refptr<const ContentAction> result = ContentAction::Create(
-      NULL,
+      profile(),
+      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