Remove TransparentActivateWindowButton from Overview Mode

ash/wm/overview/window_selector_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
@@ skipping 28 matching lines @@
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
-#include "ui/views/controls/label.h"
+#include "ui/views/controls/button/label_button.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_delegate.h"
 
 namespace ash {
 namespace {
 
 typedef std::vector<aura::Window*> WindowList;
 typedef std::map<const aura::Window*, int> WindowIndexMap;
@@ skipping 48 matching lines @@
   aura::Window* CreateNonActivatableWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateWindow(bounds);
     aura::client::SetActivationDelegate(window,
                                         &non_activatable_activation_delegate_);
     EXPECT_FALSE(ash::wm::CanActivateWindow(window));
     return window;
   }
 
   aura::Window* CreatePanelWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
-        nullptr, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
+
+
+        &delegate_, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
     test::TestShelfDelegate::instance()->AddShelfItem(window);
     shelf_view_test()->RunMessageLoopUntilAnimationsDone();
     return window;
   }
 
   views::Widget* CreatePanelWindowWidget(const gfx::Rect& bounds) {
     views::Widget* widget = new views::Widget;
     views::Widget::InitParams params;
     params.bounds = bounds;
     params.type = views::Widget::InitParams::TYPE_PANEL;
@@ skipping 92 matching lines @@
     WindowSelector* ws = ash::Shell::GetInstance()->
         window_selector_controller()->window_selector_.get();
     return ws->text_filter_widget_->GetNativeWindow()->layer()->
         GetTargetTransform().IsIdentity();
   }
 
   views::Widget* GetCloseButton(ash::WindowSelectorItem* window) {
     return &(window->close_button_widget_);
   }
 
