Convert //chrome/browser/safe_browsing from scoped_ptr to std::unique_ptr

chrome/browser/safe_browsing/safe_browsing_database_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.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/chunk.pb.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 #include "crypto/sha2.h"
 #include "net/base/ip_address.h"
@@ skipping 33 matching lines @@
   EXPECT_TRUE(ip_address.IsIPv6());
   const std::string hashed_ip_prefix =
       base::SHA1HashString(net::IPAddressToPackedString(ip_address));
   std::string hash(crypto::kSHA256Length, '\0');
   hash.replace(0, hashed_ip_prefix.size(), hashed_ip_prefix);
   hash[base::kSHA1Length] = static_cast<char>(prefix_size);
   return hash;
 }
 
 // Helper to build a chunk.  Caller takes ownership.
-scoped_ptr<SBChunkData> BuildChunk(int chunk_number,
-                                   ChunkData::ChunkType chunk_type,
-                                   ChunkData::PrefixType prefix_type,
-                                   const void* data,
-                                   size_t data_size,
-                                   const std::vector<int>& add_chunk_numbers) {
-  scoped_ptr<ChunkData> raw_data(new ChunkData);
+std::unique_ptr<SBChunkData> BuildChunk(
+    int chunk_number,
+    ChunkData::ChunkType chunk_type,
+    ChunkData::PrefixType prefix_type,
+    const void* data,
+    size_t data_size,
+    const std::vector<int>& add_chunk_numbers) {
+  std::unique_ptr<ChunkData> raw_data(new ChunkData);
   raw_data->set_chunk_number(chunk_number);
   raw_data->set_chunk_type(chunk_type);
   raw_data->set_prefix_type(prefix_type);
   raw_data->set_hashes(data, data_size);
   raw_data->clear_add_numbers();
   for (size_t i = 0; i < add_chunk_numbers.size(); ++i) {
     raw_data->add_add_numbers(add_chunk_numbers[i]);
   }
 
-  return make_scoped_ptr(new SBChunkData(std::move(raw_data)));
+  return base::WrapUnique(new SBChunkData(std::move(raw_data)));
 }
 
 // Create add chunk with a single prefix.
-scoped_ptr<SBChunkData> AddChunkPrefix(int chunk_number, SBPrefix prefix) {
+std::unique_ptr<SBChunkData> AddChunkPrefix(int chunk_number, SBPrefix prefix) {
   return BuildChunk(chunk_number, ChunkData::ADD, ChunkData::PREFIX_4B, &prefix,
                     sizeof(prefix), std::vector<int>());
 }
 
 // Create add chunk with a single prefix generated from |value|.
-scoped_ptr<SBChunkData> AddChunkPrefixValue(int chunk_number,
-                                            const std::string& value) {
+std::unique_ptr<SBChunkData> AddChunkPrefixValue(int chunk_number,
+                                                 const std::string& value) {
   return AddChunkPrefix(chunk_number, SBPrefixForString(value));
 }
 
 // Generate an add chunk with two prefixes.
-scoped_ptr<SBChunkData> AddChunkPrefix2Value(int chunk_number,
-                                             const std::string& value1,
-                                             const std::string& value2) {
+std::unique_ptr<SBChunkData> AddChunkPrefix2Value(int chunk_number,
+                                                  const std::string& value1,
+                                                  const std::string& value2) {
   const SBPrefix prefixes[2] = {
     SBPrefixForString(value1),
     SBPrefixForString(value2),
   };
   return BuildChunk(chunk_number, ChunkData::ADD, ChunkData::PREFIX_4B,
                     &prefixes[0], sizeof(prefixes), std::vector<int>());
 }
 
 // Generate an add chunk with four prefixes.
-scoped_ptr<SBChunkData> AddChunkPrefix4Value(int chunk_number,
-                                             const std::string& value1,
-                                             const std::string& value2,
-                                             const std::string& value3,
-                                             const std::string& value4) {
+std::unique_ptr<SBChunkData> AddChunkPrefix4Value(int chunk_number,
+                                                  const std::string& value1,
+                                                  const std::string& value2,
+                                                  const std::string& value3,
+                                                  const std::string& value4) {
   const SBPrefix prefixes[4] = {
     SBPrefixForString(value1),
     SBPrefixForString(value2),
     SBPrefixForString(value3),
     SBPrefixForString(value4),
   };
   return BuildChunk(chunk_number, ChunkData::ADD, ChunkData::PREFIX_4B,
                     &prefixes[0], sizeof(prefixes), std::vector<int>());
 }
 
 // Generate an add chunk with a full hash.
-scoped_ptr<SBChunkData> AddChunkFullHash(int chunk_number,
-                                         SBFullHash full_hash) {
+std::unique_ptr<SBChunkData> AddChunkFullHash(int chunk_number,
+                                              SBFullHash full_hash) {
   return BuildChunk(chunk_number, ChunkData::ADD, ChunkData::FULL_32B,
                     &full_hash, sizeof(full_hash), std::vector<int>());
 }
 
 // Generate an add chunk with a full hash generated from |value|.
-scoped_ptr<SBChunkData> AddChunkFullHashValue(int chunk_number,
-                                              const std::string& value) {
+std::unique_ptr<SBChunkData> AddChunkFullHashValue(int chunk_number,
+                                                   const std::string& value) {
   return AddChunkFullHash(chunk_number,
                           SBFullHashForString(value));
 }
 
 // Generate an add chunk with two full hashes.
-scoped_ptr<SBChunkData> AddChunkFullHash2Value(int chunk_number,
-                                               const std::string& value1,
-                                               const std::string& value2) {
+std::unique_ptr<SBChunkData> AddChunkFullHash2Value(int chunk_number,
+                                                    const std::string& value1,
+                                                    const std::string& value2) {
   const SBFullHash full_hashes[2] = {
     SBFullHashForString(value1),
     SBFullHashForString(value2),
   };
   return BuildChunk(chunk_number, ChunkData::ADD, ChunkData::FULL_32B,
                     &full_hashes[0], sizeof(full_hashes), std::vector<int>());
 }
 
 // Generate a sub chunk with a prefix generated from |value|.
-scoped_ptr<SBChunkData> SubChunkPrefixValue(int chunk_number,
-                                            const std::string& value,
-                                            int add_chunk_number) {
+std::unique_ptr<SBChunkData> SubChunkPrefixValue(int chunk_number,
+                                                 const std::string& value,
+                                                 int add_chunk_number) {
   const SBPrefix prefix = SBPrefixForString(value);
   return BuildChunk(chunk_number, ChunkData::SUB, ChunkData::PREFIX_4B, &prefix,
                     sizeof(prefix), std::vector<int>(1, add_chunk_number));
 }
 
 // Generate a sub chunk with two prefixes.
-scoped_ptr<SBChunkData> SubChunkPrefix2Value(int chunk_number,
-                                             const std::string& value1,
-                                             int add_chunk_number1,
-                                             const std::string& value2,
-                                             int add_chunk_number2) {
+std::unique_ptr<SBChunkData> SubChunkPrefix2Value(int chunk_number,
+                                                  const std::string& value1,
+                                                  int add_chunk_number1,
+                                                  const std::string& value2,
+                                                  int add_chunk_number2) {
   const SBPrefix prefixes[2] = {
     SBPrefixForString(value1),
     SBPrefixForString(value2),
   };
   std::vector<int> add_chunk_numbers;
   add_chunk_numbers.push_back(add_chunk_number1);
   add_chunk_numbers.push_back(add_chunk_number2);
   return BuildChunk(chunk_number, ChunkData::SUB, ChunkData::PREFIX_4B,
                     &prefixes[0], sizeof(prefixes), add_chunk_numbers);
 }
 
 // Generate a sub chunk with a full hash.
-scoped_ptr<SBChunkData> SubChunkFullHash(int chunk_number,
-                                         SBFullHash full_hash,
-                                         int add_chunk_number) {
+std::unique_ptr<SBChunkData> SubChunkFullHash(int chunk_number,
+                                              SBFullHash full_hash,
+                                              int add_chunk_number) {
   return BuildChunk(chunk_number, ChunkData::SUB, ChunkData::FULL_32B,
                     &full_hash, sizeof(full_hash),
                     std::vector<int>(1, add_chunk_number));
 }
 
 // Generate a sub chunk with a full hash generated from |value|.
-scoped_ptr<SBChunkData> SubChunkFullHashValue(int chunk_number,
-                                              const std::string& value,
-                                              int add_chunk_number) {
+std::unique_ptr<SBChunkData> SubChunkFullHashValue(int chunk_number,
+                                                   const std::string& value,
+                                                   int add_chunk_number) {
   return SubChunkFullHash(chunk_number,
                           SBFullHashForString(value),
                           add_chunk_number);
 }
 
 // Generate an add chunk with a single full hash for the ip blacklist.
-scoped_ptr<SBChunkData> AddChunkHashedIpValue(int chunk_number,
-                                              const std::string& ip_str,
-                                              size_t prefix_size) {
+std::unique_ptr<SBChunkData> AddChunkHashedIpValue(int chunk_number,
+                                                   const std::string& ip_str,
+                                                   size_t prefix_size) {
   const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size);
   EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size());
   SBFullHash full_hash;
   std::memcpy(&(full_hash.full_hash), full_hash_str.data(), sizeof(SBFullHash));
   return BuildChunk(chunk_number, ChunkData::ADD, ChunkData::FULL_32B,
                     &full_hash, sizeof(full_hash), std::vector<int>());
 }
 
 // Prevent DCHECK from killing tests.
 // TODO(shess): Pawel disputes the use of this, so the test which uses
@@ skipping 123 matching lines @@
   }
 
   void SubDelChunk(const std::string& list, int chunk_id) {
     DelChunk(list, chunk_id, true);
   }
 
   // Utility function for setting up the database for the caching test.
   void PopulateDatabaseForCacheTest();
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
-  scoped_ptr<SafeBrowsingDatabaseNew> database_;
+  std::unique_ptr<SafeBrowsingDatabaseNew> database_;
   base::FilePath database_filename_;
   base::ScopedTempDir temp_dir_;
 };
 
 // Tests retrieving list name information.
 TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) {
   std::vector<SBListChunkRanges> lists;
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
 
   chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
   chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
   chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html"));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
@@ skipping 40 matching lines @@
   ASSERT_LE(2U, lists.size());
   EXPECT_EQ(kMalwareList, lists[0].name);
   EXPECT_EQ("1-3", lists[0].adds);
   EXPECT_EQ("7", lists[0].subs);
   EXPECT_EQ(kPhishingList, lists[1].name);
   EXPECT_EQ("47", lists[1].adds);
   EXPECT_EQ("200-201", lists[1].subs);
 }
 
 TEST_F(SafeBrowsingDatabaseTest, ListNames) {
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
 
   // Insert malware, phish, binurl and bindownload add chunks.
   chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
   database_->InsertChunks(kMalwareList, chunks);
 
   chunks.clear();
   chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
@@ skipping 144 matching lines @@
       &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl,
       &SafeBrowsingDatabase::ContainsUnwantedSoftwareHashes
     },
   };
 
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(std::string("Tested list at fault => ") +
                  test_case.test_list_name);
 
     std::vector<SBListChunkRanges> lists;
-    std::vector<scoped_ptr<SBChunkData>> chunks;
+    std::vector<std::unique_ptr<SBChunkData>> chunks;
 
     chunks.push_back(AddChunkPrefix2Value(1,
                                           "www.evil.com/phishing.html",
                                           "www.evil.com/malware.html"));
     chunks.push_back(AddChunkPrefix4Value(2,
                                           "www.evil.com/notevil1.html",
                                           "www.evil.com/notevil2.html",
                                           "www.good.com/good1.html",
                                           "www.good.com/good2.html"));
     chunks.push_back(AddChunkPrefixValue(3, "192.168.0.1/malware.html"));
@@ skipping 216 matching lines @@
     test_case.TestContainsFunctions(*database_, true,
         GURL("http://www.evil.com/evil.html"), &prefix_hits, &cache_hits);
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(SBPrefixForString("www.evil.com/evil.html"), prefix_hits[0]);
   }
 }
 
 // Test adding zero length chunks to the database.
 TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
   std::vector<SBListChunkRanges> lists;
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
 
   // Populate with a couple of normal chunks.
   chunks.push_back(AddChunkPrefix2Value(1,
                                         "www.test.com/test1.html",
                                         "www.test.com/test2.html"));
   chunks.push_back(AddChunkPrefix2Value(10,
                                         "www.random.com/random1.html",
                                         "www.random.com/random2.html"));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
@@ skipping 66 matching lines @@
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
   EXPECT_EQ(kMalwareList, lists[0].name);
   EXPECT_EQ("1,10,19-20,22", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
 }
 
 // Utility function for setting up the database for the caching test.
 void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() {
   // Add a couple prefixes.
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkPrefix2Value(1,
                                         "www.evil.com/phishing.html",
                                         "www.evil.com/malware.html"));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
@@ skipping 47 matching lines @@
   EXPECT_TRUE(prefix_hits.empty());
   ASSERT_EQ(1U, cache_hits.size());
   EXPECT_TRUE(SBFullHashEqual(
       cache_hits[0].hash,
       SBFullHashForString("www.evil.com/malware.html")));
 
   prefix_hits.clear();
   cache_hits.clear();
 
   // Test removing a prefix via a sub chunk.
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(SubChunkPrefixValue(2, "www.evil.com/phishing.html", 1));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   // This prefix should still be there, but cached fullhash should be gone.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
@@ skipping 153 matching lines @@
       GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits));
 
   // Add a fullhash which has a prefix collision for a known url.
   static const char kExampleFine[] = "www.example.com/fine.html";
   static const char kExampleCollision[] =
       "www.example.com/3123364814/malware.htm";
   ASSERT_EQ(SBPrefixForString(kExampleFine),
             SBPrefixForString(kExampleCollision));
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   {
-    std::vector<scoped_ptr<SBChunkData>> chunks;
+    std::vector<std::unique_ptr<SBChunkData>> chunks;
     chunks.push_back(AddChunkPrefixValue(21, kExampleCollision));
     database_->InsertChunks(kMalwareList, chunks);
   }
   database_->UpdateFinished(true);
 
   // Expect a prefix hit due to the collision between |kExampleFine| and
   // |kExampleCollision|.
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
   ASSERT_EQ(1U, prefix_hits.size());
@@ skipping 30 matching lines @@
       task_runner_, store, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
       NULL));
   database_->Init(database_filename_);
 
   // This will cause an empty database to be created.
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
 
   // Create a sub chunk to insert.
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(SubChunkPrefixValue(7,
                                        "www.subbed.com/notevil1.html",
                                        19));
 
   // Corrupt the file by corrupting the checksum, which is not checked
   // until the entire table is read in |UpdateFinished()|.
   FILE* fp = base::OpenFile(database_filename_, "r+");
   ASSERT_TRUE(fp);
   ASSERT_NE(-1, fseek(fp, -8, SEEK_END));
   for (size_t i = 0; i < 8; ++i) {
@@ skipping 29 matching lines @@
 
   database_.reset();
 }
 
 // Checks database reading and writing.
 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrlPrefixes) {
   const char kEvil1Url1[] = "www.evil1.com/download1/";
   const char kEvil1Url2[] = "www.evil1.com/download2.html";
 
   // Add a simple chunk with one hostkey for download url list.
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkPrefix2Value(1, kEvil1Url1, kEvil1Url2));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kBinUrlList, chunks);
   database_->UpdateFinished(true);
 
   std::vector<SBPrefix> prefix_hits;
   std::vector<GURL> urls(1);
 
