Convert //google_apis from scoped_ptr to std::unique_ptr

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"
 #include "google_apis/gcm/base/socket_stream.h"
 #include "google_apis/gcm/engine/connection_factory.h"
 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
 
 using namespace google::protobuf::io;
 
 namespace gcm {
 
 namespace {
 
-typedef scoped_ptr<google::protobuf::MessageLite> MCSProto;
+typedef std::unique_ptr<google::protobuf::MessageLite> MCSProto;
 
 // The category of messages intended for the GCM client itself from MCS.
 const char kMCSCategory[] = "com.google.android.gsf.gtalkservice";
 
 // The from field for messages originating in the GCM client.
 const char kGCMFromField[] = "gcm@android.com";
 
 // MCS status message types.
 // TODO(zea): handle these at the GCMClient layer.
 const char kIdleNotification[] = "IdleNotification";
@@ skipping 141 matching lines @@
       weak_ptr_factory_(this) {
 }
 
 MCSClient::~MCSClient() {
 }
 
 void MCSClient::Initialize(
     const ErrorCallback& error_callback,
     const OnMessageReceivedCallback& message_received_callback,
     const OnMessageSentCallback& message_sent_callback,
-    scoped_ptr<GCMStore::LoadResult> load_result) {
+    std::unique_ptr<GCMStore::LoadResult> load_result) {
   DCHECK_EQ(state_, UNINITIALIZED);
 
   state_ = LOADED;
   mcs_error_callback_ = error_callback;
   message_received_callback_ = message_received_callback;
   message_sent_callback_ = message_sent_callback;
 
   connection_factory_->Initialize(
       base::Bind(&MCSClient::ResetStateAndBuildLoginRequest,
                  weak_ptr_factory_.GetWeakPtr()),
@@ skipping 107 matching lines @@
   DCHECK_GE(ttl, 0);
   if (to_send_.size() > kMaxSendQueueSize) {
     NotifyMessageSendStatus(message.GetProtobuf(), QUEUE_SIZE_LIMIT_REACHED);
     return;
   }
   if (message.size() > kMaxMessageBytes) {
     NotifyMessageSendStatus(message.GetProtobuf(), MESSAGE_TOO_LARGE);
     return;
   }
 
-  scoped_ptr<ReliablePacketInfo> packet_info(new ReliablePacketInfo());
+  std::unique_ptr<ReliablePacketInfo> packet_info(new ReliablePacketInfo());
   packet_info->tag = message.tag();
   packet_info->protobuf = message.CloneProtobuf();
 
   if (ttl > 0) {
     DCHECK_EQ(message.tag(), kDataMessageStanzaTag);
 
     // 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*>(
@@ skipping 40 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) {
+void MCSClient::UpdateHeartbeatTimer(std::unique_ptr<base::Timer> timer) {
   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,
@@ skipping 207 matching lines @@
       persistent_id_list.push_back(iter->second);
     }
     unacked_server_ids_.clear();
     acked_server_ids_[stream_id_out_] = persistent_id_list;
   }
 
   connection_handler_->SendMessage(*packet_info->protobuf);
 }
 
 void MCSClient::HandleMCSDataMesssage(
-    scoped_ptr<google::protobuf::MessageLite> protobuf) {
+    std::unique_ptr<google::protobuf::MessageLite> protobuf) {
   mcs_proto::DataMessageStanza* data_message =
       reinterpret_cast<mcs_proto::DataMessageStanza*>(protobuf.get());
   // TODO(zea): implement a proper status manager rather than hardcoding these
   // values.
-  scoped_ptr<mcs_proto::DataMessageStanza> response(
+  std::unique_ptr<mcs_proto::DataMessageStanza> response(
       new mcs_proto::DataMessageStanza());
   response->set_from(kGCMFromField);
   response->set_sent(clock_->Now().ToInternalValue() /
                          base::Time::kMicrosecondsPerSecond);
   response->set_ttl(0);
   bool send = false;
   for (int i = 0; i < data_message->app_data_size(); ++i) {
     const mcs_proto::AppData& app_data = data_message->app_data(i);
     if (app_data.key() == kIdleNotification) {
       // Tell the MCS server the client is not idle.
       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, std::move(response)));
   }
 }
 
 void MCSClient::HandlePacketFromWire(
-    scoped_ptr<google::protobuf::MessageLite> protobuf) {
+    std::unique_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);
 
   if (last_stream_id_received != 0) {
     last_device_to_server_stream_id_received_ = last_stream_id_received;
 
     // Process device to server messages that have now been acknowledged by the
@@ skipping 312 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