Drive: Add response handling to BatchUploadRequst class.

google_apis/drive/drive_api_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/drive_api_requests.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "google_apis/drive/request_sender.h"
 #include "google_apis/drive/request_util.h"
 #include "google_apis/drive/time_util.h"
 #include "net/base/url_util.h"
+#include "net/http/http_response_headers.h"
 
 namespace google_apis {
 namespace drive {
 namespace {
 
 // Format of one request in batch uploading request.
 const char kBatchUploadRequestFormat[] =
     "%s %s HTTP/1.1\n"
     "Host: %s\n"
     "X-Goog-Upload-Protocol: multipart\n"
     "Content-Type: %s\n"
     "\n"
     "%s";
 
 // Request header for specifying batch upload.
 const char kBatchUploadHeader[] = "X-Goog-Upload-Protocol: batch";
 
 // Content type of HTTP request.
 const char kHttpContentType[] = "application/http";
 
+// Break line in HTTP message.
+const char kHttpBr[] = "\r\n";
+
+// Mime type of multipart mixed.
+const char kMultipartMixedMimeTypePrefix[] = "multipart/mixed; boundary=";
+
 // Parses the JSON value to FileResource instance and runs |callback| on the
 // UI thread once parsing is done.
 // This is customized version of ParseJsonAndRun defined above to adapt the
 // remaining response type.
 void ParseFileResourceWithUploadRangeAndRun(const UploadRangeCallback& callback,
                                             const UploadRangeResponse& response,
                                             scoped_ptr<base::Value> value) {
   DCHECK(!callback.is_null());
 
   scoped_ptr<FileResource> file_resource;
@@ skipping 70 matching lines @@
     root.SetString("lastViewedByMeDate", google_apis::util::FormatTimeAsString(
                                              last_viewed_by_me_date));
   }
 
   AttachProperties(properties, &root);
   std::string json_string;
   base::JSONWriter::Write(&root, &json_string);
   return json_string;
 }
 
+// Splits |string| into lines by |kHttpBr|.
+// Each line does not include |kHttpBr|.
+void SplitIntoLines(const std::string& string,
+                    std::vector<base::StringPiece>* output) {
+  const size_t br_size = std::string(kHttpBr).size();
+  std::string::const_iterator it = string.begin();
+  std::vector<base::StringPiece> lines;
+  while (true) {
+    const std::string::const_iterator next_pos =
+        std::search(it, string.end(), kHttpBr, kHttpBr + br_size);
+    lines.push_back(base::StringPiece(it, next_pos));
+    if (next_pos == string.end())
+      break;
+    it = next_pos + br_size;
+  }
+  output->swap(lines);
+}
+
+// Remove transport padding (spaces and tabs at the end of line) from |piece|.
+base::StringPiece TrimTransportPadding(const base::StringPiece& piece) {
+  size_t trim_size = 0;
+  while (trim_size < piece.size() &&
+         (piece[piece.size() - 1 - trim_size] == ' ' ||
+          piece[piece.size() - 1 - trim_size] == '\t')) {
+    ++trim_size;
+  }
+  return piece.substr(0, piece.size() - trim_size);
+}
+
 }  // namespace
 
+MultipartHttpResponse::MultipartHttpResponse() : code(HTTP_SUCCESS) {
+}
+
+MultipartHttpResponse::~MultipartHttpResponse() {
+}
+
+// The |response| must be multipart/mixed format that contains child HTTP
+// response of drive batch request.
+// https://www.ietf.org/rfc/rfc2046.txt
+//
+// It looks like:
+// --Boundary
+// Content-type: application/http
+//
+// HTTP/1.1 200 OK
+// Header of child response
+//
+// Body of child response
+// --Boundary
+// Content-type: application/http
+//
+// HTTP/1.1 404 Not Found
+// Header of child response
+//
+// Body of child response
+// --Boundary--
+bool ParseMultipartResponse(const std::string& content_type,
+                            const std::string& response,
+                            std::vector<MultipartHttpResponse>* parts) {
+  if (response.empty())
+    return false;
+
+  base::StringPiece content_type_piece(content_type);
+  if (!content_type_piece.starts_with(kMultipartMixedMimeTypePrefix)) {
+    return false;
+  }
+  content_type_piece.remove_prefix(
+      base::StringPiece(kMultipartMixedMimeTypePrefix).size());
+
+  if (content_type_piece.empty())
+    return false;
+  if (content_type_piece[0] == '"') {
+    if (content_type_piece.size() <= 2 ||
+        content_type_piece[content_type_piece.size() - 1] != '"') {
+      return false;
+    }
+    content_type_piece =
+        content_type_piece.substr(1, content_type_piece.size() - 2);
+  }
+
+  std::string boundary;
+  content_type_piece.CopyToString(&boundary);
+  const std::string header = "--" + boundary;
+  const std::string terminator = "--" + boundary + "--";
+
+  std::vector<base::StringPiece> lines;
+  SplitIntoLines(response, &lines);
+
+  enum {
+    STATE_START,
+    STATE_PART_HEADER,
+    STATE_PART_HTTP_STATUS_LINE,
+    STATE_PART_HTTP_HEADER,
+    STATE_PART_HTTP_BODY
+  } state = STATE_START;
+
+  const std::string kHttpStatusPrefix = "HTTP/1.1 ";
+  std::vector<MultipartHttpResponse> responses;
+  DriveApiErrorCode code = DRIVE_PARSE_ERROR;
+  std::string body;
+  for (const auto& line : lines) {
+    if (state == STATE_PART_HEADER && line.empty()) {
+      state = STATE_PART_HTTP_STATUS_LINE;
+      continue;
+    }
+
+    if (state == STATE_PART_HTTP_STATUS_LINE) {
+      if (line.starts_with(kHttpStatusPrefix)) {
+        int int_code;
+        base::StringToInt(
+            line.substr(base::StringPiece(kHttpStatusPrefix).size()),
+            &int_code);
+        if (int_code > 0)
+          code = static_cast<DriveApiErrorCode>(int_code);
+        else
+          code = DRIVE_PARSE_ERROR;
+      } else {
+        code = DRIVE_PARSE_ERROR;
+      }
+      state = STATE_PART_HTTP_HEADER;
+      continue;
+    }
+
+    if (state == STATE_PART_HTTP_HEADER && line.empty()) {
+      state = STATE_PART_HTTP_BODY;
+      body.clear();
+      continue;
+    }
+    const base::StringPiece chopped_line = TrimTransportPadding(line);
+    const bool is_new_part = chopped_line == header;
+    const bool was_last_part = chopped_line == terminator;
+    if (is_new_part || was_last_part) {
+      switch (state) {
+        case STATE_START:
+          break;
+        case STATE_PART_HEADER:
+        case STATE_PART_HTTP_STATUS_LINE:
+          responses.push_back(MultipartHttpResponse());
+          responses.back().code = DRIVE_PARSE_ERROR;
+          break;
+        case STATE_PART_HTTP_HEADER:
+          responses.push_back(MultipartHttpResponse());
+          responses.back().code = code;
+          break;
+        case STATE_PART_HTTP_BODY:
+          // Drop the last kHttpBr.
+          if (!body.empty())
+            body.resize(body.size() - 2);
+          responses.push_back(MultipartHttpResponse());
+          responses.back().code = code;
+          responses.back().body.swap(body);
+          break;
+      }
+      if (is_new_part)
+        state = STATE_PART_HEADER;
+      if (was_last_part)
+        break;
+    } else if (state == STATE_PART_HTTP_BODY) {
+      line.AppendToString(&body);
+      body.append(kHttpBr);
+    }
+  }
+
+  parts->swap(responses);
+  return true;
+}
+
 Property::Property() : visibility_(VISIBILITY_PRIVATE) {
 }
 
 Property::~Property() {
 }
 
 //============================ DriveApiPartialFieldRequest ====================
 
 DriveApiPartialFieldRequest::DriveApiPartialFieldRequest(
     RequestSender* sender) : UrlFetchRequestBase(sender) {
@@ skipping 866 matching lines @@
 void BatchUploadRequest::SetBoundaryForTesting(const std::string& boundary) {
   boundary_ = boundary;
 }
 
 void BatchUploadRequest::AddRequest(BatchableRequestBase* request) {
   DCHECK(CalledOnValidThread());
   DCHECK(request);
   DCHECK(GetChildEntry(request) == child_requests_.end());
   DCHECK(!committed_);
   child_requests_.push_back(BatchUploadChildEntry(request));
-  request->Prepare(
-      base::Bind(&BatchUploadRequest::OnChildRequestPrepared,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 request));
+  request->Prepare(base::Bind(&BatchUploadRequest::OnChildRequestPrepared,
+                              weak_ptr_factory_.GetWeakPtr(), request));
 }
 
-void BatchUploadRequest::OnChildRequestPrepared(
-    RequestID request_id, DriveApiErrorCode result) {
+void BatchUploadRequest::OnChildRequestPrepared(RequestID request_id,
+                                                DriveApiErrorCode result) {
   DCHECK(CalledOnValidThread());
   auto const child = GetChildEntry(request_id);
   DCHECK(child != child_requests_.end());
   if (IsSuccessfulDriveApiErrorCode(result)) {
     child->prepared = true;
   } else {
     child->request->RunCallbackOnPrematureFailure(result);
     sender_->RequestFinished(child->request);
     child_requests_.erase(child);
   }
@@ skipping 19 matching lines @@
   for (auto& child : child_requests_) {
     // Request cancel should delete the request instance.
     child.request->Cancel();
   }
   child_requests_.clear();
   UrlFetchRequestBase::Cancel();
 }
 
 // Obtains corresponding child entry of |request_id|. Returns NULL if the
 // entry is not found.
-std::vector<BatchUploadChildEntry>::iterator
-BatchUploadRequest::GetChildEntry(RequestID request_id) {
+std::vector<BatchUploadChildEntry>::iterator BatchUploadRequest::GetChildEntry(
+    RequestID request_id) {
   for (auto it = child_requests_.begin(); it != child_requests_.end(); ++it) {
     if (it->request == request_id)
       return it;
   }
   return child_requests_.end();
 }
 
 void BatchUploadRequest::MayCompletePrepare() {
   if (!committed_ || prepare_callback_.is_null())
     return;
@@ skipping 21 matching lines @@
         method = "PUT";
         break;
       default:
         NOTREACHED();
         break;
     }
 
     parts.push_back(ContentTypeAndData());
     parts.back().type = kHttpContentType;
     parts.back().data = base::StringPrintf(
-        kBatchUploadRequestFormat,
-        method.c_str(),
-        url.path().c_str(),
-        url_generator_.GetBatchUploadUrl().host().c_str(),
-        type.c_str(),
+        kBatchUploadRequestFormat, method.c_str(), url.path().c_str(),
+        url_generator_.GetBatchUploadUrl().host().c_str(), type.c_str(),
         data.c_str());
   }
 
   GenerateMultipartBody(MULTIPART_MIXED, boundary_, parts, &upload_content_);
   prepare_callback_.Run(HTTP_SUCCESS);
 }
 
 bool BatchUploadRequest::GetContentData(std::string* upload_content_type,
                                         std::string* upload_content_data) {
   upload_content_type->assign(upload_content_.type);
@@ skipping 20 matching lines @@
   return headers;
 }
 
 void BatchUploadRequest::ProcessURLFetchResults(const net::URLFetcher* source) {
   if (!IsSuccessfulDriveApiErrorCode(GetErrorCode())) {
     RunCallbackOnPrematureFailure(GetErrorCode());
     sender_->RequestFinished(this);
     return;
   }
 
-  for (auto& child : child_requests_) {
-    // TODO(hirono): Split the mutlipart result and return the correct code and
-    // body.
-    child.request->ProcessURLFetchResults(HTTP_SERVICE_UNAVAILABLE, "");
-    // Request deletes itself after processing.
+  std::string content_type;
+  source->GetResponseHeaders()->EnumerateHeader(
+      /* need only first header */ NULL, "Content-Type", &content_type);
+
+  std::vector<MultipartHttpResponse> parts;
+  if (!ParseMultipartResponse(content_type, response_writer()->data(),
+                              &parts) ||
+      child_requests_.size() != parts.size()) {
+    RunCallbackOnPrematureFailure(DRIVE_PARSE_ERROR);
+    sender_->RequestFinished(this);
+    return;
+  }
+
+  for (size_t i = 0; i < parts.size(); ++i) {
+    child_requests_[i].request->ProcessURLFetchResults(parts[i].code,
+                                                       parts[i].body);
   }
 
   child_requests_.clear();
+  sender_->RequestFinished(this);
 }
 
 void BatchUploadRequest::RunCallbackOnPrematureFailure(DriveApiErrorCode code) {
   for (auto child : child_requests_) {
     child.request->RunCallbackOnPrematureFailure(code);
     sender_->RequestFinished(child.request);
   }
   child_requests_.clear();
 }
 
 }  // namespace drive
 }  // namespace google_apis