@@ skipping 68 matching lines @@
   database_.reset();
 }
 
 TEST_F(SafeBrowsingDatabaseTest, ContainsResourceUrlPrefixes) {
   const char* kBadUrl1 = "bad1.com/";
   const char* kBadUrl2 = "bad2.com/script.js";
   const SBPrefix kBadPrefix1 = SBPrefixForString(kBadUrl1);
   const SBPrefix kBadPrefix2 = SBPrefixForString(kBadUrl2);
 
   // Populate database
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkPrefix2Value(1, kBadUrl1, kBadUrl2));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kResourceBlacklist, chunks);
   database_->UpdateFinished(true);
 
   struct {
     std::string url;
     bool found_in_db;
@@ skipping 122 matching lines @@
         EXPECT_TRUE(
             (database_.get()->*test_case.test_list_contains_whitelisted_string)(
                 "asdf"));
       } else {
         EXPECT_FALSE(
             (database_.get()->*test_case.test_list_contains_whitelisted_string)(
                 kGoodString));
       }
     }
 
-    std::vector<scoped_ptr<SBChunkData>> chunks;
+    std::vector<std::unique_ptr<SBChunkData>> chunks;
 
     // Add a few test chunks to the whitelist under test.
     if (test_case.TestUrls()) {
       chunks.push_back(AddChunkFullHash2Value(1, kGood1Url1, kGood1Url2));
       chunks.push_back(AddChunkFullHashValue(2, kGood2Url1));
       chunks.push_back(AddChunkFullHashValue(4, kGood3Url1));
     }
     if (test_case.TestStrings())
       chunks.push_back(AddChunkFullHashValue(3, kGoodString));
 
