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/logging.h"

[raymes, 2017/02/08 01:42:06]

nit: is this needed?

[meredithl, 2017/02/08 02:18:23]

No! Forgot to remove it. Done.

 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/simple_test_clock.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "content/public/browser/permission_type.h"
 
 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;
@@ skipping 161 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(last_embargoed_status());
 }
 
 // Check that IsUnderEmbargo returns the correct value when the embargo is set
@@ skipping 102 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_FALSE(last_embargoed_status());
   EXPECT_FALSE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
   db_manager->SetPerformCallback(true);
@@ skipping 73 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_FALSE(last_embargoed_status());

[kcarattini, 2017/02/08 02:07:28]

Can you also check that the callback was run. Otherwise this could pass by
accident since this is set to false SetUp.

[meredithl, 2017/02/08 02:18:23]

Done.

+}