Add support for GCM subtypes to desktop Instance ID implementation

google_apis/gcm/engine/registration_request_unittest.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 <stdint.h>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "google_apis/gcm/engine/gcm_registration_request_handler.h"
 #include "google_apis/gcm/engine/gcm_request_test_base.h"
 #include "google_apis/gcm/engine/instance_id_get_token_request_handler.h"
 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_status.h"
 
 namespace gcm {
 
 namespace {
 const uint64_t kAndroidId = 42UL;
 const char kAppId[] = "TestAppId";
+const char kCategoryForSubtypes[] = "com.chrome.stable.macosx";
 const char kDeveloperId[] = "Project1";
 const char kLoginHeader[] = "AidLogin";
 const char kRegistrationURL[] = "http://foo.bar/register";
 const uint64_t kSecurityToken = 77UL;
 const int kGCMVersion = 40;
 const char kInstanceId[] = "IID1";
 const char kScope[] = "GCM";
 
 }  // namespace
 
@@ skipping 52 matching lines @@
   void CreateRequest(const std::string& sender_ids);
 };
 
 GCMRegistrationRequestTest::GCMRegistrationRequestTest() {
 }
 
 GCMRegistrationRequestTest::~GCMRegistrationRequestTest() {
 }
 
 void GCMRegistrationRequestTest::CreateRequest(const std::string& sender_ids) {
-  RegistrationRequest::RequestInfo request_info(
-      kAndroidId, kSecurityToken, kAppId);
+  RegistrationRequest::RequestInfo request_info(kAndroidId, kSecurityToken,
+                                                kAppId, false /* use_subtype */,
+                                                kCategoryForSubtypes);
   std::unique_ptr<GCMRegistrationRequestHandler> request_handler(
       new GCMRegistrationRequestHandler(sender_ids));
   request_.reset(new RegistrationRequest(
       GURL(kRegistrationURL), request_info, std::move(request_handler),
       GetBackoffPolicy(),
       base::Bind(&RegistrationRequestTest::RegistrationCallback,
                  base::Unretained(this)),
       max_retry_count_, url_request_context_getter(), &recorder_, sender_ids));
 }
 
@@ skipping 31 matching lines @@
   ASSERT_TRUE(auth_tokenizer.GetNext());
   EXPECT_EQ(base::Uint64ToString(kAndroidId), auth_tokenizer.token());
   ASSERT_TRUE(auth_tokenizer.GetNext());
   EXPECT_EQ(base::Uint64ToString(kSecurityToken), auth_tokenizer.token());
 
   std::map<std::string, std::string> expected_pairs;
   expected_pairs["app"] = kAppId;
   expected_pairs["sender"] = kDeveloperId;
   expected_pairs["device"] = base::Uint64ToString(kAndroidId);
 
