Converted ResumeUploadOperation to use JSON in response instead of XML.

chrome/browser/google_apis/gdata_wapi_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/gdata_wapi_operations.h"
 
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_url_generator.h"
 #include "chrome/browser/google_apis/time_util.h"
 #include "chrome/common/net/url_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
+using content::BrowserThread;
 using net::URLFetcher;
 
 namespace {
 
 // etag matching header.
 const char kIfMatchAllHeader[] = "If-Match: *";
 const char kIfMatchHeaderFormat[] = "If-Match: %s";
 
 const char kUploadContentRange[] = "Content-Range: bytes ";
 const char kUploadContentType[] = "X-Upload-Content-Type: ";
@@ skipping 538 matching lines @@
       initiate_upload_url_(chrome_common_net::AppendOrReplaceQueryParameter(
           params.upload_location,
           kUploadParamConvertKey,
           kUploadParamConvertValue)) {
   DCHECK(!callback_.is_null());
 }
 
 InitiateUploadOperation::~InitiateUploadOperation() {}
 
 GURL InitiateUploadOperation::GetURL() const {
-  return initiate_upload_url_;
+  return GDataWapiUrlGenerator::AddStandardUrlParams(initiate_upload_url_);
 }
 
 void InitiateUploadOperation::ProcessURLFetchResults(
     const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
 
   std::string upload_location;
   if (code == HTTP_SUCCESS) {
     // Retrieve value of the first "Location" header.
     source->GetResponseHeaders()->EnumerateHeader(NULL,
@@ skipping 75 matching lines @@
     OperationRegistry* registry,
     net::URLRequestContextGetter* url_request_context_getter,
     const ResumeUploadCallback& callback,
     const ResumeUploadParams& params)
   : UrlFetchOperationBase(registry,
                           url_request_context_getter,
                           OPERATION_UPLOAD,
                           params.drive_file_path),
       callback_(callback),
       params_(params),
-      last_chunk_completed_(false) {
+      last_chunk_completed_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(!callback_.is_null());
 }
 
 ResumeUploadOperation::~ResumeUploadOperation() {}
 
 GURL ResumeUploadOperation::GetURL() const {
+  // This is very tricky to get json from this operation. To do that, &alt=json
+  // has to be appended not here but in InitiateUploadOperation::GetURL().
   return params_.upload_location;
 }
 
 void ResumeUploadOperation::ProcessURLFetchResults(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   net::HttpResponseHeaders* hdrs = source->GetResponseHeaders();
-  int64 start_position_received = -1;
-  int64 end_position_received = -1;
-  scoped_ptr<ResourceEntry> entry;
 
   if (code == HTTP_RESUME_INCOMPLETE) {
     // Retrieve value of the first "Range" header.
+    int64 start_position_received = -1;
+    int64 end_position_received = -1;
     std::string range_received;
     hdrs->EnumerateHeader(NULL, kUploadResponseRange, &range_received);
     if (!range_received.empty()) {  // Parse the range header.
       std::vector<net::HttpByteRange> ranges;
       if (net::HttpUtil::ParseRangeHeader(range_received, &ranges) &&
           !ranges.empty() ) {
         // We only care about the first start-end pair in the range.
         //
         // Range header represents the range inclusively, while we are treating
         // ranges exclusively (i.e., end_position_received should be one passed
         // the last valid index). So "+ 1" is added.
         start_position_received = ranges[0].first_byte_position();
         end_position_received = ranges[0].last_byte_position() + 1;
       }
     }
     DVLOG(1) << "Got response for [" << params_.drive_file_path.value()
              << "]: code=" << code
              << ", range_hdr=[" << range_received
              << "], range_parsed=" << start_position_received
              << "," << end_position_received;
+
+    callback_.Run(ResumeUploadResponse(code,
+                                       start_position_received,
+                                       end_position_received),
+                  scoped_ptr<ResourceEntry>());
+
+    OnProcessURLFetchResultsComplete(true);
   } else {
     // There might be explanation of unexpected error code in response.
     std::string response_content;
     source->GetResponseAsString(&response_content);
     DVLOG(1) << "Got response for [" << params_.drive_file_path.value()
              << "]: code=" << code
              << ", content=[\n" << response_content << "\n]";
 
-    // Parse entry XML.
-    XmlReader xml_reader;
-    if (xml_reader.Load(response_content)) {
-      while (xml_reader.Read()) {
-        if (xml_reader.NodeName() == ResourceEntry::GetEntryNodeName()) {
-          entry = ResourceEntry::CreateFromXml(&xml_reader);
-          break;
-        }
-      }
-    }
-    if (!entry.get())
-      LOG(WARNING) << "Invalid entry received on upload:\n" << response_content;
+    ParseJson(response_content,
+              base::Bind(&ResumeUploadOperation::OnDataParsed,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         code));
   }
+}
 
-  callback_.Run(ResumeUploadResponse(code,
-                                     start_position_received,
-                                     end_position_received),
-                entry.Pass());
+void ResumeUploadOperation::OnDataParsed(GDataErrorCode code,
+                                         scoped_ptr<base::Value> value) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // For a new file, HTTP_CREATED is returned.
   // For an existing file, HTTP_SUCCESS is returned.
   if ((params_.upload_mode == UPLOAD_NEW_FILE && code == HTTP_CREATED) ||
       (params_.upload_mode == UPLOAD_EXISTING_FILE && code == HTTP_SUCCESS)) {
     last_chunk_completed_ = true;
   }
 
-  OnProcessURLFetchResultsComplete(
-      last_chunk_completed_ || code == HTTP_RESUME_INCOMPLETE);
+  scoped_ptr<ResourceEntry> entry;
+  if (value.get())
+    entry = ResourceEntry::ExtractAndParse(*(value.get()));
+
+  if (!entry.get())
+    LOG(WARNING) << "Invalid entry received on upload.";
+
+  callback_.Run(ResumeUploadResponse(code, -1, -1), entry.Pass());
+  OnProcessURLFetchResultsComplete(last_chunk_completed_);
 }
 
 void ResumeUploadOperation::NotifyStartToOperationRegistry() {
   NotifyResume();
 }
 
 void ResumeUploadOperation::NotifySuccessToOperationRegistry() {
   if (last_chunk_completed_)
     NotifyFinish(OPERATION_COMPLETED);
   else
@@ skipping 45 matching lines @@
   return true;
 }
 
 void ResumeUploadOperation::OnURLFetchUploadProgress(
     const URLFetcher* source, int64 current, int64 total) {
   // Adjust the progress values according to the range currently uploaded.
   NotifyProgress(params_.start_position + current, params_.content_length);
 }
 
 }  // namespace google_apis