Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(32)

Side by Side Diff: chrome/browser/safe_browsing/safe_browsing_database_unittest.cc

Issue 1420123003: Move more declarations from c/b/sb/sb_util.h to components. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@01_components
Patch Set: Minor: Replace safe_browsing_util:: with safe_browsing:: and use safe_browsing:: namespace prefix Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 // 4 //
5 // Unit tests for the SafeBrowsing storage system. 5 // Unit tests for the SafeBrowsing storage system.
6 6
7 #include "chrome/browser/safe_browsing/safe_browsing_database.h" 7 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
8 8
9 #include "base/files/file_util.h" 9 #include "base/files/file_util.h"
10 #include "base/files/scoped_temp_dir.h" 10 #include "base/files/scoped_temp_dir.h"
(...skipping 14 matching lines...) Expand all
25 #include "url/gurl.h" 25 #include "url/gurl.h"
26 26
27 using base::Time; 27 using base::Time;
28 using base::TimeDelta; 28 using base::TimeDelta;
29 29
30 namespace { 30 namespace {
31 31
32 const TimeDelta kCacheLifetime = TimeDelta::FromMinutes(45); 32 const TimeDelta kCacheLifetime = TimeDelta::FromMinutes(45);
33 33
34 SBPrefix SBPrefixForString(const std::string& str) { 34 SBPrefix SBPrefixForString(const std::string& str) {
35 return SBFullHashForString(str).prefix; 35 return safe_browsing::SBFullHashForString(str).prefix;
36 } 36 }
37 37
38 // Construct a full hash which has the given prefix, with the given 38 // Construct a full hash which has the given prefix, with the given
39 // suffix data coming after the prefix. 39 // suffix data coming after the prefix.
40 SBFullHash SBFullHashForPrefixAndSuffix(SBPrefix prefix, 40 SBFullHash SBFullHashForPrefixAndSuffix(SBPrefix prefix,
41 const base::StringPiece& suffix) { 41 const base::StringPiece& suffix) {
42 SBFullHash full_hash; 42 SBFullHash full_hash;
43 memset(&full_hash, 0, sizeof(SBFullHash)); 43 memset(&full_hash, 0, sizeof(SBFullHash));
44 full_hash.prefix = prefix; 44 full_hash.prefix = prefix;
45 CHECK_LE(suffix.size() + sizeof(SBPrefix), sizeof(SBFullHash)); 45 CHECK_LE(suffix.size() + sizeof(SBPrefix), sizeof(SBFullHash));
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after
128 SBChunkData* AddChunkFullHash(int chunk_number, SBFullHash full_hash) { 128 SBChunkData* AddChunkFullHash(int chunk_number, SBFullHash full_hash) {
129 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 129 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD,
130 safe_browsing::ChunkData::FULL_32B, 130 safe_browsing::ChunkData::FULL_32B,
131 &full_hash, sizeof(full_hash), 131 &full_hash, sizeof(full_hash),
132 std::vector<int>()); 132 std::vector<int>());
133 } 133 }
134 134
135 // Generate an add chunk with a full hash generated from |value|. 135 // Generate an add chunk with a full hash generated from |value|.
136 SBChunkData* AddChunkFullHashValue(int chunk_number, 136 SBChunkData* AddChunkFullHashValue(int chunk_number,
137 const std::string& value) { 137 const std::string& value) {
138 return AddChunkFullHash(chunk_number, SBFullHashForString(value)); 138 return AddChunkFullHash(chunk_number,
139 safe_browsing::SBFullHashForString(value));
139 } 140 }
140 141
141 // Generate an add chunk with two full hashes. 142 // Generate an add chunk with two full hashes.
142 SBChunkData* AddChunkFullHash2Value(int chunk_number, 143 SBChunkData* AddChunkFullHash2Value(int chunk_number,
143 const std::string& value1, 144 const std::string& value1,
144 const std::string& value2) { 145 const std::string& value2) {
145 const SBFullHash full_hashes[2] = { 146 const SBFullHash full_hashes[2] = {
146 SBFullHashForString(value1), 147 safe_browsing::SBFullHashForString(value1),
147 SBFullHashForString(value2), 148 safe_browsing::SBFullHashForString(value2),
148 }; 149 };
149 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 150 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD,
150 safe_browsing::ChunkData::FULL_32B, 151 safe_browsing::ChunkData::FULL_32B,
151 &full_hashes[0], sizeof(full_hashes), 152 &full_hashes[0], sizeof(full_hashes),
152 std::vector<int>()); 153 std::vector<int>());
153 } 154 }
154 155
155 // Generate a sub chunk with a prefix generated from |value|. 156 // Generate a sub chunk with a prefix generated from |value|.
156 SBChunkData* SubChunkPrefixValue(int chunk_number, 157 SBChunkData* SubChunkPrefixValue(int chunk_number,
157 const std::string& value, 158 const std::string& value,
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
190 safe_browsing::ChunkData::FULL_32B, 191 safe_browsing::ChunkData::FULL_32B,
191 &full_hash, sizeof(full_hash), 192 &full_hash, sizeof(full_hash),
192 std::vector<int>(1, add_chunk_number)); 193 std::vector<int>(1, add_chunk_number));
193 } 194 }
194 195
195 // Generate a sub chunk with a full hash generated from |value|. 196 // Generate a sub chunk with a full hash generated from |value|.
196 SBChunkData* SubChunkFullHashValue(int chunk_number, 197 SBChunkData* SubChunkFullHashValue(int chunk_number,
197 const std::string& value, 198 const std::string& value,
198 int add_chunk_number) { 199 int add_chunk_number) {
199 return SubChunkFullHash(chunk_number, 200 return SubChunkFullHash(chunk_number,
200 SBFullHashForString(value), 201 safe_browsing::SBFullHashForString(value),
201 add_chunk_number); 202 add_chunk_number);
202 } 203 }
203 204
204 // Generate an add chunk with a single full hash for the ip blacklist. 205 // Generate an add chunk with a single full hash for the ip blacklist.
205 SBChunkData* AddChunkHashedIpValue(int chunk_number, 206 SBChunkData* AddChunkHashedIpValue(int chunk_number,
206 const std::string& ip_str, 207 const std::string& ip_str,
207 size_t prefix_size) { 208 size_t prefix_size) {
208 const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size); 209 const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size);
209 EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size()); 210 EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size());
210 SBFullHash full_hash; 211 SBFullHash full_hash;
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after
344 // Tests retrieving list name information. 345 // Tests retrieving list name information.
345 TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) { 346 TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) {
346 std::vector<SBListChunkRanges> lists; 347 std::vector<SBListChunkRanges> lists;
347 ScopedVector<SBChunkData> chunks; 348 ScopedVector<SBChunkData> chunks;
348 349
349 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 350 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
350 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); 351 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
351 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html")); 352 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html"));
352 353
353 ASSERT_TRUE(database_->UpdateStarted(&lists)); 354 ASSERT_TRUE(database_->UpdateStarted(&lists));
354 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 355 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
355 database_->UpdateFinished(true); 356 database_->UpdateFinished(true);
356 357
357 GetListsInfo(&lists); 358 GetListsInfo(&lists);
358 ASSERT_LE(1U, lists.size()); 359 ASSERT_LE(1U, lists.size());
359 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 360 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
360 EXPECT_EQ("1-3", lists[0].adds); 361 EXPECT_EQ("1-3", lists[0].adds);
361 EXPECT_TRUE(lists[0].subs.empty()); 362 EXPECT_TRUE(lists[0].subs.empty());
362 363
363 // Insert a malware sub chunk. 364 // Insert a malware sub chunk.
364 chunks.clear(); 365 chunks.clear();
365 chunks.push_back(SubChunkPrefixValue(7, "www.subbed.com/noteveil1.html", 19)); 366 chunks.push_back(SubChunkPrefixValue(7, "www.subbed.com/noteveil1.html", 19));
366 367
367 ASSERT_TRUE(database_->UpdateStarted(&lists)); 368 ASSERT_TRUE(database_->UpdateStarted(&lists));
368 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 369 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
369 database_->UpdateFinished(true); 370 database_->UpdateFinished(true);
370 371
371 GetListsInfo(&lists); 372 GetListsInfo(&lists);
372 ASSERT_LE(1U, lists.size()); 373 ASSERT_LE(1U, lists.size());
373 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 374 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
374 EXPECT_EQ("1-3", lists[0].adds); 375 EXPECT_EQ("1-3", lists[0].adds);
375 EXPECT_EQ("7", lists[0].subs); 376 EXPECT_EQ("7", lists[0].subs);
376 if (lists.size() == 2) { 377 if (lists.size() == 2) {
377 // Old style database won't have the second entry since it creates the lists 378 // Old style database won't have the second entry since it creates the lists
378 // when it receives an update containing that list. The filter-based 379 // when it receives an update containing that list. The filter-based
379 // database has these values hard coded. 380 // database has these values hard coded.
380 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 381 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
381 EXPECT_TRUE(lists[1].adds.empty()); 382 EXPECT_TRUE(lists[1].adds.empty());
382 EXPECT_TRUE(lists[1].subs.empty()); 383 EXPECT_TRUE(lists[1].subs.empty());
383 } 384 }
384 385
385 // Add phishing chunks. 386 // Add phishing chunks.
386 chunks.clear(); 387 chunks.clear();
387 chunks.push_back(AddChunkPrefixValue(47, "www.evil.com/phishing.html")); 388 chunks.push_back(AddChunkPrefixValue(47, "www.evil.com/phishing.html"));
388 chunks.push_back( 389 chunks.push_back(
389 SubChunkPrefixValue(200, "www.phishy.com/notevil1.html", 1999)); 390 SubChunkPrefixValue(200, "www.phishy.com/notevil1.html", 1999));
390 chunks.push_back( 391 chunks.push_back(
391 SubChunkPrefixValue(201, "www.phishy2.com/notevil1.html", 1999)); 392 SubChunkPrefixValue(201, "www.phishy2.com/notevil1.html", 1999));
392 393
393 ASSERT_TRUE(database_->UpdateStarted(&lists)); 394 ASSERT_TRUE(database_->UpdateStarted(&lists));
394 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 395 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
395 database_->UpdateFinished(true); 396 database_->UpdateFinished(true);
396 397
397 GetListsInfo(&lists); 398 GetListsInfo(&lists);
398 ASSERT_LE(2U, lists.size()); 399 ASSERT_LE(2U, lists.size());
399 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 400 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
400 EXPECT_EQ("1-3", lists[0].adds); 401 EXPECT_EQ("1-3", lists[0].adds);
401 EXPECT_EQ("7", lists[0].subs); 402 EXPECT_EQ("7", lists[0].subs);
402 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 403 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
403 EXPECT_EQ("47", lists[1].adds); 404 EXPECT_EQ("47", lists[1].adds);
404 EXPECT_EQ("200-201", lists[1].subs); 405 EXPECT_EQ("200-201", lists[1].subs);
405 } 406 }
406 407
407 TEST_F(SafeBrowsingDatabaseTest, ListNames) { 408 TEST_F(SafeBrowsingDatabaseTest, ListNames) {
408 ScopedVector<SBChunkData> chunks; 409 ScopedVector<SBChunkData> chunks;
409 410
410 std::vector<SBListChunkRanges> lists; 411 std::vector<SBListChunkRanges> lists;
411 ASSERT_TRUE(database_->UpdateStarted(&lists)); 412 ASSERT_TRUE(database_->UpdateStarted(&lists));
412 413
413 // Insert malware, phish, binurl and bindownload add chunks. 414 // Insert malware, phish, binurl and bindownload add chunks.
414 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 415 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
415 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 416 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
416 417
417 chunks.clear(); 418 chunks.clear();
418 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); 419 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
419 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 420 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
420 421
421 chunks.clear(); 422 chunks.clear();
422 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/download.html")); 423 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/download.html"));
423 database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get()); 424 database_->InsertChunks(safe_browsing::kBinUrlList, chunks.get());
424 425
425 chunks.clear(); 426 chunks.clear();
426 chunks.push_back(AddChunkFullHashValue(5, "www.forwhitelist.com/a.html")); 427 chunks.push_back(AddChunkFullHashValue(5, "www.forwhitelist.com/a.html"));
427 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get()); 428 database_->InsertChunks(safe_browsing::kCsdWhiteList, chunks.get());
428 429
429 chunks.clear(); 430 chunks.clear();
430 chunks.push_back(AddChunkFullHashValue(6, "www.download.com/")); 431 chunks.push_back(AddChunkFullHashValue(6, "www.download.com/"));
431 database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, chunks.get()); 432 database_->InsertChunks(safe_browsing::kDownloadWhiteList, chunks.get());
432 433
433 chunks.clear(); 434 chunks.clear();
434 chunks.push_back(AddChunkFullHashValue(7, "www.inclusion.com/")); 435 chunks.push_back(AddChunkFullHashValue(7, "www.inclusion.com/"));
435 database_->InsertChunks(safe_browsing_util::kInclusionWhitelist, 436 database_->InsertChunks(safe_browsing::kInclusionWhitelist,
436 chunks.get()); 437 chunks.get());
437 438
438 chunks.clear(); 439 chunks.clear();
439 chunks.push_back(AddChunkFullHashValue(8, 440 chunks.push_back(AddChunkFullHashValue(8,
440 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 441 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
441 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); 442 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
442 database_->InsertChunks(safe_browsing_util::kExtensionBlacklist, 443 database_->InsertChunks(safe_browsing::kExtensionBlacklist,
443 chunks.get()); 444 chunks.get());
444 445
445 chunks.clear(); 446 chunks.clear();
446 chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120)); 447 chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120));
447 database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get()); 448 database_->InsertChunks(safe_browsing::kIPBlacklist, chunks.get());
448 449
449 chunks.clear(); 450 chunks.clear();
450 chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html")); 451 chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html"));
451 database_->InsertChunks(safe_browsing_util::kUnwantedUrlList, chunks.get()); 452 database_->InsertChunks(safe_browsing::kUnwantedUrlList, chunks.get());
452 453
453 database_->UpdateFinished(true); 454 database_->UpdateFinished(true);
454 455
455 GetListsInfo(&lists); 456 GetListsInfo(&lists);
456 ASSERT_EQ(9U, lists.size()); 457 ASSERT_EQ(9U, lists.size());
457 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 458 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
458 EXPECT_EQ("1", lists[0].adds); 459 EXPECT_EQ("1", lists[0].adds);
459 EXPECT_TRUE(lists[0].subs.empty()); 460 EXPECT_TRUE(lists[0].subs.empty());
460 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 461 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
461 EXPECT_EQ("2", lists[1].adds); 462 EXPECT_EQ("2", lists[1].adds);
462 EXPECT_TRUE(lists[1].subs.empty()); 463 EXPECT_TRUE(lists[1].subs.empty());
463 EXPECT_EQ(safe_browsing_util::kBinUrlList, lists[2].name); 464 EXPECT_EQ(safe_browsing::kBinUrlList, lists[2].name);
464 EXPECT_EQ("3", lists[2].adds); 465 EXPECT_EQ("3", lists[2].adds);
465 EXPECT_TRUE(lists[2].subs.empty()); 466 EXPECT_TRUE(lists[2].subs.empty());
466 EXPECT_EQ(safe_browsing_util::kCsdWhiteList, lists[3].name); 467 EXPECT_EQ(safe_browsing::kCsdWhiteList, lists[3].name);
467 EXPECT_EQ("5", lists[3].adds); 468 EXPECT_EQ("5", lists[3].adds);
468 EXPECT_TRUE(lists[3].subs.empty()); 469 EXPECT_TRUE(lists[3].subs.empty());
469 EXPECT_EQ(safe_browsing_util::kDownloadWhiteList, lists[4].name); 470 EXPECT_EQ(safe_browsing::kDownloadWhiteList, lists[4].name);
470 EXPECT_EQ("6", lists[4].adds); 471 EXPECT_EQ("6", lists[4].adds);
471 EXPECT_TRUE(lists[4].subs.empty()); 472 EXPECT_TRUE(lists[4].subs.empty());
472 EXPECT_EQ(safe_browsing_util::kInclusionWhitelist, lists[5].name); 473 EXPECT_EQ(safe_browsing::kInclusionWhitelist, lists[5].name);
473 EXPECT_EQ("7", lists[5].adds); 474 EXPECT_EQ("7", lists[5].adds);
474 EXPECT_TRUE(lists[5].subs.empty()); 475 EXPECT_TRUE(lists[5].subs.empty());
475 EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[6].name); 476 EXPECT_EQ(safe_browsing::kExtensionBlacklist, lists[6].name);
476 EXPECT_EQ("8", lists[6].adds); 477 EXPECT_EQ("8", lists[6].adds);
477 EXPECT_TRUE(lists[6].subs.empty()); 478 EXPECT_TRUE(lists[6].subs.empty());
478 EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[7].name); 479 EXPECT_EQ(safe_browsing::kIPBlacklist, lists[7].name);
479 EXPECT_EQ("10", lists[7].adds); 480 EXPECT_EQ("10", lists[7].adds);
480 EXPECT_TRUE(lists[7].subs.empty()); 481 EXPECT_TRUE(lists[7].subs.empty());
481 EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[8].name); 482 EXPECT_EQ(safe_browsing::kUnwantedUrlList, lists[8].name);
482 EXPECT_EQ("11", lists[8].adds); 483 EXPECT_EQ("11", lists[8].adds);
483 EXPECT_TRUE(lists[8].subs.empty()); 484 EXPECT_TRUE(lists[8].subs.empty());
484 485
485 database_.reset(); 486 database_.reset();
486 } 487 }
487 488
488 // Checks database reading and writing for browse and unwanted PrefixSets. 489 // Checks database reading and writing for browse and unwanted PrefixSets.
489 TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) { 490 TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) {
490 struct TestCase { 491 struct TestCase {
491 using TestListContainsBadUrl = bool (SafeBrowsingDatabase::*)( 492 using TestListContainsBadUrl = bool (SafeBrowsingDatabase::*)(
492 const GURL& url, 493 const GURL& url,
493 std::vector<SBPrefix>* prefix_hits, 494 std::vector<SBPrefix>* prefix_hits,
494 std::vector<SBFullHashResult>* cache_hits); 495 std::vector<SBFullHashResult>* cache_hits);
495 496
496 const char* test_list_name; 497 const char* test_list_name;
497 size_t expected_list_index; 498 size_t expected_list_index;
498 TestListContainsBadUrl test_list_contains_bad_url; 499 TestListContainsBadUrl test_list_contains_bad_url;
499 } const kTestCases[] { 500 } const kTestCases[] {
500 { safe_browsing_util::kMalwareList, 0U, 501 { safe_browsing::kMalwareList, 0U,
501 &SafeBrowsingDatabase::ContainsBrowseUrl }, 502 &SafeBrowsingDatabase::ContainsBrowseUrl },
502 { safe_browsing_util::kPhishingList, 1U, 503 { safe_browsing::kPhishingList, 1U,
503 &SafeBrowsingDatabase::ContainsBrowseUrl }, 504 &SafeBrowsingDatabase::ContainsBrowseUrl },
504 { safe_browsing_util::kUnwantedUrlList, 8U, 505 { safe_browsing::kUnwantedUrlList, 8U,
505 &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl }, 506 &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl },
506 }; 507 };
507 508
508 for (const auto& test_case : kTestCases) { 509 for (const auto& test_case : kTestCases) {
509 SCOPED_TRACE(std::string("Tested list at fault => ") + 510 SCOPED_TRACE(std::string("Tested list at fault => ") +
510 test_case.test_list_name); 511 test_case.test_list_name);
511 512
512 std::vector<SBListChunkRanges> lists; 513 std::vector<SBListChunkRanges> lists;
513 ScopedVector<SBChunkData> chunks; 514 ScopedVector<SBChunkData> chunks;
514 515
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after
750 751
751 // Populate with a couple of normal chunks. 752 // Populate with a couple of normal chunks.
752 chunks.push_back(AddChunkPrefix2Value(1, 753 chunks.push_back(AddChunkPrefix2Value(1,
753 "www.test.com/test1.html", 754 "www.test.com/test1.html",
754 "www.test.com/test2.html")); 755 "www.test.com/test2.html"));
755 chunks.push_back(AddChunkPrefix2Value(10, 756 chunks.push_back(AddChunkPrefix2Value(10,
756 "www.random.com/random1.html", 757 "www.random.com/random1.html",
757 "www.random.com/random2.html")); 758 "www.random.com/random2.html"));
758 759
759 ASSERT_TRUE(database_->UpdateStarted(&lists)); 760 ASSERT_TRUE(database_->UpdateStarted(&lists));
760 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 761 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
761 database_->UpdateFinished(true); 762 database_->UpdateFinished(true);
762 763
763 // Add an empty ADD and SUB chunk. 764 // Add an empty ADD and SUB chunk.
764 GetListsInfo(&lists); 765 GetListsInfo(&lists);
765 ASSERT_LE(1U, lists.size()); 766 ASSERT_LE(1U, lists.size());
766 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 767 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
767 EXPECT_EQ("1,10", lists[0].adds); 768 EXPECT_EQ("1,10", lists[0].adds);
768 EXPECT_TRUE(lists[0].subs.empty()); 769 EXPECT_TRUE(lists[0].subs.empty());
769 770
770 chunks.clear(); 771 chunks.clear();
771 chunks.push_back(BuildChunk(19, safe_browsing::ChunkData::ADD, 772 chunks.push_back(BuildChunk(19, safe_browsing::ChunkData::ADD,
772 safe_browsing::ChunkData::PREFIX_4B, 773 safe_browsing::ChunkData::PREFIX_4B,
773 NULL, 0, std::vector<int>())); 774 NULL, 0, std::vector<int>()));
774 chunks.push_back(BuildChunk(7, safe_browsing::ChunkData::SUB, 775 chunks.push_back(BuildChunk(7, safe_browsing::ChunkData::SUB,
775 safe_browsing::ChunkData::PREFIX_4B, 776 safe_browsing::ChunkData::PREFIX_4B,
776 NULL, 0, std::vector<int>())); 777 NULL, 0, std::vector<int>()));
777 778
778 ASSERT_TRUE(database_->UpdateStarted(&lists)); 779 ASSERT_TRUE(database_->UpdateStarted(&lists));
779 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 780 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
780 database_->UpdateFinished(true); 781 database_->UpdateFinished(true);
781 782
782 GetListsInfo(&lists); 783 GetListsInfo(&lists);
783 ASSERT_LE(1U, lists.size()); 784 ASSERT_LE(1U, lists.size());
784 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 785 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
785 EXPECT_EQ("1,10,19", lists[0].adds); 786 EXPECT_EQ("1,10,19", lists[0].adds);
786 EXPECT_EQ("7", lists[0].subs); 787 EXPECT_EQ("7", lists[0].subs);
787 788
788 // Add an empty chunk along with a couple that contain data. This should 789 // Add an empty chunk along with a couple that contain data. This should
789 // result in the chunk range being reduced in size. 790 // result in the chunk range being reduced in size.
790 chunks.clear(); 791 chunks.clear();
791 chunks.push_back(AddChunkPrefixValue(20, "www.notempty.com/full1.html")); 792 chunks.push_back(AddChunkPrefixValue(20, "www.notempty.com/full1.html"));
792 chunks.push_back(BuildChunk(21, safe_browsing::ChunkData::ADD, 793 chunks.push_back(BuildChunk(21, safe_browsing::ChunkData::ADD,
793 safe_browsing::ChunkData::PREFIX_4B, 794 safe_browsing::ChunkData::PREFIX_4B,
794 NULL, 0, std::vector<int>())); 795 NULL, 0, std::vector<int>()));
795 chunks.push_back(AddChunkPrefixValue(22, "www.notempty.com/full2.html")); 796 chunks.push_back(AddChunkPrefixValue(22, "www.notempty.com/full2.html"));
796 797
797 ASSERT_TRUE(database_->UpdateStarted(&lists)); 798 ASSERT_TRUE(database_->UpdateStarted(&lists));
798 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 799 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
799 database_->UpdateFinished(true); 800 database_->UpdateFinished(true);
800 801
801 std::vector<SBPrefix> prefix_hits; 802 std::vector<SBPrefix> prefix_hits;
802 std::vector<SBFullHashResult> cache_hits; 803 std::vector<SBFullHashResult> cache_hits;
803 EXPECT_TRUE(database_->ContainsBrowseUrl( 804 EXPECT_TRUE(database_->ContainsBrowseUrl(
804 GURL("http://www.notempty.com/full1.html"), &prefix_hits, &cache_hits)); 805 GURL("http://www.notempty.com/full1.html"), &prefix_hits, &cache_hits));
805 EXPECT_TRUE(database_->ContainsBrowseUrl( 806 EXPECT_TRUE(database_->ContainsBrowseUrl(
806 GURL("http://www.notempty.com/full2.html"), &prefix_hits, &cache_hits)); 807 GURL("http://www.notempty.com/full2.html"), &prefix_hits, &cache_hits));
807 808
808 GetListsInfo(&lists); 809 GetListsInfo(&lists);
809 ASSERT_LE(1U, lists.size()); 810 ASSERT_LE(1U, lists.size());
810 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 811 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
811 EXPECT_EQ("1,10,19-22", lists[0].adds); 812 EXPECT_EQ("1,10,19-22", lists[0].adds);
812 EXPECT_EQ("7", lists[0].subs); 813 EXPECT_EQ("7", lists[0].subs);
813 814
814 // Handle AddDel and SubDel commands for empty chunks. 815 // Handle AddDel and SubDel commands for empty chunks.
815 ASSERT_TRUE(database_->UpdateStarted(&lists)); 816 ASSERT_TRUE(database_->UpdateStarted(&lists));
816 AddDelChunk(safe_browsing_util::kMalwareList, 21); 817 AddDelChunk(safe_browsing::kMalwareList, 21);
817 database_->UpdateFinished(true); 818 database_->UpdateFinished(true);
818 819
819 GetListsInfo(&lists); 820 GetListsInfo(&lists);
820 ASSERT_LE(1U, lists.size()); 821 ASSERT_LE(1U, lists.size());
821 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 822 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
822 EXPECT_EQ("1,10,19-20,22", lists[0].adds); 823 EXPECT_EQ("1,10,19-20,22", lists[0].adds);
823 EXPECT_EQ("7", lists[0].subs); 824 EXPECT_EQ("7", lists[0].subs);
824 825
825 ASSERT_TRUE(database_->UpdateStarted(&lists)); 826 ASSERT_TRUE(database_->UpdateStarted(&lists));
826 SubDelChunk(safe_browsing_util::kMalwareList, 7); 827 SubDelChunk(safe_browsing::kMalwareList, 7);
827 database_->UpdateFinished(true); 828 database_->UpdateFinished(true);
828 829
829 GetListsInfo(&lists); 830 GetListsInfo(&lists);
830 ASSERT_LE(1U, lists.size()); 831 ASSERT_LE(1U, lists.size());
831 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 832 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
832 EXPECT_EQ("1,10,19-20,22", lists[0].adds); 833 EXPECT_EQ("1,10,19-20,22", lists[0].adds);
833 EXPECT_TRUE(lists[0].subs.empty()); 834 EXPECT_TRUE(lists[0].subs.empty());
834 } 835 }
835 836
836 // Utility function for setting up the database for the caching test. 837 // Utility function for setting up the database for the caching test.
837 void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() { 838 void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() {
838 // Add a couple prefixes. 839 // Add a couple prefixes.
839 ScopedVector<SBChunkData> chunks; 840 ScopedVector<SBChunkData> chunks;
840 chunks.push_back(AddChunkPrefix2Value(1, 841 chunks.push_back(AddChunkPrefix2Value(1,
841 "www.evil.com/phishing.html", 842 "www.evil.com/phishing.html",
842 "www.evil.com/malware.html")); 843 "www.evil.com/malware.html"));
843 844
844 std::vector<SBListChunkRanges> lists; 845 std::vector<SBListChunkRanges> lists;
845 ASSERT_TRUE(database_->UpdateStarted(&lists)); 846 ASSERT_TRUE(database_->UpdateStarted(&lists));
846 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 847 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
847 database_->UpdateFinished(true); 848 database_->UpdateFinished(true);
848 849
849 // Cache should be cleared after updating. 850 // Cache should be cleared after updating.
850 EXPECT_TRUE( 851 EXPECT_TRUE(
851 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); 852 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
852 853
853 SBFullHashResult full_hash; 854 SBFullHashResult full_hash;
854 full_hash.list_id = safe_browsing_util::MALWARE; 855 full_hash.list_id = safe_browsing::MALWARE;
855 856
856 std::vector<SBFullHashResult> results; 857 std::vector<SBFullHashResult> results;
857 std::vector<SBPrefix> prefixes; 858 std::vector<SBPrefix> prefixes;
858 859
859 // Add a fullhash result for each prefix. 860 // Add a fullhash result for each prefix.
860 full_hash.hash = SBFullHashForString("www.evil.com/phishing.html"); 861 full_hash.hash =
862 safe_browsing::SBFullHashForString("www.evil.com/phishing.html");
861 results.push_back(full_hash); 863 results.push_back(full_hash);
862 prefixes.push_back(full_hash.hash.prefix); 864 prefixes.push_back(full_hash.hash.prefix);
863 865
864 full_hash.hash = SBFullHashForString("www.evil.com/malware.html"); 866 full_hash.hash =
867 safe_browsing::SBFullHashForString("www.evil.com/malware.html");
865 results.push_back(full_hash); 868 results.push_back(full_hash);
866 prefixes.push_back(full_hash.hash.prefix); 869 prefixes.push_back(full_hash.hash.prefix);
867 870
868 database_->CacheHashResults(prefixes, results, kCacheLifetime); 871 database_->CacheHashResults(prefixes, results, kCacheLifetime);
869 } 872 }
870 873
871 TEST_F(SafeBrowsingDatabaseTest, HashCaching) { 874 TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
872 PopulateDatabaseForCacheTest(); 875 PopulateDatabaseForCacheTest();
873 876
874 // We should have both full hashes in the cache. 877 // We should have both full hashes in the cache.
875 EXPECT_EQ(2U, 878 EXPECT_EQ(2U,
876 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->size()); 879 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->size());
877 880
878 // Test the cache lookup for the first prefix. 881 // Test the cache lookup for the first prefix.
879 std::vector<SBPrefix> prefix_hits; 882 std::vector<SBPrefix> prefix_hits;
880 std::vector<SBFullHashResult> cache_hits; 883 std::vector<SBFullHashResult> cache_hits;
881 EXPECT_TRUE(database_->ContainsBrowseUrl( 884 EXPECT_TRUE(database_->ContainsBrowseUrl(
882 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 885 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
883 EXPECT_TRUE(prefix_hits.empty()); 886 EXPECT_TRUE(prefix_hits.empty());
884 ASSERT_EQ(1U, cache_hits.size()); 887 ASSERT_EQ(1U, cache_hits.size());
885 EXPECT_TRUE(SBFullHashEqual( 888 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
886 cache_hits[0].hash, SBFullHashForString("www.evil.com/phishing.html"))); 889 cache_hits[0].hash,
890 safe_browsing::SBFullHashForString("www.evil.com/phishing.html")));
887 891
888 prefix_hits.clear(); 892 prefix_hits.clear();
889 cache_hits.clear(); 893 cache_hits.clear();
890 894
891 // Test the cache lookup for the second prefix. 895 // Test the cache lookup for the second prefix.
892 EXPECT_TRUE(database_->ContainsBrowseUrl( 896 EXPECT_TRUE(database_->ContainsBrowseUrl(
893 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 897 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
894 EXPECT_TRUE(prefix_hits.empty()); 898 EXPECT_TRUE(prefix_hits.empty());
895 ASSERT_EQ(1U, cache_hits.size()); 899 ASSERT_EQ(1U, cache_hits.size());
896 EXPECT_TRUE(SBFullHashEqual( 900 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
897 cache_hits[0].hash, SBFullHashForString("www.evil.com/malware.html"))); 901 cache_hits[0].hash,
902 safe_browsing::SBFullHashForString("www.evil.com/malware.html")));
898 903
899 prefix_hits.clear(); 904 prefix_hits.clear();
900 cache_hits.clear(); 905 cache_hits.clear();
901 906
902 // Test removing a prefix via a sub chunk. 907 // Test removing a prefix via a sub chunk.
903 ScopedVector<SBChunkData> chunks; 908 ScopedVector<SBChunkData> chunks;
904 chunks.push_back(SubChunkPrefixValue(2, "www.evil.com/phishing.html", 1)); 909 chunks.push_back(SubChunkPrefixValue(2, "www.evil.com/phishing.html", 1));
905 910
906 std::vector<SBListChunkRanges> lists; 911 std::vector<SBListChunkRanges> lists;
907 ASSERT_TRUE(database_->UpdateStarted(&lists)); 912 ASSERT_TRUE(database_->UpdateStarted(&lists));
908 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 913 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
909 database_->UpdateFinished(true); 914 database_->UpdateFinished(true);
910 915
911 // This prefix should still be there, but cached fullhash should be gone. 916 // This prefix should still be there, but cached fullhash should be gone.
912 EXPECT_TRUE(database_->ContainsBrowseUrl( 917 EXPECT_TRUE(database_->ContainsBrowseUrl(
913 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 918 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
914 ASSERT_EQ(1U, prefix_hits.size()); 919 ASSERT_EQ(1U, prefix_hits.size());
915 EXPECT_EQ(SBPrefixForString("www.evil.com/malware.html"), prefix_hits[0]); 920 EXPECT_EQ(SBPrefixForString("www.evil.com/malware.html"), prefix_hits[0]);
916 EXPECT_TRUE(cache_hits.empty()); 921 EXPECT_TRUE(cache_hits.empty());
917 prefix_hits.clear(); 922 prefix_hits.clear();
918 cache_hits.clear(); 923 cache_hits.clear();
919 924
920 // This prefix should be gone. 925 // This prefix should be gone.
921 EXPECT_FALSE(database_->ContainsBrowseUrl( 926 EXPECT_FALSE(database_->ContainsBrowseUrl(
922 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 927 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
923 prefix_hits.clear(); 928 prefix_hits.clear();
924 cache_hits.clear(); 929 cache_hits.clear();
925 930
926 // Test that an AddDel for the original chunk removes the last cached entry. 931 // Test that an AddDel for the original chunk removes the last cached entry.
927 ASSERT_TRUE(database_->UpdateStarted(&lists)); 932 ASSERT_TRUE(database_->UpdateStarted(&lists));
928 AddDelChunk(safe_browsing_util::kMalwareList, 1); 933 AddDelChunk(safe_browsing::kMalwareList, 1);
929 database_->UpdateFinished(true); 934 database_->UpdateFinished(true);
930 EXPECT_FALSE(database_->ContainsBrowseUrl( 935 EXPECT_FALSE(database_->ContainsBrowseUrl(
931 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 936 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
932 EXPECT_TRUE( 937 EXPECT_TRUE(
933 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); 938 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
934 prefix_hits.clear(); 939 prefix_hits.clear();
935 cache_hits.clear(); 940 cache_hits.clear();
936 941
937 // Test that the cache won't return expired values. First we have to adjust 942 // Test that the cache won't return expired values. First we have to adjust
938 // the cached entries' received time to make them older, since the database 943 // the cached entries' received time to make them older, since the database
(...skipping 21 matching lines...) Expand all
960 // This entry should still exist. 965 // This entry should still exist.
961 EXPECT_TRUE(database_->ContainsBrowseUrl( 966 EXPECT_TRUE(database_->ContainsBrowseUrl(
962 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 967 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
963 EXPECT_TRUE(prefix_hits.empty()); 968 EXPECT_TRUE(prefix_hits.empty());
964 EXPECT_EQ(1U, cache_hits.size()); 969 EXPECT_EQ(1U, cache_hits.size());
965 970
966 // Testing prefix miss caching. First, we clear out the existing database, 971 // Testing prefix miss caching. First, we clear out the existing database,
967 // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate 972 // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate
968 // chunks. 973 // chunks.
969 ASSERT_TRUE(database_->UpdateStarted(&lists)); 974 ASSERT_TRUE(database_->UpdateStarted(&lists));
970 AddDelChunk(safe_browsing_util::kMalwareList, 1); 975 AddDelChunk(safe_browsing::kMalwareList, 1);
971 database_->UpdateFinished(true); 976 database_->UpdateFinished(true);
972 977
973 // Cache should be cleared after updating. 978 // Cache should be cleared after updating.
974 EXPECT_TRUE(hash_cache->empty()); 979 EXPECT_TRUE(hash_cache->empty());
975 980
976 std::vector<SBPrefix> prefix_misses; 981 std::vector<SBPrefix> prefix_misses;
977 std::vector<SBFullHashResult> empty_full_hash; 982 std::vector<SBFullHashResult> empty_full_hash;
978 prefix_misses.push_back(SBPrefixForString("http://www.bad.com/malware.html")); 983 prefix_misses.push_back(SBPrefixForString("http://www.bad.com/malware.html"));
979 prefix_misses.push_back( 984 prefix_misses.push_back(
980 SBPrefixForString("http://www.bad.com/phishing.html")); 985 SBPrefixForString("http://www.bad.com/phishing.html"));
(...skipping 28 matching lines...) Expand all
1009 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 1014 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
1010 prefix_hits.clear(); 1015 prefix_hits.clear();
1011 cache_hits.clear(); 1016 cache_hits.clear();
1012 1017
1013 // Test receiving a full add chunk. 1018 // Test receiving a full add chunk.
1014 chunks.clear(); 1019 chunks.clear();
1015 chunks.push_back(AddChunkFullHash2Value(20, 1020 chunks.push_back(AddChunkFullHash2Value(20,
1016 "www.fullevil.com/bad1.html", 1021 "www.fullevil.com/bad1.html",
1017 "www.fullevil.com/bad2.html")); 1022 "www.fullevil.com/bad2.html"));
1018 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1023 ASSERT_TRUE(database_->UpdateStarted(&lists));
1019 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1024 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1020 database_->UpdateFinished(true); 1025 database_->UpdateFinished(true);
1021 1026
1022 EXPECT_TRUE(database_->ContainsBrowseUrl( 1027 EXPECT_TRUE(database_->ContainsBrowseUrl(
1023 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); 1028 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits));
1024 ASSERT_EQ(1U, prefix_hits.size()); 1029 ASSERT_EQ(1U, prefix_hits.size());
1025 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad1.html"), prefix_hits[0]); 1030 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad1.html"), prefix_hits[0]);
1026 EXPECT_TRUE(cache_hits.empty()); 1031 EXPECT_TRUE(cache_hits.empty());
1027 prefix_hits.clear(); 1032 prefix_hits.clear();
1028 cache_hits.clear(); 1033 cache_hits.clear();
1029 1034
1030 EXPECT_TRUE(database_->ContainsBrowseUrl( 1035 EXPECT_TRUE(database_->ContainsBrowseUrl(
1031 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); 1036 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits));
1032 ASSERT_EQ(1U, prefix_hits.size()); 1037 ASSERT_EQ(1U, prefix_hits.size());
1033 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); 1038 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]);
1034 EXPECT_TRUE(cache_hits.empty()); 1039 EXPECT_TRUE(cache_hits.empty());
1035 prefix_hits.clear(); 1040 prefix_hits.clear();
1036 cache_hits.clear(); 1041 cache_hits.clear();
1037 1042
1038 // Test receiving a full sub chunk, which will remove one of the full adds. 1043 // Test receiving a full sub chunk, which will remove one of the full adds.
1039 chunks.clear(); 1044 chunks.clear();
1040 chunks.push_back(SubChunkFullHashValue(200, 1045 chunks.push_back(SubChunkFullHashValue(200,
1041 "www.fullevil.com/bad1.html", 1046 "www.fullevil.com/bad1.html",
1042 20)); 1047 20));
1043 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1048 ASSERT_TRUE(database_->UpdateStarted(&lists));
1044 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1049 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1045 database_->UpdateFinished(true); 1050 database_->UpdateFinished(true);
1046 1051
1047 EXPECT_FALSE(database_->ContainsBrowseUrl( 1052 EXPECT_FALSE(database_->ContainsBrowseUrl(
1048 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); 1053 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits));
1049 1054
1050 // There should be one remaining full add. 1055 // There should be one remaining full add.
1051 EXPECT_TRUE(database_->ContainsBrowseUrl( 1056 EXPECT_TRUE(database_->ContainsBrowseUrl(
1052 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); 1057 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits));
1053 ASSERT_EQ(1U, prefix_hits.size()); 1058 ASSERT_EQ(1U, prefix_hits.size());
1054 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); 1059 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]);
1055 EXPECT_TRUE(cache_hits.empty()); 1060 EXPECT_TRUE(cache_hits.empty());
1056 prefix_hits.clear(); 1061 prefix_hits.clear();
1057 cache_hits.clear(); 1062 cache_hits.clear();
1058 1063
1059 // Now test an AddDel for the remaining full add. 1064 // Now test an AddDel for the remaining full add.
1060 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1065 ASSERT_TRUE(database_->UpdateStarted(&lists));
1061 AddDelChunk(safe_browsing_util::kMalwareList, 20); 1066 AddDelChunk(safe_browsing::kMalwareList, 20);
1062 database_->UpdateFinished(true); 1067 database_->UpdateFinished(true);
1063 1068
1064 EXPECT_FALSE(database_->ContainsBrowseUrl( 1069 EXPECT_FALSE(database_->ContainsBrowseUrl(
1065 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); 1070 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits));
1066 EXPECT_FALSE(database_->ContainsBrowseUrl( 1071 EXPECT_FALSE(database_->ContainsBrowseUrl(
1067 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); 1072 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits));
1068 1073
1069 // Add a fullhash which has a prefix collision for a known url. 1074 // Add a fullhash which has a prefix collision for a known url.
1070 static const char kExampleFine[] = "www.example.com/fine.html"; 1075 static const char kExampleFine[] = "www.example.com/fine.html";
1071 static const char kExampleCollision[] = 1076 static const char kExampleCollision[] =
1072 "www.example.com/3123364814/malware.htm"; 1077 "www.example.com/3123364814/malware.htm";
1073 ASSERT_EQ(SBPrefixForString(kExampleFine), 1078 ASSERT_EQ(SBPrefixForString(kExampleFine),
1074 SBPrefixForString(kExampleCollision)); 1079 SBPrefixForString(kExampleCollision));
1075 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1080 ASSERT_TRUE(database_->UpdateStarted(&lists));
1076 { 1081 {
1077 ScopedVector<SBChunkData> chunks; 1082 ScopedVector<SBChunkData> chunks;
1078 chunks.push_back(AddChunkPrefixValue(21, kExampleCollision)); 1083 chunks.push_back(AddChunkPrefixValue(21, kExampleCollision));
1079 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1084 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1080 } 1085 }
1081 database_->UpdateFinished(true); 1086 database_->UpdateFinished(true);
1082 1087
1083 // Expect a prefix hit due to the collision between |kExampleFine| and 1088 // Expect a prefix hit due to the collision between |kExampleFine| and
1084 // |kExampleCollision|. 1089 // |kExampleCollision|.
1085 EXPECT_TRUE(database_->ContainsBrowseUrl( 1090 EXPECT_TRUE(database_->ContainsBrowseUrl(
1086 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); 1091 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
1087 ASSERT_EQ(1U, prefix_hits.size()); 1092 ASSERT_EQ(1U, prefix_hits.size());
1088 EXPECT_EQ(SBPrefixForString(kExampleFine), prefix_hits[0]); 1093 EXPECT_EQ(SBPrefixForString(kExampleFine), prefix_hits[0]);
1089 EXPECT_TRUE(cache_hits.empty()); 1094 EXPECT_TRUE(cache_hits.empty());
1090 1095
1091 // Cache gethash response for |kExampleCollision|. 1096 // Cache gethash response for |kExampleCollision|.
1092 { 1097 {
1093 SBFullHashResult result; 1098 SBFullHashResult result;
1094 result.hash = SBFullHashForString(kExampleCollision); 1099 result.hash = safe_browsing::SBFullHashForString(kExampleCollision);
1095 result.list_id = safe_browsing_util::MALWARE; 1100 result.list_id = safe_browsing::MALWARE;
1096 database_->CacheHashResults(std::vector<SBPrefix>(1, result.hash.prefix), 1101 database_->CacheHashResults(std::vector<SBPrefix>(1, result.hash.prefix),
1097 std::vector<SBFullHashResult>(1, result), 1102 std::vector<SBFullHashResult>(1, result),
1098 kCacheLifetime); 1103 kCacheLifetime);
1099 } 1104 }
1100 1105
1101 // The cached response means the collision no longer causes a hit. 1106 // The cached response means the collision no longer causes a hit.
1102 EXPECT_FALSE(database_->ContainsBrowseUrl( 1107 EXPECT_FALSE(database_->ContainsBrowseUrl(
1103 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); 1108 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
1104 } 1109 }
1105 1110
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
1138 fputc('!', fp); 1143 fputc('!', fp);
1139 } 1144 }
1140 fclose(fp); 1145 fclose(fp);
1141 1146
1142 { 1147 {
1143 // The following code will cause DCHECKs, so suppress the crashes. 1148 // The following code will cause DCHECKs, so suppress the crashes.
1144 ScopedLogMessageIgnorer ignorer; 1149 ScopedLogMessageIgnorer ignorer;
1145 1150
1146 // Start an update. The insert will fail due to corruption. 1151 // Start an update. The insert will fail due to corruption.
1147 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1152 ASSERT_TRUE(database_->UpdateStarted(&lists));
1148 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1153 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1149 database_->UpdateFinished(true); 1154 database_->UpdateFinished(true);
1150 1155
1151 // Database file still exists until the corruption handler has run. 1156 // Database file still exists until the corruption handler has run.
1152 EXPECT_TRUE(base::PathExists(database_filename_)); 1157 EXPECT_TRUE(base::PathExists(database_filename_));
1153 1158
1154 // Flush through the corruption-handler task. 1159 // Flush through the corruption-handler task.
1155 DVLOG(1) << "Expect failed check on: SafeBrowsing database reset"; 1160 DVLOG(1) << "Expect failed check on: SafeBrowsing database reset";
1156 base::MessageLoop::current()->RunUntilIdle(); 1161 base::MessageLoop::current()->RunUntilIdle();
1157 } 1162 }
1158 1163
1159 // Database file should not exist. 1164 // Database file should not exist.
1160 EXPECT_FALSE(base::PathExists(database_filename_)); 1165 EXPECT_FALSE(base::PathExists(database_filename_));
1161 1166
1162 // Run the update again successfully. 1167 // Run the update again successfully.
1163 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1168 ASSERT_TRUE(database_->UpdateStarted(&lists));
1164 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1169 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1165 database_->UpdateFinished(true); 1170 database_->UpdateFinished(true);
1166 EXPECT_TRUE(base::PathExists(database_filename_)); 1171 EXPECT_TRUE(base::PathExists(database_filename_));
1167 1172
1168 database_.reset(); 1173 database_.reset();
1169 } 1174 }
1170 1175
1171 // Checks database reading and writing. 1176 // Checks database reading and writing.
1172 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrlPrefixes) { 1177 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrlPrefixes) {
1173 const char kEvil1Url1[] = "www.evil1.com/download1/"; 1178 const char kEvil1Url1[] = "www.evil1.com/download1/";
1174 const char kEvil1Url2[] = "www.evil1.com/download2.html"; 1179 const char kEvil1Url2[] = "www.evil1.com/download2.html";
1175 1180
1176 // Add a simple chunk with one hostkey for download url list. 1181 // Add a simple chunk with one hostkey for download url list.
1177 ScopedVector<SBChunkData> chunks; 1182 ScopedVector<SBChunkData> chunks;
1178 chunks.push_back(AddChunkPrefix2Value(1, kEvil1Url1, kEvil1Url2)); 1183 chunks.push_back(AddChunkPrefix2Value(1, kEvil1Url1, kEvil1Url2));
1179 1184
1180 std::vector<SBListChunkRanges> lists; 1185 std::vector<SBListChunkRanges> lists;
1181 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1186 ASSERT_TRUE(database_->UpdateStarted(&lists));
1182 database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get()); 1187 database_->InsertChunks(safe_browsing::kBinUrlList, chunks.get());
1183 database_->UpdateFinished(true); 1188 database_->UpdateFinished(true);
1184 1189
1185 std::vector<SBPrefix> prefix_hits; 1190 std::vector<SBPrefix> prefix_hits;
1186 std::vector<GURL> urls(1); 1191 std::vector<GURL> urls(1);
1187 1192
1188 urls[0] = GURL(std::string("http://") + kEvil1Url1); 1193 urls[0] = GURL(std::string("http://") + kEvil1Url1);
1189 EXPECT_TRUE(ContainsDownloadUrl(urls, &prefix_hits)); 1194 EXPECT_TRUE(ContainsDownloadUrl(urls, &prefix_hits));
1190 ASSERT_EQ(1U, prefix_hits.size()); 1195 ASSERT_EQ(1U, prefix_hits.size());
1191 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); 1196 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]);
1192 1197
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after
1269 bool TestStrings() const { 1274 bool TestStrings() const {
1270 return test_list_contains_whitelisted_string != nullptr; 1275 return test_list_contains_whitelisted_string != nullptr;
1271 } 1276 }
1272 1277
1273 const char* test_list_name; 1278 const char* test_list_name;
1274 TestListContainsWhitelistedUrl test_list_contains_whitelisted_url; 1279 TestListContainsWhitelistedUrl test_list_contains_whitelisted_url;
1275 // Optional test case field, if set the tested whitelist will also be tested 1280 // Optional test case field, if set the tested whitelist will also be tested
1276 // for strings. 1281 // for strings.
1277 TestListContainsWhitelistedString test_list_contains_whitelisted_string; 1282 TestListContainsWhitelistedString test_list_contains_whitelisted_string;
1278 } const kTestCases[]{ 1283 } const kTestCases[]{
1279 {safe_browsing_util::kCsdWhiteList, 1284 {safe_browsing::kCsdWhiteList,
1280 &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl, 1285 &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl,
1281 nullptr}, 1286 nullptr},
1282 {safe_browsing_util::kDownloadWhiteList, 1287 {safe_browsing::kDownloadWhiteList,
1283 &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl, 1288 &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl,
1284 &SafeBrowsingDatabase::ContainsDownloadWhitelistedString}, 1289 &SafeBrowsingDatabase::ContainsDownloadWhitelistedString},
1285 {safe_browsing_util::kInclusionWhitelist, 1290 {safe_browsing::kInclusionWhitelist,
1286 &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl, 1291 &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl,
1287 nullptr}, 1292 nullptr},
1288 }; 1293 };
1289 1294
1290 // If the whitelist is disabled everything should match the whitelist. 1295 // If the whitelist is disabled everything should match the whitelist.
1291 database_.reset(new SafeBrowsingDatabaseNew( 1296 database_.reset(new SafeBrowsingDatabaseNew(
1292 task_runner_, new SafeBrowsingStoreFile(task_runner_), NULL, NULL, NULL, 1297 task_runner_, new SafeBrowsingStoreFile(task_runner_), NULL, NULL, NULL,
1293 NULL, NULL, NULL, NULL)); 1298 NULL, NULL, NULL, NULL));
1294 database_->Init(database_filename_); 1299 database_->Init(database_filename_);
1295 for (const auto& test_case : kTestCases) { 1300 for (const auto& test_case : kTestCases) {
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after
1410 EXPECT_TRUE( 1415 EXPECT_TRUE(
1411 (database_.get()->*test_case.test_list_contains_whitelisted_string)( 1416 (database_.get()->*test_case.test_list_contains_whitelisted_string)(
1412 kGoodString)); 1417 kGoodString));
1413 } 1418 }
1414 1419
1415 EXPECT_FALSE( 1420 EXPECT_FALSE(
1416 (database_.get()->*test_case.test_list_contains_whitelisted_url)( 1421 (database_.get()->*test_case.test_list_contains_whitelisted_url)(
1417 GURL(std::string("http://www.google.com/")))); 1422 GURL(std::string("http://www.google.com/"))));
1418 1423
1419 // The malware kill switch is for the CSD whitelist only. 1424 // The malware kill switch is for the CSD whitelist only.
1420 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { 1425 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
1421 // The CSD whitelist killswitch is not present. 1426 // The CSD whitelist killswitch is not present.
1422 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); 1427 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
1423 1428
1424 // Test only add the malware IP killswitch 1429 // Test only add the malware IP killswitch
1425 chunks.clear(); 1430 chunks.clear();
1426 chunks.push_back(AddChunkFullHashValue( 1431 chunks.push_back(AddChunkFullHashValue(
1427 15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware")); 1432 15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware"));
1428 1433
1429 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1434 ASSERT_TRUE(database_->UpdateStarted(&lists));
1430 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get()); 1435 database_->InsertChunks(safe_browsing::kCsdWhiteList, chunks.get());
1431 database_->UpdateFinished(true); 1436 database_->UpdateFinished(true);
1432 1437
1433 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); 1438 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
1434 // The CSD whitelist killswitch is not present. 1439 // The CSD whitelist killswitch is not present.
1435 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); 1440 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
1436 } 1441 }
1437 1442
1438 // Test that the generic whitelist kill-switch works as intended. 1443 // Test that the generic whitelist kill-switch works as intended.
1439 chunks.clear(); 1444 chunks.clear();
1440 lists.clear(); 1445 lists.clear();
1441 chunks.push_back(AddChunkFullHashValue( 1446 chunks.push_back(AddChunkFullHashValue(
1442 5, "sb-ssl.google.com/safebrowsing/csd/killswitch")); 1447 5, "sb-ssl.google.com/safebrowsing/csd/killswitch"));
1443 1448
1444 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1449 ASSERT_TRUE(database_->UpdateStarted(&lists));
1445 database_->InsertChunks(test_case.test_list_name, chunks.get()); 1450 database_->InsertChunks(test_case.test_list_name, chunks.get());
1446 database_->UpdateFinished(true); 1451 database_->UpdateFinished(true);
1447 1452
1448 // Test CSD whitelist specific methods. 1453 // Test CSD whitelist specific methods.
1449 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { 1454 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
1450 // The CSD whitelist killswitch is present. 1455 // The CSD whitelist killswitch is present.
1451 EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn()); 1456 EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn());
1452 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); 1457 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
1453 } 1458 }
1454 1459
1455 EXPECT_TRUE( 1460 EXPECT_TRUE(
1456 (database_.get()->*test_case.test_list_contains_whitelisted_url)( 1461 (database_.get()->*test_case.test_list_contains_whitelisted_url)(
1457 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); 1462 GURL(std::string("https://") + kGood1Url2 + "/c.html")));
1458 EXPECT_TRUE( 1463 EXPECT_TRUE(
1459 (database_.get()->*test_case.test_list_contains_whitelisted_url)( 1464 (database_.get()->*test_case.test_list_contains_whitelisted_url)(
1460 GURL(std::string("http://www.google.com/")))); 1465 GURL(std::string("http://www.google.com/"))));
1461 EXPECT_TRUE( 1466 EXPECT_TRUE(
1462 (database_.get()->*test_case.test_list_contains_whitelisted_url)( 1467 (database_.get()->*test_case.test_list_contains_whitelisted_url)(
1463 GURL(std::string("http://www.phishing_url.com/")))); 1468 GURL(std::string("http://www.phishing_url.com/"))));
1464 1469
1465 if (test_case.TestStrings()) { 1470 if (test_case.TestStrings()) {
1466 EXPECT_TRUE( 1471 EXPECT_TRUE(
1467 (database_.get()->*test_case.test_list_contains_whitelisted_string)( 1472 (database_.get()->*test_case.test_list_contains_whitelisted_string)(
1468 "asdf")); 1473 "asdf"));
1469 EXPECT_TRUE( 1474 EXPECT_TRUE(
1470 (database_.get()->*test_case.test_list_contains_whitelisted_string)( 1475 (database_.get()->*test_case.test_list_contains_whitelisted_string)(
1471 kGoodString)); 1476 kGoodString));
1472 } 1477 }
1473 1478
1474 // Remove the kill-switch and verify that we can recover. 1479 // Remove the kill-switch and verify that we can recover.
1475 chunks.clear(); 1480 chunks.clear();
1476 lists.clear(); 1481 lists.clear();
1477 chunks.push_back(SubChunkFullHashValue( 1482 chunks.push_back(SubChunkFullHashValue(
1478 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5)); 1483 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5));
1479 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { 1484 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
1480 chunks.push_back(SubChunkFullHashValue( 1485 chunks.push_back(SubChunkFullHashValue(
1481 10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15)); 1486 10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15));
1482 } 1487 }
1483 1488
1484 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1489 ASSERT_TRUE(database_->UpdateStarted(&lists));
1485 database_->InsertChunks(test_case.test_list_name, chunks.get()); 1490 database_->InsertChunks(test_case.test_list_name, chunks.get());
1486 database_->UpdateFinished(true); 1491 database_->UpdateFinished(true);
1487 1492
1488 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { 1493 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
1489 EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn()); 1494 EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn());
1490 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); 1495 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
1491 } 1496 }
1492 EXPECT_TRUE( 1497 EXPECT_TRUE(
1493 (database_.get()->*test_case.test_list_contains_whitelisted_url)( 1498 (database_.get()->*test_case.test_list_contains_whitelisted_url)(
1494 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); 1499 GURL(std::string("https://") + kGood1Url2 + "/c.html")));
1495 EXPECT_TRUE( 1500 EXPECT_TRUE(
1496 (database_.get()->*test_case.test_list_contains_whitelisted_url)( 1501 (database_.get()->*test_case.test_list_contains_whitelisted_url)(
1497 GURL(std::string("https://") + kGood2Url1 + "/c/bla"))); 1502 GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
1498 EXPECT_TRUE( 1503 EXPECT_TRUE(
(...skipping 22 matching lines...) Expand all
1521 ScopedVector<SBChunkData> chunks; 1526 ScopedVector<SBChunkData> chunks;
1522 1527
1523 // Add a malware add chunk with two entries of the same host. 1528 // Add a malware add chunk with two entries of the same host.
1524 chunks.push_back(AddChunkPrefix2Value(1, 1529 chunks.push_back(AddChunkPrefix2Value(1,
1525 "www.evil.com/malware1.html", 1530 "www.evil.com/malware1.html",
1526 "www.evil.com/malware2.html")); 1531 "www.evil.com/malware2.html"));
1527 1532
1528 // Insert the testing chunks into database. 1533 // Insert the testing chunks into database.
1529 std::vector<SBListChunkRanges> lists; 1534 std::vector<SBListChunkRanges> lists;
1530 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1535 ASSERT_TRUE(database_->UpdateStarted(&lists));
1531 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1536 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1532 database_->UpdateFinished(true); 1537 database_->UpdateFinished(true);
1533 1538
1534 GetListsInfo(&lists); 1539 GetListsInfo(&lists);
1535 ASSERT_LE(1U, lists.size()); 1540 ASSERT_LE(1U, lists.size());
1536 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 1541 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
1537 EXPECT_EQ("1", lists[0].adds); 1542 EXPECT_EQ("1", lists[0].adds);
1538 EXPECT_TRUE(lists[0].subs.empty()); 1543 EXPECT_TRUE(lists[0].subs.empty());
1539 1544
1540 // Add a phishing add chunk with two entries of the same host. 1545 // Add a phishing add chunk with two entries of the same host.
1541 chunks.clear(); 1546 chunks.clear();
1542 chunks.push_back(AddChunkPrefix2Value(47, 1547 chunks.push_back(AddChunkPrefix2Value(47,
1543 "www.evil.com/phishing1.html", 1548 "www.evil.com/phishing1.html",
1544 "www.evil.com/phishing2.html")); 1549 "www.evil.com/phishing2.html"));
1545 1550
1546 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1551 ASSERT_TRUE(database_->UpdateStarted(&lists));
1547 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 1552 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
1548 database_->UpdateFinished(true); 1553 database_->UpdateFinished(true);
1549 1554
1550 GetListsInfo(&lists); 1555 GetListsInfo(&lists);
1551 ASSERT_LE(2U, lists.size()); 1556 ASSERT_LE(2U, lists.size());
1552 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 1557 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
1553 EXPECT_EQ("1", lists[0].adds); 1558 EXPECT_EQ("1", lists[0].adds);
1554 EXPECT_TRUE(lists[0].subs.empty()); 1559 EXPECT_TRUE(lists[0].subs.empty());
1555 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 1560 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
1556 EXPECT_EQ("47", lists[1].adds); 1561 EXPECT_EQ("47", lists[1].adds);
1557 EXPECT_TRUE(lists[1].subs.empty()); 1562 EXPECT_TRUE(lists[1].subs.empty());
1558 1563
1559 std::vector<SBPrefix> prefix_hits; 1564 std::vector<SBPrefix> prefix_hits;
1560 std::vector<SBFullHashResult> cache_hits; 1565 std::vector<SBFullHashResult> cache_hits;
1561 1566
1562 EXPECT_TRUE(database_->ContainsBrowseUrl( 1567 EXPECT_TRUE(database_->ContainsBrowseUrl(
1563 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); 1568 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits));
1564 EXPECT_TRUE(database_->ContainsBrowseUrl( 1569 EXPECT_TRUE(database_->ContainsBrowseUrl(
1565 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); 1570 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits));
1566 EXPECT_TRUE(database_->ContainsBrowseUrl( 1571 EXPECT_TRUE(database_->ContainsBrowseUrl(
1567 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); 1572 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits));
1568 EXPECT_TRUE(database_->ContainsBrowseUrl( 1573 EXPECT_TRUE(database_->ContainsBrowseUrl(
1569 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); 1574 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits));
1570 1575
1571 // Test removing a single prefix from the add chunk. 1576 // Test removing a single prefix from the add chunk.
1572 // Remove the prefix that added first. 1577 // Remove the prefix that added first.
1573 chunks.clear(); 1578 chunks.clear();
1574 chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/malware1.html", 1)); 1579 chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/malware1.html", 1));
1575 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1580 ASSERT_TRUE(database_->UpdateStarted(&lists));
1576 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1581 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1577 database_->UpdateFinished(true); 1582 database_->UpdateFinished(true);
1578 1583
1579 // Remove the prefix that added last. 1584 // Remove the prefix that added last.
1580 chunks.clear(); 1585 chunks.clear();
1581 chunks.push_back(SubChunkPrefixValue(5, "www.evil.com/phishing2.html", 47)); 1586 chunks.push_back(SubChunkPrefixValue(5, "www.evil.com/phishing2.html", 47));
1582 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1587 ASSERT_TRUE(database_->UpdateStarted(&lists));
1583 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 1588 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
1584 database_->UpdateFinished(true); 1589 database_->UpdateFinished(true);
1585 1590
1586 // Verify that the database contains urls expected. 1591 // Verify that the database contains urls expected.
1587 EXPECT_FALSE(database_->ContainsBrowseUrl( 1592 EXPECT_FALSE(database_->ContainsBrowseUrl(
1588 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); 1593 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits));
1589 EXPECT_TRUE(database_->ContainsBrowseUrl( 1594 EXPECT_TRUE(database_->ContainsBrowseUrl(
1590 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); 1595 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits));
1591 EXPECT_TRUE(database_->ContainsBrowseUrl( 1596 EXPECT_TRUE(database_->ContainsBrowseUrl(
1592 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); 1597 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits));
1593 EXPECT_FALSE(database_->ContainsBrowseUrl( 1598 EXPECT_FALSE(database_->ContainsBrowseUrl(
1594 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); 1599 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits));
1595 } 1600 }
1596 1601
1597 // Test that an empty update doesn't actually update the database. 1602 // Test that an empty update doesn't actually update the database.
1598 // This isn't a functionality requirement, but it is a useful 1603 // This isn't a functionality requirement, but it is a useful
1599 // optimization. 1604 // optimization.
1600 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) { 1605 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) {
1601 ScopedVector<SBChunkData> chunks; 1606 ScopedVector<SBChunkData> chunks;
1602 1607
1603 base::FilePath filename = database_->BrowseDBFilename(database_filename_); 1608 base::FilePath filename = database_->BrowseDBFilename(database_filename_);
1604 1609
1605 // Prime the database. 1610 // Prime the database.
1606 std::vector<SBListChunkRanges> lists; 1611 std::vector<SBListChunkRanges> lists;
1607 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1612 ASSERT_TRUE(database_->UpdateStarted(&lists));
1608 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 1613 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
1609 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1614 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1610 database_->UpdateFinished(true); 1615 database_->UpdateFinished(true);
1611 1616
1612 // Get an older time to reset the lastmod time for detecting whether 1617 // Get an older time to reset the lastmod time for detecting whether
1613 // the file has been updated. 1618 // the file has been updated.
1614 base::File::Info before_info, after_info; 1619 base::File::Info before_info, after_info;
1615 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1620 ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
1616 const Time old_last_modified = 1621 const Time old_last_modified =
1617 before_info.last_modified - TimeDelta::FromSeconds(10); 1622 before_info.last_modified - TimeDelta::FromSeconds(10);
1618 1623
1619 // Inserting another chunk updates the database file. The sleep is 1624 // Inserting another chunk updates the database file. The sleep is
1620 // needed because otherwise the entire test can finish w/in the 1625 // needed because otherwise the entire test can finish w/in the
1621 // resolution of the lastmod time. 1626 // resolution of the lastmod time.
1622 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); 1627 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified));
1623 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1628 ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
1624 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1629 ASSERT_TRUE(database_->UpdateStarted(&lists));
1625 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); 1630 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
1626 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1631 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1627 database_->UpdateFinished(true); 1632 database_->UpdateFinished(true);
1628 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); 1633 ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
1629 EXPECT_LT(before_info.last_modified, after_info.last_modified); 1634 EXPECT_LT(before_info.last_modified, after_info.last_modified);
1630 1635
1631 // Deleting a chunk updates the database file. 1636 // Deleting a chunk updates the database file.
1632 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); 1637 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified));
1633 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1638 ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
1634 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1639 ASSERT_TRUE(database_->UpdateStarted(&lists));
1635 AddDelChunk(safe_browsing_util::kMalwareList, 2); 1640 AddDelChunk(safe_browsing::kMalwareList, 2);
1636 database_->UpdateFinished(true); 1641 database_->UpdateFinished(true);
1637 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); 1642 ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
1638 EXPECT_LT(before_info.last_modified, after_info.last_modified); 1643 EXPECT_LT(before_info.last_modified, after_info.last_modified);
1639 1644
1640 // Simply calling |UpdateStarted()| then |UpdateFinished()| does not 1645 // Simply calling |UpdateStarted()| then |UpdateFinished()| does not
1641 // update the database file. 1646 // update the database file.
1642 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); 1647 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified));
1643 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1648 ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
1644 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1649 ASSERT_TRUE(database_->UpdateStarted(&lists));
1645 database_->UpdateFinished(true); 1650 database_->UpdateFinished(true);
1646 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); 1651 ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
1647 EXPECT_EQ(before_info.last_modified, after_info.last_modified); 1652 EXPECT_EQ(before_info.last_modified, after_info.last_modified);
1648 } 1653 }
1649 1654
1650 // Test that a filter file is written out during update and read back 1655 // Test that a filter file is written out during update and read back
1651 // in during setup. 1656 // in during setup.
1652 TEST_F(SafeBrowsingDatabaseTest, FilterFile) { 1657 TEST_F(SafeBrowsingDatabaseTest, FilterFile) {
1653 // Create a database with trivial example data and write it out. 1658 // Create a database with trivial example data and write it out.
1654 { 1659 {
1655 // Prime the database. 1660 // Prime the database.
1656 std::vector<SBListChunkRanges> lists; 1661 std::vector<SBListChunkRanges> lists;
1657 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1662 ASSERT_TRUE(database_->UpdateStarted(&lists));
1658 1663
1659 ScopedVector<SBChunkData> chunks; 1664 ScopedVector<SBChunkData> chunks;
1660 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 1665 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
1661 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1666 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1662 database_->UpdateFinished(true); 1667 database_->UpdateFinished(true);
1663 } 1668 }
1664 1669
1665 // Find the malware url in the database, don't find a good url. 1670 // Find the malware url in the database, don't find a good url.
1666 std::vector<SBPrefix> prefix_hits; 1671 std::vector<SBPrefix> prefix_hits;
1667 std::vector<SBFullHashResult> cache_hits; 1672 std::vector<SBFullHashResult> cache_hits;
1668 EXPECT_TRUE(database_->ContainsBrowseUrl( 1673 EXPECT_TRUE(database_->ContainsBrowseUrl(
1669 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 1674 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
1670 EXPECT_FALSE(database_->ContainsBrowseUrl( 1675 EXPECT_FALSE(database_->ContainsBrowseUrl(
1671 GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits)); 1676 GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits));
(...skipping 29 matching lines...) Expand all
1701 const SBFullHash kFullHash2_1 = 1706 const SBFullHash kFullHash2_1 =
1702 SBFullHashForPrefixAndSuffix(kPrefix2, "\x01"); 1707 SBFullHashForPrefixAndSuffix(kPrefix2, "\x01");
1703 1708
1704 // Insert prefix kPrefix1 and kPrefix2 into database. 1709 // Insert prefix kPrefix1 and kPrefix2 into database.
1705 ScopedVector<SBChunkData> chunks; 1710 ScopedVector<SBChunkData> chunks;
1706 chunks.push_back(AddChunkPrefix(1, kPrefix1)); 1711 chunks.push_back(AddChunkPrefix(1, kPrefix1));
1707 chunks.push_back(AddChunkPrefix(2, kPrefix2)); 1712 chunks.push_back(AddChunkPrefix(2, kPrefix2));
1708 1713
1709 std::vector<SBListChunkRanges> lists; 1714 std::vector<SBListChunkRanges> lists;
1710 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1715 ASSERT_TRUE(database_->UpdateStarted(&lists));
1711 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1716 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1712 database_->UpdateFinished(true); 1717 database_->UpdateFinished(true);
1713 1718
1714 { 1719 {
1715 // Cache a full miss result for kPrefix1. 1720 // Cache a full miss result for kPrefix1.
1716 std::vector<SBPrefix> prefixes(1, kPrefix1); 1721 std::vector<SBPrefix> prefixes(1, kPrefix1);
1717 std::vector<SBFullHashResult> cache_results; 1722 std::vector<SBFullHashResult> cache_results;
1718 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); 1723 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime);
1719 } 1724 }
1720 1725
1721 { 1726 {
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
1756 const SBFullHash kFullHash3_1 = 1761 const SBFullHash kFullHash3_1 =
1757 SBFullHashForPrefixAndSuffix(kPrefix3, "\x01"); 1762 SBFullHashForPrefixAndSuffix(kPrefix3, "\x01");
1758 1763
1759 // Insert prefix kPrefix1 and kPrefix2 into database. 1764 // Insert prefix kPrefix1 and kPrefix2 into database.
1760 ScopedVector<SBChunkData> chunks; 1765 ScopedVector<SBChunkData> chunks;
1761 chunks.push_back(AddChunkPrefix(1, kPrefix1)); 1766 chunks.push_back(AddChunkPrefix(1, kPrefix1));
1762 chunks.push_back(AddChunkPrefix(2, kPrefix2)); 1767 chunks.push_back(AddChunkPrefix(2, kPrefix2));
1763 1768
1764 std::vector<SBListChunkRanges> lists; 1769 std::vector<SBListChunkRanges> lists;
1765 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1770 ASSERT_TRUE(database_->UpdateStarted(&lists));
1766 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1771 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1767 database_->UpdateFinished(true); 1772 database_->UpdateFinished(true);
1768 1773
1769 { 1774 {
1770 // kFullHash1_1 has a prefix hit of kPrefix1. 1775 // kFullHash1_1 has a prefix hit of kPrefix1.
1771 std::vector<SBFullHash> full_hashes; 1776 std::vector<SBFullHash> full_hashes;
1772 full_hashes.push_back(kFullHash1_1); 1777 full_hashes.push_back(kFullHash1_1);
1773 std::vector<SBPrefix> prefix_hits; 1778 std::vector<SBPrefix> prefix_hits;
1774 std::vector<SBFullHashResult> cache_hits; 1779 std::vector<SBFullHashResult> cache_hits;
1775 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 1780 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
1776 full_hashes, &prefix_hits, &cache_hits)); 1781 full_hashes, &prefix_hits, &cache_hits));
(...skipping 23 matching lines...) Expand all
1800 EXPECT_EQ(kPrefix2, prefix_hits[1]); 1805 EXPECT_EQ(kPrefix2, prefix_hits[1]);
1801 EXPECT_TRUE(cache_hits.empty()); 1806 EXPECT_TRUE(cache_hits.empty());
1802 } 1807 }
1803 1808
1804 { 1809 {
1805 // Cache a fullhash result for two kPrefix1 full hashes. 1810 // Cache a fullhash result for two kPrefix1 full hashes.
1806 std::vector<SBPrefix> prefixes(1, kPrefix1); 1811 std::vector<SBPrefix> prefixes(1, kPrefix1);
1807 std::vector<SBFullHashResult> cache_results; 1812 std::vector<SBFullHashResult> cache_results;
1808 1813
1809 SBFullHashResult full_hash_result; 1814 SBFullHashResult full_hash_result;
1810 full_hash_result.list_id = safe_browsing_util::MALWARE; 1815 full_hash_result.list_id = safe_browsing::MALWARE;
1811 1816
1812 full_hash_result.hash = kFullHash1_1; 1817 full_hash_result.hash = kFullHash1_1;
1813 cache_results.push_back(full_hash_result); 1818 cache_results.push_back(full_hash_result);
1814 1819
1815 full_hash_result.hash = kFullHash1_3; 1820 full_hash_result.hash = kFullHash1_3;
1816 cache_results.push_back(full_hash_result); 1821 cache_results.push_back(full_hash_result);
1817 1822
1818 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); 1823 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime);
1819 } 1824 }
1820 1825
1821 { 1826 {
1822 // kFullHash1_1 should now see a cache hit. 1827 // kFullHash1_1 should now see a cache hit.
1823 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); 1828 std::vector<SBFullHash> full_hashes(1, kFullHash1_1);
1824 std::vector<SBPrefix> prefix_hits; 1829 std::vector<SBPrefix> prefix_hits;
1825 std::vector<SBFullHashResult> cache_hits; 1830 std::vector<SBFullHashResult> cache_hits;
1826 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 1831 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
1827 full_hashes, &prefix_hits, &cache_hits)); 1832 full_hashes, &prefix_hits, &cache_hits));
1828 EXPECT_TRUE(prefix_hits.empty()); 1833 EXPECT_TRUE(prefix_hits.empty());
1829 ASSERT_EQ(1U, cache_hits.size()); 1834 ASSERT_EQ(1U, cache_hits.size());
1830 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); 1835 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
1836 kFullHash1_1, cache_hits[0].hash));
1831 1837
1832 // Adding kFullHash2_1 will see the existing cache hit plus the prefix hit 1838 // Adding kFullHash2_1 will see the existing cache hit plus the prefix hit
1833 // for kPrefix2. 1839 // for kPrefix2.
1834 full_hashes.push_back(kFullHash2_1); 1840 full_hashes.push_back(kFullHash2_1);
1835 prefix_hits.clear(); 1841 prefix_hits.clear();
1836 cache_hits.clear(); 1842 cache_hits.clear();
1837 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 1843 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
1838 full_hashes, &prefix_hits, &cache_hits)); 1844 full_hashes, &prefix_hits, &cache_hits));
1839 ASSERT_EQ(1U, prefix_hits.size()); 1845 ASSERT_EQ(1U, prefix_hits.size());
1840 EXPECT_EQ(kPrefix2, prefix_hits[0]); 1846 EXPECT_EQ(kPrefix2, prefix_hits[0]);
1841 ASSERT_EQ(1U, cache_hits.size()); 1847 ASSERT_EQ(1U, cache_hits.size());
1842 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); 1848 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
1849 kFullHash1_1, cache_hits[0].hash));
1843 1850
1844 // kFullHash1_3 also gets a cache hit. 1851 // kFullHash1_3 also gets a cache hit.
1845 full_hashes.push_back(kFullHash1_3); 1852 full_hashes.push_back(kFullHash1_3);
1846 prefix_hits.clear(); 1853 prefix_hits.clear();
1847 cache_hits.clear(); 1854 cache_hits.clear();
1848 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 1855 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
1849 full_hashes, &prefix_hits, &cache_hits)); 1856 full_hashes, &prefix_hits, &cache_hits));
1850 ASSERT_EQ(1U, prefix_hits.size()); 1857 ASSERT_EQ(1U, prefix_hits.size());
1851 EXPECT_EQ(kPrefix2, prefix_hits[0]); 1858 EXPECT_EQ(kPrefix2, prefix_hits[0]);
1852 ASSERT_EQ(2U, cache_hits.size()); 1859 ASSERT_EQ(2U, cache_hits.size());
1853 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); 1860 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
1854 EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[1].hash)); 1861 kFullHash1_1, cache_hits[0].hash));
1862 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
1863 kFullHash1_3, cache_hits[1].hash));
1855 } 1864 }
1856 1865
1857 { 1866 {
1858 // Check if DB contains only kFullHash1_3. Should return a cache hit. 1867 // Check if DB contains only kFullHash1_3. Should return a cache hit.
1859 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); 1868 std::vector<SBFullHash> full_hashes(1, kFullHash1_3);
1860 std::vector<SBPrefix> prefix_hits; 1869 std::vector<SBPrefix> prefix_hits;
1861 std::vector<SBFullHashResult> cache_hits; 1870 std::vector<SBFullHashResult> cache_hits;
1862 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 1871 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
1863 full_hashes, &prefix_hits, &cache_hits)); 1872 full_hashes, &prefix_hits, &cache_hits));
1864 EXPECT_TRUE(prefix_hits.empty()); 1873 EXPECT_TRUE(prefix_hits.empty());
1865 ASSERT_EQ(1U, cache_hits.size()); 1874 ASSERT_EQ(1U, cache_hits.size());
1866 EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[0].hash)); 1875 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
1876 kFullHash1_3, cache_hits[0].hash));
1867 } 1877 }
1868 1878
1869 { 1879 {
1870 // kFullHash1_2 has no cache hit, and no prefix hit because of the cache for 1880 // kFullHash1_2 has no cache hit, and no prefix hit because of the cache for
1871 // kPrefix1. 1881 // kPrefix1.
1872 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 1882 std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
1873 std::vector<SBPrefix> prefix_hits; 1883 std::vector<SBPrefix> prefix_hits;
1874 std::vector<SBFullHashResult> cache_hits; 1884 std::vector<SBFullHashResult> cache_hits;
1875 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( 1885 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
1876 full_hashes, &prefix_hits, &cache_hits)); 1886 full_hashes, &prefix_hits, &cache_hits));
(...skipping 19 matching lines...) Expand all
1896 const SBFullHash kFullHash1_3 = 1906 const SBFullHash kFullHash1_3 =
1897 SBFullHashForPrefixAndSuffix(kPrefix1, "\x03"); 1907 SBFullHashForPrefixAndSuffix(kPrefix1, "\x03");
1898 1908
1899 // Insert two full hashes with a shared prefix. 1909 // Insert two full hashes with a shared prefix.
1900 ScopedVector<SBChunkData> chunks; 1910 ScopedVector<SBChunkData> chunks;
1901 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); 1911 chunks.push_back(AddChunkFullHash(1, kFullHash1_1));
1902 chunks.push_back(AddChunkFullHash(2, kFullHash1_2)); 1912 chunks.push_back(AddChunkFullHash(2, kFullHash1_2));
1903 1913
1904 std::vector<SBListChunkRanges> lists; 1914 std::vector<SBListChunkRanges> lists;
1905 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1915 ASSERT_TRUE(database_->UpdateStarted(&lists));
1906 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1916 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1907 database_->UpdateFinished(true); 1917 database_->UpdateFinished(true);
1908 1918
1909 { 1919 {
1910 // Check a full hash which isn't present. 1920 // Check a full hash which isn't present.
1911 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); 1921 std::vector<SBFullHash> full_hashes(1, kFullHash1_3);
1912 std::vector<SBPrefix> prefix_hits; 1922 std::vector<SBPrefix> prefix_hits;
1913 std::vector<SBFullHashResult> cache_hits; 1923 std::vector<SBFullHashResult> cache_hits;
1914 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( 1924 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
1915 full_hashes, &prefix_hits, &cache_hits)); 1925 full_hashes, &prefix_hits, &cache_hits));
1916 1926
(...skipping 14 matching lines...) Expand all
1931 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 1941 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
1932 full_hashes, &prefix_hits, &cache_hits)); 1942 full_hashes, &prefix_hits, &cache_hits));
1933 ASSERT_EQ(1U, prefix_hits.size()); 1943 ASSERT_EQ(1U, prefix_hits.size());
1934 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1944 EXPECT_EQ(kPrefix1, prefix_hits[0]);
1935 EXPECT_TRUE(cache_hits.empty()); 1945 EXPECT_TRUE(cache_hits.empty());
1936 } 1946 }
1937 1947
1938 { 1948 {
1939 // Cache a gethash result for kFullHash1_2. 1949 // Cache a gethash result for kFullHash1_2.
1940 SBFullHashResult full_hash_result; 1950 SBFullHashResult full_hash_result;
1941 full_hash_result.list_id = safe_browsing_util::MALWARE; 1951 full_hash_result.list_id = safe_browsing::MALWARE;
1942 full_hash_result.hash = kFullHash1_2; 1952 full_hash_result.hash = kFullHash1_2;
1943 1953
1944 std::vector<SBPrefix> prefixes(1, kPrefix1); 1954 std::vector<SBPrefix> prefixes(1, kPrefix1);
1945 std::vector<SBFullHashResult> cache_results(1, full_hash_result); 1955 std::vector<SBFullHashResult> cache_results(1, full_hash_result);
1946 1956
1947 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); 1957 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime);
1948 } 1958 }
1949 1959
1950 { 1960 {
1951 // kFullHash1_3 should still return false, because the cached 1961 // kFullHash1_3 should still return false, because the cached
(...skipping 13 matching lines...) Expand all
1965 full_hashes, &prefix_hits, &cache_hits)); 1975 full_hashes, &prefix_hits, &cache_hits));
1966 1976
1967 // kFullHash1_2 is in the cached result. 1977 // kFullHash1_2 is in the cached result.
1968 full_hashes.push_back(kFullHash1_2); 1978 full_hashes.push_back(kFullHash1_2);
1969 prefix_hits.clear(); 1979 prefix_hits.clear();
1970 cache_hits.clear(); 1980 cache_hits.clear();
1971 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 1981 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
1972 full_hashes, &prefix_hits, &cache_hits)); 1982 full_hashes, &prefix_hits, &cache_hits));
1973 EXPECT_TRUE(prefix_hits.empty()); 1983 EXPECT_TRUE(prefix_hits.empty());
1974 ASSERT_EQ(1U, cache_hits.size()); 1984 ASSERT_EQ(1U, cache_hits.size());
1975 EXPECT_TRUE(SBFullHashEqual(kFullHash1_2, cache_hits[0].hash)); 1985 EXPECT_TRUE(safe_browsing::SBFullHashEqual(
1986 kFullHash1_2, cache_hits[0].hash));
1976 } 1987 }
1977 1988
1978 // Remove kFullHash1_1 from the database. 1989 // Remove kFullHash1_1 from the database.
1979 chunks.clear(); 1990 chunks.clear();
1980 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); 1991 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1));
1981 1992
1982 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1993 ASSERT_TRUE(database_->UpdateStarted(&lists));
1983 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1994 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
1984 database_->UpdateFinished(true); 1995 database_->UpdateFinished(true);
1985 1996
1986 // Cache should be cleared after updating. 1997 // Cache should be cleared after updating.
1987 EXPECT_TRUE( 1998 EXPECT_TRUE(
1988 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); 1999 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
1989 2000
1990 { 2001 {
1991 // Now the database doesn't contain kFullHash1_1. 2002 // Now the database doesn't contain kFullHash1_1.
1992 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); 2003 std::vector<SBFullHash> full_hashes(1, kFullHash1_1);
1993 std::vector<SBPrefix> prefix_hits; 2004 std::vector<SBPrefix> prefix_hits;
(...skipping 17 matching lines...) Expand all
2011 ASSERT_EQ(1U, prefix_hits.size()); 2022 ASSERT_EQ(1U, prefix_hits.size());
2012 EXPECT_EQ(kPrefix1, prefix_hits[0]); 2023 EXPECT_EQ(kPrefix1, prefix_hits[0]);
2013 EXPECT_TRUE(cache_hits.empty()); 2024 EXPECT_TRUE(cache_hits.empty());
2014 } 2025 }
2015 2026
2016 // Remove kFullHash1_2 from the database. 2027 // Remove kFullHash1_2 from the database.
2017 chunks.clear(); 2028 chunks.clear();
2018 chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2)); 2029 chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2));
2019 2030
2020 ASSERT_TRUE(database_->UpdateStarted(&lists)); 2031 ASSERT_TRUE(database_->UpdateStarted(&lists));
2021 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2032 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
2022 database_->UpdateFinished(true); 2033 database_->UpdateFinished(true);
2023 2034
2024 // Cache should be cleared after updating. 2035 // Cache should be cleared after updating.
2025 EXPECT_TRUE( 2036 EXPECT_TRUE(
2026 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); 2037 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
2027 2038
2028 { 2039 {
2029 // None are present. 2040 // None are present.
2030 std::vector<SBFullHash> full_hashes; 2041 std::vector<SBFullHash> full_hashes;
2031 std::vector<SBPrefix> prefix_hits; 2042 std::vector<SBPrefix> prefix_hits;
(...skipping 11 matching lines...) Expand all
2043 const SBFullHash kFullHash1_1 = 2054 const SBFullHash kFullHash1_1 =
2044 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01"); 2055 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01");
2045 const SBFullHash kFullHash1_2 = 2056 const SBFullHash kFullHash1_2 =
2046 SBFullHashForPrefixAndSuffix(kPrefix1, "\x02"); 2057 SBFullHashForPrefixAndSuffix(kPrefix1, "\x02");
2047 2058
2048 ScopedVector<SBChunkData> chunks; 2059 ScopedVector<SBChunkData> chunks;
2049 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); 2060 chunks.push_back(AddChunkFullHash(1, kFullHash1_1));
2050 2061
2051 std::vector<SBListChunkRanges> lists; 2062 std::vector<SBListChunkRanges> lists;
2052 ASSERT_TRUE(database_->UpdateStarted(&lists)); 2063 ASSERT_TRUE(database_->UpdateStarted(&lists));
2053 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2064 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
2054 database_->UpdateFinished(true); 2065 database_->UpdateFinished(true);
2055 2066
2056 { 2067 {
2057 // kFullHash1_2 does not match kFullHash1_1. 2068 // kFullHash1_2 does not match kFullHash1_1.
2058 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 2069 std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
2059 std::vector<SBPrefix> prefix_hits; 2070 std::vector<SBPrefix> prefix_hits;
2060 std::vector<SBFullHashResult> cache_hits; 2071 std::vector<SBFullHashResult> cache_hits;
2061 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( 2072 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting(
2062 full_hashes, &prefix_hits, &cache_hits)); 2073 full_hashes, &prefix_hits, &cache_hits));
2063 } 2074 }
2064 2075
2065 // Add a prefix match. 2076 // Add a prefix match.
2066 chunks.clear(); 2077 chunks.clear();
2067 chunks.push_back(AddChunkPrefix(2, kPrefix1)); 2078 chunks.push_back(AddChunkPrefix(2, kPrefix1));
2068 2079
2069 ASSERT_TRUE(database_->UpdateStarted(&lists)); 2080 ASSERT_TRUE(database_->UpdateStarted(&lists));
2070 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2081 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
2071 database_->UpdateFinished(true); 2082 database_->UpdateFinished(true);
2072 2083
2073 { 2084 {
2074 // kFullHash1_2 does match kPrefix1. 2085 // kFullHash1_2 does match kPrefix1.
2075 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 2086 std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
2076 std::vector<SBPrefix> prefix_hits; 2087 std::vector<SBPrefix> prefix_hits;
2077 std::vector<SBFullHashResult> cache_hits; 2088 std::vector<SBFullHashResult> cache_hits;
2078 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 2089 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
2079 full_hashes, &prefix_hits, &cache_hits)); 2090 full_hashes, &prefix_hits, &cache_hits));
2080 ASSERT_EQ(1U, prefix_hits.size()); 2091 ASSERT_EQ(1U, prefix_hits.size());
2081 EXPECT_EQ(kPrefix1, prefix_hits[0]); 2092 EXPECT_EQ(kPrefix1, prefix_hits[0]);
2082 EXPECT_TRUE(cache_hits.empty()); 2093 EXPECT_TRUE(cache_hits.empty());
2083 } 2094 }
2084 2095
2085 // Remove the full hash. 2096 // Remove the full hash.
2086 chunks.clear(); 2097 chunks.clear();
2087 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); 2098 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1));
2088 2099
2089 ASSERT_TRUE(database_->UpdateStarted(&lists)); 2100 ASSERT_TRUE(database_->UpdateStarted(&lists));
2090 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2101 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
2091 database_->UpdateFinished(true); 2102 database_->UpdateFinished(true);
2092 2103
2093 { 2104 {
2094 // kFullHash1_2 still returns true due to the prefix hit. 2105 // kFullHash1_2 still returns true due to the prefix hit.
2095 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 2106 std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
2096 std::vector<SBPrefix> prefix_hits; 2107 std::vector<SBPrefix> prefix_hits;
2097 std::vector<SBFullHashResult> cache_hits; 2108 std::vector<SBFullHashResult> cache_hits;
2098 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( 2109 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting(
2099 full_hashes, &prefix_hits, &cache_hits)); 2110 full_hashes, &prefix_hits, &cache_hits));
2100 ASSERT_EQ(1U, prefix_hits.size()); 2111 ASSERT_EQ(1U, prefix_hits.size());
(...skipping 19 matching lines...) Expand all
2120 2131
2121 // IPv6 prefix match for: 2620:0:1000:3103::/64. 2132 // IPv6 prefix match for: 2620:0:1000:3103::/64.
2122 chunks.push_back(AddChunkHashedIpValue(4, "2620:0:1000:3103::", 64)); 2133 chunks.push_back(AddChunkHashedIpValue(4, "2620:0:1000:3103::", 64));
2123 2134
2124 // IPv4 prefix match for ::ffff:192.1.122.0/119. 2135 // IPv4 prefix match for ::ffff:192.1.122.0/119.
2125 chunks.push_back(AddChunkHashedIpValue(5, "::ffff:192.1.122.0", 119)); 2136 chunks.push_back(AddChunkHashedIpValue(5, "::ffff:192.1.122.0", 119));
2126 2137
2127 // IPv4 prefix match for ::ffff:192.1.128.0/113. 2138 // IPv4 prefix match for ::ffff:192.1.128.0/113.
2128 chunks.push_back(AddChunkHashedIpValue(6, "::ffff:192.1.128.0", 113)); 2139 chunks.push_back(AddChunkHashedIpValue(6, "::ffff:192.1.128.0", 113));
2129 2140
2130 database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get()); 2141 database_->InsertChunks(safe_browsing::kIPBlacklist, chunks.get());
2131 database_->UpdateFinished(true); 2142 database_->UpdateFinished(true);
2132 2143
2133 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.0.255")); 2144 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.0.255"));
2134 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.0")); 2145 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.0"));
2135 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.255")); 2146 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.255"));
2136 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.10")); 2147 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.10"));
2137 EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.168.1.2")); 2148 EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.168.1.2"));
2138 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.2.0")); 2149 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.2.0"));
2139 2150
2140 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.1.0")); 2151 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.1.0"));
(...skipping 29 matching lines...) Expand all
2170 } 2181 }
2171 2182
2172 TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) { 2183 TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) {
2173 std::vector<SBListChunkRanges> lists; 2184 std::vector<SBListChunkRanges> lists;
2174 ASSERT_TRUE(database_->UpdateStarted(&lists)); 2185 ASSERT_TRUE(database_->UpdateStarted(&lists));
2175 2186
2176 // Add a host-level hit. 2187 // Add a host-level hit.
2177 { 2188 {
2178 ScopedVector<SBChunkData> chunks; 2189 ScopedVector<SBChunkData> chunks;
2179 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/")); 2190 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/"));
2180 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2191 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
2181 } 2192 }
2182 2193
2183 // Add a specific fullhash. 2194 // Add a specific fullhash.
2184 static const char kWhateverMalware[] = "www.whatever.com/malware.html"; 2195 static const char kWhateverMalware[] = "www.whatever.com/malware.html";
2185 { 2196 {
2186 ScopedVector<SBChunkData> chunks; 2197 ScopedVector<SBChunkData> chunks;
2187 chunks.push_back(AddChunkFullHashValue(2, kWhateverMalware)); 2198 chunks.push_back(AddChunkFullHashValue(2, kWhateverMalware));
2188 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2199 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
2189 } 2200 }
2190 2201
2191 // Add a fullhash which has a prefix collision for a known url. 2202 // Add a fullhash which has a prefix collision for a known url.
2192 static const char kExampleFine[] = "www.example.com/fine.html"; 2203 static const char kExampleFine[] = "www.example.com/fine.html";
2193 static const char kExampleCollision[] = 2204 static const char kExampleCollision[] =
2194 "www.example.com/3123364814/malware.htm"; 2205 "www.example.com/3123364814/malware.htm";
2195 ASSERT_EQ(SBPrefixForString(kExampleFine), 2206 ASSERT_EQ(SBPrefixForString(kExampleFine),
2196 SBPrefixForString(kExampleCollision)); 2207 SBPrefixForString(kExampleCollision));
2197 { 2208 {
2198 ScopedVector<SBChunkData> chunks; 2209 ScopedVector<SBChunkData> chunks;
2199 chunks.push_back(AddChunkFullHashValue(3, kExampleCollision)); 2210 chunks.push_back(AddChunkFullHashValue(3, kExampleCollision));
2200 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2211 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
2201 } 2212 }
2202 2213
2203 database_->UpdateFinished(true); 2214 database_->UpdateFinished(true);
2204 2215
2205 std::vector<SBPrefix> prefix_hits; 2216 std::vector<SBPrefix> prefix_hits;
2206 std::vector<SBFullHashResult> cache_hits; 2217 std::vector<SBFullHashResult> cache_hits;
2207 2218
2208 // Anything will hit the host prefix. 2219 // Anything will hit the host prefix.
2209 EXPECT_TRUE(database_->ContainsBrowseUrl( 2220 EXPECT_TRUE(database_->ContainsBrowseUrl(
2210 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 2221 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
(...skipping 20 matching lines...) Expand all
2231 GURL(std::string("http://") + kExampleCollision), 2242 GURL(std::string("http://") + kExampleCollision),
2232 &prefix_hits, &cache_hits)); 2243 &prefix_hits, &cache_hits));
2233 ASSERT_EQ(1U, prefix_hits.size()); 2244 ASSERT_EQ(1U, prefix_hits.size());
2234 EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]); 2245 EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
2235 EXPECT_TRUE(cache_hits.empty()); 2246 EXPECT_TRUE(cache_hits.empty());
2236 2247
2237 // This prefix collides, but no full hash match. 2248 // This prefix collides, but no full hash match.
2238 EXPECT_FALSE(database_->ContainsBrowseUrl( 2249 EXPECT_FALSE(database_->ContainsBrowseUrl(
2239 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); 2250 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
2240 } 2251 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698