Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/filesystem/directory_impl.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 "components/filesystem/directory_impl.h"
 
 #include <utility>
 
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "components/filesystem/file_impl.h"
 #include "components/filesystem/lock_table.h"
 #include "components/filesystem/util.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
 
 using mojo::ScopedHandle;
 
 namespace filesystem {
 
 DirectoryImpl::DirectoryImpl(mojo::InterfaceRequest<Directory> request,
                              base::FilePath directory_path,
-                             scoped_ptr<base::ScopedTempDir> temp_dir,
+                             std::unique_ptr<base::ScopedTempDir> temp_dir,
                              scoped_refptr<LockTable> lock_table)
     : binding_(this, std::move(request)),
       directory_path_(directory_path),
       temp_dir_(std::move(temp_dir)),
       lock_table_(std::move(lock_table)) {}
 
 DirectoryImpl::~DirectoryImpl() {
 }
 
 void DirectoryImpl::Read(const ReadCallback& callback) {
@@ skipping 110 matching lines @@
     }
 
     base::File::Error error;
     if (!base::CreateDirectoryAndGetError(path, &error)) {
       callback.Run(static_cast<filesystem::FileError>(error));
       return;
     }
   }
 
   if (directory.is_pending())
-    new DirectoryImpl(std::move(directory), path,
-                      scoped_ptr<base::ScopedTempDir>(), lock_table_);
+    new DirectoryImpl(std::move(directory), path, nullptr, lock_table_);
   callback.Run(FileError::OK);
 }
 
 void DirectoryImpl::Rename(const mojo::String& raw_old_path,
                            const mojo::String& raw_new_path,
                            const RenameCallback& callback) {
   base::FilePath old_path;
   FileError error = ValidatePath(raw_old_path, directory_path_, &old_path);
   if (error != FileError::OK) {
     callback.Run(error);
@@ skipping 113 matching lines @@
   }
 
   base::File base_file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   if (!base_file.IsValid()) {
     callback.Run(GetError(base_file), mojo::Array<uint8_t>());
     return;
   }
 
   std::string contents;
   const int kBufferSize = 1 << 16;
-  scoped_ptr<char[]> buf(new char[kBufferSize]);
+  std::unique_ptr<char[]> buf(new char[kBufferSize]);
   int len;
   while ((len = base_file.ReadAtCurrentPos(buf.get(), kBufferSize)) > 0)
     contents.append(buf.get(), len);
 
   callback.Run(FileError::OK, mojo::Array<uint8_t>::From(contents));
 }
 
 void DirectoryImpl::WriteFile(const mojo::String& raw_path,
                               mojo::Array<uint8_t> data,
                               const WriteFileCallback& callback) {
@@ skipping 23 matching lines @@
                         data_size) == -1) {
       callback.Run(GetError(base_file));
       return;
     }
   }
 
   callback.Run(FileError::OK);
 }
 
 }  // namespace filesystem