Fetch incremental updates. Store new state in V4Store.

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 40 matching lines @@
       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 base::hash_map<UpdateListIdentifier, std::string>
-          current_list_states,
       const std::vector<ListUpdateResponse>& expected_lurs) {
     V4ProtocolConfig config;
     config.client_name = kClient;
     config.version = kAppVer;
     config.key_param = kKeyParam;
     config.disable_auto_update = false;
     return V4UpdateProtocolManager::Create(
-        NULL, config, current_list_states,
+        NULL, config,
         base::Bind(&V4UpdateProtocolManagerTest::ValidateGetUpdatesResults,
                    base::Unretained(this), expected_lurs));
   }
 
-  void SetupCurrentListStates(
-      base::hash_map<UpdateListIdentifier, std::string>* current_list_states) {
+  void SetupStoreStates() {
     UpdateListIdentifier list_identifier;
     list_identifier.platform_type = WINDOWS_PLATFORM;
     list_identifier.threat_entry_type = URL;
     list_identifier.threat_type = MALWARE_THREAT;
-    current_list_states->insert({list_identifier, "initial_state_1"});
+    store_state_map_.insert({list_identifier, "initial_state_1"});
 
     list_identifier.platform_type = WINDOWS_PLATFORM;
     list_identifier.threat_entry_type = URL;
     list_identifier.threat_type = UNWANTED_SOFTWARE;
-    current_list_states->insert({list_identifier, "initial_state_2"});
+    store_state_map_.insert({list_identifier, "initial_state_2"});
 
     list_identifier.platform_type = WINDOWS_PLATFORM;
     list_identifier.threat_entry_type = EXECUTABLE;
     list_identifier.threat_type = MALWARE_THREAT;
-    current_list_states->insert({list_identifier, "initial_state_3"});
+    store_state_map_.insert({list_identifier, "initial_state_3"});
   }
 
   void SetupExpectedListUpdateResponse(
       std::vector<ListUpdateResponse>* expected_lurs) {
     ListUpdateResponse lur;
     lur.set_platform_type(WINDOWS_PLATFORM);
     lur.set_response_type(ListUpdateResponse::PARTIAL_UPDATE);
     lur.set_threat_entry_type(URL);
     lur.set_threat_type(MALWARE_THREAT);
     lur.set_new_client_state("new_state_1");
@@ skipping 28 matching lines @@
     }
 
     // Serialize.
     std::string res_data;
     response.SerializeToString(&res_data);
 
     return res_data;
   }
 
   bool expect_callback_to_be_called_;
+  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 base::hash_map<UpdateListIdentifier, std::string> current_list_states;
   const std::vector<ListUpdateResponse> expected_lurs;
   std::unique_ptr<V4UpdateProtocolManager> pm(
-      CreateProtocolManager(current_list_states, expected_lurs));
+      CreateProtocolManager(expected_lurs));
   runner->ClearPendingTasks();
 
   // Initial state. No errors.
   EXPECT_EQ(0ul, pm->update_error_count_);
   EXPECT_EQ(1ul, pm->update_back_off_mult_);
   expect_callback_to_be_called_ = false;
+  pm->SetStoreStateMap(&store_state_map_);
   pm->IssueUpdateRequest();
 
   EXPECT_FALSE(pm->IsUpdateScheduled());
 
   runner->RunPendingTasks();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   DCHECK(fetcher);
   // Failed request status should result in error.
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                             net::ERR_CONNECTION_RESET));
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // Should have recorded one error, but back off multiplier is unchanged.
   EXPECT_EQ(1ul, pm->update_error_count_);
   EXPECT_EQ(1ul, pm->update_back_off_mult_);
   EXPECT_TRUE(pm->IsUpdateScheduled());
 }
 
 TEST_F(V4UpdateProtocolManagerTest, TestGetUpdatesErrorHandlingResponseCode) {
   scoped_refptr<base::TestSimpleTaskRunner> runner(
       new base::TestSimpleTaskRunner());
   base::ThreadTaskRunnerHandle runner_handler(runner);
   net::TestURLFetcherFactory factory;
   const std::vector<ListUpdateResponse> expected_lurs;
-  const base::hash_map<UpdateListIdentifier, std::string> current_list_states;
   std::unique_ptr<V4UpdateProtocolManager> pm(
-      CreateProtocolManager(current_list_states, expected_lurs));
+      CreateProtocolManager(expected_lurs));
   runner->ClearPendingTasks();
 
   // Initial state. No errors.
   EXPECT_EQ(0ul, pm->update_error_count_);
   EXPECT_EQ(1ul, pm->update_back_off_mult_);
   expect_callback_to_be_called_ = false;
