Revert 288017 "Parse Drive API responses all at once in the bloc..."

trunk/src/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";
 
-// 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);
+// 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();
 }
 
 // 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
   // the headers, one per line, which is probably what we want.
   std::string headers;
   // Check that response code indicates response headers are valid (i.e. not
   // malformed) before we retrieve the headers.
   if (url_fetcher->GetResponseCode() == URLFetcher::RESPONSE_CODE_INVALID) {
     headers.assign("Response headers are malformed!!");
   } else {
     url_fetcher->GetResponseHeaders()->GetNormalizedHeaders(&headers);
   }
   return headers;
 }
 
 bool IsSuccessfulResponseCode(int response_code) {
   return 200 <= response_code && response_code <= 299;
 }
 
 }  // namespace
 
 namespace google_apis {
 
-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();
+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);
 }
 
 //=========================== 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(ParseJson(response_writer_->data()));
+    scoped_ptr<base::Value> value(ParseJsonInternal(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 54 matching lines @@
 
 void EntryActionRequest::ProcessURLFetchResults(const URLFetcher* source) {
   callback_.Run(GetErrorCode());
   OnProcessURLFetchResultsComplete();
 }
 
 void EntryActionRequest::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   callback_.Run(code);
 }
 
+//============================== GetDataRequest ==============================
+
+GetDataRequest::GetDataRequest(RequestSender* sender,
+                               const GetDataCallback& callback)
+    : UrlFetchRequestBase(sender),
+      callback_(callback),
+      weak_ptr_factory_(this) {
+  DCHECK(!callback_.is_null());
+}
+
+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));
+}
+
+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;
+    default:
+      RunCallbackOnPrematureFailure(fetch_error_code);
+      OnProcessURLFetchResultsComplete();
+      break;
+  }
+}
+
+void GetDataRequest::RunCallbackOnPrematureFailure(
+    GDataErrorCode fetch_error_code) {
+  callback_.Run(fetch_error_code, scoped_ptr<base::Value>());
+}
+
+void GetDataRequest::OnDataParsed(GDataErrorCode fetch_error_code,
+                                  scoped_ptr<base::Value> value) {
+  DCHECK(CalledOnValidThread());
+
+  if (!value.get())
+    fetch_error_code = GDATA_PARSE_ERROR;
+
+  callback_.Run(fetch_error_code, value.Pass());
+  OnProcessURLFetchResultsComplete();
+}
+
 //========================= InitiateUploadRequestBase ========================
 
 InitiateUploadRequestBase::InitiateUploadRequestBase(
     RequestSender* sender,
     const InitiateUploadCallback& callback,
     const std::string& content_type,
     int64 content_length)
     : UrlFetchRequestBase(sender),
       callback_(callback),
       content_type_(content_type),
@@ skipping 108 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.
-    ParseJsonOnBlockingPool(blocking_task_runner(),
-                            response_writer()->data(),
-                            base::Bind(&UploadRangeRequestBase::OnDataParsed,
-                                       weak_ptr_factory_.GetWeakPtr(),
-                                       code));
+    ParseJson(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