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

chrome/browser/safe_browsing/safe_browsing_database.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_database.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process_handle.h"
 #include "base/process/process_metrics.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ skipping 488 matching lines @@
                   AutoLockRequirement auto_lock_requirement)
       : outer_(outer) {
     DCHECK(outer_);
     if (auto_lock_requirement == AutoLockRequirement::LOCK)
       transaction_lock_.reset(new base::AutoLock(outer_->lock_));
     else
       DCHECK(outer_->db_task_runner_->RunsTasksOnCurrentThread());
   }
 
   const ThreadSafeStateManager* outer_;
-  scoped_ptr<base::AutoLock> transaction_lock_;
+  std::unique_ptr<base::AutoLock> transaction_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ReadTransaction);
 };
 
 class SafeBrowsingDatabaseNew::ThreadSafeStateManager::WriteTransaction {
  public:
   // Call this method if an error occured with the given whitelist.  This will
   // result in all lookups to the whitelist to return true.
   void WhitelistEverything(SBWhitelistId id) {
     SBWhitelist* whitelist = SBWhitelistForId(id);
     whitelist->second = true;
     whitelist->first.clear();
   }
 
   void SwapSBWhitelist(SBWhitelistId id,
                        std::vector<SBFullHash>* new_whitelist) {
     SBWhitelist* whitelist = SBWhitelistForId(id);
     whitelist->second = false;
     whitelist->first.swap(*new_whitelist);
   }
 
   void clear_ip_blacklist() { outer_->ip_blacklist_.clear(); }
 
   void swap_ip_blacklist(IPBlacklist* new_blacklist) {
     outer_->ip_blacklist_.swap(*new_blacklist);
   }
 
   void SwapPrefixSet(PrefixSetId id,
-                     scoped_ptr<const PrefixSet> new_prefix_set) {
+                     std::unique_ptr<const PrefixSet> new_prefix_set) {
     switch (id) {
       case PrefixSetId::BROWSE:
         outer_->browse_prefix_set_.swap(new_prefix_set);
         break;
       case PrefixSetId::UNWANTED_SOFTWARE:
         outer_->unwanted_software_prefix_set_.swap(new_prefix_set);
         break;
     }
   }
 
@@ skipping 37 matching lines @@
 SafeBrowsingDatabaseNew::ThreadSafeStateManager::~ThreadSafeStateManager() {}
 
 SafeBrowsingDatabaseNew::DatabaseStateManager::DatabaseStateManager(
     const scoped_refptr<const base::SequencedTaskRunner>& db_task_runner)
     : db_task_runner_(db_task_runner),
       corruption_detected_(false),
       change_detected_(false) {}
 
 SafeBrowsingDatabaseNew::DatabaseStateManager::~DatabaseStateManager() {}
 
-scoped_ptr<SafeBrowsingDatabaseNew::ReadTransaction>
+std::unique_ptr<SafeBrowsingDatabaseNew::ReadTransaction>
 SafeBrowsingDatabaseNew::ThreadSafeStateManager::BeginReadTransaction() {
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new ReadTransaction(this, ReadTransaction::AutoLockRequirement::LOCK));
 }
 
