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

chrome/browser/safe_browsing/safe_browsing_database.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "components/safe_browsing_db/util.h"
 
 class GURL;
 
@@ skipping 173 matching lines @@
   //   // back.
   //   db.UpdateFinished(success);
   // }
   //
   // If UpdateStarted() returns true, the caller MUST eventually call
   // UpdateFinished().  If it returns false, the caller MUST NOT call
   // the other functions.
   virtual bool UpdateStarted(std::vector<SBListChunkRanges>* lists) = 0;
   virtual void InsertChunks(
       const std::string& list_name,
-      const std::vector<scoped_ptr<SBChunkData>>& chunks) = 0;
+      const std::vector<std::unique_ptr<SBChunkData>>& chunks) = 0;
   virtual void DeleteChunks(
       const std::vector<SBChunkDelete>& chunk_deletes) = 0;
   virtual void UpdateFinished(bool update_succeeded) = 0;
 
   // Store the results of a GetHash response. In the case of empty results, we
   // cache the prefixes until the next update so that we don't have to issue
   // further GetHash requests we know will be empty. This function is safe to
   // call from any thread.
   virtual void CacheHashResults(
       const std::vector<SBPrefix>& prefixes,
@@ skipping 168 matching lines @@
   bool ContainsModuleWhitelistedString(const std::string& str) override;
   bool ContainsExtensionPrefixes(const std::vector<SBPrefix>& prefixes,
                                  std::vector<SBPrefix>* prefix_hits) override;
   bool ContainsMalwareIP(const std::string& ip_address) override;
   bool ContainsResourceUrlPrefixes(const std::vector<SBPrefix>& prefixes,
                                    std::vector<SBPrefix>* prefix_hits) override;
 
   bool UpdateStarted(std::vector<SBListChunkRanges>* lists) override;
   void InsertChunks(
       const std::string& list_name,
-      const std::vector<scoped_ptr<SBChunkData>>& chunks) override;
+      const std::vector<std::unique_ptr<SBChunkData>>& chunks) override;
   void DeleteChunks(const std::vector<SBChunkDelete>& chunk_deletes) override;
   void UpdateFinished(bool update_succeeded) override;
   void CacheHashResults(const std::vector<SBPrefix>& prefixes,
                         const std::vector<SBFullHashResult>& full_hits,
                         const base::TimeDelta& cache_lifetime) override;
 
   // Returns the value of malware_kill_switch_;
   bool IsMalwareIPMatchKillSwitchOn() override;
 
   // Returns true if the CSD whitelist has everything whitelisted.
@@ skipping 57 matching lines @@
     // Obtained through BeginWriteTransaction(): a WriteTransaction allows
     // modification of the ThreadSafeStateManager's state. It should be used for
     // the shortest amount of time possible (e.g., pre-compute the new state
     // before grabbing a WriteTransaction to swap it in atomically).
     class WriteTransaction;
 
     explicit ThreadSafeStateManager(
         const scoped_refptr<const base::SequencedTaskRunner>& db_task_runner);
     ~ThreadSafeStateManager();
 
-    scoped_ptr<ReadTransaction> BeginReadTransaction();
-    scoped_ptr<ReadTransaction> BeginReadTransactionNoLockOnMainTaskRunner();
-    scoped_ptr<WriteTransaction> BeginWriteTransaction();
+    std::unique_ptr<ReadTransaction> BeginReadTransaction();
+    std::unique_ptr<ReadTransaction>
+    BeginReadTransactionNoLockOnMainTaskRunner();
+    std::unique_ptr<WriteTransaction> BeginWriteTransaction();
 
    private:
     // The sequenced task runner for this object, used to verify that its state
     // is only ever accessed from the runner.
     scoped_refptr<const base::SequencedTaskRunner> db_task_runner_;
 
     // Lock for protecting access to this class' state.
     mutable base::Lock lock_;
 
     SBWhitelist csd_whitelist_;
     SBWhitelist download_whitelist_;
     SBWhitelist inclusion_whitelist_;
     SBWhitelist module_whitelist_;
 
     // The IP blacklist should be small.  At most a couple hundred IPs.
     IPBlacklist ip_blacklist_;
 
     // PrefixSets to speed up lookups for particularly large lists. The
     // PrefixSet themselves are never modified, instead a new one is swapped in
     // on update.
