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

chrome/browser/chromeos/policy/device_status_collector.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 <sys/statvfs.h>
+
 #include <cstdio>
 #include <limits>
+#include <memory>
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
@@ skipping 173 matching lines @@
       }
     }
   }
   return contents;
 }
 
 // Returns the DeviceLocalAccount associated with the current kiosk session.
 // Returns null if there is no active kiosk session, or if that kiosk
 // session has been removed from policy since the session started, in which
 // case we won't report its status).
-scoped_ptr<policy::DeviceLocalAccount>
-GetCurrentKioskDeviceLocalAccount(chromeos::CrosSettings* settings) {
+std::unique_ptr<policy::DeviceLocalAccount> GetCurrentKioskDeviceLocalAccount(
+    chromeos::CrosSettings* settings) {
   if (!user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
-    return scoped_ptr<policy::DeviceLocalAccount>();
+    return std::unique_ptr<policy::DeviceLocalAccount>();
   const user_manager::User* const user =
       user_manager::UserManager::Get()->GetActiveUser();
   const std::vector<policy::DeviceLocalAccount> accounts =
       policy::GetDeviceLocalAccounts(settings);
 
   for (const auto& device_local_account : accounts) {
     if (AccountId::FromUserEmail(device_local_account.user_id) ==
         user->GetAccountId()) {
-      return make_scoped_ptr(
+      return base::WrapUnique(
           new policy::DeviceLocalAccount(device_local_account));
     }
   }
   LOG(WARNING) << "Kiosk app not found in list of device-local accounts";
-  return scoped_ptr<policy::DeviceLocalAccount>();
+  return std::unique_ptr<policy::DeviceLocalAccount>();
 }
 
 }  // namespace
 
 namespace policy {
 
 DeviceStatusCollector::DeviceStatusCollector(
     PrefService* local_state,
     chromeos::system::StatisticsProvider* provider,
     const LocationUpdateRequester& location_update_requester,
@@ skipping 204 matching lines @@
   TrimStoredActivityPeriods(TimestampToDayKey(min_time), 0,
                             TimestampToDayKey(max_time));
 }
 
 void DeviceStatusCollector::TrimStoredActivityPeriods(int64_t min_day_key,
                                                       int min_day_trim_duration,
                                                       int64_t max_day_key) {
   const base::DictionaryValue* activity_times =
       local_state_->GetDictionary(prefs::kDeviceActivityTimes);
 
-  scoped_ptr<base::DictionaryValue> copy(activity_times->DeepCopy());
+  std::unique_ptr<base::DictionaryValue> copy(activity_times->DeepCopy());
   for (base::DictionaryValue::Iterator it(*activity_times); !it.IsAtEnd();
        it.Advance()) {
     int64_t timestamp;
     if (base::StringToInt64(it.key(), &timestamp)) {
       // Remove data that is too old, or too far in the future.
       if (timestamp >= min_day_key && timestamp < max_day_key) {
         if (timestamp == min_day_key) {
           int new_activity_duration = 0;
           if (it.value().GetAsInteger(&new_activity_duration)) {
             new_activity_duration =
@@ skipping 55 matching lines @@
                       now);
     } else {
       AddActivePeriod(last_idle_check_, now);
     }
 
     PruneStoredActivityPeriods(now);
   }
   last_idle_check_ = now;
 }
 
-scoped_ptr<DeviceLocalAccount>
+std::unique_ptr<DeviceLocalAccount>
 DeviceStatusCollector::GetAutoLaunchedKioskSessionInfo() {
-  scoped_ptr<DeviceLocalAccount> account =
+  std::unique_ptr<DeviceLocalAccount> account =
       GetCurrentKioskDeviceLocalAccount(cros_settings_);
   if (account) {
     chromeos::KioskAppManager::App current_app;
     if (chromeos::KioskAppManager::Get()->GetApp(account->kiosk_app_id,
                                                  &current_app) &&
         current_app.was_auto_launched_with_zero_delay) {
       return account;
     }
   }
   // No auto-launched kiosk session active.
-  return scoped_ptr<DeviceLocalAccount>();
+  return std::unique_ptr<DeviceLocalAccount>();
 }
 
 void DeviceStatusCollector::SampleHardwareStatus() {
   // If hardware reporting has been disabled, do nothing here.
   if (!report_hardware_status_)
     return;
 
   // Create list of mounted disk volumes to query status.
   std::vector<storage::MountPoints::MountPointInfo> external_mount_points;
   storage::ExternalMountPoints::GetSystemInstance()->AddMountPointInfosTo(
@@ skipping 376 matching lines @@
           report_hardware_status_);
 }
 
 bool DeviceStatusCollector::GetDeviceSessionStatus(
     em::SessionStatusReportRequest* status) {
   // Only generate session status reports if session status reporting is
   // enabled.
   if (!report_session_status_)
     return false;
 
-  scoped_ptr<const DeviceLocalAccount> account =
+  std::unique_ptr<const DeviceLocalAccount> account =
       GetAutoLaunchedKioskSessionInfo();
   // Only generate session status reports if we are in an auto-launched kiosk
   // session.
   if (!account)
     return false;
 
   // Get the account ID associated with this user.
   status->set_device_local_account_id(account->account_id);
   em::AppStatus* app_status = status->add_installed_apps();
   app_status->set_app_id(account->kiosk_app_id);
@@ skipping 94 matching lines @@
   ScheduleGeolocationUpdateRequest();
 }
 
 void DeviceStatusCollector::ReceiveVolumeInfo(
     const std::vector<em::VolumeInfo>& info) {
   if (report_hardware_status_)
     volume_info_ = info;
 }
 
 }  // namespace policy