Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/gcm/engine/mcs_client.h

 // 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.
 
 #ifndef GOOGLE_APIS_GCM_ENGINE_MCS_CLIENT_H_
 #define GOOGLE_APIS_GCM_ENGINE_MCS_CLIENT_H_
 
 #include <stdint.h>
 
 #include <deque>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "google_apis/gcm/base/gcm_export.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/engine/connection_factory.h"
 #include "google_apis/gcm/engine/connection_handler.h"
 #include "google_apis/gcm/engine/gcm_store.h"
 #include "google_apis/gcm/engine/heartbeat_manager.h"
 
 namespace base {
 class Clock;
@@ skipping 82 matching lines @@
   // passing the id/token information back via |initialization_callback| along
   // with a |success == true| result. If no GCM information is present (and
   // this is therefore a fresh client), a clean GCM store will be created and
   // values of 0 will be returned via |initialization_callback| with
   // |success == true|.
   // If an error loading the GCM store is encountered,
   // |initialization_callback| will be invoked with |success == false|.
   void Initialize(const ErrorCallback& initialization_callback,
                   const OnMessageReceivedCallback& message_received_callback,
                   const OnMessageSentCallback& message_sent_callback,
-                  scoped_ptr<GCMStore::LoadResult> load_result);
+                  std::unique_ptr<GCMStore::LoadResult> load_result);
 
   // Logs the client into the server. Client must be initialized.
   // |android_id| and |security_token| are optional if this is not a new
   // client, else they must be non-zero.
   // Successful login will result in |message_received_callback| being invoked
   // with a valid LoginResponse.
   // Login failure (typically invalid id/token) will shut down the client, and
   // |initialization_callback| to be invoked with |success = false|.
   virtual void Login(uint64_t android_id, uint64_t security_token);
 
@@ skipping 12 matching lines @@
   // Returns the size of the send message queue.
   int GetSendQueueSize() const;
 
   // Returns the size of the resend messaage queue.
   int GetResendQueueSize() const;
 
   // Returns text representation of the state enum.
   std::string GetStateString() const;
 
   // Updates the timer used by |heartbeat_manager_| for sending heartbeats.
-  void UpdateHeartbeatTimer(scoped_ptr<base::Timer> timer);
+  void UpdateHeartbeatTimer(std::unique_ptr<base::Timer> timer);
 
   // Allows a caller to set a heartbeat interval (in milliseconds) with which
   // the MCS connection will be monitored on both ends, to detect device
   // presence. In case the newly set interval is less then the current one,
   // connection will be restarted with new heartbeat interval. Valid values have
   // to be between GetMax/GetMinClientHeartbeatIntervalMs of HeartbeatManager,
   // otherwise the setting won't take effect.
   void AddHeartbeatInterval(const std::string& scope, int interval_ms);
   void RemoveHeartbeatInterval(const std::string& scope);
 
@@ skipping 23 matching lines @@
 
   // Attempt to send a message.
   void MaybeSendMessage();
 
   // Helper for sending a protobuf along with any unacknowledged ids to the
   // wire.
   void SendPacketToWire(ReliablePacketInfo* packet_info);
 
   // Handle a data message sent to the MCS client system from the MCS server.
   void HandleMCSDataMesssage(
-      scoped_ptr<google::protobuf::MessageLite> protobuf);
+      std::unique_ptr<google::protobuf::MessageLite> protobuf);
 
   // Handle a packet received over the wire.
-  void HandlePacketFromWire(scoped_ptr<google::protobuf::MessageLite> protobuf);
+  void HandlePacketFromWire(
+      std::unique_ptr<google::protobuf::MessageLite> protobuf);
 
   // ReliableMessageQueue acknowledgment helpers.
   // Handle a StreamAck sent by the server confirming receipt of all
   // messages up to the message with stream id |last_stream_id_received|.
   void HandleStreamAck(StreamId last_stream_id_received_);
   // Handle a SelectiveAck sent by the server confirming all messages
   // in |id_list|.
   void HandleSelectiveAck(const PersistentIdList& id_list);
   // Handle server confirmation of a device message, including device's
   // acknowledgment of receipt of messages.
@@ skipping 95 matching lines @@
   GCMStatsRecorder* recorder_;
 
   base::WeakPtrFactory<MCSClient> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MCSClient);
 };
 
 } // namespace gcm
 
 #endif  // GOOGLE_APIS_GCM_ENGINE_MCS_CLIENT_H_