Remove raw base::DictionaryValue::Set in //content

content/browser/gpu/gpu_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 "content/browser/gpu/gpu_internals_ui.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 62 matching lines @@
     const std::string& desc,
     const std::string& value) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("description", desc);
   dict->SetString("value", value);
   return dict;
 }
 
 std::unique_ptr<base::DictionaryValue> NewDescriptionValuePair(
     const std::string& desc,
-    base::Value* value) {
+    std::unique_ptr<base::Value> value) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("description", desc);
-  dict->Set("value", value);
+  dict->Set("value", std::move(value));
   return dict;
 }
 
 #if defined(OS_WIN)
 // Output DxDiagNode tree as nested array of {description,value} pairs
-base::ListValue* DxDiagNodeToList(const gpu::DxDiagNode& node) {
-  base::ListValue* list = new base::ListValue();
+std::unique_ptr<base::ListValue> DxDiagNodeToList(const gpu::DxDiagNode& node) {
+  auto list = base::MakeUnique<base::ListValue>();
   for (std::map<std::string, std::string>::const_iterator it =
       node.values.begin();
       it != node.values.end();
       ++it) {
     list->Append(NewDescriptionValuePair(it->first, it->second));
   }
 
   for (std::map<std::string, gpu::DxDiagNode>::const_iterator it =
       node.children.begin();
       it != node.children.end();
       ++it) {
-    base::ListValue* sublist = DxDiagNodeToList(it->second);
-    list->Append(NewDescriptionValuePair(it->first, sublist));
+    std::unique_ptr<base::ListValue> sublist = DxDiagNodeToList(it->second);
+    list->Append(NewDescriptionValuePair(it->first, std::move(sublist)));
   }
   return list;
 }
 #endif
 
 std::string GPUDeviceToString(const gpu::GPUInfo::GPUDevice& gpu) {
   std::string vendor = base::StringPrintf("0x%04x", gpu.vendor_id);
   if (!gpu.vendor_string.empty())
     vendor += " [" + gpu.vendor_string + "]";
   std::string device = base::StringPrintf("0x%04x", gpu.device_id);
   if (!gpu.device_string.empty())
     device += " [" + gpu.device_string + "]";
   return base::StringPrintf("VENDOR = %s, DEVICE= %s%s",
       vendor.c_str(), device.c_str(), gpu.active ? " *ACTIVE*" : "");
 }
 
-base::DictionaryValue* GpuInfoAsDictionaryValue() {
+std::unique_ptr<base::DictionaryValue> GpuInfoAsDictionaryValue() {
   gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
-  base::ListValue* basic_info = new base::ListValue();
+  auto basic_info = base::MakeUnique<base::ListValue>();
   basic_info->Append(NewDescriptionValuePair(
       "Initialization time",
       base::Int64ToString(gpu_info.initialization_time.InMilliseconds())));
   basic_info->Append(NewDescriptionValuePair(
-      "In-process GPU", new base::Value(gpu_info.in_process_gpu)));
+      "In-process GPU",
+      base::MakeUnique<base::Value>(gpu_info.in_process_gpu)));
   basic_info->Append(NewDescriptionValuePair(
       "Passthrough Command Decoder",
-      new base::Value(gpu_info.passthrough_cmd_decoder)));
+      base::MakeUnique<base::Value>(gpu_info.passthrough_cmd_decoder)));
   basic_info->Append(NewDescriptionValuePair(
-      "Supports overlays", new base::Value(gpu_info.supports_overlays)));
+      "Supports overlays",
+      base::MakeUnique<base::Value>(gpu_info.supports_overlays)));
   basic_info->Append(NewDescriptionValuePair(
-      "Sandboxed", new base::Value(gpu_info.sandboxed)));
+      "Sandboxed", base::MakeUnique<base::Value>(gpu_info.sandboxed)));
   basic_info->Append(NewDescriptionValuePair(
       "GPU0", GPUDeviceToString(gpu_info.gpu)));
   for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
     basic_info->Append(NewDescriptionValuePair(
         base::StringPrintf("GPU%d", static_cast<int>(i + 1)),
         GPUDeviceToString(gpu_info.secondary_gpus[i])));
   }
