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

net/disk_cache/blockfile/backend_impl.cc

 // Copyright (c) 2012 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/blockfile/backend_impl.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 377 matching lines @@
     node = next;
     next = OpenNextEntryImpl(iterator.get());
 
     if (node->GetLastUsed() >= initial_time &&
         node->GetLastUsed() < end_time) {
       node->DoomImpl();
     } else if (node->GetLastUsed() < initial_time) {
       if (next)
         next->Release();
       next = NULL;
-      SyncEndEnumeration(iterator.Pass());
+      SyncEndEnumeration(std::move(iterator));
     }
 
     node->Release();
   }
 
   return net::OK;
 }
 
 int BackendImpl::SyncCalculateSizeOfAllEntries() {
   DCHECK_NE(net::APP_CACHE, cache_type_);
@@ skipping 12 matching lines @@
 
   stats_.OnEvent(Stats::DOOM_RECENT);
   for (;;) {
     scoped_ptr<Rankings::Iterator> iterator(new Rankings::Iterator());
     EntryImpl* entry = OpenNextEntryImpl(iterator.get());
     if (!entry)
       return net::OK;
 
     if (initial_time > entry->GetLastUsed()) {
       entry->Release();
-      SyncEndEnumeration(iterator.Pass());
+      SyncEndEnumeration(std::move(iterator));
       return net::OK;
     }
 
     entry->DoomImpl();
     entry->Release();
-    SyncEndEnumeration(iterator.Pass());  // The doom invalidated the iterator.
+    SyncEndEnumeration(
+        std::move(iterator));  // The doom invalidated the iterator.
   }
 }
 
 int BackendImpl::SyncOpenNextEntry(Rankings::Iterator* iterator,
                                    Entry** next_entry) {
   *next_entry = OpenNextEntryImpl(iterator);
   return (*next_entry) ? net::OK : net::ERR_FAILED;
 }
 
 void BackendImpl::SyncEndEnumeration(scoped_ptr<Rankings::Iterator> iterator) {
@@ skipping 819 matching lines @@
 
 class BackendImpl::IteratorImpl : public Backend::Iterator {
  public:
   explicit IteratorImpl(base::WeakPtr<InFlightBackendIO> background_queue)
       : background_queue_(background_queue),
         iterator_(new Rankings::Iterator()) {
   }
 
   ~IteratorImpl() override {
     if (background_queue_)
-      background_queue_->EndEnumeration(iterator_.Pass());
+      background_queue_->EndEnumeration(std::move(iterator_));
   }
 
   int OpenNextEntry(Entry** next_entry,
                     const net::CompletionCallback& callback) override {
     if (!background_queue_)
       return net::ERR_FAILED;
     background_queue_->OpenNextEntry(iterator_.get(), next_entry, callback);
     return net::ERR_IO_PENDING;
   }
 
@@ skipping 69 matching lines @@
 
   int flags = base::File::FLAG_READ | base::File::FLAG_WRITE |
               base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_EXCLUSIVE_WRITE;
   base::File base_file(index_name, flags);
   if (!base_file.IsValid())
     return false;
 
   bool ret = true;
   *file_created = base_file.created();
 
-  scoped_refptr<disk_cache::File> file(new disk_cache::File(base_file.Pass()));
+  scoped_refptr<disk_cache::File> file(
+      new disk_cache::File(std::move(base_file)));
   if (*file_created)
     ret = CreateBackingStore(file.get());
 
   file = NULL;
   if (!ret)
     return false;
 
   index_ = new MappedFile();
   data_ = static_cast<Index*>(index_->Init(index_name, 0));
   if (!data_) {
@@ skipping 726 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache