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

chrome/browser/extensions/extension_protocols.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 "chrome/browser/extensions/extension_protocols.h"
 
 #include <algorithm>
 
+#include "base/base64.h"
 #include "base/compiler_specific.h"
+#include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
+#include "base/sha1.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/image_loader.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/background_info.h"
@@ skipping 20 matching lines @@
 #include "net/url_request/url_request_simple_job.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::ResourceRequestInfo;
 using extensions::Extension;
 using extensions::SharedModuleInfo;
 
 namespace {
 
 net::HttpResponseHeaders* BuildHttpHeaders(
-    const std::string& content_security_policy, bool send_cors_header) {
+    const std::string& content_security_policy, bool send_cors_header,
+    const base::Time& last_modified_time) {
   std::string raw_headers;
   raw_headers.append("HTTP/1.1 200 OK");
   if (!content_security_policy.empty()) {
     raw_headers.append(1, '\0');
     raw_headers.append("Content-Security-Policy: ");
     raw_headers.append(content_security_policy);
   }
 
   if (send_cors_header) {
     raw_headers.append(1, '\0');
     raw_headers.append("Access-Control-Allow-Origin: *");
   }
+
+  if (!last_modified_time.is_null()) {
+    // Hash the time and make an etag to avoid exposing the exact
+    // user installation time of the extension.
+    std::string hash = base::StringPrintf("%f", last_modified_time.ToDoubleT());
+    hash = base::SHA1HashString(hash);
+    std::string etag;
+    if (base::Base64Encode(hash, &etag)) {
+      raw_headers.append(1, '\0');
+      raw_headers.append("ETag: \"");
+      raw_headers.append(etag.c_str());

[Matt Perry, 2013/06/03 18:13:55]

No need to take c_str() here

[jvoung (off chromium), 2013/06/03 20:21:52]

Done.

+      raw_headers.append("\"");
+      // Also force revalidation.
+      raw_headers.append(1, '\0');
+      raw_headers.append("cache-control: no-cache");
+    }
+  }
+
   raw_headers.append(2, '\0');
   return new net::HttpResponseHeaders(raw_headers);
 }
 
 void ReadMimeTypeFromFile(const base::FilePath& filename,
                           std::string* mime_type,
                           bool* result) {
   *result = net::GetMimeTypeFromFile(filename, mime_type);
 }
 
+void GetLastModifiedTime(const base::FilePath& filename,
+                         base::Time* last_modified_time) {
+  if (file_util::PathExists(filename)) {
+    base::PlatformFileInfo info;
+    if (file_util::GetFileInfo(filename, &info))
+      *last_modified_time = info.last_modified;
+  }
+}
+
 class URLRequestResourceBundleJob : public net::URLRequestSimpleJob {
  public:
   URLRequestResourceBundleJob(net::URLRequest* request,
                               net::NetworkDelegate* network_delegate,
                               const base::FilePath& filename,
                               int resource_id,
                               const std::string& content_security_policy,
                               bool send_cors_header)
       : net::URLRequestSimpleJob(request, network_delegate),
         filename_(filename),
         resource_id_(resource_id),
         weak_factory_(this) {
+     // Leave cache headers out of resource bundle requests.
     response_info_.headers = BuildHttpHeaders(content_security_policy,
-                                              send_cors_header);
+                                              send_cors_header,
+                                              base::Time());
   }
 
   // Overridden from URLRequestSimpleJob:
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
                       const net::CompletionCallback& callback) const OVERRIDE {
     const ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     *data = rb.GetRawDataResource(resource_id_).as_string();
 
@@ skipping 53 matching lines @@
 
 class GeneratedBackgroundPageJob : public net::URLRequestSimpleJob {
  public:
   GeneratedBackgroundPageJob(net::URLRequest* request,
                              net::NetworkDelegate* network_delegate,
                              const scoped_refptr<const Extension> extension,
                              const std::string& content_security_policy)
       : net::URLRequestSimpleJob(request, network_delegate),
         extension_(extension) {
     const bool send_cors_headers = false;
+    // Leave cache headers out of generated background page jobs.
     response_info_.headers = BuildHttpHeaders(content_security_policy,
-                                              send_cors_headers);
+                                              send_cors_headers,
+                                              base::Time());
   }
 
   // Overridden from URLRequestSimpleJob:
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
                       const net::CompletionCallback& callback) const OVERRIDE {
     *mime_type = "text/html";
     *charset = "utf-8";
 
@@ skipping 13 matching lines @@
     *info = response_info_;
   }
 
  private:
   virtual ~GeneratedBackgroundPageJob() {}
 
   scoped_refptr<const Extension> extension_;
   net::HttpResponseInfo response_info_;
 };
 
