Support getting and deleting token for Instance ID.

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"
 #include "base/values.h"
 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace gcm {
 
 namespace {
 
 const char kRegistrationRequestContentType[] =
     "application/x-www-form-urlencoded";
 
 // Request constants.
+//   Common keys.
 const char kAppIdKey[] = "app";
 const char kDeviceIdKey[] = "device";
 const char kLoginHeader[] = "AidLogin";
 const char kSenderKey[] = "sender";
+//    Keys specific to InstanceID's GetToken request.
+const char kGMSVersionKey[] = "gmsv";
+const char kInstanceIDKey[] = "appid";
+const char kScopeKey[] = "scope";
+
+// Prefix that needs to be added for each option key.
+const char kOptionKeyPrefix[] = "X-";
 
 // 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";
@@ skipping 33 matching lines @@
          status == RegistrationRequest::RESPONSE_PARSING_FAILED;
 }
 
 void RecordRegistrationStatusToUMA(RegistrationRequest::Status status) {
   UMA_HISTOGRAM_ENUMERATION("GCM.RegistrationRequestStatus", status,
                             RegistrationRequest::STATUS_COUNT);
 }
 
 }  // namespace
 
-RegistrationRequest::RequestInfo::RequestInfo(
-    uint64 android_id,
-    uint64 security_token,
-    const std::string& app_id,
-    const std::vector<std::string>& sender_ids)
-    : android_id(android_id),
-      security_token(security_token),
-      app_id(app_id),
-      sender_ids(sender_ids) {
-}
+RegistrationRequest::RequestInfo::RequestInfo() {}
 
 RegistrationRequest::RequestInfo::~RequestInfo() {}
 
+void RegistrationRequest::RequestInfo::BuildRequestHeaders(
+    std::string* extra_headers) {
+  net::HttpRequestHeaders headers;
+  headers.SetHeader(
+      net::HttpRequestHeaders::kAuthorization,
+      std::string(kLoginHeader) + " " +
+          base::Uint64ToString(android_id_) + ":" +
+          base::Uint64ToString(security_token_));
+  *extra_headers = headers.ToString();
+}
+
+void RegistrationRequest::RequestInfo::BuildRequestBody(std::string* body){
+  DCHECK(android_id_ != 0UL && security_token_ != 0UL);
+
+  BuildFormEncoding(kAppIdKey, app_id_, body);
+  BuildFormEncoding(kDeviceIdKey, base::Uint64ToString(android_id_), body);
+}
+
+RegistrationRequest::GCMRequestInfo::GCMRequestInfo() {}
+
+RegistrationRequest::GCMRequestInfo::~GCMRequestInfo() {}
+
+void RegistrationRequest::GCMRequestInfo::BuildRequestBody(std::string* body){
+  DCHECK(0 < sender_ids_.size() && sender_ids_.size() <= kMaxSenders);
+
+  RequestInfo::BuildRequestBody(body);
+
+  std::string senders;
+  for (auto iter = sender_ids_.begin(); iter != sender_ids_.end(); ++iter) {
+    if (!senders.empty())
+      senders.append(",");
+    senders.append(*iter);
+  }
+  BuildFormEncoding(kSenderKey, senders, body);
+  UMA_HISTOGRAM_COUNTS("GCM.RegistrationSenderIdCount", sender_ids_.size());
+}
+
+std::string RegistrationRequest::GCMRequestInfo::GetSenders() const {
+  std::string senders;
+  for (auto iter = sender_ids_.begin(); iter != sender_ids_.end(); ++iter) {
+    if (!senders.empty())
+      senders.append(",");
+    senders.append(*iter);
+  }
+  return senders;
+}
+
+RegistrationRequest::InstanceIDRequestInfo::InstanceIDRequestInfo() {}
+
+RegistrationRequest::InstanceIDRequestInfo::~InstanceIDRequestInfo() {}
+
+void RegistrationRequest::InstanceIDRequestInfo::BuildRequestBody(
+    std::string* body){
+  DCHECK(!instance_id_.empty() && !authorized_entity_.empty() &&
+         !scope_.empty());
+
+  RequestInfo::BuildRequestBody(body);
+
+  BuildFormEncoding(kGMSVersionKey, chrome_version_, body);
+  BuildFormEncoding(kInstanceIDKey, instance_id_, body);
+  BuildFormEncoding(kSenderKey, authorized_entity_, body);
+  BuildFormEncoding(kScopeKey, scope_, body);
+  for (auto iter = options_.begin(); iter != options_.end(); ++iter)
+    BuildFormEncoding(kOptionKeyPrefix + iter->first, iter->second, body);
+}
+
+std::string RegistrationRequest::InstanceIDRequestInfo::GetSenders()
+    const {
+  return authorized_entity_;
+}
+
 RegistrationRequest::RegistrationRequest(
     const GURL& registration_url,
-    const RequestInfo& request_info,
+    scoped_ptr<RequestInfo> request_info,
     const net::BackoffEntry::Policy& backoff_policy,
     const RegistrationCallback& callback,
     int max_retry_count,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     GCMStatsRecorder* recorder)
     : callback_(callback),
-      request_info_(request_info),
+      request_info_(request_info.Pass()),
       registration_url_(registration_url),
       backoff_entry_(&backoff_policy),
       request_context_getter_(request_context_getter),
       retries_left_(max_retry_count),
       recorder_(recorder),
       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(0 < request_info_.sender_ids.size() &&
-         request_info_.sender_ids.size() <= kMaxSenders);
+  DCHECK(!url_fetcher_.get());
 
-  DCHECK(!url_fetcher_.get());
   url_fetcher_ =
       net::URLFetcher::Create(registration_url_, net::URLFetcher::POST, this);
   url_fetcher_->SetRequestContext(request_context_getter_.get());
   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SAVE_COOKIES);
 
-  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 extra_headers;
+  request_info_->BuildRequestHeaders(&extra_headers);
+  url_fetcher_->SetExtraRequestHeaders(extra_headers);
 
   std::string body;
-  BuildFormEncoding(kAppIdKey, request_info_.app_id, &body);
-  BuildFormEncoding(kDeviceIdKey, android_id, &body);
+  request_info_->BuildRequestBody(&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);
-  UMA_HISTOGRAM_COUNTS("GCM.RegistrationSenderIdCount",
-                       request_info_.sender_ids.size());
-
-  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, senders);
+  recorder_->RecordRegistrationSent(request_info_->app_id(),
+                                    request_info_->GetSenders());
   request_start_time_ = base::TimeTicks::Now();
   url_fetcher_->Start();
 }
 
 void RegistrationRequest::RetryWithBackoff(bool update_backoff) {
   if (update_backoff) {
     DCHECK_GT(retries_left_, 0);
     --retries_left_;
     url_fetcher_.reset();
     backoff_entry_.InformOfRequest(false);
   }
 
   if (backoff_entry_.ShouldRejectRequest()) {
     DVLOG(1) << "Delaying GCM registration of app: "
-             << request_info_.app_id << ", for "
+             << request_info_->app_id() << ", for "
              << backoff_entry_.GetTimeUntilRelease().InMilliseconds()
              << " milliseconds.";
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&RegistrationRequest::RetryWithBackoff,
                    weak_ptr_factory_.GetWeakPtr(),
                    false),
         backoff_entry_.GetTimeUntilRelease());
     return;
   }
@@ skipping 40 matching lines @@
   }
 
   return UNKNOWN_ERROR;
 }
 
 void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
   std::string token;
   Status status = ParseResponse(source, &token);
   RecordRegistrationStatusToUMA(status);
   recorder_->RecordRegistrationResponse(
-      request_info_.app_id,
-      request_info_.sender_ids,
+      request_info_->app_id(),
+      request_info_->GetSenders(),
       status);
 
   if (ShouldRetryWithStatus(status)) {
     if (retries_left_ > 0) {
       recorder_->RecordRegistrationRetryRequested(
-          request_info_.app_id,
-          request_info_.sender_ids,
+          request_info_->app_id(),
+          request_info_->GetSenders(),
           retries_left_);
       RetryWithBackoff(true);
       return;
     }
 
     status = REACHED_MAX_RETRIES;
     recorder_->RecordRegistrationResponse(
-        request_info_.app_id,
-        request_info_.sender_ids,
+        request_info_->app_id(),
+        request_info_->GetSenders(),
         status);
     RecordRegistrationStatusToUMA(status);
   }
 
   if (status == SUCCESS) {
     UMA_HISTOGRAM_COUNTS("GCM.RegistrationRetryCount",
                          backoff_entry_.failure_count());
     UMA_HISTOGRAM_TIMES("GCM.RegistrationCompleteTime",
                         base::TimeTicks::Now() - request_start_time_);
   }
   callback_.Run(status, token);
 }
 
 }  // namespace gcm