Add support for GCM subtypes to desktop Instance ID implementation

google_apis/gcm/engine/unregistration_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/unregistration_request.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 11 matching lines @@
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 namespace gcm {
 
 namespace {
 
 const char kRequestContentType[] = "application/x-www-form-urlencoded";
 
 // Request constants.
-const char kAppIdKey[] = "app";
+const char kCategoryKey[] = "app";
+const char kSubtypeKey[] = "X-subtype";
 const char kDeleteKey[] = "delete";
 const char kDeleteValue[] = "true";
 const char kDeviceIdKey[] = "device";
 const char kLoginHeader[] = "AidLogin";
 
 }  // namespace
 
 UnregistrationRequest::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());
 }
 
 UnregistrationRequest::RequestInfo::~RequestInfo() {}
 
 UnregistrationRequest::CustomRequestHandler::CustomRequestHandler() {}
 
 UnregistrationRequest::CustomRequestHandler::~CustomRequestHandler() {}
 
 UnregistrationRequest::UnregistrationRequest(
     const GURL& registration_url,
@@ skipping 33 matching lines @@
   std::string extra_headers;
   BuildRequestHeaders(&extra_headers);
   url_fetcher_->SetExtraRequestHeaders(extra_headers);
 
   std::string body;
   BuildRequestBody(&body);
 
   DVLOG(1) << "Unregistration request: " << body;
   url_fetcher_->SetUploadData(kRequestContentType, body);
 
-  DVLOG(1) << "Performing unregistration for: " << request_info_.app_id;
-  recorder_->RecordUnregistrationSent(request_info_.app_id, source_to_record_);
+  DVLOG(1) << "Performing unregistration for: " << request_info_.app_id();
+  recorder_->RecordUnregistrationSent(request_info_.app_id(),
+                                      source_to_record_);
   request_start_time_ = base::TimeTicks::Now();
   url_fetcher_->Start();
 }
 
 void UnregistrationRequest::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));
-  headers.SetHeader(kAppIdKey, request_info_.app_id);
   *extra_headers = headers.ToString();
 }
 
 void UnregistrationRequest::BuildRequestBody(std::string* body) {
-  BuildFormEncoding(kAppIdKey, request_info_.app_id, body);
+  BuildFormEncoding(kCategoryKey, request_info_.category, body);
+  if (!request_info_.subtype.empty())
+    BuildFormEncoding(kSubtypeKey, request_info_.subtype, body);
+
   BuildFormEncoding(kDeviceIdKey,
                     base::Uint64ToString(request_info_.android_id),
                     body);
   BuildFormEncoding(kDeleteKey, kDeleteValue, body);
 
   DCHECK(custom_request_handler_.get());
   custom_request_handler_->BuildRequestBody(body);
 }
 
 UnregistrationRequest::Status UnregistrationRequest::ParseResponse(
@@ skipping 17 matching lines @@
   DCHECK(custom_request_handler_.get());
   return custom_request_handler_->ParseResponse(source);
 }
 
 void UnregistrationRequest::RetryWithBackoff() {
   DCHECK_GT(retries_left_, 0);
   --retries_left_;
   url_fetcher_.reset();
   backoff_entry_.InformOfRequest(false);
 
-  DVLOG(1) << "Delaying GCM unregistration of app: "
-           << request_info_.app_id << ", for "
-           << backoff_entry_.GetTimeUntilRelease().InMilliseconds()
+  DVLOG(1) << "Delaying GCM unregistration of app: " << request_info_.app_id()
+           << ", for " << backoff_entry_.GetTimeUntilRelease().InMilliseconds()
            << " milliseconds.";
   recorder_->RecordUnregistrationRetryDelayed(
-      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(&UnregistrationRequest::Start, weak_ptr_factory_.GetWeakPtr()),
       backoff_entry_.GetTimeUntilRelease());
 }
 
 void UnregistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
   UnregistrationRequest::Status status = ParseResponse(source);
 
   DVLOG(1) << "UnregistrationRequestStauts: " << status;
 
   DCHECK(custom_request_handler_.get());
   custom_request_handler_->ReportUMAs(
       status,
       backoff_entry_.failure_count(),
       base::TimeTicks::Now() - request_start_time_);
 
-  recorder_->RecordUnregistrationResponse(
-      request_info_.app_id, source_to_record_, status);
+  recorder_->RecordUnregistrationResponse(request_info_.app_id(),
+                                          source_to_record_, status);
 
   if (status == URL_FETCHING_FAILED ||
       status == HTTP_NOT_OK ||
       status == NO_RESPONSE_BODY ||
       status == SERVICE_UNAVAILABLE ||
       status == INTERNAL_SERVER_ERROR ||
       status == INCORRECT_APP_ID ||
       status == RESPONSE_PARSING_FAILED) {
     if (retries_left_ > 0) {
       RetryWithBackoff();
       return;
     }
 
     status = REACHED_MAX_RETRIES;
-    recorder_->RecordUnregistrationResponse(
-        request_info_.app_id, source_to_record_, status);
+    recorder_->RecordUnregistrationResponse(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());
   }
 
   // status == SUCCESS || INVALID_PARAMETERS || UNKNOWN_ERROR ||
   //           REACHED_MAX_RETRIES
 
   callback_.Run(status);
 }
 
 }  // namespace gcm