-  // Verify data was formatted properly.
-  std::string upload_data = fetcher->upload_data();
-  base::StringTokenizer data_tokenizer(upload_data, "&=");
-  while (data_tokenizer.GetNext()) {
-    std::map<std::string, std::string>::iterator iter =
-        expected_pairs.find(data_tokenizer.token());
-    ASSERT_TRUE(iter != expected_pairs.end());
-    ASSERT_TRUE(data_tokenizer.GetNext());
-    EXPECT_EQ(iter->second, data_tokenizer.token());
-    // Ensure that none of the keys appears twice.
-    expected_pairs.erase(iter);
-  }
-
-  EXPECT_EQ(0UL, expected_pairs.size());
+  ASSERT_NO_FATAL_FAILURE(VerifyFetcherUploadData(&expected_pairs));
 }
 
 TEST_F(GCMRegistrationRequestTest, RequestRegistrationWithMultipleSenderIds) {
   CreateRequest("sender1,sender2@gmail.com");
   request_->Start();
 
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
   // Verify data was formatted properly.
@@ skipping 215 matching lines @@
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::REACHED_MAX_RETRIES, status_);
   EXPECT_EQ(std::string(), registration_id_);
 }
 
 class InstanceIDGetTokenRequestTest : public RegistrationRequestTest {
  public:
   InstanceIDGetTokenRequestTest();
   ~InstanceIDGetTokenRequestTest() override;
 
-  void CreateRequest(const std::string& instance_id,
+  void CreateRequest(bool use_subtype,
+                     const std::string& instance_id,
                      const std::string& authorized_entity,
                      const std::string& scope,
                      const std::map<std::string, std::string>& options);
 };
 
 InstanceIDGetTokenRequestTest::InstanceIDGetTokenRequestTest() {
 }
 
 InstanceIDGetTokenRequestTest::~InstanceIDGetTokenRequestTest() {
 }
 
 void InstanceIDGetTokenRequestTest::CreateRequest(
+    bool use_subtype,
     const std::string& instance_id,
     const std::string& authorized_entity,
     const std::string& scope,
     const std::map<std::string, std::string>& options) {
   RegistrationRequest::RequestInfo request_info(
-      kAndroidId, kSecurityToken, kAppId);
+      kAndroidId, kSecurityToken, kAppId, use_subtype, kCategoryForSubtypes);
   std::unique_ptr<InstanceIDGetTokenRequestHandler> request_handler(
       new InstanceIDGetTokenRequestHandler(instance_id, authorized_entity,
                                            scope, kGCMVersion, options));
   request_.reset(new RegistrationRequest(
       GURL(kRegistrationURL), request_info, std::move(request_handler),
       GetBackoffPolicy(),
       base::Bind(&RegistrationRequestTest::RegistrationCallback,
                  base::Unretained(this)),
       max_retry_count_, url_request_context_getter(), &recorder_,
       authorized_entity));
 }
 
 TEST_F(InstanceIDGetTokenRequestTest, RequestSuccessful) {
   std::map<std::string, std::string> options;
   options["Foo"] = "Bar";
 
   set_max_retry_count(0);
-  CreateRequest(kInstanceId, kDeveloperId, kScope, options);
+  CreateRequest(false /* use_subtype */, kInstanceId, kDeveloperId, kScope,
+                options);
   request_->Start();
 
   SetResponse(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(InstanceIDGetTokenRequestTest, RequestDataAndURL) {
   std::map<std::string, std::string> options;
   options["Foo"] = "Bar";
-  CreateRequest(kInstanceId, kDeveloperId, kScope, options);
+  CreateRequest(false /* use_subtype */, kInstanceId, kDeveloperId, kScope,
+                options);
   request_->Start();
 
   // Get data sent by request.
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
   EXPECT_EQ(GURL(kRegistrationURL), fetcher->GetOriginalURL());
 
   // Verify that the no-cookie flag is set.
   int flags = fetcher->GetLoadFlags();
@@ skipping 10 matching lines @@
   EXPECT_EQ(kLoginHeader, auth_tokenizer.token());
   ASSERT_TRUE(auth_tokenizer.GetNext());
   EXPECT_EQ(base::Uint64ToString(kAndroidId), auth_tokenizer.token());
   ASSERT_TRUE(auth_tokenizer.GetNext());
   EXPECT_EQ(base::Uint64ToString(kSecurityToken), auth_tokenizer.token());
 
   std::map<std::string, std::string> expected_pairs;
   expected_pairs["gmsv"] = base::IntToString(kGCMVersion);
   expected_pairs["app"] = kAppId;
   expected_pairs["sender"] = kDeveloperId;
-  expected_pairs["X-subtype"] = kDeveloperId;
   expected_pairs["device"] = base::Uint64ToString(kAndroidId);
   expected_pairs["appid"] = kInstanceId;
   expected_pairs["scope"] = kScope;
+  expected_pairs["X-scope"] = kScope;
+  expected_pairs["X-Foo"] = "Bar";
+
+  ASSERT_NO_FATAL_FAILURE(VerifyFetcherUploadData(&expected_pairs));
+}
+
+TEST_F(InstanceIDGetTokenRequestTest, RequestDataWithSubtype) {
+  std::map<std::string, std::string> options;
+  options["Foo"] = "Bar";
+  CreateRequest(true /* use_subtype */, kInstanceId, kDeveloperId, kScope,
+                options);
+  request_->Start();
+
+  // Get data sent by request.
+  net::TestURLFetcher* fetcher = GetFetcher();
+  ASSERT_TRUE(fetcher);
+
+  // Same as RequestDataAndURL except "app" and "X-subtype".
+  std::map<std::string, std::string> expected_pairs;
+  expected_pairs["gmsv"] = base::IntToString(kGCMVersion);
+  expected_pairs["app"] = kCategoryForSubtypes;
+  expected_pairs["X-subtype"] = kAppId;
+  expected_pairs["sender"] = kDeveloperId;
+  expected_pairs["device"] = base::Uint64ToString(kAndroidId);
+  expected_pairs["appid"] = kInstanceId;
+  expected_pairs["scope"] = kScope;
   expected_pairs["X-scope"] = kScope;
   expected_pairs["X-Foo"] = "Bar";
 
   // Verify data was formatted properly.
   std::string upload_data = fetcher->upload_data();
   base::StringTokenizer data_tokenizer(upload_data, "&=");
   while (data_tokenizer.GetNext()) {
-    std::map<std::string, std::string>::iterator iter =
-        expected_pairs.find(data_tokenizer.token());
+    auto iter = expected_pairs.find(data_tokenizer.token());
     ASSERT_TRUE(iter != expected_pairs.end());
     ASSERT_TRUE(data_tokenizer.GetNext());
     EXPECT_EQ(iter->second, data_tokenizer.token());
     // Ensure that none of the keys appears twice.
     expected_pairs.erase(iter);
   }
 
   EXPECT_EQ(0UL, expected_pairs.size());
 }
 
 TEST_F(InstanceIDGetTokenRequestTest, ResponseHttpStatusNotOK) {
   std::map<std::string, std::string> options;
-  CreateRequest(kInstanceId, kDeveloperId, kScope, options);
+  CreateRequest(false /* use_subtype */, kInstanceId, kDeveloperId, kScope,
+                options);
   request_->Start();
 
   SetResponse(net::HTTP_UNAUTHORIZED, "token=2501");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponse(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 }  // namespace gcm