[GCM] API update to allow only a single sender in registration

google_apis/gcm/engine/registration_request.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 "google_apis/gcm/engine/registration_request.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 15 matching lines @@
 const char kRegistrationRequestContentType[] =
     "application/x-www-form-urlencoded";
 
 // Request constants.
 const char kAppIdKey[] = "app";
 const char kCertKey[] = "cert";
 const char kDeviceIdKey[] = "device";
 const char kLoginHeader[] = "AidLogin";
 const char kSenderKey[] = "sender";
 
-// Request validation constants.
-const size_t kMaxSenders = 100;
-
 // Response constants.
 const char kErrorPrefix[] = "Error=";
 const char kTokenPrefix[] = "token=";
 const char kDeviceRegistrationError[] = "PHONE_REGISTRATION_ERROR";
 const char kAuthenticationFailed[] = "AUTHENTICATION_FAILED";
 const char kInvalidSender[] = "INVALID_SENDER";
 const char kInvalidParameters[] = "INVALID_PARAMETERS";
 
 void BuildFormEncoding(const std::string& key,
                        const std::string& value,
@@ skipping 32 matching lines @@
                             RegistrationRequest::STATUS_COUNT);
 }
 
 }  // namespace
 
 RegistrationRequest::RequestInfo::RequestInfo(
     uint64 android_id,
     uint64 security_token,
     const std::string& app_id,
     const std::string& cert,
-    const std::vector<std::string>& sender_ids)
+    const std::string& sender_id)
     : android_id(android_id),
       security_token(security_token),
       app_id(app_id),
       cert(cert),
-      sender_ids(sender_ids) {
+      sender_id(sender_id) {
 }
 
 RegistrationRequest::RequestInfo::~RequestInfo() {}
 
 RegistrationRequest::RegistrationRequest(
     const RequestInfo& request_info,
     const net::BackoffEntry::Policy& backoff_policy,
     const RegistrationCallback& callback,
     int max_retry_count,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter)
     : callback_(callback),
       request_info_(request_info),
       backoff_entry_(&backoff_policy),
       request_context_getter_(request_context_getter),
       retries_left_(max_retry_count),
       weak_ptr_factory_(this) {
   DCHECK_GE(max_retry_count, 0);
 }
 
 RegistrationRequest::~RegistrationRequest() {}
 
 void RegistrationRequest::Start() {
   DCHECK(!callback_.is_null());
   DCHECK(request_info_.android_id != 0UL);
   DCHECK(request_info_.security_token != 0UL);
   DCHECK(!request_info_.cert.empty());
-  DCHECK(0 < request_info_.sender_ids.size() &&
-         request_info_.sender_ids.size() <= kMaxSenders);
+  DCHECK(!request_info_.sender_id.empty());
 
   DCHECK(!url_fetcher_.get());
   url_fetcher_.reset(net::URLFetcher::Create(
       GURL(kRegistrationURL), net::URLFetcher::POST, this));
   url_fetcher_->SetRequestContext(request_context_getter_);
 
   std::string android_id = base::Uint64ToString(request_info_.android_id);
   std::string auth_header =
       std::string(net::HttpRequestHeaders::kAuthorization) + ": " +
       kLoginHeader + " " + android_id + ":" +
       base::Uint64ToString(request_info_.security_token);
   url_fetcher_->SetExtraRequestHeaders(auth_header);
 
   std::string body;
   BuildFormEncoding(kAppIdKey, request_info_.app_id, &body);
   BuildFormEncoding(kCertKey, request_info_.cert, &body);
   BuildFormEncoding(kDeviceIdKey, android_id, &body);
-
-  std::string senders;
-  for (std::vector<std::string>::const_iterator iter =
-           request_info_.sender_ids.begin();
-       iter != request_info_.sender_ids.end();
-       ++iter) {
-    DCHECK(!iter->empty());
-    if (!senders.empty())
-      senders.append(",");
-    senders.append(*iter);
-  }
-  BuildFormEncoding(kSenderKey, senders, &body);
+  BuildFormEncoding(kSenderKey, request_info_.sender_id, &body);
 
   DVLOG(1) << "Performing registration for: " << request_info_.app_id;
   DVLOG(1) << "Registration request: " << body;
   url_fetcher_->SetUploadData(kRegistrationRequestContentType, body);
   url_fetcher_->Start();
 }
 
 void RegistrationRequest::RetryWithBackoff(bool update_backoff) {
   if (update_backoff) {
     DCHECK_GT(retries_left_, 0);
@@ skipping 62 matching lines @@
     }
 
     status = REACHED_MAX_RETRIES;
     RecordRegistrationStatusToUMA(status);
   }
 
   callback_.Run(status, token);
 }
 
 }  // namespace gcm