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

content/browser/tracing/tracing_controller_impl_data_sinks.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 <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/strings/pattern.h"
 #include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/zlib/zlib.h"
 
 namespace content {
 
 namespace {
 
 const char kChromeTraceLabel[] = "traceEvents";
 const char kMetadataTraceLabel[] = "metadata";
 
 class StringTraceDataEndpoint : public TracingController::TraceDataEndpoint {
  public:
-  typedef base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                              base::RefCountedString*)> CompletionCallback;
+  typedef base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                              base::RefCountedString*)>
+      CompletionCallback;
 
   explicit StringTraceDataEndpoint(CompletionCallback callback)
       : completion_callback_(callback) {}
 
   void ReceiveTraceFinalContents(
-      scoped_ptr<const base::DictionaryValue> metadata,
+      std::unique_ptr<const base::DictionaryValue> metadata,
       const std::string& contents) override {
     std::string tmp = contents;
     scoped_refptr<base::RefCountedString> str =
         base::RefCountedString::TakeString(&tmp);
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(completion_callback_, base::Passed(std::move(metadata)),
                    base::RetainedRef(str)));
   }
@@ skipping 17 matching lines @@
   void ReceiveTraceChunk(const std::string& chunk) override {
     std::string tmp = chunk;
     scoped_refptr<base::RefCountedString> chunk_ptr =
         base::RefCountedString::TakeString(&tmp);
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&FileTraceDataEndpoint::ReceiveTraceChunkOnFileThread, this,
                    chunk_ptr));
   }
 
-  void ReceiveTraceFinalContents(
-      scoped_ptr<const base::DictionaryValue> ,
-      const std::string& contents) override {
+  void ReceiveTraceFinalContents(std::unique_ptr<const base::DictionaryValue>,
+                                 const std::string& contents) override {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&FileTraceDataEndpoint::CloseOnFileThread, this));
   }
 
  private:
   ~FileTraceDataEndpoint() override { DCHECK(file_ == NULL); }
 
   void ReceiveTraceChunkOnFileThread(
       const scoped_refptr<base::RefCountedString> chunk) {
@@ skipping 199 matching lines @@
     AddTraceChunkAndCompressOnFileThread("}", true);
 
     deflateEnd(stream_.get());
     stream_.reset();
 
     endpoint_->ReceiveTraceFinalContents(GetMetadataCopy(),
                                          compressed_trace_data_);
   }
 
   scoped_refptr<TracingController::TraceDataEndpoint> endpoint_;
-  scoped_ptr<z_stream> stream_;
+  std::unique_ptr<z_stream> stream_;
   bool already_tried_open_;
   std::string compressed_trace_data_;
 
   DISALLOW_COPY_AND_ASSIGN(CompressedStringTraceDataSink);
 };
 
 }  // namespace
 
 TracingController::TraceDataSink::TraceDataSink() {}
 
@@ skipping 15 matching lines @@
 void TracingController::TraceDataSink::AddMetadata(
     const base::DictionaryValue& data) {
   metadata_.MergeDictionary(&data);
 }
 
 void TracingController::TraceDataSink::SetMetadataFilterPredicate(
     const MetadataFilterPredicate& metadata_filter_predicate) {
   metadata_filter_predicate_ = metadata_filter_predicate;
 }
 
-scoped_ptr<const base::DictionaryValue>
-    TracingController::TraceDataSink::GetMetadataCopy() const {
+std::unique_ptr<const base::DictionaryValue>
+TracingController::TraceDataSink::GetMetadataCopy() const {
   if (metadata_filter_predicate_.is_null())
-    return scoped_ptr<const base::DictionaryValue>(metadata_.DeepCopy());
+    return std::unique_ptr<const base::DictionaryValue>(metadata_.DeepCopy());
 
-  scoped_ptr<base::DictionaryValue> metadata_copy(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> metadata_copy(
+      new base::DictionaryValue);
   for (base::DictionaryValue::Iterator it(metadata_); !it.IsAtEnd();
        it.Advance()) {
     if (metadata_filter_predicate_.Run(it.key()))
       metadata_copy->Set(it.key(), it.value().DeepCopy());
     else
       metadata_copy->SetString(it.key(), "__stripped__");
   }
   return std::move(metadata_copy);
 }
 
 scoped_refptr<TracingController::TraceDataSink>
 TracingController::CreateStringSink(
-    const base::Callback<void(scoped_ptr<const base::DictionaryValue>,
+    const base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
                               base::RefCountedString*)>& callback) {
   return new StringTraceDataSink(new StringTraceDataEndpoint(callback));
 }
 
 scoped_refptr<TracingController::TraceDataSink>
 TracingController::CreateCompressedStringSink(
     scoped_refptr<TracingController::TraceDataEndpoint> endpoint) {
   return new CompressedStringTraceDataSink(endpoint);
 }
 
 scoped_refptr<TracingController::TraceDataSink>
 TracingController::CreateFileSink(const base::FilePath& file_path,
                                   const base::Closure& callback) {
   return new StringTraceDataSink(
       CreateFileEndpoint(file_path, callback));
 }
 
 scoped_refptr<TracingController::TraceDataEndpoint>
-TracingController::CreateCallbackEndpoint(const base::Callback<
-    void(scoped_ptr<const base::DictionaryValue>,
-         base::RefCountedString*)>& callback) {
+TracingController::CreateCallbackEndpoint(
+    const base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                              base::RefCountedString*)>& callback) {
   return new StringTraceDataEndpoint(callback);
 }
 
 scoped_refptr<TracingController::TraceDataEndpoint>
 TracingController::CreateFileEndpoint(const base::FilePath& file_path,
                                       const base::Closure& callback) {
   return new FileTraceDataEndpoint(file_path, callback);
 }
 
 }  // namespace content