Convert //third_party from scoped_ptr to std::unique_ptr

third_party/leveldatabase/env_chromium.cc

 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "third_party/leveldatabase/env_chromium.h"
 
+#include <memory>
 #include <utility>
 
 #if defined(OS_POSIX)
 #include <dirent.h>
 #include <sys/types.h>
 #endif
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
@@ skipping 157 matching lines @@
       uma_logger_->RecordErrorAt(kSequentialFileSkip);
       return MakeIOError(filename_, base::File::ErrorToString(error),
                          kSequentialFileSkip, error);
     } else {
       return Status::OK();
     }
   }
 
  private:
   std::string filename_;
-  scoped_ptr<base::File> file_;
+  std::unique_ptr<base::File> file_;
   const UMALogger* uma_logger_;
 };
 
 class ChromiumRandomAccessFile : public leveldb::RandomAccessFile {
  public:
   ChromiumRandomAccessFile(const std::string& fname,
                            base::File file,
                            const UMALogger* uma_logger)
       : filename_(fname), file_(std::move(file)), uma_logger_(uma_logger) {}
   virtual ~ChromiumRandomAccessFile() {}
@@ skipping 30 matching lines @@
   leveldb::Status Append(const leveldb::Slice& data) override;
   leveldb::Status Close() override;
   leveldb::Status Flush() override;
   leveldb::Status Sync() override;
 
  private:
   enum Type { kManifest, kTable, kOther };
   leveldb::Status SyncParent();
 
   std::string filename_;
-  scoped_ptr<base::File> file_;
+  std::unique_ptr<base::File> file_;
   const UMALogger* uma_logger_;
   Type file_type_;
   std::string parent_dir_;
   bool make_backup_;
 };
 
 ChromiumWritableFile::ChromiumWritableFile(const std::string& fname,
                                            base::File* f,
                                            const UMALogger* uma_logger,
                                            bool make_backup)
@@ skipping 556 matching lines @@
     }
   }
   *path = test_directory_.AsUTF8Unsafe();
   mu_.Release();
   return Status::OK();
 }
 
 Status ChromiumEnv::NewLogger(const std::string& fname,
                               leveldb::Logger** result) {
   FilePath path = FilePath::FromUTF8Unsafe(fname);
-  scoped_ptr<base::File> f(new base::File(
+  std::unique_ptr<base::File> f(new base::File(
       path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE));
   if (!f->IsValid()) {
     *result = NULL;
     RecordOSError(kNewLogger, f->error_details());
     return MakeIOError(fname, "Unable to create log file", kNewLogger,
                        f->error_details());
   } else {
     *result = new leveldb::ChromiumLogger(f.release());
     return Status::OK();
   }
 }
 
 Status ChromiumEnv::NewSequentialFile(const std::string& fname,
                                       leveldb::SequentialFile** result) {
   FilePath path = FilePath::FromUTF8Unsafe(fname);
-  scoped_ptr<base::File> f(
+  std::unique_ptr<base::File> f(
       new base::File(path, base::File::FLAG_OPEN | base::File::FLAG_READ));
   if (!f->IsValid()) {
     *result = NULL;
     RecordOSError(kNewSequentialFile, f->error_details());
     return MakeIOError(fname, "Unable to create sequential file",
                        kNewSequentialFile, f->error_details());
   } else {
     *result = new ChromiumSequentialFile(fname, f.release(), this);
     return Status::OK();
   }
@@ skipping 26 matching lines @@
   *result = NULL;
   RecordOSError(kNewRandomAccessFile, error_code);
   return MakeIOError(fname, FileErrorString(error_code), kNewRandomAccessFile,
                      error_code);
 }
 
 Status ChromiumEnv::NewWritableFile(const std::string& fname,
                                     leveldb::WritableFile** result) {
   *result = NULL;
   FilePath path = FilePath::FromUTF8Unsafe(fname);
-  scoped_ptr<base::File> f(new base::File(
+  std::unique_ptr<base::File> f(new base::File(
       path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE));
   if (!f->IsValid()) {
     RecordErrorAt(kNewWritableFile);
     return MakeIOError(fname, "Unable to create writable file",
                        kNewWritableFile, f->error_details());
   } else {
     *result = new ChromiumWritableFile(fname, f.release(), this, make_backup_);
     return Status::OK();
   }
 }
 
 Status ChromiumEnv::NewAppendableFile(const std::string& fname,
                                       leveldb::WritableFile** result) {
   *result = NULL;
   FilePath path = FilePath::FromUTF8Unsafe(fname);
-  scoped_ptr<base::File> f(new base::File(
+  std::unique_ptr<base::File> f(new base::File(
       path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_APPEND));
   if (!f->IsValid()) {
     RecordErrorAt(kNewAppendableFile);
     return MakeIOError(fname, "Unable to create appendable file",
                        kNewAppendableFile, f->error_details());
   }
   *result = new ChromiumWritableFile(fname, f.release(), this, make_backup_);
   return Status::OK();
 }
 
@@ skipping 176 matching lines @@
 
 }  // namespace leveldb_env
 
 namespace leveldb {
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb