Convert //components/[o-t]* from scoped_ptr to std::unique_ptr

components/tracing/process_metrics_memory_dump_provider.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 "components/tracing/process_metrics_memory_dump_provider.h"
 
 #include <fcntl.h>
 #include <stdint.h>
 
 #include <map>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "build/build_config.h"
 
 namespace tracing {
 
 namespace {
 
 base::LazyInstance<
-    std::map<base::ProcessId, scoped_ptr<ProcessMetricsMemoryDumpProvider>>>::
-    Leaky g_dump_providers_map = LAZY_INSTANCE_INITIALIZER;
+    std::map<base::ProcessId,
+             std::unique_ptr<ProcessMetricsMemoryDumpProvider>>>::Leaky
+    g_dump_providers_map = LAZY_INSTANCE_INITIALIZER;
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 const char kClearPeakRssCommand[] = "5";
 
 const uint32_t kMaxLineSize = 4096;
 
 bool ParseSmapsHeader(const char* header_line,
                       base::trace_event::ProcessMemoryMaps::VMRegion* region) {
   // e.g., "00400000-00421000 r-xp 00000000 fc:01 1234  /foo.so\n"
   bool res = true;  // Whether this region should be appended or skipped.
@@ skipping 105 matching lines @@
           ++num_valid_regions;
           should_add_current_region = false;
         }
       }
     }
   }
   return num_valid_regions;
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
-scoped_ptr<base::ProcessMetrics> CreateProcessMetrics(base::ProcessId process) {
+std::unique_ptr<base::ProcessMetrics> CreateProcessMetrics(
+    base::ProcessId process) {
   if (process == base::kNullProcessId)
-    return make_scoped_ptr(base::ProcessMetrics::CreateCurrentProcessMetrics());
+    return base::WrapUnique(
+        base::ProcessMetrics::CreateCurrentProcessMetrics());
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   // Just pass ProcessId instead of handle since they are the same in linux and
   // android.
-  return make_scoped_ptr(base::ProcessMetrics::CreateProcessMetrics(process));
+  return base::WrapUnique(base::ProcessMetrics::CreateProcessMetrics(process));
 #else
   // Creating process metrics for child processes in mac or windows requires
   // additional information like ProcessHandle or port provider. This is a non
   // needed use case.
   NOTREACHED();
-  return scoped_ptr<base::ProcessMetrics>();
+  return std::unique_ptr<base::ProcessMetrics>();
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 }
 
 }  // namespace
 
 // static
 uint64_t ProcessMetricsMemoryDumpProvider::rss_bytes_for_testing = 0;
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 
@@ skipping 17 matching lines @@
 
   if (res)
     pmd->set_has_process_mmaps();
   return res;
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 // static
 void ProcessMetricsMemoryDumpProvider::RegisterForProcess(
     base::ProcessId process) {
-  scoped_ptr<ProcessMetricsMemoryDumpProvider> metrics_provider(
+  std::unique_ptr<ProcessMetricsMemoryDumpProvider> metrics_provider(
       new ProcessMetricsMemoryDumpProvider(process));
   base::trace_event::MemoryDumpProvider::Options options;
   options.target_pid = process;
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       metrics_provider.get(), "ProcessMemoryMetrics", nullptr, options);
   bool did_insert =
       g_dump_providers_map.Get()
           .insert(std::make_pair(process, std::move(metrics_provider)))
           .second;
   if (!did_insert) {
@@ skipping 82 matching lines @@
 
   pmd->process_totals()->set_resident_set_bytes(rss_bytes);
   pmd->set_has_process_totals();
   pmd->process_totals()->set_peak_resident_set_bytes(peak_rss_bytes);
 
   // Returns true even if other metrics failed, since rss is reported.
   return true;
 }
 
 }  // namespace tracing