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

sql/mojo/mojo_vfs.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 "sql/mojo/mojo_vfs.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "components/filesystem/public/interfaces/file.mojom.h"
 #include "components/filesystem/public/interfaces/file_system.mojom.h"
 #include "components/filesystem/public/interfaces/types.mojom.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/util/capture_util.h"
@@ skipping 90 matching lines @@
                  const void* buffer,
                  int size,
                  sqlite_int64 offset) {
   DVLOG(1) << "MojoVFSWrite(*, " << size << ", " << offset << ")";
   TRACE_EVENT0("sql", "MojoVFSWrite");
   mojo::Array<uint8_t> mojo_data(size);
   memcpy(&mojo_data.front(), buffer, size);
 
   filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
   uint32_t num_bytes_written = 0;
-  GetFSFile(sql_file)->Write(mojo_data.Pass(), offset,
+  GetFSFile(sql_file)->Write(std::move(mojo_data), offset,
                              filesystem::WHENCE_FROM_BEGIN,
                              Capture(&error, &num_bytes_written));
   GetFSFile(sql_file).WaitForIncomingResponse();
   if (error != filesystem::FILE_ERROR_OK) {
     // TODO(erg): Better implementation here.
     NOTIMPLEMENTED();
     return SQLITE_IOERR_WRITE;
   }
   if (num_bytes_written != static_cast<uint32_t>(size)) {
     NOTIMPLEMENTED();
@@ skipping 162 matching lines @@
     return SQLITE_CANTOPEN;
   }
 
   // Set the method table so we can be closed (and run the manual dtor call to
   // match the following placement news).
   file->pMethods = &mojo_vfs_io_methods;
 
   // |file| is actually a malloced buffer of size szOsFile. This means that we
   // need to manually use placement new to construct the C++ object which owns
   // the pipe to our file.
-  new (&GetFSFile(file)) filesystem::FilePtr(file_ptr.Pass());
+  new (&GetFSFile(file)) filesystem::FilePtr(std::move(file_ptr));
 
   return SQLITE_OK;
 }
 
 int MojoVFSDelete(sqlite3_vfs* mojo_vfs, const char* filename, int sync_dir) {
   DVLOG(1) << "MojoVFSDelete(*, " << filename << ", " << sync_dir << ")";
   TRACE_EVENT2("sql", "MojoVFSDelete",
                "name", filename,
                "sync_dir", sync_dir);
   // TODO(erg): The default windows sqlite VFS has retry code to work around
@@ skipping 111 matching lines @@
     MojoVFSCurrentTime,     /* xCurrentTime */
     MojoVFSGetLastError,    /* xGetLastError */
     MojoVFSCurrentTimeInt64 /* xCurrentTimeInt64 */
 };
 
 }  // namespace
 
 ScopedMojoFilesystemVFS::ScopedMojoFilesystemVFS(
     filesystem::DirectoryPtr root_directory)
     : parent_(sqlite3_vfs_find(NULL)),
-      root_directory_(root_directory.Pass()) {
+      root_directory_(std::move(root_directory)) {
   CHECK(!mojo_vfs.pAppData);
   mojo_vfs.pAppData = this;
   mojo_vfs.mxPathname = parent_->mxPathname;
 
   CHECK(sqlite3_vfs_register(&mojo_vfs, 1) == SQLITE_OK);
 }
 
 ScopedMojoFilesystemVFS::~ScopedMojoFilesystemVFS() {
   CHECK(mojo_vfs.pAppData);
   mojo_vfs.pAppData = nullptr;
 
   CHECK(sqlite3_vfs_register(parent_, 1) == SQLITE_OK);
   CHECK(sqlite3_vfs_unregister(&mojo_vfs) == SQLITE_OK);
 }
 
 filesystem::DirectoryPtr& ScopedMojoFilesystemVFS::GetDirectory() {
   return root_directory_;
 }
 
 }  // namespace sql