Undoing revert, cl is not the cause of gcm crash on canary.

components/copresence/rpc/rpc_handler.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 "components/copresence/rpc/rpc_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 // TODO(ckehoe): time.h includes windows.h, which #defines DeviceCapabilities
 // to DeviceCapabilitiesW. This breaks the pb.h headers below. For now,
 // we fix this with an #undef.
 #include "base/time/time.h"
 #if defined(OS_WIN)
 #undef DeviceCapabilities
 #endif
 
 #include "components/copresence/copresence_switches.h"
 #include "components/copresence/handlers/directive_handler.h"
+#include "components/copresence/handlers/gcm_handler.h"
 #include "components/copresence/proto/codes.pb.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
 #include "components/copresence/public/copresence_constants.h"
 #include "components/copresence/public/copresence_delegate.h"
 #include "components/copresence/rpc/http_post.h"
 #include "net/http/http_status_code.h"
 
 // TODO(ckehoe): Return error messages for bad requests.
 
 namespace copresence {
 
 using google::protobuf::MessageLite;
 using google::protobuf::RepeatedPtrField;
 
 const char RpcHandler::kReportRequestRpcName[] = "report";
 
-// Number of characters of suffix to log for auth tokens
-const int kTokenSuffix = 5;
+namespace {
 
-namespace {
+const int kTokenLoggingSuffix = 5;
+const int kInvalidTokenExpiryTimeMs = 10 * 60 * 1000;  // 10 minutes.
+const int kMaxInvalidTokens = 10000;
+const char kRegisterDeviceRpcName[] = "registerdevice";
+const char kDefaultCopresenceServer[] =
+    "https://www.googleapis.com/copresence/v2/copresence";
 
 // UrlSafe is defined as:
 // '/' represented by a '_' and '+' represented by a '-'
 // TODO(rkc): Move this to the wrapper.
 std::string ToUrlSafe(std::string token) {
   base::ReplaceChars(token, "+", "-", &token);
   base::ReplaceChars(token, "/", "_", &token);
   return token;
 }
 
-const int kInvalidTokenExpiryTimeMs = 10 * 60 * 1000;  // 10 minutes.
-const int kMaxInvalidTokens = 10000;
-const char kRegisterDeviceRpcName[] = "registerdevice";
-const char kDefaultCopresenceServer[] =
-    "https://www.googleapis.com/copresence/v2/copresence";
 
 // Logging
 
 // Checks for a copresence error. If there is one, logs it and returns true.
 bool IsErrorStatus(const Status& status) {
   if (status.code() != OK) {
     LOG(ERROR) << "Copresence error code " << status.code()
                << (status.message().empty() ? "" : ": " + status.message());
   }
   return status.code() != OK;
@@ skipping 17 matching lines @@
   if (response.has_manage_messages_response())
     LogIfErrorStatus(response.manage_messages_response().status(), "Publish");
   if (response.has_manage_subscriptions_response()) {
     LogIfErrorStatus(response.manage_subscriptions_response().status(),
                      "Subscribe");
   }
 
   return result;
 }
 
+const std::string LoggingStrForToken(const std::string& auth_token) {
+  if (auth_token.empty())
+    return "anonymous";
+
+  std::string token_suffix = auth_token.substr(
+      auth_token.length() - kTokenLoggingSuffix, kTokenLoggingSuffix);
+  return base::StringPrintf("token ...%s", token_suffix.c_str());
+}
+
+
 // Request construction
 // TODO(ckehoe): Move these into a separate file?
 
 template <typename T>
 BroadcastScanConfiguration GetBroadcastScanConfig(const T& msg) {
   if (msg.has_token_exchange_strategy() &&
       msg.token_exchange_strategy().has_broadcast_scan_configuration()) {
     return msg.token_exchange_strategy().broadcast_scan_configuration();
   }
   return BROADCAST_SCAN_CONFIGURATION_UNKNOWN;
@@ skipping 35 matching lines @@
   TokenObservation* token_observation =
       request->mutable_update_signals_request()->add_token_observation();
   token_observation->set_token_id(ToUrlSafe(token.token));
 
   TokenSignals* signals = token_observation->add_signals();
   signals->set_medium(token.audible ? AUDIO_AUDIBLE_DTMF
                                     : AUDIO_ULTRASOUND_PASSBAND);
   signals->set_observed_time_millis(base::Time::Now().ToJsTime());
 }
 
-const std::string LoggingStrForToken(const std::string& auth_token) {
-  std::string token_str = auth_token.empty() ? "anonymous" :
-      base::StringPrintf("token ...%s",
-                         auth_token.substr(auth_token.length() - kTokenSuffix,
-                                           kTokenSuffix).c_str());
-  return token_str;
-}
-
 }  // namespace
 
 
 // Public functions.
 
 RpcHandler::RpcHandler(CopresenceDelegate* delegate,
                        DirectiveHandler* directive_handler,
+                       GCMHandler* gcm_handler,
                        const PostCallback& server_post_callback)
     : delegate_(delegate),
       directive_handler_(directive_handler),
+      gcm_handler_(gcm_handler),
       server_post_callback_(server_post_callback),
       invalid_audio_token_cache_(
           base::TimeDelta::FromMilliseconds(kInvalidTokenExpiryTimeMs),
           kMaxInvalidTokens) {
     DCHECK(delegate_);
     DCHECK(directive_handler_);
+    // |gcm_handler_| is optional.
 
     if (server_post_callback_.is_null()) {
       server_post_callback_ =
           base::Bind(&RpcHandler::SendHttpPost, base::Unretained(this));
     }
+
+    if (gcm_handler_) {
+      gcm_handler_->GetGcmId(
+          base::Bind(&RpcHandler::RegisterGcmId, base::Unretained(this)));
+    }
   }
 
 RpcHandler::~RpcHandler() {
-  // Do not use |directive_handler_| here.
-  // It will already have been destructed.
+  // Do not use |directive_handler_| or |gcm_handler_| here.
+  // They will already have been destructed.
   for (HttpPost* post : pending_posts_)
     delete post;
 }
 
 void RpcHandler::SendReportRequest(scoped_ptr<ReportRequest> request,
                                    const std::string& app_id,
                                    const std::string& auth_token,
                                    const StatusCallback& status_callback) {
   DCHECK(request.get());
 
@@ skipping 55 matching lines @@
     AddTokenToRequest(token, &request);
   }
 
   // Report under all active tokens.
   for (const auto& registration : device_id_by_auth_token_) {
     SendReportRequest(make_scoped_ptr(new ReportRequest(request)),
                       registration.first);
   }
 }
 
-// Private methods
+
+// Private functions.
 
 RpcHandler::PendingRequest::PendingRequest(scoped_ptr<ReportRequest> report,
                                            const std::string& app_id,
                                            const std::string& auth_token,
                                            const StatusCallback& callback)
     : report(report.Pass()),
       app_id(app_id),
       auth_token(auth_token),
       callback(callback) {}
 
 RpcHandler::PendingRequest::~PendingRequest() {}
 
 void RpcHandler::RegisterForToken(const std::string& auth_token) {
   DVLOG(2) << "Sending " << LoggingStrForToken(auth_token)
            << " registration to server.";
 
-  // Mark registration as in progress.
-  device_id_by_auth_token_[auth_token] = "";
+  scoped_ptr<RegisterDeviceRequest> request(new RegisterDeviceRequest);
 
-  scoped_ptr<RegisterDeviceRequest> request(new RegisterDeviceRequest);
-  request->mutable_push_service()->set_service(PUSH_SERVICE_NONE);
+  // Add a GCM ID for authenticated registration, if we have one.
+  if (auth_token.empty() || gcm_id_.empty()) {
+    request->mutable_push_service()->set_service(PUSH_SERVICE_NONE);
+  } else {
+    DVLOG(2) << "Registering GCM ID with " << LoggingStrForToken(auth_token);
+    request->mutable_push_service()->set_service(GCM);
+    request->mutable_push_service()->mutable_gcm_registration()
+        ->set_device_token(gcm_id_);
+  }
 
   // Only identify as a Chrome device if we're in anonymous mode.
   // Authenticated calls come from a "GAIA device".
   if (auth_token.empty()) {
     Identity* identity =
         request->mutable_device_identifiers()->mutable_registrant();
     identity->set_type(CHROME);
     identity->set_chrome_id(base::GenerateGUID());
+
+    // Since we're generating a new "Chrome ID" here,
+    // we need to make sure this isn't a duplicate registration.
+    DCHECK_EQ(0u, device_id_by_auth_token_.count(std::string()))
+        << "Attempted anonymous re-registration";
   }
 
+  bool gcm_pending = !auth_token.empty() && gcm_handler_ && gcm_id_.empty();
   SendServerRequest(
       kRegisterDeviceRpcName,
-      std::string(),  // device ID
+      // This will have the side effect of populating an empty device ID
+      // for this auth token in the map. This is what we want,
+      // to mark registration as being in progress.
+      device_id_by_auth_token_[auth_token],
       std::string(),  // app ID
       auth_token,
       request.Pass(),
       base::Bind(&RpcHandler::RegisterResponseHandler,
                  // On destruction, this request will be cancelled.
                  base::Unretained(this),
-                 auth_token));
+                 auth_token,
+                 gcm_pending));
 }
 
 void RpcHandler::ProcessQueuedRequests(const std::string& auth_token) {
   // Track requests that are not on this auth token.
   ScopedVector<PendingRequest> still_pending_requests;
 
   // If there is no device ID for this auth token, registration failed.
   bool registration_failed =
       (device_id_by_auth_token_.count(auth_token) == 0);
 
@@ skipping 23 matching lines @@
 }
 
 void RpcHandler::SendReportRequest(scoped_ptr<ReportRequest> request,
                                    const std::string& auth_token) {
   SendReportRequest(request.Pass(),
                     std::string(),
                     auth_token,
                     StatusCallback());
 }
 
