Drive API: Generates randum boundary for multipart uploading.

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"
+#include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/request_sender.h"
 #include "google_apis/drive/request_util.h"
 #include "google_apis/drive/task_util.h"
 #include "google_apis/drive/time_util.h"
@@ skipping 33 matching lines @@
 const char kUploadResponseRange[] = "range";
 
 // The prefix of multipart/related mime type.
 const char kMultipartMimeTypePrefix[] = "multipart/related; boundary=";
 
 // 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--";
 
-// The predetermined boundary string for multipart/related.
-// TODO(hirono): Generates the boundary string randomly and ensure the string
-// does not appears in the content parts.
-const char kBoundaryForPrototype[] =
-    "LJx6AFbwBL94CmojDJBcmXpl1WfnvCUOenZqWrpI1Ua3l7xv8Y";
+// 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) {
   base::PostTaskAndReplyWithResult(
       blocking_task_runner,
@@ skipping 54 matching lines @@
                                              last_viewed_by_me_date));
   }
 
   std::string json_string;
   base::JSONWriter::Write(&root, &json_string);
   return json_string;
 }
 
 // Obtains the multipart body for the metadata string and file contents. If
 // predetermined_boundary is empty, the function generates the boundary string.
-// TODO(hirono): Generates the boundary string randomly and ensure the string
-// does not appears in the content parts.
 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))
     return false;
 
-  const std::string boundary = predetermined_boundary.empty()
-                                   ? kBoundaryForPrototype
-                                   : predetermined_boundary;
-
-  *upload_content_type = kMultipartMimeTypePrefix + boundary;
+  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;
-
   return true;
 }
 
 }  // namespace
 
 namespace google_apis {
 
 scoped_ptr<base::Value> ParseJson(const std::string& json) {
   int error_code = -1;
   std::string error_message;
@@ skipping 768 matching lines @@
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis