Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

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>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/ownership/fake_owner_settings_service.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/stub_enterprise_install_attributes.h"
@@ skipping 36 matching lines @@
 namespace em = enterprise_management;
 
 namespace {
 
 const int64_t kMillisecondsPerDay = Time::kMicrosecondsPerDay / 1000;
 const char kKioskAccountId[] = "kiosk_user@localhost";
 const char kKioskAppId[] = "kiosk_app_id";
 const char kExternalMountPoint[] = "/a/b/c";
 const char kPublicAccountId[] = "public_user@localhost";
 
-scoped_ptr<content::Geoposition> mock_position_to_return_next;
+std::unique_ptr<content::Geoposition> mock_position_to_return_next;
 
 void SetMockPositionToReturnNext(const content::Geoposition &position) {
   mock_position_to_return_next.reset(new content::Geoposition(position));
 }
 
 void MockPositionUpdateRequester(
     const content::GeolocationProvider::LocationUpdateCallback& callback) {
   if (!mock_position_to_return_next.get())
     return;
 
   // If the fix is invalid, the DeviceStatusCollector will immediately request
   // another update when it receives the callback. This is desirable and safe in
   // real life where geolocation updates arrive asynchronously. In this testing
   // harness, the callback is invoked synchronously upon request, leading to a
   // request-callback loop. The loop is broken by returning the mock position
   // only once.
-  scoped_ptr<content::Geoposition> position(
+  std::unique_ptr<content::Geoposition> position(
       mock_position_to_return_next.release());
   callback.Run(*position);
 }
 
 class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
  public:
   TestingDeviceStatusCollector(
       PrefService* local_state,
       chromeos::system::StatisticsProvider* provider,
       const policy::DeviceStatusCollector::LocationUpdateRequester&
@@ skipping 25 matching lines @@
   void set_max_stored_future_activity_days(unsigned int value) {
     max_stored_future_activity_days_ = value;
   }
 
   // Reset the baseline time.
   void SetBaselineTime(Time time) {
     baseline_time_ = time;
     baseline_offset_periods_ = 0;
   }
 
-  void set_kiosk_account(scoped_ptr<policy::DeviceLocalAccount> account) {
+  void set_kiosk_account(std::unique_ptr<policy::DeviceLocalAccount> account) {
     kiosk_account_ = std::move(account);
   }
 
-  scoped_ptr<policy::DeviceLocalAccount>
-  GetAutoLaunchedKioskSessionInfo() override {
+  std::unique_ptr<policy::DeviceLocalAccount> GetAutoLaunchedKioskSessionInfo()
+      override {
     if (kiosk_account_)
-      return make_scoped_ptr(new policy::DeviceLocalAccount(*kiosk_account_));
-    return scoped_ptr<policy::DeviceLocalAccount>();
+      return base::WrapUnique(new 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() {
     SampleHardwareStatus();
@@ skipping 14 matching lines @@
         TimeDelta::FromSeconds(poll_interval * baseline_offset_periods_++);
   }
 
  private:
   // Baseline time for the fake times returned from GetCurrentTime().
   Time baseline_time_;
 
   // The number of simulated periods since the baseline time.
   int baseline_offset_periods_;
 
-  scoped_ptr<policy::DeviceLocalAccount> kiosk_account_;
+  std::unique_ptr<policy::DeviceLocalAccount> kiosk_account_;
 };
 
 // Return the total number of active milliseconds contained in a device
 // status report.
 int64_t GetActiveMilliseconds(em::DeviceStatusReportRequest& status) {
   int64_t active_milliseconds = 0;
   for (int i = 0; i < status.active_period_size(); i++) {
     active_milliseconds += status.active_period(i).active_duration();
   }
   return active_milliseconds;
@@ skipping 63 matching lines @@
                             DEVICE_MODE_ENTERPRISE),
         settings_helper_(false),
         user_manager_(new chromeos::MockUserManager()),
         user_manager_enabler_(user_manager_),
         fake_device_local_account_(policy::DeviceLocalAccount::TYPE_KIOSK_APP,
                                    kKioskAccountId,
                                    kKioskAppId,
                                    std::string() /* kiosk_app_update_url */) {
     // Run this test with a well-known timezone so that Time::LocalMidnight()
     // returns the same values on all machines.
-    scoped_ptr<base::Environment> env(base::Environment::Create());
+    std::unique_ptr<base::Environment> env(base::Environment::Create());
     env->SetVar("TZ", "UTC");
 
     // Initialize our mock mounted disk volumes.
-    scoped_ptr<chromeos::disks::MockDiskMountManager> mock_disk_mount_manager =
-        make_scoped_ptr(new chromeos::disks::MockDiskMountManager());
+    std::unique_ptr<chromeos::disks::MockDiskMountManager>
+        mock_disk_mount_manager =
+            base::WrapUnique(new 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 122 matching lines @@
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
 
   ScopedStubEnterpriseInstallAttributes install_attributes_;
   TestingPrefServiceSimple prefs_;
   chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   DiskMountManager::MountPointMap mount_point_map_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedCrosSettingsTestHelper settings_helper_;
-  scoped_ptr<chromeos::FakeOwnerSettingsService> owner_settings_service_;
+  std::unique_ptr<chromeos::FakeOwnerSettingsService> owner_settings_service_;
   chromeos::MockUserManager* user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   em::DeviceStatusReportRequest status_;
-  scoped_ptr<TestingDeviceStatusCollector> status_collector_;
+  std::unique_ptr<TestingDeviceStatusCollector> status_collector_;
   const policy::DeviceLocalAccount fake_device_local_account_;
 };
 
 TEST_F(DeviceStatusCollectorTest, AllIdle) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE
   };
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
@@ skipping 552 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(make_scoped_ptr(
+  status_collector_->set_kiosk_account(base::WrapUnique(
       new 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(make_scoped_ptr(
+  status_collector_->set_kiosk_account(base::WrapUnique(
       new 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);
@@ skipping 266 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(make_scoped_ptr(
+  status_collector_->set_kiosk_account(base::WrapUnique(
       new 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();
@@ skipping 13 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy