Beginning of support for 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 15 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer/elapsed_timer.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
+#include "extensions/browser/content_verifier.h"
+#include "extensions/browser/content_verify_job.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/csp_info.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
@@ skipping 112 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)
+                         bool follow_symlinks_anywhere,
+                         ContentVerifyJob* verify_job)
       : net::URLRequestFileJob(
             request,
             network_delegate,
             base::FilePath(),
             BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
+        verify_job_(verify_job),
         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) {
       resource_.set_follow_symlinks_anywhere();
     }
-    const std::string& group =
-        base::FieldTrialList::FindFullName("ExtensionContentHashMeasurement");
-    if (group == "Yes") {
-      base::ElapsedTimer timer;
-      hash_.reset(crypto::SecureHash::Create(crypto::SecureHash::SHA256));
-      hashing_time_ = timer.Elapsed();
-    }
   }
 
   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 = BrowserThread::PostBlockingPoolTaskAndReply(
         FROM_HERE,
         base::Bind(&ReadResourceFilePathAndLastModifiedTime,
                    resource_,
                    directory_path_,
                    base::Unretained(read_file_path),
                    base::Unretained(last_modified_time)),
         base::Bind(&URLRequestExtensionJob::OnFilePathAndLastModifiedTimeRead,
                    weak_factory_.GetWeakPtr(),
                    base::Owned(read_file_path),
                    base::Owned(last_modified_time)));
     DCHECK(posted);
   }
 
+  virtual void SetExtraRequestHeaders(
+      const net::HttpRequestHeaders& headers) OVERRIDE {
+    // TODO(asargent) - we'll need to add proper support for range headers.
+    // crbug.com/369895.
+    std::string range_header;
+    if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
+      if (verify_job_)
+        verify_job_ = NULL;
+    }
+    URLRequestFileJob::SetExtraRequestHeaders(headers);
+  }
+
   virtual void OnSeekComplete(int64 result) OVERRIDE {
     DCHECK_EQ(seek_position_, 0);
     seek_position_ = result;
+    // TODO(asargent) - we'll need to add proper support for range headers.
+    // crbug.com/369895.
+    if (result > 0 && verify_job_)
+      verify_job_ = NULL;
   }
 
   virtual void OnReadComplete(net::IOBuffer* buffer, int result) OVERRIDE {
     if (result >= 0)
       UMA_HISTOGRAM_COUNTS("ExtensionUrlRequest.OnReadCompleteResult", result);
     else
       UMA_HISTOGRAM_SPARSE_SLOWLY("ExtensionUrlRequest.OnReadCompleteError",
                                   -result);
     if (result > 0) {
       bytes_read_ += result;
-      if (hash_.get()) {
-        base::ElapsedTimer timer;
-        hash_->Update(buffer->data(), result);
-        hashing_time_ += timer.Elapsed();
+      if (verify_job_) {
+        verify_job_->BytesRead(result, buffer->data());
+        if (remaining_bytes() == 0)

[rvargas (doing something else), 2014/05/08 17:50:07]

Very small nit: maybe !remaining_bytes() reads better.

[asargent_no_longer_on_chrome, 2014/05/08 18:02:07]

Done.

+          verify_job_->DoneReading();
       }
     }
   }
 
  private:
   virtual ~URLRequestExtensionJob() {
-    if (hash_.get()) {
-      base::ElapsedTimer timer;
-      std::string hash_bytes(crypto::kSHA256Length, 0);
-      hash_->Finish(string_as_array(&hash_bytes), hash_bytes.size());
-      hashing_time_ += timer.Elapsed();
-      UMA_HISTOGRAM_TIMES("ExtensionUrlRequest.HashTimeMs", hashing_time_);
-    }
     UMA_HISTOGRAM_COUNTS("ExtensionUrlRequest.TotalKbRead", bytes_read_ / 1024);
     UMA_HISTOGRAM_COUNTS("ExtensionUrlRequest.SeekPosition", seek_position_);
   }
 
   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();
   }
 
-  // A hash of the contents we've read from the file.
-  scoped_ptr<crypto::SecureHash> hash_;
+  scoped_refptr<ContentVerifyJob> verify_job_;
 
   // 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_;
 
-  // Used to count the total time it takes to do hashing operations.
-  base::TimeDelta hashing_time_;
-
   net::HttpResponseInfo response_info_;
   base::FilePath directory_path_;
   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,
@@ skipping 209 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);
+                                    follow_symlinks_anywhere,
+                                    verify_job);
 }
 
 }  // 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