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

net/disk_cache/simple/simple_index_file.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_index_file.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 330 matching lines @@
                                        base::Time* out_last_cache_seen_by_index,
                                        SimpleIndexLoadResult* out_result) {
   out_result->Reset();
 
   File file(index_filename,
             File::FLAG_OPEN | File::FLAG_READ | File::FLAG_SHARE_DELETE);
   if (!file.IsValid())
     return;
 
   base::MemoryMappedFile index_file_map;
-  if (!index_file_map.Initialize(file.Pass())) {
+  if (!index_file_map.Initialize(std::move(file))) {
     simple_util::SimpleCacheDeleteFile(index_filename);
     return;
   }
 
   SimpleIndexFile::Deserialize(
       reinterpret_cast<const char*>(index_file_map.data()),
       index_file_map.length(),
       out_last_cache_seen_by_index,
       out_result);
 
   if (!out_result->did_load)
     simple_util::SimpleCacheDeleteFile(index_filename);
 }
 
 // static
 scoped_ptr<base::Pickle> SimpleIndexFile::Serialize(
     const SimpleIndexFile::IndexMetadata& index_metadata,
     const SimpleIndex::EntrySet& entries) {
   scoped_ptr<base::Pickle> pickle(
       new base::Pickle(sizeof(SimpleIndexFile::PickleHeader)));
 
   index_metadata.Serialize(pickle.get());
   for (SimpleIndex::EntrySet::const_iterator it = entries.begin();
        it != entries.end(); ++it) {
     pickle->WriteUInt64(it->first);
     it->second.Serialize(pickle.get());
   }
-  return pickle.Pass();
+  return pickle;
 }
 
 // static
 void SimpleIndexFile::Deserialize(const char* data, int data_len,
                                   base::Time* out_cache_last_modified,
                                   SimpleIndexLoadResult* out_result) {
   DCHECK(data);
 
   out_result->Reset();
   SimpleIndex::EntrySet* entries = &out_result->entries;
@@ skipping 79 matching lines @@
 bool SimpleIndexFile::LegacyIsIndexFileStale(
     base::Time cache_last_modified,
     const base::FilePath& index_file_path) {
   base::Time index_mtime;
   if (!simple_util::GetMTime(index_file_path, &index_mtime))
     return true;
   return index_mtime < cache_last_modified;
 }
 
 }  // namespace disk_cache