@@ skipping 155 matching lines @@
       EXPECT_FALSE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               "asdf"));
     }
   }
 }
 
 // Test to make sure we could insert chunk list that
 // contains entries for the same host.
 TEST_F(SafeBrowsingDatabaseTest, SameHostEntriesOkay) {
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
 
   // Add a malware add chunk with two entries of the same host.
   chunks.push_back(AddChunkPrefix2Value(1,
                                         "www.evil.com/malware1.html",
                                         "www.evil.com/malware2.html"));
 
   // Insert the testing chunks into database.
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
@@ skipping 59 matching lines @@
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits));
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits));
 }
 
 // Test that an empty update doesn't actually update the database.
 // This isn't a functionality requirement, but it is a useful
 // optimization.
 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) {
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
 
   base::FilePath filename = database_->BrowseDBFilename(database_filename_);
 
   // Prime the database.
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
@@ skipping 37 matching lines @@
 
 // Test that a filter file is written out during update and read back
 // in during setup.
 TEST_F(SafeBrowsingDatabaseTest, FilterFile) {
   // Create a database with trivial example data and write it out.
   {
     // Prime the database.
     std::vector<SBListChunkRanges> lists;
     ASSERT_TRUE(database_->UpdateStarted(&lists));
 
-    std::vector<scoped_ptr<SBChunkData>> chunks;
+    std::vector<std::unique_ptr<SBChunkData>> chunks;
     chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
     database_->InsertChunks(kMalwareList, chunks);
     database_->UpdateFinished(true);
   }
 
   // Find the malware url in the database, don't find a good url.
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> cache_hits;
   EXPECT_TRUE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
@@ skipping 25 matching lines @@
 TEST_F(SafeBrowsingDatabaseTest, CachedFullMiss) {
   const SBPrefix kPrefix1 = 1001U;
   const SBFullHash kFullHash1_1 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x01");
 
   const SBPrefix kPrefix2 = 1002U;
   const SBFullHash kFullHash2_1 =
       SBFullHashForPrefixAndSuffix(kPrefix2, "\x01");
 
   // Insert prefix kPrefix1 and kPrefix2 into database.
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkPrefix(1, kPrefix1));
   chunks.push_back(AddChunkPrefix(2, kPrefix2));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // Cache a full miss result for kPrefix1.
@@ skipping 34 matching lines @@
 
   const SBPrefix kPrefix2 = 1002U;
   const SBFullHash kFullHash2_1 =
       SBFullHashForPrefixAndSuffix(kPrefix2, "\x01");
 
   const SBPrefix kPrefix3 = 1003U;
   const SBFullHash kFullHash3_1 =
       SBFullHashForPrefixAndSuffix(kPrefix3, "\x01");
 
   // Insert prefix kPrefix1 and kPrefix2 into database.
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkPrefix(1, kPrefix1));
   chunks.push_back(AddChunkPrefix(2, kPrefix2));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // kFullHash1_1 has a prefix hit of kPrefix1.
@@ skipping 124 matching lines @@
 TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) {
   const SBPrefix kPrefix1 = 1001U;
   const SBFullHash kFullHash1_1 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x01");
   const SBFullHash kFullHash1_2 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x02");
   const SBFullHash kFullHash1_3 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x03");
 
   // Insert two full hashes with a shared prefix.
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkFullHash(1, kFullHash1_1));
   chunks.push_back(AddChunkFullHash(2, kFullHash1_2));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // Check a full hash which isn't present.