-  basic_info->Append(
-      NewDescriptionValuePair("Optimus", new base::Value(gpu_info.optimus)));
-  basic_info->Append(
-      NewDescriptionValuePair("Optimus", new base::Value(gpu_info.optimus)));
   basic_info->Append(NewDescriptionValuePair(
-      "AMD switchable", new base::Value(gpu_info.amd_switchable)));
+      "Optimus", base::MakeUnique<base::Value>(gpu_info.optimus)));
+  basic_info->Append(NewDescriptionValuePair(
+      "Optimus", base::MakeUnique<base::Value>(gpu_info.optimus)));
+  basic_info->Append(NewDescriptionValuePair(
+      "AMD switchable",
+      base::MakeUnique<base::Value>(gpu_info.amd_switchable)));
 #if defined(OS_WIN)
   std::string compositor =
       ui::win::IsAeroGlassEnabled() ? "Aero Glass" : "none";
   basic_info->Append(
       NewDescriptionValuePair("Desktop compositing", compositor));
 
   std::vector<gfx::PhysicalDisplaySize> display_sizes =
       gfx::GetPhysicalSizeForDisplays();
   for (const auto& display_size : display_sizes) {
     const int w = display_size.width_mm;
@@ skipping 64 matching lines @@
 #endif
   std::string direct_rendering = gpu_info.direct_rendering ? "Yes" : "No";
   basic_info->Append(
       NewDescriptionValuePair("Direct rendering", direct_rendering));
 
   std::string reset_strategy =
       base::StringPrintf("0x%04x", gpu_info.gl_reset_notification_strategy);
   basic_info->Append(NewDescriptionValuePair(
       "Reset notification strategy", reset_strategy));
 
-  basic_info->Append(
-      NewDescriptionValuePair("GPU process crash count",
-                              new base::Value(gpu_info.process_crash_count)));
+  basic_info->Append(NewDescriptionValuePair(
+      "GPU process crash count",
+      base::MakeUnique<base::Value>(gpu_info.process_crash_count)));
 
-  base::DictionaryValue* info = new base::DictionaryValue();
-  info->Set("basic_info", basic_info);
+  auto info = base::MakeUnique<base::DictionaryValue>();
 
 #if defined(OS_WIN)
   auto dx_info = base::MakeUnique<base::Value>();
   if (gpu_info.dx_diagnostics.children.size())
-    dx_info.reset(DxDiagNodeToList(gpu_info.dx_diagnostics));
+    dx_info = DxDiagNodeToList(gpu_info.dx_diagnostics);
   info->Set("diagnostics", std::move(dx_info));
 #endif
 
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
   basic_info->Append(NewDescriptionValuePair(
       "System visual ID", base::Uint64ToString(gpu_info.system_visual)));
   basic_info->Append(NewDescriptionValuePair(
       "RGBA visual ID", base::Uint64ToString(gpu_info.rgba_visual)));
 #endif
 
+  info->Set("basic_info", std::move(basic_info));
   return info;
 }
 
 const char* BufferFormatToString(gfx::BufferFormat format) {
   switch (format) {
     case gfx::BufferFormat::ATC:
       return "ATC";
     case gfx::BufferFormat::ATCIA:
       return "ATCIA";
     case gfx::BufferFormat::DXT1:
@@ skipping 41 matching lines @@
       return "SCANOUT_CPU_READ_WRITE";
     case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
       return "GPU_READ_CPU_READ_WRITE";
     case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
       return "GPU_READ_CPU_READ_WRITE_PERSISTENT";
   }
   NOTREACHED();
   return nullptr;
 }
 
