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 initialized_ = true; |
| 56 next_serial_number_ = result.next_serial_number; |
| 57 for (std::map<std::string, int64>::const_iterator iter = |
| 58 result.user_serial_numbers.begin(); |
| 59 iter != result.user_serial_numbers.end(); |
| 60 ++iter) { |
| 61 SetSerialNumber(iter->first, iter->second); |
| 62 } |
| 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_++; |
| 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 |