Retrieve chrome build info in GCMProfileService, instead of GCMDriver

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/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/default_clock.h"
 #include "google_apis/gcm/base/encryptor.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/monitoring/gcm_stats_recorder.h"
+#include "google_apis/gcm/protocol/checkin.pb.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "net/http/http_network_session.h"
 #include "net/url_request/url_request_context.h"
 #include "url/gurl.h"
 
 namespace gcm {
 
 namespace {
 
 // Backoff policy. Shared across reconnection logic and checkin/(un)registration
@@ skipping 74 matching lines @@
     case MCSClient::TTL_EXCEEDED:
       return GCMClient::NETWORK_ERROR;
     case MCSClient::SENT:
     default:
       NOTREACHED();
       break;
   }
   return GCMClientImpl::UNKNOWN_ERROR;
 }
 
+void ToCheckinProtoVersion(
+    const GCMClient::ChromeBuildInfo& chrome_build_info,
+    checkin_proto::ChromeBuildProto* android_build_info) {
+  checkin_proto::ChromeBuildProto_Platform platform;
+  switch (chrome_build_info.platform) {
+    case GCMClient::PLATFORM_WIN:
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_WIN;
+      break;
+    case GCMClient::PLATFORM_MAC:
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_MAC;
+      break;
+    case GCMClient::PLATFORM_LINUX:
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_LINUX;
+      break;
+    case GCMClient::PLATFORM_IOS:
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_IOS;
+      break;
+    case GCMClient::PLATFORM_ANDROID:
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_ANDROID;
+      break;
+    case GCMClient::PLATFORM_CROS:
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_CROS;
+      break;
+    case GCMClient::PLATFORM_UNKNOWN:
+      // For unknown platform, return as LINUX.
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_LINUX;
+      break;
+    default:
+      NOTREACHED();
+      platform = checkin_proto::ChromeBuildProto_Platform_PLATFORM_LINUX;
+      break;
+  }
+  android_build_info->set_platform(platform);
+
+  checkin_proto::ChromeBuildProto_Channel channel;
+  switch (chrome_build_info.channel) {
+    case GCMClient::CHANNEL_STABLE:
+      channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_STABLE;
+      break;
+    case GCMClient::CHANNEL_BETA:
+      channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_BETA;
+      break;
+    case GCMClient::CHANNEL_DEV:
+      channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_DEV;
+      break;
+    case GCMClient::CHANNEL_CANARY:
+      channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_CANARY;
+      break;
+    case GCMClient::CHANNEL_UNKNOWN:
+      channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_UNKNOWN;
+      break;
+    default:
+      NOTREACHED();
+      channel = checkin_proto::ChromeBuildProto_Channel_CHANNEL_UNKNOWN;
+      break;
+  }
+  android_build_info->set_channel(channel);
+
+  android_build_info->set_chrome_version(chrome_build_info.version);
+}
+
 MessageType DecodeMessageType(const std::string& value) {
   if (kMessageTypeDeletedMessagesKey == value)
     return DELETED_MESSAGES;
   if (kMessageTypeSendErrorKey == value)
     return SEND_ERROR;
   if (kMessageTypeDataMessage == value)
     return DATA_MESSAGE;
   return UNKNOWN;
 }
 
@@ skipping 66 matching lines @@
       pending_unregistration_requests_deleter_(
           &pending_unregistration_requests_),
       periodic_checkin_ptr_factory_(this),
       weak_ptr_factory_(this) {
 }
 
 GCMClientImpl::~GCMClientImpl() {
 }
 
 void GCMClientImpl::Initialize(
-    const checkin_proto::ChromeBuildProto& chrome_build_proto,
+    const ChromeBuildInfo& chrome_build_info,
     const base::FilePath& path,
     const std::vector<std::string>& account_ids,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
     const scoped_refptr<net::URLRequestContextGetter>&
         url_request_context_getter,
     scoped_ptr<Encryptor> encryptor,
     GCMClient::Delegate* delegate) {
   DCHECK_EQ(UNINITIALIZED, state_);
   DCHECK(url_request_context_getter);
   DCHECK(delegate);
 
   url_request_context_getter_ = url_request_context_getter;
   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);
 
-  chrome_build_proto_.CopyFrom(chrome_build_proto);
+  chrome_build_info_ = chrome_build_info;
   account_ids_ = account_ids;
 
   gcm_store_.reset(
       new GCMStoreImpl(path, blocking_task_runner, encryptor.Pass()));
 
   delegate_ = delegate;
 
   recorder_.SetDelegate(this);
 
   state_ = INITIALIZED;
@@ skipping 39 matching lines @@
   std::vector<GURL> endpoints;
   endpoints.push_back(gservices_settings_.GetMCSMainEndpoint());
   endpoints.push_back(gservices_settings_.GetMCSFallbackEndpoint());
   connection_factory_ = internals_builder_->BuildConnectionFactory(
       endpoints,
       kDefaultBackoffPolicy,
       network_session_,
       net_log_.net_log(),
       &recorder_);
   mcs_client_ = internals_builder_->BuildMCSClient(
-      chrome_build_proto_.chrome_version(),
+      chrome_build_info_.version,
       clock_.get(),
       connection_factory_.get(),
       gcm_store_.get(),
       &recorder_).Pass();
 
   mcs_client_->Initialize(
       base::Bind(&GCMClientImpl::OnMCSError, weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&GCMClientImpl::OnMessageReceivedFromMCS,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&GCMClientImpl::OnMessageSentToMCS,
@@ skipping 32 matching lines @@
 void GCMClientImpl::ResetState() {
   state_ = UNINITIALIZED;
   // TODO(fgorski): reset all of the necessart objects and start over.
 }
 
 void GCMClientImpl::StartCheckin() {
   // Make sure no checkin is in progress.
   if (checkin_request_.get())
     return;
 
+  checkin_proto::ChromeBuildProto chrome_build_proto;
+  ToCheckinProtoVersion(chrome_build_info_, &chrome_build_proto);
   CheckinRequest::RequestInfo request_info(device_checkin_info_.android_id,
                                            device_checkin_info_.secret,
                                            gservices_settings_.digest(),
                                            account_ids_,
-                                           chrome_build_proto_);
+                                           chrome_build_proto);
   checkin_request_.reset(
       new CheckinRequest(gservices_settings_.GetCheckinURL(),
                          request_info,
                          kDefaultBackoffPolicy,
                          base::Bind(&GCMClientImpl::OnCheckinCompleted,
                                     weak_ptr_factory_.GetWeakPtr()),
                          url_request_context_getter_,
                          &recorder_));
   checkin_request_->Start();
 }
@@ skipping 453 matching lines @@
 
   recorder_.RecordIncomingSendError(
       data_message_stanza.category(),
       data_message_stanza.to(),
       data_message_stanza.id());
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 }  // namespace gcm