1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
// 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_GCM_CLIENT_IMPL_H_
#define GOOGLE_APIS_GCM_GCM_CLIENT_IMPL_H_
#include <map>
#include <string>
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/stl_util.h"
#include "base/time/default_clock.h"
#include "google_apis/gcm/base/mcs_message.h"
#include "google_apis/gcm/engine/gcm_store.h"
#include "google_apis/gcm/engine/mcs_client.h"
#include "google_apis/gcm/gcm_client.h"
#include "google_apis/gcm/protocol/android_checkin.pb.h"
#include "net/base/net_log.h"
#include "net/url_request/url_request_context_getter.h"
namespace base {
class FilePath;
class SequencedTaskRunner;
} // namespace base
namespace net {
class HttpNetworkSession;
class URLRequestContextGetter;
}
namespace gcm {
class CheckinRequest;
class ConnectionFactory;
class GCMClientImplTest;
class UserList;
// Implements the GCM Client. It is used to coordinate MCS Client (communication
// with MCS) and other pieces of GCM infrastructure like Registration and
// Checkins. It also allows for registering user delegates that host
// applications that send and receive messages.
class GCM_EXPORT GCMClientImpl : public GCMClient {
public:
GCMClientImpl();
virtual ~GCMClientImpl();
// Begins initialization of the GCM Client.
void Initialize(
const checkin_proto::ChromeBuildProto& chrome_build_proto,
const base::FilePath& path,
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
const scoped_refptr<net::URLRequestContextGetter>&
url_request_context_getter);
// Overridden from GCMClient:
virtual void SetUserDelegate(const std::string& username,
Delegate* delegate) OVERRIDE;
virtual void CheckIn(const std::string& username) OVERRIDE;
virtual void Register(const std::string& username,
const std::string& app_id,
const std::string& cert,
const std::vector<std::string>& sender_ids) OVERRIDE;
virtual void Unregister(const std::string& username,
const std::string& app_id) OVERRIDE;
virtual void Send(const std::string& username,
const std::string& app_id,
const std::string& receiver_id,
const OutgoingMessage& message) OVERRIDE;
virtual bool IsLoading() const OVERRIDE;
private:
// State representation of the GCMClient.
enum State {
// Uninitialized.
UNINITIALIZED,
// GCM store loading is in progress.
LOADING,
// Initial device checkin is in progress.
INITIAL_DEVICE_CHECKIN,
// Ready to accept requests.
READY,
};
// Collection of pending checkin requests. Keys are serial numbers of the
// users as assigned by the user_list_. Values are pending checkin requests to
// obtain android IDs and security tokens for the users.
typedef std::map<int64, CheckinRequest*> PendingCheckins;
friend class GCMClientImplTest;
// Callbacks for the MCSClient.
// Receives messages and dispatches them to relevant user delegates.
void OnMessageReceivedFromMCS(const gcm::MCSMessage& message);
// Receives confirmation of sent messages or information about errors.
void OnMessageSentToMCS(int64 user_serial_number,
const std::string& app_id,
const std::string& message_id,
MCSClient::MessageSendStatus status);
// Receives information about mcs_client_ errors.
void OnMCSError();
// Runs after GCM Store load is done to trigger continuation of the
// initialization.
void OnLoadCompleted(const GCMStore::LoadResult& result);
// Initializes mcs_client_, which handles the connection to MCS.
void InitializeMCSClient(const GCMStore::LoadResult& result);
// Complets the first time device checkin.
void OnFirstTimeDeviceCheckinCompleted(const CheckinInfo& checkin_info);
// Starts a login on mcs_client_.
void StartMCSLogin();
// Resets state to before initialization.
void ResetState();
// Startes a checkin request for a user with specified |serial_number|.
// Checkin info can be invalid, in which case it is considered a first time
// checkin.
void StartCheckin(int64 user_serial_number,
const CheckinInfo& checkin_info);
// Completes the checkin request for the specified |serial_number|.
// |android_id| and |security_token| are expected to be non-zero or an error
// is triggered. Function also cleans up the pending checkin.
void OnCheckinCompleted(int64 user_serial_number,
uint64 android_id,
uint64 security_token);
// Completes the checkin request for a device (serial number of 0).
void OnDeviceCheckinCompleted(const CheckinInfo& checkin_info);
// Callback for persisting device credentials in the |gcm_store_|.
void SetDeviceCredentialsCallback(bool success);
// Callback for setting a delegate on a |user_list_|. Informs that the
// delegate with matching |username| was assigned a |user_serial_number|.
void SetDelegateCompleted(const std::string& username,
int64 user_serial_number);
// Handles incoming data message and dispatches it the a relevant user
// delegate.
void HandleIncomingMessage(const gcm::MCSMessage& message);
// Fires OnMessageReceived event on |delegate|, with specified |app_id| and
// |incoming_message|.
void NotifyDelegateOnMessageReceived(GCMClient::Delegate* delegate,
const std::string& app_id,
const IncomingMessage& incoming_message);
// State of the GCM Client Implementation.
State state_;
// Device checkin info (android ID and security token used by device).
CheckinInfo device_checkin_info_;
// Clock used for timing of retry logic.
base::DefaultClock clock_;
// Information about the chrome build.
// TODO(fgorski): Check if it can be passed in constructor and made const.
checkin_proto::ChromeBuildProto chrome_build_proto_;
// Persistent data store for keeping device credentials, messages and user to
// serial number mappings.
scoped_ptr<GCMStore> gcm_store_;
// Keeps the mappings of user's serial numbers and assigns new serial numbers
// once a user delegate is added for the first time.
scoped_ptr<UserList> user_list_;
scoped_refptr<net::HttpNetworkSession> network_session_;
net::BoundNetLog net_log_;
scoped_ptr<ConnectionFactory> connection_factory_;
scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
// Controls receiving and sending of packets and reliable message queueing.
scoped_ptr<MCSClient> mcs_client_;
// Currently pending checkins. GCMClientImpl owns the CheckinRequests.
PendingCheckins pending_checkins_;
STLValueDeleter<PendingCheckins> pending_checkins_deleter_;
DISALLOW_COPY_AND_ASSIGN(GCMClientImpl);
};
} // namespace gcm
#endif // GOOGLE_APIS_GCM_GCM_CLIENT_IMPL_H_
|
