[GCM] Add app handler support for connection events

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"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 #include "components/gcm_driver/gcm_client_factory.h"
 #include "components/gcm_driver/system_encryptor.h"
 #include "google_apis/gaia/oauth2_token_service.h"
+#include "net/base/ip_endpoint.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace gcm {
 
+namespace {
+
+// Empty string is reserved for the default app handler.
+const char kDefaultAppHandler[] = "";
+
+}  // namespace
+
 // Helper class to save tasks to run until we're ready to execute them.
 class GCMDriverDesktop::DelayedTaskController {
  public:
   DelayedTaskController();
   ~DelayedTaskController();
 
   // Adds a task that will be invoked once we're ready.
   void AddTask(const base::Closure& task);
 
   // Sets ready status. It is ready only when check-in is completed and
@@ skipping 62 matching lines @@
                               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 GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
   virtual void OnGCMReady() OVERRIDE;
   virtual void OnActivityRecorded() OVERRIDE;
+  virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE;
+  virtual 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 std::vector<std::string>& account_ids,
       const scoped_refptr<net::URLRequestContextGetter>& request_context,
       const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
   void Start(const base::WeakPtr<GCMDriverDesktop>& service);
@@ skipping 127 matching lines @@
       base::Bind(&GCMDriverDesktop::GCMClientReady, service_));
 }
 
 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(
+    const net::IPEndPoint& ip_endpoint) {
+  ui_thread_->PostTask(FROM_HERE,
+                       base::Bind(&GCMDriverDesktop::OnConnected,
+                                  service_,
+                                  ip_endpoint));
+}
+
+void GCMDriverDesktop::IOWorker::OnDisconnected() {
+  ui_thread_->PostTask(FROM_HERE,
+                       base::Bind(&GCMDriverDesktop::OnDisconnected, service_));
+}
+
 void GCMDriverDesktop::IOWorker::Start(
     const base::WeakPtr<GCMDriverDesktop>& service) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   service_ = service;
   gcm_client_->Start();
 }
 
 void GCMDriverDesktop::IOWorker::Stop() {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
@@ skipping 67 matching lines @@
     scoped_ptr<GCMClientFactory> gcm_client_factory,
     scoped_ptr<IdentityProvider> identity_provider,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
     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,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner)
     : gcm_enabled_(true),
       gcm_client_ready_(false),
+      connected_(false),
       identity_provider_(identity_provider.Pass()),
       ui_thread_(ui_thread),
       io_thread_(io_thread),
       weak_ptr_factory_(this) {
   // Get the list of available accounts.
   std::vector<std::string> account_ids;
   account_ids = identity_provider_->GetTokenService()->GetAccounts();
 
   // Create and initialize the GCMClient. Note that this does not initiate the
   // GCM check-in.
@@ skipping 177 matching lines @@
 bool GCMDriverDesktop::IsStarted() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return !account_id_.empty();
 }
 
 bool GCMDriverDesktop::IsGCMClientReady() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return gcm_client_ready_;
 }
 
+bool GCMDriverDesktop::IsConnected() const {
+  return connected_;
+}
+
 void GCMDriverDesktop::GetGCMStatistics(
     const GetGCMStatisticsCallback& callback,
     bool clear_logs) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   DCHECK(!callback.is_null());
 
   request_gcm_statistics_callback_ = callback;
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::GetGCMStatistics,
@@ skipping 113 matching lines @@
 void GCMDriverDesktop::GCMClientReady() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   if (gcm_client_ready_)
     return;
   gcm_client_ready_ = true;
 
   delayed_task_controller_->SetReady();
 }
 
+void GCMDriverDesktop::OnConnected(const net::IPEndPoint& ip_endpoint) {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  connected_ = true;
+
+  // Drop the event if signed out.
+  if (account_id_.empty())
+    return;
+
+  const GCMAppHandlerMap& app_handler_map = app_handlers();
+  for (GCMAppHandlerMap::const_iterator iter = app_handler_map.begin();
+       iter != app_handler_map.end(); ++iter) {
+    iter->second->OnConnected(ip_endpoint);
+  }
+
+  GetAppHandler(kDefaultAppHandler)->OnConnected(ip_endpoint);
+}
+
+void GCMDriverDesktop::OnDisconnected() {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  connected_ = false;
+
+  // Drop the event if signed out.
+  if (account_id_.empty())
+    return;
+
+  const GCMAppHandlerMap& app_handler_map = app_handlers();
+  for (GCMAppHandlerMap::const_iterator iter = app_handler_map.begin();
+       iter != app_handler_map.end(); ++iter) {
+    iter->second->OnDisconnected();
+  }
+
+  GetAppHandler(kDefaultAppHandler)->OnDisconnected();
+}
+
 void GCMDriverDesktop::GetGCMStatisticsFinished(
     const GCMClient::GCMStatistics& stats) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // 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.";
 }
 
 std::string GCMDriverDesktop::SignedInUserName() const {
   if (IsStarted())
     return identity_provider_->GetActiveUsername();
   return std::string();
 }
 
 }  // namespace gcm
+