Re-write many calls to WrapUnique() with MakeUnique()

extensions/renderer/event_bindings.cc

 // Copyright 2014 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/renderer/event_bindings.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
@@ skipping 108 matching lines @@
 // Add a filter to |event_name| in |extension_id|, returning true if it
 // was the first filter for that event in that extension.
 bool AddFilter(const std::string& event_name,
                const std::string& extension_id,
                const base::DictionaryValue& filter) {
   FilteredEventListenerKey key(extension_id, event_name);
   FilteredEventListenerCounts& all_counts = g_filtered_listener_counts.Get();
   FilteredEventListenerCounts::const_iterator counts = all_counts.find(key);
   if (counts == all_counts.end()) {
     counts =
-        all_counts
-            .insert(std::make_pair(key, base::WrapUnique(new ValueCounter())))
+        all_counts.insert(std::make_pair(key, base::MakeUnique<ValueCounter>()))
             .first;
   }
   return counts->second->Add(filter);
 }
 
 // Remove a filter from |event_name| in |extension_id|, returning true if it
 // was the last filter for that event in that extension.
 bool RemoveFilter(const std::string& event_name,
                   const std::string& extension_id,
                   base::DictionaryValue* filter) {
@@ skipping 199 matching lines @@
   for (MatcherIDs::iterator it = matched_event_filters.begin();
        it != matched_event_filters.end();
        ++it) {
     array->Set(v8::Integer::New(isolate, i++), v8::Integer::New(isolate, *it));
   }
   args.GetReturnValue().Set(array);
 }
 
 std::unique_ptr<EventMatcher> EventBindings::ParseEventMatcher(
     std::unique_ptr<base::DictionaryValue> filter) {
-  return base::WrapUnique(new EventMatcher(
-      std::move(filter), context()->GetRenderFrame()->GetRoutingID()));
+  return base::MakeUnique<EventMatcher>(
+      std::move(filter), context()->GetRenderFrame()->GetRoutingID());
 }
 
 void EventBindings::OnInvalidated() {
   // Detach all attached events that weren't attached. Iterate over a copy
   // because it will be mutated.
   std::set<std::string> attached_event_names_safe = attached_event_names_;
   for (const std::string& event_name : attached_event_names_safe) {
     DetachEvent(event_name, false /* is_manual */);
   }
   DCHECK(attached_event_names_.empty())
       << "Events cannot be attached during invalidation";
 
   // Same for filtered events.
   std::set<int> attached_matcher_ids_safe = attached_matcher_ids_;
   for (int matcher_id : attached_matcher_ids_safe) {
     DetachFilteredEvent(matcher_id, false /* is_manual */);
   }
   DCHECK(attached_matcher_ids_.empty())
       << "Filtered events cannot be attached during invalidation";
 }
 
 }  // namespace extensions