WIP: Implement 5xx Error handling.

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"
@@ skipping 70 matching lines @@
 InitiateUploadParams::~InitiateUploadParams() {
 }
 
 ResumeUploadParams::ResumeUploadParams(
     UploadMode upload_mode,
     int64 start_position,
     int64 end_position,
     int64 content_length,
     const std::string& content_type,
     scoped_refptr<net::IOBuffer> buf,
+    int64 buffer_offset,
     const GURL& upload_location,
     const FilePath& drive_file_path) : upload_mode(upload_mode),
                                     start_position(start_position),
                                     end_position(end_position),
                                     content_length(content_length),
                                     content_type(content_type),
                                     buf(buf),
+                                    buffer_offset(buffer_offset),
                                     upload_location(upload_location),
                                     drive_file_path(drive_file_path) {
 }
 
 ResumeUploadParams::~ResumeUploadParams() {
 }
 
 //============================ GetResourceListOperation ========================
 
 GetResourceListOperation::GetResourceListOperation(
@@ skipping 555 matching lines @@
                           "http://schemas.google.com/docs/2007");
   xml_writer.WriteElement("title", params_.title);
   xml_writer.EndElement();  // Ends "entry" element.
   xml_writer.StopWriting();
   upload_content->assign(xml_writer.GetWrittenString());
   DVLOG(1) << "Upload data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
-//============================ ResumeUploadOperation ===========================
+namespace {
 
-ResumeUploadOperation::ResumeUploadOperation(
-    OperationRegistry* registry,
-    net::URLRequestContextGetter* url_request_context_getter,
+bool ProcessURLFetchResultsImpl(
+    GDataErrorCode code,
+    const URLFetcher* source,
+    const FilePath& drive_file_path,
     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),
-      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);
+    const ParseJsonCallback& json_callback) {
   net::HttpResponseHeaders* hdrs = source->GetResponseHeaders();
 
   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()
+    DVLOG(1) << "Got response for [" << 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>());
+    callback.Run(ResumeUploadResponse(code,
+                                      start_position_received,
+                                      end_position_received),
+                 scoped_ptr<ResourceEntry>());
+    return true;
+  }
 
-    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]";
+  // There might be explanation of unexpected error code in response.
+  std::string response_content;
+  source->GetResponseAsString(&response_content);
+  DVLOG(1) << "Got response for [" << drive_file_path.value()
+           << "]: code=" << code
+           << ", content=[\n" << response_content << "\n]";
 
-    ParseJson(response_content,
-              base::Bind(&ResumeUploadOperation::OnDataParsed,
-                         weak_ptr_factory_.GetWeakPtr(),
-                         code));
-  }
+  ParseJson(response_content, json_callback);
+  return false;
 }
 
-void ResumeUploadOperation::OnDataParsed(GDataErrorCode code,
-                                         scoped_ptr<base::Value> value) {
+bool OnDataParsedImpl(
+    UploadMode upload_mode,
+    const ResumeUploadCallback& callback,
+    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;
-  }
-
   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());
+  callback.Run(ResumeUploadResponse(code, -1, -1), entry.Pass());
+
+  // For a new file, HTTP_CREATED is returned.
+  // For an existing file, HTTP_SUCCESS is returned.
+  return (upload_mode == UPLOAD_NEW_FILE && code == HTTP_CREATED) ||
+      (upload_mode == UPLOAD_EXISTING_FILE && code == HTTP_SUCCESS);
+}
+
+}  // namespace
+
+//============================ ResumeUploadOperation ===========================
+
+ResumeUploadOperation::ResumeUploadOperation(
+    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),
+      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);
+  if (ProcessURLFetchResultsImpl(
+          code, source, params_.drive_file_path, callback_,
+          base::Bind(&ResumeUploadOperation::OnDataParsed,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     code))) {
+    OnProcessURLFetchResultsComplete(true);
+  }
+}
+
+void ResumeUploadOperation::OnDataParsed(GDataErrorCode code,
+                                         scoped_ptr<base::Value> value) {
+  last_chunk_completed_ = OnDataParsedImpl(
+      params_.upload_mode, callback_, code, value.Pass());
   OnProcessURLFetchResultsComplete(last_chunk_completed_);
 }
 
 void ResumeUploadOperation::NotifyStartToOperationRegistry() {
   NotifyResume();
 }
 
 void ResumeUploadOperation::NotifySuccessToOperationRegistry() {
   if (last_chunk_completed_)
     NotifyFinish(OPERATION_COMPLETED);
@@ skipping 34 matching lines @@
       base::Int64ToString(params_.start_position) + "-" +
       base::Int64ToString(params_.end_position - 1) + "/" +
       (params_.content_length == -1 ? "*" :
           base::Int64ToString(params_.content_length)));
   return headers;
 }
 
 bool ResumeUploadOperation::GetContentData(std::string* upload_content_type,
                                            std::string* upload_content) {
   *upload_content_type = params_.content_type;
-  *upload_content = std::string(params_.buf->data(),
+  *upload_content = std::string(params_.buf->data() + params_.buffer_offset,
                                 params_.end_position - params_.start_position);
   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);
 }
 
+//============================ GetUploadStateOperation =========================
+
+GetUploadStateOperation::GetUploadStateOperation(
+      OperationRegistry* registry,
+      net::URLRequestContextGetter* url_request_context_getter,
+      const ResumeUploadCallback& callback,
+      const UploadMode upload_mode,
+      const FilePath& drive_file_path,
+      const GURL& upload_url,
+      int64 content_length)
+    : UrlFetchOperationBase(registry, url_request_context_getter),
+      callback_(callback),
+      upload_mode_(upload_mode),
+      drive_file_path_(drive_file_path),
+      upload_url_(upload_url),
+      content_length_(content_length),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+}
+
+GetUploadStateOperation::~GetUploadStateOperation() {
+}
+
+GURL GetUploadStateOperation::GetURL() const {
+  return upload_url_;
+}
+
+net::URLFetcher::RequestType GetUploadStateOperation::GetRequestType() const {
+  return net::URLFetcher::PUT_WITHOUT_BODY;
+}
+
+void GetUploadStateOperation::ProcessURLFetchResults(
+    const net::URLFetcher* source) {
+  GDataErrorCode code = GetErrorCode(source);
+  if (ProcessURLFetchResultsImpl(
+          code, source, drive_file_path_, callback_,
+          base::Bind(&GetUploadStateOperation::OnDataParsed,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     code))) {
+    OnProcessURLFetchResultsComplete(true);
+  }
+}
+
+void GetUploadStateOperation::RunCallbackOnPrematureFailure(
+    GDataErrorCode code) {
+  callback_.Run(ResumeUploadResponse(code, 0, 0), scoped_ptr<ResourceEntry>());
+}
+
+std::vector<std::string>
+GetUploadStateOperation::GetExtraRequestHeaders() const {
+  // The header looks like
+  // Content-Range: bytes */<content_length>
+  // for example:
+  // Content-Range: bytes */13851821
+  // Use * for unknown/streaming content length.
+  // The header takes inclusive range, so we adjust by "end_position - 1".
+  DCHECK_GE(content_length_, -1);
+
+  std::vector<std::string> headers;
+  headers.push_back(
+      std::string(kUploadContentRange) + "*/" +
+      (content_length_ == -1 ? "*" : base::Int64ToString(content_length_)));
+  return headers;
+}
+
+void GetUploadStateOperation::OnDataParsed(
+    GDataErrorCode code, scoped_ptr<base::Value> value) {
+  OnProcessURLFetchResultsComplete(
+      OnDataParsedImpl(
+          upload_mode_, callback_, code, value.Pass()));
+}
+
 }  // namespace google_apis