Fix extension content verification out-of-band hash fetching

extensions/browser/content_hash_fetcher.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/content_hash_fetcher.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <memory>
+#include <vector>
 
 #include "base/base64.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/version.h"
-#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/storage_partition.h"
 #include "crypto/sha2.h"
 #include "extensions/browser/computed_hashes.h"
 #include "extensions/browser/content_hash_tree.h"
 #include "extensions/browser/content_verifier_delegate.h"
 #include "extensions/browser/verified_contents.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/file_util.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
@@ skipping 216 matching lines @@
     url_fetcher_->Start();
   }
 }
 
 // Helper function to let us pass ownership of a string via base::Bind with the
 // contents to be written into a file. Also ensures that the directory for
 // |path| exists, creating it if needed.
 static int WriteFileHelper(const base::FilePath& path,
                            std::unique_ptr<std::string> content) {
   base::FilePath dir = path.DirName();
-  return (base::CreateDirectoryAndGetError(dir, NULL) &&
-          base::WriteFile(path, content->data(), content->size()));
+  if (!base::CreateDirectoryAndGetError(dir, nullptr))
+    return -1;
+  return base::WriteFile(path, content->data(), content->size());
 }
 
 void ContentHashFetcherJob::OnURLFetchComplete(const net::URLFetcher* source) {
   VLOG(1) << "URLFetchComplete for " << extension_id_
           << " is_success:" << url_fetcher_->GetStatus().is_success() << " "
           << fetch_url_.possibly_invalid_spec();
   if (IsCancelled())
     return;
   std::unique_ptr<std::string> response(new std::string);
   if (!url_fetcher_->GetStatus().is_success() ||
@@ skipping 72 matching lines @@
   if (IsCancelled())
     return false;
   // Make sure the directory exists.
   if (!base::CreateDirectoryAndGetError(hashes_file.DirName(), NULL))
     return false;
 
   if (!verified_contents_.get()) {
     base::FilePath verified_contents_path =
         file_util::GetVerifiedContentsPath(extension_path_);
     verified_contents_.reset(new VerifiedContents(key_.data, key_.size));
-    if (!verified_contents_->InitFrom(verified_contents_path, false))
+    if (!verified_contents_->InitFrom(verified_contents_path, false)) {
+      verified_contents_.reset();
       return false;
-    verified_contents_.reset();
+    }
   }
 
   base::FileEnumerator enumerator(extension_path_,
                                   true, /* recursive */
                                   base::FileEnumerator::FILES);
   // First discover all the file paths and put them in a sorted set.
   SortedFilePathSet paths;
   for (;;) {
     if (IsCancelled())
       return false;
@@ skipping 48 matching lines @@
   {
     base::AutoLock autolock(cancelled_lock_);
     if (cancelled_)
       return;
   }
   callback_.Run(this);
 }
 
 // ----
 
-ContentHashFetcher::ContentHashFetcher(content::BrowserContext* context,
-                                       ContentVerifierDelegate* delegate,
-                                       const FetchCallback& callback)
-    : context_(context),
+ContentHashFetcher::ContentHashFetcher(
+    net::URLRequestContextGetter* context_getter,
+    ContentVerifierDelegate* delegate,
+    const FetchCallback& callback)
+    : context_getter_(context_getter),
       delegate_(delegate),
       fetch_callback_(callback),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 ContentHashFetcher::~ContentHashFetcher() {
   for (JobMap::iterator i = jobs_.begin(); i != jobs_.end(); ++i) {
     i->second->Cancel();
   }
 }
 
 void ContentHashFetcher::DoFetch(const Extension* extension, bool force) {
   DCHECK(extension);
 
@@ skipping 11 matching lines @@
   }
 
   // TODO(asargent) - we should do something here to remember recent attempts
   // to fetch signatures by extension id, and use exponential backoff to avoid
   // hammering the server when we aren't successful in getting them.
   // crbug.com/373397
 
   DCHECK(extension->version());
   GURL url =
       delegate_->GetSignatureFetchUrl(extension->id(), *extension->version());
-  ContentHashFetcherJob* job = new ContentHashFetcherJob(
-      content::BrowserContext::GetDefaultStoragePartition(context_)->
-          GetURLRequestContext(),
-      delegate_->GetPublicKey(), extension->id(),
-      extension->path(), url, force,
-      base::Bind(&ContentHashFetcher::JobFinished,
-                 weak_ptr_factory_.GetWeakPtr()));
+  ContentHashFetcherJob* job =
+      new ContentHashFetcherJob(context_getter_, delegate_->GetPublicKey(),
+                                extension->id(), extension->path(), url, force,
+                                base::Bind(&ContentHashFetcher::JobFinished,
+                                           weak_ptr_factory_.GetWeakPtr()));
   jobs_.insert(std::make_pair(key, job));
   job->Start();
 }
 
 void ContentHashFetcher::ExtensionLoaded(const Extension* extension) {
   CHECK(extension);
   DoFetch(extension, false);
 }
 
 void ContentHashFetcher::ExtensionUnloaded(const Extension* extension) {
@@ skipping 16 matching lines @@
 
   for (JobMap::iterator i = jobs_.begin(); i != jobs_.end(); ++i) {
     if (i->second.get() == job) {
       jobs_.erase(i);
       break;
     }
   }
 }
 
 }  // namespace extensions