[GCM] Adding last token fetching time handling

components/gcm_driver/gcm_driver_desktop.cc

 // Copyright 2014 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 "components/gcm_driver/gcm_driver_desktop.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 33 matching lines @@
                       const std::string& message_id,
                       GCMClient::Result result) override;
   void OnMessageReceived(const std::string& app_id,
                          const GCMClient::IncomingMessage& message) override;
   void OnMessagesDeleted(const std::string& app_id) override;
   void OnMessageSendError(
       const std::string& app_id,
       const GCMClient::SendErrorDetails& send_error_details) override;
   void OnSendAcknowledged(const std::string& app_id,
                           const std::string& message_id) override;
-  void OnGCMReady(const std::vector<AccountMapping>& account_mappings) override;
+  void OnGCMReady(const std::vector<AccountMapping>& account_mappings,
+                  const base::Time& last_token_fetching_time) override;
   void OnActivityRecorded() override;
   void OnConnected(const net::IPEndPoint& ip_endpoint) override;
   void OnDisconnected() override;
 
   // Called on IO thread.
   void Initialize(
       scoped_ptr<GCMClientFactory> gcm_client_factory,
       const GCMClient::ChromeBuildInfo& chrome_build_info,
       const base::FilePath& store_path,
       const scoped_refptr<net::URLRequestContextGetter>& request_context,
       const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
   void Start(const base::WeakPtr<GCMDriverDesktop>& service);
   void Stop();
   void CheckOut();
   void Register(const std::string& app_id,
                 const std::vector<std::string>& sender_ids);
   void Unregister(const std::string& app_id);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message);
   void GetGCMStatistics(bool clear_logs);
   void SetGCMRecording(bool recording);
 
   void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens);
   void UpdateAccountMapping(const AccountMapping& account_mapping);
   void RemoveAccountMapping(const std::string& account_id);
+  void SetLastTokenFetchingTime(const base::Time& time);
 
   // For testing purpose. Can be called from UI thread. Use with care.
   GCMClient* gcm_client_for_testing() const { return gcm_client_.get(); }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> io_thread_;
 
   base::WeakPtr<GCMDriverDesktop> service_;
 
@@ skipping 104 matching lines @@
     const std::string& message_id) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   ui_thread_->PostTask(
       FROM_HERE,
       base::Bind(
           &GCMDriverDesktop::SendAcknowledged, service_, app_id, message_id));
 }
 
 void GCMDriverDesktop::IOWorker::OnGCMReady(
-    const std::vector<AccountMapping>& account_mappings) {
+    const std::vector<AccountMapping>& account_mappings,
+    const base::Time& last_token_fetching_time) {
   ui_thread_->PostTask(
       FROM_HERE,
-      base::Bind(
-          &GCMDriverDesktop::GCMClientReady, service_, account_mappings));
+      base::Bind(&GCMDriverDesktop::GCMClientReady,
+                 service_,
+                 account_mappings,
+                 last_token_fetching_time));
 }
 
 void GCMDriverDesktop::IOWorker::OnActivityRecorded() {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
   // When an activity is recorded, get all the stats and refresh the UI of
   // gcm-internals page.
   GetGCMStatistics(false);
 }
 
 void GCMDriverDesktop::IOWorker::OnConnected(
@@ skipping 102 matching lines @@
 }
 
 void GCMDriverDesktop::IOWorker::RemoveAccountMapping(
     const std::string& account_id) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   if (gcm_client_.get())
     gcm_client_->RemoveAccountMapping(account_id);
 }
 
+void GCMDriverDesktop::IOWorker::SetLastTokenFetchingTime(
+    const base::Time& time) {
+  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+
+  if (gcm_client_.get())
+    gcm_client_->SetLastTokenFetchingTime(time);
+}
+
 GCMDriverDesktop::GCMDriverDesktop(
     scoped_ptr<GCMClientFactory> gcm_client_factory,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
     const std::string& channel_status_request_url,
     const std::string& user_agent,
     PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
     const scoped_refptr<base::SequencedTaskRunner>& io_thread,
@@ skipping 278 matching lines @@
 void GCMDriverDesktop::RemoveAccountMapping(const std::string& account_id) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::RemoveAccountMapping,
                  base::Unretained(io_worker_.get()),
                  account_id));
 }
 
+base::Time GCMDriverDesktop::GetLastTokenFetchingTime() {
+  return last_token_fetching_time_;
+}
+
+void GCMDriverDesktop::SetLastTokenFetchingTime(const base::Time& time) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  io_thread_->PostTask(
+      FROM_HERE,
+      base::Bind(&GCMDriverDesktop::IOWorker::SetLastTokenFetchingTime,
+                 base::Unretained(io_worker_.get()),
+                 time));
+}
+
 void GCMDriverDesktop::SetAccountTokens(
     const std::vector<GCMClient::AccountTokenInfo>& account_tokens) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   account_mapper_->SetAccountTokens(account_tokens);
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::SetAccountTokens,
                  base::Unretained(io_worker_.get()),
@@ skipping 95 matching lines @@
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // Drop the event if the service has been stopped.
   if (!gcm_started_)
     return;
 
   GetAppHandler(app_id)->OnSendAcknowledged(app_id, message_id);
 }
 
 void GCMDriverDesktop::GCMClientReady(
-    const std::vector<AccountMapping>& account_mappings) {
+    const std::vector<AccountMapping>& account_mappings,
+    const base::Time& last_token_fetching_time) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   GCMDriver::AddAppHandler(kGCMAccountMapperAppId, account_mapper_.get());
   account_mapper_->Initialize(account_mappings);
+  last_token_fetching_time_ = last_token_fetching_time;
 
   delayed_task_controller_->SetReady();
 }
 
 void GCMDriverDesktop::OnConnected(const net::IPEndPoint& ip_endpoint) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   connected_ = true;
 
   // Drop the event if the service has been stopped.
@@ skipping 24 matching lines @@
 
   // Normally request_gcm_statistics_callback_ would not be null.
   if (!request_gcm_statistics_callback_.is_null())
     request_gcm_statistics_callback_.Run(stats);
   else
     LOG(WARNING) << "request_gcm_statistics_callback_ is NULL.";
 }
 
 }  // namespace gcm