[Extensions] Remove linked_ptr entirely from extensions generated code

chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_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_webrequest/webrequest_rules_registry.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 108 matching lines @@
     https_condition_url_filter.Set(keys::kUrlKey, https_condition_dict);
     https_condition_url_filter.SetString(keys::kInstanceTypeKey,
                                          keys::kRequestMatcherType);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kCancelRequestType);
 
     linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId1));
     rule->priority.reset(new int(100));
-    rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
-    rule->conditions.push_back(
-        linked_ptr<base::Value>(http_condition_url_filter.DeepCopy()));
-    rule->conditions.push_back(
-        linked_ptr<base::Value>(https_condition_url_filter.DeepCopy()));
+    rule->actions.push_back(action_dict.CreateDeepCopy());
+    rule->conditions.push_back(http_condition_url_filter.CreateDeepCopy());
+    rule->conditions.push_back(https_condition_url_filter.CreateDeepCopy());
     return rule;
   }
 
   // Returns a rule that matches anything and cancels it.
   linked_ptr<api::events::Rule> CreateRule2() {
     base::DictionaryValue condition_dict;
     condition_dict.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kCancelRequestType);
 
     linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId2));
     rule->priority.reset(new int(100));
-    rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
-    rule->conditions.push_back(
-        linked_ptr<base::Value>(condition_dict.DeepCopy()));
+    rule->actions.push_back(action_dict.CreateDeepCopy());
+    rule->conditions.push_back(condition_dict.CreateDeepCopy());
     return rule;
   }
 
   linked_ptr<api::events::Rule> CreateRedirectRule(
       const std::string& destination) {
     base::DictionaryValue condition_dict;
     condition_dict.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kRedirectRequestType);
     action_dict.SetString(keys::kRedirectUrlKey, destination);
 
     linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId3));
     rule->priority.reset(new int(100));
-    rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
-    rule->conditions.push_back(
-        linked_ptr<base::Value>(condition_dict.DeepCopy()));
+    rule->actions.push_back(action_dict.CreateDeepCopy());
+    rule->conditions.push_back(condition_dict.CreateDeepCopy());
     return rule;
   }
 
   // Create a rule to ignore all other rules for a destination that
   // contains index.html.
   linked_ptr<api::events::Rule> CreateIgnoreRule() {
     base::DictionaryValue condition_dict;
     base::DictionaryValue* http_condition_dict = new base::DictionaryValue();
     http_condition_dict->SetString(keys2::kPathContainsKey, "index.html");
     condition_dict.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
     condition_dict.Set(keys::kUrlKey, http_condition_dict);
 
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kIgnoreRulesType);
     action_dict.SetInteger(keys::kLowerPriorityThanKey, 150);
 
     linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(kRuleId4));
     rule->priority.reset(new int(200));
-    rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
-    rule->conditions.push_back(
-        linked_ptr<base::Value>(condition_dict.DeepCopy()));
+    rule->actions.push_back(action_dict.CreateDeepCopy());
+    rule->conditions.push_back(condition_dict.CreateDeepCopy());
     return rule;
   }
 
   // Create a condition with the attributes specified. An example value of
   // |attributes| is: "\"resourceType\": [\"stylesheet\"], \n".
-  linked_ptr<base::Value> CreateCondition(const std::string& attributes) {
+  scoped_ptr<base::Value> CreateCondition(const std::string& attributes) {
     std::string json_description =
         "{ \n"
         "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n";
     json_description += attributes;
     json_description += "}";
 
-    return linked_ptr<base::Value>(
-        base::test::ParseJson(json_description).release());
+    return base::test::ParseJson(json_description);
   }
 
   // Create a rule with the ID |rule_id| and with conditions created from the
   // |attributes| specified (one entry one condition). An example value of a
   // string from |attributes| is: "\"resourceType\": [\"stylesheet\"], \n".
   linked_ptr<api::events::Rule> CreateCancellingRule(
       const char* rule_id,
       const std::vector<const std::string*>& attributes) {
     base::DictionaryValue action_dict;
     action_dict.SetString(keys::kInstanceTypeKey, keys::kCancelRequestType);
 
     linked_ptr<api::events::Rule> rule(new api::events::Rule);
     rule->id.reset(new std::string(rule_id));
     rule->priority.reset(new int(1));
-    rule->actions.push_back(linked_ptr<base::Value>(action_dict.DeepCopy()));
+    rule->actions.push_back(action_dict.CreateDeepCopy());
     for (std::vector<const std::string*>::const_iterator it =
              attributes.begin();
          it != attributes.end(); ++it)
       rule->conditions.push_back(CreateCondition(**it));
     return rule;
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   content::TestBrowserThread ui_;
@@ skipping 499 matching lines @@
 TEST(WebRequestRulesRegistrySimpleTest, HostPermissionsChecker) {
   const char kAction[] =  // This action requires all URLs host permission.
       "{                                                             \n"
       "  \"instanceType\": \"declarativeWebRequest.RedirectRequest\",\n"
       "  \"redirectUrl\": \"http://bar.com\"                         \n"
       "}                                                             ";
   scoped_ptr<base::Value> action_value = base::JSONReader::Read(kAction);
   ASSERT_TRUE(action_value);
 
   WebRequestActionSet::Values actions;
-  actions.push_back(linked_ptr<base::Value>(action_value.release()));
+  actions.push_back(std::move(action_value));
   ASSERT_TRUE(actions.back().get());
 
   std::string error;
   bool bad_message = false;
   scoped_ptr<WebRequestActionSet> action_set(
       WebRequestActionSet::Create(NULL, NULL, actions, &error, &bad_message));
   ASSERT_TRUE(error.empty()) << error;
   ASSERT_FALSE(bad_message);
   ASSERT_TRUE(action_set);
 
@@ skipping 66 matching lines @@
   // This is a correct match.
   GURL url2("http://foo.com/index.html");
   scoped_ptr<net::URLRequest> request2(context.CreateRequest(
       url2, net::DEFAULT_PRIORITY, NULL));
   WebRequestData request_data2(request2.get(), ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data2, false);
   EXPECT_EQ(1u, deltas.size());
 }
 
 }  // namespace extensions