Add support for setting properties to requests uploading contents.

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/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"
 
 namespace google_apis {
+namespace drive {
 namespace {
 
 // 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 drive::UploadRangeCallback& callback,
-    const UploadRangeResponse& response,
-    scoped_ptr<base::Value> value) {
+void ParseFileResourceWithUploadRangeAndRun(const UploadRangeCallback& callback,
+                                            const UploadRangeResponse& response,
+                                            scoped_ptr<base::Value> value) {
   DCHECK(!callback.is_null());
 
   scoped_ptr<FileResource> file_resource;
   if (value) {
     file_resource = FileResource::CreateFrom(*value);
     if (!file_resource) {
       callback.Run(
           UploadRangeResponse(DRIVE_PARSE_ERROR,
                               response.start_position_received,
                               response.end_position_received),
           scoped_ptr<FileResource>());
       return;
     }
   }
 
   callback.Run(response, file_resource.Pass());
 }
 
+// Attaches |properties| to the |request_body| if |properties| is not empty.
+// |request_body| must not be NULL.
+void AttachProperties(const Properties& properties,
+                      base::DictionaryValue* request_body) {
+  DCHECK(request_body);
+  if (properties.empty())
+    return;
+
+  base::ListValue* const properties_value = new base::ListValue;
+  for (const auto& property : properties) {
+    base::DictionaryValue* const property_value = new base::DictionaryValue;
+    std::string visibility_as_string;
+    switch (property.visibility()) {
+      case Property::VISIBILITY_PRIVATE:
+        visibility_as_string = "PRIVATE";
+        break;
+      case Property::VISIBILITY_PUBLIC:
+        visibility_as_string = "PUBLIC";
+        break;
+    }
+    property_value->SetString("visibility", visibility_as_string);
+    property_value->SetString("key", property.key());
+    property_value->SetString("value", property.value());
+    properties_value->Append(property_value);
+  }
+  request_body->Set("properties", properties_value);
+}
+
+// Creates metadata JSON string for multipart uploading.
+// All the values are optional. If the value is empty or null, the value does
+// not appear in the metadata.
+std::string CreateMultipartUploadMetadataJson(
+    const std::string& title,
+    const std::string& parent_resource_id,
+    const base::Time& modified_date,
+    const base::Time& last_viewed_by_me_date,
+    const Properties& properties) {
+  base::DictionaryValue root;
+  if (!title.empty())
+    root.SetString("title", title);
+
+  // Fill parent link.
+  if (!parent_resource_id.empty()) {
+    scoped_ptr<base::ListValue> parents(new base::ListValue);
+    parents->Append(
+        google_apis::util::CreateParentValue(parent_resource_id).release());
+    root.Set("parents", parents.release());
+  }
+
+  if (!modified_date.is_null()) {
+    root.SetString("modifiedDate",
+                   google_apis::util::FormatTimeAsString(modified_date));
+  }
+
+  if (!last_viewed_by_me_date.is_null()) {
+    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;
+}
+
 }  // namespace
 
-namespace drive {
-
 Property::Property() : visibility_(VISIBILITY_PRIVATE) {
 }
 
 Property::~Property() {
 }
 
 //============================ DriveApiPartialFieldRequest ====================
 
 DriveApiPartialFieldRequest::DriveApiPartialFieldRequest(
     RequestSender* sender) : UrlFetchRequestBase(sender) {
@@ skipping 91 matching lines @@
       base::DictionaryValue* parent = new base::DictionaryValue;
       parent->SetString("id", parents_[i]);
       parents_value->Append(parent);
     }
     root.Set("parents", parents_value);
   }
 
   if (!title_.empty())
     root.SetString("title", title_);
 
+  AttachProperties(properties_, &root);
   base::JSONWriter::Write(&root, upload_content);
+
   DVLOG(1) << "FilesInsert data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
 GURL FilesInsertRequest::GetURLInternal() const {
   return url_generator_.GetFilesInsertUrl();
 }
 
 //============================== FilesPatchRequest ============================
@@ skipping 51 matching lines @@
   if (!parents_.empty()) {
     base::ListValue* parents_value = new base::ListValue;
     for (size_t i = 0; i < parents_.size(); ++i) {
       base::DictionaryValue* parent = new base::DictionaryValue;
       parent->SetString("id", parents_[i]);
       parents_value->Append(parent);
     }
     root.Set("parents", parents_value);
   }
 
-  if (!properties_.empty()) {
-    base::ListValue* properties_value = new base::ListValue;
-    for (const auto& property : properties_) {
-      base::DictionaryValue* const property_value = new base::DictionaryValue;
-      std::string visibility_as_string;
-      switch (property.visibility()) {
-        case Property::VISIBILITY_PRIVATE:
-          visibility_as_string = "PRIVATE";
-          break;
-        case Property::VISIBILITY_PUBLIC:
-          visibility_as_string = "PUBLIC";
-          break;
-      }
-      property_value->SetString("visibility", visibility_as_string);
-      property_value->SetString("key", property.key());
-      property_value->SetString("value", property.value());
-      properties_value->Append(property_value);
-    }
-    root.Set("properties", properties_value);
-  }
+  AttachProperties(properties_, &root);
+  base::JSONWriter::Write(&root, upload_content);
 
-  base::JSONWriter::Write(&root, upload_content);
   DVLOG(1) << "FilesPatch data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
 //============================= FilesCopyRequest ==============================
 
 FilesCopyRequest::FilesCopyRequest(
     RequestSender* sender,
     const DriveApiUrlGenerator& url_generator,
@@ skipping 320 matching lines @@
   root.Set("parents", parents.release());
 
   if (!modified_date_.is_null())
     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 
   if (!last_viewed_by_me_date_.is_null()) {
     root.SetString("lastViewedByMeDate",
                    util::FormatTimeAsString(last_viewed_by_me_date_));
   }
 
+  AttachProperties(properties_, &root);
   base::JSONWriter::Write(&root, upload_content);
 
   DVLOG(1) << "InitiateUploadNewFile data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
 //===================== InitiateUploadExistingFileRequest ====================
 
 InitiateUploadExistingFileRequest::InitiateUploadExistingFileRequest(
@@ skipping 47 matching lines @@
     root.SetString("title", title_);
 
   if (!modified_date_.is_null())
     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 
   if (!last_viewed_by_me_date_.is_null()) {
     root.SetString("lastViewedByMeDate",
                    util::FormatTimeAsString(last_viewed_by_me_date_));
   }
 
+  AttachProperties(properties_, &root);
   if (root.empty())
     return false;
 
   *upload_content_type = util::kContentTypeApplicationJson;
   base::JSONWriter::Write(&root, upload_content);
   DVLOG(1) << "InitiateUploadExistingFile data: " << *upload_content_type
            << ", [" << *upload_content << "]";
   return true;
 }
 
@@ skipping 63 matching lines @@
 
 MultipartUploadNewFileRequest::MultipartUploadNewFileRequest(
     RequestSender* sender,
     const std::string& title,
     const std::string& parent_resource_id,
     const std::string& content_type,
     int64 content_length,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const base::FilePath& local_file_path,
+    const Properties& properties,
     const DriveApiUrlGenerator& url_generator,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback)
-    : MultipartUploadRequestBase(sender,
-                                 title,
-                                 parent_resource_id,
-                                 content_type,
-                                 content_length,
-                                 modified_date,
-                                 last_viewed_by_me_date,
-                                 local_file_path,
-                                 callback,
-                                 progress_callback),
+    : MultipartUploadRequestBase(
+          sender,
+          CreateMultipartUploadMetadataJson(title,
+                                            parent_resource_id,
+                                            modified_date,
+                                            last_viewed_by_me_date,
+                                            properties),
+          content_type,
+          content_length,
+          local_file_path,
+          callback,
+          progress_callback),
+      has_modified_date_(!modified_date.is_null()),
       url_generator_(url_generator) {
 }
 
 MultipartUploadNewFileRequest::~MultipartUploadNewFileRequest() {
 }
 
 GURL MultipartUploadNewFileRequest::GetURL() const {
-  return url_generator_.GetMultipartUploadNewFileUrl(has_modified_date());
+  return url_generator_.GetMultipartUploadNewFileUrl(has_modified_date_);
 }
 
 net::URLFetcher::RequestType MultipartUploadNewFileRequest::GetRequestType()
     const {
   return net::URLFetcher::POST;
 }
 
 //======================= MultipartUploadExistingFileRequest ===================
 
 MultipartUploadExistingFileRequest::MultipartUploadExistingFileRequest(
     RequestSender* sender,
     const std::string& title,
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& content_type,
     int64 content_length,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const base::FilePath& local_file_path,
     const std::string& etag,
+    const Properties& properties,
     const DriveApiUrlGenerator& url_generator,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback)
-    : MultipartUploadRequestBase(sender,
-                                 title,
-                                 parent_resource_id,
-                                 content_type,
-                                 content_length,
-                                 modified_date,
-                                 last_viewed_by_me_date,
-                                 local_file_path,
-                                 callback,
-                                 progress_callback),
+    : MultipartUploadRequestBase(
+          sender,
+          CreateMultipartUploadMetadataJson(title,
+                                            parent_resource_id,
+                                            modified_date,
+                                            last_viewed_by_me_date,
+                                            properties),
+          content_type,
+          content_length,
+          local_file_path,
+          callback,
+          progress_callback),
       resource_id_(resource_id),
       etag_(etag),
+      has_modified_date_(!modified_date.is_null()),
       url_generator_(url_generator) {
 }
 
 MultipartUploadExistingFileRequest::~MultipartUploadExistingFileRequest() {
 }
 
 std::vector<std::string>
 MultipartUploadExistingFileRequest::GetExtraRequestHeaders() const {
   std::vector<std::string> headers(
       MultipartUploadRequestBase::GetExtraRequestHeaders());
   headers.push_back(util::GenerateIfMatchHeader(etag_));
   return headers;
 }
 
 GURL MultipartUploadExistingFileRequest::GetURL() const {
-  return url_generator_.GetMultipartUploadExistingFileUrl(
-      resource_id_, has_modified_date());
+  return url_generator_.GetMultipartUploadExistingFileUrl(resource_id_,
+                                                          has_modified_date_);
 }
 
 net::URLFetcher::RequestType
 MultipartUploadExistingFileRequest::GetRequestType() const {
   return net::URLFetcher::PUT;
 }
 
 //========================== DownloadFileRequest ==========================
 
 DownloadFileRequest::DownloadFileRequest(
@@ skipping 78 matching lines @@
       }
       break;
   }
   root.SetString("value", value_);
   base::JSONWriter::Write(&root, upload_content);
   return true;
 }
 
 }  // namespace drive
 }  // namespace google_apis