Add extended reporting level in the update request

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.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.
     }
   }
 
+  ExtendedReportingLevel GetExtendedReportingLevel(ExtendedReportingLevel erl) {
+    return erl;
+  }
+
   std::unique_ptr<V4UpdateProtocolManager> CreateProtocolManager(
       const std::vector<ListUpdateResponse>& expected_lurs,
-      bool disable_auto_update = false) {
+      bool disable_auto_update = false,
+      ExtendedReportingLevel erl = SBER_LEVEL_OFF) {
     return V4UpdateProtocolManager::Create(
         NULL, GetTestV4ProtocolConfig(disable_auto_update),
         base::Bind(&V4UpdateProtocolManagerTest::ValidateGetUpdatesResults,
-                   base::Unretained(this), expected_lurs));
+                   base::Unretained(this), expected_lurs),
+        base::Bind(&V4UpdateProtocolManagerTest::GetExtendedReportingLevel,
+                   base::Unretained(this), erl));
   }
 
   void SetupStoreStates() {
     store_state_map_ = base::MakeUnique<StoreStateMap>();
 
     ListIdentifier win_url_malware(WINDOWS_PLATFORM, URL, MALWARE_THREAT);
     store_state_map_->insert({win_url_malware, "initial_state_1"});
 
     ListIdentifier win_url_uws(WINDOWS_PLATFORM, URL, UNWANTED_SOFTWARE);
     store_state_map_->insert({win_url_uws, "initial_state_2"});
@@ skipping 206 matching lines @@
   // output.
   store_state_map_->clear();
   (*store_state_map_)[ListIdentifier(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 =
       pm->GetBase64SerializedUpdateRequestProto();
-  EXPECT_EQ("Cg8KCHVuaXR0ZXN0EgMxLjAaGAgBEAIaCmg4eGZZcVk-OlIiBCABIAIoAQ==",
+  EXPECT_EQ("Cg8KCHVuaXR0ZXN0EgMxLjAaGAgBEAIaCmg4eGZZcVk-OlIiBCABIAIoASICCAE=",
             encoded_request_with_minus);
 
   // TODO(vakh): Add a similar test for underscore for completeness, although
   // the '-' case is sufficient to prove that we are using URL encoding.
 }
 
 TEST_F(V4UpdateProtocolManagerTest, TestDisableAutoUpdates) {
   scoped_refptr<base::TestSimpleTaskRunner> runner(
       new base::TestSimpleTaskRunner());
   base::ThreadTaskRunnerHandle runner_handler(runner);
@@ skipping 46 matching lines @@
   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_);
 }
 
+TEST_F(V4UpdateProtocolManagerTest, TestExtendedReportingLevelIncluded) {
+  store_state_map_->clear();
+  (*store_state_map_)[ListIdentifier(LINUX_PLATFORM, URL, MALWARE_THREAT)] =
+      "state";
+  std::string base = "Cg8KCHVuaXR0ZXN0EgMxLjAaEwgBEAIaBXN0YXRlIgQgASACKAEiAgg";
+
+  std::unique_ptr<V4UpdateProtocolManager> pm_with_off(CreateProtocolManager(
+      std::vector<ListUpdateResponse>({}), false, SBER_LEVEL_OFF));
+  pm_with_off->store_state_map_ = std::move(store_state_map_);
+  EXPECT_EQ(base + "B", pm_with_off->GetBase64SerializedUpdateRequestProto());
+
+  std::unique_ptr<V4UpdateProtocolManager> pm_with_legacy(CreateProtocolManager(
+      std::vector<ListUpdateResponse>({}), false, SBER_LEVEL_LEGACY));
+  pm_with_legacy->store_state_map_ = std::move(pm_with_off->store_state_map_);
+  EXPECT_EQ(base + "C",
+            pm_with_legacy->GetBase64SerializedUpdateRequestProto());
+
+  std::unique_ptr<V4UpdateProtocolManager> pm_with_scout(CreateProtocolManager(
+      std::vector<ListUpdateResponse>({}), false, SBER_LEVEL_SCOUT));
+  pm_with_scout->store_state_map_ = std::move(pm_with_legacy->store_state_map_);
+  EXPECT_EQ(base + "D", pm_with_scout->GetBase64SerializedUpdateRequestProto());
+}
+
 }  // namespace safe_browsing