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