-scoped_ptr<SafeBrowsingDatabaseNew::ReadTransaction> SafeBrowsingDatabaseNew::
-    ThreadSafeStateManager::BeginReadTransactionNoLockOnMainTaskRunner() {
-  return make_scoped_ptr(new ReadTransaction(
+std::unique_ptr<SafeBrowsingDatabaseNew::ReadTransaction>
+SafeBrowsingDatabaseNew::ThreadSafeStateManager::
+    BeginReadTransactionNoLockOnMainTaskRunner() {
+  return base::WrapUnique(new ReadTransaction(
       this,
       ReadTransaction::AutoLockRequirement::DONT_LOCK_ON_MAIN_TASK_RUNNER));
 }
 
-scoped_ptr<SafeBrowsingDatabaseNew::WriteTransaction>
+std::unique_ptr<SafeBrowsingDatabaseNew::WriteTransaction>
 SafeBrowsingDatabaseNew::ThreadSafeStateManager::BeginWriteTransaction() {
-  return make_scoped_ptr(new WriteTransaction(this));
+  return base::WrapUnique(new WriteTransaction(this));
 }
 
 SafeBrowsingDatabaseNew::SafeBrowsingDatabaseNew(
     const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
     SafeBrowsingStore* browse_store,
     SafeBrowsingStore* download_store,
     SafeBrowsingStore* csd_whitelist_store,
     SafeBrowsingStore* download_whitelist_store,
     SafeBrowsingStore* inclusion_whitelist_store,
     SafeBrowsingStore* extension_blacklist_store,
@@ skipping 34 matching lines @@
   // The store variables are also tested to see if a list is enabled.  Perhaps
   // the stores could be refactored into an update object so that they are only
   // live in memory while being actively used.  The sense of enabled probably
   // belongs in protocol_manager or database_manager.
 
   {
     // NOTE: A transaction here is overkill as there are no pointers to this
     // class on other threads until this function returns, but it's also
     // harmless as that also means there is no possibility of contention on the
     // lock.
-    scoped_ptr<WriteTransaction> txn = state_manager_.BeginWriteTransaction();
+    std::unique_ptr<WriteTransaction> txn =
+        state_manager_.BeginWriteTransaction();
 
     txn->clear_prefix_gethash_cache();
 
     browse_store_->Init(
         BrowseDBFilename(db_state_manager_.filename_base()),
         base::Bind(&SafeBrowsingDatabaseNew::HandleCorruptDatabase,
                    base::Unretained(this)));
 
     if (unwanted_software_store_.get()) {
       unwanted_software_store_->Init(
@@ skipping 135 matching lines @@
 bool SafeBrowsingDatabaseNew::ResetDatabase() {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   // Delete files on disk.
   // TODO(shess): Hard to see where one might want to delete without a
   // reset.  Perhaps inline |Delete()|?
   if (!Delete())
     return false;
 
   // Reset objects in memory.
-  scoped_ptr<WriteTransaction> txn = state_manager_.BeginWriteTransaction();
+  std::unique_ptr<WriteTransaction> txn =
+      state_manager_.BeginWriteTransaction();
   txn->clear_prefix_gethash_cache();
   txn->SwapPrefixSet(PrefixSetId::BROWSE, nullptr);
   txn->SwapPrefixSet(PrefixSetId::UNWANTED_SOFTWARE, nullptr);
   txn->clear_ip_blacklist();
   txn->WhitelistEverything(SBWhitelistId::CSD);
   txn->WhitelistEverything(SBWhitelistId::DOWNLOAD);
   txn->WhitelistEverything(SBWhitelistId::MODULE);
   return true;
 }
 
@@ skipping 49 matching lines @@
   prefix_hits->clear();
   cache_hits->clear();
 
   if (full_hashes.empty())
     return false;
 
   // Used to determine cache expiration.
   const base::Time now = base::Time::Now();
 
   {
-    scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
+    std::unique_ptr<ReadTransaction> txn =
+        state_manager_.BeginReadTransaction();
 
     // |prefix_set| is empty until it is either read from disk, or the first
     // update populates it.  Bail out without a hit if not yet available.
     const PrefixSet* prefix_set = txn->GetPrefixSet(prefix_set_id);
     if (!prefix_set)
       return false;
 
     for (size_t i = 0; i < full_hashes.size(); ++i) {
       if (!GetCachedFullHash(txn->prefix_gethash_cache(), full_hashes[i], now,
                              cache_hits)) {
@@ skipping 57 matching lines @@
 
 bool SafeBrowsingDatabaseNew::ContainsMalwareIP(const std::string& ip_address) {
   net::IPAddress address;
   if (!address.AssignFromIPLiteral(ip_address))
     return false;
   if (address.IsIPv4())
     address = net::ConvertIPv4ToIPv4MappedIPv6(address);
   if (!address.IsIPv6())
     return false;  // better safe than sorry.
 
-  scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
+  std::unique_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
   const IPBlacklist* ip_blacklist = txn->ip_blacklist();
   for (IPBlacklist::const_iterator it = ip_blacklist->begin();
        it != ip_blacklist->end(); ++it) {
     const std::string& mask = it->first;
     DCHECK_EQ(mask.size(), address.size());
     std::string subnet(net::IPAddress::kIPv6AddressSize, '\0');
     for (size_t i = 0; i < net::IPAddress::kIPv6AddressSize; ++i) {
       subnet[i] = address.bytes()[i] & mask[i];
     }
     const std::string hash = base::SHA1HashString(subnet);
@@ skipping 31 matching lines @@
 bool SafeBrowsingDatabaseNew::ContainsModuleWhitelistedString(
     const std::string& str) {
   std::vector<SBFullHash> hashes;
   hashes.push_back(SBFullHashForString(str));
   return ContainsWhitelistedHashes(SBWhitelistId::MODULE, hashes);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsWhitelistedHashes(
     SBWhitelistId whitelist_id,
     const std::vector<SBFullHash>& hashes) {
-  scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
+  std::unique_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
   const SBWhitelist* whitelist = txn->GetSBWhitelist(whitelist_id);
   if (whitelist->second)
     return true;
   for (std::vector<SBFullHash>::const_iterator it = hashes.begin();
        it != hashes.end(); ++it) {
     if (std::binary_search(whitelist->first.begin(), whitelist->first.end(),
                            *it, SBFullHashLess)) {
       return true;
     }
   }
@@ skipping 57 matching lines @@
       const int add_chunk_id = chunk_data.AddChunkNumberAt(i);
       const int encoded_add_chunk_id = EncodeChunkId(add_chunk_id, list_id);
       store->WriteSubHash(encoded_chunk_id, encoded_add_chunk_id,
                           chunk_data.FullHashAt(i));
     }
   }
 }
 
 void SafeBrowsingDatabaseNew::InsertChunks(
     const std::string& list_name,
-    const std::vector<scoped_ptr<SBChunkData>>& chunks) {
+    const std::vector<std::unique_ptr<SBChunkData>>& chunks) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   if (db_state_manager_.corruption_detected() || chunks.empty())
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
 
   // TODO(shess): The caller should just pass list_id.
   const ListType list_id = GetListId(list_name);
 
@@ skipping 48 matching lines @@
     }
   }
 }
 
 void SafeBrowsingDatabaseNew::CacheHashResults(
     const std::vector<SBPrefix>& prefixes,
     const std::vector<SBFullHashResult>& full_hits,
     const base::TimeDelta& cache_lifetime) {
   const base::Time expire_after = base::Time::Now() + cache_lifetime;
 
-  scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
+  std::unique_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
   PrefixGetHashCache* prefix_gethash_cache = txn->prefix_gethash_cache();
 
   // Create or reset all cached results for these prefixes.
   for (size_t i = 0; i < prefixes.size(); ++i) {
     (*prefix_gethash_cache)[prefixes[i]] = SBCachedFullHashResult(expire_after);
   }
 
   // Insert any fullhash hits. Note that there may be one, multiple, or no
   // fullhashes for any given entry in |prefixes|.
   for (size_t i = 0; i < full_hits.size(); ++i) {
@@ skipping 304 matching lines @@
     SafeBrowsingStore* url_store,
     PrefixSetId prefix_set_id,
     FailureType finish_failure_type,
     FailureType write_failure_type,
     bool store_full_hashes_in_prefix_set) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(url_store);
 
   // Measure the amount of IO during the filter build.
   base::IoCounters io_before, io_after;
-  scoped_ptr<base::ProcessMetrics> metric(
+  std::unique_ptr<base::ProcessMetrics> metric(
       base::ProcessMetrics::CreateCurrentProcessMetrics());
 
   // IoCounters are currently not supported on Mac, and may not be
   // available for Linux, so we check the result and only show IO
   // stats if they are available.
   const bool got_counters = metric->GetIOCounters(&io_before);
 
   const base::TimeTicks before = base::TimeTicks::Now();
 
   // TODO(shess): Perhaps refactor to let builder accumulate full hashes on the
   // fly?  Other clients use the SBAddFullHash vector, but AFAICT they only use
   // the SBFullHash portion.  It would need an accessor on PrefixSet.
   PrefixSetBuilder builder;
   std::vector<SBAddFullHash> add_full_hashes;
   if (!url_store->FinishUpdate(&builder, &add_full_hashes)) {
     RecordFailure(finish_failure_type);
     return;
   }
 
-  scoped_ptr<const PrefixSet> new_prefix_set;
+  std::unique_ptr<const PrefixSet> new_prefix_set;
   if (store_full_hashes_in_prefix_set) {
     std::vector<SBFullHash> full_hash_results;
     for (size_t i = 0; i < add_full_hashes.size(); ++i) {
       full_hash_results.push_back(add_full_hashes[i].full_hash);
     }
 
     new_prefix_set = builder.GetPrefixSet(full_hash_results);
   } else {
     // TODO(gab): Ensure that stores which do not want full hashes just don't
     // have full hashes in the first place and remove
@@ skipping 101 matching lines @@
   if (!GetFileSizeOrZero(db_filename))
     return;
 
   // Cleanup any stale bloom filter (no longer used).
   // TODO(shess): Track existence to drive removal of this code?
   const base::FilePath bloom_filter_filename =
       BloomFilterForFilename(db_filename);
   base::DeleteFile(bloom_filter_filename, false);
 
   const base::TimeTicks before = base::TimeTicks::Now();
-  scoped_ptr<const PrefixSet> new_prefix_set =
+  std::unique_ptr<const PrefixSet> new_prefix_set =
       PrefixSet::LoadFile(PrefixSetForFilename(db_filename));
   if (!new_prefix_set.get())
     RecordFailure(read_failure_type);
   txn->SwapPrefixSet(prefix_set_id, std::move(new_prefix_set));
   UMA_HISTOGRAM_TIMES("SB2.PrefixSetLoad", base::TimeTicks::Now() - before);
 }
 
 bool SafeBrowsingDatabaseNew::Delete() {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!db_state_manager_.filename_base().empty());
@@ skipping 79 matching lines @@
 }
 
 void SafeBrowsingDatabaseNew::WritePrefixSet(const base::FilePath& db_filename,
                                              PrefixSetId prefix_set_id,
                                              FailureType write_failure_type) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   // Do not grab the lock to avoid contention while writing to disk. This is
   // safe as only this task runner can ever modify |state_manager_|'s prefix
   // sets anyways.
-  scoped_ptr<ReadTransaction> txn =
+  std::unique_ptr<ReadTransaction> txn =
       state_manager_.BeginReadTransactionNoLockOnMainTaskRunner();
   const PrefixSet* prefix_set = txn->GetPrefixSet(prefix_set_id);
 
   if (!prefix_set)
     return;
 
   const base::FilePath prefix_set_filename = PrefixSetForFilename(db_filename);
 
   const base::TimeTicks before = base::TimeTicks::Now();
   const bool write_ok = prefix_set->WriteFile(prefix_set_filename);
@@ skipping 159 matching lines @@
 
   // Histogram properties as in UMA_HISTOGRAM_COUNTS macro.
   base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
       histogram_name, 1, 1000000, 50,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram_pointer->Add(file_size_kilobytes);
 }
 
 }  // namespace safe_browsing