Re-write many calls to WrapUnique() with MakeUnique()

chrome/browser/chromeos/policy/device_status_collector_browsertest.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/chromeos/policy/device_status_collector.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 131 matching lines @@
     baseline_offset_periods_ = 0;
   }
 
   void set_kiosk_account(std::unique_ptr<policy::DeviceLocalAccount> account) {
     kiosk_account_ = std::move(account);
   }
 
   std::unique_ptr<policy::DeviceLocalAccount> GetAutoLaunchedKioskSessionInfo()
       override {
     if (kiosk_account_)
-      return base::WrapUnique(new policy::DeviceLocalAccount(*kiosk_account_));
+      return base::MakeUnique<policy::DeviceLocalAccount>(*kiosk_account_);
     return std::unique_ptr<policy::DeviceLocalAccount>();
   }
 
   std::string GetAppVersion(const std::string& app_id) override {
     // Just return the app_id as the version - this makes it easy for tests
     // to confirm that the correct app's version was requested.
     return app_id;
   }
 
   void RefreshSampleResourceUsage() {
@@ skipping 107 matching lines @@
         user_data_dir_override_(chrome::DIR_USER_DATA),
         update_engine_client_(new chromeos::FakeUpdateEngineClient) {
     // Run this test with a well-known timezone so that Time::LocalMidnight()
     // returns the same values on all machines.
     std::unique_ptr<base::Environment> env(base::Environment::Create());
     env->SetVar("TZ", "UTC");
 
     // Initialize our mock mounted disk volumes.
     std::unique_ptr<chromeos::disks::MockDiskMountManager>
         mock_disk_mount_manager =
-            base::WrapUnique(new chromeos::disks::MockDiskMountManager());
+            base::MakeUnique<chromeos::disks::MockDiskMountManager>();
     AddMountPoint("/mount/volume1");
     AddMountPoint("/mount/volume2");
     EXPECT_CALL(*mock_disk_mount_manager, mount_points())
         .WillRepeatedly(ReturnRef(mount_point_map_));
 
     // Setup a fake file system that should show up in mount points.
     storage::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems();
     storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
         "c", storage::kFileSystemTypeNativeLocal,
         storage::FileSystemMountOption(),
@@ skipping 748 matching lines @@
 TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfNotKioskMode) {
   // Should not report session status if we don't have an active kiosk app.
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, true);
   em::SessionStatusReportRequest session_status;
   EXPECT_FALSE(status_collector_->GetDeviceSessionStatus(&session_status));
 }
 
 TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfSessionReportingDisabled) {
   // Should not report session status if session status reporting is disabled.
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, false);
-  status_collector_->set_kiosk_account(base::WrapUnique(
-      new policy::DeviceLocalAccount(fake_device_local_account_)));
+  status_collector_->set_kiosk_account(
+      base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
   // Set up a device-local account for single-app kiosk mode.
   MockRunningKioskApp(fake_device_local_account_);
 
   em::SessionStatusReportRequest session_status;
   EXPECT_FALSE(status_collector_->GetDeviceSessionStatus(&session_status));
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportSessionStatus) {
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, true);
-  status_collector_->set_kiosk_account(base::WrapUnique(
-      new policy::DeviceLocalAccount(fake_device_local_account_)));
+  status_collector_->set_kiosk_account(
+      base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
 
   // Set up a device-local account for single-app kiosk mode.
   MockRunningKioskApp(fake_device_local_account_);
 
   em::SessionStatusReportRequest session_status;
   EXPECT_TRUE(status_collector_->GetDeviceSessionStatus(&session_status));
   ASSERT_EQ(1, session_status.installed_apps_size());
   EXPECT_EQ(kKioskAccountId, session_status.device_local_account_id());
   const em::AppStatus app = session_status.installed_apps(0);
   EXPECT_EQ(kKioskAppId, app.app_id());
@@ skipping 75 matching lines @@
   GetStatus();
   ASSERT_TRUE(status_.has_os_update_status());
   EXPECT_EQ(em::OsUpdateStatus::OS_UPDATE_NEED_REBOOT,
             status_.os_update_status().update_status());
 }
 
 TEST_F(DeviceStatusCollectorTest, NoRunningKioskAppByDefault) {
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1234.0.0");
-  status_collector_->set_kiosk_account(base::WrapUnique(
-      new policy::DeviceLocalAccount(fake_device_local_account_)));
+  status_collector_->set_kiosk_account(
+      base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
   MockRunningKioskApp(fake_device_local_account_);
 
   GetStatus();
   EXPECT_FALSE(status_.has_running_kiosk_app());
 }
 
 TEST_F(DeviceStatusCollectorTest, NoRunningKioskAppWhenNotInKioskSession) {
   settings_helper_.SetBoolean(chromeos::kReportRunningKioskApp, true);
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1234.0.0");
 
   GetStatus();
   EXPECT_FALSE(status_.has_running_kiosk_app());
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportRunningKioskApp) {
   settings_helper_.SetBoolean(chromeos::kReportRunningKioskApp, true);
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1235");
   MockRunningKioskApp(fake_device_local_account_);
-  status_collector_->set_kiosk_account(base::WrapUnique(
-      new policy::DeviceLocalAccount(fake_device_local_account_)));
+  status_collector_->set_kiosk_account(
+      base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
 
   GetStatus();
   ASSERT_TRUE(status_.has_running_kiosk_app());
   const em::AppStatus app = status_.running_kiosk_app();
   EXPECT_EQ(kKioskAppId, app.app_id());
   EXPECT_EQ("1235", app.required_platform_version());
   EXPECT_FALSE(app.has_status());
   EXPECT_FALSE(app.has_error());
 }
 
@@ skipping 259 matching lines @@
 TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NoNetworkStateIfNotKiosk) {
   // If not in an active kiosk session, there should be network interfaces
   // reported, but no network state.
   GetStatus();
   EXPECT_LT(0, status_.network_interface_size());
   EXPECT_EQ(0, status_.network_state_size());
 }
 
 TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NetworkInterfaces) {
   // Mock that we are in kiosk mode so we report network state.
-  status_collector_->set_kiosk_account(base::WrapUnique(
-      new policy::DeviceLocalAccount(fake_device_local_account_)));
+  status_collector_->set_kiosk_account(
+      base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
 
   // Interfaces should be reported by default.
   GetStatus();
   EXPECT_LT(0, status_.network_interface_size());
   EXPECT_LT(0, status_.network_state_size());
 
   // No interfaces should be reported if the policy is off.
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
   GetStatus();
   EXPECT_EQ(0, status_.network_interface_size());
@@ skipping 12 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy