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

extensions/browser/api/declarative/rules_registry_unittest.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 "extensions/browser/api/declarative/rules_registry.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 110 matching lines @@
 
   std::vector<linked_ptr<api::events::Rule>> get_rules_4b;
   registry->GetAllRules(kExtensionId, &get_rules_4b);
 
   ASSERT_EQ(1u, get_rules_4b.size());
 
   ASSERT_TRUE(get_rules_4b[0]->id.get());
   EXPECT_EQ(kRuleId, *get_rules_4b[0]->id);
 
   // Create extension
-  scoped_ptr<base::DictionaryValue> manifest = ParseDictionary(
+  std::unique_ptr<base::DictionaryValue> manifest = ParseDictionary(
       "{"
       "  \"name\": \"Test\","
       "  \"version\": \"1\""
       "}");
   scoped_refptr<Extension> extension = ExtensionBuilder()
                                            .SetManifest(std::move(manifest))
                                            .SetID(kExtensionId)
                                            .Build();
   registry->OnExtensionUninstalled(extension.get());
   EXPECT_EQ(0u /*extensions*/ + 0u /*rules*/,
@@ skipping 39 matching lines @@
   registry = NULL;
   message_loop.RunUntilIdle();
 }
 
 // Test verifies 2 rules defined in the manifest appear in the registry.
 TEST(RulesRegistryTest, TwoRulesInManifest) {
   base::MessageLoopForUI message_loop;
   content::TestBrowserThread thread(content::BrowserThread::UI, &message_loop);
 
   // Create extension
-  scoped_ptr<base::DictionaryValue> manifest = ParseDictionary(
+  std::unique_ptr<base::DictionaryValue> manifest = ParseDictionary(
       "{"
       "  \"name\": \"Test\","
       "  \"version\": \"1\","
       "  \"event_rules\": ["
       "    {"
       "      \"id\": \"000\","
       "      \"priority\": 200,"
       "      \"tags\": [\"tagged\"],"
       "      \"event\": \"declarativeContent.onPageChanged\","
       "      \"actions\": [{"
@@ skipping 23 matching lines @@
 
   scoped_refptr<RulesRegistry> registry = new TestRulesRegistry(
       content::BrowserThread::UI, "declarativeContent.onPageChanged", key);
   // Simulate what RulesRegistryService would do on extension load.
   registry->OnExtensionLoaded(extension.get());
 
   std::vector<linked_ptr<api::events::Rule>> get_rules;
   registry->GetAllRules(kExtensionId, &get_rules);
 
   ASSERT_EQ(2u, get_rules.size());
-  scoped_ptr<base::DictionaryValue> expected_rule_0 = ParseDictionary(
+  std::unique_ptr<base::DictionaryValue> expected_rule_0 = ParseDictionary(
       "{"
       "  \"id\": \"000\","
       "  \"priority\": 200,"
       "  \"tags\": [\"tagged\"],"
       "  \"actions\": [{"
       "    \"instanceType\": \"declarativeContent.ShowPageAction\""
       "  }],"
       "  \"conditions\" : [{"
       "    \"css\": [\"video\"],"
       "    \"instanceType\" : \"declarativeContent.PageStateMatcher\""
       "  }]"
       "}");
   EXPECT_TRUE(expected_rule_0->Equals(get_rules[0]->ToValue().get()));
 
-  scoped_ptr<base::DictionaryValue> expected_rule_1 = ParseDictionary(
+  std::unique_ptr<base::DictionaryValue> expected_rule_1 = ParseDictionary(
       "{"
       "  \"id\": \"_0_\","
       "  \"priority\": 100,"
       "  \"actions\": [{"
       "    \"instanceType\": \"declarativeContent.ShowPageAction\""
       "  }],"
       "  \"conditions\" : [{"
       "    \"css\": [\"input[type='password']\"],"
       "    \"instanceType\" : \"declarativeContent.PageStateMatcher\""
       "  }]"
       "}");
   EXPECT_TRUE(expected_rule_1->Equals(get_rules[1]->ToValue().get()));
 }
 
 // Tests verifies that rules defined in the manifest cannot be deleted but
 // programmatically added rules still can be deleted.
 TEST(RulesRegistryTest, DeleteRuleInManifest) {
   base::MessageLoopForUI message_loop;
   content::TestBrowserThread thread(content::BrowserThread::UI, &message_loop);
 
   // Create extension
-  scoped_ptr<base::DictionaryValue> manifest = ParseDictionary(
+  std::unique_ptr<base::DictionaryValue> manifest = ParseDictionary(
       "{"
       "  \"name\": \"Test\","
       "  \"version\": \"1\","
       "  \"event_rules\": [{"
       "    \"id\":  \"manifest_rule_0\","
       "    \"event\": \"declarativeContent.onPageChanged\","
       "    \"actions\": [{"
       "      \"type\": \"declarativeContent.ShowPageAction\""
       "    }],"
       "    \"conditions\" : [{"
@@ skipping 50 matching lines @@
 
   // Remove all rules.
   registry->RemoveAllRules(kExtensionId);
   get_rules.clear();
   registry->GetAllRules(kExtensionId, &get_rules);
   ASSERT_EQ(1u, get_rules.size());
   EXPECT_EQ("manifest_rule_0", *(get_rules[0]->id));
 }
 
 }  // namespace extensions