Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/tracing/tracing_controller_impl.cc

 // Copyright (c) 2013 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 "content/browser/tracing/tracing_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/cpu.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/json/string_escape.h"
@@ skipping 90 matching lines @@
     case base::TimeTicks::Clock::WIN_QPC:
       return "WIN_QPC";
     case base::TimeTicks::Clock::WIN_ROLLOVER_PROTECTED_TIME_GET_TIME:
       return "WIN_ROLLOVER_PROTECTED_TIME_GET_TIME";
   }
 
   NOTREACHED();
   return std::string();
 }
 
-scoped_ptr<base::DictionaryValue> GenerateTracingMetadataDict()  {
-  scoped_ptr<base::DictionaryValue> metadata_dict(new base::DictionaryValue());
+std::unique_ptr<base::DictionaryValue> GenerateTracingMetadataDict() {
+  std::unique_ptr<base::DictionaryValue> metadata_dict(
+      new base::DictionaryValue());
 
   metadata_dict->SetString("network-type", GetNetworkTypeString());
   metadata_dict->SetString("product-version", GetContentClient()->GetProduct());
   metadata_dict->SetString("user-agent", GetContentClient()->GetUserAgent());
 
   // OS
   metadata_dict->SetString("os-name", base::SysInfo::OperatingSystemName());
   metadata_dict->SetString("os-version",
                            base::SysInfo::OperatingSystemVersion());
   metadata_dict->SetString("os-arch",
@@ skipping 28 matching lines @@
   metadata_dict->SetString("gpu-psver", gpu_info.pixel_shader_version);
   metadata_dict->SetString("gpu-vsver", gpu_info.vertex_shader_version);
 
 #if defined(OS_MACOSX)
   metadata_dict->SetString("gpu-glver", gpu_info.gl_version);
 #elif defined(OS_POSIX)
   metadata_dict->SetString("gpu-gl-vendor", gpu_info.gl_vendor);
   metadata_dict->SetString("gpu-gl-renderer", gpu_info.gl_renderer);
 #endif
 
-  scoped_ptr<TracingDelegate> delegate(
+  std::unique_ptr<TracingDelegate> delegate(
       GetContentClient()->browser()->GetTracingDelegate());
   if (delegate)
     delegate->GenerateMetadataDict(metadata_dict.get());
 
   metadata_dict->SetString("clock-domain", GetClockString());
   metadata_dict->SetBoolean("highres-ticks",
                             base::TimeTicks::IsHighResolution());
 
   return metadata_dict;
 }
@@ skipping 169 matching lines @@
         FROM_HERE,
         base::Bind(base::IgnoreResult(&TracingControllerImpl::StopTracing),
                    base::Unretained(this), trace_data_sink),
         base::TimeDelta::FromMilliseconds(kStopTracingRetryTimeMilliseconds));
     return true;
   }
 
   if (trace_data_sink) {
     if (TraceLog::GetInstance()->GetCurrentTraceConfig()
         .IsArgumentFilterEnabled()) {
-      scoped_ptr<TracingDelegate> delegate(
+      std::unique_ptr<TracingDelegate> delegate(
           GetContentClient()->browser()->GetTracingDelegate());
       if (delegate) {
         trace_data_sink->SetMetadataFilterPredicate(
             delegate->GetMetadataFilterPredicate());
       }
     }
     trace_data_sink->AddMetadata(*GenerateTracingMetadataDict().get());
   }
 
   trace_data_sink_ = trace_data_sink;
@@ skipping 663 matching lines @@
   const bool global_success = failed_memory_dump_count_ == 0;
   if (!pending_memory_dump_callback_.is_null()) {
     pending_memory_dump_callback_.Run(pending_memory_dump_guid_,
                                       global_success);
     pending_memory_dump_callback_.Reset();
   }
   pending_memory_dump_guid_ = 0;
 }
 
 }  // namespace content