| OLD | NEW |
|---|
| (Empty) |
| 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 <string> | |
| 6 | |
| 7 #include "base/file_util.h" | |
| 8 #include "base/message_loop/message_loop.h" | |
| 9 #include "base/strings/string_number_conversions.h" | |
| 10 #include "base/strings/string_util.h" | |
| 11 #include "base/values.h" | |
| 12 #include "chrome/browser/extensions/extension_protocols.h" | |
| 13 #include "chrome/common/chrome_paths.h" | |
| 14 #include "chrome/common/url_constants.h" | |
| 15 #include "content/public/browser/resource_request_info.h" | |
| 16 #include "content/public/test/mock_resource_context.h" | |
| 17 #include "content/public/test/test_browser_thread_bundle.h" | |
| 18 #include "extensions/browser/info_map.h" | |
| 19 #include "extensions/common/constants.h" | |
| 20 #include "extensions/common/extension.h" | |
| 21 #include "net/base/request_priority.h" | |
| 22 #include "net/url_request/url_request.h" | |
| 23 #include "net/url_request/url_request_job_factory_impl.h" | |
| 24 #include "net/url_request/url_request_status.h" | |
| 25 #include "net/url_request/url_request_test_util.h" | |
| 26 #include "testing/gtest/include/gtest/gtest.h" | |
| 27 | |
| 28 namespace extensions { | |
| 29 | |
| 30 scoped_refptr<Extension> CreateTestExtension(const std::string& name, | |
| 31 bool incognito_split_mode) { | |
| 32 base::DictionaryValue manifest; | |
| 33 manifest.SetString("name", name); | |
| 34 manifest.SetString("version", "1"); | |
| 35 manifest.SetInteger("manifest_version", 2); | |
| 36 manifest.SetString("incognito", incognito_split_mode ? "split" : "spanning"); | |
| 37 | |
| 38 base::FilePath path; | |
| 39 EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path)); | |
| 40 path = path.AppendASCII("extensions").AppendASCII("response_headers"); | |
| 41 | |
| 42 std::string error; | |
| 43 scoped_refptr<Extension> extension( | |
| 44 Extension::Create(path, Manifest::INTERNAL, manifest, | |
| 45 Extension::NO_FLAGS, &error)); | |
| 46 EXPECT_TRUE(extension.get()) << error; | |
| 47 return extension; | |
| 48 } | |
| 49 | |
| 50 scoped_refptr<Extension> CreateWebStoreExtension() { | |
| 51 base::DictionaryValue manifest; | |
| 52 manifest.SetString("name", "WebStore"); | |
| 53 manifest.SetString("version", "1"); | |
| 54 manifest.SetString("icons.16", "webstore_icon_16.png"); | |
| 55 | |
| 56 base::FilePath path; | |
| 57 EXPECT_TRUE(PathService::Get(chrome::DIR_RESOURCES, &path)); | |
| 58 path = path.AppendASCII("web_store"); | |
| 59 | |
| 60 std::string error; | |
| 61 scoped_refptr<Extension> extension( | |
| 62 Extension::Create(path, Manifest::COMPONENT, manifest, | |
| 63 Extension::NO_FLAGS, &error)); | |
| 64 EXPECT_TRUE(extension.get()) << error; | |
| 65 return extension; | |
| 66 } | |
| 67 | |
| 68 scoped_refptr<Extension> CreateTestResponseHeaderExtension() { | |
| 69 base::DictionaryValue manifest; | |
| 70 manifest.SetString("name", "An extension with web-accessible resources"); | |
| 71 manifest.SetString("version", "2"); | |
| 72 | |
| 73 base::ListValue* web_accessible_list = new base::ListValue(); | |
| 74 web_accessible_list->AppendString("test.dat"); | |
| 75 manifest.Set("web_accessible_resources", web_accessible_list); | |
| 76 | |
| 77 base::FilePath path; | |
| 78 EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path)); | |
| 79 path = path.AppendASCII("extensions").AppendASCII("response_headers"); | |
| 80 | |
| 81 std::string error; | |
| 82 scoped_refptr<Extension> extension( | |
| 83 Extension::Create(path, Manifest::UNPACKED, manifest, | |
| 84 Extension::NO_FLAGS, &error)); | |
| 85 EXPECT_TRUE(extension.get()) << error; | |
| 86 return extension; | |
| 87 } | |
| 88 | |
| 89 class ExtensionProtocolTest : public testing::Test { | |
| 90 public: | |
| 91 ExtensionProtocolTest() | |
| 92 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), | |
| 93 resource_context_(&test_url_request_context_) {} | |
| 94 | |
| 95 virtual void SetUp() OVERRIDE { | |
| 96 testing::Test::SetUp(); | |
| 97 extension_info_map_ = new InfoMap(); | |
| 98 net::URLRequestContext* request_context = | |
| 99 resource_context_.GetRequestContext(); | |
| 100 old_factory_ = request_context->job_factory(); | |
| 101 } | |
| 102 | |
| 103 virtual void TearDown() { | |
| 104 net::URLRequestContext* request_context = | |
| 105 resource_context_.GetRequestContext(); | |
| 106 request_context->set_job_factory(old_factory_); | |
| 107 } | |
| 108 | |
| 109 void SetProtocolHandler(Profile::ProfileType profile_type) { | |
| 110 net::URLRequestContext* request_context = | |
| 111 resource_context_.GetRequestContext(); | |
| 112 job_factory_.SetProtocolHandler( | |
| 113 kExtensionScheme, | |
| 114 CreateExtensionProtocolHandler(profile_type, | |
| 115 extension_info_map_.get())); | |
| 116 request_context->set_job_factory(&job_factory_); | |
| 117 } | |
| 118 | |
| 119 void StartRequest(net::URLRequest* request, | |
| 120 ResourceType::Type resource_type) { | |
| 121 content::ResourceRequestInfo::AllocateForTesting(request, | |
| 122 resource_type, | |
| 123 &resource_context_, | |
| 124 -1, | |
| 125 -1, | |
| 126 -1, | |
| 127 false); | |
| 128 request->Start(); | |
| 129 base::MessageLoop::current()->Run(); | |
| 130 } | |
| 131 | |
| 132 protected: | |
| 133 content::TestBrowserThreadBundle thread_bundle_; | |
| 134 scoped_refptr<InfoMap> extension_info_map_; | |
| 135 net::URLRequestJobFactoryImpl job_factory_; | |
| 136 const net::URLRequestJobFactory* old_factory_; | |
| 137 net::TestDelegate test_delegate_; | |
| 138 net::TestURLRequestContext test_url_request_context_; | |
| 139 content::MockResourceContext resource_context_; | |
| 140 }; | |
| 141 | |
| 142 // Tests that making a chrome-extension request in an incognito context is | |
| 143 // only allowed under the right circumstances (if the extension is allowed | |
| 144 // in incognito, and it's either a non-main-frame request or a split-mode | |
| 145 // extension). | |
| 146 TEST_F(ExtensionProtocolTest, IncognitoRequest) { | |
| 147 // Register an incognito extension protocol handler. | |
| 148 SetProtocolHandler(Profile::INCOGNITO_PROFILE); | |
| 149 | |
| 150 struct TestCase { | |
| 151 // Inputs. | |
| 152 std::string name; | |
| 153 bool incognito_split_mode; | |
| 154 bool incognito_enabled; | |
| 155 | |
| 156 // Expected results. | |
| 157 bool should_allow_main_frame_load; | |
| 158 bool should_allow_sub_frame_load; | |
| 159 } cases[] = { | |
| 160 {"spanning disabled", false, false, false, false}, | |
| 161 {"split disabled", true, false, false, false}, | |
| 162 {"spanning enabled", false, true, false, true}, | |
| 163 {"split enabled", true, true, true, true}, | |
| 164 }; | |
| 165 | |
| 166 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) { | |
| 167 scoped_refptr<Extension> extension = | |
| 168 CreateTestExtension(cases[i].name, cases[i].incognito_split_mode); | |
| 169 extension_info_map_->AddExtension( | |
| 170 extension.get(), base::Time::Now(), cases[i].incognito_enabled, false); | |
| 171 | |
| 172 // First test a main frame request. | |
| 173 { | |
| 174 // It doesn't matter that the resource doesn't exist. If the resource | |
| 175 // is blocked, we should see ADDRESS_UNREACHABLE. Otherwise, the request | |
| 176 // should just fail because the file doesn't exist. | |
| 177 net::URLRequest request(extension->GetResourceURL("404.html"), | |
| 178 net::DEFAULT_PRIORITY, | |
| 179 &test_delegate_, | |
| 180 resource_context_.GetRequestContext()); | |
| 181 StartRequest(&request, ResourceType::MAIN_FRAME); | |
| 182 EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status()); | |
| 183 | |
| 184 if (cases[i].should_allow_main_frame_load) { | |
| 185 EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request.status().error()) << | |
| 186 cases[i].name; | |
| 187 } else { | |
| 188 EXPECT_EQ(net::ERR_ADDRESS_UNREACHABLE, request.status().error()) << | |
| 189 cases[i].name; | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 // Now do a subframe request. | |
| 194 { | |
| 195 net::URLRequest request(extension->GetResourceURL("404.html"), | |
| 196 net::DEFAULT_PRIORITY, | |
| 197 &test_delegate_, | |
| 198 resource_context_.GetRequestContext()); | |
| 199 StartRequest(&request, ResourceType::SUB_FRAME); | |
| 200 EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status()); | |
| 201 | |
| 202 if (cases[i].should_allow_sub_frame_load) { | |
| 203 EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request.status().error()) << | |
| 204 cases[i].name; | |
| 205 } else { | |
| 206 EXPECT_EQ(net::ERR_ADDRESS_UNREACHABLE, request.status().error()) << | |
| 207 cases[i].name; | |
| 208 } | |
| 209 } | |
| 210 } | |
| 211 } | |
| 212 | |
| 213 void CheckForContentLengthHeader(net::URLRequest* request) { | |
| 214 std::string content_length; | |
| 215 request->GetResponseHeaderByName(net::HttpRequestHeaders::kContentLength, | |
| 216 &content_length); | |
| 217 EXPECT_FALSE(content_length.empty()); | |
| 218 int length_value = 0; | |
| 219 EXPECT_TRUE(base::StringToInt(content_length, &length_value)); | |
| 220 EXPECT_GT(length_value, 0); | |
| 221 } | |
| 222 | |
| 223 // Tests getting a resource for a component extension works correctly, both when | |
| 224 // the extension is enabled and when it is disabled. | |
| 225 TEST_F(ExtensionProtocolTest, ComponentResourceRequest) { | |
| 226 // Register a non-incognito extension protocol handler. | |
| 227 SetProtocolHandler(Profile::REGULAR_PROFILE); | |
| 228 | |
| 229 scoped_refptr<Extension> extension = CreateWebStoreExtension(); | |
| 230 extension_info_map_->AddExtension(extension.get(), | |
| 231 base::Time::Now(), | |
| 232 false, | |
| 233 false); | |
| 234 | |
| 235 // First test it with the extension enabled. | |
| 236 { | |
| 237 net::URLRequest request(extension->GetResourceURL("webstore_icon_16.png"), | |
| 238 net::DEFAULT_PRIORITY, | |
| 239 &test_delegate_, | |
| 240 resource_context_.GetRequestContext()); | |
| 241 StartRequest(&request, ResourceType::MEDIA); | |
| 242 EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status()); | |
| 243 CheckForContentLengthHeader(&request); | |
| 244 } | |
| 245 | |
| 246 // And then test it with the extension disabled. | |
| 247 extension_info_map_->RemoveExtension(extension->id(), | |
| 248 UnloadedExtensionInfo::REASON_DISABLE); | |
| 249 { | |
| 250 net::URLRequest request(extension->GetResourceURL("webstore_icon_16.png"), | |
| 251 net::DEFAULT_PRIORITY, | |
| 252 &test_delegate_, | |
| 253 resource_context_.GetRequestContext()); | |
| 254 StartRequest(&request, ResourceType::MEDIA); | |
| 255 EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status()); | |
| 256 CheckForContentLengthHeader(&request); | |
| 257 } | |
| 258 } | |
| 259 | |
| 260 // Tests that a URL request for resource from an extension returns a few | |
| 261 // expected response headers. | |
| 262 TEST_F(ExtensionProtocolTest, ResourceRequestResponseHeaders) { | |
| 263 // Register a non-incognito extension protocol handler. | |
| 264 SetProtocolHandler(Profile::REGULAR_PROFILE); | |
| 265 | |
| 266 scoped_refptr<Extension> extension = CreateTestResponseHeaderExtension(); | |
| 267 extension_info_map_->AddExtension(extension.get(), | |
| 268 base::Time::Now(), | |
| 269 false, | |
| 270 false); | |
| 271 | |
| 272 { | |
| 273 net::URLRequest request(extension->GetResourceURL("test.dat"), | |
| 274 net::DEFAULT_PRIORITY, | |
| 275 &test_delegate_, | |
| 276 resource_context_.GetRequestContext()); | |
| 277 StartRequest(&request, ResourceType::MEDIA); | |
| 278 EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status()); | |
| 279 | |
| 280 // Check that cache-related headers are set. | |
| 281 std::string etag; | |
| 282 request.GetResponseHeaderByName("ETag", &etag); | |
| 283 EXPECT_TRUE(StartsWithASCII(etag, "\"", false)); | |
| 284 EXPECT_TRUE(EndsWith(etag, "\"", false)); | |
| 285 | |
| 286 std::string revalidation_header; | |
| 287 request.GetResponseHeaderByName("cache-control", &revalidation_header); | |
| 288 EXPECT_EQ("no-cache", revalidation_header); | |
| 289 | |
| 290 // We set test.dat as web-accessible, so it should have a CORS header. | |
| 291 std::string access_control; | |
| 292 request.GetResponseHeaderByName("Access-Control-Allow-Origin", | |
| 293 &access_control); | |
| 294 EXPECT_EQ("*", access_control); | |
| 295 } | |
| 296 } | |
| 297 | |
| 298 // Tests that a URL request for main frame or subframe from an extension | |
| 299 // succeeds, but subresources fail. See http://crbug.com/312269. | |
| 300 TEST_F(ExtensionProtocolTest, AllowFrameRequests) { | |
| 301 // Register a non-incognito extension protocol handler. | |
| 302 SetProtocolHandler(Profile::REGULAR_PROFILE); | |
| 303 | |
| 304 scoped_refptr<Extension> extension = CreateTestExtension("foo", false); | |
| 305 extension_info_map_->AddExtension(extension.get(), | |
| 306 base::Time::Now(), | |
| 307 false, | |
| 308 false); | |
| 309 | |
| 310 // All MAIN_FRAME and SUB_FRAME requests should succeed. | |
| 311 { | |
| 312 net::URLRequest request(extension->GetResourceURL("test.dat"), | |
| 313 net::DEFAULT_PRIORITY, | |
| 314 &test_delegate_, | |
| 315 resource_context_.GetRequestContext()); | |
| 316 StartRequest(&request, ResourceType::MAIN_FRAME); | |
| 317 EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status()); | |
| 318 } | |
| 319 { | |
| 320 net::URLRequest request(extension->GetResourceURL("test.dat"), | |
| 321 net::DEFAULT_PRIORITY, | |
| 322 &test_delegate_, | |
| 323 resource_context_.GetRequestContext()); | |
| 324 StartRequest(&request, ResourceType::SUB_FRAME); | |
| 325 EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status()); | |
| 326 } | |
| 327 | |
| 328 // And subresource types, such as media, should fail. | |
| 329 { | |
| 330 net::URLRequest request(extension->GetResourceURL("test.dat"), | |
| 331 net::DEFAULT_PRIORITY, | |
| 332 &test_delegate_, | |
| 333 resource_context_.GetRequestContext()); | |
| 334 StartRequest(&request, ResourceType::MEDIA); | |
| 335 EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status()); | |
| 336 } | |
| 337 } | |
| 338 | |
| 339 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 229733002:
Toro: Move ExtensionProtocolHandler to //extensions (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src