Split GCMDriver into platform-specific implementations

components/gcm/gcm_driver.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/gcm_driver.h"
 
 #include <algorithm>
 #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/message_loop/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/gcm/gcm_app_handler.h"
 #include "components/gcm/gcm_client_factory.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "google_apis/gcm/protocol/android_checkin.pb.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace gcm {
 
-// Helper class to save tasks to run until we're ready to execute them.
-class GCMDriver::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
-  // the GCMClient is fully initialized.
-  void SetReady();
-
-  // Returns true if it is ready to perform tasks.
-  bool CanRunTaskWithoutDelay() const;
-
- private:
-  void RunTasks();
-
-  // Flag that indicates that GCM is ready.
-  bool ready_;
-
-  std::vector<base::Closure> delayed_tasks_;
-
-  DISALLOW_COPY_AND_ASSIGN(DelayedTaskController);
-};
-
-GCMDriver::DelayedTaskController::DelayedTaskController() : ready_(false) {
+GCMDriver::GCMDriver(const scoped_refptr<base::MessageLoopProxy>& ui_thread)
+    : ui_thread_(ui_thread) {
 }
 
-GCMDriver::DelayedTaskController::~DelayedTaskController() {
-}
-
-void GCMDriver::DelayedTaskController::AddTask(const base::Closure& task) {
-  delayed_tasks_.push_back(task);
-}
-
-void GCMDriver::DelayedTaskController::SetReady() {
-  ready_ = true;
-  RunTasks();
-}
-
-bool GCMDriver::DelayedTaskController::CanRunTaskWithoutDelay() const {
-  return ready_;
-}
-
-void GCMDriver::DelayedTaskController::RunTasks() {
-  DCHECK(ready_);
-
-  for (size_t i = 0; i < delayed_tasks_.size(); ++i)
-    delayed_tasks_[i].Run();
-  delayed_tasks_.clear();
-}
-
-class GCMDriver::IOWorker : public GCMClient::Delegate {
- public:
-  // Called on UI thread.
-  IOWorker(const scoped_refptr<base::MessageLoopProxy>& ui_thread,
-           const scoped_refptr<base::MessageLoopProxy>& io_thread);
-  virtual ~IOWorker();
-
-  // Overridden from GCMClient::Delegate:
-  // Called on IO thread.
-  virtual void OnRegisterFinished(const std::string& app_id,
-                                  const std::string& registration_id,
-                                  GCMClient::Result result) OVERRIDE;
-  virtual void OnUnregisterFinished(const std::string& app_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 GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
-  virtual void OnGCMReady() OVERRIDE;
-
-  // Called on IO thread.
-  void Initialize(
-      const checkin_proto::ChromeBuildProto& chrome_build_proto,
-      scoped_ptr<GCMClientFactory> gcm_client_factory,
-      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<GCMDriver>& 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);
-
-  // 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::MessageLoopProxy> ui_thread_;
-  scoped_refptr<base::MessageLoopProxy> io_thread_;
-
-  base::WeakPtr<GCMDriver> service_;
-
-  scoped_ptr<GCMClient> gcm_client_;
-
-  DISALLOW_COPY_AND_ASSIGN(IOWorker);
-};
-
-GCMDriver::IOWorker::IOWorker(
-    const scoped_refptr<base::MessageLoopProxy>& ui_thread,
-    const scoped_refptr<base::MessageLoopProxy>& io_thread)
-    : ui_thread_(ui_thread),
-      io_thread_(io_thread) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-}
-
-GCMDriver::IOWorker::~IOWorker() {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-}
-
-void GCMDriver::IOWorker::Initialize(
-    const checkin_proto::ChromeBuildProto& chrome_build_proto,
-    scoped_ptr<GCMClientFactory> gcm_client_factory,
-    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_->BelongsToCurrentThread());
-
-  gcm_client_ = gcm_client_factory->BuildInstance().Pass();
-
-  gcm_client_->Initialize(chrome_build_proto,
-                          store_path,
-                          account_ids,
-                          blocking_task_runner,
-                          request_context,
-                          this);
-}
-
-void GCMDriver::IOWorker::OnRegisterFinished(
-    const std::string& app_id,
-    const std::string& registration_id,
-    GCMClient::Result result) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::RegisterFinished, service_, app_id,
-                 registration_id, result));
-}
-
-void GCMDriver::IOWorker::OnUnregisterFinished(const std::string& app_id,
-                                               GCMClient::Result result) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::UnregisterFinished, service_, app_id, result));
-}
-
-void GCMDriver::IOWorker::OnSendFinished(const std::string& app_id,
-                                         const std::string& message_id,
-                                         GCMClient::Result result) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::SendFinished, service_, app_id, message_id,
-                 result));
-}
-
-void GCMDriver::IOWorker::OnMessageReceived(
-    const std::string& app_id,
-    const GCMClient::IncomingMessage& message) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::MessageReceived, service_, app_id, message));
-}
-
-void GCMDriver::IOWorker::OnMessagesDeleted(const std::string& app_id) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::MessagesDeleted, service_, app_id));
-}
-
-void GCMDriver::IOWorker::OnMessageSendError(
-    const std::string& app_id,
-    const GCMClient::SendErrorDetails& send_error_details) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::MessageSendError, service_, app_id,
-                 send_error_details));
-}
-
-void GCMDriver::IOWorker::OnGCMReady() {
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::GCMClientReady, service_));
-}
-
-void GCMDriver::IOWorker::Start(const base::WeakPtr<GCMDriver>& service) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  service_ = service;
-  gcm_client_->Start();
-}
-
-void GCMDriver::IOWorker::Stop() {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  gcm_client_->Stop();
-}
-
-void GCMDriver::IOWorker::CheckOut() {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  gcm_client_->CheckOut();
-
-  // Note that we still need to keep GCMClient instance alive since the
-  // GCMDriver may check in again.
-}
-
-void GCMDriver::IOWorker::Register(
-    const std::string& app_id,
-    const std::vector<std::string>& sender_ids) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  gcm_client_->Register(app_id, sender_ids);
-}
-
-void GCMDriver::IOWorker::Unregister(const std::string& app_id) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  gcm_client_->Unregister(app_id);
-}
-
-void GCMDriver::IOWorker::Send(const std::string& app_id,
-                               const std::string& receiver_id,
-                               const GCMClient::OutgoingMessage& message) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-
-  gcm_client_->Send(app_id, receiver_id, message);
-}
-
-void GCMDriver::IOWorker::GetGCMStatistics(bool clear_logs) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-  gcm::GCMClient::GCMStatistics stats;
-
-  if (gcm_client_.get()) {
-    if (clear_logs)
-      gcm_client_->ClearActivityLogs();
-    stats = gcm_client_->GetStatistics();
-  }
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::GetGCMStatisticsFinished, service_, stats));
-}
-
-void GCMDriver::IOWorker::SetGCMRecording(bool recording) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
-  gcm::GCMClient::GCMStatistics stats;
-
-  if (gcm_client_.get()) {
-    gcm_client_->SetRecording(recording);
-    stats = gcm_client_->GetStatistics();
-    stats.gcm_client_created = true;
-  }
-
-  ui_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::GetGCMStatisticsFinished, service_, stats));
-}
-
-GCMDriver::GCMDriver(
-    const checkin_proto::ChromeBuildProto& chrome_build_proto,
-    scoped_ptr<GCMClientFactory> gcm_client_factory,
-    scoped_ptr<IdentityProvider> identity_provider,
-    const base::FilePath& store_path,
-    const scoped_refptr<net::URLRequestContextGetter>& request_context,
-    const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
-    const scoped_refptr<base::MessageLoopProxy>& ui_thread,
-    const scoped_refptr<base::MessageLoopProxy>& io_thread)
-    : identity_provider_(identity_provider.Pass()),
-      ui_thread_(ui_thread),
-      io_thread_(io_thread),
-      gcm_enabled_(true),
-      gcm_client_ready_(false),
-      weak_ptr_factory_(this) {
-  // Get the list of available accounts.
-  std::vector<std::string> account_ids;
-#if !defined(OS_ANDROID)
-  account_ids = identity_provider_->GetTokenService()->GetAccounts();
-#endif
-
-  // Create and initialize the GCMClient. Note that this does not initiate the
-  // GCM check-in.
-  DCHECK(!io_worker_);
-  io_worker_.reset(new IOWorker(ui_thread, io_thread));
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::IOWorker::Initialize,
-                 base::Unretained(io_worker_.get()),
-                 chrome_build_proto,
-                 base::Passed(&gcm_client_factory),
-                 store_path,
-                 account_ids,
-                 request_context,
-                 blocking_task_runner));
-
-  identity_provider_->AddObserver(this);
-}
-
-GCMDriver::GCMDriver()
-    : gcm_enabled_(true),
-      gcm_client_ready_(false),
-      weak_ptr_factory_(this) {
+GCMDriver::GCMDriver() {
 }
 
 GCMDriver::~GCMDriver() {
 }
 
-void GCMDriver::Enable() {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  if (gcm_enabled_)
-    return;
-  gcm_enabled_ = true;
-
-  EnsureStarted();
-}
-
-void GCMDriver::Disable() {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  if (!gcm_enabled_)
-    return;
-  gcm_enabled_ = false;
-
-  Stop();
-}
-
 void GCMDriver::Shutdown() {
   DCHECK(ui_thread_->BelongsToCurrentThread());
-  identity_provider_->RemoveObserver(this);
   for (GCMAppHandlerMap::const_iterator iter = app_handlers_.begin();
        iter != app_handlers_.end(); ++iter) {
     iter->second->ShutdownHandler();
   }
   app_handlers_.clear();
-  io_thread_->DeleteSoon(FROM_HERE, io_worker_.release());
 }
 
 void GCMDriver::AddAppHandler(const std::string& app_id,
                               GCMAppHandler* handler) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   DCHECK(!app_id.empty());
   DCHECK(handler);
 
   app_handlers_[app_id] = handler;
-
-  // Ensures that the GCM service is started when there is an interest.
-  EnsureStarted();
 }
 
 void GCMDriver::RemoveAppHandler(const std::string& app_id) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   DCHECK(!app_id.empty());
 
   app_handlers_.erase(app_id);
