Fix case-sensitivity problems in extension content verification

extensions/browser/extension_protocols.cc

 // Copyright 2014 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 "extensions/browser/extension_protocols.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 151 matching lines @@
 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,
                          bool follow_symlinks_anywhere,
-                         ContentVerifyJob* verify_job)
+                         ContentVerifier* verifier)
       : net::URLRequestFileJob(
             request,
             network_delegate,
             base::FilePath(),
             BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
-        verify_job_(verify_job),
+        verifier_(verifier),
         seek_position_(0),
         bytes_read_(0),
         directory_path_(directory_path),
         // 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) {
     if (follow_symlinks_anywhere) {
@@ skipping 65 matching lines @@
     UMA_HISTOGRAM_COUNTS("ExtensionUrlRequest.TotalKbRead", bytes_read_ / 1024);
     UMA_HISTOGRAM_COUNTS("ExtensionUrlRequest.SeekPosition", seek_position_);
     if (request_timer_.get())
       UMA_HISTOGRAM_TIMES("ExtensionUrlRequest.Latency",
                           request_timer_->Elapsed());
   }
 
   void OnFilePathAndLastModifiedTimeRead(base::FilePath* read_file_path,
                                          base::Time* last_modified_time) {
     file_path_ = *read_file_path;
+    if (verifier_.get()) {
+      // On case-insentivie filesystems, the relative path we got passed in at
+      // construction time might differ in case from the actual filename on
+      // disk, but we want to use the actual filename for content verification
+      // purposes.
+      base::FilePath actual_relative_path;
+      directory_path_.AppendRelativePath(file_path_, &actual_relative_path);

[Ken Rockot(use gerrit already), 2014/09/19 18:03:05]

It looks like this may not actually work on Windows. We can trace any potential
case translation back to file_util::MakeAbsolutePath, which in turn calls
_wfullpath. I've verified however that this function makes no effort to reflect
the case of the filename as it's known by the filesystem. It will preserve the
case of its input string.

+      verify_job_ = verifier_->CreateJobFor(
+          resource_.extension_id(), directory_path_, actual_relative_path);
+      if (verify_job_.get())
+        verify_job_->Start();
+      verifier_ = NULL;
+    }
     response_info_.headers = BuildHttpHeaders(
         content_security_policy_,
         send_cors_header_,
         *last_modified_time);
     URLRequestFileJob::Start();
   }
 
+  scoped_refptr<ContentVerifier> verifier_;
   scoped_refptr<ContentVerifyJob> verify_job_;
 
   scoped_ptr<base::ElapsedTimer> request_timer_;
 
   // The position we seeked to in the file.
   int64 seek_position_;
 
   // The number of bytes of content we read from the file.
   int bytes_read_;
 
@@ skipping 219 matching lines @@
         new_extension &&
         (first_party_in_import ||
          SharedModuleInfo::IsExportAllowed(new_extension, new_relative_path))) {
       directory_path = new_extension->path();
       extension_id = new_extension_id;
       relative_path = base::FilePath::FromUTF8Unsafe(new_relative_path);
     } else {
       return NULL;
     }
   }
-  ContentVerifyJob* verify_job = NULL;
   ContentVerifier* verifier = extension_info_map_->content_verifier();
-  if (verifier) {
-    verify_job =
-        verifier->CreateJobFor(extension_id, directory_path, relative_path);
-    if (verify_job)
-      verify_job->Start();
-  }
-
   return new URLRequestExtensionJob(request,
                                     network_delegate,
                                     extension_id,
                                     directory_path,
                                     relative_path,
                                     content_security_policy,
                                     send_cors_header,
                                     follow_symlinks_anywhere,
-                                    verify_job);
+                                    verifier);
 }
 
 }  // namespace
 
 net::HttpResponseHeaders* BuildHttpHeaders(
     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");
@@ skipping 29 matching lines @@
   return new net::HttpResponseHeaders(raw_headers);
 }
 
 net::URLRequestJobFactory::ProtocolHandler* CreateExtensionProtocolHandler(
     bool is_incognito,
     extensions::InfoMap* extension_info_map) {
   return new ExtensionProtocolHandler(is_incognito, extension_info_map);
 }
 
 }  // namespace extensions