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

google_apis/gcm/engine/gcm_store_impl.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 "google_apis/gcm/engine/gcm_store_impl.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 247 matching lines @@
 
   scoped_ptr<leveldb::DB> db_;
 };
 
 GCMStoreImpl::Backend::Backend(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> foreground_task_runner,
     scoped_ptr<Encryptor> encryptor)
     : path_(path),
       foreground_task_runner_(foreground_task_runner),
-      encryptor_(encryptor.Pass()) {
-}
+      encryptor_(std::move(encryptor)) {}
 
 GCMStoreImpl::Backend::~Backend() {}
 
 LoadStatus GCMStoreImpl::Backend::OpenStoreAndLoadData(StoreOpenMode open_mode,
                                                        LoadResult* result) {
   LoadStatus load_status;
   if (db_.get()) {
     LOG(ERROR) << "Attempting to reload open database.";
     return RELOADING_OPEN_STORE;
   }
@@ skipping 872 matching lines @@
 
   return true;
 }
 
 GCMStoreImpl::GCMStoreImpl(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
     scoped_ptr<Encryptor> encryptor)
     : backend_(new Backend(path,
                            base::ThreadTaskRunnerHandle::Get(),
-                           encryptor.Pass())),
+                           std::move(encryptor))),
       blocking_task_runner_(blocking_task_runner),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 GCMStoreImpl::~GCMStoreImpl() {}
 
 void GCMStoreImpl::Load(StoreOpenMode open_mode, const LoadCallback& callback) {
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMStoreImpl::Backend::Load,
                  backend_,
                  open_mode,
                  base::Bind(&GCMStoreImpl::LoadContinuation,
@@ skipping 241 matching lines @@
                  callback));
 }
 
 void GCMStoreImpl::LoadContinuation(const LoadCallback& callback,
                                     scoped_ptr<LoadResult> result) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 GCMStoreImpl::LoadContinuation"));
   if (!result->success) {
-    callback.Run(result.Pass());
+    callback.Run(std::move(result));
     return;
   }
   int num_throttled_apps = 0;
   for (OutgoingMessageMap::const_iterator
            iter = result->outgoing_messages.begin();
        iter != result->outgoing_messages.end(); ++iter) {
     const mcs_proto::DataMessageStanza* data_message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(iter->second.get());
     DCHECK(!data_message->category().empty());
     if (app_message_counts_.count(data_message->category()) == 0)
       app_message_counts_[data_message->category()] = 1;
     else
       app_message_counts_[data_message->category()]++;
     if (app_message_counts_[data_message->category()] == kMessagesPerAppLimit)
       num_throttled_apps++;
   }
   UMA_HISTOGRAM_COUNTS("GCM.NumThrottledApps", num_throttled_apps);
-  callback.Run(result.Pass());
+  callback.Run(std::move(result));
 }
 
 void GCMStoreImpl::AddOutgoingMessageContinuation(
     const UpdateCallback& callback,
     const std::string& app_id,
     bool success) {
   if (!success) {
     DCHECK(app_message_counts_[app_id] > 0);
     app_message_counts_[app_id]--;
   }
@@ skipping 12 matching lines @@
            removed_message_counts.begin();
        iter != removed_message_counts.end(); ++iter) {
     DCHECK_NE(app_message_counts_.count(iter->first), 0U);
     app_message_counts_[iter->first] -= iter->second;
     DCHECK_GE(app_message_counts_[iter->first], 0);
   }
   callback.Run(true);
 }
 
 }  // namespace gcm