+// Store a GCM ID and send it to the server if needed. The constructor passes
+// this callback to the GCMHandler to receive the ID whenever it's ready.
+// It may be returned immediately, if the ID is cached, or require a server
+// round-trip. This ID must then be passed along to the copresence server.
+// There are a few ways this can happen for each auth token:
+//
+// 1. The GCM ID is available when we first register, and is passed along
+//    with the RegisterDeviceRequest.
+//
+// 2. The GCM ID becomes available after the RegisterDeviceRequest has
+//    completed. Then the loop in this function will invoke RegisterForToken()
+//    again to pass on the ID.
+//
+// 3. The GCM ID becomes available after the RegisterDeviceRequest is sent,
+//    but before it completes. In this case, the gcm_pending flag is passed
+//    through to the RegisterResponseHandler, which invokes RegisterForToken()
+//    again to pass on the ID. The loop here must skip pending registrations,
+//    as the device ID will be empty.
+//
+// TODO(ckehoe): Add tests for these scenarios.
+void RpcHandler::RegisterGcmId(const std::string& gcm_id) {
+  gcm_id_ = gcm_id;
+  if (!gcm_id.empty()) {
+    for (const auto& registration : device_id_by_auth_token_) {
+      const std::string& auth_token = registration.first;
+      const std::string& device_id = registration.second;
+      if (!auth_token.empty() && !device_id.empty())
+        RegisterForToken(auth_token);
+    }
+  }
+}
+
 void RpcHandler::RegisterResponseHandler(
     const std::string& auth_token,
+    bool gcm_pending,
     HttpPost* completed_post,
     int http_status_code,
     const std::string& response_data) {
   if (completed_post) {
     int elements_erased = pending_posts_.erase(completed_post);
     DCHECK_GT(elements_erased, 0);
     delete completed_post;
   }
 
   // Registration is no longer in progress.
   // If it was successful, we'll update below.
   device_id_by_auth_token_.erase(auth_token);
 
   RegisterDeviceResponse response;
   if (http_status_code != net::HTTP_OK) {
     // TODO(ckehoe): Retry registration if appropriate.
     LOG(ERROR) << LoggingStrForToken(auth_token)
                << " device registration failed";
   } else if (!response.ParseFromString(response_data)) {
     LOG(ERROR) << "Invalid RegisterDeviceResponse:\n" << response_data;
   } else if (!IsErrorStatus(response.header().status())) {
     const std::string& device_id = response.registered_device_id();
     DCHECK(!device_id.empty());
     device_id_by_auth_token_[auth_token] = device_id;
     DVLOG(2) << LoggingStrForToken(auth_token)
              << " device registration successful. Id: " << device_id;
+
+    // If we have a GCM ID now, and didn't before, pass it on to the server.
+    if (gcm_pending && !gcm_id_.empty())
+      RegisterForToken(auth_token);
   }
 
   // Send or fail requests on this auth token.
   ProcessQueuedRequests(auth_token);
 }
 
 void RpcHandler::ReportResponseHandler(const StatusCallback& status_callback,
                                        HttpPost* completed_post,
                                        int http_status_code,
                                        const std::string& response_data) {
@@ skipping 128 matching lines @@
     const std::string& device_id) const {
   RequestHeader* header = new RequestHeader;
 
   header->set_allocated_framework_version(CreateVersion(
       "Chrome", delegate_->GetPlatformVersionString()));
   if (!client_name.empty()) {
     header->set_allocated_client_version(
         CreateVersion(client_name, std::string()));
   }
   header->set_current_time_millis(base::Time::Now().ToJsTime());
-  header->set_registered_device_id(device_id);
+  if (!device_id.empty())
+    header->set_registered_device_id(device_id);
 
   DeviceFingerprint* fingerprint = new DeviceFingerprint;
   fingerprint->set_platform_version(delegate_->GetPlatformVersionString());
   fingerprint->set_type(CHROME_PLATFORM_TYPE);
   header->set_allocated_device_fingerprint(fingerprint);
 
   return header;
 }
 
 template <class T>
@@ skipping 34 matching lines @@
       api_key,
       auth_token,
       command_line->GetSwitchValueASCII(switches::kCopresenceTracingToken),
       *request_proto);
 
   http_post->Start(base::Bind(callback, http_post));
   pending_posts_.insert(http_post);
 }
 
 }  // namespace copresence