Convert Pass()→std::move() in //net

net/disk_cache/simple/simple_backend_impl.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 "net/disk_cache/simple/simple_backend_impl.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
 
@@ skipping 196 matching lines @@
       DCHECK_EQ(1U, backend_->active_entries_.count(entry_hash_));
       backend_->active_entries_.erase(entry_hash_);
     }
   }
 
   static scoped_ptr<SimpleEntryImpl::ActiveEntryProxy> Create(
       int64_t entry_hash,
       SimpleBackendImpl* backend) {
     scoped_ptr<SimpleEntryImpl::ActiveEntryProxy>
         proxy(new ActiveEntryProxy(entry_hash, backend));
-    return proxy.Pass();
+    return proxy;
   }
 
  private:
   ActiveEntryProxy(uint64_t entry_hash, SimpleBackendImpl* backend)
       : entry_hash_(entry_hash), backend_(backend->AsWeakPtr()) {}
 
   uint64_t entry_hash_;
   base::WeakPtr<SimpleBackendImpl> backend_;
 };
 
@@ skipping 257 matching lines @@
                          int index_initialization_error_code) {
     if (!backend_) {
       callback.Run(net::ERR_FAILED);
       return;
     }
     if (index_initialization_error_code != net::OK) {
       callback.Run(index_initialization_error_code);
       return;
     }
     if (!hashes_to_enumerate_)
-      hashes_to_enumerate_ = backend_->index()->GetAllHashes().Pass();
+      hashes_to_enumerate_ = backend_->index()->GetAllHashes();
 
     while (!hashes_to_enumerate_->empty()) {
       uint64_t entry_hash = hashes_to_enumerate_->back();
       hashes_to_enumerate_->pop_back();
       if (backend_->index()->Has(entry_hash)) {
         *next_entry = NULL;
         CompletionCallback continue_iteration = base::Bind(
             &SimpleIterator::CheckIterationReturnValue,
             weak_factory_.GetWeakPtr(),
             next_entry,
@@ skipping 240 matching lines @@
 }
 
 // static
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
   // We only need to do this if we there is an active task runner.
   if (base::ThreadTaskRunnerHandle::IsSet())
     g_sequenced_worker_pool.Get().FlushForTesting();
 }
 
 }  // namespace disk_cache