-void ReadResourceFilePath(const extensions::ExtensionResource& resource,
-                          base::FilePath* file_path) {
+void ReadResourceFilePathAndLastModifiedTime(
+    const extensions::ExtensionResource& resource,
+    base::FilePath* file_path,
+    base::Time* last_modified_time) {
   *file_path = resource.GetFilePath();
+  GetLastModifiedTime(*file_path, last_modified_time);
 }
 
 class URLRequestExtensionJob : public net::URLRequestFileJob {
  public:
   URLRequestExtensionJob(net::URLRequest* request,
                          net::NetworkDelegate* network_delegate,
                          const std::string& extension_id,
                          const base::FilePath& directory_path,
                          const base::FilePath& relative_path,
                          const std::string& content_security_policy,
                          bool send_cors_header)
     : net::URLRequestFileJob(request, network_delegate, base::FilePath()),
       // TODO(tc): Move all of these files into resources.pak so we don't break
       // when updating on Linux.
       resource_(extension_id, directory_path, relative_path),
+      content_security_policy_(content_security_policy),
+      send_cors_header_(send_cors_header),
       weak_factory_(this) {
-      response_info_.headers = BuildHttpHeaders(content_security_policy,
-                                                send_cors_header);
   }
 
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE {
     *info = response_info_;
   }
 
   virtual void Start() OVERRIDE {
     base::FilePath* read_file_path = new base::FilePath;
+    base::Time* last_modified_time = new base::Time();
     bool posted = base::WorkerPool::PostTaskAndReply(
         FROM_HERE,
-        base::Bind(&ReadResourceFilePath, resource_,
-                   base::Unretained(read_file_path)),
-        base::Bind(&URLRequestExtensionJob::OnFilePathRead,
+        base::Bind(&ReadResourceFilePathAndLastModifiedTime, resource_,
+                   base::Unretained(read_file_path),
+                   base::Unretained(last_modified_time)),
+        base::Bind(&URLRequestExtensionJob::OnFilePathAndLastModifiedTimeRead,
                    weak_factory_.GetWeakPtr(),
-                   base::Owned(read_file_path)),
+                   base::Owned(read_file_path),
+                   base::Owned(last_modified_time)),
         true /* task is slow */);
     DCHECK(posted);
   }
 
  private:
   virtual ~URLRequestExtensionJob() {}
 
-  void OnFilePathRead(base::FilePath* read_file_path) {
+  void OnFilePathAndLastModifiedTimeRead(base::FilePath* read_file_path,
+                                         base::Time* last_modified_time) {
     file_path_ = *read_file_path;
+    response_info_.headers = BuildHttpHeaders(
+        content_security_policy_,
+        send_cors_header_,
+        *last_modified_time);
     URLRequestFileJob::Start();
   }
 
   net::HttpResponseInfo response_info_;
   extensions::ExtensionResource resource_;
+  std::string content_security_policy_;
+  bool send_cors_header_;
   base::WeakPtrFactory<URLRequestExtensionJob> weak_factory_;
 };
 
 bool ExtensionCanLoadInIncognito(const ResourceRequestInfo* info,
                                  const std::string& extension_id,
                                  ExtensionInfoMap* extension_info_map) {
   if (!extension_info_map->IsIncognitoEnabled(extension_id))
     return false;
 
   // Only allow incognito toplevel navigations to extension resources in
@@ skipping 256 matching lines @@
                                     send_cors_header);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateExtensionProtocolHandler(
     bool is_incognito,
     ExtensionInfoMap* extension_info_map) {
   return new ExtensionProtocolHandler(is_incognito, extension_info_map);
 }