Remove raw base::DictionaryValue::Set

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 <stddef.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
@@ skipping 65 matching lines @@
 }
 
 // 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;
+  auto properties_value = base::MakeUnique<base::ListValue>();
   for (const auto& property : properties) {
-    std::unique_ptr<base::DictionaryValue> property_value(
-        new base::DictionaryValue);
+    auto property_value = base::MakeUnique<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(std::move(property_value));
   }
-  request_body->Set("properties", properties_value);
+  request_body->Set("properties", std::move(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()) {
-    std::unique_ptr<base::ListValue> parents(new base::ListValue);
+    auto parents = base::MakeUnique<base::ListValue>();
     parents->Append(google_apis::util::CreateParentValue(parent_resource_id));
-    root.Set("parents", parents.release());
+    root.Set("parents", std::move(parents));
   }
 
   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));
@@ skipping 237 matching lines @@
                    util::FormatTimeAsString(last_viewed_by_me_date_));
   }
 
   if (!mime_type_.empty())
     root.SetString("mimeType", mime_type_);
 
   if (!modified_date_.is_null())
     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 
   if (!parents_.empty()) {
-    base::ListValue* parents_value = new base::ListValue;
+    auto parents_value = base::MakeUnique<base::ListValue>();
     for (size_t i = 0; i < parents_.size(); ++i) {
-      std::unique_ptr<base::DictionaryValue> parent(new base::DictionaryValue);
+      auto parent = base::MakeUnique<base::DictionaryValue>();
       parent->SetString("id", parents_[i]);
       parents_value->Append(std::move(parent));
     }
-    root.Set("parents", parents_value);
+    root.Set("parents", std::move(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 << "]";
@@ skipping 51 matching lines @@
 
   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_));
   }
 
   if (!parents_.empty()) {
-    base::ListValue* parents_value = new base::ListValue;
+    auto parents_value = base::MakeUnique<base::ListValue>();
     for (size_t i = 0; i < parents_.size(); ++i) {
-      std::unique_ptr<base::DictionaryValue> parent(new base::DictionaryValue);
+      auto parent = base::MakeUnique<base::DictionaryValue>();
       parent->SetString("id", parents_[i]);
       parents_value->Append(std::move(parent));
     }
-    root.Set("parents", parents_value);
+    root.Set("parents", std::move(parents_value));
   }
 
   AttachProperties(properties_, &root);
   base::JSONWriter::Write(root, upload_content);
 
   DVLOG(1) << "FilesPatch data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
@@ skipping 27 matching lines @@
     return false;
 
   *upload_content_type = util::kContentTypeApplicationJson;
 
   base::DictionaryValue root;
 
   if (!modified_date_.is_null())
     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 
   if (!parents_.empty()) {
-    base::ListValue* parents_value = new base::ListValue;
+    auto parents_value = base::MakeUnique<base::ListValue>();
     for (size_t i = 0; i < parents_.size(); ++i) {
-      std::unique_ptr<base::DictionaryValue> parent(new base::DictionaryValue);
+      auto parent = base::MakeUnique<base::DictionaryValue>();
       parent->SetString("id", parents_[i]);
       parents_value->Append(std::move(parent));
     }
-    root.Set("parents", parents_value);
+    root.Set("parents", std::move(parents_value));
   }
 
   if (!title_.empty())
     root.SetString("title", title_);
 
   base::JSONWriter::Write(root, upload_content);
   DVLOG(1) << "FilesCopy data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
@@ skipping 277 matching lines @@
 
 bool InitiateUploadNewFileRequest::GetContentData(
     std::string* upload_content_type,
     std::string* upload_content) {
   *upload_content_type = util::kContentTypeApplicationJson;
 
   base::DictionaryValue root;
   root.SetString("title", title_);
 
   // Fill parent link.
-  std::unique_ptr<base::ListValue> parents(new base::ListValue);
+  auto parents = base::MakeUnique<base::ListValue>();
   parents->Append(util::CreateParentValue(parent_resource_id_));
-  root.Set("parents", parents.release());
+  root.Set("parents", std::move(parents));
 
   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);
@@ skipping 37 matching lines @@
       InitiateUploadRequestBase::GetExtraRequestHeaders());
   headers.push_back(util::GenerateIfMatchHeader(etag_));
   return headers;
 }
 
 bool InitiateUploadExistingFileRequest::GetContentData(
     std::string* upload_content_type,
     std::string* upload_content) {
   base::DictionaryValue root;
   if (!parent_resource_id_.empty()) {
-    std::unique_ptr<base::ListValue> parents(new base::ListValue);
+    auto parents = base::MakeUnique<base::ListValue>();
     parents->Append(util::CreateParentValue(parent_resource_id_));
-    root.Set("parents", parents.release());
+    root.Set("parents", std::move(parents));
   }
 
   if (!title_.empty())
     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",
@@ skipping 241 matching lines @@
       break;
     case PERMISSION_ROLE_READER:
       root.SetString("role", "reader");
       break;
     case PERMISSION_ROLE_WRITER:
       root.SetString("role", "writer");
       break;
     case PERMISSION_ROLE_COMMENTER:
       root.SetString("role", "reader");
       {
-        base::ListValue* list = new base::ListValue;
+        auto list = base::MakeUnique<base::ListValue>();
         list->AppendString("commenter");
-        root.Set("additionalRoles", list);
+        root.Set("additionalRoles", std::move(list));
       }
       break;
   }
   root.SetString("value", value_);
   base::JSONWriter::Write(root, upload_content);
   return true;
 }
 
 //======================= SingleBatchableDelegateRequest =======================
 
@@ skipping 283 matching lines @@
     } else if (last_progress_value_ < child->data_offset + child->data_size &&
                child->data_offset + child->data_size < current) {
       child->request->NotifyUploadProgress(source, child->data_size,
                                            child->data_size);
     }
   }
   last_progress_value_ = current;
 }
 }  // namespace drive
 }  // namespace google_apis