Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/value_store/leveldb_value_store_unittest.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 "extensions/browser/value_store/value_store_unittest.h"
 
 #include <stddef.h>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
@@ skipping 45 matching lines @@
 
   void CreateStore() {
     store_.reset(
         new LeveldbValueStore(kDatabaseUMAClientName, database_path()));
   }
 
   LeveldbValueStore* store() { return store_.get(); }
   const base::FilePath& database_path() { return database_dir_.path(); }
 
  private:
-  scoped_ptr<LeveldbValueStore> store_;
+  std::unique_ptr<LeveldbValueStore> store_;
   base::ScopedTempDir database_dir_;
 
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 // Check that we can restore a single corrupted key in the LeveldbValueStore.
 TEST_F(LeveldbValueStoreUnitTest, RestoreKeyTest) {
   const char kNotCorruptKey[] = "not-corrupt";
   const char kValue[] = "value";
 
   // Insert a valid pair.
-  scoped_ptr<base::Value> value(new base::StringValue(kValue));
+  std::unique_ptr<base::Value> value(new base::StringValue(kValue));
   ASSERT_TRUE(store()
                   ->Set(ValueStore::DEFAULTS, kNotCorruptKey, *value)
                   ->status().ok());
 
   // Insert a corrupt pair.
   const char kCorruptKey[] = "corrupt";
   leveldb::WriteBatch batch;
   batch.Put(kCorruptKey, "[{(.*+\"\'\\");
   ASSERT_TRUE(store()->WriteToDbForTest(&batch));
 
@@ skipping 21 matching lines @@
 // (unless absolutely necessary), and instead only removes corrupted keys.
 TEST_F(LeveldbValueStoreUnitTest, RestoreDoesMinimumNecessary) {
   const char* kNotCorruptKeys[] = {"a", "n", "z"};
   const size_t kNotCorruptKeysSize = 3u;
   const char kCorruptKey1[] = "f";
   const char kCorruptKey2[] = "s";
   const char kValue[] = "value";
   const char kCorruptValue[] = "[{(.*+\"\'\\";
 
   // Insert a collection of non-corrupted pairs.
-  scoped_ptr<base::Value> value(new base::StringValue(kValue));
+  std::unique_ptr<base::Value> value(new base::StringValue(kValue));
   for (size_t i = 0; i < kNotCorruptKeysSize; ++i) {
     ASSERT_TRUE(store()
                     ->Set(ValueStore::DEFAULTS, kNotCorruptKeys[i], *value)
                     ->status().ok());
   }
 
   // Insert a few corrupted pairs.
   leveldb::WriteBatch batch;
   batch.Put(kCorruptKey1, kCorruptValue);
   batch.Put(kCorruptKey2, kCorruptValue);
@@ skipping 25 matching lines @@
 // Full corruption has been known to happen occasionally in strange edge cases,
 // such as after users use Windows Restore. We can't prevent it, but we need to
 // be able to handle it smoothly.
 TEST_F(LeveldbValueStoreUnitTest, RestoreFullDatabase) {
   const std::string kLolCats("I can haz leveldb filez?");
   const char* kNotCorruptKeys[] = {"a", "n", "z"};
   const size_t kNotCorruptKeysSize = 3u;
   const char kValue[] = "value";
 
   // Generate a database.
-  scoped_ptr<base::Value> value(new base::StringValue(kValue));
+  std::unique_ptr<base::Value> value(new base::StringValue(kValue));
   for (size_t i = 0; i < kNotCorruptKeysSize; ++i) {
     ASSERT_TRUE(store()
                     ->Set(ValueStore::DEFAULTS, kNotCorruptKeys[i], *value)
                     ->status().ok());
   }
 
   // Close it (so we remove the lock), and replace all files with LolCats.
   CloseStore();
   base::FileEnumerator enumerator(
       database_path(), true /* recursive */, base::FileEnumerator::FILES);
   for (base::FilePath file = enumerator.Next(); !file.empty();
        file = enumerator.Next()) {
     // WriteFile() failure is a result of -1.
     ASSERT_NE(base::WriteFile(file, kLolCats.c_str(), kLolCats.length()), -1);
   }
   CreateStore();
 
   // We couldn't recover anything, but we should be in a sane state again.
   ValueStore::ReadResult result = store()->Get();
   ASSERT_EQ(ValueStore::DB_RESTORE_REPAIR_SUCCESS,
             result->status().restore_status);
   EXPECT_TRUE(result->status().ok());
   EXPECT_EQ(0u, result->settings().size());
 }