[Extensions] Remove linked_ptr entirely from extensions generated code

extensions/browser/api/declarative/declarative_rule_unittest.cc

 // Copyright (c) 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/declarative_rule.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "components/url_matcher/url_matcher_constants.h"
 #include "extensions/common/extension_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::test::ParseJson;
 using url_matcher::URLMatcher;
 using url_matcher::URLMatcherConditionFactory;
 using url_matcher::URLMatcherConditionSet;
 
 namespace extensions {
 
 namespace {
 
-template<typename T>
-linked_ptr<T> ScopedToLinkedPtr(scoped_ptr<T> ptr) {
-  return linked_ptr<T>(ptr.release());
-}
-
 scoped_ptr<base::DictionaryValue> SimpleManifest() {
   return DictionaryBuilder()
       .Set("name", "extension")
       .Set("manifest_version", 2)
       .Set("version", "1.0")
       .Build();
 }
 
 }  // namespace
 
@@ skipping 23 matching lines @@
     result->factory = url_matcher_condition_factory;
     result->value.reset(condition.DeepCopy());
     return result;
   }
 };
 typedef DeclarativeConditionSet<RecordingCondition> RecordingConditionSet;
 
 TEST(DeclarativeConditionTest, ErrorConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::Values conditions;
-  conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"key\": 1}")));
-  conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"bad_key\": 2}")));
+  conditions.push_back(ParseJson("{\"key\": 1}"));
+  conditions.push_back(ParseJson("{\"bad_key\": 2}"));
 
   std::string error;
   scoped_ptr<RecordingConditionSet> result = RecordingConditionSet::Create(
       NULL, matcher.condition_factory(), conditions, &error);
   EXPECT_EQ("Found error key", error);
   ASSERT_FALSE(result);
 }
 
 TEST(DeclarativeConditionTest, CreateConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::Values conditions;
-  conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"key\": 1}")));
-  conditions.push_back(ScopedToLinkedPtr(ParseJson("[\"val1\", 2]")));
+  conditions.push_back(ParseJson("{\"key\": 1}"));
+  conditions.push_back(ParseJson("[\"val1\", 2]"));
 
   // Test insertion
   std::string error;
   scoped_ptr<RecordingConditionSet> result = RecordingConditionSet::Create(
       NULL, matcher.condition_factory(), conditions, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->conditions().size());
 
   EXPECT_EQ(matcher.condition_factory(), result->conditions()[0]->factory);
@@ skipping 52 matching lines @@
           result->condition_set_id,
           URLMatcherConditionSet::Conditions());
     }
     return result;
   }
 };
 
 TEST(DeclarativeConditionTest, FulfillConditionSet) {
   typedef DeclarativeConditionSet<FulfillableCondition> FulfillableConditionSet;
   FulfillableConditionSet::Values conditions;
-  conditions.push_back(ScopedToLinkedPtr(ParseJson(
-      "{\"url_id\": 1, \"max\": 3}")));
-  conditions.push_back(ScopedToLinkedPtr(ParseJson(
-      "{\"url_id\": 2, \"max\": 5}")));
-  conditions.push_back(ScopedToLinkedPtr(ParseJson(
-      "{\"url_id\": 3, \"max\": 1}")));
-  conditions.push_back(ScopedToLinkedPtr(ParseJson(
-      "{\"max\": -5}")));  // No url.
+  conditions.push_back(ParseJson("{\"url_id\": 1, \"max\": 3}"));
+  conditions.push_back(ParseJson("{\"url_id\": 2, \"max\": 5}"));
+  conditions.push_back(ParseJson("{\"url_id\": 3, \"max\": 1}"));
+  conditions.push_back(ParseJson("{\"max\": -5}"));  // No url.
 
   // Test insertion
   std::string error;
   scoped_ptr<FulfillableConditionSet> result =
       FulfillableConditionSet::Create(NULL, NULL, conditions, &error);
   ASSERT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(4u, result->conditions().size());
 
   std::set<URLMatcherConditionSet::ID> url_matches;
@@ skipping 79 matching lines @@
   friend class base::RefCounted<SummingAction>;
   virtual ~SummingAction() {}
 
   int increment_;
   int min_priority_;
 };
 typedef DeclarativeActionSet<SummingAction> SummingActionSet;
 
 TEST(DeclarativeActionTest, ErrorActionSet) {
   SummingActionSet::Values actions;
-  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 1}")));
-  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"error\": \"the error\"}")));
+  actions.push_back(ParseJson("{\"value\": 1}"));
+  actions.push_back(ParseJson("{\"error\": \"the error\"}"));
 
   std::string error;
   bool bad = false;
   scoped_ptr<SummingActionSet> result =
       SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
   EXPECT_EQ("the error", error);
   EXPECT_FALSE(bad);
   EXPECT_FALSE(result);
 
   actions.clear();
-  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 1}")));
-  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"bad\": 3}")));
+  actions.push_back(ParseJson("{\"value\": 1}"));
+  actions.push_back(ParseJson("{\"bad\": 3}"));
   result = SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_TRUE(bad);
   EXPECT_FALSE(result);
 }
 
 TEST(DeclarativeActionTest, ApplyActionSet) {
   SummingActionSet::Values actions;
-  actions.push_back(ScopedToLinkedPtr(ParseJson(
-      "{\"value\": 1,"
-      " \"priority\": 5}")));
-  actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 2}")));
+  actions.push_back(
+      ParseJson("{\"value\": 1,"
+                " \"priority\": 5}"));
+  actions.push_back(ParseJson("{\"value\": 2}"));
 
   // Test insertion
   std::string error;
   bool bad = false;
   scoped_ptr<SummingActionSet> result =
       SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->actions().size());
@@ skipping 130 matching lines @@
                       extension.get(),
                       base::Time(),
                       json_rule,
                       base::Bind(AtLeastOneCondition),
                       &error);
   EXPECT_FALSE(rule);
   EXPECT_EQ("No conditions", error);
 }
 
 }  // namespace extensions