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

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_reader.cc

 // Copyright 2014 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/file_system_provider/fileapi/file_stream_reader.h"
 
 #include "base/files/file.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/chromeos/file_system_provider/abort_callback.h"
 #include "chrome/browser/chromeos/file_system_provider/fileapi/provider_async_file_util.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/scoped_file_opener.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 75 matching lines @@
   // Requests metadata of a file. In case of either succes or a failure,
   // |callback| is executed. Must be called on UI thread.
   void GetMetadataOnUIThread(
       const ProvidedFileSystemInterface::GetMetadataCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(abort_callback_.is_null());
 
     // If the file system got unmounted, then abort the get length operation.
     if (!file_system_.get()) {
       BrowserThread::PostTask(
-          BrowserThread::IO,
-          FROM_HERE,
+          BrowserThread::IO, FROM_HERE,
           base::Bind(callback,
-                     base::Passed(make_scoped_ptr<EntryMetadata>(NULL)),
+                     base::Passed(base::WrapUnique<EntryMetadata>(NULL)),
                      base::File::FILE_ERROR_ABORT));
       return;
     }
 
     abort_callback_ = file_system_->GetMetadata(
         file_path_,
         ProvidedFileSystemInterface::METADATA_FIELD_SIZE |
             ProvidedFileSystemInterface::METADATA_FIELD_MODIFICATION_TIME,
         base::Bind(&OperationRunner::OnGetMetadataCompletedOnUIThread, this,
                    callback));
@@ skipping 33 matching lines @@
     if (result == base::File::FILE_OK)
       file_handle_ = file_handle;
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
   }
 
   // Forwards a metadata to the IO thread.
   void OnGetMetadataCompletedOnUIThread(
       const ProvidedFileSystemInterface::GetMetadataCallback& callback,
-      scoped_ptr<EntryMetadata> metadata,
+      std::unique_ptr<EntryMetadata> metadata,
       base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     abort_callback_ = AbortCallback();
 
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(callback, base::Passed(&metadata), result));
   }
 
@@ skipping 10 matching lines @@
 
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(chunk_received_callback, chunk_length, has_more, result));
   }
 
   AbortCallback abort_callback_;
   base::WeakPtr<ProvidedFileSystemInterface> file_system_;
   base::FilePath file_path_;
-  scoped_ptr<ScopedFileOpener> file_opener_;
+  std::unique_ptr<ScopedFileOpener> file_opener_;
   int file_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(OperationRunner);
 };
 
 FileStreamReader::FileStreamReader(storage::FileSystemContext* context,
                                    const storage::FileSystemURL& url,
                                    int64_t initial_offset,
                                    const base::Time& expected_modification_time)
     : url_(url),
@@ skipping 60 matching lines @@
                  runner_,
                  base::Bind(&FileStreamReader::OnInitializeCompleted,
                             weak_ptr_factory_.GetWeakPtr(),
                             pending_closure,
                             error_callback)));
 }
 
 void FileStreamReader::OnInitializeCompleted(
     const base::Closure& pending_closure,
     const net::Int64CompletionCallback& error_callback,
-    scoped_ptr<EntryMetadata> metadata,
+    std::unique_ptr<EntryMetadata> metadata,
     base::File::Error result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(INITIALIZING, state_);
 
   // In case of an error, abort.
   if (result != base::File::FILE_OK) {
     state_ = FAILED;
     error_callback.Run(net::FileErrorToNetError(result));
     return;
   }
@@ skipping 159 matching lines @@
     callback.Run(net::FileErrorToNetError(result));
     return;
   }
 
   // More data is about to come, so do not call the callback yet.
   DCHECK(has_more);
 }
 
 void FileStreamReader::OnGetMetadataForGetLengthReceived(
     const net::Int64CompletionCallback& callback,
-    scoped_ptr<EntryMetadata> metadata,
+    std::unique_ptr<EntryMetadata> metadata,
     base::File::Error result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(INITIALIZED, state_);
 
   // In case of an error, abort.
   if (result != base::File::FILE_OK) {
     state_ = FAILED;
     callback.Run(net::FileErrorToNetError(result));
     return;
   }
 
   // If the file modification time has changed, then abort. Note, that the file
   // may be changed without affecting the modification time.
   DCHECK(metadata.get());
   if (!expected_modification_time_.is_null() &&
       *metadata->modification_time != expected_modification_time_) {
     callback.Run(net::ERR_UPLOAD_FILE_CHANGED);
     return;
   }
 
   DCHECK_EQ(base::File::FILE_OK, result);
   callback.Run(*metadata->size);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos