Global conversion of Pass()→std::move() on Linux

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 <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"
 #include "base/process/process_metrics.h"
 #include "base/stl_util.h"
@@ skipping 164 matching lines @@
   std::string filename_;
   scoped_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_(file.Pass()), uma_logger_(uma_logger) {}
+      : filename_(fname), file_(std::move(file)), uma_logger_(uma_logger) {}
   virtual ~ChromiumRandomAccessFile() {}
 
   Status Read(uint64_t offset,
               size_t n,
               Slice* result,
               char* scratch) const override {
     Status s;
     int r = file_.Read(offset, scratch, n);
     *result = Slice(scratch, (r < 0) ? 0 : r);
     if (r < 0) {
@@ skipping 557 matching lines @@
 
   if (error_code != base::File::FILE_OK) {
     locks_.Remove(fname);
     result = MakeIOError(fname, FileErrorString(error_code), kLockFile,
                          error_code);
     RecordOSError(kLockFile, error_code);
     return result;
   }
 
   ChromiumFileLock* my_lock = new ChromiumFileLock;
-  my_lock->file_ = file.Pass();
+  my_lock->file_ = std::move(file);
   my_lock->name_ = fname;
   *lock = my_lock;
   return result;
 }
 
 Status ChromiumEnv::UnlockFile(FileLock* lock) {
   ChromiumFileLock* my_lock = reinterpret_cast<ChromiumFileLock*>(lock);
   Status result;
 
   base::File::Error error_code = my_lock->file_.Unlock();
@@ skipping 64 matching lines @@
 #else
 #error "Need to determine limit to open files for this OS"
 #endif
 }
 
 Status ChromiumEnv::NewRandomAccessFile(const std::string& fname,
                                         leveldb::RandomAccessFile** result) {
   int flags = base::File::FLAG_READ | base::File::FLAG_OPEN;
   base::File file(FilePath::FromUTF8Unsafe(fname), flags);
   if (file.IsValid()) {
-    *result = new ChromiumRandomAccessFile(fname, file.Pass(), this);
+    *result = new ChromiumRandomAccessFile(fname, std::move(file), this);
     RecordOpenFilesLimit("Success");
     return Status::OK();
   }
   base::File::Error error_code = file.error_details();
   if (error_code == base::File::FILE_ERROR_TOO_MANY_OPENED)
     RecordOpenFilesLimit("TooManyOpened");
   else
     RecordOpenFilesLimit("OtherError");
   *result = NULL;
   RecordOSError(kNewRandomAccessFile, error_code);
@@ skipping 211 matching lines @@
 
 }  // namespace leveldb_env
 
 namespace leveldb {
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb