| // 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 <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/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/url_request/url_request_context_getter.h" |
| |
| namespace gcm { |
| |
| // 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 |
| // 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); |
| }; |
| |
| GCMDriverDesktop::DelayedTaskController::DelayedTaskController() |
| : ready_(false) { |
| } |
| |
| GCMDriverDesktop::DelayedTaskController::~DelayedTaskController() { |
| } |
| |
| void GCMDriverDesktop::DelayedTaskController::AddTask( |
| const base::Closure& task) { |
| delayed_tasks_.push_back(task); |
| } |
| |
| void GCMDriverDesktop::DelayedTaskController::SetReady() { |
| ready_ = true; |
| RunTasks(); |
| } |
| |
| bool GCMDriverDesktop::DelayedTaskController::CanRunTaskWithoutDelay() const { |
| return ready_; |
| } |
| |
| void GCMDriverDesktop::DelayedTaskController::RunTasks() { |
| DCHECK(ready_); |
| |
| for (size_t i = 0; i < delayed_tasks_.size(); ++i) |
| delayed_tasks_[i].Run(); |
| delayed_tasks_.clear(); |
| } |
| |
| class GCMDriverDesktop::IOWorker : public GCMClient::Delegate { |
| public: |
| // Called on UI thread. |
| IOWorker(const scoped_refptr<base::SequencedTaskRunner>& ui_thread, |
| const scoped_refptr<base::SequencedTaskRunner>& 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; |
| virtual void OnActivityRecorded() 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, |
| 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::SequencedTaskRunner> ui_thread_; |
| scoped_refptr<base::SequencedTaskRunner> io_thread_; |
| |
| base::WeakPtr<GCMDriverDesktop> service_; |
| |
| scoped_ptr<GCMClient> gcm_client_; |
| |
| DISALLOW_COPY_AND_ASSIGN(IOWorker); |
| }; |
| |
| GCMDriverDesktop::IOWorker::IOWorker( |
| const scoped_refptr<base::SequencedTaskRunner>& ui_thread, |
| const scoped_refptr<base::SequencedTaskRunner>& io_thread) |
| : ui_thread_(ui_thread), |
| io_thread_(io_thread) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| } |
| |
| 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) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| ui_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::RegisterFinished, service_, app_id, |
| registration_id, result)); |
| } |
| |
| void GCMDriverDesktop::IOWorker::OnUnregisterFinished( |
| const std::string& app_id, |
| GCMClient::Result result) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| ui_thread_->PostTask(FROM_HERE, |
| base::Bind(&GCMDriverDesktop::UnregisterFinished, |
| service_, |
| app_id, |
| result)); |
| } |
| |
| void GCMDriverDesktop::IOWorker::OnSendFinished(const std::string& app_id, |
| const std::string& message_id, |
| GCMClient::Result result) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| ui_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::SendFinished, service_, app_id, message_id, |
| result)); |
| } |
| |
| void GCMDriverDesktop::IOWorker::OnMessageReceived( |
| const std::string& app_id, |
| const GCMClient::IncomingMessage& message) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| ui_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::MessageReceived, |
| service_, |
| app_id, |
| message)); |
| } |
| |
| void GCMDriverDesktop::IOWorker::OnMessagesDeleted(const std::string& app_id) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| ui_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::MessagesDeleted, service_, app_id)); |
| } |
| |
| void GCMDriverDesktop::IOWorker::OnMessageSendError( |
| const std::string& app_id, |
| const GCMClient::SendErrorDetails& send_error_details) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| ui_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::MessageSendError, service_, app_id, |
| send_error_details)); |
| } |
| |
| void GCMDriverDesktop::IOWorker::OnGCMReady() { |
| ui_thread_->PostTask( |
| FROM_HERE, |
| 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::Start( |
| const base::WeakPtr<GCMDriverDesktop>& service) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| service_ = service; |
| gcm_client_->Start(); |
| } |
| |
| void GCMDriverDesktop::IOWorker::Stop() { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| gcm_client_->Stop(); |
| } |
| |
| void GCMDriverDesktop::IOWorker::CheckOut() { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| gcm_client_->CheckOut(); |
| |
| // Note that we still need to keep GCMClient instance alive since the |
| // GCMDriverDesktop may check in again. |
| } |
| |
| void GCMDriverDesktop::IOWorker::Register( |
| const std::string& app_id, |
| const std::vector<std::string>& sender_ids) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| gcm_client_->Register(app_id, sender_ids); |
| } |
| |
| void GCMDriverDesktop::IOWorker::Unregister(const std::string& app_id) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| gcm_client_->Unregister(app_id); |
| } |
| |
| void GCMDriverDesktop::IOWorker::Send( |
| const std::string& app_id, |
| const std::string& receiver_id, |
| const GCMClient::OutgoingMessage& message) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| |
| gcm_client_->Send(app_id, receiver_id, message); |
| } |
| |
| void GCMDriverDesktop::IOWorker::GetGCMStatistics(bool clear_logs) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| 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(&GCMDriverDesktop::GetGCMStatisticsFinished, service_, stats)); |
| } |
| |
| void GCMDriverDesktop::IOWorker::SetGCMRecording(bool recording) { |
| DCHECK(io_thread_->RunsTasksOnCurrentThread()); |
| 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(&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), |
| gcm_client_ready_(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::Shutdown() { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| identity_provider_->RemoveObserver(this); |
| GCMDriver::Shutdown(); |
| io_thread_->DeleteSoon(FROM_HERE, io_worker_.release()); |
| } |
| |
| 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) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| GCMDriver::RemoveAppHandler(app_id); |
| |
| // Stops the GCM service when no app intends to consume it. |
| if (app_handlers().empty()) |
| Stop(); |
| } |
| |
| void GCMDriverDesktop::Enable() { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| if (gcm_enabled_) |
| return; |
| gcm_enabled_ = true; |
| |
| EnsureStarted(); |
| } |
| |
| void GCMDriverDesktop::Disable() { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| if (!gcm_enabled_) |
| 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()) |
| return; |
| |
| RemoveCachedData(); |
| |
| io_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::IOWorker::Stop, |
| base::Unretained(io_worker_.get()))); |
| } |
| |
| void GCMDriverDesktop::Register(const std::string& app_id, |
| const std::vector<std::string>& sender_ids, |
| const RegisterCallback& callback) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| 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(&GCMDriverDesktop::DoRegister, |
| weak_ptr_factory_.GetWeakPtr(), |
| app_id, |
| sender_ids)); |
| return; |
| } |
| |
| DoRegister(app_id, sender_ids); |
| } |
| |
| void GCMDriverDesktop::DoRegister(const std::string& app_id, |
| const std::vector<std::string>& sender_ids) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| 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(&GCMDriverDesktop::IOWorker::Register, |
| base::Unretained(io_worker_.get()), |
| app_id, |
| normalized_sender_ids)); |
| } |
| |
| void GCMDriverDesktop::Unregister(const std::string& app_id, |
| const UnregisterCallback& callback) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| 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(&GCMDriverDesktop::DoUnregister, |
| weak_ptr_factory_.GetWeakPtr(), |
| app_id)); |
| return; |
| } |
| |
| DoUnregister(app_id); |
| } |
| |
| void GCMDriverDesktop::DoUnregister(const std::string& app_id) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| // 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(&GCMDriverDesktop::IOWorker::Unregister, |
| base::Unretained(io_worker_.get()), |
| app_id)); |
| } |
| |
| void GCMDriverDesktop::Send(const std::string& app_id, |
| const std::string& receiver_id, |
| const GCMClient::OutgoingMessage& message, |
| const SendCallback& callback) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| 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(&GCMDriverDesktop::DoSend, |
| weak_ptr_factory_.GetWeakPtr(), |
| app_id, |
| receiver_id, |
| message)); |
| return; |
| } |
| |
| DoSend(app_id, receiver_id, message); |
| } |
| |
| void GCMDriverDesktop::DoSend(const std::string& app_id, |
| const std::string& receiver_id, |
| const GCMClient::OutgoingMessage& message) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| io_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::IOWorker::Send, |
| base::Unretained(io_worker_.get()), |
| app_id, |
| receiver_id, |
| 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(); |
| } |
| |
| bool GCMDriverDesktop::IsGCMClientReady() const { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| return gcm_client_ready_; |
| } |
| |
| 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, |
| base::Unretained(io_worker_.get()), |
| clear_logs)); |
| } |
| |
| void GCMDriverDesktop::SetGCMRecording(const GetGCMStatisticsCallback& callback, |
| bool recording) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| request_gcm_statistics_callback_ = callback; |
| io_thread_->PostTask( |
| FROM_HERE, |
| base::Bind(&GCMDriverDesktop::IOWorker::SetGCMRecording, |
| base::Unretained(io_worker_.get()), |
| recording)); |
| } |
| |
| void GCMDriverDesktop::OnActiveAccountLogin() { |
| EnsureStarted(); |
| } |
| |
| void GCMDriverDesktop::OnActiveAccountLogout() { |
| CheckOut(); |
| } |
| |
| GCMClient::Result GCMDriverDesktop::EnsureStarted() { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| 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()) |
| 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())); |
| |
| 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_client_ready_ = false; |
| delayed_task_controller_.reset(); |
| register_callbacks_.clear(); |
| send_callbacks_.clear(); |
| } |
| |
| 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()))); |
| } |
| |
| bool GCMDriverDesktop::IsAsyncOperationPending( |
| const std::string& app_id) const { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| return register_callbacks_.find(app_id) != register_callbacks_.end() || |
| unregister_callbacks_.find(app_id) != unregister_callbacks_.end(); |
| } |
| |
| void GCMDriverDesktop::RegisterFinished(const std::string& app_id, |
| const std::string& registration_id, |
| GCMClient::Result result) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| 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 GCMDriverDesktop::UnregisterFinished(const std::string& app_id, |
| GCMClient::Result result) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| 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 GCMDriverDesktop::SendFinished(const std::string& app_id, |
| const std::string& message_id, |
| GCMClient::Result result) { |
| DCHECK(ui_thread_->RunsTasksOnCurrentThread()); |
| |
| 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 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()) |
| 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()) |
| 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()) |
| 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::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 |