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

chrome/browser/safe_browsing/local_database_manager.h

 // 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.
 //
 // Safe Browsing Database Manager implementation that manages a local
 // database.  This is used by Desktop Chromium.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_
 
 #include <stddef.h>
 
 #include <deque>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/safebrowsing.pb.h"
 #include "components/safe_browsing_db/util.h"
 #include "url/gurl.h"
 
@@ skipping 54 matching lines @@
     std::vector<SBFullHashResult> cache_hits;
 
     // Invoke one of client's callbacks with these results.
     void OnSafeBrowsingResult();
 
     // Vends weak pointers for async callbacks on the IO thread, such as
     // timeout checks and replies from checks performed on the SB task runner.
     // TODO(lzheng): We should consider to use this time out check
     // for browsing too (instead of implementing in
     // safe_browsing_resource_handler.cc).
-    scoped_ptr<base::WeakPtrFactory<LocalSafeBrowsingDatabaseManager>>
+    std::unique_ptr<base::WeakPtrFactory<LocalSafeBrowsingDatabaseManager>>
         weak_ptr_factory_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(SafeBrowsingCheck);
   };
 
   // Creates the safe browsing service.  Need to initialize before using.
   LocalSafeBrowsingDatabaseManager(
       const scoped_refptr<SafeBrowsingService>& service);
 
@@ skipping 134 matching lines @@
   void OnAddChunksComplete(AddChunksCallback callback);
 
   // Notification that the database is done loading its bloom filter.  We may
   // have had to queue checks until the database is ready, and if so, this
   // checks them.
   void DatabaseLoadComplete();
 
   // Called on the database thread to add/remove chunks and host keys.
   void AddDatabaseChunks(
       const std::string& list,
-      scoped_ptr<std::vector<scoped_ptr<SBChunkData>>> chunks,
+      std::unique_ptr<std::vector<std::unique_ptr<SBChunkData>>> chunks,
       AddChunksCallback callback);
 
   void DeleteDatabaseChunks(
-      scoped_ptr<std::vector<SBChunkDelete>> chunk_deletes);
+      std::unique_ptr<std::vector<SBChunkDelete>> chunk_deletes);
 
   void NotifyClientBlockingComplete(Client* client, bool proceed);
 
   void DatabaseUpdateFinished(bool update_succeeded);
 
   // Called on the db thread to close the database.  See CloseDatabase().
   void OnCloseDatabase();
 
   // Runs on the db thread to reset the database. We assume that resetting the
   // database is a synchronous operation.
@@ skipping 37 matching lines @@
   // success, otherwise TimeoutCallback will be called.
   void StartSafeBrowsingCheck(
       SafeBrowsingCheck* check,
       const base::Callback<std::vector<SBPrefix>(void)>& task);
 
   // SafeBrowsingProtocolManageDelegate override
   void ResetDatabase() override;
   void UpdateStarted() override;
   void UpdateFinished(bool success) override;
   void GetChunks(GetChunksCallback callback) override;
-  void AddChunks(const std::string& list,
-                 scoped_ptr<std::vector<scoped_ptr<SBChunkData>>> chunks,
-                 AddChunksCallback callback) override;
+  void AddChunks(
+      const std::string& list,
+      std::unique_ptr<std::vector<std::unique_ptr<SBChunkData>>> chunks,
+      AddChunksCallback callback) override;
   void DeleteChunks(
-      scoped_ptr<std::vector<SBChunkDelete>> chunk_deletes) override;
+      std::unique_ptr<std::vector<SBChunkDelete>> chunk_deletes) override;
 
   scoped_refptr<SafeBrowsingService> sb_service_;
 
   CurrentChecks checks_;
 
   // Used for issuing only one GetHash request for a given prefix.
   GetHashRequests gethash_requests_;
 
-  // The persistent database.  We don't use a scoped_ptr because it
+  // The persistent database.  We don't use a std::unique_ptr because it
   // needs to be destroyed on a different thread than this object.
   SafeBrowsingDatabase* database_;
 
   // Lock used to prevent possible data races due to compiler optimizations.
   mutable base::Lock database_lock_;
 
   // Whether the service is running. 'enabled_' is used by the
   // SafeBrowsingDatabaseManager on the IO thread during normal operations.
   bool enabled_;
 
@@ skipping 38 matching lines @@
 
   // Timeout to use for safe browsing checks.
   base::TimeDelta check_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalSafeBrowsingDatabaseManager);
 };  // class LocalSafeBrowsingDatabaseManager
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_