Removes code using mus client lib

ui/views/widget/widget_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <memory>
 #include <set>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 294 matching lines @@
   EXPECT_TRUE(child->IsVisible());
   EXPECT_TRUE(IsWindowStackedAbove(child, parent.get()));
   EXPECT_FALSE(IsWindowStackedAbove(parent.get(), child));  // Sanity check.
 
   WidgetAutoclosePtr popover(CreateTopLevelPlatformWidget());
   popover->SetBounds(gfx::Rect(150, 90, 340, 240));
   popover->Show();
 
   // NOTE: for aura-mus-client stacking of top-levels is not maintained in the
   // client, so z-order of top-levels can't be determined.
-  const bool check_toplevel_z_order = !IsAuraMusClient();
+  const bool check_toplevel_z_order = !IsMus();
   if (check_toplevel_z_order)
     EXPECT_TRUE(IsWindowStackedAbove(popover.get(), child));
   EXPECT_TRUE(IsWindowStackedAbove(child, parent.get()));
 
   // Showing the parent again should raise it and its child above the popover.
   parent->Show();
   EXPECT_TRUE(IsWindowStackedAbove(child, parent.get()));
   if (check_toplevel_z_order)
     EXPECT_TRUE(IsWindowStackedAbove(parent.get(), popover.get()));
 
@@ skipping 655 matching lines @@
   EXPECT_TRUE(child_observer.widget_closed());
 }
 
 // Test behavior of NativeWidget*::GetWindowPlacement on the native desktop.
 TEST_F(WidgetTest, GetWindowPlacement) {
 #if defined(OS_MACOSX)
   if (base::mac::IsOS10_10())
     return;  // Fails when swarmed. http://crbug.com/660582
 #endif
 
-  if (IsMus()) {
-    NOTIMPLEMENTED();
-    return;
-  }
-
   WidgetAutoclosePtr widget;
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // On desktop-Linux cheat and use non-desktop widgets. On X11, minimize is
   // asynchronous. Also (harder) showing a window doesn't activate it without
   // user interaction (or extra steps only done for interactive ui tests).
   // Without that, show_state remains in ui::SHOW_STATE_INACTIVE throughout.
   // TODO(tapted): Find a nice way to run this with desktop widgets on Linux.
   widget.reset(CreateTopLevelPlatformWidget());
 #else
   widget.reset(CreateNativeDesktopWidget());
@@ skipping 90 matching lines @@
   EXPECT_EQ(minimum_size, GetNativeWidgetMinimumContentSize(widget));
 
   // Trying to resize smaller than the minimum size should restrict the content
   // size to the minimum size.
   widget->SetBounds(gfx::Rect(smaller_size));
   EXPECT_EQ(minimum_size, widget->GetClientAreaBoundsInScreen().size());
 
   widget->SetSize(smaller_size);
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // TODO(tapted): Desktop Linux ignores size constraints for SetSize. Fix it.
-  const bool use_small_size = IsMus() ? false : true;
+  const bool use_small_size = true;
 #else
   const bool use_small_size = false;
 #endif
   EXPECT_EQ(use_small_size ? smaller_size : minimum_size,
             widget->GetClientAreaBoundsInScreen().size());
 }
 
 // Tests that SetBounds() and GetWindowBoundsInScreen() is symmetric when the
 // widget is visible and not maximized or fullscreen.
 TEST_F(WidgetTest, GetWindowBoundsInScreen) {
@@ skipping 55 matching lines @@
 // Disable on Linux because windows restore to the wrong bounds.
 // See http://crbug.com/515369.
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
 #define MAYBE_GetRestoredBounds DISABLED_GetRestoredBounds
 #else
 #define MAYBE_GetRestoredBounds GetRestoredBounds
 #endif
 
 // Test that GetRestoredBounds() returns the original bounds of the window.
 TEST_F(WidgetTest, MAYBE_GetRestoredBounds) {
-  if (IsMus()) {
-    NOTIMPLEMENTED();
-    return;
-  }
-
   WidgetAutoclosePtr toplevel(CreateNativeDesktopWidget());
   toplevel->Show();
   // Initial restored bounds have non-zero size.
   EXPECT_FALSE(toplevel->GetRestoredBounds().IsEmpty());
 
   const gfx::Rect bounds(100, 100, 200, 200);
   toplevel->SetBounds(bounds);
   EXPECT_EQ(bounds, toplevel->GetWindowBoundsInScreen());
   EXPECT_EQ(bounds, toplevel->GetRestoredBounds());
 
@@ skipping 101 matching lines @@
   }
 
   anchor->Hide();
 }
 
 #if defined(OS_WIN)
 // Test to ensure that after minimize, view width is set to zero. This is only
 // the case for desktop widgets on Windows. Other platforms retain the window
 // size while minimized.
 TEST_F(WidgetTest, TestViewWidthAfterMinimizingWidget) {
-  if (IsMus()) {
-    // This test is testing behavior specific to DesktopWindowTreeHostWin.
-    return;
-  }
   // Create a widget.
   Widget widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 300, 400);
   init_params.bounds = initial_bounds;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.native_widget =
       CreatePlatformDesktopNativeWidgetImpl(init_params, &widget, nullptr);
