Remove ScopedVector from IDStores

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 <set>
 
 #include "base/basictypes.h"
 #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/memory/scoped_ptr.h"
-#include "base/memory/scoped_vector.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(
-      ScopedVector<DefaultChannelIDStore::ChannelID>* channel_ids);
+      std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>* channel_ids);

[mmenke, 2015/11/30 20:33:16]

include vector

 
   // 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 45 matching lines @@
   // 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<ScopedVector<DefaultChannelIDStore::ChannelID> > channel_ids(
-      new ScopedVector<DefaultChannelIDStore::ChannelID>());
-  ScopedVector<DefaultChannelIDStore::ChannelID>* channel_ids_ptr =
+  scoped_ptr<std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>>
+      channel_ids(
+          new std::vector<scoped_ptr<DefaultChannelIDStore::ChannelID>>());
+  std::vector<scoped_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(
-    ScopedVector<DefaultChannelIDStore::ChannelID>* channel_ids) {
+    std::vector<scoped_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 49 matching lines @@
     scoped_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(
         new DefaultChannelIDStore::ChannelID(
             smt.ColumnString(0),  // host
             base::Time::FromInternalValue(smt.ColumnInt64(3)), key.Pass()));
-    channel_ids->push_back(channel_id.release());
+    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;
   UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.DBLoadTime",
                              load_time,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(1),
@@ skipping 364 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