Move IdentityProvider usage from GCMDriverDesktop to GCMProfileService

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[] = "";
 
@@ skipping 82 matching lines @@
   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);
   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,
@@ skipping 24 matching lines @@
 }
 
 GCMDriverDesktop::IOWorker::~IOWorker() {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 }
 
 void GCMDriverDesktop::IOWorker::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) {
   DCHECK(io_thread_->RunsTasksOnCurrentThread());
 
   gcm_client_ = gcm_client_factory->BuildInstance();
 
   gcm_client_->Initialize(chrome_build_info,
                           store_path,
-                          account_ids,
                           blocking_task_runner,
                           request_context,
                           make_scoped_ptr<Encryptor>(new SystemEncryptor),
                           this);
 }
 
 void GCMDriverDesktop::IOWorker::OnRegisterFinished(
     const std::string& app_id,
     const std::string& registration_id,
     GCMClient::Result result) {
@@ skipping 157 matching lines @@
     stats.gcm_client_created = true;
   }
 
   ui_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::GetGCMStatisticsFinished, service_, stats));
 }
 
 GCMDriverDesktop::GCMDriverDesktop(
     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),
+    : signed_in_(false),
+      gcm_started_(false),
+      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.
   io_worker_.reset(new IOWorker(ui_thread, io_thread));
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Initialize,
                  base::Unretained(io_worker_.get()),
                  base::Passed(&gcm_client_factory),
                  chrome_build_info,
                  store_path,
-                 account_ids,
                  request_context,
                  blocking_task_runner));
-
-  identity_provider_->AddObserver(this);
 }
 
 GCMDriverDesktop::~GCMDriverDesktop() {
 }
 
-void GCMDriverDesktop::OnActiveAccountLogin() {
-  EnsureStarted();
-}
-
-void GCMDriverDesktop::OnActiveAccountLogout() {
-  CheckOut();
-}
-
 void GCMDriverDesktop::Shutdown() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
-  identity_provider_->RemoveObserver(this);
   GCMDriver::Shutdown();
   io_thread_->DeleteSoon(FROM_HERE, io_worker_.release());
 }
 
+void GCMDriverDesktop::OnSignedIn() {
+  signed_in_ = true;
+  EnsureStarted();
+}
+
+void GCMDriverDesktop::Purge() {
+  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+
+  // We still proceed with the check-out logic even if the check-in is not
+  // initiated in the current session. This will make sure that all the
+  // persisted data written previously will get purged.
+  signed_in_ = false;
+  RemoveCachedData();
+
+  io_thread_->PostTask(FROM_HERE,
+                       base::Bind(&GCMDriverDesktop::IOWorker::CheckOut,
+                       base::Unretained(io_worker_.get())));
+}
+
 void GCMDriverDesktop::AddAppHandler(const std::string& app_id,
                                      GCMAppHandler* handler) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   GCMDriver::AddAppHandler(app_id, handler);
 
    // Ensures that the GCM service is started when there is an interest.
   EnsureStarted();
 }
 
 void GCMDriverDesktop::RemoveAppHandler(const std::string& app_id) {
@@ skipping 22 matching lines @@
     return;
   gcm_enabled_ = false;
 
   Stop();
 }
 
 void GCMDriverDesktop::Stop() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
   // No need to stop GCM service if not started yet.
-  if (account_id_.empty())
+  if (!gcm_started_)
     return;
 
   RemoveCachedData();
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Stop,
                  base::Unretained(io_worker_.get())));
 }
 
@@ skipping 83 matching lines @@
                  message));
 }
 
 GCMClient* GCMDriverDesktop::GetGCMClientForTesting() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return io_worker_ ? io_worker_->gcm_client_for_testing() : NULL;
 }
 
 bool GCMDriverDesktop::IsStarted() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
-  return !account_id_.empty();
+  return gcm_started_;
 }
 
 bool GCMDriverDesktop::IsGCMClientReady() const {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   return gcm_client_ready_;
 }
 
 bool GCMDriverDesktop::IsConnected() const {
   return connected_;
 }
@@ skipping 20 matching lines @@
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::SetGCMRecording,
                  base::Unretained(io_worker_.get()),
                  recording));
 }
 
 GCMClient::Result GCMDriverDesktop::EnsureStarted() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
+  if (gcm_started_)
+    return GCMClient::SUCCESS;
+
   if (!gcm_enabled_)
     return GCMClient::GCM_DISABLED;
 
   // Have any app requested the service?
   if (app_handlers().empty())
     return GCMClient::UNKNOWN_ERROR;
 
-  // Is the user signed in?
-  const std::string account_id = identity_provider_->GetActiveAccountId();
-  if (account_id.empty())
+  // TODO(jianli): To be removed when sign-in enforcement is dropped.
+  if (!signed_in_)
     return GCMClient::NOT_SIGNED_IN;
 
-  // CheckIn could be called more than once when:
-  // 1) The password changes.
-  // 2) Register/send function calls it to ensure CheckIn is done.
-  if (account_id_ == account_id)
-    return GCMClient::SUCCESS;
-  account_id_ = account_id;
-
   DCHECK(!delayed_task_controller_);
   delayed_task_controller_.reset(new DelayedTaskController);
 
   // Note that we need to pass weak pointer again since the existing weak
   // pointer in IOWorker might have been invalidated when check-out occurs.
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&GCMDriverDesktop::IOWorker::Start,
                  base::Unretained(io_worker_.get()),
                  weak_ptr_factory_.GetWeakPtr()));
 
+  gcm_started_ = true;
   return GCMClient::SUCCESS;
 }
 
 void GCMDriverDesktop::RemoveCachedData() {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
   // Remove all the queued tasks since they no longer make sense after
   // GCM service is stopped.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
-  account_id_.clear();
+  gcm_started_ = false;
   gcm_client_ready_ = false;
   delayed_task_controller_.reset();
   ClearCallbacks();
 }
 
-void GCMDriverDesktop::CheckOut() {
-  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
-
-  // We still proceed with the check-out logic even if the check-in is not
-  // initiated in the current session. This will make sure that all the
-  // persisted data written previously will get purged.
-
-  RemoveCachedData();
-
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriverDesktop::IOWorker::CheckOut,
-                 base::Unretained(io_worker_.get())));
-}
-
 void GCMDriverDesktop::MessageReceived(
     const std::string& app_id,
     const GCMClient::IncomingMessage& message) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
-  // Drop the event if signed out.
-  if (account_id_.empty())
+  // Drop the event if the service has been stopped.
+  if (!gcm_started_)
     return;
 
   GetAppHandler(app_id)->OnMessage(app_id, message);
 }
 
 void GCMDriverDesktop::MessagesDeleted(const std::string& app_id) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
-  // Drop the event if signed out.
-  if (account_id_.empty())
+  // Drop the event if the service has been stopped.
+  if (!gcm_started_)
     return;
 
   GetAppHandler(app_id)->OnMessagesDeleted(app_id);
 }
 
 void GCMDriverDesktop::MessageSendError(
     const std::string& app_id,
     const GCMClient::SendErrorDetails& send_error_details) {
   DCHECK(ui_thread_->RunsTasksOnCurrentThread());
 
-  // Drop the event if signed out.
-  if (account_id_.empty())
+  // Drop the event if the service has been stopped.
+  if (!gcm_started_)
     return;
 
   GetAppHandler(app_id)->OnSendError(app_id, send_error_details);
 }
 
 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())
+  if (!signed_in_)
     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())
+  if (!signed_in_)
     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