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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
// 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 <vector>
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/stl_util.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/engine/registration_request.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 Clock;
} // namespace base
namespace net {
class HttpNetworkSession;
} // namespace net
namespace gcm {
class CheckinRequest;
class ConnectionFactory;
class GCMClientImplTest;
class UnregistrationRequest;
// 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();
// Overridden from GCMClient:
virtual void Initialize(
const checkin_proto::ChromeBuildProto& chrome_build_proto,
const base::FilePath& store_path,
const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
const scoped_refptr<net::URLRequestContextGetter>&
url_request_context_getter,
Delegate* delegate) OVERRIDE;
virtual void CheckOut() OVERRIDE;
virtual void Register(const std::string& app_id,
const std::string& cert,
const std::vector<std::string>& sender_ids) OVERRIDE;
virtual void Unregister(const std::string& app_id) OVERRIDE;
virtual void Send(const std::string& app_id,
const std::string& receiver_id,
const OutgoingMessage& message) OVERRIDE;
virtual bool IsReady() 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,
};
// The check-in info for the user. Returned by the server.
struct GCM_EXPORT CheckinInfo {
CheckinInfo() : android_id(0), secret(0) {}
bool IsValid() const { return android_id != 0 && secret != 0; }
void Reset() {
android_id = 0;
secret = 0;
}
uint64 android_id;
uint64 secret;
};
// Collection of pending registration requests. Keys are app IDs, while values
// are pending registration requests to obtain a registration ID for
// requesting application.
typedef std::map<std::string, RegistrationRequest*>
PendingRegistrations;
// Collection of pending unregistration requests. Keys are app IDs, while
// values are pending unregistration requests to disable the registration ID
// currently assigned to the application.
typedef std::map<std::string, UnregistrationRequest*>
PendingUnregistrations;
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(scoped_ptr<GCMStore::LoadResult> result);
// Initializes mcs_client_, which handles the connection to MCS.
void InitializeMCSClient(scoped_ptr<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();
// Sets state to ready. This will initiate the MCS login and notify the
// delegates.
void OnReady();
// Starts a first time device checkin.
void StartCheckin(const CheckinInfo& checkin_info);
// Completes the device checkin request.
// |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(uint64 android_id,
uint64 security_token);
// Callback for persisting device credentials in the |gcm_store_|.
void SetDeviceCredentialsCallback(bool success);
// Completes the registration request.
void OnRegisterCompleted(const std::string& app_id,
RegistrationRequest::Status status,
const std::string& registration_id);
// Completes the unregistration request.
void OnUnregisterCompleted(const std::string& app_id, bool status);
// Handles incoming data message and dispatches it the a relevant user
// delegate.
void HandleIncomingMessage(const gcm::MCSMessage& message);
// Fires OnMessageSendError event on |delegate|, with specified |app_id| and
// message ID obtained from |incoming_message| if one is available.
void NotifyDelegateOnMessageSendError(
GCMClient::Delegate* delegate,
const std::string& app_id,
const IncomingMessage& incoming_message);
// For testing purpose only.
// Sets an |mcs_client_| for testing. Takes the ownership of |mcs_client|.
// TODO(fgorski): Remove this method. Create GCMEngineFactory that will create
// components of the engine.
void SetMCSClientForTesting(scoped_ptr<MCSClient> mcs_client);
// State of the GCM Client Implementation.
State state_;
Delegate* delegate_;
// Device checkin info (android ID and security token used by device).
CheckinInfo device_checkin_info_;
// Clock used for timing of retry logic. Passed in for testing. Owned by
// GCMClientImpl.
scoped_ptr<base::Clock> 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_;
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_;
scoped_ptr<CheckinRequest> checkin_request_;
// Currently pending registrations. GCMClientImpl owns the
// RegistrationRequests.
PendingRegistrations pending_registrations_;
STLValueDeleter<PendingRegistrations> pending_registrations_deleter_;
// Currently pending unregistrations. GCMClientImpl owns the
// UnregistrationRequests.
PendingUnregistrations pending_unregistrations_;
STLValueDeleter<PendingUnregistrations> pending_unregistrations_deleter_;
// Factory for creating references in callbacks.
base::WeakPtrFactory<GCMClientImpl> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(GCMClientImpl);
};
} // namespace gcm
#endif // GOOGLE_APIS_GCM_GCM_CLIENT_IMPL_H_
|