@@ skipping 128 matching lines @@
   }
 }
 
 TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashAndPrefixMatching) {
   const SBPrefix kPrefix1 = 1001U;
   const SBFullHash kFullHash1_1 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x01");
   const SBFullHash kFullHash1_2 =
       SBFullHashForPrefixAndSuffix(kPrefix1, "\x02");
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   chunks.push_back(AddChunkFullHash(1, kFullHash1_1));
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->InsertChunks(kMalwareList, chunks);
   database_->UpdateFinished(true);
 
   {
     // kFullHash1_2 does not match kFullHash1_1.
     std::vector<SBFullHash> full_hashes(1, kFullHash1_2);
@@ skipping 41 matching lines @@
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix1, prefix_hits[0]);
     EXPECT_TRUE(cache_hits.empty());
   }
 }
 
 TEST_F(SafeBrowsingDatabaseTest, MalwareIpBlacklist) {
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
 
   // IPv4 prefix match for ::ffff:192.168.1.0/120.
   chunks.push_back(AddChunkHashedIpValue(1, "::ffff:192.168.1.0", 120));
 
   // IPv4 exact match for ::ffff:192.1.1.1.
   chunks.push_back(AddChunkHashedIpValue(2, "::ffff:192.1.1.1", 128));
 
   // IPv6 exact match for: fe80::31a:a0ff:fe10:786e/128.
   chunks.push_back(AddChunkHashedIpValue(3, "fe80::31a:a0ff:fe10:786e", 128));
 
@@ skipping 47 matching lines @@
   EXPECT_TRUE(database_->ContainsMalwareIP("192.1.255.255"));
   EXPECT_FALSE(database_->ContainsMalwareIP("192.2.0.0"));
 }
 
 TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) {
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
 
   // Add a host-level hit.
   {
-    std::vector<scoped_ptr<SBChunkData>> chunks;
+    std::vector<std::unique_ptr<SBChunkData>> chunks;
     chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/"));
     database_->InsertChunks(kMalwareList, chunks);
   }
 
   // Add a specific fullhash.
   static const char kWhateverMalware[] = "www.whatever.com/malware.html";
   {
-    std::vector<scoped_ptr<SBChunkData>> chunks;
+    std::vector<std::unique_ptr<SBChunkData>> chunks;
     chunks.push_back(AddChunkFullHashValue(2, kWhateverMalware));
     database_->InsertChunks(kMalwareList, chunks);
   }
 
   // Add a fullhash which has a prefix collision for a known url.
   static const char kExampleFine[] = "www.example.com/fine.html";
   static const char kExampleCollision[] =
       "www.example.com/3123364814/malware.htm";
   ASSERT_EQ(SBPrefixForString(kExampleFine),
             SBPrefixForString(kExampleCollision));
   {
-    std::vector<scoped_ptr<SBChunkData>> chunks;
+    std::vector<std::unique_ptr<SBChunkData>> chunks;
     chunks.push_back(AddChunkFullHashValue(3, kExampleCollision));
     database_->InsertChunks(kMalwareList, chunks);
   }
 
   database_->UpdateFinished(true);
 
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> cache_hits;
 
   // Anything will hit the host prefix.
@@ skipping 24 matching lines @@
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
   EXPECT_TRUE(cache_hits.empty());
 
   // This prefix collides, but no full hash match.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
 }
 
 }  // namespace safe_browsing