-  views::Label* GetLabelView(ash::WindowSelectorItem* window) {
-    return window->window_label_view_;
+  views::LabelButton* GetLabelButtonView(ash::WindowSelectorItem* window) {
+    return window->window_label_button_view_;
   }
 
   // Tests that a window is contained within a given WindowSelectorItem, and
   // that both the window and its matching close button are within the same
   // screen.
   void IsWindowAndCloseButtonInScreen(aura::Window* window,
                                       WindowSelectorItem* window_item) {
     aura::Window* root_window = window_item->root_window();
     EXPECT_TRUE(window_item->Contains(window));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
@@ skipping 125 matching lines @@
 
   event_generator.ReleaseTouchId(kTouchId);
 }
 
 // Tests that we do not crash and a window is selected when appropriate when
 // we click on a window during touch.
 TEST_F(WindowSelectorTest, ClickOnWindowDuringTouch) {
   gfx::Rect bounds(0, 0, 400, 400);
   scoped_ptr<aura::Window> window1(CreateWindow(bounds));
   scoped_ptr<aura::Window> window2(CreateWindow(bounds));
-  wm::ActivateWindow(window2.get());
-  EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
-  EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
+  wm::ActivateWindow(window1.get());
+  EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
+  EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
 
   ToggleOverview();
 
   gfx::Rect window1_bounds =
       gfx::ToEnclosingRect(GetTransformedBoundsInRootWindow(window1.get()));
   ui::test::EventGenerator event_generator(window1->GetRootWindow(),
                                            window1_bounds.CenterPoint());
 
   // Clicking on |window2| while touching on |window1| should not cause a
-  // crash, and overview mode should remain engaged because |window1|
-  // has capture.
+  // crash, overview mode should be disengaged and |window2| should be active.
   const int kTouchId = 19;
   event_generator.PressTouchId(kTouchId);
   event_generator.MoveMouseToCenterOf(window2.get());
   event_generator.ClickLeftButton();
-  EXPECT_TRUE(IsSelecting());
+  EXPECT_FALSE(IsSelecting());
+  EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
   event_generator.ReleaseTouchId(kTouchId);
 
+  ToggleOverview();
+
   // Clicking on |window1| while touching on |window1| should not cause
   // a crash, overview mode should be disengaged, and |window1| should
   // be active.
   event_generator.MoveMouseToCenterOf(window1.get());
   event_generator.PressTouchId(kTouchId);
   event_generator.ClickLeftButton();
   EXPECT_FALSE(IsSelecting());
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
   EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
   event_generator.ReleaseTouchId(kTouchId);
@@ skipping 514 matching lines @@
   RunAllPendingInMessageLoop();
 }
 
 // Test that a label is created under the window on entering overview mode.
 TEST_F(WindowSelectorTest, CreateLabelUnderWindow) {
   scoped_ptr<aura::Window> window(CreateWindow(gfx::Rect(0, 0, 100, 100)));
   base::string16 window_title = base::UTF8ToUTF16("My window");
   window->SetTitle(window_title);
   ToggleOverview();
   WindowSelectorItem* window_item = GetWindowItemsForRoot(0).back();
-  views::Label* label = GetLabelView(window_item);
+  views::LabelButton* label = GetLabelButtonView(window_item);
   // Has the label view been created?
   ASSERT_TRUE(label);
 
   // Verify the label matches the window title.
-  EXPECT_EQ(label->text(), window_title);
+  EXPECT_EQ(label->GetText(), window_title);
 
   // Update the window title and check that the label is updated, too.
   base::string16 updated_title = base::UTF8ToUTF16("Updated title");
   window->SetTitle(updated_title);
-  EXPECT_EQ(label->text(), updated_title);
+  EXPECT_EQ(label->GetText(), updated_title);
 
   // Labels are located based on target_bounds, not the actual window item
   // bounds.
   gfx::Rect target_bounds(window_item->target_bounds());
   gfx::Rect expected_label_bounds(target_bounds.x(),
                                   target_bounds.bottom() - label->
                                       GetPreferredSize().height(),
                                   target_bounds.width(),
                                   label->GetPreferredSize().height());
   gfx::Rect real_label_bounds = label->GetWidget()->GetNativeWindow()->bounds();
   EXPECT_EQ(real_label_bounds, expected_label_bounds);
 }
 
 // Tests that a label is created for the active panel in a group of panels in
 // overview mode.
 TEST_F(WindowSelectorTest, CreateLabelUnderPanel) {
   scoped_ptr<aura::Window> panel1(CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
   scoped_ptr<aura::Window> panel2(CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
   base::string16 panel1_title = base::UTF8ToUTF16("My panel");
   base::string16 panel2_title = base::UTF8ToUTF16("Another panel");
   base::string16 updated_panel1_title = base::UTF8ToUTF16("WebDriver Torso");
   base::string16 updated_panel2_title = base::UTF8ToUTF16("Da panel");
   panel1->SetTitle(panel1_title);
   panel2->SetTitle(panel2_title);
   wm::ActivateWindow(panel1.get());
   ToggleOverview();
   WindowSelectorItem* window_item = GetWindowItemsForRoot(0).back();
-  views::Label* label = GetLabelView(window_item);
+  views::LabelButton* label = GetLabelButtonView(window_item);
   // Has the label view been created?
   ASSERT_TRUE(label);
 
   // Verify the label matches the active window title.
-  EXPECT_EQ(label->text(), panel1_title);
+  EXPECT_EQ(label->GetText(), panel1_title);
   // Verify that updating the title also updates the label.
   panel1->SetTitle(updated_panel1_title);
-  EXPECT_EQ(label->text(), updated_panel1_title);
+  EXPECT_EQ(label->GetText(), updated_panel1_title);
   // After destroying the first panel, the label should match the second panel.
   panel1.reset();
-  label = GetLabelView(window_item);
-  EXPECT_EQ(label->text(), panel2_title);
+  label = GetLabelButtonView(window_item);
+  EXPECT_EQ(label->GetText(), panel2_title);
   // Also test updating the title on the second panel.
   panel2->SetTitle(updated_panel2_title);
-  EXPECT_EQ(label->text(), updated_panel2_title);
+  EXPECT_EQ(label->GetText(), updated_panel2_title);
 }
 
 // Tests that overview updates the window positions if the display orientation
 // changes.
 TEST_F(WindowSelectorTest, DisplayOrientationChanged) {
   if (!SupportsHostWindowResize())
     return;
 
   aura::Window* root_window = Shell::GetInstance()->GetPrimaryRootWindow();
   UpdateDisplay("600x200");
@@ skipping 193 matching lines @@
   event_generator1.ClickLeftButton();
   EXPECT_TRUE(widget1->IsClosed());
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(IsSelecting());
   WindowSelectorItem* window_item = GetWindowItemsForRoot(0).front();
   EXPECT_FALSE(window_item->empty());
   EXPECT_TRUE(window_item->Contains(window2));
   EXPECT_TRUE(GetCloseButton(window_item)->IsVisible());
 
 
-  views::Label* label = GetLabelView(window_item);
-  EXPECT_EQ(label->text(), panel2_title);
+  views::LabelButton* label = GetLabelButtonView(window_item);
+  EXPECT_EQ(label->GetText(), panel2_title);
 
   gfx::RectF bounds2 = GetTransformedBoundsInRootWindow(window2);
   gfx::Point point2(bounds2.top_right().x() - 1, bounds2.top_right().y() - 1);
   ui::test::EventGenerator event_generator2(window2->GetRootWindow(), point2);
 
   EXPECT_FALSE(widget2->IsClosed());
   event_generator2.ClickLeftButton();
   EXPECT_TRUE(widget2->IsClosed());
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsSelecting());
@@ skipping 130 matching lines @@
 
   // Switch to overview mode.
   ToggleOverview();
   ASSERT_TRUE(IsSelecting());
 
   // Tap should now exit overview mode.
   generator.GestureTapAt(point_in_background_page);
   EXPECT_FALSE(IsSelecting());
 }
 
-// Tests that the transparent overlays z-order matches the windows z-order.

[Nina, 2015/01/09 15:43:48]

This test is no longer needed as we are actually targeting the panels now.

-TEST_F(WindowSelectorTest, PanelStackOrdering) {
-  gfx::Rect bounds1(0, 0, 100, 100);
-  gfx::Rect bounds2(10, 0, 100, 100);
-  gfx::Rect bounds3(20, 0, 100, 100);
-  scoped_ptr<aura::Window> panel1(CreatePanelWindow(bounds1));
-  scoped_ptr<aura::Window> panel2(CreatePanelWindow(bounds2));
-  scoped_ptr<aura::Window> panel3(CreatePanelWindow(bounds3));
-
-  wm::ActivateWindow(panel2.get());
-  wm::ActivateWindow(panel3.get());
-  wm::ActivateWindow(panel1.get());
-
-  WindowIndexMap z_order;
-  GetWindowIndexMap(panel1->parent()->children(), &z_order);
-  ASSERT_GT(z_order[panel1.get()], z_order[panel2.get()]);
-  ASSERT_GT(z_order[panel2.get()], z_order[panel3.get()]);
-
-  WindowList mru_windows = ash::Shell::GetInstance()->mru_window_tracker()->
-      BuildMruWindowList();
-  WindowIndexMap mru_rank;
-  GetWindowIndexMap(mru_windows, &mru_rank);
-  ASSERT_LT(mru_rank[panel1.get()], mru_rank[panel3.get()]);
-  ASSERT_LT(mru_rank[panel3.get()], mru_rank[panel2.get()]);
-
-  ToggleOverview();
-
-  gfx::Rect panel1_transformed_bounds(
-      gfx::ToEnclosingRect(GetTransformedTargetBounds(panel1.get())));
-  gfx::Rect panel2_transformed_bounds(
-      gfx::ToEnclosingRect(GetTransformedTargetBounds(panel2.get())));
-  gfx::Rect panel3_transformed_bounds(
-      gfx::ToEnclosingRect(GetTransformedTargetBounds(panel3.get())));
-
-  gfx::Rect target_rect(panel2_transformed_bounds);
-  target_rect.Intersect(panel3_transformed_bounds);
-  target_rect.Subtract(panel1_transformed_bounds);
-  gfx::Point tap_target(target_rect.CenterPoint());
-
-  ASSERT_TRUE(panel3_transformed_bounds.Contains(tap_target));
-
-  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
-  generator.GestureTapAt(tap_target);
-  EXPECT_EQ(panel2.get(), GetFocusedWindow());
-}
-
 // Tests that individual panels can be selected on a secondary display.
 TEST_F(WindowSelectorTest, PanelSelectionOnSecondaryDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("600x400,600x400");
-  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   gfx::Rect bounds1(700, 0, 100, 100);
   gfx::Rect bounds2(710, 0, 100, 100);
   scoped_ptr<aura::Window> panel1(CreatePanelWindow(bounds1));
   scoped_ptr<aura::Window> panel2(CreatePanelWindow(bounds2));
 
   wm::ActivateWindow(panel2.get());
   wm::ActivateWindow(panel1.get());
 
   WindowList mru_windows = ash::Shell::GetInstance()->mru_window_tracker()->
       BuildMruWindowList();
   WindowIndexMap mru_rank;
   GetWindowIndexMap(mru_windows, &mru_rank);
   ASSERT_LT(mru_rank[panel1.get()], mru_rank[panel2.get()]);
   ASSERT_EQ(panel1.get(), GetFocusedWindow());
 
   ToggleOverview();
 
   gfx::Rect panel2_transformed_bounds(
       gfx::ToEnclosingRect(GetTransformedBoundsInRootWindow(panel2.get())));
   gfx::Point tap_target(panel2_transformed_bounds.right() - 2,
                         panel2_transformed_bounds.bottom() - 2);
 
-  ui::test::EventGenerator generator(root_windows[1]);
+  ui::test::EventGenerator generator(panel2->GetRootWindow());
   generator.GestureTapAt(tap_target);
   EXPECT_EQ(panel2.get(), GetFocusedWindow());
 }
 
 }  // namespace ash