GCM Checkin implementation with unit tests and protobufs

chrome/browser/services/gcm/gcm_profile_service.cc

 // Copyright (c) 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.
 
 #include "chrome/browser/services/gcm/gcm_profile_service.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 148 matching lines @@
 }
 
 class GCMProfileService::IOWorker
     : public GCMClient::Delegate,
       public base::RefCountedThreadSafe<GCMProfileService::IOWorker>{
  public:
   explicit IOWorker(const base::WeakPtr<GCMProfileService>& service);
 
   // Overridden from GCMClient::Delegate:
   // Called from IO thread.
-  virtual void OnCheckInFinished(const GCMClient::CheckInInfo& checkin_info,
+  virtual void OnCheckInFinished(const GCMClient::CheckinInfo& checkin_info,
                                  GCMClient::Result result) OVERRIDE;
   virtual void OnRegisterFinished(const std::string& app_id,
                                   const std::string& registration_id,
                                   GCMClient::Result result) OVERRIDE;
   virtual void OnSendFinished(const std::string& app_id,
                               const std::string& message_id,
                               GCMClient::Result result) OVERRIDE;
   virtual void OnMessageReceived(
       const std::string& app_id,
       const GCMClient::IncomingMessage& message) OVERRIDE;
   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
   virtual void OnMessageSendError(const std::string& app_id,
                                   const std::string& message_id,
                                   GCMClient::Result result) OVERRIDE;
-  virtual GCMClient::CheckInInfo GetCheckInInfo() const OVERRIDE;
+  virtual GCMClient::CheckinInfo GetCheckinInfo() const OVERRIDE;
   virtual void OnLoadingCompleted() OVERRIDE;
   virtual base::TaskRunner* GetFileTaskRunner() OVERRIDE;
 
   void CheckGCMClientLoading();
   void SetUser(const std::string& username);
   void RemoveUser(const std::string& username);
   void CheckIn();
-  void SetCheckInInfo(GCMClient::CheckInInfo checkin_info);
+  void SetCheckinInfo(GCMClient::CheckinInfo checkin_info);

[Nicolas Zea, 2014/01/07 00:41:52]

const ref

[fgorski, 2014/01/07 23:46:44]

Added TODO.

   void CheckOut();
   void Register(const std::string& app_id,
                 const std::vector<std::string>& sender_ids,
                 const std::string& cert);
   void Unregister(const std::string& app_id);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message);
 
  private:
   friend class base::RefCountedThreadSafe<IOWorker>;
   virtual ~IOWorker();
 
   const base::WeakPtr<GCMProfileService> service_;
 
   // The username (email address) of the signed-in user.
   std::string username_;
 
   // The checkin info obtained from the server for the signed in user associated
   // with the profile.
-  GCMClient::CheckInInfo checkin_info_;
+  GCMClient::CheckinInfo checkin_info_;
 };
 
 GCMProfileService::IOWorker::IOWorker(
     const base::WeakPtr<GCMProfileService>& service)
     : service_(service) {
 }
 
 GCMProfileService::IOWorker::~IOWorker() {
 }
 
 void GCMProfileService::IOWorker::OnCheckInFinished(
-    const GCMClient::CheckInInfo& checkin_info,
+    const GCMClient::CheckinInfo& checkin_info,
     GCMClient::Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   checkin_info_ = checkin_info;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMProfileService::CheckInFinished,
                  service_,
@@ skipping 67 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMProfileService::MessageSendError,
                  service_,
                  app_id,
                  message_id,
                  result));
 }
 
-GCMClient::CheckInInfo GCMProfileService::IOWorker::GetCheckInInfo() const {
+GCMClient::CheckinInfo GCMProfileService::IOWorker::GetCheckinInfo() const {
   return checkin_info_;
 }
 
 void GCMProfileService::IOWorker::OnLoadingCompleted() {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMProfileService::GCMClientLoadingFinished,
                  service_));
 }
@@ skipping 29 matching lines @@
   username_.clear();
   GCMClient::Get()->SetUserDelegate(username_, NULL);
 }
 
 void GCMProfileService::IOWorker::CheckIn() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   GCMClient::Get()->CheckIn(username_);
 }
 
-void GCMProfileService::IOWorker::SetCheckInInfo(
-    GCMClient::CheckInInfo checkin_info) {
+void GCMProfileService::IOWorker::SetCheckinInfo(
+    GCMClient::CheckinInfo checkin_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   checkin_info_ = checkin_info;
 }
 
 void GCMProfileService::IOWorker::CheckOut() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   username_.clear();
   checkin_info_.Reset();
@@ skipping 288 matching lines @@
   PrefService* pref_service = profile_->GetPrefs();
   uint64 android_id = pref_service->GetUint64(prefs::kGCMUserAccountID);
   std::string base64_token = pref_service->GetString(prefs::kGCMUserToken);
   std::string encrypted_secret;
   base::Base64Decode(base::StringPiece(base64_token), &encrypted_secret);
   if (android_id && !encrypted_secret.empty()) {
     std::string decrypted_secret;
     Encryptor::DecryptString(encrypted_secret, &decrypted_secret);
     uint64 secret = 0;
     if (base::StringToUint64(decrypted_secret, &secret) && secret) {
-      GCMClient::CheckInInfo checkin_info;
+      GCMClient::CheckinInfo checkin_info;
       checkin_info.android_id = android_id;
       checkin_info.secret = secret;
       content::BrowserThread::PostTask(
           content::BrowserThread::IO,
           FROM_HERE,
-          base::Bind(&GCMProfileService::IOWorker::SetCheckInInfo,
+          base::Bind(&GCMProfileService::IOWorker::SetCheckinInfo,
                      io_worker_,
                      checkin_info));
 
       if (testing_delegate_)
         testing_delegate_->CheckInFinished(checkin_info, GCMClient::SUCCESS);
 
       return;
     }
   }
 
@@ skipping 38 matching lines @@
   // unregister request fails. If this occurs, it does not bring any harm since
   // we simply reject the messages/events received from the server.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::Unregister,
                  io_worker_,
                  app_id));
 }
 
-void GCMProfileService::CheckInFinished(GCMClient::CheckInInfo checkin_info,
+void GCMProfileService::CheckInFinished(GCMClient::CheckinInfo checkin_info,
                                         GCMClient::Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Save the check-in info into the profile's prefs store.
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->SetUint64(prefs::kGCMUserAccountID, checkin_info.android_id);
 
   // Encrypt the secret for persisting purpose.
   std::string encrypted_secret;
   Encryptor::EncryptString(base::Uint64ToString(checkin_info.secret),
@@ skipping 190 matching lines @@
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm