Move code in components/safe_browsing_db and chrome/browser/s_b/ under the safe_browsing namespace.

chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/path_service.h"
 #include "base/test/test_simple_task_runner.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/safe_browsing_db/prefix_set.h"
 #include "components/safe_browsing_db/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
+namespace safe_browsing {
+
 namespace {
 
 const int kAddChunk1 = 1;
 const int kAddChunk2 = 3;
 const int kAddChunk3 = 5;
 const int kAddChunk4 = 7;
 // Disjoint chunk numbers for subs to flush out typos.
 const int kSubChunk1 = 2;
 const int kSubChunk2 = 4;
 
-const SBFullHash kHash1 = safe_browsing::SBFullHashForString("one");
-const SBFullHash kHash2 = safe_browsing::SBFullHashForString("two");
-const SBFullHash kHash3 = safe_browsing::SBFullHashForString("three");
-const SBFullHash kHash4 = safe_browsing::SBFullHashForString("four");
-const SBFullHash kHash5 = safe_browsing::SBFullHashForString("five");
-const SBFullHash kHash6 = safe_browsing::SBFullHashForString("six");
+const SBFullHash kHash1 = SBFullHashForString("one");
+const SBFullHash kHash2 = SBFullHashForString("two");
+const SBFullHash kHash3 = SBFullHashForString("three");
+const SBFullHash kHash4 = SBFullHashForString("four");
+const SBFullHash kHash5 = SBFullHashForString("five");
+const SBFullHash kHash6 = SBFullHashForString("six");
 
 const SBPrefix kMinSBPrefix = 0u;
 const SBPrefix kMaxSBPrefix = ~kMinSBPrefix;
 
 }  // namespace
 
-namespace safe_browsing {
-
 class SafeBrowsingStoreFileTest : public PlatformTest {
  public:
   SafeBrowsingStoreFileTest()
       : task_runner_(new base::TestSimpleTaskRunner),
         corruption_detected_(false) {}
 
   void SetUp() override {
     PlatformTest::SetUp();
 
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
@@ skipping 41 matching lines @@
     EXPECT_TRUE(store_->CheckAddChunk(kAddChunk2));
     EXPECT_TRUE(store_->WriteAddHash(kAddChunk2, kHash4));
     EXPECT_TRUE(store_->FinishChunk());
 
     // Chunk numbers shouldn't leak over.
     EXPECT_FALSE(store_->CheckAddChunk(kSubChunk1));
     EXPECT_FALSE(store_->CheckAddChunk(kAddChunk3));
     EXPECT_FALSE(store_->CheckSubChunk(kAddChunk1));
     EXPECT_FALSE(store_->CheckSubChunk(kAddChunk2));
 
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
 
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
   }
 
   // Manually read the shard stride info from the file.
   uint32 ReadStride() {
     base::ScopedFILE file(base::OpenFile(filename_, "rb"));
     const long kOffset = 4 * sizeof(uint32);
     EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
@@ skipping 21 matching lines @@
 
   // Shouldn't see anything, but anything is a big set to test.
   EXPECT_FALSE(store_->CheckAddChunk(0));
   EXPECT_FALSE(store_->CheckAddChunk(1));
   EXPECT_FALSE(store_->CheckAddChunk(-1));
 
   EXPECT_FALSE(store_->CheckSubChunk(0));
   EXPECT_FALSE(store_->CheckSubChunk(1));
   EXPECT_FALSE(store_->CheckSubChunk(-1));
 
-  safe_browsing::PrefixSetBuilder builder;
+  PrefixSetBuilder builder;
   std::vector<SBAddFullHash> add_full_hashes_result;
 
   EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
   EXPECT_TRUE(add_full_hashes_result.empty());
 
   std::vector<SBPrefix> prefixes_result;
   builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
   EXPECT_TRUE(prefixes_result.empty());
 }
 
@@ skipping 17 matching lines @@
   EXPECT_TRUE(store_->CheckAddChunk(kAddChunk1));
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
 
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetAddChunk(kAddChunk3);
   EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk3, kHash5.prefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   // Still has the chunks expected in the next update.
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(3U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_EQ(kHash5.prefix, prefixes_result[1]);
     EXPECT_EQ(kHash2.prefix, prefixes_result[2]);
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+    EXPECT_TRUE(SBFullHashEqual(
         kHash4, add_full_hashes_result[0].full_hash));
   }
 }
 
 // Verify that the min and max prefixes are stored and operated on.
 TEST_F(SafeBrowsingStoreFileTest, PrefixMinMax) {
   PopulateStore();
 
   ASSERT_TRUE(store_->BeginUpdate());
 
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetAddChunk(kAddChunk3);
   EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk3, kMinSBPrefix));
   EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk3, kMaxSBPrefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(4U, prefixes_result.size());
     EXPECT_EQ(kMinSBPrefix, prefixes_result[0]);
     EXPECT_EQ(kHash1.prefix, prefixes_result[1]);
     EXPECT_EQ(kHash2.prefix, prefixes_result[2]);
     EXPECT_EQ(kMaxSBPrefix, prefixes_result[3]);
   }
 
   ASSERT_TRUE(store_->BeginUpdate());
 
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetAddChunk(kSubChunk2);
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk2, kAddChunk3, kMinSBPrefix));
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk2, kAddChunk3, kMaxSBPrefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(2U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_EQ(kHash2.prefix, prefixes_result[1]);
   }
 }
@@ skipping 13 matching lines @@
   EXPECT_TRUE(store_->WriteAddHash(kAddChunk2, kHash4));
   EXPECT_TRUE(store_->FinishChunk());
 
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetSubChunk(kSubChunk1);
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk3, kHash3.prefix));
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk1, kHash2.prefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // Knocked out the chunk expected.
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+    EXPECT_TRUE(SBFullHashEqual(
         kHash4, add_full_hashes_result[0].full_hash));
   }
 
   ASSERT_TRUE(store_->BeginUpdate());
 
   // This add should be knocked out by an existing sub.
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetAddChunk(kAddChunk3);
   EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk3, kHash3.prefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+    EXPECT_TRUE(SBFullHashEqual(
         kHash4, add_full_hashes_result[0].full_hash));
   }
 
   ASSERT_TRUE(store_->BeginUpdate());
 
   // But by here the sub should be gone, so it should stick this time.
   EXPECT_TRUE(store_->BeginChunk());
   store_->SetAddChunk(kAddChunk3);
   EXPECT_TRUE(store_->WriteAddPrefix(kAddChunk3, kHash3.prefix));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(2U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_EQ(kHash3.prefix, prefixes_result[1]);
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+    EXPECT_TRUE(SBFullHashEqual(
         kHash4, add_full_hashes_result[0].full_hash));
   }
 }
 
 // Test that deletes delete the chunk's data.
 TEST_F(SafeBrowsingStoreFileTest, DeleteChunks) {
   ASSERT_TRUE(store_->BeginUpdate());
 
   // A prefix chunk which will be deleted.
   EXPECT_FALSE(store_->CheckAddChunk(kAddChunk1));
@@ skipping 35 matching lines @@
   store_->DeleteSubChunk(kSubChunk1);
 
   // Not actually deleted until finish.
   EXPECT_TRUE(store_->CheckAddChunk(kAddChunk1));
   EXPECT_TRUE(store_->CheckAddChunk(kAddChunk2));
   EXPECT_TRUE(store_->CheckAddChunk(kAddChunk3));
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk2));
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash3.prefix, prefixes_result[0]);
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk3, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+    EXPECT_TRUE(SBFullHashEqual(
         kHash6, add_full_hashes_result[0].full_hash));
   }
 
   // Expected chunks are there in another update.
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(store_->CheckAddChunk(kAddChunk1));
   EXPECT_TRUE(store_->CheckAddChunk(kAddChunk2));
   EXPECT_TRUE(store_->CheckAddChunk(kAddChunk3));
   EXPECT_FALSE(store_->CheckSubChunk(kSubChunk1));
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk2));
 
   // Delete them, too.
   store_->DeleteAddChunk(kAddChunk2);
   store_->DeleteAddChunk(kAddChunk3);
   store_->DeleteSubChunk(kSubChunk2);
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     EXPECT_TRUE(prefixes_result.empty());
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 
   // Expect no more chunks.
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_FALSE(store_->CheckAddChunk(kAddChunk1));
   EXPECT_FALSE(store_->CheckAddChunk(kAddChunk2));
   EXPECT_FALSE(store_->CheckAddChunk(kAddChunk3));
   EXPECT_FALSE(store_->CheckSubChunk(kSubChunk1));
   EXPECT_FALSE(store_->CheckSubChunk(kSubChunk2));
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     EXPECT_TRUE(prefixes_result.empty());
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 }
 
@@ skipping 38 matching lines @@
 
 // Test basic corruption-handling.
 TEST_F(SafeBrowsingStoreFileTest, DetectsCorruption) {
   // Load a store with some data.
   PopulateStore();
 
   // Can successfully open and read the store.
   {
     std::vector<SBPrefix> orig_prefixes;
     std::vector<SBAddFullHash> orig_hashes;
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     ASSERT_TRUE(store_->BeginUpdate());
     EXPECT_TRUE(store_->FinishUpdate(&builder, &orig_hashes));
     builder.GetPrefixSetNoHashes()->GetPrefixes(&orig_prefixes);
     EXPECT_GT(orig_prefixes.size(), 0U);
     EXPECT_GT(orig_hashes.size(), 0U);
     EXPECT_FALSE(corruption_detected_);
   }
 
   // Corrupt the store.
   base::ScopedFILE file(base::OpenFile(filename_, "rb+"));
   const long kOffset = 60;
   EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
   const uint32 kZero = 0;
   uint32 previous = kZero;
   EXPECT_EQ(fread(&previous, sizeof(previous), 1, file.get()), 1U);
   EXPECT_NE(previous, kZero);
   EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
   EXPECT_EQ(fwrite(&kZero, sizeof(kZero), 1, file.get()), 1U);
   file.reset();
 
   // Update fails and corruption callback is called.
   std::vector<SBAddFullHash> add_hashes;
   corruption_detected_ = false;
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     ASSERT_TRUE(store_->BeginUpdate());
     EXPECT_FALSE(store_->FinishUpdate(&builder, &add_hashes));
     EXPECT_TRUE(corruption_detected_);
   }
 
   // Make it look like there is a lot of add-chunks-seen data.
   const long kAddChunkCountOffset = 2 * sizeof(int32);
   const int32 kLargeCount = 1000 * 1000 * 1000;
   file.reset(base::OpenFile(filename_, "rb+"));
   EXPECT_EQ(fseek(file.get(), kAddChunkCountOffset, SEEK_SET), 0);
@@ skipping 116 matching lines @@
   std::vector<int> chunks;
   store_->GetAddChunks(&chunks);
   ASSERT_EQ(2U, chunks.size());
   EXPECT_EQ(kAddChunk1, chunks[0]);
   EXPECT_EQ(kAddChunk2, chunks[1]);
 
   store_->GetSubChunks(&chunks);
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(kSubChunk1, chunks[0]);
 
-  safe_browsing::PrefixSetBuilder builder;
+  PrefixSetBuilder builder;
   std::vector<SBAddFullHash> add_full_hashes_result;
   EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
   SBAddPrefixes add_prefixes;
   EXPECT_TRUE(store_->GetAddPrefixes(&add_prefixes));
   ASSERT_EQ(2U, add_prefixes.size());
   EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
   EXPECT_EQ(kHash1.prefix, add_prefixes[0].prefix);
   EXPECT_EQ(kAddChunk1, add_prefixes[1].chunk_id);
   EXPECT_EQ(kHash2.prefix, add_prefixes[1].prefix);
 
   std::vector<SBAddFullHash> add_hashes;
   EXPECT_TRUE(store_->GetAddFullHashes(&add_hashes));
   ASSERT_EQ(1U, add_hashes.size());
   EXPECT_EQ(kAddChunk2, add_hashes[0].chunk_id);
