Change scoped_ptr to std::unique_ptr in //net.

net/extras/sqlite/sqlite_channel_id_store.cc

 // Copyright 2014 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 "net/extras/sqlite/sqlite_channel_id_store.h"
 
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "crypto/ec_private_key.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/x509_certificate.h"
 #include "net/cookies/cookie_util.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/ssl_client_cert_type.h"
 #include "sql/error_delegate_util.h"
@@ skipping 48 matching lines @@
   friend class base::RefCountedThreadSafe<SQLiteChannelIDStore::Backend>;
 
   // You should call Close() before destructing this object.
   virtual ~Backend() {
     DCHECK(!db_.get()) << "Close should have already been called.";
     DCHECK_EQ(0u, num_pending_);
     DCHECK(pending_.empty());
   }
 
   void LoadInBackground(
-      std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>* channel_ids);
+      std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>*
+          channel_ids);
 
   // Database upgrade statements.
   bool EnsureDatabaseVersion();
 
   class PendingOperation {
    public:
     enum OperationType { CHANNEL_ID_ADD, CHANNEL_ID_DELETE };
 
     PendingOperation(OperationType op,
                      const DefaultChannelIDStore::ChannelID& channel_id)
@@ skipping 22 matching lines @@
   // Close() executed on the background task runner.
   void InternalBackgroundClose();
 
   void BackgroundDeleteAllInList(
       const std::list<std::string>& server_identifiers);
 
   void DatabaseErrorCallback(int error, sql::Statement* stmt);
   void KillDatabase();
 
   const base::FilePath path_;
-  scoped_ptr<sql::Connection> db_;
+  std::unique_ptr<sql::Connection> db_;
   sql::MetaTable meta_table_;
 
   typedef std::list<PendingOperation*> PendingOperationsList;
   PendingOperationsList pending_;
   PendingOperationsList::size_type num_pending_;
   // True if the persistent store should skip clear on exit rules.
   bool force_keep_session_state_;
   // Guard |pending_|, |num_pending_| and |force_keep_session_state_|.
   base::Lock lock_;
 
   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
 
   // Indicates if the kill-database callback has been scheduled.
   bool corruption_detected_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
 void SQLiteChannelIDStore::Backend::Load(
     const LoadedCallback& loaded_callback) {
   // This function should be called only once per instance.
   DCHECK(!db_.get());
-  scoped_ptr<std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>>
+  std::unique_ptr<
+      std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>>
       channel_ids(
-          new std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>());
-  std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>* channel_ids_ptr =
-      channel_ids.get();
+          new std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>());
+  std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>*
+      channel_ids_ptr = channel_ids.get();
 
   background_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&Backend::LoadInBackground, this, channel_ids_ptr),
       base::Bind(loaded_callback, base::Passed(&channel_ids)));
 }
 
 void SQLiteChannelIDStore::Backend::LoadInBackground(
-    std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>* channel_ids) {
+    std::vector<std::unique_ptr<DefaultChannelIDStore::ChannelID>>*
+        channel_ids) {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
   // This method should be called only once per instance.
   DCHECK(!db_.get());
 
   base::TimeTicks start = base::TimeTicks::Now();
 
   // Ensure the parent directory for storing certs is created before reading
   // from it.
   const base::FilePath dir = path_.DirName();
@@ skipping 39 matching lines @@
       KillDatabase();
     meta_table_.Reset();
     db_.reset();
     return;
   }
 
   while (smt.Step()) {
     std::vector<uint8_t> private_key_from_db, public_key_from_db;
     smt.ColumnBlobAsVector(1, &private_key_from_db);
     smt.ColumnBlobAsVector(2, &public_key_from_db);
-    scoped_ptr<crypto::ECPrivateKey> key(
+    std::unique_ptr<crypto::ECPrivateKey> key(
         crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
             ChannelIDService::kEPKIPassword, private_key_from_db,
             public_key_from_db));
     if (!key)
       continue;
-    scoped_ptr<DefaultChannelIDStore::ChannelID> channel_id(
+    std::unique_ptr<DefaultChannelIDStore::ChannelID> channel_id(
         new DefaultChannelIDStore::ChannelID(
             smt.ColumnString(0),  // host
             base::Time::FromInternalValue(smt.ColumnInt64(3)), std::move(key)));
     channel_ids->push_back(std::move(channel_id));
   }
 
   UMA_HISTOGRAM_COUNTS_10000(
       "DomainBoundCerts.DBLoadedCount",
       static_cast<base::HistogramBase::Sample>(channel_ids->size()));
   base::TimeDelta load_time = base::TimeTicks::Now() - start;
@@ skipping 163 matching lines @@
 
 void SQLiteChannelIDStore::Backend::BatchOperation(
     PendingOperation::OperationType op,
     const DefaultChannelIDStore::ChannelID& channel_id) {
   // Commit every 30 seconds.
   static const int kCommitIntervalMs = 30 * 1000;
   // Commit right away if we have more than 512 outstanding operations.
   static const size_t kCommitAfterBatchSize = 512;
 
   // We do a full copy of the cert here, and hopefully just here.
-  scoped_ptr<PendingOperation> po(new PendingOperation(op, channel_id));
+  std::unique_ptr<PendingOperation> po(new PendingOperation(op, channel_id));
 
   PendingOperationsList::size_type num_pending;
   {
     base::AutoLock locked(lock_);
     pending_.push_back(po.release());
     num_pending = ++num_pending_;
   }
 
   if (num_pending == 1) {
     // We've gotten our first entry for this batch, fire off the timer.
@@ skipping 14 matching lines @@
   base::AutoLock locked(lock_);
 
   for (PendingOperationsList::iterator it = pending_.begin();
        it != pending_.end();) {
     bool remove =
         std::find(server_identifiers.begin(), server_identifiers.end(),
                   (*it)->channel_id().server_identifier()) !=
         server_identifiers.end();
 
     if (remove) {
-      scoped_ptr<PendingOperation> po(*it);
+      std::unique_ptr<PendingOperation> po(*it);
       it = pending_.erase(it);
       --num_pending_;
     } else {
       ++it;
     }
   }
 }
 
 void SQLiteChannelIDStore::Backend::Commit() {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 21 matching lines @@
   if (!del_statement.is_valid())
     return;
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return;
 
   for (PendingOperationsList::iterator it = ops.begin(); it != ops.end();
        ++it) {
     // Free the certs as we commit them to the database.
-    scoped_ptr<PendingOperation> po(*it);
+    std::unique_ptr<PendingOperation> po(*it);
     switch (po->op()) {
       case PendingOperation::CHANNEL_ID_ADD: {
         add_statement.Reset(true);
         add_statement.BindString(0, po->channel_id().server_identifier());
         std::vector<uint8_t> private_key, public_key;
         if (!po->channel_id().key()->ExportEncryptedPrivateKey(
                 ChannelIDService::kEPKIPassword, 1, &private_key))
           continue;
         if (!po->channel_id().key()->ExportPublicKey(&public_key))
           continue;
@@ skipping 107 matching lines @@
   backend_->SetForceKeepSessionState();
 }
 
 SQLiteChannelIDStore::~SQLiteChannelIDStore() {
   backend_->Close();
   // We release our reference to the Backend, though it will probably still have
   // a reference if the background task runner has not run Close() yet.
 }
 
 }  // namespace net