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

components/suggestions/image_manager.cc

 // Copyright 2014 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/suggestions/image_manager.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/task_runner_util.h"
 #include "components/suggestions/image_encoder.h"
 #include "components/suggestions/image_fetcher.h"
 
 using leveldb_proto::ProtoDatabase;
 
 namespace {
 
@@ skipping 13 matching lines @@
 
 namespace suggestions {
 
 ImageManager::ImageManager() : weak_ptr_factory_(this) {}
 
 ImageManager::ImageManager(
     scoped_ptr<ImageFetcher> image_fetcher,
     scoped_ptr<ProtoDatabase<ImageData>> database,
     const base::FilePath& database_dir,
     scoped_refptr<base::TaskRunner> background_task_runner)
-    : image_fetcher_(image_fetcher.Pass()),
-      database_(database.Pass()),
+    : image_fetcher_(std::move(image_fetcher)),
+      database_(std::move(database)),
       background_task_runner_(background_task_runner),
       database_ready_(false),
       weak_ptr_factory_(this) {
   image_fetcher_->SetImageFetcherDelegate(this);
   database_->Init(kDatabaseUMAClientName, database_dir,
                   base::Bind(&ImageManager::OnDatabaseInit,
                              weak_ptr_factory_.GetWeakPtr()));
 }
 
 ImageManager::~ImageManager() {}
@@ skipping 122 matching lines @@
 
   // Save the resulting bitmap to the database.
   ImageData data;
   data.set_url(url.spec());
   data.set_data(encoded_data->front(), encoded_data->size());
   scoped_ptr<ProtoDatabase<ImageData>::KeyEntryVector> entries_to_save(
       new ProtoDatabase<ImageData>::KeyEntryVector());
   scoped_ptr<std::vector<std::string>> keys_to_remove(
       new std::vector<std::string>());
   entries_to_save->push_back(std::make_pair(data.url(), data));
-  database_->UpdateEntries(entries_to_save.Pass(), keys_to_remove.Pass(),
+  database_->UpdateEntries(std::move(entries_to_save),
+                           std::move(keys_to_remove),
                            base::Bind(&ImageManager::OnDatabaseSave,
                                       weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ImageManager::OnDatabaseInit(bool success) {
   if (!success) {
     DVLOG(1) << "Image database init failed.";
     database_.reset();
     ServePendingCacheRequests();
     return;
   }
   database_->LoadEntries(base::Bind(&ImageManager::OnDatabaseLoad,
                                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ImageManager::OnDatabaseLoad(bool success,
                                   scoped_ptr<ImageDataVector> entries) {
   if (!success) {
     DVLOG(1) << "Image database load failed.";
     database_.reset();
     ServePendingCacheRequests();
     return;
   }
   database_ready_ = true;
 
-  LoadEntriesInCache(entries.Pass());
+  LoadEntriesInCache(std::move(entries));
   ServePendingCacheRequests();
 }
 
 void ImageManager::OnDatabaseSave(bool success) {
   if (!success) {
     DVLOG(1) << "Image database save failed.";
     database_.reset();
     database_ready_ = false;
   }
 }
@@ skipping 14 matching lines @@
        it != pending_cache_requests_.end(); ++it) {
     const ImageCacheRequest& request = it->second;
     for (CallbackVector::const_iterator callback_it = request.callbacks.begin();
          callback_it != request.callbacks.end(); ++callback_it) {
       ServeFromCacheOrNetwork(request.url, request.image_url, *callback_it);
     }
   }
 }
 
 }  // namespace suggestions