Convert Pass()→std::move() in //content/browser

content/browser/indexed_db/leveldb/leveldb_database.cc

 // Copyright (c) 2013 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 "content/browser/indexed_db/leveldb/leveldb_database.h"
 
 #include <stdint.h>
-
 #include <cerrno>
+#include <utility>
 
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 281 matching lines @@
     return s;
   }
 
   UMA_HISTOGRAM_MEDIUM_TIMES("WebCore.IndexedDB.LevelDB.OpenTime",
                              base::TimeTicks::Now() - begin_time);
 
   CheckFreeSpace("Success", file_name);
 
   (*result).reset(new LevelDBDatabase);
   (*result)->db_ = make_scoped_ptr(db);
-  (*result)->comparator_adapter_ = comparator_adapter.Pass();
+  (*result)->comparator_adapter_ = std::move(comparator_adapter);
   (*result)->comparator_ = comparator;
-  (*result)->filter_policy_ = filter_policy.Pass();
+  (*result)->filter_policy_ = std::move(filter_policy);
 
   return s;
 }
 
 scoped_ptr<LevelDBDatabase> LevelDBDatabase::OpenInMemory(
     const LevelDBComparator* comparator) {
   scoped_ptr<ComparatorAdapter> comparator_adapter(
       new ComparatorAdapter(comparator));
   scoped_ptr<leveldb::Env> in_memory_env(leveldb::NewMemEnv(LevelDBEnv::Get()));
 
   leveldb::DB* db;
   scoped_ptr<const leveldb::FilterPolicy> filter_policy;
   const leveldb::Status s = OpenDB(comparator_adapter.get(),
                                    in_memory_env.get(),
                                    base::FilePath(),
                                    &db,
                                    &filter_policy);
 
   if (!s.ok()) {
     LOG(ERROR) << "Failed to open in-memory LevelDB database: " << s.ToString();
     return scoped_ptr<LevelDBDatabase>();
   }
 
   scoped_ptr<LevelDBDatabase> result(new LevelDBDatabase);
-  result->env_ = in_memory_env.Pass();
+  result->env_ = std::move(in_memory_env);
   result->db_ = make_scoped_ptr(db);
-  result->comparator_adapter_ = comparator_adapter.Pass();
+  result->comparator_adapter_ = std::move(comparator_adapter);
   result->comparator_ = comparator;
-  result->filter_policy_ = filter_policy.Pass();
+  result->filter_policy_ = std::move(filter_policy);
 
-  return result.Pass();
+  return result;
 }
 
 leveldb::Status LevelDBDatabase::Put(const StringPiece& key,
                                      std::string* value) {
   base::TimeTicks begin_time = base::TimeTicks::Now();
 
   leveldb::WriteOptions write_options;
   write_options.sync = kSyncWrites;
 
   const leveldb::Status s =
@@ skipping 57 matching lines @@
 
 scoped_ptr<LevelDBIterator> LevelDBDatabase::CreateIterator(
     const LevelDBSnapshot* snapshot) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;  // TODO(jsbell): Disable this if the
                                          // performance impact is too great.
   read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;
 
   scoped_ptr<leveldb::Iterator> i(db_->NewIterator(read_options));
   return scoped_ptr<LevelDBIterator>(
-      IndexedDBClassFactory::Get()->CreateIteratorImpl(i.Pass()));
+      IndexedDBClassFactory::Get()->CreateIteratorImpl(std::move(i)));
 }
 
 const LevelDBComparator* LevelDBDatabase::Comparator() const {
   return comparator_;
 }
 
 void LevelDBDatabase::Compact(const base::StringPiece& start,
                               const base::StringPiece& stop) {
   IDB_TRACE("LevelDBDatabase::Compact");
   const leveldb::Slice start_slice = MakeSlice(start);
   const leveldb::Slice stop_slice = MakeSlice(stop);
   // NULL batch means just wait for earlier writes to be done
   db_->Write(leveldb::WriteOptions(), NULL);
   db_->CompactRange(&start_slice, &stop_slice);
 }
 
 void LevelDBDatabase::CompactAll() { db_->CompactRange(NULL, NULL); }
 
 }  // namespace content