1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/bind.h" 6 #include "base/message_loop/message_loop.h" 7 #include "base/run_loop.h" 8 #include "chrome/browser/extensions/blacklist.h" 9 #include "chrome/browser/extensions/extension_prefs.h" 10 #include "chrome/browser/extensions/fake_safe_browsing_database_manager.h" 11 #include "chrome/browser/extensions/test_blacklist.h" 12 #include "chrome/browser/extensions/test_extension_prefs.h" 13 #include "content/public/test/test_browser_thread.h" 14 #include "testing/gtest/include/gtest/gtest.h" 15 16 namespace extensions { 17 namespace { 18 19 class BlacklistTest : public testing::Test { 20 public: 21 BlacklistTest() 22 : prefs_(message_loop_.message_loop_proxy().get()), 23 ui_thread_(content::BrowserThread::UI, &message_loop_), 24 io_thread_(content::BrowserThread::IO, &message_loop_), 25 safe_browsing_database_manager_(new FakeSafeBrowsingDatabaseManager()), 26 scoped_blacklist_database_manager_(safe_browsing_database_manager_), 27 blacklist_(prefs_.prefs()) {} 28 29 bool IsBlacklisted(const Extension* extension) { 30 return TestBlacklist(&blacklist_).IsBlacklisted(extension->id()); 31 } 32 33 protected: 34 base::MessageLoop message_loop_; 35 36 TestExtensionPrefs prefs_; 37 38 content::TestBrowserThread ui_thread_; 39 content::TestBrowserThread io_thread_; 40 41 scoped_refptr<FakeSafeBrowsingDatabaseManager> 42 safe_browsing_database_manager_; 43 Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_database_manager_; 44 45 Blacklist blacklist_; 46 }; 47 48 TEST_F(BlacklistTest, SetFromUpdater) { 49 scoped_refptr<const Extension> extension_a = prefs_.AddExtension("a"); 50 scoped_refptr<const Extension> extension_b = prefs_.AddExtension("b"); 51 scoped_refptr<const Extension> extension_c = prefs_.AddExtension("c"); 52 scoped_refptr<const Extension> extension_d = prefs_.AddExtension("d"); 53 54 // c, d, start blacklisted. 55 prefs_.prefs()->SetExtensionBlacklisted(extension_c->id(), true); 56 prefs_.prefs()->SetExtensionBlacklisted(extension_d->id(), true); 57 58 EXPECT_FALSE(IsBlacklisted(extension_a.get())); 59 EXPECT_FALSE(IsBlacklisted(extension_b.get())); 60 EXPECT_TRUE(IsBlacklisted(extension_c.get())); 61 EXPECT_TRUE(IsBlacklisted(extension_d.get())); 62 63 // Mix up the blacklist. 64 { 65 std::vector<std::string> blacklist; 66 blacklist.push_back(extension_b->id()); 67 blacklist.push_back(extension_c->id()); 68 blacklist_.SetFromUpdater(blacklist, "1"); 69 } 70 EXPECT_FALSE(IsBlacklisted(extension_a.get())); 71 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 72 EXPECT_TRUE(IsBlacklisted(extension_c.get())); 73 EXPECT_FALSE(IsBlacklisted(extension_d.get())); 74 75 // No-op, just in case. 76 { 77 std::vector<std::string> blacklist; 78 blacklist.push_back(extension_b->id()); 79 blacklist.push_back(extension_c->id()); 80 blacklist_.SetFromUpdater(blacklist, "2"); 81 } 82 EXPECT_FALSE(IsBlacklisted(extension_a.get())); 83 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 84 EXPECT_TRUE(IsBlacklisted(extension_c.get())); 85 EXPECT_FALSE(IsBlacklisted(extension_d.get())); 86 87 // Strictly increase the blacklist. 88 { 89 std::vector<std::string> blacklist; 90 blacklist.push_back(extension_a->id()); 91 blacklist.push_back(extension_b->id()); 92 blacklist.push_back(extension_c->id()); 93 blacklist.push_back(extension_d->id()); 94 blacklist_.SetFromUpdater(blacklist, "3"); 95 } 96 EXPECT_TRUE(IsBlacklisted(extension_a.get())); 97 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 98 EXPECT_TRUE(IsBlacklisted(extension_c.get())); 99 EXPECT_TRUE(IsBlacklisted(extension_d.get())); 100 101 // Strictly decrease the blacklist. 102 { 103 std::vector<std::string> blacklist; 104 blacklist.push_back(extension_a->id()); 105 blacklist.push_back(extension_b->id()); 106 blacklist_.SetFromUpdater(blacklist, "4"); 107 } 108 EXPECT_TRUE(IsBlacklisted(extension_a.get())); 109 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 110 EXPECT_FALSE(IsBlacklisted(extension_c.get())); 111 EXPECT_FALSE(IsBlacklisted(extension_d.get())); 112 113 // Clear the blacklist. 114 { 115 std::vector<std::string> blacklist; 116 blacklist_.SetFromUpdater(blacklist, "5"); 117 } 118 EXPECT_FALSE(IsBlacklisted(extension_a.get())); 119 EXPECT_FALSE(IsBlacklisted(extension_b.get())); 120 EXPECT_FALSE(IsBlacklisted(extension_c.get())); 121 EXPECT_FALSE(IsBlacklisted(extension_d.get())); 122 } 123 124 void Assign(std::set<std::string> *to, const std::set<std::string>& from) { 125 *to = from; 126 } 127 128 TEST_F(BlacklistTest, OnlyIncludesRequestedIDs) { 129 scoped_refptr<const Extension> extension_a = prefs_.AddExtension("a"); 130 scoped_refptr<const Extension> extension_b = prefs_.AddExtension("b"); 131 scoped_refptr<const Extension> extension_c = prefs_.AddExtension("c"); 132 133 { 134 std::vector<std::string> blacklist; 135 blacklist.push_back(extension_a->id()); 136 blacklist.push_back(extension_b->id()); 137 blacklist_.SetFromUpdater(blacklist, "1"); 138 base::RunLoop().RunUntilIdle(); 139 } 140 141 std::set<std::string> blacklist_actual; 142 { 143 std::set<std::string> blacklist_query; 144 blacklist_query.insert(extension_a->id()); 145 blacklist_query.insert(extension_c->id()); 146 blacklist_.GetBlacklistedIDs(blacklist_query, 147 base::Bind(&Assign, &blacklist_actual)); 148 base::RunLoop().RunUntilIdle(); 149 } 150 151 std::set<std::string> blacklist_expected; 152 blacklist_expected.insert(extension_a->id()); 153 EXPECT_EQ(blacklist_expected, blacklist_actual); 154 } 155 156 TEST_F(BlacklistTest, PrefsVsSafeBrowsing) { 157 scoped_refptr<const Extension> extension_a = prefs_.AddExtension("a"); 158 scoped_refptr<const Extension> extension_b = prefs_.AddExtension("b"); 159 scoped_refptr<const Extension> extension_c = prefs_.AddExtension("c"); 160 161 // Prefs have a and b blacklisted, safebrowsing has b and c. 162 prefs_.prefs()->SetExtensionBlacklisted(extension_a->id(), true); 163 prefs_.prefs()->SetExtensionBlacklisted(extension_b->id(), true); 164 { 165 std::set<std::string> bc; 166 bc.insert(extension_b->id()); 167 bc.insert(extension_c->id()); 168 safe_browsing_database_manager_->set_unsafe_ids(bc); 169 } 170 171 // The manager is still disabled at this point, so c won't be blacklisted. 172 EXPECT_TRUE(IsBlacklisted(extension_a.get())); 173 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 174 EXPECT_FALSE(IsBlacklisted(extension_c.get())); 175 176 // Now it should be. 177 safe_browsing_database_manager_->set_enabled(true); 178 EXPECT_TRUE(IsBlacklisted(extension_a.get())); 179 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 180 EXPECT_TRUE(IsBlacklisted(extension_c.get())); 181 182 // Corner case: nothing in safebrowsing (but still enabled). 183 safe_browsing_database_manager_->set_unsafe_ids(std::set<std::string>()); 184 EXPECT_TRUE(IsBlacklisted(extension_a.get())); 185 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 186 EXPECT_FALSE(IsBlacklisted(extension_c.get())); 187 188 // Corner case: nothing in prefs. 189 prefs_.prefs()->SetExtensionBlacklisted(extension_a->id(), false); 190 prefs_.prefs()->SetExtensionBlacklisted(extension_b->id(), false); 191 { 192 std::set<std::string> bc; 193 bc.insert(extension_b->id()); 194 bc.insert(extension_c->id()); 195 safe_browsing_database_manager_->set_unsafe_ids(bc); 196 } 197 EXPECT_FALSE(IsBlacklisted(extension_a.get())); 198 EXPECT_TRUE(IsBlacklisted(extension_b.get())); 199 EXPECT_TRUE(IsBlacklisted(extension_c.get())); 200 } 201 202 } // namespace extensions 203 } // namespace 204
