Adding Send to Gaia ID feature

components/gcm_driver/gcm_account_mapper.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/gcm_driver/gcm_account_mapper.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
@@ skipping 11 matching lines @@
 const int kGCMUpdateIntervalHours = 24;
 // Because adding an account mapping dependents on a fresh OAuth2 token, we
 // allow the update to happen earlier than update due time, if it is within
 // the early start time to take advantage of that token.
 const int kGCMUpdateEarlyStartHours = 6;
 const char kRegistrationIdMessgaeKey[] = "id";
 const char kTokenMessageKey[] = "t";
 const char kAccountMessageKey[] = "a";
 const char kRemoveAccountKey[] = "r";
 const char kRemoveAccountValue[] = "1";
+// Use to handle send to Gaia ID scenario:
+const char kGCMSendToGaiaIdAppIdKey[] = "gcmb";
+
 
 std::string GenerateMessageID() {
   return base::GenerateGUID();
 }
 
 }  // namespace
 
 const char kGCMAccountMapperAppId[] = "com.google.android.gms";
 
 GCMAccountMapper::GCMAccountMapper(GCMDriver* gcm_driver)
     : gcm_driver_(gcm_driver),
       clock_(new base::DefaultClock),
       initialized_(false),
       weak_ptr_factory_(this) {
 }
 
 GCMAccountMapper::~GCMAccountMapper() {
 }
 
-void GCMAccountMapper::Initialize(
-    const std::vector<AccountMapping>& account_mappings) {
+void GCMAccountMapper::Initialize(const AccountMappings& account_mappings,
+                                  const DispatchMessageCallback& callback) {
   DCHECK(!initialized_);
   initialized_ = true;
   accounts_ = account_mappings;
+  dispatch_message_callback_ = callback;
   GetRegistration();
 }
 
 void GCMAccountMapper::SetAccountTokens(
     const std::vector<GCMClient::AccountTokenInfo>& account_tokens) {
   DVLOG(1) << "GCMAccountMapper::SetAccountTokens called with "
            << account_tokens.size() << " accounts.";
 
   // If account mapper is not ready to handle tasks yet, save the latest
   // account tokens and return.
@@ skipping 68 matching lines @@
         SendAddMappingMessage(*mappings_iter);
       }
     }
   }
 }
 
 void GCMAccountMapper::ShutdownHandler() {
   initialized_ = false;
   accounts_.clear();
   registration_id_.clear();
+  dispatch_message_callback_.Reset();
 }
 
 void GCMAccountMapper::OnMessage(const std::string& app_id,
                                  const GCMClient::IncomingMessage& message) {
-  // Account message does not expect messages right now.
+  DCHECK_EQ(app_id, kGCMAccountMapperAppId);
+  // TODO(fgorski): Report Send to Gaia ID failures using UMA.
+
+  if (dispatch_message_callback_.is_null()) {
+    DVLOG(1) << "dispatch_message_callback_ missing in GCMAccountMapper";
+    return;
+  }
+
+  GCMClient::MessageData::const_iterator it =
+      message.data.find(kGCMSendToGaiaIdAppIdKey);
+  if (it == message.data.end()) {
+    DVLOG(1) << "Send to Gaia ID failure: Embedded app ID missing.";
+    return;
+  }
+
+  std::string embedded_app_id = it->second;
+  if (embedded_app_id.empty()) {
+    DVLOG(1) << "Send to Gaia ID failure: Embedded app ID is empty.";
+    return;
+  }
+
+  // Ensuring the message does not carry the embedded app ID.
+  GCMClient::IncomingMessage new_message = message;
+  new_message.data.erase(new_message.data.find(kGCMSendToGaiaIdAppIdKey));
+  dispatch_message_callback_.Run(embedded_app_id, new_message);
 }
 
 void GCMAccountMapper::OnMessagesDeleted(const std::string& app_id) {
   // Account message does not expect messages right now.
 }
 
 void GCMAccountMapper::OnSendError(
     const std::string& app_id,
     const GCMClient::SendErrorDetails& send_error_details) {
   DCHECK_EQ(app_id, kGCMAccountMapperAppId);
@@ skipping 195 matching lines @@
   }
 
   return accounts_.end();
 }
 
 void GCMAccountMapper::SetClockForTesting(scoped_ptr<base::Clock> clock) {
   clock_ = clock.Pass();
 }
 
 }  // namespace gcm