Reland: Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/devtools/devtools_targets_ui.cc

 // Copyright 2013 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/devtools/devtools_targets_ui.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/location.h"
@@ skipping 233 matching lines @@
 
   for (auto& it : targets_) {
     scoped_refptr<DevToolsAgentHost> host = it.second;
     base::DictionaryValue* descriptor = id_to_descriptor[host->GetId()];
     DCHECK(descriptor);
     std::string parent_id = host->GetParentId();
     if (parent_id.empty() || id_to_descriptor.count(parent_id) == 0) {
       list_value.Append(base::WrapUnique(descriptor));
     } else {
       base::DictionaryValue* parent = id_to_descriptor[parent_id];
-      base::ListValue* guests = NULL;
-      if (!parent->GetList(kGuestList, &guests)) {
-        guests = new base::ListValue();
-        parent->Set(kGuestList, guests);
+      base::ListValue* guests_weak = NULL;
+      if (!parent->GetList(kGuestList, &guests_weak)) {
+        auto guests = base::MakeUnique<base::ListValue>();
+        guests_weak = guests.get();
+        parent->Set(kGuestList, std::move(guests));
       }
-      guests->Append(base::WrapUnique(descriptor));
+      guests_weak->Append(base::WrapUnique(descriptor));
     }
   }
 
   SendSerializedTargets(list_value);
 }
 
 // AdbTargetsUIHandler --------------------------------------------------------
 
 class AdbTargetsUIHandler
     : public DevToolsTargetsUIHandler,
@@ skipping 67 matching lines @@
     DevToolsAndroidBridge::RemoteDevice* device = dit->get();
     std::unique_ptr<base::DictionaryValue> device_data(
         new base::DictionaryValue());
     device_data->SetString(kAdbModelField, device->model());
     device_data->SetString(kAdbSerialField, device->serial());
     device_data->SetBoolean(kAdbConnectedField, device->is_connected());
     std::string device_id = base::StringPrintf(
         kAdbDeviceIdFormat,
         device->serial().c_str());
     device_data->SetString(kTargetIdField, device_id);
-    base::ListValue* browser_list = new base::ListValue();
-    device_data->Set(kAdbBrowsersList, browser_list);
+    auto browser_list = base::MakeUnique<base::ListValue>();
 
     DevToolsAndroidBridge::RemoteBrowsers& browsers = device->browsers();
     for (DevToolsAndroidBridge::RemoteBrowsers::iterator bit =
         browsers.begin(); bit != browsers.end(); ++bit) {
       DevToolsAndroidBridge::RemoteBrowser* browser = bit->get();
       std::unique_ptr<base::DictionaryValue> browser_data(
           new base::DictionaryValue());
       browser_data->SetString(kAdbBrowserNameField, browser->display_name());
       browser_data->SetString(kAdbBrowserUserField, browser->user());
       browser_data->SetString(kAdbBrowserVersionField, browser->version());
       DevToolsAndroidBridge::RemoteBrowser::ParsedVersion parsed =
           browser->GetParsedVersion();
       browser_data->SetInteger(
           kAdbBrowserChromeVersionField,
           browser->IsChrome() && !parsed.empty() ? parsed[0] : 0);
       std::string browser_id = browser->GetId();
       browser_data->SetString(kTargetIdField, browser_id);
       browser_data->SetString(kTargetSourceField, source_id());
 
-      base::ListValue* page_list = new base::ListValue();
+      auto page_list = base::MakeUnique<base::ListValue>();
       remote_browsers_[browser_id] = browser;
-            browser_data->Set(kAdbPagesList, page_list);
       for (const auto& page : browser->pages()) {
         scoped_refptr<DevToolsAgentHost> host = page->CreateTarget();
         std::unique_ptr<base::DictionaryValue> target_data = Serialize(host);
         // Pass the screen size in the target object to make sure that
         // the caching logic does not prevent the target item from updating
         // when the screen size changes.
         gfx::Size screen_size = device->screen_size();
         target_data->SetInteger(kAdbScreenWidthField, screen_size.width());
         target_data->SetInteger(kAdbScreenHeightField, screen_size.height());
         targets_[host->GetId()] = host;
         page_list->Append(std::move(target_data));
       }
+      browser_data->Set(kAdbPagesList, std::move(page_list));
       browser_list->Append(std::move(browser_data));
     }
 
+    device_data->Set(kAdbBrowsersList, std::move(browser_list));
     device_list.Append(std::move(device_data));
   }
   SendSerializedTargets(device_list);
 }
 
 } // namespace
 
 // DevToolsTargetsUIHandler ---------------------------------------------------
 
 DevToolsTargetsUIHandler::DevToolsTargetsUIHandler(
@@ skipping 79 matching lines @@
       DevToolsAndroidBridge::Factory::GetForProfile(profile_);
   if (android_bridge)
     android_bridge->RemovePortForwardingListener(this);
 }
 
 void PortForwardingStatusSerializer::PortStatusChanged(
     const ForwardingStatus& status) {
   base::DictionaryValue result;
   for (ForwardingStatus::const_iterator sit = status.begin();
       sit != status.end(); ++sit) {
-    base::DictionaryValue* port_status_dict = new base::DictionaryValue();
+    auto port_status_dict = base::MakeUnique<base::DictionaryValue>();
     const PortStatusMap& port_status_map = sit->second;
     for (PortStatusMap::const_iterator it = port_status_map.begin();
          it != port_status_map.end(); ++it) {
       port_status_dict->SetInteger(base::IntToString(it->first), it->second);
     }
 
-    base::DictionaryValue* device_status_dict = new base::DictionaryValue();
-    device_status_dict->Set(kPortForwardingPorts, port_status_dict);
+    auto device_status_dict = base::MakeUnique<base::DictionaryValue>();
+    device_status_dict->Set(kPortForwardingPorts, std::move(port_status_dict));
     device_status_dict->SetString(kPortForwardingBrowserId,
                                   sit->first->GetId());
 
     std::string device_id = base::StringPrintf(
         kAdbDeviceIdFormat,
         sit->first->serial().c_str());
-    result.Set(device_id, device_status_dict);
+    result.Set(device_id, std::move(device_status_dict));
   }
   callback_.Run(result);
 }