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

chrome/browser/chromeos/resource_reporter/resource_reporter.cc

 // Copyright 2015 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/resource_reporter/resource_reporter.h"
 
 #include <cstdint>
 #include <queue>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/task_management/task_manager_interface.h"
 #include "components/rappor/rappor_service.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
 
@@ skipping 174 matching lines @@
         last_gpu_process_cpu_ = cpu_usage;
         last_gpu_process_memory_ = memory_usage >= 0 ? memory_usage : 0;
         break;
 
       default:
         // Other tasks types will be reported using Rappor.
         TaskRecord* task_data = nullptr;
         auto itr = task_records_.find(id);
         if (itr == task_records_.end()) {
           task_data = new TaskRecord(id);
-          task_records_[id] = make_scoped_ptr(task_data);
+          task_records_[id] = base::WrapUnique(task_data);
         } else {
           task_data = itr->second.get();
         }
 
         DCHECK_EQ(task_data->id, id);
         task_data->task_name_for_rappor =
             observed_task_manager()->GetTaskNameForRappor(id);
         task_data->cpu_percent = cpu_usage;
         task_data->memory_bytes = memory_usage;
         task_data->is_background =
@@ skipping 28 matching lines @@
 
 ResourceReporter::ResourceReporter()
     : TaskManagerObserver(base::TimeDelta::FromSeconds(kRefreshIntervalSeconds),
                           task_management::REFRESH_TYPE_CPU |
                               task_management::REFRESH_TYPE_MEMORY |
                                   task_management::REFRESH_TYPE_PRIORITY),
       system_cpu_cores_range_(GetCurrentSystemCpuCoresRange()) {
 }
 
 // static
-scoped_ptr<rappor::Sample> ResourceReporter::CreateRapporSample(
+std::unique_ptr<rappor::Sample> ResourceReporter::CreateRapporSample(
     rappor::RapporService* rappor_service,
     const ResourceReporter::TaskRecord& task_record) {
-  scoped_ptr<rappor::Sample> sample(rappor_service->CreateSample(
-      rappor::UMA_RAPPOR_TYPE));
+  std::unique_ptr<rappor::Sample> sample(
+      rappor_service->CreateSample(rappor::UMA_RAPPOR_TYPE));
   sample->SetStringField(kRapporTaskStringField,
                          task_record.task_name_for_rappor);
   sample->SetFlagsField(kRapporPriorityFlagsField,
                         task_record.is_background ?
                             GET_ENUM_VAL(TaskProcessPriority::BACKGROUND) :
                             GET_ENUM_VAL(TaskProcessPriority::FOREGROUND),
                         GET_ENUM_VAL(TaskProcessPriority::NUM_PRIORITIES));
   return sample;
 }
 
@@ skipping 123 matching lines @@
         base::TimeDelta::FromMilliseconds(kMinimumTimeBetweenReportsInMs)) {
       return;
     }
 
     last_memory_pressure_event_time_ = base::TimeTicks::Now();
 
     // Use weighted random sampling to select a task to report in the CPU
     // metric.
     const TaskRecord* sampled_cpu_task = SampleTaskByCpu();
     if (sampled_cpu_task) {
-      scoped_ptr<rappor::Sample> cpu_sample(
+      std::unique_ptr<rappor::Sample> cpu_sample(
           CreateRapporSample(rappor_service, *sampled_cpu_task));
       cpu_sample->SetFlagsField(kRapporNumCoresRangeFlagsField,
                                 GET_ENUM_VAL(system_cpu_cores_range_),
                                 GET_ENUM_VAL(CpuCoresNumberRange::NUM_RANGES));
       cpu_sample->SetFlagsField(
           kRapporUsageRangeFlagsField,
           GET_ENUM_VAL(GetCpuUsageRange(sampled_cpu_task->cpu_percent)),
           GET_ENUM_VAL(CpuUsageRange::NUM_RANGES));
       rappor_service->RecordSampleObj(kCpuRapporMetric, std::move(cpu_sample));
     }
 
     // Use weighted random sampling to select a task to report in the memory
     // metric.
     const TaskRecord* sampled_memory_task = SampleTaskByMemory();
     if (sampled_memory_task) {
-      scoped_ptr<rappor::Sample> memory_sample(
+      std::unique_ptr<rappor::Sample> memory_sample(
           CreateRapporSample(rappor_service, *sampled_memory_task));
       memory_sample->SetFlagsField(
           kRapporUsageRangeFlagsField,
           GET_ENUM_VAL(GetMemoryUsageRange(sampled_memory_task->memory_bytes)),
           GET_ENUM_VAL(MemoryUsageRange::NUM_RANGES));
       rappor_service->RecordSampleObj(kMemoryRapporMetric,
                                       std::move(memory_sample));
     }
   }
 }
 
 }  // namespace chromeos