-  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash4, add_hashes[0].full_hash));
+  EXPECT_TRUE(SBFullHashEqual(kHash4, add_hashes[0].full_hash));
 }
 
 // Test that the database handles resharding correctly, both when growing and
 // which shrinking.
 TEST_F(SafeBrowsingStoreFileTest, Resharding) {
   // Loop through multiple stride boundaries (1<<32, 1<<31, 1<<30, 1<<29).
   const uint32 kTargetStride = 1 << 29;
 
   // Each chunk will require 8 bytes per prefix, plus 4 bytes for chunk
   // information.  It should be less than |kTargetFootprint| in the
@@ skipping 10 matching lines @@
     ASSERT_TRUE(store_->BeginUpdate());
 
     EXPECT_TRUE(store_->BeginChunk());
     store_->SetAddChunk(chunk_id);
     EXPECT_TRUE(store_->CheckAddChunk(chunk_id));
     for (size_t i = 0; i < kPrefixesPerChunk; ++i) {
       EXPECT_TRUE(store_->WriteAddPrefix(chunk_id, static_cast<SBPrefix>(i)));
     }
     EXPECT_TRUE(store_->FinishChunk());
 
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     SBAddPrefixes add_prefixes;
     EXPECT_TRUE(store_->GetAddPrefixes(&add_prefixes));
     ASSERT_EQ(chunk_id * kPrefixesPerChunk, add_prefixes.size());
 
     // New stride should be the same, or shifted one right.
     const uint32 new_shard_stride = ReadStride();
     EXPECT_TRUE((new_shard_stride == shard_stride) ||
                 ((new_shard_stride << 1) == shard_stride));
     shard_stride = new_shard_stride;
     ++chunk_id;
   } while (!shard_stride || shard_stride > kTargetStride);
 
   // Guard against writing too many chunks.  If this gets too big, adjust
   // |kPrefixesPerChunk|.
   EXPECT_LT(chunk_id, 20);
 
   // Remove each chunk and check that the stride goes back to 0.
   while (--chunk_id) {
     ASSERT_TRUE(store_->BeginUpdate());
     EXPECT_TRUE(store_->CheckAddChunk(chunk_id));
     EXPECT_FALSE(store_->CheckAddChunk(chunk_id + 1));
     store_->DeleteAddChunk(chunk_id);
 
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // New stride should be the same, or shifted one left.
     const uint32 new_shard_stride = ReadStride();
     EXPECT_TRUE((new_shard_stride == shard_stride) ||
                 (new_shard_stride == (shard_stride << 1)));
     shard_stride = new_shard_stride;
   }
   EXPECT_EQ(0u, shard_stride);
@@ skipping 63 matching lines @@
   ASSERT_EQ(2U, add_prefixes.size());
   EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
   EXPECT_EQ(kHash1.prefix, add_prefixes[0].prefix);
   EXPECT_EQ(kAddChunk1, add_prefixes[1].chunk_id);
   EXPECT_EQ(kHash2.prefix, add_prefixes[1].prefix);
 
   std::vector<SBAddFullHash> add_hashes;
   EXPECT_TRUE(store_->GetAddFullHashes(&add_hashes));
   ASSERT_EQ(1U, add_hashes.size());
   EXPECT_EQ(kAddChunk1, add_hashes[0].chunk_id);
-  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash2, add_hashes[0].full_hash));
+  EXPECT_TRUE(SBFullHashEqual(kHash2, add_hashes[0].full_hash));
 
   // Attempt an update to make sure things work end-to-end.
   EXPECT_TRUE(store_->BeginUpdate());
 
   // Still has the chunks expected in the next update.
   std::vector<int> chunks;
   store_->GetAddChunks(&chunks);
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(kAddChunk1, chunks[0]);
 
   store_->GetSubChunks(&chunks);
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(kSubChunk1, chunks[0]);
 
   EXPECT_TRUE(store_->CheckAddChunk(kAddChunk1));
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
 
   // Sub chunk kAddChunk1 hash kHash2.
   // NOTE(shess): Having full hashes and prefixes in the same chunk is no longer
   // supported, though it was when this code was written.
   store_->SetSubChunk(kSubChunk2);
   EXPECT_TRUE(store_->CheckSubChunk(kSubChunk1));
   EXPECT_TRUE(store_->WriteSubPrefix(kSubChunk1, kAddChunk1, kHash2.prefix));
   EXPECT_TRUE(store_->WriteSubHash(kSubChunk1, kAddChunk1, kHash2));
   EXPECT_TRUE(store_->FinishChunk());
 
   {
-    safe_browsing::PrefixSetBuilder builder;
+    PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // The sub'ed prefix and hash are gone.
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 }
 #endif
 
 }  // namespace safe_browsing