Convert //extensions/renderer from scoped_ptr to std::unique_ptr

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>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/event_filter.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/value_counter.h"
 #include "extensions/renderer/extension_frame_helper.h"
@@ skipping 12 matching lines @@
 // A map of extension IDs to listener counts for that extension.
 base::LazyInstance<std::map<std::string, EventListenerCounts>>
     g_listener_counts = LAZY_INSTANCE_INITIALIZER;
 
 // A map of (extension ID, event name) pairs to the filtered listener counts
 // for that pair. The map is used to keep track of which filters are in effect
 // for which events.  We notify the browser about filtered event listeners when
 // we transition between 0 and 1.
 using FilteredEventListenerKey = std::pair<std::string, std::string>;
 using FilteredEventListenerCounts =
-    std::map<FilteredEventListenerKey, scoped_ptr<ValueCounter>>;
+    std::map<FilteredEventListenerKey, std::unique_ptr<ValueCounter>>;
 base::LazyInstance<FilteredEventListenerCounts> g_filtered_listener_counts =
     LAZY_INSTANCE_INITIALIZER;
 
 base::LazyInstance<EventFilter> g_event_filter = LAZY_INSTANCE_INITIALIZER;
 
 // Gets a unique string key identifier for a ScriptContext.
 // TODO(kalman): Just use pointer equality...?
 std::string GetKeyForScriptContext(ScriptContext* script_context) {
   const std::string& extension_id = script_context->GetExtensionID();
   CHECK(crx_file::id_util::IdIsValid(extension_id) ||
@@ skipping 59 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, make_scoped_ptr(new ValueCounter())))
-                 .first;
+    counts =
+        all_counts
+            .insert(std::make_pair(key, base::WrapUnique(new 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) {
   FilteredEventListenerKey key(extension_id, event_name);
@@ skipping 110 matching lines @@
 void EventBindings::AttachFilteredEvent(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsString());
   CHECK(args[1]->IsObject());
 
   std::string event_name = *v8::String::Utf8Value(args[0]);
   if (!context()->HasAccessOrThrowError(event_name))
     return;
 
-  scoped_ptr<base::DictionaryValue> filter;
+  std::unique_ptr<base::DictionaryValue> filter;
   {
-    scoped_ptr<content::V8ValueConverter> converter(
+    std::unique_ptr<content::V8ValueConverter> converter(
         content::V8ValueConverter::create());
-    scoped_ptr<base::Value> filter_value(converter->FromV8Value(
+    std::unique_ptr<base::Value> filter_value(converter->FromV8Value(
         v8::Local<v8::Object>::Cast(args[1]), context()->v8_context()));
     if (!filter_value || !filter_value->IsType(base::Value::TYPE_DICTIONARY)) {
       args.GetReturnValue().Set(static_cast<int32_t>(-1));
       return;
     }
     filter = base::DictionaryValue::From(std::move(filter_value));
   }
 
   // Hold onto a weak reference to |filter| so that it can be used after passing
   // ownership to |event_filter|.
@@ skipping 57 matching lines @@
       v8::Array::New(isolate, matched_event_filters.size()));
   int i = 0;
   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);
 }
 
-scoped_ptr<EventMatcher> EventBindings::ParseEventMatcher(
-    scoped_ptr<base::DictionaryValue> filter) {
-  return make_scoped_ptr(new EventMatcher(
+std::unique_ptr<EventMatcher> EventBindings::ParseEventMatcher(
+    std::unique_ptr<base::DictionaryValue> filter) {
+  return base::WrapUnique(new 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