Modernize some extensions code.

extensions/browser/event_router_unittest.cc

 // Copyright 2013 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/event_router.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 19 matching lines @@
 namespace extensions {
 
 namespace {
 
 // A simple mock to keep track of listener additions and removals.
 class MockEventRouterObserver : public EventRouter::Observer {
  public:
   MockEventRouterObserver()
       : listener_added_count_(0),
         listener_removed_count_(0) {}
-  virtual ~MockEventRouterObserver() {}
+  ~MockEventRouterObserver() override {}
 
   int listener_added_count() const { return listener_added_count_; }
   int listener_removed_count() const { return listener_removed_count_; }
   const std::string& last_event_name() const { return last_event_name_; }
 
   void Reset() {
     listener_added_count_ = 0;
     listener_removed_count_ = 0;
     last_event_name_.clear();
   }
@@ skipping 10 matching lines @@
   }
 
  private:
   int listener_added_count_;
   int listener_removed_count_;
   std::string last_event_name_;
 
   DISALLOW_COPY_AND_ASSIGN(MockEventRouterObserver);
 };
 
-typedef base::Callback<std::unique_ptr<EventListener>(
-    const std::string&,           // event_name
-    content::RenderProcessHost*,  // process
-    base::DictionaryValue*        // filter (takes ownership)
-    )>
-    EventListenerConstructor;
+using EventListenerConstructor = base::Callback<std::unique_ptr<EventListener>(
+    const std::string& /* event_name */,
+    content::RenderProcessHost* /* process */,
+    std::unique_ptr<base::DictionaryValue> /* filter */)>;
 
 std::unique_ptr<EventListener> CreateEventListenerForExtension(
     const std::string& extension_id,
     const std::string& event_name,
     content::RenderProcessHost* process,
-    base::DictionaryValue* filter) {
+    std::unique_ptr<base::DictionaryValue> filter) {
   return EventListener::ForExtension(event_name, extension_id, process,
-                                     base::WrapUnique(filter));
+                                     std::move(filter));
 }
 
 std::unique_ptr<EventListener> CreateEventListenerForURL(
     const GURL& listener_url,
     const std::string& event_name,
     content::RenderProcessHost* process,
-    base::DictionaryValue* filter) {
+    std::unique_ptr<base::DictionaryValue> filter) {
   return EventListener::ForURL(event_name, listener_url, process,
-                               base::WrapUnique(filter));
+                               std::move(filter));
 }
 
 // Creates an extension.  If |component| is true, it is created as a component
 // extension.  If |persistent| is true, it is created with a persistent
 // background page; otherwise it is created with an event page.
 scoped_refptr<Extension> CreateExtension(bool component, bool persistent) {
   ExtensionBuilder builder;
   std::unique_ptr<base::DictionaryValue> manifest =
       base::MakeUnique<base::DictionaryValue>();
   manifest->SetString("name", "foo");
   manifest->SetString("version", "1.0.0");
   manifest->SetInteger("manifest_version", 2);
   manifest->SetString("background.page", "background.html");
   manifest->SetBoolean("background.persistent", persistent);
   builder.SetManifest(std::move(manifest));
   if (component)
     builder.SetLocation(Manifest::Location::COMPONENT);
 
   return builder.Build();
 }
 
 std::unique_ptr<DictionaryValue> CreateHostSuffixFilter(
     const std::string& suffix) {
-  std::unique_ptr<DictionaryValue> filter(new DictionaryValue());
-  std::unique_ptr<ListValue> filter_list(new ListValue());
-  std::unique_ptr<DictionaryValue> filter_dict(new DictionaryValue());
+  auto filter_dict = base::MakeUnique<DictionaryValue>();
+  filter_dict->Set("hostSuffix", base::MakeUnique<Value>(suffix));
 
-  filter_dict->Set("hostSuffix", base::MakeUnique<Value>(suffix));
+  auto filter_list = base::MakeUnique<ListValue>();
   filter_list->Append(std::move(filter_dict));
+
+  auto filter = base::MakeUnique<DictionaryValue>();
   filter->Set("url", std::move(filter_list));
-
   return filter;
 }
 
 }  // namespace
 
 class EventRouterTest : public ExtensionsTest {
  public:
   EventRouterTest() {}
 
  protected:
@@ skipping 46 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(EventRouterTest);
 };
 
 class EventRouterFilterTest : public ExtensionsTest {
  public:
   EventRouterFilterTest() {}
 
   void SetUp() override {
     ExtensionsTest::SetUp();
-    render_process_host_.reset(
-        new content::MockRenderProcessHost(browser_context()));
-    ASSERT_TRUE(EventRouter::Get(browser_context()));  // constructs EventRouter
+    render_process_host_ =
+        base::MakeUnique<content::MockRenderProcessHost>(browser_context());
+    ASSERT_TRUE(event_router());  // constructs EventRouter
   }
 
   void TearDown() override {
     render_process_host_.reset();
     ExtensionsTest::TearDown();
   }
 
   content::RenderProcessHost* render_process_host() const {
     return render_process_host_.get();
   }
@@ skipping 48 matching lines @@
   // Normal event names are passed through unchanged.
   EXPECT_EQ("foo.onBar", EventRouter::GetBaseEventName("foo.onBar"));
 
   // Sub-events are converted to the part before the slash.
   EXPECT_EQ("foo.onBar", EventRouter::GetBaseEventName("foo.onBar/123"));
 }
 
 // Tests adding and removing observers from EventRouter.
 void EventRouterTest::RunEventRouterObserverTest(
     const EventListenerConstructor& constructor) {
-  EventRouter router(NULL, NULL);
-  std::unique_ptr<EventListener> listener =
-      constructor.Run("event_name", NULL, new base::DictionaryValue());
+  EventRouter router(nullptr, nullptr);
+  std::unique_ptr<EventListener> listener = constructor.Run(
+      "event_name", nullptr, base::MakeUnique<base::DictionaryValue>());
 
   // Add/remove works without any observers.
   router.OnListenerAdded(listener.get());
   router.OnListenerRemoved(listener.get());
 
   // Register observers that both match and don't match the event above.
   MockEventRouterObserver matching_observer;
   router.RegisterObserver(&matching_observer, "event_name");
   MockEventRouterObserver non_matching_observer;
   router.RegisterObserver(&non_matching_observer, "other");
@@ skipping 14 matching lines @@
   EXPECT_EQ(0, non_matching_observer.listener_added_count());
 
   // Removing the listener again notifies again.
   router.OnListenerRemoved(listener.get());
   EXPECT_EQ(2, matching_observer.listener_removed_count());
   EXPECT_EQ(0, non_matching_observer.listener_removed_count());
 
   // Adding a listener with a sub-event notifies the main observer with
   // proper details.
   matching_observer.Reset();
-  std::unique_ptr<EventListener> sub_event_listener =
-      constructor.Run("event_name/1", NULL, new base::DictionaryValue());
+  std::unique_ptr<EventListener> sub_event_listener = constructor.Run(
+      "event_name/1", nullptr, base::MakeUnique<base::DictionaryValue>());
   router.OnListenerAdded(sub_event_listener.get());
   EXPECT_EQ(1, matching_observer.listener_added_count());
   EXPECT_EQ(0, matching_observer.listener_removed_count());
   EXPECT_EQ("event_name/1", matching_observer.last_event_name());
 
   // Ditto for removing the listener.
   matching_observer.Reset();
   router.OnListenerRemoved(sub_event_listener.get());
   EXPECT_EQ(0, matching_observer.listener_added_count());
   EXPECT_EQ(1, matching_observer.listener_removed_count());
   EXPECT_EQ("event_name/1", matching_observer.last_event_name());
 }
 
 TEST_F(EventRouterTest, EventRouterObserverForExtensions) {
   RunEventRouterObserverTest(
       base::Bind(&CreateEventListenerForExtension, "extension_id"));
 }
 
 TEST_F(EventRouterTest, EventRouterObserverForURLs) {
   RunEventRouterObserverTest(
       base::Bind(&CreateEventListenerForURL, GURL("http://google.com/path")));
 }
 
 TEST_F(EventRouterTest, TestReportEvent) {
-  EventRouter router(browser_context(), NULL);
+  EventRouter router(browser_context(), nullptr);
   scoped_refptr<Extension> normal = test_util::CreateEmptyExtension("id1");
   router.ReportEvent(events::HistogramValue::FOR_TEST, normal.get(),
                      false /** did_enqueue */);
   ExpectHistogramCounts(1 /** Dispatch */, 0 /** DispatchToComponent */,
                         0 /** DispatchWithPersistentBackgroundPage */,
                         0 /** DispatchWithSuspendedEventPage */,
                         0 /** DispatchToComponentWithSuspendedEventPage */,
                         0 /** DispatchWithRunningEventPage */);
 
   scoped_refptr<Extension> component =
@@ skipping 29 matching lines @@
   // For the purpose of this test, "." is important in |event_name| as it
   // exercises the code path that uses |event_name| as a key in DictionaryValue.
   const std::string kEventName = "webNavigation.onBeforeNavigate";
 
   const std::string kExtensionId = "mbflcebpggnecokmikipoihdbecnjfoj";
   const std::string kHostSuffixes[] = {"foo.com", "bar.com", "baz.com"};
   std::vector<std::unique_ptr<DictionaryValue>> filters;
   for (size_t i = 0; i < arraysize(kHostSuffixes); ++i) {
     std::unique_ptr<base::DictionaryValue> filter =
         CreateHostSuffixFilter(kHostSuffixes[i]);
-    EventRouter::Get(browser_context())
-        ->AddFilteredEventListener(kEventName, render_process_host(),
-                                   kExtensionId, *filter, true);
+    event_router()->AddFilteredEventListener(kEventName, render_process_host(),
+                                             kExtensionId, *filter, true);
     filters.push_back(std::move(filter));
   }
 
   const base::DictionaryValue* filtered_events =
       GetFilteredEvents(kExtensionId);
   ASSERT_TRUE(filtered_events);
   ASSERT_EQ(1u, filtered_events->size());
 
   DictionaryValue::Iterator iter(*filtered_events);
   ASSERT_EQ(kEventName, iter.key());
@@ skipping 22 matching lines @@
 
   // Remove the third filter.
   event_router()->RemoveFilteredEventListener(kEventName, render_process_host(),
                                               kExtensionId, *filters[2], true);
   ASSERT_FALSE(ContainsFilter(kExtensionId, kEventName, *filters[0]));
   ASSERT_FALSE(ContainsFilter(kExtensionId, kEventName, *filters[1]));
   ASSERT_FALSE(ContainsFilter(kExtensionId, kEventName, *filters[2]));
 }
 
 }  // namespace extensions