Add support for GCM subtypes to desktop Instance ID implementation

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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 #include "url/gurl.h"
 
 namespace gcm {
 
 namespace {
 
 const char kRegistrationRequestContentType[] =
     "application/x-www-form-urlencoded";
 
 // Request constants.
-const char kAppIdKey[] = "app";
+const char kCategoryKey[] = "app";
+const char kSubtypeKey[] = "X-subtype";
 const char kDeviceIdKey[] = "device";
 const char kLoginHeader[] = "AidLogin";
 
 // 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";
@@ skipping 21 matching lines @@
          status == RegistrationRequest::DEVICE_REGISTRATION_ERROR ||
          status == RegistrationRequest::HTTP_NOT_OK ||
          status == RegistrationRequest::URL_FETCHING_FAILED ||
          status == RegistrationRequest::RESPONSE_PARSING_FAILED;
 }
 
 }  // namespace
 
 RegistrationRequest::RequestInfo::RequestInfo(uint64_t android_id,
                                               uint64_t security_token,
-                                              const std::string& app_id)
-    : android_id(android_id), security_token(security_token), app_id(app_id) {
+                                              const std::string& category,
+                                              const std::string& subtype)
+    : android_id(android_id),
+      security_token(security_token),
+      category(category),
+      subtype(subtype) {
   DCHECK(android_id != 0UL);
   DCHECK(security_token != 0UL);
+  DCHECK(!category.empty());
 }
 
 RegistrationRequest::RequestInfo::~RequestInfo() {}
 
 RegistrationRequest::CustomRequestHandler::CustomRequestHandler() {}
 
 RegistrationRequest::CustomRequestHandler::~CustomRequestHandler() {}
 
 RegistrationRequest::RegistrationRequest(
     const GURL& registration_url,
@@ skipping 30 matching lines @@
   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SAVE_COOKIES);
 
   std::string extra_headers;
   BuildRequestHeaders(&extra_headers);
   url_fetcher_->SetExtraRequestHeaders(extra_headers);
 
   std::string body;
   BuildRequestBody(&body);
 
-  DVLOG(1) << "Performing registration for: " << request_info_.app_id;
+  DVLOG(1) << "Performing registration for: " << request_info_.app_id();
   DVLOG(1) << "Registration request: " << body;
   url_fetcher_->SetUploadData(kRegistrationRequestContentType, body);
-  recorder_->RecordRegistrationSent(request_info_.app_id, source_to_record_);
+  recorder_->RecordRegistrationSent(request_info_.app_id(), source_to_record_);
   request_start_time_ = base::TimeTicks::Now();
   url_fetcher_->Start();
 }
 
 void RegistrationRequest::BuildRequestHeaders(std::string* extra_headers) {
   net::HttpRequestHeaders headers;
   headers.SetHeader(
       net::HttpRequestHeaders::kAuthorization,
       std::string(kLoginHeader) + " " +
           base::Uint64ToString(request_info_.android_id) + ":" +
           base::Uint64ToString(request_info_.security_token));
   *extra_headers = headers.ToString();
 }
 
 void RegistrationRequest::BuildRequestBody(std::string* body) {
-  BuildFormEncoding(kAppIdKey, request_info_.app_id, body);
+  BuildFormEncoding(kCategoryKey, request_info_.category, body);
+  if (!request_info_.subtype.empty())

[Nicolas Zea, 2016/08/17 20:54:09]

nit: make this an if/else?

[johnme, 2016/08/18 17:43:21]

|subtype| is an additional field that is sent if non-empty (in addition to
|category|, which is always sent); there would be nothing to do in the else
clause.

+    BuildFormEncoding(kSubtypeKey, request_info_.subtype, body);
+
   BuildFormEncoding(kDeviceIdKey,
                     base::Uint64ToString(request_info_.android_id),
                     body);
 
   DCHECK(custom_request_handler_.get());
   custom_request_handler_->BuildRequestBody(body);
 }
 
 void RegistrationRequest::RetryWithBackoff() {
   DCHECK_GT(retries_left_, 0);
   --retries_left_;
   url_fetcher_.reset();
   backoff_entry_.InformOfRequest(false);
 
-  DVLOG(1) << "Delaying GCM registration of app: "
-           << request_info_.app_id << ", for "
-           << backoff_entry_.GetTimeUntilRelease().InMilliseconds()
+  DVLOG(1) << "Delaying GCM registration of app: " << request_info_.app_id()
+           << ", for " << backoff_entry_.GetTimeUntilRelease().InMilliseconds()
            << " milliseconds.";
   recorder_->RecordRegistrationRetryDelayed(
-      request_info_.app_id,
-      source_to_record_,
-      backoff_entry_.GetTimeUntilRelease().InMilliseconds(),
-      retries_left_ + 1);
+      request_info_.app_id(), source_to_record_,
+      backoff_entry_.GetTimeUntilRelease().InMilliseconds(), retries_left_ + 1);
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&RegistrationRequest::Start, weak_ptr_factory_.GetWeakPtr()),
       backoff_entry_.GetTimeUntilRelease());
 }
 
 RegistrationRequest::Status RegistrationRequest::ParseResponse(
     const net::URLFetcher* source, std::string* token) {
   if (!source->GetStatus().is_success()) {
@@ skipping 31 matching lines @@
                 << source->GetResponseCode();
     return HTTP_NOT_OK;
   }
 
   return UNKNOWN_ERROR;
 }
 
 void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
   std::string token;
   Status status = ParseResponse(source, &token);
-  recorder_->RecordRegistrationResponse(
-      request_info_.app_id,
-      source_to_record_,
-      status);
+  recorder_->RecordRegistrationResponse(request_info_.app_id(),
+                                        source_to_record_, status);
 
   DCHECK(custom_request_handler_.get());
   custom_request_handler_->ReportUMAs(
       status,
       backoff_entry_.failure_count(),
       base::TimeTicks::Now() - request_start_time_);
 
   if (ShouldRetryWithStatus(status)) {
     if (retries_left_ > 0) {
       RetryWithBackoff();
       return;
     }
 
     status = REACHED_MAX_RETRIES;
-    recorder_->RecordRegistrationResponse(
-        request_info_.app_id,
-        source_to_record_,
-        status);
+    recorder_->RecordRegistrationResponse(request_info_.app_id(),
+                                          source_to_record_, status);
 
     // Only REACHED_MAX_RETRIES is reported because the function will skip
     // reporting count and time when status is not SUCCESS.
     DCHECK(custom_request_handler_.get());
     custom_request_handler_->ReportUMAs(status, 0, base::TimeDelta());
   }
 
   callback_.Run(status, token);
 }
 
 }  // namespace gcm