Check result of ApiBlacklist query in client.

chrome/browser/permissions/permission_decision_auto_blocker_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 "chrome/browser/permissions/permission_decision_auto_blocker.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 11 matching lines @@
 namespace {
 
 bool FilterGoogle(const GURL& url) {
   return url == "https://www.google.com/";
 }
 
 bool FilterAll(const GURL& url) {
   return true;
 }
 
-}  // namespace
-
 class MockSafeBrowsingDatabaseManager
     : public safe_browsing::TestSafeBrowsingDatabaseManager {
  public:
-  explicit MockSafeBrowsingDatabaseManager(bool perform_callback)
-      : perform_callback_(perform_callback) {}
+  explicit MockSafeBrowsingDatabaseManager(bool perform_callback, bool enabled)
+      : perform_callback_(perform_callback), enabled_(enabled) {}
 
   bool CheckApiBlacklistUrl(
       const GURL& url,
       safe_browsing::SafeBrowsingDatabaseManager::Client* client) override {
+    // Return true when able to synchronously determine that the url is safe.
+    if (!enabled_) {
+      return true;
+    }
+
     if (perform_callback_) {
       safe_browsing::ThreatMetadata metadata;
       const auto& blacklisted_permissions = permissions_blacklist_.find(url);
       if (blacklisted_permissions != permissions_blacklist_.end())
         metadata.api_permissions = blacklisted_permissions->second;
       client->OnCheckApiBlacklistUrlResult(url, metadata);
     }
     return false;
   }
 
@@ skipping 10 matching lines @@
 
   void SetPerformCallback(bool perform_callback) {
     perform_callback_ = perform_callback;
   }
 
  protected:
   ~MockSafeBrowsingDatabaseManager() override {}
 
  private:
   bool perform_callback_;
+  bool enabled_;
   std::map<GURL, std::set<std::string>> permissions_blacklist_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSafeBrowsingDatabaseManager);
 };
 
+}  // namespace
+
 class PermissionDecisionAutoBlockerUnitTest
     : public ChromeRenderViewHostTestHarness {
  protected:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     autoblocker_ = PermissionDecisionAutoBlocker::GetForProfile(profile());
     feature_list_.InitWithFeatures({features::kBlockPromptsIfDismissedOften,
                                     features::kPermissionsBlacklist},
                                    {});
     last_embargoed_status_ = false;
     std::unique_ptr<base::SimpleTestClock> clock =
         base::MakeUnique<base::SimpleTestClock>();
     clock_ = clock.get();
     autoblocker_->SetClockForTesting(std::move(clock));
+    callback_was_run_ = false;
   }
 
   void SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(
       scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager,
       int timeout) {
     autoblocker_->SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                                      timeout);
   }
 
   void UpdateEmbargoedStatus(content::PermissionType permission,
@@ skipping 12 matching lines @@
   void PlaceUnderBlacklistEmbargo(content::PermissionType permission,
                                   const GURL& url) {
     autoblocker_->PlaceUnderEmbargo(
         permission, url,
         PermissionDecisionAutoBlocker::kPermissionBlacklistEmbargoKey);
   }
 
   PermissionDecisionAutoBlocker* autoblocker() { return autoblocker_; }
 
   void SetLastEmbargoStatus(base::Closure quit_closure, bool status) {
+    callback_was_run_ = true;
     last_embargoed_status_ = status;
     if (quit_closure) {
       quit_closure.Run();
       quit_closure.Reset();
     }
   }
 
   bool last_embargoed_status() { return last_embargoed_status_; }
 
+  bool callback_was_run() { return callback_was_run_; }
+
   base::SimpleTestClock* clock() { return clock_; }
 
   const char* GetDismissKey() {
     return PermissionDecisionAutoBlocker::kPromptDismissCountKey;
   }
 
   const char* GetIgnoreKey() {
     return PermissionDecisionAutoBlocker::kPromptIgnoreCountKey;
   }
 
  private:
   PermissionDecisionAutoBlocker* autoblocker_;
   base::test::ScopedFeatureList feature_list_;
   base::SimpleTestClock* clock_;
   bool last_embargoed_status_;
+  bool callback_was_run_;
 };
 
 TEST_F(PermissionDecisionAutoBlockerUnitTest, RemoveCountsByUrl) {
   GURL url1("https://www.google.com");
   GURL url2("https://www.example.com");
 
   // Record some dismissals.
   EXPECT_FALSE(autoblocker()->RecordDismissAndEmbargo(
       url1, content::PermissionType::GEOLOCATION));
   EXPECT_EQ(1, autoblocker()->GetDismissCount(
@@ skipping 91 matching lines @@
                    url2, content::PermissionType::DURABLE_STORAGE));
   EXPECT_EQ(0, autoblocker()->GetIgnoreCount(
                    url2, content::PermissionType::MIDI_SYSEX));
 }
 
 // Test that an origin that has been blacklisted for a permission is embargoed.
 TEST_F(PermissionDecisionAutoBlockerUnitTest, TestUpdateEmbargoBlacklist) {
   GURL url("https://www.google.com");
 
   scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
-      new MockSafeBrowsingDatabaseManager(true /* perform_callback */);
+      new MockSafeBrowsingDatabaseManager(true /* perform_callback */,
+                                          true /* enabled */);
   std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
   SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                      2000 /* timeout in ms */);
 
   UpdateEmbargoedStatus(content::PermissionType::GEOLOCATION, url);
+  EXPECT_TRUE(callback_was_run());
   EXPECT_TRUE(last_embargoed_status());
 }
 
 // Check that IsUnderEmbargo returns the correct value when the embargo is set
 // and expires.
 TEST_F(PermissionDecisionAutoBlockerUnitTest, CheckEmbargoStatus) {
   GURL url("https://www.google.com");
   clock()->SetNow(base::Time::Now());
 
   PlaceUnderBlacklistEmbargo(content::PermissionType::GEOLOCATION, url);
@@ skipping 96 matching lines @@
   clock()->Advance(base::TimeDelta::FromDays(3));
   EXPECT_TRUE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 }
 
 TEST_F(PermissionDecisionAutoBlockerUnitTest, TestSafeBrowsingTimeout) {
   GURL url("https://www.google.com");
   clock()->SetNow(base::Time::Now());
 
   scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
-      new MockSafeBrowsingDatabaseManager(false /* perform_callback */);
+      new MockSafeBrowsingDatabaseManager(false /* perform_callback */,
+                                          true /* enabled */);
   std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
   SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                      0 /* timeout in ms */);
 
   UpdateEmbargoedStatus(content::PermissionType::GEOLOCATION, url);
+  EXPECT_TRUE(callback_was_run());
   EXPECT_FALSE(last_embargoed_status());
   EXPECT_FALSE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
   db_manager->SetPerformCallback(true);
   SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                      2000 /* timeout in ms */);
 
   clock()->Advance(base::TimeDelta::FromDays(1));
   UpdateEmbargoedStatus(content::PermissionType::GEOLOCATION, url);
+  EXPECT_TRUE(callback_was_run());
   EXPECT_TRUE(last_embargoed_status());
 
   clock()->Advance(base::TimeDelta::FromDays(1));
   EXPECT_TRUE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 }
 
 // TODO(raymes): See crbug.com/681709. Remove after M60.
 TEST_F(PermissionDecisionAutoBlockerUnitTest,
        MigrateNoDecisionCountToPermissionAutoBlockerData) {
@@ skipping 58 matching lines @@
         profile()->GetPrefs(), false /* is_incognito_profile */,
         false /* is_guest_profile */));
     temp_map->ShutdownOnUIThread();
   }
 
   EXPECT_EQ(100, autoblocker()->GetDismissCount(
                      url, content::PermissionType::GEOLOCATION));
   EXPECT_EQ(50, autoblocker()->GetIgnoreCount(
                     url, content::PermissionType::GEOLOCATION));
 }
+
+// Test that a blacklisted permission should not be autoblocked if the database
+// manager is disabled.
+TEST_F(PermissionDecisionAutoBlockerUnitTest, TestDisabledDatabaseManager) {
+  GURL url("https://www.google.com");
+  scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
+      new MockSafeBrowsingDatabaseManager(true /* perform_callback */,
+                                          false /* enabled */);
+  std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
+  db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
+  SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
+                                                     2000 /* timeout in ms */);
+  UpdateEmbargoedStatus(content::PermissionType::GEOLOCATION, url);
+  EXPECT_TRUE(callback_was_run());
+  EXPECT_FALSE(last_embargoed_status());
+}