@@ skipping 89 matching lines @@
 
   View* contents_view = new View;
   contents_view->SetFocusBehavior(View::FocusBehavior::ALWAYS);
   SetContentsView(contents_view);
 
   Show();
   Activate();
 }
 
 TEST_F(WidgetTest, DesktopNativeWidgetNoPaintAfterCloseTest) {
-  // TODO(sad): Desktop widgets do not work well in mus https://crbug.com/616551
-  if (IsMus())
-    return;
   DesktopAuraTestValidPaintWidget widget;
   widget.InitForTest(CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS));
   widget.WaitUntilPaint();
   EXPECT_TRUE(widget.ReadReceivedPaintAndReset());
   widget.SchedulePaintInRect(widget.GetRestoredBounds());
   widget.Close();
   RunPendingMessages();
   EXPECT_FALSE(widget.ReadReceivedPaintAndReset());
   EXPECT_FALSE(widget.received_paint_while_hidden());
 }
 
 TEST_F(WidgetTest, DesktopNativeWidgetNoPaintAfterHideTest) {
-  // TODO(sad): Desktop widgets do not work well in mus https://crbug.com/616551
-  if (IsMus())
-    return;
   DesktopAuraTestValidPaintWidget widget;
   widget.InitForTest(CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS));
   widget.WaitUntilPaint();
   EXPECT_TRUE(widget.ReadReceivedPaintAndReset());
   widget.SchedulePaintInRect(widget.GetRestoredBounds());
   widget.Hide();
   RunPendingMessages();
   EXPECT_FALSE(widget.ReadReceivedPaintAndReset());
   EXPECT_FALSE(widget.received_paint_while_hidden());
   widget.Close();
@@ skipping 247 matching lines @@
 
   widget->Show();
 
   // SynthesizeMouseMoveEvent does nothing until the mouse is entered.
   widget->SynthesizeMouseMoveEvent();
   EXPECT_EQ(0, v1->GetEventCount(ui::ET_MOUSE_MOVED));
   EXPECT_EQ(0, v2->GetEventCount(ui::ET_MOUSE_MOVED));
 
   gfx::Point cursor_location(5, 5);
   ui::test::EventGenerator generator(
-      IsMus() || IsAuraMusClient() ? widget->GetNativeWindow() : GetContext(),
+      IsMus() ? widget->GetNativeWindow() : GetContext(),
       widget->GetNativeWindow());
   generator.MoveMouseTo(cursor_location);
 
   EXPECT_EQ(1, v1->GetEventCount(ui::ET_MOUSE_MOVED));
   EXPECT_EQ(0, v2->GetEventCount(ui::ET_MOUSE_MOVED));
 
   // SynthesizeMouseMoveEvent dispatches an mousemove event.
   widget->SynthesizeMouseMoveEvent();
   EXPECT_EQ(2, v1->GetEventCount(ui::ET_MOUSE_MOVED));
 
