Add extended reporting level in the update request

components/safe_browsing_db/v4_local_database_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 "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/safe_browsing_db/v4_database.h"
 #include "components/safe_browsing_db/v4_local_database_manager.h"
 #include "components/safe_browsing_db/v4_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "crypto/sha2.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/platform_test.h"
 
 namespace safe_browsing {
 
 namespace {
 
+typedef base::Callback<void()> NullCallback;
+
 // Utility function for populating hashes.
 FullHash HashForUrl(const GURL& url) {
   std::vector<FullHash> full_hashes;
   V4ProtocolManagerUtil::UrlToFullHashes(url, &full_hashes);
   // ASSERT_GE(full_hashes.size(), 1u);
   return full_hashes[0];
 }
 
 // Always returns misses from GetFullHashes().
 class FakeGetHashProtocolManager : public V4GetHashProtocolManager {
@@ skipping 148 matching lines @@
 };
 
 class FakeV4LocalDatabaseManager : public V4LocalDatabaseManager {
  public:
   void PerformFullHashCheck(std::unique_ptr<PendingCheck> check,
                             const FullHashToStoreAndHashPrefixesMap&
                                 full_hash_to_store_and_hash_prefixes) override {
     perform_full_hash_check_called_ = true;
   }
 
-  FakeV4LocalDatabaseManager(const base::FilePath& base_path)
-      : V4LocalDatabaseManager(base_path),
+  FakeV4LocalDatabaseManager(
+      const base::FilePath& base_path,
+      ExtendedReportingLevelCallback extended_reporting_level_callback)
+      : V4LocalDatabaseManager(base_path, extended_reporting_level_callback),
         perform_full_hash_check_called_(false) {}
 
   static bool PerformFullHashCheckCalled(
       scoped_refptr<safe_browsing::V4LocalDatabaseManager>& v4_ldbm) {
     FakeV4LocalDatabaseManager* fake =
         static_cast<FakeV4LocalDatabaseManager*>(v4_ldbm.get());
     return fake->perform_full_hash_check_called_;
   }
 
  private:
   ~FakeV4LocalDatabaseManager() override {}
 
   bool perform_full_hash_check_called_;
 };
 
 class V4LocalDatabaseManagerTest : public PlatformTest {
  public:
   V4LocalDatabaseManagerTest() : task_runner_(new base::TestSimpleTaskRunner) {}
 
   void SetUp() override {
     PlatformTest::SetUp();
 
     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
     DVLOG(1) << "base_dir_: " << base_dir_.GetPath().value();
 
-    v4_local_database_manager_ =
-        make_scoped_refptr(new V4LocalDatabaseManager(base_dir_.GetPath()));
+    extended_reporting_level_ = SBER_LEVEL_OFF;
+    erl_callback_ =
+        base::Bind(&V4LocalDatabaseManagerTest::GetExtendedReportingLevel,
+                   base::Unretained(this));
+
+    v4_local_database_manager_ = make_scoped_refptr(
+        new V4LocalDatabaseManager(base_dir_.GetPath(), erl_callback_));
     SetTaskRunnerForTest();
 
     StartLocalDatabaseManager();
   }
 
   void TearDown() override {
     StopLocalDatabaseManager();
 
     PlatformTest::TearDown();
   }
 
   void ForceDisableLocalDatabaseManager() {
     v4_local_database_manager_->enabled_ = false;
   }
 
   void ForceEnableLocalDatabaseManager() {
     v4_local_database_manager_->enabled_ = true;
   }
 
   const V4LocalDatabaseManager::QueuedChecks& GetQueuedChecks() {
     return v4_local_database_manager_->queued_checks_;
   }
 
+  ExtendedReportingLevel GetExtendedReportingLevel() {
+    return extended_reporting_level_;
+  }
+
   void ReplaceV4Database(const StoreAndHashPrefixes& store_and_hash_prefixes,
                          bool stores_available = false) {
     // Disable the V4LocalDatabaseManager first so that if the callback to
     // verify checksum has been scheduled, then it doesn't do anything when it
     // is called back.
     ForceDisableLocalDatabaseManager();
     // Wait to make sure that the callback gets executed if it has already been
     // scheduled.
     WaitForTasksOnTaskRunner();
     // Re-enable the V4LocalDatabaseManager otherwise the checks won't work and
     // the fake database won't be set either.
     ForceEnableLocalDatabaseManager();
 
     NewDatabaseReadyCallback db_ready_callback =
         base::Bind(&V4LocalDatabaseManager::DatabaseReadyForChecks,
                    base::Unretained(v4_local_database_manager_.get()));
     FakeV4Database::Create(task_runner_, base::MakeUnique<StoreMap>(),
                            store_and_hash_prefixes, db_ready_callback,
                            stores_available);
     WaitForTasksOnTaskRunner();
   }
 
   void ResetLocalDatabaseManager() {
     StopLocalDatabaseManager();
-    v4_local_database_manager_ =
-        make_scoped_refptr(new V4LocalDatabaseManager(base_dir_.GetPath()));
+    v4_local_database_manager_ = make_scoped_refptr(
+        new V4LocalDatabaseManager(base_dir_.GetPath(), erl_callback_));
     SetTaskRunnerForTest();
     StartLocalDatabaseManager();
   }
 
   void ResetV4Database() {
     V4Database::Destroy(std::move(v4_local_database_manager_->v4_database_));
   }
 
   void SetTaskRunnerForTest() {
     v4_local_database_manager_->SetTaskRunnerForTest(task_runner_);
@@ skipping 18 matching lines @@
     // V4LocalDatabaseManager has read the data from disk.
     task_runner_->RunPendingTasks();
     base::RunLoop().RunUntilIdle();
   }
 
   // For those tests that need the fake manager
   void SetupFakeManager() {
     // StopLocalDatabaseManager before resetting it because that's what
     // ~V4LocalDatabaseManager expects.
     StopLocalDatabaseManager();
-    v4_local_database_manager_ =
-        make_scoped_refptr(new FakeV4LocalDatabaseManager(base_dir_.GetPath()));
+    v4_local_database_manager_ = make_scoped_refptr(
+        new FakeV4LocalDatabaseManager(base_dir_.GetPath(), erl_callback_));
     SetTaskRunnerForTest();
     StartLocalDatabaseManager();
     WaitForTasksOnTaskRunner();
   }
 
   base::ScopedTempDir base_dir_;
+  ExtendedReportingLevel extended_reporting_level_;
+  ExtendedReportingLevelCallback erl_callback_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<V4LocalDatabaseManager> v4_local_database_manager_;
 };
 
 TEST_F(V4LocalDatabaseManagerTest, TestGetThreatSource) {
   WaitForTasksOnTaskRunner();
   EXPECT_EQ(ThreatSource::LOCAL_PVER4,
             v4_local_database_manager_->GetThreatSource());
 }
@@ skipping 390 matching lines @@
   EXPECT_FALSE(client.on_check_resource_url_result_called_);
   WaitForTasksOnTaskRunner();
   EXPECT_TRUE(client.on_check_resource_url_result_called_);
 }
 
 // TODO(nparker): Add tests for
 //   CheckDownloadUrl()
 //   CheckExtensionIDs()
 
 }  // namespace safe_browsing