Remove direct reference to GetBlockingPool() in c/b/google_apis.

chrome/browser/google_apis/base_requests.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/google_apis/base_requests.h"
 
 #include "base/json/json_reader.h"
+#include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
-#include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/request_sender.h"
-#include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 
-using content::BrowserThread;
 using net::URLFetcher;
 
 namespace {
 
 // Template for optional OAuth2 authorization HTTP header.
 const char kAuthorizationHeaderFormat[] = "Authorization: Bearer %s";
 // Template for GData API version HTTP header.
 const char kGDataVersionHeader[] = "GData-Version: 3.0";
 
 // Maximum number of attempts for re-authentication per request.
@@ skipping 39 matching lines @@
   } else {
     url_fetcher->GetResponseHeaders()->GetNormalizedHeaders(&headers);
   }
   return headers;
 }
 
 }  // namespace
 
 namespace google_apis {
 
-void ParseJson(const std::string& json, const ParseJsonCallback& callback) {
+void ParseJson(base::TaskRunner* blocking_task_runner,
+               const std::string& json,
+               const ParseJsonCallback& callback) {
   base::PostTaskAndReplyWithResult(
-      BrowserThread::GetBlockingPool(),
+      blocking_task_runner,
       FROM_HERE,
       base::Bind(&ParseJsonOnBlockingPool, json),
       callback);
 }
 
 //============================ UrlFetchRequestBase ===========================
 
 UrlFetchRequestBase::UrlFetchRequestBase(RequestSender* sender)
     : re_authenticate_count_(0),
       sender_(sender),
@@ skipping 28 matching lines @@
   url_fetcher_->SetRequestContext(sender_->url_request_context_getter());
   // Always set flags to neither send nor save cookies.
   url_fetcher_->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES |
       net::LOAD_DISABLE_CACHE);
 
   base::FilePath output_file_path;
   if (GetOutputFilePath(&output_file_path)) {
     url_fetcher_->SaveResponseToFileAtPath(
         output_file_path,
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
+        blocking_task_runner());
   }
 
   // Add request headers.
   // Note that SetExtraRequestHeaders clears the current headers and sets it
   // to the passed-in headers, so calling it for each header will result in
   // only the last header being set in request headers.
   if (!custom_user_agent.empty())
     url_fetcher_->AddExtraRequestHeader("User-Agent: " + custom_user_agent);
   url_fetcher_->AddExtraRequestHeader(kGDataVersionHeader);
   url_fetcher_->AddExtraRequestHeader(
@@ skipping 13 matching lines @@
     base::FilePath local_file_path;
     int64 range_offset = 0;
     int64 range_length = 0;
     if (GetContentFile(&local_file_path, &range_offset, &range_length,
                        &upload_content_type)) {
       url_fetcher_->SetUploadFilePath(
           upload_content_type,
           local_file_path,
           range_offset,
           range_length,
-          BrowserThread::GetBlockingPool());
+          blocking_task_runner());
     } else {
       // Even if there is no content data, UrlFetcher requires to set empty
       // upload data string for POST, PUT and PATCH methods, explicitly.
       // It is because that most requests of those methods have non-empty
       // body, and UrlFetcher checks whether it is actually not forgotten.
       if (request_type == URLFetcher::POST ||
           request_type == URLFetcher::PUT ||
           request_type == URLFetcher::PATCH) {
         // Set empty upload content-type and upload content, so that
         // the request will have no "Content-type: " header and no content.
@@ skipping 47 matching lines @@
         code = GDATA_OTHER_ERROR;
     }
   }
   return code;
 }
 
 bool UrlFetchRequestBase::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
+base::TaskRunner* UrlFetchRequestBase::blocking_task_runner() const {
+  return sender_->blocking_task_runner();
+}
+
 void UrlFetchRequestBase::OnProcessURLFetchResultsComplete(bool result) {
   sender_->RequestFinished(this);
 }
 
 void UrlFetchRequestBase::OnURLFetchComplete(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   DVLOG(1) << "Response headers:\n" << GetResponseHeadersAsString(source);
 
   if (code == HTTP_UNAUTHORIZED) {
     if (++re_authenticate_count_ <= kMaxReAuthenticateAttemptsPerRequest) {
@@ skipping 55 matching lines @@
 }
 
 GetDataRequest::~GetDataRequest() {}
 
 void GetDataRequest::ParseResponse(GDataErrorCode fetch_error_code,
                                    const std::string& data) {
   DCHECK(CalledOnValidThread());
 
   VLOG(1) << "JSON received from " << GetURL().spec() << ": "
           << data.size() << " bytes";
-  ParseJson(data,
+  ParseJson(blocking_task_runner(),
+            data,
             base::Bind(&GetDataRequest::OnDataParsed,
                        weak_ptr_factory_.GetWeakPtr(),
                        fetch_error_code));
 }
 
 void GetDataRequest::ProcessURLFetchResults(const URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
   scoped_ptr<base::Value> root_value;
   GDataErrorCode fetch_error_code = GetErrorCode(source);
@@ skipping 161 matching lines @@
                                                start_position_received,
                                                end_position_received),
                            scoped_ptr<base::Value>());
 
     OnProcessURLFetchResultsComplete(true);
   } else {
     // There might be explanation of unexpected error code in response.
     std::string response_content;
     source->GetResponseAsString(&response_content);
 
-    ParseJson(response_content,
+    ParseJson(blocking_task_runner(),
+              response_content,
               base::Bind(&UploadRangeRequestBase::OnDataParsed,
                          weak_ptr_factory_.GetWeakPtr(),
                          code));
   }
 }
 
 void UploadRangeRequestBase::OnDataParsed(GDataErrorCode code,
                                           scoped_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 165 matching lines @@
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis