Rewrite simple uses of base::ListValue::Append(base::Value*) on CrOS.

chrome/browser/ui/webui/chromeos/drive_internals_ui.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 "chrome/browser/ui/webui/chromeos/drive_internals_ui.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+#include <utility>
+
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/drive/debug_info_collector.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/drive/drive_notification_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 168 matching lines @@
       return "error";
     default:  // Treat all other higher severities as ERROR.
       return "error";
   }
 }
 
 // Appends {'key': key, 'value': value} dictionary to the |list|.
 void AppendKeyValue(base::ListValue* list,
                     const std::string& key,
                     const std::string& value) {
-  base::DictionaryValue* dict = new base::DictionaryValue;
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString("key", key);
   dict->SetString("value", value);
-  list->Append(dict);
+  list->Append(std::move(dict));
 }
 
 // Class to handle messages from chrome://drive-internals.
 class DriveInternalsWebUIHandler : public content::WebUIMessageHandler {
  public:
   DriveInternalsWebUIHandler()
       : last_sent_event_id_(-1),
         weak_ptr_factory_(this) {
   }
 
@@ skipping 128 matching lines @@
     return;
   }
   DCHECK(parsed_app_list);
 
   base::DictionaryValue app_list;
   app_list.SetString("etag", parsed_app_list->etag());
 
   base::ListValue* items = new base::ListValue();
   for (size_t i = 0; i < parsed_app_list->items().size(); ++i) {
     const google_apis::AppResource* app = parsed_app_list->items()[i];
-    base::DictionaryValue* app_data = new base::DictionaryValue();
+    auto app_data = base::MakeUnique<base::DictionaryValue>();
     app_data->SetString("name", app->name());
     app_data->SetString("application_id", app->application_id());
     app_data->SetString("object_type", app->object_type());
     app_data->SetBoolean("supports_create", app->supports_create());
 
-    items->Append(app_data);
+    items->Append(std::move(app_data));
   }
   app_list.Set("items", items);
 
   web_ui()->CallJavascriptFunctionUnsafe("updateAppList", app_list);
 }
 
 void DriveInternalsWebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "pageLoaded",
       base::Bind(&DriveInternalsWebUIHandler::OnPageLoaded,
@@ skipping 267 matching lines @@
     drive::JobListInterface* job_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(job_list);
 
   std::vector<drive::JobInfo> info_list = job_list->GetJobInfoList();
 
   base::ListValue in_flight_operations;
   for (size_t i = 0; i < info_list.size(); ++i) {
     const drive::JobInfo& info = info_list[i];
 
-    base::DictionaryValue* dict = new base::DictionaryValue;
+    auto dict = base::MakeUnique<base::DictionaryValue>();
     dict->SetInteger("id", info.job_id);
     dict->SetString("type", drive::JobTypeToString(info.job_type));
     dict->SetString("file_path", info.file_path.AsUTF8Unsafe());
     dict->SetString("state", drive::JobStateToString(info.state));
     dict->SetDouble("progress_current", info.num_completed_bytes);
     dict->SetDouble("progress_total", info.num_total_bytes);
-    in_flight_operations.Append(dict);
+    in_flight_operations.Append(std::move(dict));
   }
   web_ui()->CallJavascriptFunctionUnsafe("updateInFlightOperations",
                                          in_flight_operations);
 }
 
 void DriveInternalsWebUIHandler::UpdateGCacheContentsSection() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Start updating the GCache contents section.
   Profile* profile = Profile::FromWebUI(web_ui());
@@ skipping 76 matching lines @@
       integration_service->event_logger()->GetHistory();
 
   base::ListValue list;
   for (size_t i = 0; i < log.size(); ++i) {
     // Skip events which were already sent.
     if (log[i].id <= last_sent_event_id_)
       continue;
 
     std::string severity = SeverityToString(log[i].severity);
 
-    base::DictionaryValue* dict = new base::DictionaryValue;
+    auto dict = base::MakeUnique<base::DictionaryValue>();
     dict->SetString("key",
         google_apis::util::FormatTimeAsStringLocaltime(log[i].when));
     dict->SetString("value", "[" + severity + "] " + log[i].what);
     dict->SetString("class", "log-" + severity);
-    list.Append(dict);
+    list.Append(std::move(dict));
     last_sent_event_id_ = log[i].id;
   }
   if (!list.empty())
     web_ui()->CallJavascriptFunctionUnsafe("updateEventLog", list);
 }
 
 void DriveInternalsWebUIHandler::UpdatePathConfigurationsSection() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Profile* const profile = Profile::FromWebUI(web_ui());
@@ skipping 128 matching lines @@
       content::WebUIDataSource::Create(chrome::kChromeUIDriveInternalsHost);
   source->AddResourcePath("drive_internals.css", IDR_DRIVE_INTERNALS_CSS);
   source->AddResourcePath("drive_internals.js", IDR_DRIVE_INTERNALS_JS);
   source->SetDefaultResource(IDR_DRIVE_INTERNALS_HTML);
 
   Profile* profile = Profile::FromWebUI(web_ui);
   content::WebUIDataSource::Add(profile, source);
 }
 
 }  // namespace chromeos