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 47 matching lines @@
     std::string res_data;
     response.SerializeToString(&res_data);
 
     return res_data;
   }
 
   bool expect_callback_to_be_called_;
   std::unique_ptr<StoreStateMap> store_state_map_;
 };
 
-// TODO(vakh): Add many more tests.
 TEST_F(V4UpdateProtocolManagerTest, TestGetUpdatesErrorHandlingNetwork) {
   scoped_refptr<base::TestSimpleTaskRunner> runner(
       new base::TestSimpleTaskRunner());
   base::ThreadTaskRunnerHandle runner_handler(runner);
   net::TestURLFetcherFactory factory;
   const std::vector<ListUpdateResponse> expected_lurs;
   std::unique_ptr<V4UpdateProtocolManager> pm(
       CreateProtocolManager(expected_lurs));
   runner->ClearPendingTasks();
 
@@ skipping 140 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";
-  StoreStateMap store_state_map_minus{
-      {UpdateListIdentifier(LINUX_PLATFORM, URL, MALWARE_THREAT), state_minus}};
+  store_state_map_->clear();
+  (*store_state_map_)[UpdateListIdentifier(LINUX_PLATFORM, URL,
+                                           MALWARE_THREAT)] = "h8xfYqY>:R";
+  std::unique_ptr<V4UpdateProtocolManager> pm(
+      CreateProtocolManager(std::vector<ListUpdateResponse>({})));
+  pm->store_state_map_ = std::move(store_state_map_);
+
   std::string encoded_request_with_minus =
-      V4UpdateProtocolManager::GetBase64SerializedUpdateRequestProto(
-          store_state_map_minus);
-  EXPECT_EQ("GhkIARACGgt6LVJ-M3J1VmlRSCIEIAEgAigB", encoded_request_with_minus);
+      pm->GetBase64SerializedUpdateRequestProto();
+  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