Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

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 <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension_test_util.h"
 #include "components/url_matcher/url_matcher_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/browser/api/declarative/rules_registry_service.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
@@ skipping 68 matching lines @@
   void SetUp() override;
 
   void TearDown() override {
     // Make sure that deletion traits of all registries are executed.
     base::RunLoop().RunUntilIdle();
   }
 
   // Returns a rule that roughly matches http://*.example.com and
   // https://www.example.com and cancels it
   linked_ptr<api::events::Rule> CreateRule1() {
-    base::ListValue* scheme_http = new base::ListValue();
+    auto scheme_http = base::MakeUnique<base::ListValue>();
     scheme_http->AppendString("http");
-    base::DictionaryValue* http_condition_dict = new base::DictionaryValue();
-    http_condition_dict->Set(keys2::kSchemesKey, scheme_http);
+    auto http_condition_dict = base::MakeUnique<base::DictionaryValue>();
     http_condition_dict->SetString(keys2::kHostSuffixKey, "example.com");
     base::DictionaryValue http_condition_url_filter;
-    http_condition_url_filter.Set(keys::kUrlKey, http_condition_dict);
     http_condition_url_filter.SetString(keys::kInstanceTypeKey,
                                         keys::kRequestMatcherType);
 
-    base::ListValue* scheme_https = new base::ListValue();
     scheme_http->AppendString("https");
-    base::DictionaryValue* https_condition_dict = new base::DictionaryValue();
-    https_condition_dict->Set(keys2::kSchemesKey, scheme_https);
+    auto https_condition_dict = base::MakeUnique<base::DictionaryValue>();
+    https_condition_dict->Set(keys2::kSchemesKey,
+                              base::MakeUnique<base::ListValue>());
     https_condition_dict->SetString(keys2::kHostSuffixKey, "example.com");
     https_condition_dict->SetString(keys2::kHostPrefixKey, "www");
     base::DictionaryValue https_condition_url_filter;
-    https_condition_url_filter.Set(keys::kUrlKey, https_condition_dict);
+    https_condition_url_filter.Set(keys::kUrlKey,
+                                   std::move(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(action_dict.CreateDeepCopy());
+    http_condition_dict->Set(keys2::kSchemesKey, std::move(scheme_http));
+    http_condition_url_filter.Set(keys::kUrlKey,
+                                  std::move(http_condition_dict));
     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);
 
@@ skipping 22 matching lines @@
     rule->priority.reset(new int(100));
     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();
+    auto http_condition_dict = base::MakeUnique<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);
+    condition_dict.Set(keys::kUrlKey, std::move(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(action_dict.CreateDeepCopy());
     rule->conditions.push_back(condition_dict.CreateDeepCopy());
@@ skipping 625 matching lines @@
   // This is a correct match.
   GURL url2("http://foo.com/index.html");
   std::unique_ptr<net::URLRequest> request2(context.CreateRequest(
       url2, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
   WebRequestData request_data2(request2.get(), ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data2, false);
   EXPECT_EQ(1u, deltas.size());
 }
 
 }  // namespace extensions