@@ skipping 36 matching lines @@
   widget->SetSize(gfx::Size(300, 300));
 
   EventCountView* event_count_view = new EventCountView();
   event_count_view->SetBounds(0, 0, 300, 300);
   widget->GetRootView()->AddChildView(event_count_view);
 
   MousePressEventConsumer consumer;
   event_count_view->AddPostTargetHandler(&consumer);
 
   ui::test::EventGenerator generator(
-      IsMus() || IsAuraMusClient() ? widget->GetNativeWindow() : GetContext(),
+      IsMus() ? widget->GetNativeWindow() : GetContext(),
       widget->GetNativeWindow());
   generator.PressTouch();
   generator.ClickLeftButton();
 
   EXPECT_EQ(1, event_count_view->GetEventCount(ui::ET_MOUSE_PRESSED));
   EXPECT_EQ(1, event_count_view->GetEventCount(ui::ET_MOUSE_RELEASED));
 
   // For mus it's important we destroy the widget before the EventGenerator.
   widget->CloseNow();
 }
@@ skipping 11 matching lines @@
   event_count_view->SetBounds(0, 0, 300, 300);
   widget->GetRootView()->AddChildView(event_count_view);
 
   // No capture has been set.
   EXPECT_EQ(nullptr, internal::NativeWidgetPrivate::GetGlobalCapture(
                          widget->GetNativeView()));
 
   MousePressEventConsumer consumer;
   event_count_view->AddPostTargetHandler(&consumer);
   ui::test::EventGenerator generator(
-      IsMus() || IsAuraMusClient() ? widget->GetNativeWindow() : GetContext(),
+      IsMus() ? widget->GetNativeWindow() : GetContext(),
       widget->GetNativeWindow());
   generator.PressLeftButton();
 
   EXPECT_EQ(1, event_count_view->GetEventCount(ui::ET_MOUSE_PRESSED));
   EXPECT_EQ(
       widget->GetNativeView(),
       internal::NativeWidgetPrivate::GetGlobalCapture(widget->GetNativeView()));
 
   // For mus it's important we destroy the widget before the EventGenerator.
   widget->CloseNow();