-base::ListValue* CompositorInfo() {
-  base::ListValue* compositor_info = new base::ListValue();
+std::unique_ptr<base::ListValue> CompositorInfo() {
+  auto compositor_info = base::MakeUnique<base::ListValue>();
 
   compositor_info->Append(NewDescriptionValuePair(
       "Tile Update Mode",
       IsZeroCopyUploadEnabled() ? "Zero-copy" : "One-copy"));
 
   compositor_info->Append(NewDescriptionValuePair(
       "Partial Raster", IsPartialRasterEnabled() ? "Enabled" : "Disabled"));
   return compositor_info;
 }
 
-base::ListValue* GpuMemoryBufferInfo() {
-  base::ListValue* gpu_memory_buffer_info = new base::ListValue();
+std::unique_ptr<base::ListValue> GpuMemoryBufferInfo() {
+  auto gpu_memory_buffer_info = base::MakeUnique<base::ListValue>();
 
   BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager =
       BrowserGpuMemoryBufferManager::current();
 
   for (size_t format = 0;
        format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
     std::string native_usage_support;
     for (size_t usage = 0;
          usage < static_cast<size_t>(gfx::BufferUsage::LAST) + 1; usage++) {
       if (gpu_memory_buffer_manager->IsNativeGpuMemoryBufferConfiguration(
@@ skipping 33 matching lines @@
   void OnGpuInfoUpdate() override;
 
   // ui::GpuSwitchingObserver implementation.
   void OnGpuSwitched() override;
 
   // Messages
   void OnBrowserBridgeInitialized(const base::ListValue* list);
   void OnCallAsync(const base::ListValue* list);
 
   // Submessages dispatched from OnCallAsync
-  base::Value* OnRequestClientInfo(const base::ListValue* list);
-  base::Value* OnRequestLogMessages(const base::ListValue* list);
+  std::unique_ptr<base::DictionaryValue> OnRequestClientInfo(
+      const base::ListValue* list);
+  std::unique_ptr<base::ListValue> OnRequestLogMessages(
+      const base::ListValue* list);
 
  private:
   // True if observing the GpuDataManager (re-attaching as observer would
   // DCHECK).
   bool observing_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuMessageHandler);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 28 matching lines @@
   // unpack args into requestId, submessage and submessageArgs
   bool ok;
   const base::Value* requestId;
   ok = args->Get(0, &requestId);
   DCHECK(ok);
 
   std::string submessage;
   ok = args->GetString(1, &submessage);
   DCHECK(ok);
 
-  base::ListValue* submessageArgs = new base::ListValue();
+  auto submessageArgs = base::MakeUnique<base::ListValue>();
   for (size_t i = 2; i < args->GetSize(); ++i) {
     const base::Value* arg;
     ok = args->Get(i, &arg);
     DCHECK(ok);
 
     submessageArgs->Append(arg->CreateDeepCopy());
   }
 
   // call the submessage handler
-  base::Value* ret = NULL;
+  std::unique_ptr<base::Value> ret;
   if (submessage == "requestClientInfo") {
-    ret = OnRequestClientInfo(submessageArgs);
+    ret = OnRequestClientInfo(submessageArgs.get());
   } else if (submessage == "requestLogMessages") {
-    ret = OnRequestLogMessages(submessageArgs);
+    ret = OnRequestLogMessages(submessageArgs.get());
   } else {  // unrecognized submessage
     NOTREACHED();
-    delete submessageArgs;
     return;
   }
-  delete submessageArgs;
 
   // call BrowserBridge.onCallAsyncReply with result
   if (ret) {
     web_ui()->CallJavascriptFunctionUnsafe("browserBridge.onCallAsyncReply",
                                            *requestId, *ret);
-    delete ret;
   } else {
     web_ui()->CallJavascriptFunctionUnsafe("browserBridge.onCallAsyncReply",
                                            *requestId);
   }
 }
 
 void GpuMessageHandler::OnBrowserBridgeInitialized(
     const base::ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Watch for changes in GPUInfo
   if (!observing_) {
     GpuDataManagerImpl::GetInstance()->AddObserver(this);
     ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
   }
   observing_ = true;
 
   // Tell GpuDataManager it should have full GpuInfo. If the
   // Gpu process has not run yet, this will trigger its launch.
   GpuDataManagerImpl::GetInstance()->RequestCompleteGpuInfoIfNeeded();
 
   // Run callback immediately in case the info is ready and no update in the
   // future.
   OnGpuInfoUpdate();
 }
 
-base::Value* GpuMessageHandler::OnRequestClientInfo(
+std::unique_ptr<base::DictionaryValue> GpuMessageHandler::OnRequestClientInfo(
     const base::ListValue* list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  auto dict = base::MakeUnique<base::DictionaryValue>();
 
   dict->SetString("version", GetContentClient()->GetProduct());
   dict->SetString("command_line",
       base::CommandLine::ForCurrentProcess()->GetCommandLineString());
   dict->SetString("operating_system",
                   base::SysInfo::OperatingSystemName() + " " +
                   base::SysInfo::OperatingSystemVersion());
   dict->SetString("angle_commit_id", ANGLE_COMMIT_HASH);
   dict->SetString("graphics_backend",
                   std::string("Skia/" STRINGIZE(SK_MILESTONE)
                               " " SKIA_COMMIT_HASH));
   dict->SetString("blacklist_version",
       GpuDataManagerImpl::GetInstance()->GetBlacklistVersion());
   dict->SetString("driver_bug_list_version",
       GpuDataManagerImpl::GetInstance()->GetDriverBugListVersion());
 
   return dict;
 }
 
-base::Value* GpuMessageHandler::OnRequestLogMessages(const base::ListValue*) {
+std::unique_ptr<base::ListValue> GpuMessageHandler::OnRequestLogMessages(
+    const base::ListValue*) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   return GpuDataManagerImpl::GetInstance()->GetLogMessages();
 }
 
 void GpuMessageHandler::OnGpuInfoUpdate() {
   // Get GPU Info.
   std::unique_ptr<base::DictionaryValue> gpu_info_val(
       GpuInfoAsDictionaryValue());
 
   // Add in blacklisting features
-  base::DictionaryValue* feature_status = new base::DictionaryValue;
+  auto feature_status = base::MakeUnique<base::DictionaryValue>();
   feature_status->Set("featureStatus", GetFeatureStatus());
   feature_status->Set("problems", GetProblems());
-  base::ListValue* workarounds = new base::ListValue();
+  auto workarounds = base::MakeUnique<base::ListValue>();
   for (const std::string& workaround : GetDriverBugWorkarounds())
     workarounds->AppendString(workaround);
-  feature_status->Set("workarounds", workarounds);
-  gpu_info_val->Set("featureStatus", feature_status);
+  feature_status->Set("workarounds", std::move(workarounds));
+  gpu_info_val->Set("featureStatus", std::move(feature_status));
   gpu_info_val->Set("compositorInfo", CompositorInfo());
   gpu_info_val->Set("gpuMemoryBufferInfo", GpuMemoryBufferInfo());
 
   // Send GPU Info to javascript.
   web_ui()->CallJavascriptFunctionUnsafe("browserBridge.onGpuInfoUpdate",
                                          *(gpu_info_val.get()));
 }
 
 void GpuMessageHandler::OnGpuSwitched() {
   GpuDataManagerImpl::GetInstance()->RequestCompleteGpuInfoIfNeeded();
@@ skipping 12 matching lines @@
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(base::MakeUnique<GpuMessageHandler>());
 
   // Set up the chrome://gpu/ source.
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, CreateGpuHTMLSource());
 }
 
 }  // namespace content