Added text filtering to 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 12 matching lines @@
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/panels/panel_layout_manager.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/test/event_generator.h"
 #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"
@@ skipping 152 matching lines @@
         window_selector_->grid_list_[index]->window_list_.get();
     }
 
   const aura::Window* GetSelectedWindow() {
     WindowSelector* ws = ash::Shell::GetInstance()->
         window_selector_controller()->window_selector_.get();
     return ws->grid_list_[ws->selected_grid_index_]->
         SelectedWindow()->SelectionWindow();
   }
 
+  const bool selection_widget_active() {
+    WindowSelector* ws = ash::Shell::GetInstance()->
+        window_selector_controller()->window_selector_.get();
+    return ws->grid_list_[ws->selected_grid_index_]->is_selecting();
+  }
+
+  bool showing_filter_widget() {
+    WindowSelector* ws = ash::Shell::GetInstance()->
+        window_selector_controller()->window_selector_.get();
+    return (ws->text_filter_widget_->GetNativeWindow()->layer()->
+        GetTargetTransform() == gfx::Transform());

[flackr, 2014/07/02 15:50:42]

nit: GetTargetTransform().IsIdentity()

[Nina, 2014/07/02 17:39:05]

Just another use of those linear algebra classes! Done.

+  }
+
   views::Widget* GetCloseButton(ash::WindowSelectorItem* window) {
     return window->close_button_.get();
   }
 
   views::Label* GetLabelView(ash::WindowSelectorItem* window) {
     return window->window_label_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->GetRootWindow();
     EXPECT_TRUE(window_item->Contains(window));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(window))));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(
             GetCloseButton(window_item)->GetNativeView()))));
   }
 
+  void FilterItems(const base::StringPiece& pattern) {
+    ash::Shell::GetInstance()->
+        window_selector_controller()->window_selector_.get()->
+            ContentsChanged(NULL, base::UTF8ToUTF16(pattern));
+  }
+
   test::ShelfViewTestAPI* shelf_view_test() {
     return shelf_view_test_.get();
   }
 
+  views::Widget* text_filter_widget() {
+    return ash::Shell::GetInstance()->
+        window_selector_controller()->window_selector_.get()->
+            text_filter_widget_.get();
+  }
+
  private:
   aura::test::TestWindowDelegate delegate_;
   NonActivatableActivationDelegate non_activatable_activation_delegate_;
   scoped_ptr<test::ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSelectorTest);
 };
 
 // Tests that an a11y alert is sent on entering overview mode.
 TEST_F(WindowSelectorTest, A11yAlertOnOverviewMode) {
@@ skipping 18 matching lines @@
   scoped_ptr<aura::Window> panel2(CreatePanelWindow(bounds));
   EXPECT_TRUE(WindowsOverlapping(window1.get(), window2.get()));
   EXPECT_TRUE(WindowsOverlapping(panel1.get(), panel2.get()));
   wm::ActivateWindow(window2.get());
   EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
   EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
   EXPECT_EQ(window2.get(), GetFocusedWindow());
   // Hide the cursor before entering overview to test that it will be shown.
   aura::client::GetCursorClient(root_window)->HideCursor();
 
-  // In overview mode the windows should no longer overlap and focus should
-  // be removed from the window.
+  // In overview mode the windows should no longer overlap and the text filter
+  // widget should be focused.
   ToggleOverview();
-  EXPECT_EQ(NULL, GetFocusedWindow());
+  EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
   EXPECT_FALSE(WindowsOverlapping(window1.get(), window2.get()));
   EXPECT_FALSE(WindowsOverlapping(window1.get(), panel1.get()));
   // Panels 1 and 2 should still be overlapping being in a single selector
   // item.
   EXPECT_TRUE(WindowsOverlapping(panel1.get(), panel2.get()));
 
   // Clicking window 1 should activate it.
   ClickWindow(window1.get());
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
   EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
   EXPECT_EQ(window1.get(), GetFocusedWindow());
 
   // Cursor should have been unlocked.
   EXPECT_FALSE(aura::client::GetCursorClient(root_window)->IsCursorLocked());
 }
 
 // Tests selecting a window by tapping on it.
 TEST_F(WindowSelectorTest, BasicGesture) {
   gfx::Rect bounds(0, 0, 400, 400);
   scoped_ptr<aura::Window> window1(CreateWindow(bounds));
   scoped_ptr<aura::Window> window2(CreateWindow(bounds));
   wm::ActivateWindow(window1.get());
   EXPECT_EQ(window1.get(), GetFocusedWindow());
   ToggleOverview();
-  EXPECT_EQ(NULL, GetFocusedWindow());
+  EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                        window2.get());
   generator.GestureTapAt(gfx::ToEnclosingRect(
       GetTransformedTargetBounds(window2.get())).CenterPoint());
   EXPECT_EQ(window2.get(), GetFocusedWindow());
 }
 
 // Tests that a window does not receive located events when in overview mode.
 TEST_F(WindowSelectorTest, WindowDoesNotReceiveEvents) {
   gfx::Rect window_bounds(20, 10, 200, 300);
@@ skipping 187 matching lines @@
 }
 
 // Tests that exiting overview mode without selecting a window restores focus
 // to the previously focused window.
 TEST_F(WindowSelectorTest, CancelRestoresFocus) {
   gfx::Rect bounds(0, 0, 400, 400);
   scoped_ptr<aura::Window> window(CreateWindow(bounds));
   wm::ActivateWindow(window.get());
   EXPECT_EQ(window.get(), GetFocusedWindow());
 
-  // In overview mode, focus should be removed.
+  // In overview mode, the text filter widget should be focused.
   ToggleOverview();
-  EXPECT_EQ(NULL, GetFocusedWindow());
+  EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
 
   // If canceling overview mode, focus should be restored.
   ToggleOverview();
   EXPECT_EQ(window.get(), GetFocusedWindow());
 }
 
 // Tests that overview mode is exited if the last remaining window is destroyed.
 TEST_F(WindowSelectorTest, LastWindowDestroyed) {
   gfx::Rect bounds(0, 0, 400, 400);
   scoped_ptr<aura::Window> window1(CreateWindow(bounds));
@@ skipping 489 matching lines @@
   gfx::Point point2(bounds2.top_right().x() - 1, bounds2.top_right().y() - 1);
   aura::test::EventGenerator event_generator2(window2->GetRootWindow(), point2);
 
   EXPECT_FALSE(widget2->IsClosed());
   event_generator2.ClickLeftButton();
   EXPECT_TRUE(widget2->IsClosed());
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(IsSelecting());
 }
 
