chrome/browser/extensions/extension_protocols_unittest.cc

   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(bool incognito) {
 110     net::URLRequestContext* request_context =
 111         resource_context_.GetRequestContext();
 112     job_factory_.SetProtocolHandler(
 113         kExtensionScheme,
 114         CreateExtensionProtocolHandler(incognito, extension_info_map_.get()));
 115     request_context->set_job_factory(&job_factory_);
 116   }
 117
 118   void StartRequest(net::URLRequest* request,
 119                     ResourceType::Type resource_type) {
 120     content::ResourceRequestInfo::AllocateForTesting(request,
 121                                                      resource_type,
 122                                                      &resource_context_,
 123                                                      -1,
 124                                                      -1,
 125                                                      -1,
 126                                                      false);
 127     request->Start();
 128     base::MessageLoop::current()->Run();
 129   }
 130
 131  protected:
 132   content::TestBrowserThreadBundle thread_bundle_;
 133   scoped_refptr<InfoMap> extension_info_map_;
 134   net::URLRequestJobFactoryImpl job_factory_;
 135   const net::URLRequestJobFactory* old_factory_;
 136   net::TestDelegate test_delegate_;
 137   net::TestURLRequestContext test_url_request_context_;
 138   content::MockResourceContext resource_context_;
 139 };
 140
 141 // Tests that making a chrome-extension request in an incognito context is
 142 // only allowed under the right circumstances (if the extension is allowed
 143 // in incognito, and it's either a non-main-frame request or a split-mode
 144 // extension).
 145 TEST_F(ExtensionProtocolTest, IncognitoRequest) {
 146   // Register an incognito extension protocol handler.
 147   SetProtocolHandler(true);
 148
 149   struct TestCase {
 150     // Inputs.
 151     std::string name;
 152     bool incognito_split_mode;
 153     bool incognito_enabled;
 154
 155     // Expected results.
 156     bool should_allow_main_frame_load;
 157     bool should_allow_sub_frame_load;
 158   } cases[] = {
 159     {"spanning disabled", false, false, false, false},
 160     {"split disabled", true, false, false, false},
 161     {"spanning enabled", false, true, false, true},
 162     {"split enabled", true, true, true, true},
 163   };
 164
 165   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 166     scoped_refptr<Extension> extension =
 167         CreateTestExtension(cases[i].name, cases[i].incognito_split_mode);
 168     extension_info_map_->AddExtension(
 169         extension.get(), base::Time::Now(), cases[i].incognito_enabled, false);
 170
 171     // First test a main frame request.
 172     {
 173       // It doesn't matter that the resource doesn't exist. If the resource
 174       // is blocked, we should see ADDRESS_UNREACHABLE. Otherwise, the request
 175       // should just fail because the file doesn't exist.
 176       net::URLRequest request(extension->GetResourceURL("404.html"),
 177                               net::DEFAULT_PRIORITY,
 178                               &test_delegate_,
 179                               resource_context_.GetRequestContext());
 180       StartRequest(&request, ResourceType::MAIN_FRAME);
 181       EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status());
 182
 183       if (cases[i].should_allow_main_frame_load) {
 184         EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request.status().error()) <<
 185             cases[i].name;
 186       } else {
 187         EXPECT_EQ(net::ERR_ADDRESS_UNREACHABLE, request.status().error()) <<
 188             cases[i].name;
 189       }
 190     }
 191
 192     // Now do a subframe request.
 193     {
 194       net::URLRequest request(extension->GetResourceURL("404.html"),
 195                               net::DEFAULT_PRIORITY,
 196                               &test_delegate_,
 197                               resource_context_.GetRequestContext());
 198       StartRequest(&request, ResourceType::SUB_FRAME);
 199       EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status());
 200
 201       if (cases[i].should_allow_sub_frame_load) {
 202         EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request.status().error()) <<
 203             cases[i].name;
 204       } else {
 205         EXPECT_EQ(net::ERR_ADDRESS_UNREACHABLE, request.status().error()) <<
 206             cases[i].name;
 207       }
 208     }
 209   }
 210 }
 211
 212 void CheckForContentLengthHeader(net::URLRequest* request) {
 213   std::string content_length;
 214   request->GetResponseHeaderByName(net::HttpRequestHeaders::kContentLength,
 215                                   &content_length);
 216   EXPECT_FALSE(content_length.empty());
 217   int length_value = 0;
 218   EXPECT_TRUE(base::StringToInt(content_length, &length_value));
 219   EXPECT_GT(length_value, 0);
 220 }
 221
 222 // Tests getting a resource for a component extension works correctly, both when
 223 // the extension is enabled and when it is disabled.
 224 TEST_F(ExtensionProtocolTest, ComponentResourceRequest) {
 225   // Register a non-incognito extension protocol handler.
 226   SetProtocolHandler(false);
 227
 228   scoped_refptr<Extension> extension = CreateWebStoreExtension();
 229   extension_info_map_->AddExtension(extension.get(),
 230                                     base::Time::Now(),
 231                                     false,
 232                                     false);
 233
 234   // First test it with the extension enabled.
 235   {
 236     net::URLRequest request(extension->GetResourceURL("webstore_icon_16.png"),
 237                             net::DEFAULT_PRIORITY,
 238                             &test_delegate_,
 239                             resource_context_.GetRequestContext());
 240     StartRequest(&request, ResourceType::MEDIA);
 241     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
 242     CheckForContentLengthHeader(&request);
 243   }
 244
 245   // And then test it with the extension disabled.
 246   extension_info_map_->RemoveExtension(extension->id(),
 247                                        UnloadedExtensionInfo::REASON_DISABLE);
 248   {
 249     net::URLRequest request(extension->GetResourceURL("webstore_icon_16.png"),
 250                             net::DEFAULT_PRIORITY,
 251                             &test_delegate_,
 252                             resource_context_.GetRequestContext());
 253     StartRequest(&request, ResourceType::MEDIA);
 254     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
 255     CheckForContentLengthHeader(&request);
 256   }
 257 }
 258
 259 // Tests that a URL request for resource from an extension returns a few
 260 // expected response headers.
 261 TEST_F(ExtensionProtocolTest, ResourceRequestResponseHeaders) {
 262   // Register a non-incognito extension protocol handler.
 263   SetProtocolHandler(false);
 264
 265   scoped_refptr<Extension> extension = CreateTestResponseHeaderExtension();
 266   extension_info_map_->AddExtension(extension.get(),
 267                                     base::Time::Now(),
 268                                     false,
 269                                     false);
 270
 271   {
 272     net::URLRequest request(extension->GetResourceURL("test.dat"),
 273                             net::DEFAULT_PRIORITY,
 274                             &test_delegate_,
 275                             resource_context_.GetRequestContext());
 276     StartRequest(&request, ResourceType::MEDIA);
 277     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
 278
 279     // Check that cache-related headers are set.
 280     std::string etag;
 281     request.GetResponseHeaderByName("ETag", &etag);
 282     EXPECT_TRUE(StartsWithASCII(etag, "\"", false));
 283     EXPECT_TRUE(EndsWith(etag, "\"", false));
 284
 285     std::string revalidation_header;
 286     request.GetResponseHeaderByName("cache-control", &revalidation_header);
 287     EXPECT_EQ("no-cache", revalidation_header);
 288
 289     // We set test.dat as web-accessible, so it should have a CORS header.
 290     std::string access_control;
 291     request.GetResponseHeaderByName("Access-Control-Allow-Origin",
 292                                     &access_control);
 293     EXPECT_EQ("*", access_control);
 294   }
 295 }
 296
 297 // Tests that a URL request for main frame or subframe from an extension
 298 // succeeds, but subresources fail. See http://crbug.com/312269.
 299 TEST_F(ExtensionProtocolTest, AllowFrameRequests) {
 300   // Register a non-incognito extension protocol handler.
 301   SetProtocolHandler(false);
 302
 303   scoped_refptr<Extension> extension = CreateTestExtension("foo", false);
 304   extension_info_map_->AddExtension(extension.get(),
 305                                     base::Time::Now(),
 306                                     false,
 307                                     false);
 308
 309   // All MAIN_FRAME and SUB_FRAME requests should succeed.
 310   {
 311     net::URLRequest request(extension->GetResourceURL("test.dat"),
 312                             net::DEFAULT_PRIORITY,
 313                             &test_delegate_,
 314                             resource_context_.GetRequestContext());
 315     StartRequest(&request, ResourceType::MAIN_FRAME);
 316     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
 317   }
 318   {
 319     net::URLRequest request(extension->GetResourceURL("test.dat"),
 320                             net::DEFAULT_PRIORITY,
 321                             &test_delegate_,
 322                             resource_context_.GetRequestContext());
 323     StartRequest(&request, ResourceType::SUB_FRAME);
 324     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
 325   }
 326
 327   // And subresource types, such as media, should fail.
 328   {
 329     net::URLRequest request(extension->GetResourceURL("test.dat"),
 330                             net::DEFAULT_PRIORITY,
 331                             &test_delegate_,
 332                             resource_context_.GetRequestContext());
 333     StartRequest(&request, ResourceType::MEDIA);
 334     EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status());
 335   }
 336 }
 337
 338 }  // namespace extensions