[GCM] Support actual check-in in mcs_probe

google_apis/gcm/tools/mcs_probe.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.
 //
 // A standalone tool for testing MCS connections and the MCS client on their
 // own.
 
 #include <cstddef>
 #include <cstdio>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/default_clock.h"
 #include "base/values.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 "net/base/host_mapping_rules.h"
 #include "net/base/net_log_logger.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/transport_security_state.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/default_server_bound_cert_store.h"
 #include "net/ssl/server_bound_cert_service.h"
 #include "net/url_request/url_request_test_util.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 // This is a simple utility that initializes an mcs client and
 // prints out any events.
 namespace gcm {
 namespace {
 
+// Default values used to communicate with the check-in server.
+const char kChromeVersion[] = "Test Chrome Version";

[fgorski, 2014/01/09 22:23:47]

Should we call it "Chrome MCS Probe"?
It would be clear what to look for if someone sees that in the logs and asks
questions.

[jianli, 2014/01/09 23:37:05]

Done.

+const int64 kUserSerialNumber = 1;

[fgorski, 2014/01/09 22:23:47]

This should be unique within the device, so should probably take the
UserSerialNumber from the store.

Unless of course MCS Probe will never be used in a multi user scenario... (We
can make that kind of change later).

[jianli, 2014/01/09 23:37:05]

For now, mcs_probe only supports single user scenario. We will add multi-user
support later.

+
 // The default server to communicate with.
 const char kMCSServerHost[] = "mtalk.google.com";
 const uint16 kMCSServerPort = 5228;
 
 // Command line switches.
 const char kRMQFileName[] = "rmq_file";
 const char kAndroidIdSwitch[] = "android_id";
 const char kSecretSwitch[] = "secret";
 const char kLogFileSwitch[] = "log-file";
 const char kIgnoreCertSwitch[] = "ignore-certs";
@@ skipping 96 matching lines @@
       const CommandLine& command_line,
       scoped_refptr<net::URLRequestContextGetter> url_request_context_getter);
   ~MCSProbe();
 
   void Start();
 
   uint64 android_id() const { return android_id_; }
   uint64 secret() const { return secret_; }
 
  private:
+  void CheckIn();
   void InitializeNetworkState();
   void BuildNetworkSession();
+  void LoginMCSClient();
 
   void InitializationCallback(bool success,
                               uint64 restored_android_id,
                               uint64 restored_security_token);
+  void OnCheckInCompleted(uint64 android_id, uint64 secret);
 
   base::DefaultClock clock_;
 
   CommandLine command_line_;
 
   base::FilePath gcm_store_path_;
   uint64 android_id_;
   uint64 secret_;
   std::string server_host_;
   int server_port_;
 
   // Network state.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   MyTestNetLog net_log_;
   scoped_ptr<net::NetLogLogger> logger_;
   scoped_ptr<base::Value> net_constants_;
   scoped_ptr<net::HostResolver> host_resolver_;
   scoped_ptr<net::CertVerifier> cert_verifier_;
   scoped_ptr<net::ServerBoundCertService> system_server_bound_cert_service_;
   scoped_ptr<net::TransportSecurityState> transport_security_state_;
   scoped_ptr<net::URLSecurityManager> url_security_manager_;
   scoped_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory_;
   scoped_ptr<net::HttpServerPropertiesImpl> http_server_properties_;
   scoped_ptr<net::HostMappingRules> host_mapping_rules_;
   scoped_refptr<net::HttpNetworkSession> network_session_;
   scoped_ptr<net::ProxyService> proxy_service_;
 
   scoped_ptr<GCMStore> gcm_store_;
   scoped_ptr<MCSClient> mcs_client_;
+  scoped_ptr<CheckinRequest> checkin_request_;
 
   scoped_ptr<ConnectionFactoryImpl> connection_factory_;
 
   base::Thread file_thread_;
 
   scoped_ptr<base::RunLoop> run_loop_;
 };
 
 MCSProbe::MCSProbe(
     const CommandLine& command_line,
@@ skipping 119 matching lines @@
   session_params.proxy_service = proxy_service_.get();
 
   network_session_ = new net::HttpNetworkSession(session_params);
 }
 
 void MCSProbe::InitializationCallback(bool success,
                                       uint64 restored_android_id,
                                       uint64 restored_security_token) {
   LOG(INFO) << "Initialization " << (success ? "success!" : "failure!");
   if (restored_android_id && restored_security_token) {
+    LOG(INFO) << "Restored device check-in info.";
     android_id_ = restored_android_id;
     secret_ = restored_security_token;
   }
-  if (success)
-    mcs_client_->Login(android_id_, secret_);
+  if (!success)
+    return;
+
+  if (!android_id_ || !secret_) {
+    CheckIn();
+    return;
+  }
+
+  LoginMCSClient();
+}
+
+void MCSProbe::CheckIn() {
+  LOG(INFO) << "Check-in request initiated.";
+  checkin_proto::ChromeBuildProto chrome_build_proto;
+  chrome_build_proto.set_platform(
+      checkin_proto::ChromeBuildProto::PLATFORM_LINUX);
+  chrome_build_proto.set_channel(
+      checkin_proto::ChromeBuildProto::CHANNEL_CANARY);
+  chrome_build_proto.set_chrome_version(kChromeVersion);
+  checkin_request_.reset(new CheckinRequest(
+      base::Bind(&MCSProbe::OnCheckInCompleted, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      0,
+      0,
+      url_request_context_getter_.get()));
+  checkin_request_->Start();
+}
+
+void MCSProbe::OnCheckInCompleted(uint64 android_id, uint64 secret) {
+  LOG(INFO) << "Check-in request completion "
+            << (android_id ? "success!" : "failure!");
+  if (!android_id || !secret)
+    return;
+  android_id_ = android_id;
+  secret_ = secret;

[fgorski, 2014/01/09 22:23:47]

I think you should persist android_id and secret, and I am not clear if that
happens.

MCS Probe could have a switch to start fresh and wipe the db.

[jianli, 2014/01/09 23:37:05]

This has already been taken care of in MCSClient::Login.
I don't think we need a switch. You can just run "rm -rf gcm_store" to do it.

+
+  // We have to wait a while to talk with MCS server due to potential
+  // propagation delay.
+  const int kDelayMS = 10000;
+  LOG(INFO) << "Delaying MCS login for " << kDelayMS << "MS ...";
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&MCSProbe::LoginMCSClient, base::Unretained(this)),
+      base::TimeDelta::FromMilliseconds(kDelayMS));
+}
+
+void MCSProbe::LoginMCSClient() {
+  LOG(INFO) << "MCS login initiated.";
+  mcs_client_->Login(android_id_, secret_);
 }
 
 int MCSProbeMain(int argc, char* argv[]) {
   base::AtExitManager exit_manager;
 
   CommandLine::Init(argc, argv);
   logging::LoggingSettings settings;
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
   logging::InitLogging(settings);
 
@@ skipping 14 matching lines @@
 
   return 0;
 }
 
 }  // namespace
 }  // namespace gcm
 
 int main(int argc, char* argv[]) {
   return gcm::MCSProbeMain(argc, argv);
 }