Convert Pass()→std::move() in //components/[n-z]*

components/visitedlink/browser/visitedlink_master.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 "components/visitedlink/browser/visitedlink_master.h"
 
 #include <stdio.h>
 #include <string.h>
-
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/containers/stack_container.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
@@ skipping 122 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LoadFromFileResult);
 };
 
 VisitedLinkMaster::LoadFromFileResult::LoadFromFileResult(
     base::ScopedFILE file,
     scoped_ptr<base::SharedMemory> shared_memory,
     Fingerprint* hash_table,
     int32_t num_entries,
     int32_t used_count,
     uint8_t salt[LINK_SALT_LENGTH])
-    : file(file.Pass()),
-      shared_memory(shared_memory.Pass()),
+    : file(std::move(file)),
+      shared_memory(std::move(shared_memory)),
       hash_table(hash_table),
       num_entries(num_entries),
       used_count(used_count) {
   memcpy(this->salt, salt, LINK_SALT_LENGTH);
 }
 
 VisitedLinkMaster::LoadFromFileResult::~LoadFromFileResult() {
 }
 
 // TableBuilder ---------------------------------------------------------------
@@ skipping 500 matching lines @@
   scoped_ptr<base::SharedMemory> shared_memory;
   VisitedLinkCommon::Fingerprint* hash_table;
   if (!CreateApartURLTable(num_entries, salt, &shared_memory, &hash_table))
     return false;
 
   if (!ReadFromFile(file_closer.get(), kFileHeaderSize, hash_table,
                     num_entries * sizeof(Fingerprint))) {
     return false;
   }
 
-  *load_from_file_result = new LoadFromFileResult(file_closer.Pass(),
-                                                  shared_memory.Pass(),
-                                                  hash_table,
-                                                  num_entries,
-                                                  used_count,
-                                                  salt);
+  *load_from_file_result =
+      new LoadFromFileResult(std::move(file_closer), std::move(shared_memory),
+                             hash_table, num_entries, used_count, salt);
   return true;
 }
 
 void VisitedLinkMaster::OnTableLoadComplete(
     bool success,
     scoped_refptr<LoadFromFileResult> load_from_file_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(persist_to_disk_);
   DCHECK(!table_builder_.get());
 
@@ skipping 214 matching lines @@
 
   // Save the header for other processes to read.
   SharedHeader* header = static_cast<SharedHeader*>(sh_mem->memory());
   header->length = num_entries;
   memcpy(header->salt, salt, LINK_SALT_LENGTH);
 
   // Our table pointer is just the data immediately following the size.
   *hash_table = reinterpret_cast<Fingerprint*>(
       static_cast<char*>(sh_mem->memory()) + sizeof(SharedHeader));
 
-  *shared_memory = sh_mem.Pass();
+  *shared_memory = std::move(sh_mem);
 
   return true;
 }
 
 bool VisitedLinkMaster::BeginReplaceURLTable(int32_t num_entries) {
   base::SharedMemory *old_shared_memory = shared_memory_;
   Fingerprint* old_hash_table = hash_table_;
   int32_t old_table_length = table_length_;
   if (!CreateURLTable(num_entries)) {
     // Try to put back the old state.
@@ skipping 272 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TableBuilder::OnCompleteMainThread, this));
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 }
 
 }  // namespace visitedlink