-    scoped_ptr<const PrefixSet> browse_prefix_set_;
-    scoped_ptr<const PrefixSet> unwanted_software_prefix_set_;
+    std::unique_ptr<const PrefixSet> browse_prefix_set_;
+    std::unique_ptr<const PrefixSet> unwanted_software_prefix_set_;
 
     // Cache of gethash results for prefix stores. Entries should not be used if
     // they are older than their expire_after field.  Cached misses will have
     // empty full_hashes field.  Cleared on each update. The cache is "mutable"
     // as it can be written to from any transaction holding the lock, including
     // ReadTransactions.
     mutable PrefixGetHashCache prefix_gethash_cache_;
 
     DISALLOW_COPY_AND_ASSIGN(ThreadSafeStateManager);
   };
@@ skipping 200 matching lines @@
   //   - |extension_blacklist_store_|: For extension IDs.
   //   - |ip_blacklist_store_|: For IP blacklist.
   //   - |unwanted_software_store_|: For unwanted software list (format
   //     identical to browsing lists).
   //   - |module_whitelist_store_|: For module whitelist. This list only
   //     contains 256 bit hashes.
   //   - |resource_blacklist_store_|: For script resource list (format identical
   //     to browsing lists).
   //
   // The stores themselves will be modified throughout the existence of this
-  // database, but shouldn't ever be swapped out (hence the const scoped_ptr --
-  // which could be swapped for C++11's std::optional when that's available).
-  // They are NonThreadSafe and should thus only be accessed on the database's
-  // main thread as enforced by SafeBrowsingStoreFile's implementation.
-  const scoped_ptr<SafeBrowsingStore> browse_store_;
-  const scoped_ptr<SafeBrowsingStore> download_store_;
-  const scoped_ptr<SafeBrowsingStore> csd_whitelist_store_;
-  const scoped_ptr<SafeBrowsingStore> download_whitelist_store_;
-  const scoped_ptr<SafeBrowsingStore> inclusion_whitelist_store_;
-  const scoped_ptr<SafeBrowsingStore> extension_blacklist_store_;
-  const scoped_ptr<SafeBrowsingStore> ip_blacklist_store_;
-  const scoped_ptr<SafeBrowsingStore> unwanted_software_store_;
-  const scoped_ptr<SafeBrowsingStore> module_whitelist_store_;
-  const scoped_ptr<SafeBrowsingStore> resource_blacklist_store_;
+  // database, but shouldn't ever be swapped out (hence the const
+  // std::unique_ptr -- which could be swapped for C++11's std::optional when
+  // that's available). They are NonThreadSafe and should thus only be accessed
+  // on the database's main thread as enforced by SafeBrowsingStoreFile's
+  // implementation.
+  const std::unique_ptr<SafeBrowsingStore> browse_store_;
+  const std::unique_ptr<SafeBrowsingStore> download_store_;
+  const std::unique_ptr<SafeBrowsingStore> csd_whitelist_store_;
+  const std::unique_ptr<SafeBrowsingStore> download_whitelist_store_;
+  const std::unique_ptr<SafeBrowsingStore> inclusion_whitelist_store_;
+  const std::unique_ptr<SafeBrowsingStore> extension_blacklist_store_;
+  const std::unique_ptr<SafeBrowsingStore> ip_blacklist_store_;
+  const std::unique_ptr<SafeBrowsingStore> unwanted_software_store_;
+  const std::unique_ptr<SafeBrowsingStore> module_whitelist_store_;
+  const std::unique_ptr<SafeBrowsingStore> resource_blacklist_store_;
 
   // Used to schedule resetting the database because of corruption. This factory
   // and the WeakPtrs it issues should only be used on the database's main
   // thread.
   base::WeakPtrFactory<SafeBrowsingDatabaseNew> reset_factory_;
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_DATABASE_H_