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

chrome/browser/chromeos/drive/drive_file_stream_reader.h

 // Copyright 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_STREAM_READER_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_STREAM_READER_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/threading/thread_checker.h"
 #include "components/drive/file_errors.h"
 #include "google_apis/drive/drive_api_error_codes.h"
 #include "net/base/completion_callback.h"
 
 namespace base {
 class SequencedTaskRunner;
 }  // namespace base
 
@@ skipping 14 matching lines @@
 // file is being downloaded from the server), NetworkReaderProxy will be used.
 class ReaderProxy {
  public:
   virtual ~ReaderProxy() {}
 
   // Called from DriveFileStreamReader::Read method.
   virtual int Read(net::IOBuffer* buffer, int buffer_length,
                    const net::CompletionCallback& callback) = 0;
 
   // Called when the data from the server is received.
-  virtual void OnGetContent(scoped_ptr<std::string> data) = 0;
+  virtual void OnGetContent(std::unique_ptr<std::string> data) = 0;
 
   // Called when the accessing to the file system is completed.
   virtual void OnCompleted(FileError error) = 0;
 };
 
 // The read operation implementation for the locally cached files.
 class LocalReaderProxy : public ReaderProxy {
  public:
   // The |file_reader| should be the instance which is already opened.
   // This class takes its ownership.
   // |length| is the number of bytes to be read. It must be equal or
   // smaller than the remaining data size in the |file_reader|.
-  LocalReaderProxy(scoped_ptr<util::LocalFileReader> file_reader,
+  LocalReaderProxy(std::unique_ptr<util::LocalFileReader> file_reader,
                    int64_t length);
   ~LocalReaderProxy() override;
 
   // ReaderProxy overrides.
   int Read(net::IOBuffer* buffer,
            int buffer_length,
            const net::CompletionCallback& callback) override;
-  void OnGetContent(scoped_ptr<std::string> data) override;
+  void OnGetContent(std::unique_ptr<std::string> data) override;
   void OnCompleted(FileError error) override;
 
  private:
-  scoped_ptr<util::LocalFileReader> file_reader_;
+  std::unique_ptr<util::LocalFileReader> file_reader_;
 
   // Callback for the LocalFileReader::Read.
   void OnReadCompleted(
       const net::CompletionCallback& callback, int read_result);
 
   // The number of remaining bytes to be read.
   int64_t remaining_length_;
 
   base::ThreadChecker thread_checker_;
 
@@ skipping 13 matching lines @@
   NetworkReaderProxy(int64_t offset,
                      int64_t content_length,
                      int64_t full_content_length,
                      const base::Closure& job_canceller);
   ~NetworkReaderProxy() override;
 
   // ReaderProxy overrides.
   int Read(net::IOBuffer* buffer,
            int buffer_length,
            const net::CompletionCallback& callback) override;
-  void OnGetContent(scoped_ptr<std::string> data) override;
+  void OnGetContent(std::unique_ptr<std::string> data) override;
   void OnCompleted(FileError error) override;
 
  private:
   // The data received from the server, but not yet read.
   ScopedVector<std::string> pending_data_;
 
   // The number of bytes to be skipped.
   int64_t remaining_offset_;
 
   // The number of bytes of remaining data (including the data not yet
@@ skipping 33 matching lines @@
 class DriveFileStreamReader {
  public:
   // Callback to return the FileSystemInterface instance. This is an
   // injecting point for testing.
   // Note that the callback will be copied between threads (IO and UI), and
   // will be called on UI thread.
   typedef base::Callback<FileSystemInterface*()> FileSystemGetter;
 
   // Callback to return the result of Initialize().
   // |error| is net::Error code.
-  typedef base::Callback<void(int error, scoped_ptr<ResourceEntry> entry)>
+  typedef base::Callback<void(int error, std::unique_ptr<ResourceEntry> entry)>
       InitializeCompletionCallback;
 
   DriveFileStreamReader(const FileSystemGetter& file_system_getter,
                         base::SequencedTaskRunner* file_task_runner);
   ~DriveFileStreamReader();
 
   // Returns true if the reader is initialized.
   bool IsInitialized() const;
 
   // Initializes the stream for the |drive_file_path|.
@@ skipping 17 matching lines @@
   // Used to store the cancel closure returned by FileSystemInterface.
   void StoreCancelDownloadClosure(const base::Closure& cancel_download_closure);
 
   // Part of Initialize. Called after GetFileContent's initialization
   // is done.
   void InitializeAfterGetFileContentInitialized(
       const net::HttpByteRange& byte_range,
       const InitializeCompletionCallback& callback,
       FileError error,
       const base::FilePath& local_cache_file_path,
-      scoped_ptr<ResourceEntry> entry);
+      std::unique_ptr<ResourceEntry> entry);
 
   // Part of Initialize. Called when the local file open process is done.
   void InitializeAfterLocalFileOpen(
       int64_t length,
       const InitializeCompletionCallback& callback,
-      scoped_ptr<ResourceEntry> entry,
-      scoped_ptr<util::LocalFileReader> file_reader,
+      std::unique_ptr<ResourceEntry> entry,
+      std::unique_ptr<util::LocalFileReader> file_reader,
       int open_result);
 
   // Called when the data is received from the server.
   void OnGetContent(google_apis::DriveApiErrorCode error_code,
-                    scoped_ptr<std::string> data);
+                    std::unique_ptr<std::string> data);
 
   // Called when GetFileContent is completed.
   void OnGetFileContentCompletion(
       const InitializeCompletionCallback& callback,
       FileError error);
 
   const FileSystemGetter file_system_getter_;
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
   base::Closure cancel_download_closure_;
-  scoped_ptr<internal::ReaderProxy> reader_proxy_;
+  std::unique_ptr<internal::ReaderProxy> reader_proxy_;
 
   base::ThreadChecker thread_checker_;
 
   // This should remain the last member so it'll be destroyed first and
   // invalidate its weak pointers before other members are destroyed.
   base::WeakPtrFactory<DriveFileStreamReader> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveFileStreamReader);
 };
 
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_STREAM_READER_H_