+// Creates three windows and tests filtering them by title.
+TEST_F(WindowSelectorTest, BasicTextFiltering) {
+  gfx::Rect bounds(0, 0, 100, 100);
+  scoped_ptr<aura::Window> window2(CreateWindow(bounds));
+  scoped_ptr<aura::Window> window1(CreateWindow(bounds));
+  scoped_ptr<aura::Window> window0(CreateWindow(bounds));
+  base::string16 window2_title = base::UTF8ToUTF16("Highway to test");
+  base::string16 window1_title = base::UTF8ToUTF16("For those about to test");
+  base::string16 window0_title = base::UTF8ToUTF16("We salute you");
+  window0->SetTitle(window0_title);
+  window1->SetTitle(window1_title);
+  window2->SetTitle(window2_title);
+  ToggleOverview();
+  EXPECT_FALSE(selection_widget_active());
+  EXPECT_FALSE(showing_filter_widget());
+  FilterItems("Test");
+
+  // The selection widget should appear when filtering starts, and should be
+  // selecting the first matching window.
+  EXPECT_TRUE(selection_widget_active());
+  EXPECT_TRUE(showing_filter_widget());
+  EXPECT_EQ(GetSelectedWindow(), window1.get());
+
+  // Window 0 has no "test" on it so it should be the only dimmed item.
+  std::vector<WindowSelectorItem*> items = GetWindowItemsForRoot(0);
+  EXPECT_TRUE(items[0]->dimmed());
+  EXPECT_FALSE(items[1]->dimmed());
+  EXPECT_FALSE(items[2]->dimmed());
+
+  // No items match the search.
+  FilterItems("I'm testing 'n testing");
+  EXPECT_TRUE(items[0]->dimmed());
+  EXPECT_TRUE(items[1]->dimmed());
+  EXPECT_TRUE(items[2]->dimmed());
+
+  // All the items should match the empty string. The filter widget should also
+  // disappear.
+  FilterItems("");
+  EXPECT_FALSE(showing_filter_widget());
+  EXPECT_FALSE(items[0]->dimmed());
+  EXPECT_FALSE(items[1]->dimmed());
+  EXPECT_FALSE(items[2]->dimmed());
+}
+
+// Tests selecting in the overview with dimmed and undimmed items.
+TEST_F(WindowSelectorTest, TextFilteringSelection) {
+  gfx::Rect bounds(0, 0, 100, 100);
+   scoped_ptr<aura::Window> window2(CreateWindow(bounds));
+   scoped_ptr<aura::Window> window1(CreateWindow(bounds));
+   scoped_ptr<aura::Window> window0(CreateWindow(bounds));
+   base::string16 window2_title = base::UTF8ToUTF16("Rock and roll");
+   base::string16 window1_title = base::UTF8ToUTF16("Rock and");
+   base::string16 window0_title = base::UTF8ToUTF16("Rock");
+   window0->SetTitle(window0_title);
+   window1->SetTitle(window1_title);
+   window2->SetTitle(window2_title);
+   ToggleOverview();
+   SendKey(ui::VKEY_RIGHT);
+   EXPECT_TRUE(selection_widget_active());
+   EXPECT_EQ(GetSelectedWindow(), window0.get());
+
+   // Dim the first item, the selection should jump to the next item.
+   std::vector<WindowSelectorItem*> items = GetWindowItemsForRoot(0);
+   FilterItems("Rock and");
+   EXPECT_EQ(GetSelectedWindow(), window1.get());
+
+   // Cycle the selection, the dimmed window should not be selected.
+   SendKey(ui::VKEY_RIGHT);
+   EXPECT_EQ(GetSelectedWindow(), window2.get());
+   SendKey(ui::VKEY_RIGHT);
+   EXPECT_EQ(GetSelectedWindow(), window1.get());
+
+   // Dimming all the items should hide the selection widget.
+   FilterItems("Pop");
+   EXPECT_FALSE(selection_widget_active());
+
+   // Undimming one window should automatically select it.
+   FilterItems("Rock and roll");
+   EXPECT_EQ(GetSelectedWindow(), window2.get());
+}
+
 }  // namespace ash