Set client_id and client_version in requests sent to SafeBrowsing

components/safe_browsing_db/v4_update_protocol_manager_unittest.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_update_protocol_manager.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 47 matching lines @@
       EXPECT_EQ(expected.platform_type(), actual->platform_type());
       EXPECT_EQ(expected.response_type(), actual->response_type());
       EXPECT_EQ(expected.threat_entry_type(), actual->threat_entry_type());
       EXPECT_EQ(expected.threat_type(), actual->threat_type());
       EXPECT_EQ(expected.new_client_state(), actual->new_client_state());
 
       // TODO(vakh): Test more fields from the proto.
     }
   }
 
-  std::unique_ptr<V4UpdateProtocolManager> CreateProtocolManager(
-      const std::vector<ListUpdateResponse>& expected_lurs) {
+  V4ProtocolConfig GetProtocolConfig() {
     V4ProtocolConfig config;
     config.client_name = kClient;
     config.version = kAppVer;
     config.key_param = kKeyParam;
     config.disable_auto_update = false;
+    return config;
+  }
+
+  std::unique_ptr<V4UpdateProtocolManager> CreateProtocolManager(
+      const std::vector<ListUpdateResponse>& expected_lurs) {
     return V4UpdateProtocolManager::Create(
-        NULL, config,
+        NULL, GetProtocolConfig(),
         base::Bind(&V4UpdateProtocolManagerTest::ValidateGetUpdatesResults,
                    base::Unretained(this), expected_lurs));
   }
 
   void SetupStoreStates() {
     store_state_map_ = base::MakeUnique<StoreStateMap>();
 
     UpdateListIdentifier win_url_malware(WINDOWS_PLATFORM, URL, MALWARE_THREAT);
     store_state_map_->insert({win_url_malware, "initial_state_1"});
 
@@ skipping 208 matching lines @@
   // No error, back off multiplier is unchanged.
   EXPECT_EQ(0ul, pm->update_error_count_);
   EXPECT_EQ(1ul, pm->update_back_off_mult_);
   EXPECT_FALSE(pm->IsUpdateScheduled());
 }
 
 TEST_F(V4UpdateProtocolManagerTest, TestBase64EncodingUsesUrlEncoding) {
   // NOTE(vakh): I handpicked this value for state by generating random strings
   // and picked the one that leads to a '-' in the base64 url encoded request
   // output.
-  std::string state_minus = "z-R~3ruViQH";
+  std::string state_minus = "h8xfYqY>:R";
   StoreStateMap store_state_map_minus{
       {UpdateListIdentifier(LINUX_PLATFORM, URL, MALWARE_THREAT), state_minus}};
   std::string encoded_request_with_minus =
       V4UpdateProtocolManager::GetBase64SerializedUpdateRequestProto(
-          store_state_map_minus);
-  EXPECT_EQ("GhkIARACGgt6LVJ-M3J1VmlRSCIEIAEgAigB", encoded_request_with_minus);
+          store_state_map_minus, GetProtocolConfig());
+  EXPECT_EQ("Cg8KCHVuaXR0ZXN0EgMxLjAaGAgBEAIaCmg4eGZZcVk-OlIiBCABIAIoAQ==",
+            encoded_request_with_minus);
 
-  // NOTE(vakh): Same process for chosing this string. I am representing it
-  // in base64 encoded form because the actual state value contains non-ASCII
-  // characters.
-  std::string base64_encoded_state_underscore = "VTFfITBf4lBM";
-  std::string state_underscore;
-  base::Base64Decode(base64_encoded_state_underscore, &state_underscore);
-  StoreStateMap store_state_map_underscore{
-      {UpdateListIdentifier(LINUX_PLATFORM, URL, MALWARE_THREAT),
-       state_underscore}};
-  std::string encoded_request_with_underscore =
-      V4UpdateProtocolManager::GetBase64SerializedUpdateRequestProto(
-          store_state_map_underscore);
-  EXPECT_EQ("GhcIARACGglVMV8hMF_iUEwiBCABIAIoAQ==",
-            encoded_request_with_underscore);
+  // TODO(vakh): Add a similar test for underscore for completeness, although
+  // the '-' case is sufficient to prove that we are using URL encoding.
 }
 
 }  // namespace safe_browsing