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

chrome/browser/chromeos/drive/drive_file_stream_reader.cc

 // 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.
 
 #include "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <cstring>
 #include <utility>
@@ skipping 78 matching lines @@
 
   // Consume the copied data.
   pending_data->erase(pending_data->begin(), pending_data->begin() + index);
 
   return offset;
 }
 
 }  // namespace
 
 LocalReaderProxy::LocalReaderProxy(
-    scoped_ptr<util::LocalFileReader> file_reader,
+    std::unique_ptr<util::LocalFileReader> file_reader,
     int64_t length)
     : file_reader_(std::move(file_reader)),
       remaining_length_(length),
       weak_ptr_factory_(this) {
   DCHECK(file_reader_);
 }
 
 LocalReaderProxy::~LocalReaderProxy() {
 }
 
 int LocalReaderProxy::Read(net::IOBuffer* buffer, int buffer_length,
                            const net::CompletionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(file_reader_);
 
   if (buffer_length > remaining_length_) {
     // Here, narrowing is safe.
     buffer_length = static_cast<int>(remaining_length_);
   }
 
   if (!buffer_length)
     return 0;
 
   file_reader_->Read(buffer, buffer_length,
                      base::Bind(&LocalReaderProxy::OnReadCompleted,
                                 weak_ptr_factory_.GetWeakPtr(), callback));
   return net::ERR_IO_PENDING;
 }
 
-void LocalReaderProxy::OnGetContent(scoped_ptr<std::string> data) {
+void LocalReaderProxy::OnGetContent(std::unique_ptr<std::string> data) {
   // This method should never be called, because no data should be received
   // from the network during the reading of local-cache file.
   NOTREACHED();
 }
 
 void LocalReaderProxy::OnCompleted(FileError error) {
   // If this method is called, no network error should be happened.
   DCHECK_EQ(FILE_ERROR_OK, error);
 }
 
@@ skipping 71 matching lines @@
 
   // Although OnCompleted() should reset |job_canceller_| when download is done,
   // due to timing issues the ReaderProxy instance may be destructed before the
   // notification. To fix the case we reset here earlier.
   if (is_full_download_ && remaining_content_length_ == 0)
     job_canceller_.Reset();
 
   return result;
 }
 
-void NetworkReaderProxy::OnGetContent(scoped_ptr<std::string> data) {
+void NetworkReaderProxy::OnGetContent(std::unique_ptr<std::string> data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(data && !data->empty());
 
   if (remaining_offset_ >= static_cast<int64_t>(data->length())) {
     // Skip unneeded leading data.
     remaining_offset_ -= data->length();
     return;
   }
 
   if (remaining_offset_ > 0) {
@@ skipping 149 matching lines @@
     const base::Closure& cancel_download_closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cancel_download_closure_ = cancel_download_closure;
 }
 
 void DriveFileStreamReader::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) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // StoreCancelDownloadClosure() should be called before this function.
   DCHECK(!cancel_download_closure_.is_null());
 
   if (error != FILE_ERROR_OK) {
-    callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
+    callback.Run(FileErrorToNetError(error), std::unique_ptr<ResourceEntry>());
     return;
   }
   DCHECK(entry);
 
   int64_t range_start = 0, range_length = 0;
   if (!ComputeConcretePosition(byte_range, entry->file_info().size(),
                                &range_start, &range_length)) {
     // If |byte_range| is invalid (e.g. out of bounds), return with an error.
     // At the same time, we cancel the in-flight downloading operation if
     // needed and and invalidate weak pointers so that we won't
     // receive unwanted callbacks.
     cancel_download_closure_.Run();
     weak_ptr_factory_.InvalidateWeakPtrs();
-    callback.Run(
-        net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, scoped_ptr<ResourceEntry>());
+    callback.Run(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE,
+                 std::unique_ptr<ResourceEntry>());
     return;
   }
 
   if (local_cache_file_path.empty()) {
     // The file is not cached, and being downloaded.
     reader_proxy_.reset(
         new internal::NetworkReaderProxy(
             range_start, range_length,
             entry->file_info().size(), cancel_download_closure_));
     callback.Run(net::OK, std::move(entry));
     return;
   }
 
   // Otherwise, open the stream for file.
-  scoped_ptr<util::LocalFileReader> file_reader(
+  std::unique_ptr<util::LocalFileReader> file_reader(
       new util::LocalFileReader(file_task_runner_.get()));
   util::LocalFileReader* file_reader_ptr = file_reader.get();
   file_reader_ptr->Open(
       local_cache_file_path,
       range_start,
       base::Bind(
           &DriveFileStreamReader::InitializeAfterLocalFileOpen,
           weak_ptr_factory_.GetWeakPtr(),
           range_length,
           callback,
           base::Passed(&entry),
           base::Passed(&file_reader)));
 }
 
 void DriveFileStreamReader::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) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (open_result != net::OK) {
-    callback.Run(net::ERR_FAILED, scoped_ptr<ResourceEntry>());
+    callback.Run(net::ERR_FAILED, std::unique_ptr<ResourceEntry>());
     return;
   }
 
   reader_proxy_.reset(
       new internal::LocalReaderProxy(std::move(file_reader), length));
   callback.Run(net::OK, std::move(entry));
 }
 
 void DriveFileStreamReader::OnGetContent(
     google_apis::DriveApiErrorCode error_code,
-    scoped_ptr<std::string> data) {
+    std::unique_ptr<std::string> data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(reader_proxy_);
   reader_proxy_->OnGetContent(std::move(data));
 }
 
 void DriveFileStreamReader::OnGetFileContentCompletion(
     const InitializeCompletionCallback& callback,
     FileError error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (reader_proxy_) {
     // If the proxy object available, send the error to it.
     reader_proxy_->OnCompleted(error);
   } else {
     // Here the proxy object is not yet available.
     // There are two cases. 1) Some error happens during the initialization.
     // 2) the cache file is found, but the proxy object is not *yet*
     // initialized because the file is being opened.
     // We are interested in 1) only. The callback for 2) will be called
     // after opening the file is completed.
     // Note: due to the same reason, LocalReaderProxy::OnCompleted may
     // or may not be called. This is timing issue, and it is difficult to avoid
     // unfortunately.
     if (error != FILE_ERROR_OK) {
-      callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
+      callback.Run(FileErrorToNetError(error),
+                   std::unique_ptr<ResourceEntry>());
     }
   }
 }
 
 }  // namespace drive