@@ skipping 42 matching lines @@
   widget->GetRootView()->AddChildView(event_count_view);
 
   EXPECT_EQ(nullptr, internal::NativeWidgetPrivate::GetGlobalCapture(
                          widget->GetNativeView()));
 
   Widget* widget2 = CreateTopLevelNativeWidget();
   // Gives explicit capture to |widget2|
   CaptureEventConsumer consumer(widget2);
   event_count_view->AddPostTargetHandler(&consumer);
   ui::test::EventGenerator generator(
-      IsMus() || IsAuraMusClient() ? widget->GetNativeWindow() : GetContext(),
+      IsMus() ? widget->GetNativeWindow() : GetContext(),
       widget->GetNativeWindow());
   // This event should implicitly give capture to |widget|, except that
   // |consumer| will explicitly set capture on |widget2|.
   generator.PressLeftButton();
 
   EXPECT_EQ(1, event_count_view->GetEventCount(ui::ET_MOUSE_PRESSED));
   EXPECT_NE(
       widget->GetNativeView(),
       internal::NativeWidgetPrivate::GetGlobalCapture(widget->GetNativeView()));
   EXPECT_EQ(
@@ skipping 64 matching lines @@
 // DesktopNativeWidget does not exist on non-Aura or on ChromeOS.
 #if !defined(OS_CHROMEOS)
 TEST_F(WidgetWindowTitleTest, SetWindowTitleChanged_DesktopNativeWidget) {
   // Override to use a DesktopNativeWidget.
   bool desktop_native_widget = true;
   RunTest(desktop_native_widget);
 }
 #endif  // !OS_CHROMEOS
 
 TEST_F(WidgetTest, WidgetDeleted_InOnMousePressed) {
-  // This test doesn't work in mus as it assumes widget and GetContext()
-  // share an aura hierarchy. Test coverage of deletion from mouse pressed is
-  // important though and should be added, hence the NOTIMPLEMENTED().
-  // http://crbug.com/594260.
-  if (IsMus()) {
-    NOTIMPLEMENTED();
-    return;
-  }
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
-  if (IsAuraMusClient())
+  if (IsMus())
     return;
 
   Widget* widget = new Widget;
   Widget::InitParams params =
       CreateParams(views::Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
 
   widget->SetContentsView(new CloseWidgetView(ui::ET_MOUSE_PRESSED));
 
   widget->SetSize(gfx::Size(100, 100));
   widget->Show();
 
   ui::test::EventGenerator generator(GetContext(), widget->GetNativeWindow());
 
   WidgetDeletionObserver deletion_observer(widget);
   generator.ClickLeftButton();
   EXPECT_FALSE(deletion_observer.IsWidgetAlive());
 
   // Yay we did not crash!
 }
 
 // No touch on desktop Mac. Tracked in http://crbug.com/445520.
 #if !defined(OS_MACOSX) || defined(USE_AURA)
 
 TEST_F(WidgetTest, WidgetDeleted_InDispatchGestureEvent) {
-  // This test doesn't make sense for mus.
-  if (IsMus())
-    return;
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
-  if (IsAuraMusClient())
+  if (IsMus())
     return;
 
   Widget* widget = new Widget;
   Widget::InitParams params =
       CreateParams(views::Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
 
   widget->SetContentsView(new CloseWidgetView(ui::ET_GESTURE_TAP_DOWN));
 
   widget->SetSize(gfx::Size(100, 100));
@@ skipping 210 matching lines @@
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
 }
 
 // Tests that we do not crash when a Widget is destroyed before it finishes
 // processing of pending input events in the message loop.
 TEST_F(WidgetTest, NoCrashOnWidgetDeleteWithPendingEvents) {
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
-  if (IsAuraMusClient())
+  if (IsMus())
     return;
 
   std::unique_ptr<Widget> widget(new Widget);
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
   params.bounds = gfx::Rect(0, 0, 200, 200);
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
   widget->Show();
 
   ui::test::EventGenerator generator(GetContext(), widget->GetNativeWindow());
@@ skipping 1024 matching lines @@
 
   parent_widget.CloseNow();
 }
 #endif  // !defined(OS_CHROMEOS)
 
 // Tests that events propagate through from the dispatcher with the correct
 // event type, and that the different platforms behave the same.
 TEST_F(WidgetTest, MouseEventTypesViaGenerator) {
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
-  if (IsAuraMusClient())
+  if (IsMus())
     return;
 
   EventCountView* view = new EventCountView;
   view->set_handle_mode(EventCountView::CONSUME_EVENTS);
   view->SetBounds(10, 10, 50, 40);
 
   WidgetAutoclosePtr widget(CreateTopLevelFramelessPlatformWidget());
   widget->GetRootView()->AddChildView(view);
 
   widget->SetBounds(gfx::Rect(0, 0, 100, 80));
@@ skipping 256 matching lines @@
   EXPECT_TRUE(subclass_helper.received_message(WM_NCLBUTTONDOWN));
   EXPECT_TRUE(subclass_helper.received_message(WM_SYSCOMMAND));
 
   widget.CloseNow();
 }
 
 #endif
 
 // Test that SetAlwaysOnTop and IsAlwaysOnTop are consistent.
 TEST_F(WidgetTest, AlwaysOnTop) {
-  if (IsMus()) {
-    NOTIMPLEMENTED();
-    return;
-  }
-
   WidgetAutoclosePtr widget(CreateTopLevelNativeWidget());
   EXPECT_FALSE(widget->IsAlwaysOnTop());
   widget->SetAlwaysOnTop(true);
   EXPECT_TRUE(widget->IsAlwaysOnTop());
   widget->SetAlwaysOnTop(false);
   EXPECT_FALSE(widget->IsAlwaysOnTop());
 }
 
 namespace {
 
@@ skipping 14 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ScaleFactorView);
 };
 
 }
 
 // Ensure scale factor changes are propagated from the native Widget.
 TEST_F(WidgetTest, OnDeviceScaleFactorChanged) {
   // This relies on the NativeWidget being the WindowDelegate, which is not the
   // case for aura-mus-client.
-  if (IsAuraMusClient())
+  if (IsMus())
     return;
 
   // Automatically close the widget, but not delete it.
   WidgetAutoclosePtr widget(CreateTopLevelPlatformWidget());
   ScaleFactorView* view = new ScaleFactorView;
   widget->GetRootView()->AddChildView(view);
   float scale_factor = widget->GetLayer()->device_scale_factor();
   EXPECT_NE(scale_factor, 0.f);
 
   // For views that are not layer-backed, adding the view won't notify the view
@@ skipping 89 matching lines @@
   widget2->client_view()->AddChildView(child);
   EXPECT_TRUE(removals_observer.DidRemoveView(child));
 
   widget->RemoveRemovalsObserver(&removals_observer);
 }
 
 // Test dispatch of ui::ET_MOUSEWHEEL.
 TEST_F(WidgetTest, MouseWheelEvent) {
   // TODO: test uses GetContext(), which is not applicable to aura-mus.
   // http://crbug.com/663809.
-  if (IsAuraMusClient())
+  if (IsMus())
     return;
 
   WidgetAutoclosePtr widget(CreateTopLevelPlatformWidget());
   widget->SetBounds(gfx::Rect(0, 0, 600, 600));
   EventCountView* event_count_view = new EventCountView();
   widget->GetContentsView()->AddChildView(event_count_view);
   event_count_view->SetBounds(0, 0, 600, 600);
   widget->Show();
 
   ui::test::EventGenerator event_generator(GetContext(),
@@ skipping 21 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ModalDialogDelegate);
 };
 
 }  // namespace
 
 // Tests the case where an intervening owner popup window is destroyed out from
 // under the currently active modal top-level window. In this instance, the
 // remaining top-level windows should be re-enabled.
 TEST_F(WidgetTest, WindowModalOwnerDestroyedEnabledTest) {
-  // Modality etc. are controlled by mus.
-  if (IsMus())
-    return;
   // top_level_widget owns owner_dialog_widget which owns owned_dialog_widget.
   Widget top_level_widget;
   Widget owner_dialog_widget;
   Widget owned_dialog_widget;
   // Create the top level widget.
   Widget::InitParams init_params =
     CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 500, 500);
   init_params.bounds = initial_bounds;
