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

extensions/browser/api/declarative/deduping_factory_unittest.cc

 // 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.
 
 #include "extensions/browser/api/declarative/deduping_factory.h"
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kTypeName[] = "Foo";
 const char kTypeName2[] = "Foo2";
 
 // This serves as an example how to use the DedupingFactory.
 class BaseClass : public base::RefCounted<BaseClass> {
@@ skipping 46 matching lines @@
   CHECK(value->GetAsDictionary(&dict));
   int parameter = 0;
   if (!dict->GetInteger("parameter", &parameter)) {
     *error = "No parameter";
     *bad_message = true;
     return scoped_refptr<const BaseClass>(NULL);
   }
   return scoped_refptr<const BaseClass>(new Foo(parameter));
 }
 
-scoped_ptr<base::DictionaryValue> CreateDictWithParameter(int parameter) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue> CreateDictWithParameter(int parameter) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   dict->SetInteger("parameter", parameter);
   return dict;
 }
 
 }  // namespace
 
 namespace extensions {
 
 TEST(DedupingFactoryTest, InstantiationParameterized) {
   DedupingFactory<BaseClass> factory(2);
   factory.RegisterFactoryMethod(
       kTypeName, DedupingFactory<BaseClass>::IS_PARAMETERIZED, &CreateFoo);
 
-  scoped_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
-  scoped_ptr<base::DictionaryValue> d2(CreateDictWithParameter(2));
-  scoped_ptr<base::DictionaryValue> d3(CreateDictWithParameter(3));
-  scoped_ptr<base::DictionaryValue> d4(CreateDictWithParameter(4));
+  std::unique_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
+  std::unique_ptr<base::DictionaryValue> d2(CreateDictWithParameter(2));
+  std::unique_ptr<base::DictionaryValue> d3(CreateDictWithParameter(3));
+  std::unique_ptr<base::DictionaryValue> d4(CreateDictWithParameter(4));
 
   std::string error;
   bool bad_message = false;
 
   // Fill factory with 2 different types.
   scoped_refptr<const BaseClass> c1(
       factory.Instantiate(kTypeName, d1.get(), &error, &bad_message));
   scoped_refptr<const BaseClass> c2(
       factory.Instantiate(kTypeName, d2.get(), &error, &bad_message));
   ASSERT_TRUE(c1.get());
@@ skipping 23 matching lines @@
       factory.Instantiate(kTypeName, d2.get(), &error, &bad_message));
   EXPECT_EQ(2, static_cast<const Foo*>(c2_c.get())->parameter());
   EXPECT_EQ(c2, c2_c);
 }
 
 TEST(DedupingFactoryTest, InstantiationNonParameterized) {
   DedupingFactory<BaseClass> factory(2);
   factory.RegisterFactoryMethod(
       kTypeName, DedupingFactory<BaseClass>::IS_NOT_PARAMETERIZED, &CreateFoo);
 
-  scoped_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
-  scoped_ptr<base::DictionaryValue> d2(CreateDictWithParameter(2));
+  std::unique_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
+  std::unique_ptr<base::DictionaryValue> d2(CreateDictWithParameter(2));
 
   std::string error;
   bool bad_message = false;
 
   // We create two instances with different dictionaries but because the type is
   // declared to be not parameterized, we should get the same instance.
   scoped_refptr<const BaseClass> c1(
       factory.Instantiate(kTypeName, d1.get(), &error, &bad_message));
   scoped_refptr<const BaseClass> c2(
       factory.Instantiate(kTypeName, d2.get(), &error, &bad_message));
   ASSERT_TRUE(c1.get());
   ASSERT_TRUE(c2.get());
   EXPECT_EQ(1, static_cast<const Foo*>(c1.get())->parameter());
   EXPECT_EQ(1, static_cast<const Foo*>(c2.get())->parameter());
   EXPECT_EQ(c1, c2);
 }
 
 TEST(DedupingFactoryTest, TypeNames) {
   DedupingFactory<BaseClass> factory(2);
   factory.RegisterFactoryMethod(
       kTypeName, DedupingFactory<BaseClass>::IS_PARAMETERIZED, &CreateFoo);
   factory.RegisterFactoryMethod(
       kTypeName2, DedupingFactory<BaseClass>::IS_PARAMETERIZED, &CreateFoo);
 
-  scoped_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
+  std::unique_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
 
   std::string error;
   bool bad_message = false;
 
   scoped_refptr<const BaseClass> c1_a(
       factory.Instantiate(kTypeName, d1.get(), &error, &bad_message));
   scoped_refptr<const BaseClass> c1_b(
       factory.Instantiate(kTypeName2, d1.get(), &error, &bad_message));
 
   ASSERT_TRUE(c1_a.get());
   ASSERT_TRUE(c1_b.get());
   EXPECT_NE(c1_a, c1_b);
 }
 
 TEST(DedupingFactoryTest, Clear) {
   DedupingFactory<BaseClass> factory(2);
   factory.RegisterFactoryMethod(
       kTypeName, DedupingFactory<BaseClass>::IS_PARAMETERIZED, &CreateFoo);
 
-  scoped_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
+  std::unique_ptr<base::DictionaryValue> d1(CreateDictWithParameter(1));
 
   std::string error;
   bool bad_message = false;
 
   scoped_refptr<const BaseClass> c1_a(
       factory.Instantiate(kTypeName, d1.get(), &error, &bad_message));
 
   factory.ClearPrototypes();
 
   scoped_refptr<const BaseClass> c1_b(
       factory.Instantiate(kTypeName, d1.get(), &error, &bad_message));
 
   ASSERT_TRUE(c1_a.get());
   ASSERT_TRUE(c1_b.get());
   EXPECT_NE(c1_a, c1_b);
 }
 
 }  // namespace extensions