OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "google_apis/gcm/engine/user_list.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/files/file_path.h" | |
9 #include "base/location.h" | |
10 #include "base/logging.h" | |
11 #include "base/memory/scoped_ptr.h" | |
12 #include "base/message_loop/message_loop.h" | |
13 #include "base/message_loop/message_loop_proxy.h" | |
14 #include "base/sequenced_task_runner.h" | |
15 #include "base/strings/string_number_conversions.h" | |
16 #include "base/strings/string_piece.h" | |
17 #include "third_party/leveldatabase/src/include/leveldb/db.h" | |
18 | |
19 namespace gcm { | |
20 const int64 kInvalidSerialNumber = -1; | |
21 | |
22 UserList::UserInfo::UserInfo() | |
23 : serial_number(kInvalidSerialNumber), | |
24 delegate(NULL) { | |
25 } | |
26 | |
27 UserList::UserInfo::UserInfo(int64 serial_number) | |
28 : serial_number(serial_number), | |
29 delegate(NULL) { | |
30 } | |
31 | |
32 UserList::UserInfo::UserInfo(GCMClient::Delegate* delegate, | |
33 const SetDelegateCallback& callback) | |
34 : serial_number(kInvalidSerialNumber), | |
35 delegate(delegate), | |
36 callback(callback) { | |
37 } | |
38 | |
39 UserList::UserInfo::~UserInfo() { | |
40 } | |
41 | |
42 UserList::UserList(GCMStore* gcm_store) | |
43 : initialized_(false), | |
44 next_serial_number_(kInvalidSerialNumber), | |
45 gcm_store_(gcm_store) { | |
46 } | |
47 | |
48 UserList::~UserList() { | |
49 } | |
50 | |
51 void UserList::Initialize(const GCMStore::SerialNumberMappings& result) { | |
52 DCHECK(!initialized_); | |
53 DCHECK_GT(result.next_serial_number, 0); | |
54 | |
55 next_serial_number_ = result.next_serial_number; | |
56 for (std::map<std::string, int64>::const_iterator iter = | |
57 result.user_serial_numbers.begin(); | |
58 iter != result.user_serial_numbers.end(); | |
59 ++iter) { | |
60 SetSerialNumber(iter->first, iter->second); | |
61 } | |
62 initialized_ = true; | |
jianli
2014/01/15 22:43:37
nit: it is a bit bizarre to set initialized_ in th
fgorski
2014/01/15 23:22:50
Done.
| |
63 | |
64 for (UserInfoMap::iterator iter = delegates_.begin(); | |
65 iter != delegates_.end(); | |
66 ++iter) { | |
67 // Process only users with delegate and callback present. | |
68 if (iter->second.delegate && !iter->second.callback.is_null()) { | |
69 if (iter->second.serial_number == kInvalidSerialNumber) | |
70 AssignSerialNumber(iter->first); | |
71 else | |
72 OnSerialNumberReady(iter); | |
73 } | |
74 } | |
75 } | |
76 | |
77 void UserList::SetDelegate(const std::string& username, | |
78 GCMClient::Delegate* delegate, | |
79 const SetDelegateCallback& callback) { | |
80 DCHECK(!username.empty()); | |
81 DCHECK(delegate); | |
82 | |
83 UserInfoMap::iterator iter = delegates_.find(username); | |
84 if (iter != delegates_.end()) { | |
85 DCHECK(initialized_); | |
86 DCHECK(!iter->second.delegate); | |
87 iter->second.delegate = delegate; | |
88 iter->second.callback = callback; | |
89 } else { | |
90 delegates_.insert( | |
91 iter, | |
92 UserInfoMap::value_type(username, UserInfo(delegate, callback))); | |
93 } | |
94 | |
95 if (initialized_) { | |
96 UserInfoMap::iterator iter = delegates_.find(username); | |
97 if (iter->second.serial_number == kInvalidSerialNumber) | |
98 AssignSerialNumber(iter->first); | |
99 else | |
100 OnSerialNumberReady(iter); | |
101 } | |
102 } | |
103 | |
104 void UserList::AssignSerialNumber(const std::string& username) { | |
105 DCHECK(initialized_); | |
106 DCHECK_EQ(delegates_.count(username), 1UL); | |
107 DCHECK_EQ(delegates_[username].serial_number, kInvalidSerialNumber); | |
108 | |
109 // Start by incrementing the |next_serial_number_| and persist it in the GCM | |
110 // store. | |
111 int64 serial_number = next_serial_number_++; | |
jianli
2014/01/15 22:43:37
Do we need to handle overflow?
fgorski
2014/01/15 23:22:50
Only if we think the user will create 2^63 profile
| |
112 gcm_store_->SetNextSerialNumber( | |
113 serial_number, | |
114 base::Bind(&UserList::IncrementSerialNumberCompleted, | |
115 base::Unretained(this), | |
116 username, | |
117 serial_number)); | |
118 } | |
119 | |
120 void UserList::IncrementSerialNumberCompleted(const std::string& username, | |
121 int64 user_serial_number, | |
122 bool success) { | |
123 // TODO(fgorski): Introduce retry logic. | |
124 if (!success) | |
125 DCHECK(success) << "Updating the next serial number failed."; | |
126 | |
127 SetSerialNumber(username, user_serial_number); | |
128 gcm_store_->AddUserSerialNumber( | |
129 username, | |
130 user_serial_number, | |
131 base::Bind(&UserList::AssignSerialNumberCompleted, | |
132 base::Unretained(this), | |
133 username)); | |
134 } | |
135 | |
136 void UserList::AssignSerialNumberCompleted(const std::string& username, | |
137 bool success) { | |
138 // TODO(fgorski): Introduce retry logic. | |
139 if (!success) { | |
140 DVLOG(1) << "It was not possible to persist username to serial number" | |
141 << " mapping for username: " << username; | |
142 return; | |
143 } | |
144 | |
145 UserInfoMap::iterator iter = delegates_.find(username); | |
146 DCHECK(iter != delegates_.end()); | |
147 OnSerialNumberReady(iter); | |
148 } | |
149 | |
150 void UserList::OnSerialNumberReady(const UserInfoMap::iterator& iter) { | |
151 base::MessageLoop::current()->PostTask( | |
152 FROM_HERE, | |
153 base::Bind(iter->second.callback, | |
154 iter->first, | |
155 iter->second.serial_number)); | |
156 iter->second.callback.Reset(); | |
157 } | |
158 | |
159 void UserList::SetSerialNumber(const std::string& username, | |
160 int64 serial_number) { | |
161 DCHECK(!username.empty()); | |
162 DCHECK_GT(serial_number, 0L); | |
163 | |
164 UserInfoMap::iterator iter = delegates_.find(username); | |
165 if (iter != delegates_.end()) { | |
166 DCHECK_EQ(iter->second.serial_number, kInvalidSerialNumber); | |
167 iter->second.serial_number = serial_number; | |
168 } else { | |
169 delegates_.insert( | |
170 iter, UserInfoMap::value_type(username, UserInfo(serial_number))); | |
171 } | |
172 } | |
173 | |
174 GCMClient::Delegate* UserList::GetDelegateBySerialNumber(int64 serial_number) | |
175 const { | |
176 for (UserInfoMap::const_iterator iter = delegates_.begin(); | |
177 iter != delegates_.end(); | |
178 ++iter) { | |
179 if (iter->second.serial_number == serial_number) | |
180 return iter->second.delegate; | |
181 } | |
182 return NULL; | |
183 } | |
184 | |
185 GCMClient::Delegate* UserList::GetDelegateByUsername( | |
186 const std::string& username) const { | |
187 UserInfoMap::const_iterator iter = delegates_.find(username); | |
188 return iter != delegates_.end() ? iter->second.delegate : NULL; | |
189 } | |
190 | |
191 int64 UserList::GetSerialNumberForUsername(const std::string& username) const { | |
192 UserInfoMap::const_iterator iter = delegates_.find(username); | |
193 return iter != delegates_.end() ? iter->second.serial_number | |
194 : kInvalidSerialNumber; | |
195 } | |
196 | |
197 } // namespace gcm | |
OLD | NEW |