Update ash CreateTestWidget() callers to specify ownership.

We're refactoring Views to change the default ownership model
for Widgets to CLIENT_OWNS_WIDGET. As part of this we need
to ensure all the existing users are specifying the ownership
explicitly so that we can remove any default values (and then
potentially change to the new value as a default down the road).

This change updates all the callers in //ash to explicitly pass
the widget ownership model to AshTestBase::CreateTestWidget()

There should be no functional changes in this CL.

Bug: 339619005
Change-Id: I5adaece6c5780de7e014c1ed7e7e9da1af490da6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5602187
Reviewed-by: James Cook <jamescook@chromium.org>
Commit-Queue: Dirk Pranke <dpranke@google.com>
Cr-Commit-Position: refs/heads/main@{#1311595}

ash/accelerators/accelerator_controller_unittest.cc

@@ -1299,7 +1299,8 @@ TEST_F(AcceleratorControllerTest, DontRepeatToggleFullscreen) {
 
 TEST_F(AcceleratorControllerTest, DontToggleFullscreenWhenOverviewStarts) {
   std::unique_ptr<views::Widget> widget(CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(400, 400)));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(400, 400)));
 
   ui::test::EventGenerator* generator = GetEventGenerator();
 

ash/accessibility/autoclick/autoclick_unittest.cc

@@ -896,7 +896,8 @@ TEST_F(AutoclickTest, ShelfAutohidesWithAutoclickBubble) {
 
   // Create a visible window so auto-hide behavior is enforced.
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, desks_util::GetActiveDeskContainerId(),
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, desks_util::GetActiveDeskContainerId(),
                        gfx::Rect(0, 0, 200, 200), true /* show */);
 
   // Turn on auto-hide for the shelf.
@@ -919,7 +920,8 @@ TEST_F(AutoclickTest, BubbleMovesWithShelfPositionChange) {
 
   // Create a visible window so WMEvents occur.
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, desks_util::GetActiveDeskContainerId(),
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, desks_util::GetActiveDeskContainerId(),
                        gfx::Rect(0, 0, 200, 200), true /* show */);
 
   // Set up autoclick and the shelf.
@@ -1059,7 +1061,8 @@ TEST_F(AutoclickTest, HidesBubbleInFullscreenWhenCursorHides) {
     UpdateDisplay(test.display_spec);
 
     std::unique_ptr<views::Widget> widget = CreateTestWidget(
-        nullptr, desks_util::GetActiveDeskContainerId(), test.widget_position,
+        views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+        desks_util::GetActiveDeskContainerId(), test.widget_position,
         /*show=*/true);
     EXPECT_TRUE(GetAutoclickBubbleWidget()->IsVisible());
 
@@ -1113,7 +1116,8 @@ TEST_F(AutoclickTest, DoesNotHideBubbleWhenNotOverFullscreenWindow) {
   cursor_manager->SetCursor(ui::mojom::CursorType::kPointer);
 
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, desks_util::GetActiveDeskContainerId(),
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, desks_util::GetActiveDeskContainerId(),
                        gfx::Rect(1000, 0, 200, 200), true);
 
   EXPECT_TRUE(GetAutoclickBubbleWidget()->IsVisible());
@@ -1133,9 +1137,9 @@ TEST_F(AutoclickTest, DoesNotHideBubbleWhenOverInactiveFullscreenWindow) {
   ::wm::CursorManager* cursor_manager = Shell::Get()->cursor_manager();
   cursor_manager->SetCursor(ui::mojom::CursorType::kPointer);
 
-  std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, desks_util::GetActiveDeskContainerId(),
-                       gfx::Rect(0, 0, 200, 200), true);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 200, 200), true);
   GetEventGenerator()->MoveMouseTo(gfx::Point(10, 10));
   widget->SetFullscreen(true);
   EXPECT_TRUE(widget->IsActive());

ash/accessibility/magnifier/docked_magnifier_controller_unittest.cc

@@ -156,8 +156,9 @@ class DockedMagnifierTest : public NoSessionAshTestBase {
       const gfx::Rect& bounds) {
     auto* widget_delegate_view = new views::WidgetDelegateView();
     widget_delegate_view->SetModalType(ui::MODAL_TYPE_SYSTEM);
-    return CreateTestWidget(widget_delegate_view,
-                            kShellWindowId_LockSystemModalContainer, bounds);
+    return CreateTestWidget(
+        views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+        widget_delegate_view, kShellWindowId_LockSystemModalContainer, bounds);
   }
 
   // Test that display work area and a modal window is adjusted correctly

ash/accessibility/ui/accessibility_highlight_controller_unittest.cc

@@ -250,7 +250,8 @@ TEST_F(AccessibilityHighlightControllerTest, CursorWorksOnMultipleDisplays) {
 TEST_F(AccessibilityHighlightControllerTest, CaretRingDrawnOnlyWithinBounds) {
   // Given caret bounds that are not within the active window, expect that the
   // caret ring highlight is not drawn.
-  std::unique_ptr<views::Widget> window = CreateTestWidget();
+  std::unique_ptr<views::Widget> window =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   window->SetBounds(gfx::Rect(5, 5, 300, 300));
 
   AccessibilityHighlightController highlight_controller;
@@ -308,7 +309,8 @@ TEST_F(AccessibilityHighlightControllerTest, ZeroWidthCaretRingVisible) {
 // Tests setting the caret bounds explicitly via AccessibilityController, rather
 // than via the input method observer. This path is used in production in mash.
 TEST_F(AccessibilityHighlightControllerTest, SetCaretBounds) {
-  std::unique_ptr<views::Widget> window = CreateTestWidget();
+  std::unique_ptr<views::Widget> window =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   window->SetBounds(gfx::Rect(5, 5, 300, 300));
 
   AccessibilityController* accessibility_controller =

ash/app_list/app_list_bubble_presenter_unittest.cc

@@ -276,8 +276,10 @@ TEST_F(AppListBubblePresenterTest, ShowAfterDisconnectingDisplay) {
 TEST_F(AppListBubblePresenterTest, ToggleByFocusingWindowOnSecondaryDisplay) {
   UpdateDisplay("1600x1200,1366x768");
 
-  std::unique_ptr<views::Widget> primary_display_widget = CreateTestWidget();
-  std::unique_ptr<views::Widget> secondary_display_widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> primary_display_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  std::unique_ptr<views::Widget> secondary_display_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   secondary_display_widget->SetBounds(
       gfx::Rect(gfx::Point(1600, 0), gfx::Size(1366, 768)));
 
@@ -620,6 +622,7 @@ TEST_F(AppListBubblePresenterTest, FocusHelpBubbleContainerChild) {
   ASSERT_TRUE(presenter->IsShowing());
 
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
       /*delegate=*/nullptr, kShellWindowId_HelpBubbleContainer);
   EXPECT_TRUE(widget->GetNativeView()->HasFocus());
 

ash/app_list/app_list_controller_impl_unittest.cc

@@ -277,7 +277,8 @@ TEST_P(AppListControllerImplTest, PageResetByTimerInTabletMode) {
   apps_grid_view->pagination_model()->SelectPage(1, false /* animate */);
 
   // Create a test window to hide the app list.
-  std::unique_ptr<views::Widget> dummy = CreateTestWidget();
+  std::unique_ptr<views::Widget> dummy =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   EXPECT_FALSE(Shell::Get()->app_list_controller()->IsVisible());
 
   // When timer is not skipped the selected page should not change when app list
@@ -310,7 +311,8 @@ TEST_P(AppListControllerImplTest, PagePersistanceTabletModeTest) {
   apps_grid_view->pagination_model()->SelectPage(1, false /* animate */);
 
   // Close and re-open the app list to ensure the current page persists.
-  std::unique_ptr<views::Widget> dummy = CreateTestWidget();
+  std::unique_ptr<views::Widget> dummy =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   EXPECT_FALSE(Shell::Get()->app_list_controller()->IsVisible());
   dummy->Minimize();
   EXPECT_TRUE(Shell::Get()->app_list_controller()->IsVisible());

ash/app_list/app_list_feature_usage_metrics_unittest.cc

@@ -140,7 +140,8 @@ TEST_F(AppListFeatureUsageMetricsTest, ShowAndHideLauncherInTablet) {
   const base::TimeDelta kUsetime = base::Seconds(2);
   FastForwardBy(kUsetime);
   // Creating a window hides the launcher.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   histograms_.ExpectTimeBucketCount(kTabletUsetimeMetric, kUsetime, 1);
 
   // Clamshell usage is not recorded.
@@ -152,7 +153,8 @@ TEST_F(AppListFeatureUsageMetricsTest,
   SimulateTabletModeSupport();
   ASSERT_TRUE(Shell::Get()->tablet_mode_controller()->CanEnterTabletMode());
   SimulateUserLogin("user@gmail.com");
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   Shell::Get()->app_list_controller()->ShowAppList(
       AppListShowSource::kSearchKey);
 

ash/app_list/app_list_metrics_unittest.cc

@@ -211,7 +211,8 @@ TEST_F(AppListMetricsTest, TapOnItemDuringTabletModeAnimation) {
 
   CreateShelfItem(/*wait_for_tablet_mode=*/true);
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ui::ScopedAnimationDurationScaleMode non_zero_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
   ClickShelfItem();
@@ -396,7 +397,8 @@ TEST_F(AppListShowSourceMetricTest, TabletInAppToHome) {
       ->accessibility_controller()
       ->SetTabletModeShelfNavigationButtonsEnabled(true);
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   Shell::Get()->tablet_mode_controller()->SetEnabledForTest(true);
 
   ClickHomeButton();
@@ -423,7 +425,8 @@ TEST_F(AppListShowSourceMetricTest, TabletInAppToHome) {
 TEST_F(AppListShowSourceMetricTest, TabletModeWithWindowOpen) {
   base::HistogramTester histogram_tester;
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   Shell::Get()->tablet_mode_controller()->SetEnabledForTest(true);
   GetAppListTestHelper()->CheckVisibility(false);
 
@@ -487,7 +490,8 @@ TEST_F(AppListShowSourceMetricTest, TabletModeDoesNotRecordAppListBubbleShow) {
 
   // Go to tablet mode, the tablet mode (non bubble) launcher will show. Create
   // a test widget so the launcher will show in the background.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   Shell::Get()->tablet_mode_controller()->SetEnabledForTest(true);
   auto* app_list_bubble_presenter =
       Shell::Get()->app_list_controller()->bubble_presenter_for_test();

ash/app_list/app_list_presenter_impl_unittest.cc

@@ -100,7 +100,8 @@ TEST_F(AppListPresenterImplTest,
   for (int id : AppListPresenterImpl::kIdsOfContainersThatWontHideAppList) {
     // Create a widget with a specific container id and make sure that the
     // kHomeLauncher background is still shown.
-    std::unique_ptr<views::Widget> widget = CreateTestWidget(nullptr, id);
+    std::unique_ptr<views::Widget> widget = CreateTestWidget(
+        views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr, id);
 
     EXPECT_EQ(ShelfBackgroundType::kHomeLauncher,
               shelf_layout_manager->shelf_background_type())

ash/app_list/app_list_presenter_unittest.cc

@@ -3852,7 +3852,8 @@ TEST_F(AppListPresenterTest, TapAppListThenSystemTrayShowsAutoHiddenShelf) {
   shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
 
   // Create a normal unmaximized window; the shelf should be hidden.
-  std::unique_ptr<views::Widget> window = CreateTestWidget();
+  std::unique_ptr<views::Widget> window =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   window->SetBounds(gfx::Rect(0, 0, 100, 100));
   GetAppListTestHelper()->CheckVisibility(false);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
@@ -3881,7 +3882,8 @@ TEST_F(AppListPresenterTest, TapAppListThenShelfHidesAutoHiddenShelf) {
   shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
 
   // Create a normal unmaximized window; the shelf should be hidden.
-  std::unique_ptr<views::Widget> window = CreateTestWidget();
+  std::unique_ptr<views::Widget> window =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   window->SetBounds(gfx::Rect(0, 0, 100, 100));
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 

ash/assistant/test/assistant_ash_test_base.cc

@@ -275,7 +275,8 @@ aura::Window* AssistantAshTestBase::SwitchToNewAppWindow() {
 }
 
 views::Widget* AssistantAshTestBase::SwitchToNewWidget() {
-  widgets_.push_back(CreateTestWidget());
+  widgets_.push_back(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
 
   views::Widget* result = widgets_.back().get();
   // Give the widget a non-zero size, otherwise things like tapping and clicking

ash/assistant/ui/base/assistant_button_unittest.cc

@@ -80,8 +80,8 @@ TEST_F(AssistantButtonTest, IconColor) {
   params.icon_size_in_dip = kIconSizeInDip;
   params.accessible_name_id = IDS_ASH_ASSISTANT_DIALOG_PLATE_KEYBOARD_ACCNAME;
 
-
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   AssistantButton* button =
       widget->GetContentsView()->AddChildView(AssistantButton::Create(
           nullptr, vector_icons::kKeyboardIcon,
@@ -106,7 +106,8 @@ TEST_F(AssistantButtonTest, IconColorType) {
   params.accessible_name_id = IDS_ASH_ASSISTANT_DIALOG_PLATE_KEYBOARD_ACCNAME;
   params.icon_color_type = cros_tokens::kColorPrimary;
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   AssistantButton* button =
       widget->GetContentsView()->AddChildView(AssistantButton::Create(
           nullptr, vector_icons::kKeyboardIcon,
@@ -153,7 +154,8 @@ TEST_F(AssistantButtonTest, FocusAndHoverColorDarkLightMode) {
   params.accessible_name_id = IDS_ASH_ASSISTANT_DIALOG_PLATE_KEYBOARD_ACCNAME;
   params.icon_color_type = cros_tokens::kColorPrimary;
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   AssistantButton* button =
       widget->GetContentsView()->AddChildView(AssistantButton::Create(
           nullptr, vector_icons::kKeyboardIcon,

ash/assistant/ui/main_stage/assistant_onboarding_suggestion_view_unittest.cc

@@ -41,7 +41,8 @@ using AssistantOnboardingSuggestionViewTest = AshTestBase;
 TEST_F(AssistantOnboardingSuggestionViewTest, DarkAndLightTheme) {
   auto* dark_light_mode_controller = DarkLightModeControllerImpl::Get();
   dark_light_mode_controller->SetDarkModeEnabledForTest(false);
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   AssistantOnboardingSuggestionView* suggestion_view_0 =
       CreateSuggestionViewAt(0, widget.get());

ash/display/display_move_window_util_unittest.cc

@@ -377,7 +377,8 @@ TEST_F(DisplayMoveWindowUtilTest, WindowWithTransientChild) {
 // target instead.
 TEST_F(DisplayMoveWindowUtilTest, ActiveTransientChildWindow) {
   UpdateDisplay("400x300,400x300");
-  std::unique_ptr<views::Widget> window = CreateTestWidget();
+  std::unique_ptr<views::Widget> window =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   window->SetBounds(gfx::Rect(10, 20, 200, 100));
 
   // Create a |child| transient widget of |window|. When |child| is shown, it is

ash/fast_ink/fast_ink_host_unittest.cc

@@ -61,8 +61,9 @@ class FastInkHostTest
 
     auto* root_window = ash_test_helper()->GetHost()->window();
     gfx::Rect screen_bounds = root_window->GetBoundsInScreen();
-
-    widget_ = CreateTestWidget(nullptr, kShellWindowId_OverlayContainer);
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                         nullptr, kShellWindowId_OverlayContainer);
     widget_->SetBounds(screen_bounds);
     host_window_ = widget_->GetNativeWindow();
 

ash/fast_ink/view_tree_host_root_view_frame_factory_unittest.cc

@@ -44,8 +44,9 @@ class ViewTreeHostRootViewFrameFactoryTest : public AshTestBase {
   // AshTestBase:
   void SetUp() override {
     AshTestBase::SetUp();
-    widget_ = CreateTestWidget(nullptr, kShellWindowId_OverlayContainer,
-                               gfx::Rect(0, 0, 200, 100));
+    widget_ = CreateTestWidget(
+        views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+        kShellWindowId_OverlayContainer, gfx::Rect(0, 0, 200, 100));
     factory_ =
         std::make_unique<ViewTreeHostRootViewFrameFactory>(widget_.get());
   }

ash/frame/default_frame_header_unittest.cc

@@ -62,7 +62,8 @@ class DefaultFrameHeaderTest : public AshTestBase {
 // Ensure the title text is vertically aligned with the window icon.
 TEST_F(DefaultFrameHeaderTest, TitleIconAlignment) {
   std::unique_ptr<Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
   FrameCaptionButtonContainerView container(widget.get());
   views::StaticSizedView window_icon(gfx::Size(16, 16));
   window_icon.SetBounds(0, 0, 16, 16);
@@ -79,8 +80,9 @@ TEST_F(DefaultFrameHeaderTest, TitleIconAlignment) {
 }
 
 TEST_F(DefaultFrameHeaderTest, BackButtonAlignment) {
-  std::unique_ptr<Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
   FrameCaptionButtonContainerView container(widget.get());
   FrameBackButton back;
 
@@ -98,7 +100,8 @@ TEST_F(DefaultFrameHeaderTest, BackButtonAlignment) {
 TEST_F(DefaultFrameHeaderTest, MinimumHeaderWidthRTL) {
   base::test::ScopedRestoreICUDefaultLocale restore_locale;
   std::unique_ptr<Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
   FrameCaptionButtonContainerView container(widget.get());
 
   DefaultFrameHeader frame_header(

ash/frame/non_client_frame_view_ash_unittest.cc

@@ -161,7 +161,8 @@ using NonClientFrameViewAshTest = AshTestBase;
 // Verifies the client view is not placed at a y location of 0.
 TEST_F(NonClientFrameViewAshTest, ClientViewCorrectlyPlaced) {
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(new NonClientFrameViewAshTestWidgetDelegate);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       new NonClientFrameViewAshTestWidgetDelegate);
   EXPECT_NE(0, widget->client_view()->bounds().y());
 }
 
@@ -170,8 +171,8 @@ TEST_F(NonClientFrameViewAshTest, ClientViewCorrectlyPlaced) {
 TEST_F(NonClientFrameViewAshTest, HeaderHeight) {
   NonClientFrameViewAshTestWidgetDelegate* delegate =
       new NonClientFrameViewAshTestWidgetDelegate;
-
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   // The header should have enough room for the window controls. The
   // header/content separator line overlays the window controls.
@@ -185,7 +186,8 @@ TEST_F(NonClientFrameViewAshTest, HeaderHeight) {
 TEST_F(NonClientFrameViewAshTest, ActiveStateOfButtonMatchesWidget) {
   NonClientFrameViewAshTestWidgetDelegate* delegate =
       new NonClientFrameViewAshTestWidgetDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   FrameCaptionButtonContainerView::TestApi test_api(
       delegate->non_client_frame_view()
           ->GetHeaderView()
@@ -199,7 +201,8 @@ TEST_F(NonClientFrameViewAshTest, ActiveStateOfButtonMatchesWidget) {
 
   // Activate a different widget so the original one loses activation.
   std::unique_ptr<views::Widget> widget2 =
-      CreateTestWidget(new NonClientFrameViewAshTestWidgetDelegate);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       new NonClientFrameViewAshTestWidgetDelegate);
   widget2->Show();
   ui::DrawWaiterForTest::WaitForCommit(widget->GetLayer()->GetCompositor());
 
@@ -211,7 +214,8 @@ TEST_F(NonClientFrameViewAshTest, ActiveStateOfButtonMatchesWidget) {
 // frame sizes when the client view does not specify any size constraints.
 TEST_F(NonClientFrameViewAshTest, NoSizeConstraints) {
   TestWidgetConstraintsDelegate* delegate = new TestWidgetConstraintsDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   NonClientFrameViewAsh* non_client_frame_view =
       delegate->non_client_frame_view();
@@ -233,7 +237,8 @@ TEST_F(NonClientFrameViewAshTest, MinimumAndMaximumSize) {
   TestWidgetConstraintsDelegate* delegate = new TestWidgetConstraintsDelegate;
   delegate->set_minimum_size(min_client_size);
   delegate->set_maximum_size(max_client_size);
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   NonClientFrameViewAsh* non_client_frame_view =
       delegate->non_client_frame_view();
@@ -252,7 +257,8 @@ TEST_F(NonClientFrameViewAshTest, MinimumAndMaximumSize) {
 // avatar icon window property.
 TEST_F(NonClientFrameViewAshTest, AvatarIcon) {
   TestWidgetConstraintsDelegate* delegate = new TestWidgetConstraintsDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   NonClientFrameViewAsh* non_client_frame_view =
       delegate->non_client_frame_view();
@@ -275,7 +281,8 @@ TEST_F(NonClientFrameViewAshTest, AvatarIcon) {
 TEST_F(NonClientFrameViewAshTest, ToggleTabletModeOnMinimizedWindow) {
   NonClientFrameViewAshTestWidgetDelegate* delegate =
       new NonClientFrameViewAshTestWidgetDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   FrameCaptionButtonContainerView::TestApi test(
       delegate->non_client_frame_view()
           ->GetHeaderView()
@@ -306,7 +313,8 @@ TEST_F(NonClientFrameViewAshTest, ToggleTabletModeOnMinimizedWindow) {
 TEST_F(NonClientFrameViewAshTest, FrameHiddenInTabletModeForMaximizedWindows) {
   NonClientFrameViewAshTestWidgetDelegate* delegate =
       new NonClientFrameViewAshTestWidgetDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   widget->Maximize();
 
   ash::TabletModeControllerTestApi().EnterTabletMode();
@@ -318,7 +326,8 @@ TEST_F(NonClientFrameViewAshTest, FrameHiddenInTabletModeForMaximizedWindows) {
 TEST_F(NonClientFrameViewAshTest,
        FrameShownInTabletModeForNonMaximizedWindows) {
   auto* delegate = new NonClientFrameViewAshTestWidgetDelegate();
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   ash::TabletModeControllerTestApi().EnterTabletMode();
   EXPECT_EQ(views::GetCaptionButtonLayoutSize(
@@ -333,7 +342,8 @@ TEST_F(NonClientFrameViewAshTest,
        FrameRemainsHiddenInTabletModeWhenTogglingFullscreen) {
   NonClientFrameViewAshTestWidgetDelegate* delegate =
       new NonClientFrameViewAshTestWidgetDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   widget->SetFullscreen(true);
   EXPECT_EQ(0, delegate->GetNonClientFrameViewTopBorderHeight());
@@ -345,7 +355,8 @@ TEST_F(NonClientFrameViewAshTest,
 
 TEST_F(NonClientFrameViewAshTest, OpeningAppsInTabletMode) {
   auto* delegate = new TestWidgetConstraintsDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   widget->Maximize();
 
   ash::TabletModeControllerTestApi().EnterTabletMode();
@@ -406,7 +417,8 @@ TEST_F(NonClientFrameViewAshTest, GetPreferredOnScreenHeightInTabletMaximzied) {
   ash::TabletModeControllerTestApi().EnterTabletMode();
 
   auto* delegate = new TestWidgetConstraintsDelegate;
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   auto* frame_view = static_cast<NonClientFrameViewAsh*>(
       widget->non_client_view()->frame_view());
   auto* header_view = frame_view->GetHeaderView();
@@ -425,7 +437,8 @@ TEST_F(NonClientFrameViewAshTest, GetPreferredOnScreenHeightInTabletMaximzied) {
 // no header when unminimized in tablet mode.
 TEST_F(NonClientFrameViewAshTest, MinimizedWindowsInTabletMode) {
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(new NonClientFrameViewAshTestWidgetDelegate);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       new NonClientFrameViewAshTestWidgetDelegate);
   widget->GetNativeWindow()->SetProperty(
       aura::client::kResizeBehaviorKey,
       aura::client::kResizeBehaviorCanMaximize);
@@ -440,7 +453,8 @@ TEST_F(NonClientFrameViewAshTest, MinimizedWindowsInTabletMode) {
 
 TEST_F(NonClientFrameViewAshTest, HeaderVisibilityInFullscreen) {
   auto* delegate = new NonClientFrameViewAshTestWidgetDelegate();
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   auto* controller = ImmersiveFullscreenController::Get(widget.get());
   ImmersiveFullscreenControllerTestApi test_api(controller);
@@ -531,9 +545,9 @@ TEST_F(NonClientFrameViewAshTest, BackButton) {
   TestButtonModel* model_ptr = model.get();
 
   auto* delegate = new NonClientFrameViewAshTestWidgetDelegate();
-  std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(delegate, desks_util::GetActiveDeskContainerId(),
-                       gfx::Rect(0, 0, 400, 500));
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 400, 500));
 
   ui::Accelerator accelerator_back_press(ui::VKEY_BROWSER_BACK, ui::EF_NONE);
   accelerator_back_press.set_key_state(ui::Accelerator::KeyState::PRESSED);
@@ -594,7 +608,8 @@ TEST_F(NonClientFrameViewAshTest, FrameVisibility) {
       new NonClientFrameViewAshTestWidgetDelegate;
   gfx::Rect window_bounds(10, 10, 200, 100);
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      delegate, desks_util::GetActiveDeskContainerId(), window_bounds);
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate,
+      desks_util::GetActiveDeskContainerId(), window_bounds);
 
   // The height is smaller by the top border height.
   gfx::Size client_bounds(200, 68);
@@ -626,7 +641,8 @@ TEST_F(NonClientFrameViewAshTest, CustomButtonModel) {
   TestButtonModel* model_ptr = model.get();
 
   auto* delegate = new NonClientFrameViewAshTestWidgetDelegate();
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   NonClientFrameViewAsh* non_client_frame_view =
       delegate->non_client_frame_view();
@@ -716,9 +732,9 @@ TEST_F(NonClientFrameViewAshTest, CustomButtonModel) {
 
 TEST_F(NonClientFrameViewAshTest, WideFrame) {
   auto* delegate = new NonClientFrameViewAshTestWidgetDelegate();
-  std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(delegate, desks_util::GetActiveDeskContainerId(),
-                       gfx::Rect(100, 0, 400, 500));
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(100, 0, 400, 500));
 
   NonClientFrameViewAsh* non_client_frame_view =
       delegate->non_client_frame_view();
@@ -795,9 +811,9 @@ TEST_F(NonClientFrameViewAshTest, WideFrame) {
 
 TEST_F(NonClientFrameViewAshTest, WideFrameButton) {
   auto* delegate = new NonClientFrameViewAshTestWidgetDelegate();
-  std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(delegate, desks_util::GetActiveDeskContainerId(),
-                       gfx::Rect(100, 0, 400, 500));
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(100, 0, 400, 500));
   widget->Maximize();
   std::unique_ptr<WideFrameView> wide_frame_view =
       std::make_unique<WideFrameView>(widget.get());
@@ -836,9 +852,9 @@ TEST_F(NonClientFrameViewAshTest, MoveFullscreenWideFrameBetweenDisplay) {
   auto display_list = screen->GetAllDisplays();
 
   auto* delegate = new NonClientFrameViewAshTestWidgetDelegate();
-  std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(delegate, desks_util::GetActiveDeskContainerId(),
-                       gfx::Rect(100, 0, 400, 500));
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(100, 0, 400, 500));
   widget->SetFullscreen(true);
   std::unique_ptr<WideFrameView> wide_frame_view =
       std::make_unique<WideFrameView>(widget.get());
@@ -901,7 +917,8 @@ class TestWidgetDelegate : public TestWidgetConstraintsDelegate {
 // kFrameActiveColorKey window property.
 TEST_P(NonClientFrameViewAshFrameColorTest, kFrameActiveColorKey) {
   TestWidgetDelegate* delegate = new TestWidgetDelegate(GetParam());
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   SkColor active_color =
       widget->GetNativeWindow()->GetProperty(kFrameActiveColorKey);
@@ -931,7 +948,8 @@ TEST_P(NonClientFrameViewAshFrameColorTest, kFrameActiveColorKey) {
 // kFrameInactiveColorKey window property.
 TEST_P(NonClientFrameViewAshFrameColorTest, KFrameInactiveColor) {
   TestWidgetDelegate* delegate = new TestWidgetDelegate(GetParam());
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
 
   SkColor active_color =
       widget->GetNativeWindow()->GetProperty(kFrameInactiveColorKey);
@@ -980,7 +998,8 @@ TEST_P(NonClientFrameViewAshFrameColorTest, KFrameColorCtor) {
 // kFrameActiveColorKey window property.
 TEST_P(NonClientFrameViewAshFrameColorTest, WideFrameInitialColor) {
   TestWidgetDelegate* delegate = new TestWidgetDelegate(GetParam());
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   widget->Maximize();
   aura::Window* window = widget->GetNativeWindow();
   SkColor active_color = window->GetProperty(kFrameActiveColorKey);
@@ -1010,7 +1029,8 @@ TEST_P(NonClientFrameViewAshFrameColorTest, DefaultFrameColorsDarkAndLight) {
       dark_light_mode_controller->IsDarkModeEnabled();
 
   TestWidgetDelegate* delegate = new TestWidgetDelegate(GetParam());
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   aura::Window* window = widget->GetNativeWindow();
 
   auto* color_provider = delegate->non_client_frame_view()->GetColorProvider();
@@ -1056,7 +1076,8 @@ TEST_P(NonClientFrameViewAshFrameColorTest,
       dark_light_mode_controller->IsDarkModeEnabled();
 
   TestWidgetDelegate* delegate = new TestWidgetDelegate(GetParam());
-  std::unique_ptr<views::Widget> widget = CreateTestWidget(delegate);
+  std::unique_ptr<views::Widget> widget = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, delegate);
   aura::Window* window = widget->GetNativeWindow();
 
   constexpr SkColor new_active_color = SK_ColorWHITE;

ash/frame_sink/frame_sink_host_unittest.cc

@@ -57,7 +57,9 @@ class FrameSinkHostTest : public AshTestBase {
     auto* root_window = ash_test_helper()->GetHost()->window();
     gfx::Rect screen_bounds = root_window->GetBoundsInScreen();
 
-    widget_ = CreateTestWidget(nullptr, kShellWindowId_OverlayContainer);
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                         nullptr, kShellWindowId_OverlayContainer);
     widget_->SetBounds(screen_bounds);
     host_window_ = widget_->GetNativeWindow();
 

ash/metrics/pointer_metrics_recorder_unittest.cc

@@ -64,7 +64,8 @@ void PointerMetricsRecorderTest::SetUp() {
   AshTestBase::SetUp();
   pointer_metrics_recorder_ = std::make_unique<PointerMetricsRecorder>();
   histogram_tester_ = std::make_unique<base::HistogramTester>();
-  widget_ = CreateTestWidget();
+  widget_ =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 }
 
 void PointerMetricsRecorderTest::TearDown() {

ash/session/session_controller_impl_unittest.cc

@@ -1006,7 +1006,8 @@ using SessionControllerImplUnblockTest = NoSessionAshTestBase;
 
 TEST_F(SessionControllerImplUnblockTest, ActiveWindowAfterUnblocking) {
   EXPECT_TRUE(Shell::Get()->session_controller()->IsUserSessionBlocked());
-  auto widget = CreateTestWidget();
+  auto widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   // |widget| should not be active as it is blocked by SessionControllerImpl.
   EXPECT_FALSE(widget->IsActive());
   SimulateUserLogin("user@test.com");

ash/shelf/back_button_unittest.cc

@@ -141,7 +141,8 @@ TEST_F(BackButtonTest, Visibility) {
   EXPECT_FALSE(IsBackButtonVisible());
   ASSERT_TRUE(!back_button());
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   test_api()->RunMessageLoopUntilAnimationsDone();
 
   EXPECT_TRUE(IsBackButtonVisible());
@@ -162,7 +163,8 @@ TEST_F(BackButtonTest, VisibilityWithVerticalShelf) {
 
   ash::TabletModeControllerTestApi().EnterTabletMode();
   // Create a test widget to transition to in-app shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   test_api()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(back_button());
@@ -179,7 +181,8 @@ TEST_F(BackButtonTest, BackKeySequenceGenerated) {
   // Enter tablet mode; the back button is not visible in non tablet mode.
   ash::TabletModeControllerTestApi().EnterTabletMode();
   // Create a test widget to transition to in-app shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   ShelfNavigationWidget::TestApi navigation_widget_test_api(
       GetPrimaryShelf()->navigation_widget());
@@ -258,7 +261,8 @@ TEST_F(BackButtonTest, BackButtonWithAndroidKeyboard) {
   controller->Register({accelerator_back_release}, &target_back_release);
 
   // Create a test widget to transition to in-app shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Fakes showing a virtual keyboard.
   VirtualKeyboardModel* keyboard =
@@ -310,7 +314,8 @@ TEST_F(BackButtonTest, NoContextMenuOnBackButton) {
   ash::TabletModeControllerTestApi().EnterTabletMode();
 
   // Create a test widget to transition to in-app shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Wait for the navigation widget's animation.
   ShelfNavigationWidget::TestApi navigation_widget_test_api(
@@ -335,7 +340,8 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST_P(BackButtonVisibilityWithAccessibilityFeaturesTest,
        TabletModeSwitchWithA11yFeatureEnabled) {
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   SetTestA11yFeatureEnabled(true /*enabled*/);
 
@@ -355,7 +361,8 @@ TEST_P(BackButtonVisibilityWithAccessibilityFeaturesTest,
 
 TEST_P(BackButtonVisibilityWithAccessibilityFeaturesTest,
        FeatureEnabledWhileInTabletMode) {
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   ShelfNavigationWidget::TestApi test_api(
       GetPrimaryShelf()->navigation_widget());

ash/shelf/home_button_unittest.cc

@@ -650,7 +650,8 @@ TEST_P(HomeButtonTest, ClipRectDoesNotClipHomeButtonBounds) {
       EXPECT_TRUE(clip_rect_bounds().Contains(home_button_bounds()));
 
     // Create a test widget to transition to in-app shelf.
-    std::unique_ptr<views::Widget> widget = CreateTestWidget();
+    std::unique_ptr<views::Widget> widget =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     shelf_test_api.RunMessageLoopUntilAnimationsDone(
         test_api.GetBoundsAnimator());
 
@@ -667,7 +668,8 @@ TEST_P(HomeButtonTest, ClipRectDoesNotClipHomeButtonBounds) {
 
     // Open another window and go back to clamshell.
     ash::TabletModeControllerTestApi().LeaveTabletMode();
-    widget = CreateTestWidget();
+    widget =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     shelf_test_api.RunMessageLoopUntilAnimationsDone(
         test_api.GetBoundsAnimator());
 
@@ -775,7 +777,8 @@ TEST_P(HomeButtonTest, ButtonPositionInTabletMode) {
   }
 
   // Switch to in-app shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Wait for the navigation widget's animation.
   shelf_test_api.RunMessageLoopUntilAnimationsDone(

ash/shelf/shelf_config_unittest.cc

@@ -88,7 +88,8 @@ TEST_F(ShelfConfigTest, ShelfSizeChangesWithContext) {
   UpdateDisplay("300x1000");
   SetTabletMode(true);
   ASSERT_TRUE(IsTabletMode());
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   GetAppListTestHelper()->CheckVisibility(false);
   const int tablet_dense_in_app = ShelfConfig::Get()->shelf_size();
   const int system_shelf_tablet_dense_in_app =
@@ -104,7 +105,8 @@ TEST_F(ShelfConfigTest, ShelfSizeChangesWithContext) {
 
   UpdateDisplay("1100x1000");
   ASSERT_TRUE(IsTabletMode());
-  widget = CreateTestWidget();
+  widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   GetAppListTestHelper()->CheckVisibility(false);
   const int tablet_standard_in_app = ShelfConfig::Get()->shelf_size();
   const int system_shelf_tablet_standard_in_app =
@@ -126,7 +128,8 @@ TEST_F(ShelfConfigTest, ShelfSizeChangesWithContext) {
       ShelfConfig::Get()->system_shelf_size();
   const int control_clamshell_home = ShelfConfig::Get()->control_size();
 
-  widget = CreateTestWidget();
+  widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->Maximize();
   const int clamshell_in_app = ShelfConfig::Get()->shelf_size();
   const int system_shelf_clamshell_in_app =
@@ -162,7 +165,8 @@ TEST_F(ShelfConfigTest, InAppMode) {
 
   // Go into tablet mode, open a window. Now we're in an app.
   SetTabletMode(true);
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   EXPECT_TRUE(ShelfConfig::Get()->is_in_app());
 
   // Close the window. We should be back on the home screen.
@@ -170,7 +174,8 @@ TEST_F(ShelfConfigTest, InAppMode) {
   EXPECT_FALSE(ShelfConfig::Get()->is_in_app());
 
   // Open a window again.
-  widget = CreateTestWidget();
+  widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   EXPECT_TRUE(ShelfConfig::Get()->is_in_app());
 
   // Now go into overview.

ash/shelf/shelf_context_menu_model_unittest.cc

@@ -203,7 +203,8 @@ TEST_P(ShelfContextMenuModelTest, AutohideShelfOptionOnExternalDisplay) {
   int64_t secondary_id = GetSecondaryDisplay().id();
 
   // Create a normal window on the primary display.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->Show();
   widget->SetFullscreen(true);
 

ash/shelf/shelf_layout_manager_unittest.cc

@@ -614,7 +614,8 @@ TEST_F(ShelfLayoutManagerTest, VisibleWhenLockScreenShowing) {
             GetShelfWidget()->GetWindowBoundsInScreen().y());
 
   std::unique_ptr<views::Widget> lock_widget(AshTestBase::CreateTestWidget(
-      nullptr, kShellWindowId_LockScreenContainer, gfx::Rect(200, 200)));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      kShellWindowId_LockScreenContainer, gfx::Rect(200, 200)));
   lock_widget->Maximize();
 
   // Lock the screen.

ash/shelf/shelf_tooltip_manager_unittest.cc

@@ -122,7 +122,8 @@ TEST_F(ShelfTooltipManagerTest, HideWhenShelfIsHidden) {
   ASSERT_TRUE(tooltip_manager_->IsVisible());
 
   // Create a full-screen window to hide the shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->SetFullscreen(true);
 
   // Once the shelf is hidden, the tooltip should be invisible.
@@ -141,7 +142,8 @@ TEST_F(ShelfTooltipManagerTest, HideWhenShelfIsHidden) {
 
 TEST_F(ShelfTooltipManagerTest, HideWhenShelfIsAutoHideHidden) {
   // Create a visible window so auto-hide behavior can actually hide the shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ShowTooltipForFirstAppIcon();
   ASSERT_TRUE(tooltip_manager_->IsVisible());
 

ash/shelf/shelf_view_unittest.cc

@@ -1844,7 +1844,8 @@ TEST_P(LtrRtlShelfViewTest, TabletModeStartAndEndClosesContextMenu) {
 // Tests that ShelfWindowWatcher buttons show a context menu on right click.
 TEST_P(LtrRtlShelfViewTest, ShelfWindowWatcherButtonShowsContextMenu) {
   ui::test::EventGenerator* generator = GetEventGenerator();
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->Show();
   aura::Window* window = widget->GetNativeWindow();
   ShelfID shelf_id("123");
@@ -1860,7 +1861,8 @@ TEST_P(LtrRtlShelfViewTest, ShelfWindowWatcherButtonShowsContextMenu) {
 // Tests that the drag view is set on left click and not set on right click.
 TEST_P(LtrRtlShelfViewTest, ShelfDragViewAndContextMenu) {
   ui::test::EventGenerator* generator = GetEventGenerator();
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->Show();
   aura::Window* window = widget->GetNativeWindow();
   ShelfID shelf_id("123");
@@ -2108,7 +2110,8 @@ TEST_P(LtrRtlShelfViewTest, DragAppAfterContextMenuIsShownInAutoHideShelf) {
   const int last_index = model_->items().size() - 1;
 
   Shelf* shelf = GetPrimaryShelf();
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->Show();
   shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
@@ -2422,7 +2425,8 @@ TEST_P(LtrRtlShelfViewTest, ClickItemInFullscreen) {
                                    std::move(selection_tracker_owned));
 
   // Create a fullscreen widget.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->SetFullscreen(true);
   WindowState* window_state = WindowState::Get(widget->GetNativeWindow());
   window_state->SetHideShelfWhenFullscreen(true);
@@ -2460,7 +2464,8 @@ TEST_P(LtrRtlShelfViewTest, TapInFullscreen) {
                                    std::move(selection_tracker_owned));
 
   // Create a fullscreen widget.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->SetFullscreen(true);
   WindowState* window_state = WindowState::Get(widget->GetNativeWindow());
   window_state->SetHideShelfWhenFullscreen(true);

ash/shelf/shelf_widget_unittest.cc

@@ -876,7 +876,8 @@ TEST_F(ShelfWidgetTest, NoAnimationAfterDragPastIdealBounds) {
   ASSERT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
 
   // Create a widget to make sure that the shelf does auto-hide.
-  auto widget = CreateTestWidget();
+  auto widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ASSERT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   ASSERT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 

ash/shelf/shelf_window_watcher_unittest.cc

@@ -55,11 +55,13 @@ TEST_F(ShelfWindowWatcherTest, OpenAndClose) {
   ASSERT_EQ(0, model->item_count());
   // Windows with valid ShelfItemType and ShelfID properties get shelf items.
   std::unique_ptr<views::Widget> widget1 = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   CreateShelfItem(widget1->GetNativeWindow());
   EXPECT_EQ(1, model->item_count());
   std::unique_ptr<views::Widget> widget2 = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   CreateShelfItem(widget2->GetNativeWindow());
   EXPECT_EQ(2, model->item_count());
 
@@ -74,9 +76,11 @@ TEST_F(ShelfWindowWatcherTest, CreateAndRemoveShelfItemProperties) {
   ShelfModel* model = ShelfModel::Get();
   // Creating windows without a valid ShelfItemType does not add items.
   std::unique_ptr<views::Widget> widget1 = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   std::unique_ptr<views::Widget> widget2 = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   EXPECT_EQ(0, model->item_count());
 
   // Create a ShelfItem for the first window.
@@ -116,7 +120,8 @@ TEST_F(ShelfWindowWatcherTest, UpdateWindowProperty) {
   ShelfModel* model = ShelfModel::Get();
   // Create a ShelfItem for a new window.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   ShelfID id = CreateShelfItem(widget->GetNativeWindow());
   EXPECT_EQ(1, model->item_count());
 
@@ -134,7 +139,8 @@ TEST_F(ShelfWindowWatcherTest, MaximizeAndRestoreWindow) {
   ShelfModel* model = ShelfModel::Get();
   // Create a ShelfItem for a new window.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   ShelfID id = CreateShelfItem(widget->GetNativeWindow());
   EXPECT_EQ(1, model->item_count());
 
@@ -168,7 +174,8 @@ TEST_F(ShelfWindowWatcherTest, DragWindow) {
   ShelfModel* model = ShelfModel::Get();
   // Create a ShelfItem for a new window.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   ShelfID id = CreateShelfItem(widget->GetNativeWindow());
   EXPECT_EQ(1, model->item_count());
 
@@ -193,7 +200,8 @@ TEST_F(ShelfWindowWatcherTest, DialogWindows) {
   ShelfModel* model = ShelfModel::Get();
   // An item is created for a dialog window.
   std::unique_ptr<views::Widget> dialog_widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   aura::Window* dialog = dialog_widget->GetNativeWindow();
   dialog->SetProperty(kShelfIDKey, ShelfID("a").Serialize());
   dialog->SetProperty(kShelfItemTypeKey, static_cast<int32_t>(TYPE_DIALOG));
@@ -201,7 +209,8 @@ TEST_F(ShelfWindowWatcherTest, DialogWindows) {
 
   // An item is not created for an app window.
   std::unique_ptr<views::Widget> app_widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   aura::Window* app = app_widget->GetNativeWindow();
   app->SetProperty(kShelfIDKey, ShelfID("c").Serialize());
   app->SetProperty(kShelfItemTypeKey, static_cast<int32_t>(TYPE_APP));
@@ -218,7 +227,8 @@ TEST_F(ShelfWindowWatcherTest, ItemIcon) {
   ShelfModel* model = ShelfModel::Get();
   // Create a ShelfItem for a window; it should have a default icon.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   aura::Window* window = widget->GetNativeWindow();
   ShelfID id = CreateShelfItem(window);
   EXPECT_EQ(1, model->item_count());
@@ -316,7 +326,8 @@ TEST_F(ShelfWindowWatcherSessionStartTest, PreExistingWindow) {
 
   // Construct a window that should get a shelf item once the session starts.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect());
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect());
   CreateShelfItem(widget->GetNativeWindow());
   EXPECT_EQ(0, model->item_count());
 

ash/shell_unittest.cc

@@ -563,7 +563,8 @@ TEST_F(ShellTest, NoWindowTabFocus) {
   ShelfNavigationWidget* home_button = GetPrimaryShelf()->navigation_widget();
 
   // Create a normal window.  It is not maximized.
-  auto widget = CreateTestWidget();
+  auto widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Hit tab with window open, and expect that focus is not on the navigation
   // widget or status widget.

ash/style/system_components_unittests.cc

@@ -89,6 +89,7 @@ class WidgetWithSystemUIComponentView : public views::WidgetDelegateView {
 std::unique_ptr<views::Widget> CreateWidgetWithComponent(
     std::unique_ptr<views::View> component) {
   return AshTestBase::CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
       new WidgetWithSystemUIComponentView(std::move(component)));
 }
 
@@ -342,7 +343,8 @@ class SystemDialogSizeTest
     } else {
       UpdateDisplay("1280x720");
       host_widget_ =
-          CreateTestWidget(nullptr, desks_util::GetActiveDeskContainerId(),
+          CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                           nullptr, desks_util::GetActiveDeskContainerId(),
                            gfx::Rect(host_size), /*show=*/true);
     }
 

ash/style/system_shadow_unittest.cc

@@ -68,6 +68,7 @@ class SystemShadowColorTest
         {chromeos::features::kJelly, chromeos::features::kJellyroll}, {});
     // Create a test widget as the owner of the shadow instances.
     widget_ = CreateTestWidget(
+        views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
         /*delegate=*/nullptr,
         /*container_id=*/desks_util::GetActiveDeskContainerId(),
         /*bounds=*/gfx::Rect(100, 100, 320, 200));

ash/system/bluetooth/bluetooth_device_list_item_battery_view_unittest.cc

@@ -23,7 +23,8 @@ class BluetoothDeviceListItemBatteryViewTest : public AshTestBase {
   void SetUp() override {
     AshTestBase::SetUp();
 
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     bluetooth_device_list_battery_item_ =
         std::make_unique<BluetoothDeviceListItemBatteryView>();
     // Add the item to widget hierarchy to make sure `ui::ColorProvider` will

ash/system/bluetooth/bluetooth_device_list_item_multiple_battery_view_unittest.cc

@@ -61,7 +61,8 @@ class BluetoothDeviceListItemMultipleBatteryViewTest : public AshTestBase {
   void SetUp() override {
     AshTestBase::SetUp();
 
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     bluetooth_device_list_multiple_battery_item_ =
         std::make_unique<BluetoothDeviceListItemMultipleBatteryView>();
     // Add the item to widget hierarchy to make sure `ui::ColorProvider` will

ash/system/eche/eche_icon_loading_indicator_view_unittest.cc

@@ -34,7 +34,8 @@ class EcheIconLoadingIndicatorViewTest : public AshTestBase {
   // AshTestBase:
   void SetUp() override {
     AshTestBase::SetUp();
-    test_widget_ = CreateTestWidget();
+    test_widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     icon_ = std::make_unique<views::ImageView>();
     eche_icon_loading_indicatior_view_ =
         test_widget_->GetContentsView()->AddChildView(

ash/system/holding_space/holding_space_tray_unittest.cc

@@ -775,7 +775,8 @@ TEST_F(HoldingSpaceTrayTest, ShelfConfigChangeWithDelayedItemRemoval) {
   StartSession();
 
   // Create a test widget to force in-app shelf in tablet mode.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ASSERT_TRUE(widget);
 
   // The tray button should be hidden if the user has previously pinned an item,
@@ -2247,7 +2248,8 @@ TEST_F(HoldingSpacePreviewsTrayTest, UpdateTrayIconSizeForInAppShelf) {
   TabletModeControllerTestApi().EnterTabletMode();
 
   // Create a test widget to force in-app shelf.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ASSERT_TRUE(widget);
 
   EXPECT_TRUE(test_api()->IsShowingInShelf());
@@ -2278,7 +2280,8 @@ TEST_F(
   GetTray()->FirePreviewsUpdateTimerIfRunningForTesting();
 
   // Create a test widget and minimize it to transition to home screen.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ASSERT_TRUE(widget);
   widget->Minimize();
 

ash/system/notification_center/ash_message_popup_collection_unittest.cc

@@ -280,7 +280,8 @@ TEST_P(AshMessagePopupCollectionTest, AutoHide) {
 
   // Create a window, otherwise autohide doesn't work.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
   Shelf* shelf = GetPrimaryShelf();
   shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
   EXPECT_EQ(origin_x, popup_collection->GetPopupOriginX(popup_size));
@@ -377,7 +378,8 @@ TEST_P(AshMessagePopupCollectionTest, DISABLED_MixedFullscreenNone) {
   UpdateWorkArea(&collection2, GetSecondaryDisplay());
 
   // No fullscreens, both receive notification.
-  std::unique_ptr<views::Widget> widget1 = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget1->SetFullscreen(false);
   AddNotification();
   EXPECT_TRUE(collection1.popup_shown());
@@ -405,7 +407,8 @@ TEST_P(AshMessagePopupCollectionTest, DISABLED_MixedFullscreenSome) {
   UpdateWorkArea(&collection2, GetSecondaryDisplay());
 
   // One fullscreen, non-fullscreen receives notification.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->SetFullscreen(true);
   AddNotification();
   EXPECT_FALSE(collection1.popup_shown());
@@ -432,10 +435,11 @@ TEST_P(AshMessagePopupCollectionTest, DISABLED_MixedFullscreenAll) {
   TestMessagePopupCollection collection2(shelf2);
   UpdateWorkArea(&collection2, GetSecondaryDisplay());
 
-  std::unique_ptr<views::Widget> widget1 = CreateTestWidget();
-  std::unique_ptr<views::Widget> widget2 =
-      CreateTestWidget(nullptr, desks_util::GetActiveDeskContainerId(),
-                       gfx::Rect(700, 0, 50, 50));
+  std::unique_ptr<views::Widget> widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  std::unique_ptr<views::Widget> widget2 = CreateTestWidget(
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(700, 0, 50, 50));
 
   // Both fullscreen, no notifications.
   widget1->SetFullscreen(true);
@@ -497,7 +501,8 @@ TEST_P(AshMessagePopupCollectionTest, BaselineInOverview) {
 
   const int baseline_with_visible_shelf = popup_collection->GetBaseline();
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->SetFullscreen(true);
   ASSERT_EQ(SHELF_HIDDEN, GetPrimaryShelf()->GetVisibilityState());
   const int baseline_with_hidden_shelf = popup_collection->GetBaseline();
@@ -687,7 +692,8 @@ TEST_P(AshMessagePopupCollectionTest,
   // Create a window, otherwise autohide doesn't work.
   Shelf* shelf = GetPrimaryShelf();
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
   shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
   ASSERT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
@@ -840,7 +846,8 @@ TEST_P(AshMessagePopupCollectionTest,
   // Create a window, otherwise autohide doesn't work.
   Shelf* shelf = GetPrimaryShelf();
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
   shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
 
   auto* popup_collection = GetPrimaryPopupCollection();
@@ -1559,7 +1566,8 @@ TEST_P(AshMessagePopupCollectionTest, QsBubbleNotCloseWhenPopupClose) {
 
   // Create a window to simulate the step from b/291988617.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
 
   auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
   unified_system_tray->ShowBubble();

ash/system/notification_center/views/ash_notification_view_unittest.cc

@@ -1350,6 +1350,7 @@ class AshNotificationViewDragTestBase : public AshNotificationViewTestBase {
 
     // Configure the widget that handles notification drop.
     drop_handling_widget_ = CreateTestWidget(
+        views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
         /*delegate=*/nullptr, desks_util::GetActiveDeskContainerId(),
         /*bounds=*/gfx::Rect(100, 100, 300, 300), /*show=*/true);
     aura::client::SetDragDropDelegate(drop_handling_widget_->GetNativeView(),

ash/system/notification_center/views/conversation_notification_view_unittest.cc

@@ -28,7 +28,8 @@ class ConversationNotificationViewTest : public AshTestBase {
     notification_ = CreateConversationNotification();
 
     // `widget_` owns `notification_view_`.
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     notification_view_ = widget_->GetContentsView()->AddChildView(
         std::make_unique<ConversationNotificationView>(*notification_.get()));
   }

ash/system/notification_center/views/notification_actions_view_unittest.cc

@@ -32,7 +32,8 @@ class NotificationActionsViewTest : public AshTestBase {
     AshTestBase::SetUp();
 
     // `widget_` owns `actions_view_`.
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
     actions_view_ = widget_->GetContentsView()->AddChildView(
         std::make_unique<NotificationActionsView>());

ash/system/notification_center/views/timestamp_view_unittest.cc

@@ -24,7 +24,8 @@ class TimestampViewTest : public AshTestBase {
     AshTestBase::SetUp();
 
     // `widget_` owns `timestamp_view_`.
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     timestamp_view_ = widget_->GetContentsView()->AddChildView(
         std::make_unique<TimestampView>());
   }

ash/system/power/power_button_controller_unittest.cc

@@ -938,7 +938,8 @@ TEST_F(PowerButtonControllerTest, SuspendWithMenuOn) {
 
 // Tests the formerly-active window state in showing power menu.
 TEST_F(PowerButtonControllerTest, FormerlyActiveWindowInShowingMenu) {
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ASSERT_TRUE(widget->IsActive());
 
   OpenPowerButtonMenu();

ash/system/power/power_status_unittest.cc

@@ -196,7 +196,8 @@ TEST_F(PowerStatusTest, BatteryImageInfoIconBadge) {
 // Tests that the battery image changes appropriately with various power supply
 // property values.
 TEST_F(PowerStatusTest, BatteryImageInfoChargeLevel) {
-  const std::unique_ptr<views::Widget> test_widget = CreateTestWidget();
+  const std::unique_ptr<views::Widget> test_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   PowerSupplyProperties prop;
 
   // No charge level is drawn when the battery is not present.
@@ -317,7 +318,8 @@ TEST_F(PowerStatusTest, BatteryImageColorResolution) {
   prop.set_external_power(PowerSupplyProperties::DISCONNECTED);
   prop.set_battery_state(PowerSupplyProperties::DISCHARGING);
   power_status_->SetProtoForTesting(prop);
-  const std::unique_ptr<views::Widget> test_widget = CreateTestWidget();
+  const std::unique_ptr<views::Widget> test_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   const ui::ColorProvider* color_provider =
       test_widget->GetRootView()->GetColorProvider();
 

ash/system/session/logout_confirmation_controller_unittest.cc

@@ -258,8 +258,10 @@ TEST_F(LastWindowClosedTest, ManagedGuestSession) {
   EXPECT_FALSE(controller->dialog_for_testing());
 
   // Opening windows does not show the dialog.
-  std::unique_ptr<views::Widget> widget1 = CreateTestWidget();
-  std::unique_ptr<views::Widget> widget2 = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  std::unique_ptr<views::Widget> widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   EXPECT_FALSE(controller->dialog_for_testing());
 
   // Closing the last window shows the dialog.
@@ -280,8 +282,10 @@ TEST_F(LastWindowClosedTest, SuggestLogoutAfterClosingLastWindowPolicy) {
   EXPECT_FALSE(controller->dialog_for_testing());
 
   // Opening windows does not show the dialog.
-  std::unique_ptr<views::Widget> widget1 = CreateTestWidget();
-  std::unique_ptr<views::Widget> widget2 = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  std::unique_ptr<views::Widget> widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   EXPECT_FALSE(controller->dialog_for_testing());
 
   // Closing the last window does not show the dialog because the
@@ -323,7 +327,8 @@ TEST_F(LastWindowClosedTest, AlwaysOnTop) {
   StartManagedGuestSession();
 
   // The new widget starts in the default window container.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Moving the widget to the always-on-top container does not trigger the
   // dialog because the window didn't close.
@@ -341,8 +346,10 @@ TEST_F(LastWindowClosedTest, MultipleContainers) {
   StartManagedGuestSession();
 
   // Create two windows in different containers.
-  std::unique_ptr<views::Widget> normal_widget = CreateTestWidget();
-  std::unique_ptr<views::Widget> always_on_top_widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> normal_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  std::unique_ptr<views::Widget> always_on_top_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   always_on_top_widget->SetZOrderLevel(ui::ZOrderLevel::kFloatingWindow);
 
   // Closing the last window shows the dialog.

ash/system/tray/tray_background_view_unittest.cc

@@ -488,7 +488,8 @@ TEST_F(TrayBackgroundViewTest, ContextMenu) {
 // Tests the auto-hide shelf status when opening and closing a context menu.
 TEST_F(TrayBackgroundViewTest, AutoHideShelfWithContextMenu) {
   // Create one window, or the shelf won't auto-hide.
-  std::unique_ptr<views::Widget> unused = CreateTestWidget();
+  std::unique_ptr<views::Widget> unused =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Set the shelf to auto-hide.
   Shelf* shelf = test_tray_background_view()->shelf();

ash/system/tray/tray_event_filter_unittest.cc

@@ -362,12 +362,14 @@ TEST_F(TrayEventFilterTest, CloseTrayBubbleWhenWindowActivated) {
             system_tray->bubble()->GetBubbleView());
 
   // Showing a new window and activating it will close the system bubble.
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   EXPECT_TRUE(widget->IsActive());
   EXPECT_FALSE(system_tray->bubble());
 
   // Show a second widget.
-  std::unique_ptr<views::Widget> second_widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> second_widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   EXPECT_TRUE(second_widget->IsActive());
 
   // Re-show the system bubble.

ash/system/unified/notification_icons_controller_unittest.cc

@@ -82,7 +82,8 @@ class NotificationIconsControllerTest : public AshTestBase {
                      kShelfAutoHideBehaviorAlways);
 
     // Verify that the shelf auto-hides by creating and showing a window.
-    auto window = CreateTestWidget();
+    auto window =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     window->SetBounds(gfx::Rect(0, 0, 100, 100));
     CHECK(GetPrimaryShelf()->GetAutoHideState() ==
           ShelfAutoHideState::SHELF_AUTO_HIDE_HIDDEN);

ash/system/unified/user_chooser_detailed_view_controller_unittest.cc

@@ -109,7 +109,8 @@ TEST_F(UserChooserDetailedViewControllerTest, SwitchUserWithOverview) {
   ASSERT_NE(GetActiveUser(), secondary_user);
 
   // Create an activatable widget.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Enter overview mode.
   EnterOverview();

ash/system/video_conference/bubble/set_camera_background_view_unittest.cc

@@ -41,7 +41,8 @@ class SetCameraBackgroundViewTest : public AshTestBase {
     MockCameraEffectsController();
 
     // This widget is required to implicitly create ColorProvider.
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     widget_->GetContentsView()->AddChildView(
         std::make_unique<SetCameraBackgroundView>(nullptr, controller()));
   }

ash/system/video_conference/video_conference_tray_unittest.cc

@@ -167,7 +167,8 @@ class VideoConferenceTrayTest : public AshTestBase {
     Shelf* shelf = Shell::GetPrimaryRootWindowController()->shelf();
     shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
     // Create a normal unmaximized window; the shelf should then hide.
-    std::unique_ptr<views::Widget> widget = CreateTestWidget();
+    std::unique_ptr<views::Widget> widget =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     widget->SetBounds(gfx::Rect(0, 0, 100, 100));
 
     EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
@@ -759,7 +760,8 @@ TEST_F(VideoConferenceTrayTest, AutoHiddenShelfTwoDisplays) {
 
   // Create a second window on the secondary display, the shelf should hide on
   // the secondary display as well.
-  auto secondary_display_window = CreateTestWidget();
+  auto secondary_display_window =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   secondary_display_window->SetBounds(gfx::Rect(900, 0, 100, 100));
 
   auto* secondary_shelf =

ash/webui/common/backend/shortcut_input_provider_unittest.cc

@@ -76,7 +76,8 @@ class ShortcutInputProviderTest : public AshTestBase {
     shortcut_input_provider_->StartObservingShortcutInput(
         observer_->receiver.BindNewPipeAndPassRemote());
 
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     widget_->Show();
     widget_->Activate();
   }

ash/webui/diagnostics_ui/backend/input/input_data_provider_unittest.cc

@@ -672,7 +672,8 @@ class InputDataProviderTest : public AshTestBase {
     system::StatisticsProvider::SetTestProvider(&statistics_provider_);
 
     fake_udev_ = std::make_unique<testing::FakeUdevLoader>();
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     provider_ = std::make_unique<TestInputDataProvider>(
         widget_.get(), watchers_, &event_rewriter_delegate_);
     DiagnosticsLogController::Initialize(
@@ -1744,7 +1745,8 @@ TEST_F(InputDataProviderTest, KeyObservationDisconnect) {
 TEST_F(InputDataProviderTest, KeyObservationObeysFocusSwitching) {
   std::unique_ptr<FakeKeyboardObserver> fake_observer =
       std::make_unique<FakeKeyboardObserver>();
-  std::unique_ptr<views::Widget> other_widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> other_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   // Provider's widget must be active and visible.
   provider_->attached_widget_->Show();
@@ -2007,7 +2009,8 @@ TEST_F(InputDataProviderTest, KeyObservationMultipleProviders) {
   // Create a second InputDataProvider, with a separate window/widget,
   // as would happen if multiple instances of the SWA were created.
   watchers_t provider2_watchers;
-  auto provider2_widget = CreateTestWidget();
+  auto provider2_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   std::unique_ptr<TestInputDataProvider> provider2_ =
       std::make_unique<TestInputDataProvider>(provider2_widget.get(),
@@ -2137,7 +2140,8 @@ TEST_F(InputDataProviderTest, KeyObservationMultipleProviders) {
   fake_observer2->events_.clear();
 
   // Activate a new widget, ensuring neither previous window is active.
-  auto widget3 = CreateTestWidget();
+  auto widget3 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget3->Activate();
   base::RunLoop().RunUntilIdle();
 

ash/wm/client_controlled_state_unittest.cc

@@ -1409,7 +1409,8 @@ TEST_F(ClientControlledStateTest, Pinned) {
   EXPECT_FALSE(GetScreenPinningController()->IsPinned());
 
   // Two windows cannot be pinned simultaneously.
-  auto widget2 = CreateTestWidget();
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   WindowState* window_state_2 = WindowState::Get(widget2->GetNativeWindow());
   window_state_2->OnWMEvent(&pin_event);
   EXPECT_TRUE(window_state_2->IsPinned());
@@ -1473,7 +1474,8 @@ TEST_F(ClientControlledStateTest, TrustedPinnedBasic) {
   EXPECT_FALSE(GetScreenPinningController()->IsPinned());
 
   // Two windows cannot be trusted-pinned simultaneously.
-  auto widget2 = CreateTestWidget();
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   WindowState* window_state_2 = WindowState::Get(widget2->GetNativeWindow());
   window_state_2->OnWMEvent(&trusted_pin_event);
   EXPECT_TRUE(window_state_2->IsTrustedPinned());

ash/wm/container_finder_unittest.cc

@@ -20,7 +20,8 @@ using ContainerFinderTest = AshTestBase;
 TEST_F(ContainerFinderTest, GetContainerForWindow) {
   // Create a normal widget in the default container.
   std::unique_ptr<views::Widget> widget = CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(1, 2, 3, 4));
   aura::Window* window = widget->GetNativeWindow();
 
   // The window itself is not a container.

ash/wm/desks/desks_unittests.cc

@@ -3918,7 +3918,8 @@ TEST_P(DesksTest, AutohiddenShelfAnimatesAfterDeskSwitch) {
   NewDesk();
 
   // Create a window on the first desk so that the shelf will auto-hide there.
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->Maximize();
   // LayoutShelf() forces the animation to completion, at which point the
   // shelf should go off the screen.

ash/wm/desks/templates/saved_desk_unittest.cc

@@ -934,7 +934,8 @@ TEST_F(SavedDeskTest, SaveDeskButtonContainerAligned) {
   auto test_window1 = CreateAppWindow();
   auto test_window2 = CreateAppWindow();
   // A widget is needed to close.
-  auto test_widget = CreateTestWidget();
+  auto test_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   ToggleOverview();
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
@@ -4006,8 +4007,10 @@ TEST_F(SavedDeskTest, SaveDeskButtonContainerVisibleAfterSwipeToClose) {
   // Use a test widget so we can close it properly after swiping to close. The
   // order matters here; overview items are ordered by MRU order, so the most
   // recently created widget corresponds to the first overview item.
-  auto widget2 = CreateTestWidget();
-  auto widget1 = CreateTestWidget();
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   ToggleOverview();
 

ash/wm/lock_action_handler_layout_manager_unittest.cc

@@ -340,7 +340,8 @@ TEST_F(LockActionHandlerLayoutManagerTest, KeyboardBounds) {
 
   const int kAccessibilityPanelHeight = 45;
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, kShellWindowId_AccessibilityPanelContainer);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, kShellWindowId_AccessibilityPanelContainer);
   SetAccessibilityPanelHeight(kAccessibilityPanelHeight);
 
   target_bounds.Inset(gfx::Insets().set_top(kAccessibilityPanelHeight));

ash/wm/lock_layout_manager_unittest.cc

@@ -190,7 +190,8 @@ TEST_F(LockLayoutManagerTest, AccessibilityPanel) {
   // Create accessibility panel and set its height.
   int accessibility_panel_height = 45;
   std::unique_ptr<views::Widget> accessibility_panel_widget =
-      CreateTestWidget(nullptr, kShellWindowId_AccessibilityPanelContainer);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, kShellWindowId_AccessibilityPanelContainer);
   SetAccessibilityPanelHeight(accessibility_panel_height);
 
   views::Widget::InitParams widget_params(
@@ -349,7 +350,8 @@ TEST_F(LockLayoutManagerTest, AccessibilityPanelWithMultipleMonitors) {
   // Create accessibility panel and set its height.
   const int kAccessibilityPanelHeight = 45;
   std::unique_ptr<views::Widget> accessibility_panel_widget =
-      CreateTestWidget(nullptr, kShellWindowId_AccessibilityPanelContainer);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, kShellWindowId_AccessibilityPanelContainer);
   SetAccessibilityPanelHeight(kAccessibilityPanelHeight);
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();

ash/wm/mru_window_tracker_unittest.cc

@@ -205,7 +205,8 @@ TEST_P(MruWindowTrackerOrderTest, Basic) {
   auto delegate = std::make_unique<views::WidgetDelegateView>();
   delegate->SetModalType(ui::MODAL_TYPE_SYSTEM);
   std::unique_ptr<views::Widget> modal =
-      CreateTestWidget(delegate.release(), kShellWindowId_Invalid);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       delegate.release(), kShellWindowId_Invalid);
   EXPECT_EQ(modal.get()->GetNativeView()->parent()->GetId(),
             kShellWindowId_SystemModalContainer);
 

ash/wm/overlay_layout_manager_unittest.cc

@@ -23,7 +23,8 @@ TEST_F(OverlayLayoutManagerTest, FullscreenWidgetWithDisplayRotation) {
 
   // Create a fullscreen widget in the overlay container.
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, kShellWindowId_OverlayContainer);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, kShellWindowId_OverlayContainer);
   widget->SetFullscreen(true);
   EXPECT_EQ(gfx::Rect(0, 0, 800, 600), widget->GetWindowBoundsInScreen());
 

ash/wm/overview/overview_focus_cycler_old_unittest.cc

@@ -112,7 +112,8 @@ TEST_P(OverviewFocusCyclerOldTest, BasicTabKeyNavigationTablet) {
 
 // Tests that pressing Ctrl+W while a window is selected in overview closes it.
 TEST_P(OverviewFocusCyclerOldTest, CloseWindowWithKey) {
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   ToggleOverview();
 
   SendKeyUntilOverviewItemIsFocused(ui::VKEY_RIGHT, GetEventGenerator());
@@ -170,9 +171,12 @@ TEST_P(OverviewFocusCyclerOldTest, BasicArrowKeyNavigation) {
 // and when we tab again we pick up where we left off.
 // TODO(http://b/325335020): Port this test to `OverviewFocusCyclerTest`.
 TEST_P(OverviewFocusCyclerOldTest, ItemClosed) {
-  auto widget1 = CreateTestWidget();
-  auto widget2 = CreateTestWidget();
-  auto widget3 = CreateTestWidget();
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget3 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   ToggleOverview();
 
   auto* event_generator = GetEventGenerator();

ash/wm/overview/overview_session_unittest.cc

@@ -285,8 +285,10 @@ class OverviewSessionTest
 // Tests that close buttons on windows in overview do not work
 // when one window is being dragged.
 TEST_P(OverviewSessionTest, CloseButtonDisabledOnDrag) {
-  std::unique_ptr<views::Widget> widget1(CreateTestWidget());
-  std::unique_ptr<views::Widget> widget2(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget1(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
+  std::unique_ptr<views::Widget> widget2(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
 
   aura::Window* window1 = widget1->GetNativeWindow();
   aura::Window* window2 = widget2->GetNativeWindow();
@@ -349,7 +351,8 @@ TEST_P(OverviewSessionTest, CloseButtonDisabledOnDrag) {
 // Tests that close buttons on windows in overview are re-enabled
 // when one window is snapped to a side of the screen.
 TEST_P(OverviewSessionTest, CloseButtonEnabledOnSnap) {
-  std::unique_ptr<views::Widget> widget2 = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   std::unique_ptr<aura::Window> window1 = CreateTestWindow();
   aura::Window* window2 = widget2->GetNativeWindow();
@@ -666,7 +669,8 @@ TEST_P(OverviewSessionTest, ActiveWindowChangedUserActionNotRecorded) {
 TEST_P(OverviewSessionTest, ActiveWindowChangedUserActionWindowClose) {
   base::UserActionTester user_action_tester;
   std::unique_ptr<views::Widget> widget(CreateTestWidget(
-      nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(400, 400)));
+      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
+      desks_util::GetActiveDeskContainerId(), gfx::Rect(400, 400)));
 
   ToggleOverview();
   aura::Window* window = widget->GetNativeWindow();
@@ -769,8 +773,10 @@ TEST_P(OverviewSessionTest, WindowDoesNotReceiveEvents) {
 
 // Tests that clicking on the close button effectively closes the window.
 TEST_P(OverviewSessionTest, CloseButton) {
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
-  std::unique_ptr<views::Widget> minimized_widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
+  std::unique_ptr<views::Widget> minimized_widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   minimized_widget->Minimize();
 
   ToggleOverview();
@@ -812,7 +818,8 @@ TEST_P(OverviewSessionTest, CloseAnimationShadow) {
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
-  std::unique_ptr<views::Widget> widget = CreateTestWidget();
+  std::unique_ptr<views::Widget> widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   ToggleOverview();
   ShellTestApi().WaitForOverviewAnimationState(
@@ -832,7 +839,8 @@ TEST_P(OverviewSessionTest, CloseAnimationShadow) {
 
 // Tests minimizing/unminimizing in overview mode.
 TEST_P(OverviewSessionTest, MinimizeUnminimize) {
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   aura::Window* window = widget->GetNativeWindow();
 
   ToggleOverview();
@@ -859,7 +867,8 @@ TEST_P(OverviewSessionTest, CloseButtonOnMultipleDisplay) {
   // closed or not. Parent the window to a window in a non-primary root window.
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(650, 300, 250, 450)));
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   widget->SetBounds(gfx::Rect(650, 0, 400, 400));
   aura::Window* window2 = widget->GetNativeWindow();
   window2->SetProperty(aura::client::kTopViewInset,
@@ -1158,7 +1167,8 @@ TEST_P(OverviewSessionTest, DesksWidgetBoundsChangeWhenDisableChromeVox) {
   // ChromeVox layout manager relies on the widget to validate ChromaVox panel's
   // exist. Check AccessibilityPanelLayoutManager::SetPanelBounds.
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, kShellWindowId_AccessibilityPanelContainer);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, kShellWindowId_AccessibilityPanelContainer);
   SetAccessibilityPanelHeight(kAccessibilityPanelHeight);
   accessibility_controller->SetSpokenFeedbackEnabled(true,
                                                      A11Y_NOTIFICATION_NONE);
@@ -2057,8 +2067,10 @@ TEST_P(OverviewSessionTest, ExitOverviewWhenAllGridsEmpty) {
   // Create two windows with widgets (widgets are needed to close the windows
   // later in the test), one each on the first two monitors.
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
-  std::unique_ptr<views::Widget> widget1(CreateTestWidget());
-  std::unique_ptr<views::Widget> widget2(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget1(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
+  std::unique_ptr<views::Widget> widget2(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   aura::Window* window1 = widget1->GetNativeWindow();
   aura::Window* window2 = widget2->GetNativeWindow();
   ASSERT_TRUE(
@@ -2274,7 +2286,8 @@ TEST_P(OverviewSessionTest, HandleActiveWindowNotInOverviewGrid) {
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
   // Create and active a new window should exit overview without error.
-  auto widget = CreateTestWidget();
+  auto widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   TweenTester tester1(window1.get());
   TweenTester tester2(window2.get());
@@ -6559,8 +6572,10 @@ TEST_F(OverviewSessionFlingTest, BasicFling) {
 TEST_F(TabletModeOverviewSessionTest, VerticalScrollingOnOverviewItem) {
   constexpr int kNumWidgets = 8;
   std::vector<std::unique_ptr<views::Widget>> widgets(kNumWidgets);
-  for (int i = kNumWidgets - 1; i >= 0; --i)
-    widgets[i] = CreateTestWidget();
+  for (int i = kNumWidgets - 1; i >= 0; --i) {
+    widgets[i] =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  }
   ToggleOverview();
   ASSERT_TRUE(InOverviewSession());
 
@@ -6718,7 +6733,8 @@ TEST_F(TabletModeOverviewSessionTest, DragOverviewWindowToSnap) {
 // will be closed.
 TEST_F(TabletModeOverviewSessionTest, DragToClose) {
   // This test requires a widget.
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
 
   ToggleOverview();
   ASSERT_TRUE(GetOverviewController()->InOverviewSession());
@@ -6750,7 +6766,8 @@ TEST_F(TabletModeOverviewSessionTest, DragToClose) {
 // will be closed.
 TEST_F(TabletModeOverviewSessionTest, FlingToClose) {
   // This test requires a widget.
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
 
   ToggleOverview();
   ASSERT_TRUE(GetOverviewController()->InOverviewSession());

ash/wm/snap_group/snap_group_unittest.cc

@@ -8002,7 +8002,8 @@ TEST_F(SnapGroupA11yTest, ResizeVertical) {
   // Simulate enabling ChromeVox.
   const int kAccessibilityPanelHeight = 45;
   std::unique_ptr<views::Widget> widget =
-      CreateTestWidget(nullptr, kShellWindowId_AccessibilityPanelContainer);
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
+                       nullptr, kShellWindowId_AccessibilityPanelContainer);
   SetAccessibilityPanelHeight(kAccessibilityPanelHeight);
   Shell::Get()->accessibility_controller()->spoken_feedback().SetEnabled(true);
   const gfx::Rect work_area_with_cvox(work_area_bounds());

ash/wm/splitview/split_view_controller_unittest.cc

@@ -2767,7 +2767,8 @@ TEST_F(SplitViewControllerTest, ActivateNonSnappableWindow) {
 // Tests that if a snapped window has a bubble transient child, the bubble's
 // bounds should always align with the snapped window's bounds.
 TEST_F(SplitViewControllerTest, AdjustTransientChildBounds) {
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   aura::Window* window = widget->GetNativeWindow();
   window->SetProperty(aura::client::kResizeBehaviorKey,
                       aura::client::kResizeBehaviorCanResize |
@@ -3247,7 +3248,8 @@ TEST_F(SplitViewControllerTest, DoNotObserveTransientIfNotInSplitview) {
 
   // Add another two windows with one being a bubble transient child of the
   // other.
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   aura::Window* parent = widget->GetNativeWindow();
   parent->SetProperty(aura::client::kResizeBehaviorKey,
                       aura::client::kResizeBehaviorCanResize |
@@ -4074,7 +4076,8 @@ TEST_F(SplitViewControllerTest,
 TEST_F(SplitViewControllerTest,
        ClamshellConversionWithSnappedWindowWithTransient) {
   // Create a widget with a transient bubble widget.
-  std::unique_ptr<views::Widget> widget(CreateTestWidget());
+  std::unique_ptr<views::Widget> widget(
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET));
   aura::Window* window = widget->GetNativeWindow();
   window->SetProperty(aura::client::kResizeBehaviorKey,
                       aura::client::kResizeBehaviorCanResize |

ash/wm/splitview/split_view_highlight_view_unittest.cc

@@ -34,7 +34,8 @@ class SplitViewHighlightViewTest : public AshTestBase {
   void SetUp() override {
     AshTestBase::SetUp();
 
-    widget_ = CreateTestWidget();
+    widget_ =
+        CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
     left_highlight_ =
         widget_->widget_delegate()->GetContentsView()->AddChildView(
             std::make_unique<SplitViewHighlightView>(false));

ash/wm/window_mirror_view_unittest.cc

@@ -19,14 +19,16 @@ namespace {
 using WindowMirrorViewTest = AshTestBase;
 
 TEST_F(WindowMirrorViewTest, LocalWindowOcclusionMadeVisible) {
-  auto widget = CreateTestWidget();
+  auto widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   widget->Hide();
   aura::Window* widget_window = widget->GetNativeWindow();
   widget_window->TrackOcclusionState();
   EXPECT_EQ(aura::Window::OcclusionState::HIDDEN,
             widget_window->GetOcclusionState());
 
-  auto mirror_widget = CreateTestWidget();
+  auto mirror_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   auto mirror_view = std::make_unique<WindowMirrorView>(widget_window);
   mirror_widget->widget_delegate()->GetContentsView()->AddChildView(
       mirror_view.get());
@@ -43,12 +45,14 @@ TEST_F(WindowMirrorViewTest, LocalWindowOcclusionMadeVisible) {
 TEST_F(WindowMirrorViewTest, MirrorLayerHasNoTransformWhenNonClientViewShown) {
   // Create a window that has a transform already. When the layer is mirrored,
   // the transform will be copied with it.
-  auto widget = CreateTestWidget();
+  auto widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   aura::Window* widget_window = widget->GetNativeWindow();
   const auto transform = gfx::Transform::MakeTranslation(100.f, 100.f);
   widget_window->SetTransform(transform);
 
-  auto mirror_widget = CreateTestWidget();
+  auto mirror_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   auto mirror_view = std::make_unique<WindowMirrorView>(
       widget_window, /*show_non_client_view=*/true);
   mirror_view->RecreateMirrorLayers();

ash/wm/window_preview_view_unittest.cc

@@ -39,8 +39,10 @@ std::unique_ptr<views::Widget> CreateTransientChild(
 // transience, WindowPreviewView's internal collection will contain both those
 // two windows.
 TEST_F(WindowPreviewViewTest, Basic) {
-  auto widget1 = CreateTestWidget();
-  auto widget2 = CreateTestWidget();
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   wm::AddTransientChild(widget1->GetNativeWindow(), widget2->GetNativeWindow());
   auto preview_view =
@@ -66,9 +68,12 @@ TEST_F(WindowPreviewViewTest, AspectRatio) {
 // Tests that WindowPreviewView behaves as expected when we add or remove
 // transient children.
 TEST_F(WindowPreviewViewTest, TransientChildAddedAndRemoved) {
-  auto widget1 = CreateTestWidget();
-  auto widget2 = CreateTestWidget();
-  auto widget3 = CreateTestWidget();
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget3 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   ::wm::AddTransientChild(widget1->GetNativeWindow(),
                           widget2->GetNativeWindow());
@@ -91,7 +96,8 @@ TEST_F(WindowPreviewViewTest, TransientChildAddedAndRemoved) {
 // WindowPreviewView is observing transient windows additions.
 // https://crbug.com/1003544.
 TEST_F(WindowPreviewViewTest, NoCrashWithTransientChildWithNoWindowState) {
-  auto widget1 = CreateTestWidget();
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   auto transient_child1 = CreateTransientChild(
       widget1.get(), views::Widget::InitParams::TYPE_WINDOW);
@@ -133,7 +139,8 @@ TEST_F(WindowPreviewViewTest, NoCrashWithTransientChildWithNoWindowState) {
 // doesn't introduce a crash. https://crbug.com/1014543.
 TEST_F(WindowPreviewViewTest,
        NoCrashWhenWindowCyclingIsCanceledWithATransientPopup) {
-  auto widget1 = CreateTestWidget();
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   auto preview_view =
       std::make_unique<WindowPreviewView>(widget1->GetNativeWindow());
@@ -153,8 +160,10 @@ TEST_F(WindowPreviewViewTest, LayoutChildWithinParentBounds) {
 
   // Create two widgets linked transiently. The child window is within the
   // bounds of the parent window.
-  auto widget1 = CreateTestWidget();
-  auto widget2 = CreateTestWidget();
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   WindowState::Get(widget1->GetNativeWindow())
       ->SetBoundsDirectForTesting(gfx::Rect(0, -20, 100, 120));
   widget1->GetNativeWindow()->SetProperty(aura::client::kTopViewInset, 20);
@@ -186,8 +195,10 @@ TEST_F(WindowPreviewViewTest, LayoutChildOutsideParentBounds) {
 
   // Create two widgets linked transiently. The child window is outside of the
   // bounds of the parent window.
-  auto widget1 = CreateTestWidget();
-  auto widget2 = CreateTestWidget();
+  auto widget1 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
+  auto widget2 =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   WindowState::Get(widget1->GetNativeWindow())
       ->SetBoundsDirectForTesting(gfx::Rect(0, -20, 200, 220));
   widget1->GetNativeWindow()->SetProperty(aura::client::kTopViewInset, 20);

ash/wm/window_state_unittest.cc

@@ -291,12 +291,14 @@ TEST_F(WindowStateTest, CanTransitionToPipWindow) {
 TEST_F(WindowStateTest, PipWindowIsSetBeforeWidgetDeactivate) {
   // Make `background_widget` to trigger shelf visibility change after
   // entering PIP.
-  auto background_widget = CreateTestWidget();
+  auto background_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   auto* window_state = WindowState::Get(background_widget->GetNativeWindow());
   const WMEvent enter_fullscreen(WM_EVENT_FULLSCREEN);
   window_state->OnWMEvent(&enter_fullscreen);
 
-  auto pip_widget = CreateTestWidget();
+  auto pip_widget =
+      CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   auto* pip_window_state = WindowState::Get(pip_widget->GetNativeWindow());
   const WMEvent enter_pip(WM_EVENT_PIP);