[Extensions] Make Event::restrict_to_browser_context const.

extensions/browser/api/app_runtime/app_runtime_api.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/browser/api/app_runtime/app_runtime_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 18 matching lines @@
 namespace app_runtime = api::app_runtime;
 
 namespace {
 
 void DispatchOnEmbedRequestedEventImpl(
     const std::string& extension_id,
     std::unique_ptr<base::DictionaryValue> app_embedding_request_data,
     content::BrowserContext* context) {
   std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(std::move(app_embedding_request_data));
-  std::unique_ptr<Event> event(
-      new Event(events::APP_RUNTIME_ON_EMBED_REQUESTED,
-                app_runtime::OnEmbedRequested::kEventName, std::move(args)));
-  event->restrict_to_browser_context = context;
+  auto event = base::MakeUnique<Event>(
+      events::APP_RUNTIME_ON_EMBED_REQUESTED,
+      app_runtime::OnEmbedRequested::kEventName, std::move(args), context);
   EventRouter::Get(context)
       ->DispatchEventWithLazyListener(extension_id, std::move(event));
 
   ExtensionPrefs::Get(context)
       ->SetLastLaunchTime(extension_id, base::Time::Now());
 }
 
 void DispatchOnLaunchedEventImpl(
     const std::string& extension_id,
     app_runtime::LaunchSource source,
     std::unique_ptr<base::DictionaryValue> launch_data,
     BrowserContext* context) {
   UMA_HISTOGRAM_ENUMERATION("Extensions.AppLaunchSource", source,
                             app_runtime::LaunchSource::LAUNCH_SOURCE_LAST + 1);
 
   // "Forced app mode" is true for Chrome OS kiosk mode.
   launch_data->SetBoolean(
       "isKioskSession",
       ExtensionsBrowserClient::Get()->IsRunningInForcedAppMode());
 
   launch_data->SetBoolean(
       "isPublicSession",
       ExtensionsBrowserClient::Get()->IsLoggedInAsPublicAccount());
 
   std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(std::move(launch_data));
-  std::unique_ptr<Event> event(new Event(events::APP_RUNTIME_ON_LAUNCHED,
-                                         app_runtime::OnLaunched::kEventName,
-                                         std::move(args)));
-  event->restrict_to_browser_context = context;
+  auto event = base::MakeUnique<Event>(events::APP_RUNTIME_ON_LAUNCHED,
+                                       app_runtime::OnLaunched::kEventName,
+                                       std::move(args), context);
   EventRouter::Get(context)
       ->DispatchEventWithLazyListener(extension_id, std::move(event));
   ExtensionPrefs::Get(context)
       ->SetLastLaunchTime(extension_id, base::Time::Now());
 }
 
 #define ASSERT_ENUM_EQUAL(Name) ASSERT_ENUM_EQUAL_FULL(Name, Name)
 
 #define ASSERT_ENUM_EQUAL_FULL(Name, Name2)                        \
   static_assert(static_cast<int>(extensions::Name) ==              \
@@ skipping 57 matching lines @@
 
   DispatchOnLaunchedEventImpl(extension->id(), source_enum,
                               launch_data->ToValue(), context);
 }
 
 // static
 void AppRuntimeEventRouter::DispatchOnRestartedEvent(
     BrowserContext* context,
     const Extension* extension) {
   std::unique_ptr<base::ListValue> arguments(new base::ListValue());
-  std::unique_ptr<Event> event(new Event(events::APP_RUNTIME_ON_RESTARTED,
-                                         app_runtime::OnRestarted::kEventName,
-                                         std::move(arguments)));
-  event->restrict_to_browser_context = context;
+  auto event = base::MakeUnique<Event>(events::APP_RUNTIME_ON_RESTARTED,
+                                       app_runtime::OnRestarted::kEventName,
+                                       std::move(arguments), context);
   EventRouter::Get(context)
       ->DispatchEventToExtension(extension->id(), std::move(event));
 }
 
 // static
 void AppRuntimeEventRouter::DispatchOnLaunchedEventWithFileEntries(
     BrowserContext* context,
     const Extension* extension,
     extensions::AppLaunchSource source,
     const std::string& handler_id,
@@ skipping 49 matching lines @@
   launch_data.url.reset(new std::string(url.spec()));
   launch_data.referrer_url.reset(new std::string(referrer_url.spec()));
   if (extensions::FeatureSwitch::trace_app_source()->IsEnabled()) {
     launch_data.source = source_enum;
   }
   DispatchOnLaunchedEventImpl(extension->id(), source_enum,
                               launch_data.ToValue(), context);
 }
 
 }  // namespace extensions