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

content/browser/byte_stream.h

 // 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.
 
 #ifndef CONTENT_BROWSER_BYTE_STREAM_H_
 #define CONTENT_BROWSER_BYTE_STREAM_H_
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "content/common/content_export.h"
 #include "net/base/io_buffer.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace content {
 
 // A byte stream is a pipe to transfer bytes between a source and a
@@ skipping 32 matching lines @@
 // evaluation, so setting a null callback will guarantee that the
 // previous callback will not be executed after setting.
 //
 // Class methods are virtual to allow mocking for tests; these classes
 // aren't intended to be base classes for other classes.
 //
 // Sample usage (note that this does not show callback usage):
 //
 //    void OriginatingClass::Initialize() {
 //      // Create a stream for sending bytes from IO->FILE threads.
-//      scoped_ptr<ByteStreamWriter> writer;
-//      scoped_ptr<ByteStreamReader> reader;
+//      std::unique_ptr<ByteStreamWriter> writer;
+//      std::unique_ptr<ByteStreamReader> reader;
 //      CreateByteStream(
 //          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
 //          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
 //          kStreamBufferSize /* e.g. 10240.  */,
 //          &writer,
 //          &reader);         // Presumed passed to FILE thread for reading.
 //
 //      // Setup callback for writing.
 //      writer->RegisterCallback(base::Bind(&SpaceAvailable, this));
 //
 //      // Do initial round of writing.
 //      SpaceAvailable();
 //    }
 //
 //    // May only be run on first argument task runner, in this case the IO
 //    // thread.
 //    void OriginatingClass::SpaceAvailable() {
 //      while (<data available>) {
-//        scoped_ptr<net::IOBuffer> buffer;
+//        std::unique_ptr<net::IOBuffer> buffer;
 //        size_t buffer_length;
 //        // Create IOBuffer, fill in with data, and set buffer_length.
 //        if (!writer->Write(buffer, buffer_length)) {
 //          // No more space; return and we'll be called again
 //          // when there is space.
 //          return;
 //        }
 //      }
 //      writer->Close(<operation status>);
 //      writer.reset(NULL);
@@ skipping 94 matching lines @@
   // with data becoming available (i.e. in the case of that race
   // either of the before or after callbacks may be called).
   // The callback will not be called after ByteStreamReader destruction.
   virtual void RegisterCallback(const base::Closure& sink_callback) = 0;
 };
 
 CONTENT_EXPORT void CreateByteStream(
     scoped_refptr<base::SequencedTaskRunner> input_task_runner,
     scoped_refptr<base::SequencedTaskRunner> output_task_runner,
     size_t buffer_size,
-    scoped_ptr<ByteStreamWriter>* input,
-    scoped_ptr<ByteStreamReader>* output);
+    std::unique_ptr<ByteStreamWriter>* input,
+    std::unique_ptr<ByteStreamReader>* output);
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BYTE_STREAM_H_