[Extensions] Make Event::restrict_to_browser_context const.

chrome/browser/extensions/api/tabs/tabs_event_router.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 "chrome/browser/extensions/api/tabs/tabs_event_router.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 186 matching lines @@
   tab_value->SetBoolean(tabs_constants::kActiveKey, active);
   event->event_args->Append(std::move(tab_value));
   return true;
 }
 
 void TabsEventRouter::TabCreatedAt(WebContents* contents,
                                    int index,
                                    bool active) {
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   std::unique_ptr<base::ListValue> args(new base::ListValue);
-  std::unique_ptr<Event> event(new Event(
-      events::TABS_ON_CREATED, tabs::OnCreated::kEventName, std::move(args)));
-  event->restrict_to_browser_context = profile;
+  auto event = base::MakeUnique<Event>(events::TABS_ON_CREATED,
+                                       tabs::OnCreated::kEventName,
+                                       std::move(args), profile);
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
   event->will_dispatch_callback =
       base::Bind(&WillDispatchTabCreatedEvent, contents, active);
   EventRouter::Get(profile)->BroadcastEvent(std::move(event));
 
   RegisterForTabNotifications(contents);
 }
 
 void TabsEventRouter::TabInsertedAt(TabStripModel* tab_strip_model,
                                     WebContents* contents,
@@ skipping 200 matching lines @@
 void TabsEventRouter::DispatchEvent(
     Profile* profile,
     events::HistogramValue histogram_value,
     const std::string& event_name,
     std::unique_ptr<base::ListValue> args,
     EventRouter::UserGestureState user_gesture) {
   EventRouter* event_router = EventRouter::Get(profile);
   if (!profile_->IsSameProfile(profile) || !event_router)
     return;
 
-  std::unique_ptr<Event> event(
-      new Event(histogram_value, event_name, std::move(args)));
-  event->restrict_to_browser_context = profile;
+  auto event = base::MakeUnique<Event>(histogram_value, event_name,
+                                       std::move(args), profile);
   event->user_gesture = user_gesture;
   event_router->BroadcastEvent(std::move(event));
 }
 
 void TabsEventRouter::DispatchTabUpdatedEvent(
     WebContents* contents,
     const std::set<std::string> changed_property_names) {
   DCHECK(!changed_property_names.empty());
   DCHECK(contents);
 
   // The state of the tab (as seen from the extension point of view) has
   // changed.  Send a notification to the extension.
   std::unique_ptr<base::ListValue> args_base(new base::ListValue);
 
   // First arg: The id of the tab that changed.
   args_base->AppendInteger(ExtensionTabUtil::GetTabId(contents));
 
   // Second arg: An object containing the changes to the tab state.  Filled in
   // by WillDispatchTabUpdatedEvent as a copy of changed_properties, if the
   // extension has the tabs permission.
 
   // Third arg: An object containing the state of the tab. Filled in by
   // WillDispatchTabUpdatedEvent.
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 
-  std::unique_ptr<Event> event(new Event(events::TABS_ON_UPDATED,
-                                         tabs::OnUpdated::kEventName,
-                                         std::move(args_base)));
-  event->restrict_to_browser_context = profile;
+  auto event = base::MakeUnique<Event>(events::TABS_ON_UPDATED,
+                                       tabs::OnUpdated::kEventName,
+                                       std::move(args_base), profile);
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
   event->will_dispatch_callback =
       base::Bind(&WillDispatchTabUpdatedEvent, contents,
                  std::move(changed_property_names));
   EventRouter::Get(profile)->BroadcastEvent(std::move(event));
 }
 
 TabsEventRouter::TabEntry* TabsEventRouter::GetTabEntry(WebContents* contents) {
   const auto it = tab_entries_.find(ExtensionTabUtil::GetTabId(contents));
 
@@ skipping 87 matching lines @@
 }
 
 void TabsEventRouter::OnAutoDiscardableStateChange(WebContents* contents,
                                                    bool is_auto_discardable) {
   std::set<std::string> changed_property_names;
   changed_property_names.insert(tabs_constants::kAutoDiscardableKey);
   DispatchTabUpdatedEvent(contents, std::move(changed_property_names));
 }
 
 }  // namespace extensions