Rename GCMClient::Load to GCMClient::Start

chrome/browser/services/gcm/gcm_service.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 "chrome/browser/services/gcm/gcm_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 136 matching lines @@
       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 base::FilePath& store_path,
                   const std::vector<std::string>& account_ids,
                   const scoped_refptr<net::URLRequestContextGetter>&
                       url_request_context_getter);
-  void Load(const base::WeakPtr<GCMService>& service);
+  void Start(const base::WeakPtr<GCMService>& 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);
@@ skipping 129 matching lines @@
                                               service_));
 }
 
 void GCMService::IOWorker::OnActivityRecorded() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   // When an activity is recorded, get all the stats and refresh the UI of
   // gcm-internals page.
   GetGCMStatistics(false);
 }
 
-void GCMService::IOWorker::Load(const base::WeakPtr<GCMService>& service) {
+void GCMService::IOWorker::Start(const base::WeakPtr<GCMService>& service) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   service_ = service;
-  gcm_client_->Load();
+  gcm_client_->Start();
 }
 
 void GCMService::IOWorker::Stop() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->Stop();
 }
 
 void GCMService::IOWorker::CheckOut() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
@@ skipping 81 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMService::IOWorker::Initialize,
                  base::Unretained(io_worker_.get()),
                  base::Passed(&gcm_client_factory),
                  GetStorePath(),
                  account_ids,
                  GetURLRequestContextGetter()));
 
-  // Load from the GCM store and initiate the GCM check-in if the rollout signal
-  // indicates yes.
+  // Start the GCM service if the rollout signal indicates yes.
   if (ShouldStartAutomatically())
-    EnsureLoaded();
+    EnsureStarted();
 
   identity_provider_->AddObserver(this);
 }
 
 void GCMService::Start() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  EnsureLoaded();
+  EnsureStarted();
 }
 
 void GCMService::Stop() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // No need to stop GCM service if not started yet.
   if (account_id_.empty())
     return;
 
   RemoveCachedData();
@@ skipping 225 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMService::IOWorker::SetGCMRecording,
                  base::Unretained(io_worker_.get()),
                  recording));
 }
 
 void GCMService::OnActiveAccountLogin() {
   if (ShouldStartAutomatically())
-    EnsureLoaded();
+    EnsureStarted();
 }
 
 void GCMService::OnActiveAccountLogout() {
   CheckOut();
 }
 
-void GCMService::EnsureLoaded() {
+void GCMService::EnsureStarted() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   const std::string account_id = identity_provider_->GetActiveAccountId();
   if (account_id.empty())
     return;
 
   // 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;
   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.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&GCMService::IOWorker::Load,
+      base::Bind(&GCMService::IOWorker::Start,
                  base::Unretained(io_worker_.get()),
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void GCMService::RemoveCachedData() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // Remove all the queued tasks since they no longer make sense after
   // GCM service is stopped.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
@@ skipping 15 matching lines @@
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMService::IOWorker::CheckOut,
                  base::Unretained(io_worker_.get())));
 }
 
 GCMClient::Result GCMService::EnsureAppReady(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  // Ensure that check-in has been done.
-  EnsureLoaded();
 
-  // If the service was not started, bail out.
+  // Starts the service if not yet.
+  EnsureStarted();
+
+  // If the service cannot be started, bail out.
   if (account_id_.empty())
     return GCMClient::NOT_SIGNED_IN;
 
   return GCMClient::SUCCESS;
 }
 
 bool GCMService::IsAsyncOperationPending(const std::string& app_id) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   return register_callbacks_.find(app_id) != register_callbacks_.end() ||
          unregister_callbacks_.find(app_id) != unregister_callbacks_.end();
@@ skipping 104 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // 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