-
-  // Stops the GCM service when no app intends to consume it.
-  if (app_handlers_.empty())
-    Stop();
-}
-
-void GCMDriver::Register(const std::string& app_id,
-                         const std::vector<std::string>& sender_ids,
-                         const RegisterCallback& callback) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  DCHECK(!app_id.empty());
-  DCHECK(!sender_ids.empty());
-  DCHECK(!callback.is_null());
-
-  GCMClient::Result result = EnsureStarted();
-  if (result != GCMClient::SUCCESS) {
-    callback.Run(std::string(), result);
-    return;
-  }
-
-  // If previous un/register operation is still in progress, bail out.
-  if (IsAsyncOperationPending(app_id)) {
-    callback.Run(std::string(), GCMClient::ASYNC_OPERATION_PENDING);
-    return;
-  }
-
-  register_callbacks_[app_id] = callback;
-
-  // Delay the register operation until GCMClient is ready.
-  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
-    delayed_task_controller_->AddTask(base::Bind(&GCMDriver::DoRegister,
-                                                 weak_ptr_factory_.GetWeakPtr(),
-                                                 app_id,
-                                                 sender_ids));
-    return;
-  }
-
-  DoRegister(app_id, sender_ids);
-}
-
-void GCMDriver::DoRegister(const std::string& app_id,
-                           const std::vector<std::string>& sender_ids) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  std::map<std::string, RegisterCallback>::iterator callback_iter =
-      register_callbacks_.find(app_id);
-  if (callback_iter == register_callbacks_.end()) {
-    // The callback could have been removed when the app is uninstalled.
-    return;
-  }
-
-  // Normalize the sender IDs by making them sorted.
-  std::vector<std::string> normalized_sender_ids = sender_ids;
-  std::sort(normalized_sender_ids.begin(), normalized_sender_ids.end());
-
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::IOWorker::Register,
-                 base::Unretained(io_worker_.get()),
-                 app_id,
-                 normalized_sender_ids));
-}
-
-void GCMDriver::Unregister(const std::string& app_id,
-                           const UnregisterCallback& callback) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  DCHECK(!app_id.empty());
-  DCHECK(!callback.is_null());
-
-  GCMClient::Result result = EnsureStarted();
-  if (result != GCMClient::SUCCESS) {
-    callback.Run(result);
-    return;
-  }
-
-  // If previous un/register operation is still in progress, bail out.
-  if (IsAsyncOperationPending(app_id)) {
-    callback.Run(GCMClient::ASYNC_OPERATION_PENDING);
-    return;
-  }
-
-  unregister_callbacks_[app_id] = callback;
-
-  // Delay the unregister operation until GCMClient is ready.
-  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
-    delayed_task_controller_->AddTask(base::Bind(&GCMDriver::DoUnregister,
-                                                 weak_ptr_factory_.GetWeakPtr(),
-                                                 app_id));
-    return;
-  }
-
-  DoUnregister(app_id);
-}
-
-void GCMDriver::DoUnregister(const std::string& app_id) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  // Ask the server to unregister it. There could be a small chance that the
-  // unregister request fails. If this occurs, it does not bring any harm since
-  // we simply reject the messages/events received from the server.
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::IOWorker::Unregister,
-                 base::Unretained(io_worker_.get()),
-                 app_id));
-}
-
-void GCMDriver::Send(const std::string& app_id,
-                     const std::string& receiver_id,
-                     const GCMClient::OutgoingMessage& message,
-                     const SendCallback& callback) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  DCHECK(!app_id.empty());
-  DCHECK(!receiver_id.empty());
-  DCHECK(!callback.is_null());
-
-  GCMClient::Result result = EnsureStarted();
-  if (result != GCMClient::SUCCESS) {
-    callback.Run(std::string(), result);
-    return;
-  }
-
-  // If the message with send ID is still in progress, bail out.
-  std::pair<std::string, std::string> key(app_id, message.id);
-  if (send_callbacks_.find(key) != send_callbacks_.end()) {
-    callback.Run(message.id, GCMClient::INVALID_PARAMETER);
-    return;
-  }
-
-  send_callbacks_[key] = callback;
-
-  // Delay the send operation until all GCMClient is ready.
-  if (!delayed_task_controller_->CanRunTaskWithoutDelay()) {
-    delayed_task_controller_->AddTask(base::Bind(&GCMDriver::DoSend,
-                                                 weak_ptr_factory_.GetWeakPtr(),
-                                                 app_id,
-                                                 receiver_id,
-                                                 message));
-    return;
-  }
-
-  DoSend(app_id, receiver_id, message);
-}
-
-void GCMDriver::DoSend(const std::string& app_id,
-                       const std::string& receiver_id,
-                       const GCMClient::OutgoingMessage& message) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::IOWorker::Send,
-                 base::Unretained(io_worker_.get()),
-                 app_id,
-                 receiver_id,
-                 message));
-}
-
-GCMClient* GCMDriver::GetGCMClientForTesting() const {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  return io_worker_ ? io_worker_->gcm_client_for_testing() : NULL;
-}
-
-bool GCMDriver::IsStarted() const {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  return !account_id_.empty();
-}
-
-bool GCMDriver::IsGCMClientReady() const {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  return gcm_client_ready_;
-}
-
-void GCMDriver::GetGCMStatistics(GetGCMStatisticsCallback callback,
-                                 bool clear_logs) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  DCHECK(!callback.is_null());
-
-  request_gcm_statistics_callback_ = callback;
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::IOWorker::GetGCMStatistics,
-                 base::Unretained(io_worker_.get()),
-                 clear_logs));
-}
-
-void GCMDriver::SetGCMRecording(GetGCMStatisticsCallback callback,
-                                bool recording) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  request_gcm_statistics_callback_ = callback;
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::IOWorker::SetGCMRecording,
-                 base::Unretained(io_worker_.get()),
-                 recording));
-}
-
-void GCMDriver::OnActiveAccountLogin() {
-  EnsureStarted();
-}
-
-void GCMDriver::OnActiveAccountLogout() {
-  CheckOut();
-}
-
-GCMClient::Result GCMDriver::EnsureStarted() {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  // Is GCM enabled?
-  if (!gcm_enabled_)
-    return GCMClient::GCM_DISABLED;
-
-  // Has any app requested the service?
-  if (app_handlers_.empty())
-    return GCMClient::UNKNOWN_ERROR;
-
-  // Can we get an account ID from the identity provider?
-  const std::string account_id = identity_provider_->GetActiveAccountId();
-  if (account_id.empty())
-    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);
-
-  // This will load the data from the gcm store and trigger the check-in if
-  // the persisted check-in info is not found.
-  // 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(&GCMDriver::IOWorker::Start,
-                 base::Unretained(io_worker_.get()),
-                 weak_ptr_factory_.GetWeakPtr()));
-
-  return GCMClient::SUCCESS;
-}
-
-void GCMDriver::Stop() {
-  // No need to stop GCM service if not started yet.
-  if (account_id_.empty())
-    return;
-
-  RemoveCachedData();
-
-  io_thread_->PostTask(
-      FROM_HERE,
-      base::Bind(&GCMDriver::IOWorker::Stop,
-                 base::Unretained(io_worker_.get())));
-}
-
-void GCMDriver::RemoveCachedData() {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  // Remove all the queued tasks since they no longer make sense after
-  // GCM service is stopped.
-  weak_ptr_factory_.InvalidateWeakPtrs();
-
-  account_id_.clear();
-  gcm_client_ready_ = false;
-  delayed_task_controller_.reset();
-  register_callbacks_.clear();
-  send_callbacks_.clear();
-}
-
-void GCMDriver::CheckOut() {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  // 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(&GCMDriver::IOWorker::CheckOut,
-                 base::Unretained(io_worker_.get())));
-}
-
-bool GCMDriver::IsAsyncOperationPending(const std::string& app_id) const {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  return register_callbacks_.find(app_id) != register_callbacks_.end() ||
-         unregister_callbacks_.find(app_id) != unregister_callbacks_.end();
-}
-
-void GCMDriver::RegisterFinished(const std::string& app_id,
-                                 const std::string& registration_id,
-                                 GCMClient::Result result) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  std::map<std::string, RegisterCallback>::iterator callback_iter =
-      register_callbacks_.find(app_id);
-  if (callback_iter == register_callbacks_.end()) {
-    // The callback could have been removed when the app is uninstalled.
-    return;
-  }
-
-  RegisterCallback callback = callback_iter->second;
-  register_callbacks_.erase(callback_iter);
-  callback.Run(registration_id, result);
-}
-
-void GCMDriver::UnregisterFinished(const std::string& app_id,
-                                   GCMClient::Result result) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  std::map<std::string, UnregisterCallback>::iterator callback_iter =
-      unregister_callbacks_.find(app_id);
-  if (callback_iter == unregister_callbacks_.end())
-    return;
-
-  UnregisterCallback callback = callback_iter->second;
-  unregister_callbacks_.erase(callback_iter);
-  callback.Run(result);
-}
-
-void GCMDriver::SendFinished(const std::string& app_id,
-                             const std::string& message_id,
-                             GCMClient::Result result) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  std::map<std::pair<std::string, std::string>, SendCallback>::iterator
-      callback_iter = send_callbacks_.find(
-          std::pair<std::string, std::string>(app_id, message_id));
-  if (callback_iter == send_callbacks_.end()) {
-    // The callback could have been removed when the app is uninstalled.
-    return;
-  }
-
-  SendCallback callback = callback_iter->second;
-  send_callbacks_.erase(callback_iter);
-  callback.Run(message_id, result);
-}
-
-void GCMDriver::MessageReceived(const std::string& app_id,
-                                GCMClient::IncomingMessage message) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  // Drop the event if signed out.
-  if (account_id_.empty())
-    return;
-
-  GetAppHandler(app_id)->OnMessage(app_id, message);
-}
-
-void GCMDriver::MessagesDeleted(const std::string& app_id) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  // Drop the event if signed out.
-  if (account_id_.empty())
-    return;
-
-  GetAppHandler(app_id)->OnMessagesDeleted(app_id);
-}
-
-void GCMDriver::MessageSendError(
-    const std::string& app_id,
-    const GCMClient::SendErrorDetails& send_error_details) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  // Drop the event if signed out.
-  if (account_id_.empty())
-    return;
-
-  GetAppHandler(app_id)->OnSendError(app_id, send_error_details);
-}
-
-void GCMDriver::GCMClientReady() {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  if (gcm_client_ready_)
-    return;
-  gcm_client_ready_ = true;
-
-  delayed_task_controller_->SetReady();
-}
-
-GCMAppHandler* GCMDriver::GetAppHandler(const std::string& app_id) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-
-  std::map<std::string, GCMAppHandler*>::const_iterator iter =
-      app_handlers_.find(app_id);
-  return iter == app_handlers_.end() ? &default_app_handler_ : iter->second;
-}
-
-void GCMDriver::GetGCMStatisticsFinished(GCMClient::GCMStatistics stats) {
-  DCHECK(ui_thread_->BelongsToCurrentThread());
-  request_gcm_statistics_callback_.Run(stats);
-}
-
-std::string GCMDriver::SignedInUserName() const {
-  if (IsStarted())
-    return identity_provider_->GetActiveUsername();
-  return std::string();
 }
 
 }  // namespace gcm