Convert //components/user_prefs from scoped_ptr to std::unique_ptr

components/user_prefs/tracked/pref_hash_store_impl.cc

 // Copyright 2013 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 "components/user_prefs/tracked/pref_hash_store_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "components/user_prefs/tracked/hash_store_contents.h"
 #include "components/user_prefs/tracked/pref_hash_store_transaction.h"
 
 class PrefHashStoreImpl::PrefHashStoreTransactionImpl
     : public PrefHashStoreTransaction {
  public:
   // Constructs a PrefHashStoreTransactionImpl which can use the private
   // members of its |outer| PrefHashStoreImpl.
   PrefHashStoreTransactionImpl(PrefHashStoreImpl* outer,
-                               scoped_ptr<HashStoreContents> storage);
+                               std::unique_ptr<HashStoreContents> storage);
   ~PrefHashStoreTransactionImpl() override;
 
   // PrefHashStoreTransaction implementation.
   ValueState CheckValue(const std::string& path,
                         const base::Value* value) const override;
   void StoreHash(const std::string& path, const base::Value* value) override;
   ValueState CheckSplitValue(
       const std::string& path,
       const base::DictionaryValue* initial_split_value,
       std::vector<std::string>* invalid_keys) const override;
@@ skipping 15 matching lines @@
                : contents_.get();
   }
 
   const HashStoreContents* contents() const {
     return outer_->legacy_hash_store_contents_
                ? outer_->legacy_hash_store_contents_.get()
                : contents_.get();
   }
 
   PrefHashStoreImpl* outer_;
-  scoped_ptr<HashStoreContents> contents_;
+  std::unique_ptr<HashStoreContents> contents_;
 
   bool super_mac_valid_;
   bool super_mac_dirty_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashStoreTransactionImpl);
 };
 
 PrefHashStoreImpl::PrefHashStoreImpl(const std::string& seed,
                                      const std::string& device_id,
                                      bool use_super_mac)
     : pref_hash_calculator_(seed, device_id), use_super_mac_(use_super_mac) {
 }
 
 PrefHashStoreImpl::~PrefHashStoreImpl() {
 }
 
 void PrefHashStoreImpl::set_legacy_hash_store_contents(
-    scoped_ptr<HashStoreContents> legacy_hash_store_contents) {
+    std::unique_ptr<HashStoreContents> legacy_hash_store_contents) {
   legacy_hash_store_contents_ = std::move(legacy_hash_store_contents);
 }
 
-scoped_ptr<PrefHashStoreTransaction> PrefHashStoreImpl::BeginTransaction(
-    scoped_ptr<HashStoreContents> storage) {
-  return scoped_ptr<PrefHashStoreTransaction>(
+std::unique_ptr<PrefHashStoreTransaction> PrefHashStoreImpl::BeginTransaction(
+    std::unique_ptr<HashStoreContents> storage) {
+  return std::unique_ptr<PrefHashStoreTransaction>(
       new PrefHashStoreTransactionImpl(this, std::move(storage)));
 }
 
 PrefHashStoreImpl::PrefHashStoreTransactionImpl::PrefHashStoreTransactionImpl(
     PrefHashStoreImpl* outer,
-    scoped_ptr<HashStoreContents> storage)
+    std::unique_ptr<HashStoreContents> storage)
     : outer_(outer),
       contents_(std::move(storage)),
       super_mac_valid_(false),
       super_mac_dirty_(false) {
   if (!outer_->use_super_mac_)
     return;
 
   // The store must be initialized and have a valid super MAC to be trusted.
 
   const base::DictionaryValue* store_contents = contents()->GetContents();
@@ skipping 125 matching lines @@
   }
 
   return invalid_keys->empty()
              ? (has_secure_legacy_id_hashes ? SECURE_LEGACY : UNCHANGED)
              : CHANGED;
 }
 
 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreSplitHash(
     const std::string& path,
     const base::DictionaryValue* split_value) {
-  scoped_ptr<HashStoreContents::MutableDictionary> mutable_dictionary =
+  std::unique_ptr<HashStoreContents::MutableDictionary> mutable_dictionary =
       contents()->GetMutableContents();
   (*mutable_dictionary)->Remove(path, NULL);
 
   if (split_value) {
     std::string keyed_path(path);
     keyed_path.push_back('.');
     const size_t common_part_length = keyed_path.length();
     for (base::DictionaryValue::Iterator it(*split_value); !it.IsAtEnd();
          it.Advance()) {
       // Keep the common part from the old |keyed_path| and replace the key to
@@ skipping 57 matching lines @@
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::IsSuperMACValid() const {
   return super_mac_valid_;
 }
 
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::StampSuperMac() {
   if (!outer_->use_super_mac_ || super_mac_valid_)
     return false;
   super_mac_dirty_ = true;
   return true;
 }