Remove raw base::DictionaryValue::Set in //extensions

extensions/common/event_filter_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/common/event_filter.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 14 matching lines @@
  public:
   EventFilterUnittest() {
     google_event_.SetURL(GURL("http://google.com"));
     yahoo_event_.SetURL(GURL("http://yahoo.com"));
     random_url_event_.SetURL(GURL("http://www.something-else.com"));
     empty_url_event_.SetURL(GURL());
   }
 
  protected:
   std::unique_ptr<base::Value> HostSuffixDict(const std::string& host_suffix) {
-    std::unique_ptr<base::DictionaryValue> dict(new DictionaryValue());
-    dict->Set("hostSuffix", new base::Value(host_suffix));
-    return std::unique_ptr<base::Value>(dict.release());
+    auto dict = base::MakeUnique<DictionaryValue>();
+    dict->SetString("hostSuffix", host_suffix);
+    return std::move(dict);
   }
 
   std::unique_ptr<base::ListValue> ValueAsList(
       std::unique_ptr<base::Value> value) {
-    std::unique_ptr<base::ListValue> result(new base::ListValue());
+    auto result = base::MakeUnique<base::ListValue>();
     result->Append(std::move(value));
     return result;
   }
 
   std::unique_ptr<EventMatcher> AllURLs() {
-    return std::unique_ptr<EventMatcher>(
-        new EventMatcher(std::unique_ptr<DictionaryValue>(new DictionaryValue),
-                         MSG_ROUTING_NONE));
+    return base::MakeUnique<EventMatcher>(
+        base::MakeUnique<base::DictionaryValue>(), MSG_ROUTING_NONE);
   }
 
   std::unique_ptr<EventMatcher> HostSuffixMatcher(
       const std::string& host_suffix) {
     return MatcherFromURLFilterList(ValueAsList(HostSuffixDict(host_suffix)));
   }
 
   std::unique_ptr<EventMatcher> MatcherFromURLFilterList(
       std::unique_ptr<ListValue> url_filter_list) {
-    std::unique_ptr<DictionaryValue> filter_dict(new DictionaryValue);
-    filter_dict->Set("url", url_filter_list.release());
+    auto filter_dict = base::MakeUnique<DictionaryValue>();
+    filter_dict->Set("url", std::move(url_filter_list));
     return std::unique_ptr<EventMatcher>(
         new EventMatcher(std::move(filter_dict), MSG_ROUTING_NONE));
   }
 
   EventFilter event_filter_;
   EventFilteringInfo empty_event_;
   EventFilteringInfo google_event_;
   EventFilteringInfo yahoo_event_;
   EventFilteringInfo random_url_event_;
   EventFilteringInfo empty_url_event_;
@@ skipping 186 matching lines @@
   std::unique_ptr<EventMatcher> matcher(MatcherFromURLFilterList(
       ValueAsList(std::unique_ptr<Value>(new DictionaryValue()))));
   int id = event_filter_.AddEventMatcher("event1", std::move(matcher));
   std::set<int> matches = event_filter_.MatchEvent(
       "event1", empty_url_event_, MSG_ROUTING_NONE);
   ASSERT_EQ(1u, matches.size());
   ASSERT_EQ(1u, matches.count(id));
 }
 
 }  // namespace extensions