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

google_apis/gcm/engine/mcs_client.cc

 // Copyright 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 "google_apis/gcm/engine/mcs_client.h"
 
 #include <stddef.h>
-
 #include <set>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "google_apis/gcm/base/mcs_util.h"
@@ skipping 307 matching lines @@
     // First check if this message should replace a pending message with the
     // same collapse key.
     mcs_proto::DataMessageStanza* data_message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(
             packet_info->protobuf.get());
     CollapseKey collapse_key(*data_message);
     if (collapse_key.IsValid() && collapse_key_map_.count(collapse_key) > 0) {
       ReliablePacketInfo* original_packet = collapse_key_map_[collapse_key];
       DVLOG(1) << "Found matching collapse key, Reusing persistent id of "
                << original_packet->persistent_id;
-      original_packet->protobuf = packet_info->protobuf.Pass();
+      original_packet->protobuf = std::move(packet_info->protobuf);
       SetPersistentId(original_packet->persistent_id,
                       original_packet->protobuf.get());
       gcm_store_->OverwriteOutgoingMessage(
           original_packet->persistent_id,
           message,
           base::Bind(&MCSClient::OnGCMUpdateFinished,
                      weak_ptr_factory_.GetWeakPtr()));
 
       // The message is already queued, return.
       return;
@@ skipping 24 matching lines @@
   to_send_.push_back(make_linked_ptr(packet_info.release()));
 
   // Notify that the messages has been succsfully queued for sending.
   // TODO(jianli): We should report QUEUED after writing to GCM store succeeds.
   NotifyMessageSendStatus(message.GetProtobuf(), QUEUED);
 
   MaybeSendMessage();
 }
 
 void MCSClient::UpdateHeartbeatTimer(scoped_ptr<base::Timer> timer) {
-  heartbeat_manager_.UpdateHeartbeatTimer(timer.Pass());
+  heartbeat_manager_.UpdateHeartbeatTimer(std::move(timer));
 }
 
 void MCSClient::AddHeartbeatInterval(const std::string& scope,
                                      int interval_ms) {
   if (!heartbeat_manager_.IsValidClientHeartbeatInterval(interval_ms))
     return;
 
   custom_heartbeat_intervals_[scope] = interval_ms;
   gcm_store_->AddHeartbeatInterval(scope, interval_ms,
                                    base::Bind(&MCSClient::OnGCMUpdateFinished,
@@ skipping 232 matching lines @@
       send = true;
       mcs_proto::AppData data;
       data.set_key(kIdleNotification);
       data.set_value("false");
       response->add_app_data()->CopyFrom(data);
       response->set_category(kMCSCategory);
     }
   }
 
   if (send) {
-    SendMessage(MCSMessage(kDataMessageStanzaTag, response.Pass()));
+    SendMessage(MCSMessage(kDataMessageStanzaTag, std::move(response)));
   }
 }
 
 void MCSClient::HandlePacketFromWire(
     scoped_ptr<google::protobuf::MessageLite> protobuf) {
   if (!protobuf.get())
     return;
   uint8_t tag = GetMCSProtoTag(*protobuf);
   PersistentId persistent_id = GetPersistentId(*protobuf);
   StreamId last_stream_id_received = GetLastStreamIdReceived(*protobuf);
@@ skipping 68 matching lines @@
         heartbeat_manager_.UpdateHeartbeatConfig(
             login_response->heartbeat_config());
       }
 
       state_ = CONNECTED;
       stream_id_in_ = 1;  // To account for the login response.
       DCHECK_EQ(1U, stream_id_out_);
 
       // Pass the login response on up.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(message_received_callback_,
-                     MCSMessage(tag, protobuf.Pass())));
+          FROM_HERE, base::Bind(message_received_callback_,
+                                MCSMessage(tag, std::move(protobuf))));
 
       // If there are pending messages, attempt to send one.
       if (!to_send_.empty()) {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE,
             base::Bind(&MCSClient::MaybeSendMessage,
                        weak_ptr_factory_.GetWeakPtr()));
       }
 
       heartbeat_manager_.Start(
@@ skipping 42 matching lines @@
           LOG(WARNING) << "Received invalid iq stanza extension "
                        << iq_extension.id();
           return;
       }
     }
     case kDataMessageStanzaTag: {
       DCHECK_GE(stream_id_in_, 1U);
       mcs_proto::DataMessageStanza* data_message =
           reinterpret_cast<mcs_proto::DataMessageStanza*>(protobuf.get());
       if (data_message->category() == kMCSCategory) {
-        HandleMCSDataMesssage(protobuf.Pass());
+        HandleMCSDataMesssage(std::move(protobuf));
         return;
       }
 
       DCHECK(protobuf.get());
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(message_received_callback_,
-                     MCSMessage(tag, protobuf.Pass())));
+          FROM_HERE, base::Bind(message_received_callback_,
+                                MCSMessage(tag, std::move(protobuf))));
       return;
     }
     default:
       LOG(ERROR) << "Received unexpected message of type "
                  << static_cast<int>(tag);
       return;
   }
 }
 
 void MCSClient::HandleStreamAck(StreamId last_stream_id_received) {
@@ skipping 157 matching lines @@
         reinterpret_cast<mcs_proto::DataMessageStanza*>(packet->protobuf.get());
     CollapseKey collapse_key(*data_message);
     if (collapse_key.IsValid())
       collapse_key_map_.erase(collapse_key);
   }
 
   return packet;
 }
 
 } // namespace gcm