Drive: Add multipart related utility methods.

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/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
@@ skipping 37 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";
 
-// The prefix of multipart/related mime type.
-const char kMultipartMimeTypePrefix[] = "multipart/related; boundary=";
+// Mime type of JSON.
+const char kJsonMimeType[] = "application/json";
 
-// Template for multipart request body.
-const char kMessageFormatBeforeFile[] =
-    "--%s\nContent-Type: %s\n\n%s\n--%s\nContent-Type: %s\n\n";
-const char kMessageFormatAfterFile[] = "\n--%s--";
+// Mime type of multipart related.
+const char kMultipartRelatedMimeTypePrefix[] =
+    "multipart/related; boundary=";
+
+// Mime type of multipart mixed.
+const char kMultipartMixedMimeTypePrefix[] =
+    "multipart/mixed; boundary=";
+
+// Header for each item in a multipart message.
+const char kMultipartItemHeaderFormat[] = "--%s\nContent-Type: %s\n\n";
+
+// Footer for whole multipart message.
+const char kMultipartFooterFormat[] = "--%s--";
 
 // Characters to be used for multipart/related boundary.
 const char kBoundaryCharacters[] =
     "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
 // Size of multipart/related's boundary.
 const char kBoundarySize = 70;
 
 // 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) {
@@ skipping 16 matching lines @@
   // 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;
-}
-
 // Obtains the multipart body for the metadata string and file contents. If
 // predetermined_boundary is empty, the function generates the boundary string.
 bool GetMultipartContent(const std::string& predetermined_boundary,
                          const std::string& metadata_json,
                          const std::string& content_type,
                          const base::FilePath& path,
                          std::string* upload_content_type,
                          std::string* upload_content_data) {
-  std::string file_content;
-  if (!ReadFileToString(path, &file_content))
+  std::vector<google_apis::ContentTypeAndData> parts(2);
+  parts[0].type = kJsonMimeType;
+  parts[0].data = metadata_json;
+  parts[1].type = content_type;
+  if (!ReadFileToString(path, &parts[1].data))
     return false;
 
-  std::string boundary;
-  if (predetermined_boundary.empty()) {
-    while (true) {
-      boundary.resize(kBoundarySize);
-      for (int i = 0; i < kBoundarySize; ++i) {
-        // Subtract 2 from the array size to exclude '\0', and to turn the size
-        // into the last index.
-        const int last_char_index = arraysize(kBoundaryCharacters) - 2;
-        boundary[i] = kBoundaryCharacters[base::RandInt(0,  last_char_index)];
-      }
-      if (metadata_json.find(boundary, 0) == std::string::npos &&
-          file_content.find(boundary, 0) == std::string::npos) {
-        break;
-      }
-    }
-  } else {
-    boundary = predetermined_boundary;
-  }
-  const std::string body_before_file = base::StringPrintf(
-      kMessageFormatBeforeFile, boundary.c_str(), "application/json",
-      metadata_json.c_str(), boundary.c_str(), content_type.c_str());
-  const std::string body_after_file =
-      base::StringPrintf(kMessageFormatAfterFile, boundary.c_str());
-
-  *upload_content_type = kMultipartMimeTypePrefix + boundary;
-  *upload_content_data = body_before_file + file_content + body_after_file;
+  google_apis::ContentTypeAndData output;
+  GenerateMultipartBody(
+      google_apis::MULTIPART_RELATED, predetermined_boundary, parts, &output);
+  upload_content_type->swap(output.type);
+  upload_content_data->swap(output.data);
   return true;
 }
 
 }  // namespace
 
 namespace google_apis {
 
 scoped_ptr<base::Value> ParseJson(const std::string& json) {
   int error_code = -1;
   std::string error_message;
@@ skipping 11 matching lines @@
           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 GenerateMultipartBody(MultipartType multipart_type,
+                           const std::string& predetermined_boundary,
+                           const std::vector<ContentTypeAndData>& parts,
+                           ContentTypeAndData* output) {
+  std::string boundary;
+  // Generate random boundary.
+  if (predetermined_boundary.empty()) {
+    while (true) {
+      boundary.resize(kBoundarySize);
+      for (int i = 0; i < kBoundarySize; ++i) {
+        // Subtract 2 from the array size to exclude '\0', and to turn the size
+        // into the last index.
+        const int last_char_index = arraysize(kBoundaryCharacters) - 2;
+        boundary[i] = kBoundaryCharacters[base::RandInt(0,  last_char_index)];
+      }
+      bool conflict_with_content = false;
+      for (auto& part : parts) {
+        if (part.data.find(boundary, 0) != std::string::npos) {
+          conflict_with_content = true;
+          break;
+        }
+      }
+      if (!conflict_with_content)
+        break;
+    }
+  } else {
+    boundary = predetermined_boundary;
+  }
+
+  switch (multipart_type) {
+    case MULTIPART_RELATED:
+      output->type = kMultipartRelatedMimeTypePrefix + boundary;
+      break;
+    case MULTIPART_MIXED:
+      output->type = kMultipartMixedMimeTypePrefix + boundary;
+      break;
+  }
+
+  output->data.clear();
+  for (auto& part : parts) {
+    output->data.append(base::StringPrintf(
+        kMultipartItemHeaderFormat, boundary.c_str(), part.type.c_str()));
+    output->data.append(part.data);
+    output->data.append("\n");
+  }
+  output->data.append(
+      base::StringPrintf(kMultipartFooterFormat, boundary.c_str()));
+}
+
 //=========================== 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(
         new net::URLFetcherFileWriter(file_task_runner, file_path));
   }
@@ skipping 99 matching lines @@
     const std::string& custom_user_agent,
     const ReAuthenticateCallback& callback,
     DriveApiErrorCode code) {
   DCHECK(CalledOnValidThread());
   DCHECK(!access_token.empty());
   DCHECK(!callback.is_null());
   DCHECK(re_authenticate_callback_.is_null());
 
   const GURL url = GetURL();
   DriveApiErrorCode error_code;
-  if (code != HTTP_SUCCESS && code != HTTP_CREATED && code != HTTP_NO_CONTENT)
+  if (IsSuccessfulDriveApiErrorCode(code))
     error_code = code;
   else if (url.is_empty())
     error_code = DRIVE_OTHER_ERROR;
   else
     error_code = HTTP_SUCCESS;
 
   if (error_code != HTTP_SUCCESS) {
     // Error is found on generating the url or preparing the request. Send the
     // error message to the callback, and then return immediately without trying
     // to connect to the server.  We need to call CompleteRequestWithError
@@ skipping 134 matching lines @@
       case net::ERR_NETWORK_CHANGED:
         error_code_ = DRIVE_NO_CONNECTION;
         break;
       default:
         error_code_ = DRIVE_OTHER_ERROR;
     }
   }
 
   // The server may return detailed error status in JSON.
   // See https://developers.google.com/drive/handle-errors
-  if (!IsSuccessfulResponseCode(error_code_)) {
+  if (!IsSuccessfulDriveApiErrorCode(error_code_)) {
     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";
 
@@ skipping 486 matching lines @@
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     DriveApiErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis