Switch to standard integer types in google_apis/.

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 <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"
 
@@ skipping 60 matching lines @@
 
   // Callback for MCSClient's error conditions.
   // TODO(fgorski): Keeping it as a callback with intention to add meaningful
   // error information.
   typedef base::Callback<void()> ErrorCallback;
   // Callback when a message is received.
   typedef base::Callback<void(const MCSMessage& message)>
       OnMessageReceivedCallback;
   // Callback when a message is sent (and receipt has been acknowledged by
   // the MCS endpoint).
-  typedef base::Callback<
-      void(int64 user_serial_number,
-           const std::string& app_id,
-           const std::string& message_id,
-           MessageSendStatus status)> OnMessageSentCallback;
+  typedef base::Callback<void(int64_t user_serial_number,
+                              const std::string& app_id,
+                              const std::string& message_id,
+                              MessageSendStatus status)> OnMessageSentCallback;
 
   MCSClient(const std::string& version_string,
             base::Clock* clock,
             ConnectionFactory* connection_factory,
             GCMStore* gcm_store,
             GCMStatsRecorder* recorder);
   virtual ~MCSClient();
 
   // Initialize the client. Will load any previous id/token information as well
   // as unacknowledged message information from the GCM storage, if it exists,
   // 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);
 
   // 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 android_id, uint64 security_token);
+  virtual void Login(uint64_t android_id, uint64_t security_token);
 
   // Sends a message, with or without reliable message queueing (RMQ) support.
   // Will asynchronously invoke the OnMessageSent callback regardless.
   // Whether to use RMQ depends on whether the protobuf has |ttl| set or not.
   // |ttl == 0| denotes the message should only be sent if the connection is
   // open. |ttl > 0| will keep the message saved for |ttl| seconds, after which
   // it will be dropped if it was unable to be sent. When a message is dropped,
   // |message_sent_callback_| is invoked with a TTL expiration error.
   virtual void SendMessage(const MCSMessage& message);
 
@@ skipping 19 matching lines @@
   // 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);
 
   HeartbeatManager* GetHeartbeatManagerForTesting() {
     return &heartbeat_manager_;
   }
 
  private:
-  typedef uint32 StreamId;
+  typedef uint32_t StreamId;
   typedef std::string PersistentId;
   typedef std::vector<StreamId> StreamIdList;
   typedef std::vector<PersistentId> PersistentIdList;
   typedef std::map<StreamId, PersistentId> StreamIdToPersistentIdMap;
   typedef linked_ptr<ReliablePacketInfo> MCSPacketInternal;
 
   // Resets the internal state and builds a new login request, acknowledging
   // any pending server-to-device messages and rebuilding the send queue
   // from all unacknowledged device-to-server messages.
   // Should only be called when the connection has been reset.
@@ skipping 58 matching lines @@
 
   // Client state.
   State state_;
 
   // Callbacks for owner.
   ErrorCallback mcs_error_callback_;
   OnMessageReceivedCallback message_received_callback_;
   OnMessageSentCallback message_sent_callback_;
 
   // The android id and security token in use by this device.
-  uint64 android_id_;
-  uint64 security_token_;
+  uint64_t android_id_;
+  uint64_t security_token_;
 
   // Factory for creating new connections and connection handlers.
   ConnectionFactory* connection_factory_;
 
   // Connection handler to handle all over-the-wire protocol communication
   // with the mobile connection server.
   ConnectionHandler* connection_handler_;
 
   // -----  Reliablie Message Queue section -----
   // Note: all queues/maps are ordered from oldest (front/begin) message to
@@ skipping 46 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_