Parse Drive API responses all at once in the blocking pool.

google_apis/drive/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 "google_apis/drive/base_requests.h"
 
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 25 matching lines @@
 
 // Template for initiate upload of both GData WAPI and Drive API v2.
 const char kUploadContentType[] = "X-Upload-Content-Type: ";
 const char kUploadContentLength[] = "X-Upload-Content-Length: ";
 const char kUploadResponseLocation[] = "location";
 
 // Template for upload data range of both GData WAPI and Drive API v2.
 const char kUploadContentRange[] = "Content-Range: bytes ";
 const char kUploadResponseRange[] = "range";
 
-// Parse JSON string to base::Value object.
-scoped_ptr<base::Value> ParseJsonInternal(const std::string& json) {
-  int error_code = -1;
-  std::string error_message;
-  scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
-      json, base::JSON_PARSE_RFC, &error_code, &error_message));
-
-  if (!value.get()) {
-    std::string trimmed_json;
-    if (json.size() < 80) {
-      trimmed_json  = json;
-    } else {
-      // Take the first 50 and the last 10 bytes.
-      trimmed_json = base::StringPrintf(
-          "%s [%s bytes] %s",
-          json.substr(0, 50).c_str(),
-          base::Uint64ToString(json.size() - 60).c_str(),
-          json.substr(json.size() - 10).c_str());
-    }
-    LOG(WARNING) << "Error while parsing entry response: " << error_message
-                 << ", code: " << error_code << ", json:\n" << trimmed_json;
-  }
-  return value.Pass();
+// Parses JSON passed in |json| on |blocking_task_runner|. Runs |callback| on
+// the calling thread when finished with either success or failure.
+// The callback must not be null.
+void ParseJsonOnBlockingPool(
+    base::TaskRunner* blocking_task_runner,
+    const std::string& json,
+    const base::Callback<void(scoped_ptr<base::Value> value)>& callback) {
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner,
+      FROM_HERE,
+      base::Bind(&google_apis::ParseJson, json),
+      callback);
 }
 
 // Returns response headers as a string. Returns a warning message if
 // |url_fetcher| does not contain a valid response. Used only for debugging.
 std::string GetResponseHeadersAsString(
     const URLFetcher* url_fetcher) {
   // net::HttpResponseHeaders::raw_headers(), as the name implies, stores
   // all headers in their raw format, i.e each header is null-terminated.
   // So logging raw_headers() only shows the first header, which is probably
   // the status line.  GetNormalizedHeaders, on the other hand, will show all
@@ skipping 10 matching lines @@
 }
 
 bool IsSuccessfulResponseCode(int response_code) {
   return 200 <= response_code && response_code <= 299;
 }
 
 }  // namespace
 
 namespace google_apis {
 
-void ParseJson(base::TaskRunner* blocking_task_runner,
-               const std::string& json,
-               const ParseJsonCallback& callback) {
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner,
-      FROM_HERE,
-      base::Bind(&ParseJsonInternal, json),
-      callback);
+scoped_ptr<base::Value> ParseJson(const std::string& json) {
+  int error_code = -1;
+  std::string error_message;
+  scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
+      json, base::JSON_PARSE_RFC, &error_code, &error_message));
+
+  if (!value.get()) {
+    std::string trimmed_json;
+    if (json.size() < 80) {
+      trimmed_json  = json;
+    } else {
+      // Take the first 50 and the last 10 bytes.
+      trimmed_json = base::StringPrintf(
+          "%s [%s bytes] %s",
+          json.substr(0, 50).c_str(),
+          base::Uint64ToString(json.size() - 60).c_str(),
+          json.substr(json.size() - 10).c_str());
+    }
+    LOG(WARNING) << "Error while parsing entry response: " << error_message
+                 << ", code: " << error_code << ", json:\n" << trimmed_json;
+  }
+  return value.Pass();
 }
 
 //=========================== ResponseWriter ==================================
 ResponseWriter::ResponseWriter(base::SequencedTaskRunner* file_task_runner,
                                const base::FilePath& file_path,
                                const GetContentCallback& get_content_callback)
     : get_content_callback_(get_content_callback),
       weak_ptr_factory_(this) {
   if (!file_path.empty()) {
     file_writer_.reset(
@@ skipping 236 matching lines @@
     DVLOG(1) << response_writer_->data();
 
     const char kErrorKey[] = "error";
     const char kErrorErrorsKey[] = "errors";
     const char kErrorReasonKey[] = "reason";
     const char kErrorMessageKey[] = "message";
     const char kErrorReasonRateLimitExceeded[] = "rateLimitExceeded";
     const char kErrorReasonUserRateLimitExceeded[] = "userRateLimitExceeded";
     const char kErrorReasonQuotaExceeded[] = "quotaExceeded";
 
-    scoped_ptr<base::Value> value(ParseJsonInternal(response_writer_->data()));
+    scoped_ptr<base::Value> value(ParseJson(response_writer_->data()));
     base::DictionaryValue* dictionary = NULL;
     base::DictionaryValue* error = NULL;
     if (value &&
         value->GetAsDictionary(&dictionary) &&
         dictionary->GetDictionaryWithoutPathExpansion(kErrorKey, &error)) {
       // Get error message.
       std::string message;
       error->GetStringWithoutPathExpansion(kErrorMessageKey, &message);
       DLOG(ERROR) << "code: " << error_code_ << ", message: " << message;
 
@@ skipping 72 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(blocking_task_runner(),
-            data,
-            base::Bind(&GetDataRequest::OnDataParsed,
-                       weak_ptr_factory_.GetWeakPtr(),
-                       fetch_error_code));
+  ParseJsonOnBlockingPool(blocking_task_runner(),
+                          data,
+                          base::Bind(&GetDataRequest::OnDataParsed,
+                                     weak_ptr_factory_.GetWeakPtr(),
+                                     fetch_error_code));
 }
 
 void GetDataRequest::ProcessURLFetchResults(const URLFetcher* source) {
   GDataErrorCode fetch_error_code = GetErrorCode();
 
   switch (fetch_error_code) {
     case HTTP_SUCCESS:
     case HTTP_CREATED:
       ParseResponse(fetch_error_code, response_writer()->data());
       break;
@@ skipping 141 matching lines @@
 
     OnRangeRequestComplete(UploadRangeResponse(code,
                                                start_position_received,
                                                end_position_received),
                            scoped_ptr<base::Value>());
 
     OnProcessURLFetchResultsComplete();
   } else if (code == HTTP_CREATED || code == HTTP_SUCCESS) {
     // The upload is successfully done. Parse the response which should be
     // the entry's metadata.
-    ParseJson(blocking_task_runner(),
-              response_writer()->data(),
-              base::Bind(&UploadRangeRequestBase::OnDataParsed,
-                         weak_ptr_factory_.GetWeakPtr(),
-                         code));
+    ParseJsonOnBlockingPool(blocking_task_runner(),
+                            response_writer()->data(),
+                            base::Bind(&UploadRangeRequestBase::OnDataParsed,
+                                       weak_ptr_factory_.GetWeakPtr(),
+                                       code));
   } else {
     // Failed to upload. Run callbacks to notify the error.
     OnRangeRequestComplete(
         UploadRangeResponse(code, -1, -1), scoped_ptr<base::Value>());
     OnProcessURLFetchResultsComplete();
   }
 }
 
 void UploadRangeRequestBase::OnDataParsed(GDataErrorCode code,
                                           scoped_ptr<base::Value> value) {
@@ skipping 156 matching lines @@
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis