NetworkStateHandler::InitializeForTest() should return a std::unique_ptr.

chromeos/network/network_state_handler.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 "chromeos/network/network_state_handler.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 67 matching lines @@
 }
 
 void NetworkStateHandler::Shutdown() {
   DCHECK(!did_shutdown_);
   did_shutdown_ = true;
   for (auto& observer : observers_)
     observer.OnShuttingDown();
 }
 
 void NetworkStateHandler::InitShillPropertyHandler() {
-  shill_property_handler_.reset(new internal::ShillPropertyHandler(this));
+  shill_property_handler_ =
+      base::MakeUnique<internal::ShillPropertyHandler>(this);
   shill_property_handler_->Init();
 }
 
 // static
-NetworkStateHandler* NetworkStateHandler::InitializeForTest() {
-  NetworkStateHandler* handler = new NetworkStateHandler();
+std::unique_ptr<NetworkStateHandler> NetworkStateHandler::InitializeForTest() {
+  auto handler = base::WrapUnique(new NetworkStateHandler());

[stevenjb, 2016/11/04 16:31:37]

My understanding is that MakeUnique<NetworkStateHandler>() is preferred here?

[Lei Zhang, 2016/11/04 18:30:37]

First thing I tried, but the ctor is private.

[stevenjb, 2016/11/04 18:33:31]

Ah, right, I remember that part of the discussion now. OK, cheers.

   handler->InitShillPropertyHandler();
   return handler;
 }
 
 void NetworkStateHandler::AddObserver(
     NetworkStateHandlerObserver* observer,
     const tracked_objects::Location& from_here) {
   observers_.AddObserver(observer);
   device_event_log::AddEntry(
       from_here.file_name(), from_here.line_number(),
@@ skipping 148 matching lines @@
     if (!network->visible())
       break;
     if (network->Matches(type))
       return network;
   }
   return nullptr;
 }
 
 std::string NetworkStateHandler::FormattedHardwareAddressForType(
     const NetworkTypePattern& type) const {
-  const DeviceState* device = nullptr;
   const NetworkState* network = ConnectedNetworkByType(type);
-  if (network)
-    device = GetDeviceState(network->device_path());
-  else
-    device = GetDeviceStateByType(type);
+  const DeviceState* device = network ? GetDeviceState(network->device_path())
+                                      : GetDeviceStateByType(type);
   if (!device)
     return std::string();
   return network_util::FormattedMacAddress(device->mac_address());
 }
 
 void NetworkStateHandler::GetVisibleNetworkListByType(
     const NetworkTypePattern& type,
     NetworkStateList* list) {
   GetNetworkListByType(type, false /* configured_only */,
                        true /* visible_only */, 0 /* no limit */, list);
@@ skipping 707 matching lines @@
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.emplace_back(shill::kTypeBluetooth);
   if (type.MatchesType(shill::kTypeVPN))
     technologies.emplace_back(shill::kTypeVPN);
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies;
 }
 
 }  // namespace chromeos