| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2014 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 "base/files/file_path.h" |
| 6 #include "base/test/values_test_util.h" |
| 7 #include "chrome/browser/extensions/api/declarative_content/content_action.h" |
| 8 #include "chrome/browser/extensions/extension_browsertest.h" |
| 9 #include "chrome/browser/extensions/test_extension_dir.h" |
| 10 #include "testing/gmock/include/gmock/gmock.h" |
| 11 #include "testing/gtest/include/gtest/gtest.h" |
| 12 |
| 13 namespace extensions { |
| 14 namespace { |
| 15 |
| 16 const char kRequestContentScriptManifest[] = |
| 17 "{\n" |
| 18 " \"name\": \"Request Content Script browsertest\",\n" |
| 19 " \"version\": \"0.1\",\n" |
| 20 " \"manifest_version\": 2,\n" |
| 21 " \"description\": \n" |
| 22 " \"browser test for the declarativeContentRequestContentScript\",\n" |
| 23 " \"background\": {\n" |
| 24 " \"scripts\": [\"background.js\"]\n" |
| 25 " },\n" |
| 26 " \"permissions\": [\n" |
| 27 " \"declarativeContent\"\n" |
| 28 " ]\n" |
| 29 "}\n"; |
| 30 |
| 31 class RequestContentScriptTest : public ExtensionBrowserTest { |
| 32 public: |
| 33 void InitBasicExtensionFiles() { |
| 34 ext_dir().WriteManifest(kRequestContentScriptManifest); |
| 35 ext_dir().WriteFile(FILE_PATH_LITERAL("background.js"), ""); |
| 36 } |
| 37 |
| 38 const Extension* LoadTestExtension() { |
| 39 const Extension* extension = |
| 40 LoadExtension(ext_dir().unpacked_path()); |
| 41 return extension; |
| 42 } |
| 43 |
| 44 TestExtensionDir& ext_dir() { return ext_dir_; } |
| 45 |
| 46 private: |
| 47 TestExtensionDir ext_dir_; |
| 48 }; |
| 49 |
| 50 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, MissingScripts) { |
| 51 InitBasicExtensionFiles(); |
| 52 const Extension* extension = LoadTestExtension(); |
| 53 ASSERT_TRUE(extension); |
| 54 |
| 55 std::string error; |
| 56 bool bad_message = false; |
| 57 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 58 profile(), |
| 59 extension, |
| 60 *base::test::ParseJson( |
| 61 "{\n" |
| 62 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 63 " \"allFrames\": true,\n" |
| 64 " \"matchAboutBlank\": true\n" |
| 65 "}"), |
| 66 &error, |
| 67 &bad_message); |
| 68 EXPECT_THAT(error, testing::HasSubstr("Missing parameter is required")); |
| 69 EXPECT_FALSE(bad_message); |
| 70 ASSERT_FALSE(result.get()); |
| 71 } |
| 72 |
| 73 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, CSS) { |
| 74 InitBasicExtensionFiles(); |
| 75 ext_dir().WriteFile(FILE_PATH_LITERAL("style.css"), ""); |
| 76 const Extension* extension = LoadTestExtension(); |
| 77 ASSERT_TRUE(extension); |
| 78 |
| 79 std::string error; |
| 80 bool bad_message = false; |
| 81 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 82 profile(), |
| 83 extension, |
| 84 *base::test::ParseJson( |
| 85 "{\n" |
| 86 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 87 " \"css\": [\"style.css\"]\n" |
| 88 "}"), |
| 89 &error, |
| 90 &bad_message); |
| 91 EXPECT_EQ("", error); |
| 92 EXPECT_FALSE(bad_message); |
| 93 ASSERT_TRUE(result.get()); |
| 94 EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType()); |
| 95 } |
| 96 |
| 97 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, JS) { |
| 98 InitBasicExtensionFiles(); |
| 99 ext_dir().WriteFile(FILE_PATH_LITERAL("script.js"), ""); |
| 100 const Extension* extension = LoadTestExtension(); |
| 101 ASSERT_TRUE(extension); |
| 102 |
| 103 std::string error; |
| 104 bool bad_message = false; |
| 105 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 106 profile(), |
| 107 extension, |
| 108 *base::test::ParseJson( |
| 109 "{\n" |
| 110 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 111 " \"js\": [\"script.js\"]\n" |
| 112 "}"), |
| 113 &error, |
| 114 &bad_message); |
| 115 EXPECT_EQ("", error); |
| 116 EXPECT_FALSE(bad_message); |
| 117 ASSERT_TRUE(result.get()); |
| 118 EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType()); |
| 119 } |
| 120 |
| 121 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, CSSBadType) { |
| 122 InitBasicExtensionFiles(); |
| 123 ext_dir().WriteFile(FILE_PATH_LITERAL("style.css"), ""); |
| 124 const Extension* extension = LoadTestExtension(); |
| 125 ASSERT_TRUE(extension); |
| 126 |
| 127 std::string error; |
| 128 bool bad_message = false; |
| 129 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 130 profile(), |
| 131 extension, |
| 132 *base::test::ParseJson( |
| 133 "{\n" |
| 134 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 135 " \"css\": \"style.css\"\n" |
| 136 "}"), |
| 137 &error, |
| 138 &bad_message); |
| 139 EXPECT_TRUE(bad_message); |
| 140 ASSERT_FALSE(result.get()); |
| 141 } |
| 142 |
| 143 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, JSBadType) { |
| 144 InitBasicExtensionFiles(); |
| 145 ext_dir().WriteFile(FILE_PATH_LITERAL("script.js"), ""); |
| 146 const Extension* extension = LoadTestExtension(); |
| 147 ASSERT_TRUE(extension); |
| 148 |
| 149 std::string error; |
| 150 bool bad_message = false; |
| 151 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 152 profile(), |
| 153 extension, |
| 154 *base::test::ParseJson( |
| 155 "{\n" |
| 156 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 157 " \"js\": \"script.js\"\n" |
| 158 "}"), |
| 159 &error, |
| 160 &bad_message); |
| 161 EXPECT_TRUE(bad_message); |
| 162 ASSERT_FALSE(result.get()); |
| 163 } |
| 164 |
| 165 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, AllFrames) { |
| 166 InitBasicExtensionFiles(); |
| 167 ext_dir().WriteFile(FILE_PATH_LITERAL("script.js"), ""); |
| 168 const Extension* extension = LoadTestExtension(); |
| 169 ASSERT_TRUE(extension); |
| 170 |
| 171 std::string error; |
| 172 bool bad_message = false; |
| 173 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 174 profile(), |
| 175 extension, |
| 176 *base::test::ParseJson( |
| 177 "{\n" |
| 178 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 179 " \"js\": [\"script.js\"],\n" |
| 180 " \"allFrames\": true\n" |
| 181 "}"), |
| 182 &error, |
| 183 &bad_message); |
| 184 EXPECT_EQ("", error); |
| 185 EXPECT_FALSE(bad_message); |
| 186 ASSERT_TRUE(result.get()); |
| 187 EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType()); |
| 188 } |
| 189 |
| 190 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, MatchAboutBlank) { |
| 191 InitBasicExtensionFiles(); |
| 192 ext_dir().WriteFile(FILE_PATH_LITERAL("script.js"), ""); |
| 193 const Extension* extension = LoadTestExtension(); |
| 194 ASSERT_TRUE(extension); |
| 195 |
| 196 std::string error; |
| 197 bool bad_message = false; |
| 198 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 199 profile(), |
| 200 extension, |
| 201 *base::test::ParseJson( |
| 202 "{\n" |
| 203 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 204 " \"js\": [\"script.js\"],\n" |
| 205 " \"matchAboutBlank\": true\n" |
| 206 "}"), |
| 207 &error, |
| 208 &bad_message); |
| 209 EXPECT_EQ("", error); |
| 210 EXPECT_FALSE(bad_message); |
| 211 ASSERT_TRUE(result.get()); |
| 212 EXPECT_EQ(ContentAction::ACTION_REQUEST_CONTENT_SCRIPT, result->GetType()); |
| 213 } |
| 214 |
| 215 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, AllFramesBadType) { |
| 216 InitBasicExtensionFiles(); |
| 217 ext_dir().WriteFile(FILE_PATH_LITERAL("script.js"), ""); |
| 218 const Extension* extension = LoadTestExtension(); |
| 219 ASSERT_TRUE(extension); |
| 220 |
| 221 std::string error; |
| 222 bool bad_message = false; |
| 223 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 224 profile(), |
| 225 extension, |
| 226 *base::test::ParseJson( |
| 227 "{\n" |
| 228 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 229 " \"js\": [\"script.js\"],\n" |
| 230 " \"allFrames\": null\n" |
| 231 "}"), |
| 232 &error, |
| 233 &bad_message); |
| 234 EXPECT_TRUE(bad_message); |
| 235 ASSERT_FALSE(result.get()); |
| 236 } |
| 237 |
| 238 IN_PROC_BROWSER_TEST_F(RequestContentScriptTest, MatchAboutBlankBadType) { |
| 239 InitBasicExtensionFiles(); |
| 240 ext_dir().WriteFile(FILE_PATH_LITERAL("script.js"), ""); |
| 241 const Extension* extension = LoadTestExtension(); |
| 242 ASSERT_TRUE(extension); |
| 243 |
| 244 std::string error; |
| 245 bool bad_message = false; |
| 246 scoped_refptr<const ContentAction> result = ContentAction::Create( |
| 247 profile(), |
| 248 extension, |
| 249 *base::test::ParseJson( |
| 250 "{\n" |
| 251 " \"instanceType\": \"declarativeContent.RequestContentScript\",\n" |
| 252 " \"js\": [\"script.js\"],\n" |
| 253 " \"matchAboutBlank\": null\n" |
| 254 "}"), |
| 255 &error, |
| 256 &bad_message); |
| 257 EXPECT_TRUE(bad_message); |
| 258 ASSERT_FALSE(result.get()); |
| 259 } |
| 260 |
| 261 } // namespace |
| 262 } // namespace extensions |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 493633003:
Browser changes for wiring up RequestContentScript API to shared memory (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master