Converted ResumeUploadOperation to use JSON in response instead of XML.

chrome/browser/google_apis/base_operations.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_operations.h"
 
 #include "base/json/json_reader.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/task_runner_util.h"
@@ skipping 12 matching lines @@
 
 // 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 operation.
 const int kMaxReAuthenticateAttemptsPerOperation = 1;
 
 // Parse JSON string to base::Value object.
-scoped_ptr<base::Value> ParseJsonOnBlockingPool(const std::string& data) {
+scoped_ptr<base::Value> ParseJsonOnBlockingPool(const std::string& json) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   int error_code = -1;
   std::string error_message;
   scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
-      data, base::JSON_PARSE_RFC, &error_code, &error_message));
+      json, base::JSON_PARSE_RFC, &error_code, &error_message));
 
   if (!value.get()) {
     LOG(ERROR) << "Error while parsing entry response: " << error_message
-               << ", code: " << error_code << ", data:\n" << data;
+               << ", code: " << error_code << ", json:\n" << 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;
 }
 
 }  // namespace
 
 namespace google_apis {
 
+void ParseJson(const std::string& json, const ParseJsonCallback& callback) {
+  base::PostTaskAndReplyWithResult(
+      BrowserThread::GetBlockingPool(),
+      FROM_HERE,
+      base::Bind(&ParseJsonOnBlockingPool, json),
+      callback);
+}
+
 //============================ UrlFetchOperationBase ===========================
 
 UrlFetchOperationBase::UrlFetchOperationBase(
     OperationRegistry* registry,
     net::URLRequestContextGetter* url_request_context_getter)
     : OperationRegistry::Operation(registry),
       url_request_context_getter_(url_request_context_getter),
       re_authenticate_count_(0),
       started_(false),
       save_temp_file_(false),
@@ skipping 200 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(!callback_.is_null());
 }
 
 GetDataOperation::~GetDataOperation() {}
 
 void GetDataOperation::ParseResponse(GDataErrorCode fetch_error_code,
                                      const std::string& data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  base::PostTaskAndReplyWithResult(
-      BrowserThread::GetBlockingPool(),
-      FROM_HERE,
-      base::Bind(&ParseJsonOnBlockingPool, data),
-      base::Bind(&GetDataOperation::OnDataParsed,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 fetch_error_code));
+  ParseJson(data,
+            base::Bind(&GetDataOperation::OnDataParsed,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       fetch_error_code));
 }
 
 void GetDataOperation::ProcessURLFetchResults(const URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
   scoped_ptr<base::Value> root_value;
   GDataErrorCode fetch_error_code = GetErrorCode(source);
 
   switch (fetch_error_code) {
     case HTTP_SUCCESS:
@@ skipping 30 matching lines @@
   OnProcessURLFetchResultsComplete(success);
 }
 
 void GetDataOperation::RunCallbackOnSuccess(GDataErrorCode fetch_error_code,
                                             scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   callback_.Run(fetch_error_code, value.Pass());
 }
 
 }  // namespace google_apis