+  pm->SetStoreStateMap(&store_state_map_);
   pm->IssueUpdateRequest();
 
   EXPECT_FALSE(pm->IsUpdateScheduled());
 
   runner->RunPendingTasks();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   DCHECK(fetcher);
   fetcher->set_status(net::URLRequestStatus());
   // Response code of anything other than 200 should result in error.
   fetcher->set_response_code(net::HTTP_NO_CONTENT);
   fetcher->SetResponseString("");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // Should have recorded one error, but back off multiplier is unchanged.
   EXPECT_EQ(1ul, pm->update_error_count_);
   EXPECT_EQ(1ul, pm->update_back_off_mult_);
   EXPECT_TRUE(pm->IsUpdateScheduled());
 }
 
 TEST_F(V4UpdateProtocolManagerTest, TestGetUpdatesNoError) {
   scoped_refptr<base::TestSimpleTaskRunner> runner(
       new base::TestSimpleTaskRunner());
   base::ThreadTaskRunnerHandle runner_handler(runner);
   net::TestURLFetcherFactory factory;
   std::vector<ListUpdateResponse> expected_lurs;
   SetupExpectedListUpdateResponse(&expected_lurs);
-  base::hash_map<UpdateListIdentifier, std::string> current_list_states;
-  SetupCurrentListStates(&current_list_states);
   std::unique_ptr<V4UpdateProtocolManager> pm(
-      CreateProtocolManager(current_list_states, expected_lurs));
+      CreateProtocolManager(expected_lurs));
   runner->ClearPendingTasks();
 
   // Initial state. No errors.
   EXPECT_EQ(0ul, pm->update_error_count_);
   EXPECT_EQ(1ul, pm->update_back_off_mult_);
   expect_callback_to_be_called_ = true;
+  SetupStoreStates();
+  pm->SetStoreStateMap(&store_state_map_);
   pm->IssueUpdateRequest();
 
   EXPECT_FALSE(pm->IsUpdateScheduled());
 
   runner->RunPendingTasks();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   DCHECK(fetcher);
   fetcher->set_status(net::URLRequestStatus());
   fetcher->set_response_code(net::HTTP_OK);
   fetcher->SetResponseString(GetExpectedV4UpdateResponse(expected_lurs));
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // 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, TestGetUpdatesWithOneBackoff) {
   scoped_refptr<base::TestSimpleTaskRunner> runner(
       new base::TestSimpleTaskRunner());
   base::ThreadTaskRunnerHandle runner_handler(runner);
   net::TestURLFetcherFactory factory;
   std::vector<ListUpdateResponse> expected_lurs;
   SetupExpectedListUpdateResponse(&expected_lurs);
-  base::hash_map<UpdateListIdentifier, std::string> current_list_states;
-  SetupCurrentListStates(&current_list_states);
   std::unique_ptr<V4UpdateProtocolManager> pm(
-      CreateProtocolManager(current_list_states, expected_lurs));
+      CreateProtocolManager(expected_lurs));
   runner->ClearPendingTasks();
 
   // Initial state. No errors.
   EXPECT_EQ(0ul, pm->update_error_count_);
   EXPECT_EQ(1ul, pm->update_back_off_mult_);
   expect_callback_to_be_called_ = false;
+  SetupStoreStates();
+  pm->SetStoreStateMap(&store_state_map_);
   pm->IssueUpdateRequest();
 
   EXPECT_FALSE(pm->IsUpdateScheduled());
 
   runner->RunPendingTasks();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   DCHECK(fetcher);
   fetcher->set_status(net::URLRequestStatus());
   // Response code of anything other than 200 should result in error.
@@ skipping 17 matching lines @@
   fetcher->SetResponseString(GetExpectedV4UpdateResponse(expected_lurs));
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // 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());
 }
 
 }  // namespace safe_browsing