Fix two ContentHashFetcherTest.* tests' flakiness.

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>
@@ skipping 123 matching lines @@
 
   // The url we'll need to use to fetch a verified_contents.json file.
   GURL fetch_url_;
 
   bool force_;
 
   CompletionCallback callback_;
   content::BrowserThread::ID creation_thread_;
 
   // Used for fetching content signatures.
+  // Created and destroyed on |creation_thread_|.
   std::unique_ptr<net::URLFetcher> url_fetcher_;
 
   // The key used to validate verified_contents.json.
   ContentVerifierKey key_;
 
   // The parsed contents of the verified_contents.json file, either read from
   // disk or fetched from the network and then written to disk.
   std::unique_ptr<VerifiedContents> verified_contents_;
 
   // Whether this job succeeded.
@@ skipping 57 matching lines @@
   cancelled_ = true;
 }
 
 bool ContentHashFetcherJob::IsCancelled() {
   base::AutoLock autolock(cancelled_lock_);
   bool result = cancelled_;
   return result;
 }
 
 ContentHashFetcherJob::~ContentHashFetcherJob() {
+  // Destroy |url_fetcher_| on correct thread.
+  // It was possible for it to be deleted on blocking pool from
+  // MaybeCreateHashes(). See https://crbug.com/702300 for details.
+  if (url_fetcher_ && !content::BrowserThread::CurrentlyOn(creation_thread_)) {
+    content::BrowserThread::DeleteSoon(creation_thread_, FROM_HERE,
+                                       url_fetcher_.release());
+  }
 }
 
 bool ContentHashFetcherJob::LoadVerifiedContents(const base::FilePath& path) {
   if (!base::PathExists(path))
     return false;
   verified_contents_.reset(new VerifiedContents(key_.data, key_.size));
   if (!verified_contents_->InitFrom(path)) {
     verified_contents_.reset();
     if (!base::DeleteFile(path, false))
       LOG(WARNING) << "Failed to delete " << path.value();
@@ skipping 54 matching lines @@
   base::FilePath dir = path.DirName();
   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();
+  // Delete |url_fetcher_| once we no longer need it.

[lazyboy, 2017/04/19 00:19:33]

As we discussed on vc, this is the deletion. However, I realized this isn't
enough, because ContentHashFetcherJob can be Cancel()ed from any thread.
Therefore I've also added
DeleteSoon to cover all the cases. This change isn't a requirement anymore, but
I thought
it would be good to do.

I've also thought of making ContentHashFetcherJob DeleteOnUI at first, but that
wouldn't
always work because we create ContentHashFetcherJob on dynamic creation_thread_,
which can or cannot be UI I think.

+  std::unique_ptr<net::URLFetcher> url_fetcher = std::move(url_fetcher_);
+
   if (IsCancelled())
     return;
   std::unique_ptr<std::string> response(new std::string);
-  if (!url_fetcher_->GetStatus().is_success() ||
-      !url_fetcher_->GetResponseAsString(response.get())) {
+  if (!url_fetcher->GetStatus().is_success() ||
+      !url_fetcher->GetResponseAsString(response.get())) {
     DoneFetchingVerifiedContents(false);
     return;
   }
 
   // Parse the response to make sure it is valid json (on staging sometimes it
   // can be a login redirect html, xml file, etc. if you aren't logged in with
   // the right cookies).  TODO(asargent) - It would be a nice enhancement to
   // move to parsing this in a sandboxed helper (crbug.com/372878).
   std::unique_ptr<base::Value> parsed(base::JSONReader::Read(*response));
   if (parsed) {
@@ skipping 218 matching lines @@
 
   for (JobMap::iterator i = jobs_.begin(); i != jobs_.end(); ++i) {
     if (i->second.get() == job.get()) {
       jobs_.erase(i);
       break;
     }
   }
 }
 
 }  // namespace extensions