@@ skipping 101 matching lines @@
 #elif defined(OS_WIN)
       // Other widget types would require to create a parent window and the
       // the purpose of this test is mainly X11 in the first place.
       if (widget_type != Widget::InitParams::TYPE_WINDOW)
         continue;
 #endif
       Widget widget;
       InitializeWidgetForOpacity(widget, CreateParams(widget_type), opacity);
 
       // Use NativeWidgetAura directly.
-      if (IsMus() &&
-          (widget_type == Widget::InitParams::TYPE_WINDOW_FRAMELESS ||
-           widget_type == Widget::InitParams::TYPE_CONTROL))
+      if (widget_type == Widget::InitParams::TYPE_WINDOW_FRAMELESS ||
+          widget_type == Widget::InitParams::TYPE_CONTROL)
         continue;
 
 #if defined(OS_MACOSX)
       // Mac always always has a compositing window manager, but doesn't have
       // transparent titlebars which is what ShouldWindowContentsBeTransparent()
       // is currently used for. Asking for transparency should get it. Note that
       // TestViewsDelegate::use_transparent_windows_ determines the result of
       // INFER_OPACITY: assume it is false.
       bool should_be_transparent =
           opacity == Widget::InitParams::TRANSLUCENT_WINDOW;
 #else
       bool should_be_transparent = widget.ShouldWindowContentsBeTransparent();
 #endif
 
       EXPECT_EQ(IsNativeWindowTransparent(widget.GetNativeWindow()),
                 should_be_transparent);
 
-      // When using the Mandoline UI Service, the translucency does not rely on
-      // the widget type.
-      if (IsMus())
-        continue;
-
 #if defined(USE_X11)
       if (HasCompositingManager() &&
           (widget_type == Widget::InitParams::TYPE_DRAG ||
            widget_type == Widget::InitParams::TYPE_WINDOW)) {
         EXPECT_TRUE(widget.IsTranslucentWindowOpacitySupported());
       } else {
         EXPECT_FALSE(widget.IsTranslucentWindowOpacitySupported());
       }
 #endif
     }
@@ skipping 17 matching lines @@
 }
 
 TEST_F(CompositingWidgetTest, Transparency_DesktopWidgetTranslucent) {
   CheckAllWidgetsForOpacity(Widget::InitParams::TRANSLUCENT_WINDOW);
 }
 
 #endif  // !defined(OS_CHROMEOS)
 
 }  // namespace test
 }  // namespace views