[GCM] Make sure GCM checkout logic is invoked when the profile is signed out

google_apis/gcm/gcm_client_impl.cc

 // Copyright 2013 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 "google_apis/gcm/gcm_client_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/time/default_clock.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/engine/connection_factory_impl.h"
 #include "google_apis/gcm/engine/gcm_store_impl.h"
 #include "google_apis/gcm/engine/mcs_client.h"
 #include "google_apis/gcm/engine/registration_request.h"
 #include "google_apis/gcm/engine/unregistration_request.h"
@@ skipping 109 matching lines @@
         url_request_context_getter,
     Delegate* delegate) {
   DCHECK_EQ(UNINITIALIZED, state_);
   DCHECK(url_request_context_getter);
   DCHECK(delegate);
 
   chrome_build_proto_.CopyFrom(chrome_build_proto);
   url_request_context_getter_ = url_request_context_getter;
 
   gcm_store_.reset(new GCMStoreImpl(false, path, blocking_task_runner));
-  gcm_store_->Load(base::Bind(&GCMClientImpl::OnLoadCompleted,
-                              weak_ptr_factory_.GetWeakPtr()));
 
   delegate_ = delegate;
 
   // |mcs_client_| might already be set for testing at this point. No need to
   // create a |connection_factory_|.
   if (!mcs_client_.get()) {
     const net::HttpNetworkSession::Params* network_session_params =
         url_request_context_getter->GetURLRequestContext()->
             GetNetworkSessionParams();
     DCHECK(network_session_params);
     network_session_ = new net::HttpNetworkSession(*network_session_params);
     connection_factory_.reset(new ConnectionFactoryImpl(
         GURL(kMCSEndpoint),
         kDefaultBackoffPolicy,
         network_session_,
         net_log_.net_log()));
     mcs_client_.reset(new MCSClient(clock_.get(),
                                     connection_factory_.get(),
                                     gcm_store_.get()));
   }

[fgorski, 2014/02/20 22:18:40]

Add a INITIALIZED to the State enum in the header and set it at the end of the
method.

[jianli, 2014/02/21 18:25:11]

Done.

+}
 
+void GCMClientImpl::CheckIn() {

[fgorski, 2014/02/20 22:18:40]

Add a DCHECK_EQ(state_, INITIALIZED);

[jianli, 2014/02/21 18:25:11]

Done.

+  // Once the loading is completed, the check-in will be initiated.
+  gcm_store_->Load(base::Bind(&GCMClientImpl::OnLoadCompleted,
+                              weak_ptr_factory_.GetWeakPtr()));
   state_ = LOADING;
 }
 
 void GCMClientImpl::OnLoadCompleted(scoped_ptr<GCMStore::LoadResult> result) {
   DCHECK_EQ(LOADING, state_);
 
   if (!result->success) {
     ResetState();
     return;
   }
@@ skipping 96 matching lines @@
 }
 
 void GCMClientImpl::SetDeviceCredentialsCallback(bool success) {
   // TODO(fgorski): This is one of the signals that store needs a rebuild.
   DCHECK(success);
 }
 
 void GCMClientImpl::CheckOut() {
   delegate_ = NULL;
   device_checkin_info_.Reset();
-  mcs_client_->Destroy();  // This will also destroy GCM store.
   mcs_client_.reset();
+  gcm_store_->Destroy(base::Bind(&GCMClientImpl::OnGCMStoreDestroyed,
+                                 weak_ptr_factory_.GetWeakPtr()));
   checkin_request_.reset();
   pending_registrations_.clear();
 }
 
 void GCMClientImpl::Register(const std::string& app_id,
                              const std::string& cert,
                              const std::vector<std::string>& sender_ids) {
   DCHECK_EQ(state_, READY);
   RegistrationRequest::RequestInfo request_info(
       device_checkin_info_.android_id,
@@ skipping 68 matching lines @@
   delegate_->OnUnregisterFinished(app_id, status);
 
   PendingUnregistrations::iterator iter = pending_unregistrations_.find(app_id);
   if (iter == pending_unregistrations_.end())
     return;
 
   delete iter->second;
   pending_unregistrations_.erase(iter);
 }
 
+void GCMClientImpl::OnGCMStoreDestroyed(bool success) {
+  LOG_IF(ERROR, !success) << "GCM store failed to be destroyed!";
+  UMA_HISTOGRAM_BOOLEAN("GCM.StoreDestroySucceeded", success);
+}
+
 void GCMClientImpl::Send(const std::string& app_id,
                          const std::string& receiver_id,
                          const OutgoingMessage& message) {
   DCHECK_EQ(state_, READY);
 
   mcs_proto::DataMessageStanza stanza;
   stanza.set_ttl(message.time_to_live);
   stanza.set_sent(clock_->Now().ToInternalValue() /
                   base::Time::kMicrosecondsPerSecond);
   stanza.set_id(message.id);
   stanza.set_from(kSendMessageFromValue);
   stanza.set_to(receiver_id);
   stanza.set_category(app_id);
 
   for (MessageData::const_iterator iter = message.data.begin();
        iter != message.data.end();
        ++iter) {
     mcs_proto::AppData* app_data = stanza.add_app_data();
     app_data->set_key(iter->first);
     app_data->set_value(iter->second);
   }
 
   MCSMessage mcs_message(stanza);
   DVLOG(1) << "MCS message size: " << mcs_message.size();
   mcs_client_->SendMessage(mcs_message);
 }
 
-bool GCMClientImpl::IsReady() const {
-  return state_ == READY;
-}
-
 void GCMClientImpl::OnMessageReceivedFromMCS(const gcm::MCSMessage& message) {
   switch (message.tag()) {
     case kLoginResponseTag:
       DVLOG(1) << "Login response received by GCM Client. Ignoring.";
       return;
     case kDataMessageStanzaTag:
       DVLOG(1) << "A downstream message received. Processing...";
       HandleIncomingMessage(message);
       return;
     default:
@@ skipping 76 matching lines @@
   if (iter != incoming_message.data.end())
     message_id = iter->second;
   delegate->OnMessageSendError(app_id, message_id, SERVER_ERROR);
 }
 
 void GCMClientImpl::SetMCSClientForTesting(scoped_ptr<MCSClient> mcs_client) {
   mcs_client_ = mcs_client.Pass();
 }
 
 }  // namespace gcm