Generate an etag for chrome-extension:// file requests, so caching can be optional

chrome/browser/extensions/extension_protocols_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 <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
+#include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_protocols.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread.h"
@@ skipping 37 matching lines @@
   path = path.AppendASCII("web_store");
 
   std::string error;
   scoped_refptr<Extension> extension(
       Extension::Create(path, Manifest::COMPONENT, manifest,
                         Extension::NO_FLAGS, &error));
   EXPECT_TRUE(extension.get()) << error;
   return extension;
 }
 
+scoped_refptr<Extension> CreateTestResponseHeaderExtension() {
+  DictionaryValue manifest;
+  manifest.SetString("name", "An extension with web-accessible resources");
+  manifest.SetString("version", "2");
+
+  ListValue* web_accessible_list = new ListValue();
+  web_accessible_list->AppendString("test.dat");
+  manifest.Set("web_accessible_resources", web_accessible_list);
+
+  base::FilePath path;
+  EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
+  path = path.AppendASCII("extensions").AppendASCII("response_headers");
+
+  std::string error;
+  scoped_refptr<Extension> extension(
+      Extension::Create(path, Manifest::UNPACKED, manifest,

[rvargas (doing something else), 2013/06/03 21:12:37]

I'm assuming that the extension destructor does cleanup of the files on disk.

[jvoung (off chromium), 2013/06/03 22:08:22]

It doesn't look like the destructor does anything, but it didn't look like the
constructor would put anything new on disk either.

I thought it just refers to a path to some directory (where the directory holds
the extension files prior to packing it up into a .zip or .crx).

[Matt Perry, 2013/06/03 22:17:19]

Yep, no new files are created by this test.

+                        Extension::NO_FLAGS, &error));
+  EXPECT_TRUE(extension.get()) << error;
+  return extension;
+}
+
 class ExtensionProtocolTest : public testing::Test {
  public:
   ExtensionProtocolTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_) {}
 
   virtual void SetUp() OVERRIDE {
     testing::Test::SetUp();
     extension_info_map_ = new ExtensionInfoMap();
@@ skipping 133 matching lines @@
                                        extension_misc::UNLOAD_REASON_DISABLE);
   {
     net::URLRequest request(extension->GetResourceURL("webstore_icon_16.png"),
                             &test_delegate_,
                             resource_context_.GetRequestContext());
     StartRequest(&request, ResourceType::MEDIA);
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
   }
 }
 
+// Tests that a URL request for resource from an extension returns a few
+// expected response headers.
+TEST_F(ExtensionProtocolTest, ResourceRequestResponseHeaders) {
+  // Register a non-incognito extension protocol handler.
+  SetProtocolHandler(false);
+
+  scoped_refptr<Extension> extension = CreateTestResponseHeaderExtension();
+  extension_info_map_->AddExtension(extension, base::Time::Now(), false);
+
+  {
+    net::URLRequest request(extension->GetResourceURL("test.dat"),
+                            &test_delegate_,
+                            resource_context_.GetRequestContext());
+    StartRequest(&request, ResourceType::MEDIA);
+    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
+
+    // Check that cache-related headers are set.
+    std::string etag;
+    request.GetResponseHeaderByName("ETag", &etag);
+    EXPECT_TRUE(StartsWithASCII(etag, "\"", false));
+    EXPECT_TRUE(EndsWith(etag, "\"", false));
+
+    std::string revalidation_header;
+    request.GetResponseHeaderByName("cache-control", &revalidation_header);
+    EXPECT_EQ("no-cache", revalidation_header);
+
+    // We set test.dat as web-accessible, so it should have a CORS header.
+    std::string access_control;
+    request.GetResponseHeaderByName("Access-Control-Allow-Origin",
+                                    &access_control);
+    EXPECT_EQ("*", access_control);
+  }
+}
+
 }  // namespace extensions