Drag fullscreened window from the top of the display.

- Make fullscreened window can be dragged from the top of the display.

- Keep shelf visible if a window is being dragged from the top of the display.

- Fling the window from the top exceed the velocity threshold should drop the
  window into overview mode.

- Update the window transform during drag.

See recorded video:
https://drive.google.com/file/d/0B5I0jFeLxqIiSnFza0t3bEluUnJ0VVBhUzFiSnNwN0k4eFpv/view?usp=sharing

Bug: 847587
Change-Id: I7f9a423f511c65c083fe11a6deb5847afa4c9a35
Reviewed-on: https://chromium-review.googlesource.com/1134575Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Commit-Queue: Min Chen <minch@chromium.org>
Cr-Commit-Position: refs/heads/master@{#577365}

ash/public/cpp/immersive/immersive_gesture_handler.h

@@ -11,8 +11,8 @@ namespace ash {
 
 // ImmersiveGestureHandler is responsible for calling
 // ImmersiveFullscreenController::OnGestureEvent() to show/hide the title bar or
-// TabletModeWindowDragController::DragWindowFromTop() to drag the window from
-// the top if CanDragWindow is true when a gesture is received.
+// TabletAppModeWindowDragController::DragWindowFromTop() to drag the window
+// from the top if CanDragWindow is true when a gesture is received.
 class ASH_PUBLIC_EXPORT ImmersiveGestureHandler {
  public:
   virtual ~ImmersiveGestureHandler() {}

ash/shelf/shelf_layout_manager.cc

@@ -32,9 +32,11 @@
 #include "ash/wm/screen_pinning_controller.h"
 #include "ash/wm/tablet_mode/tablet_mode_controller.h"
 #include "ash/wm/window_state.h"
+#include "ash/wm/window_util.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
+#include "ui/base/hit_test.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
@@ -260,6 +262,8 @@ void ShelfLayoutManager::UpdateVisibilityState() {
     SetState(SHELF_VISIBLE);
   } else if (Shell::Get()->screen_pinning_controller()->IsPinned()) {
     SetState(SHELF_HIDDEN);
+  } else if (IsDraggingWindowFromTopOfDisplay()) {
+    SetState(SHELF_VISIBLE);
   } else {
     // TODO(zelidrag): Verify shelf drag animation still shows on the device
     // when we are in SHELF_AUTO_HIDE_ALWAYS_HIDDEN.
@@ -410,6 +414,20 @@ bool ShelfLayoutManager::ProcessGestureEvent(
   return false;
 }
 
+bool ShelfLayoutManager::IsDraggingWindowFromTopOfDisplay() const {
+  // TODO(minch): Check active window directly if removed search field
+  // in overview mode. http://crbug.com/866679
+  auto windows = Shell::Get()->mru_window_tracker()->BuildMruWindowList();
+  for (auto* window : windows) {
+    wm::WindowState* window_state = wm::GetWindowState(window);
+    if (window_state && window_state->is_dragged() &&
+        window_state->drag_details()->window_component == HTCLIENT) {
+      return true;
+    }
+  }
+  return false;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, wm::WmSnapToPixelLayoutManager implementation:
 

ash/shelf/shelf_layout_manager.h

@@ -138,6 +138,9 @@ class ASH_EXPORT ShelfLayoutManager
   // be processed any further, false otherwise.
   bool ProcessGestureEvent(const ui::GestureEvent& event_in_screen);
 
+  // Returns true if a window is being dragged from the top of the display.
+  bool IsDraggingWindowFromTopOfDisplay() const;
+
   // Overridden from wm::WmSnapToPixelLayoutManager:
   void OnWindowResized() override;
   void SetChildBounds(aura::Window* child,

ash/wm/immersive_fullscreen_controller_unittest.cc

@@ -671,8 +671,10 @@ TEST_F(ImmersiveFullscreenControllerTest, DifferentModalityEnterExit) {
   EXPECT_FALSE(controller()->IsRevealed());
 }
 
-// Tests the top-of-window views for maximized window in tablet mode.
-TEST_F(ImmersiveFullscreenControllerTest, MaximizedWindowInTabletMode) {
+// Tests the top-of-window views for maximized/full-screened window in tablet
+// mode.
+TEST_F(ImmersiveFullscreenControllerTest,
+       MaximizedOrFullscreenedWindowInTabletMode) {
   SetWindowShowState(ui::SHOW_STATE_MAXIMIZED);
   EnableTabletMode(true);
   SetEnabled(true);
@@ -692,11 +694,12 @@ TEST_F(ImmersiveFullscreenControllerTest, MaximizedWindowInTabletMode) {
   AttemptUnreveal(MODALITY_GESTURE_SCROLL);
   EXPECT_FALSE(controller()->IsRevealed());
 
-  // Top-of-window views will be revealed for fullscreen window in tablet mode.
+  // Top-of-window views will not be revealed for full-screened window in tablet
+  // mode either.
   EnableTabletMode(true);
   SetWindowShowState(ui::SHOW_STATE_FULLSCREEN);
   AttemptReveal(MODALITY_GESTURE_SCROLL);
-  EXPECT_TRUE(controller()->IsRevealed());
+  EXPECT_FALSE(controller()->IsRevealed());
 }
 
 // Test when the SWIPE_CLOSE edge gesture closes the top-of-window views.

ash/wm/immersive_gesture_handler_classic.cc

@@ -71,10 +71,10 @@ bool ImmersiveGestureHandlerClassic::CanDrag(ui::GestureEvent* event) {
   if (window != immersive_fullscreen_controller_->widget()->GetNativeWindow())
     return false;
 
-  // TODO(minch): Also allow windows in fullscreen mode can be dragged.
-  // Only maximized none browser window in tablet mode allowed to be dragged.
+  // Only maximized or fullscreened none browser window in tablet mode allowed
+  // to be dragged.
   const views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
-  if (!widget || !widget->IsMaximized() ||
+  if (!widget || (!widget->IsMaximized() && !widget->IsFullscreen()) ||
       !Shell::Get()
            ->tablet_mode_controller()
            ->IsTabletModeWindowManagerEnabled() ||
@@ -113,6 +113,8 @@ ImmersiveGestureHandlerClassic::~ImmersiveGestureHandlerClassic() {
 }
 
 void ImmersiveGestureHandlerClassic::OnGestureEvent(ui::GestureEvent* event) {
+  // TODO(minch): Make window can be dragged from top if docked magnifier is
+  // enabled. http://crbug.com/866680.
   if (CanDrag(event)) {
     DCHECK(tablet_mode_app_window_drag_controller_);
     if (tablet_mode_app_window_drag_controller_->DragWindowFromTop(event))

ash/wm/immersive_gesture_handler_classic.h

@@ -18,8 +18,8 @@ class TabletModeAppWindowDragController;
 
 // ImmersiveGestureHandler is responsible for calling
 // ImmersiveFullscreenController::OnGestureEvent() to show/hide the title bar or
-// TabletModeWindowDragController::DragWindowFromTop() to drag the window from
-// the top if CanDrag is true when a gesture is received.
+// TabletAppModeWindowDragController::DragWindowFromTop() to drag the window
+// from the top if CanDrag is true when a gesture is received.
 class ASH_EXPORT ImmersiveGestureHandlerClassic
     : public ImmersiveGestureHandler,
       public ui::EventHandler {

ash/wm/splitview/split_view_controller_unittest.cc

@@ -12,6 +12,7 @@
 #include "ash/screen_util.h"
 #include "ash/session/session_controller.h"
 #include "ash/session/test_session_controller_client.h"
+#include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/system/overview/overview_button_tray.h"
 #include "ash/system/status_area_widget.h"
@@ -2198,11 +2199,16 @@ class SplitViewAppDraggingTest : public SplitViewControllerTest {
   void EndScrollSequence(const gfx::Point& start,
                          float scroll_delta,
                          base::TimeTicks& timestamp,
-                         aura::Window* window) {
+                         aura::Window* window,
+                         bool is_fling = false,
+                         float velocity_y = 0.f) {
     timestamp += base::TimeDelta::FromMilliseconds(100);
-    SendGestureEventToController(
-        start.x(), start.y() + scroll_delta, timestamp,
-        ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END), window);
+    ui::GestureEventDetails details =
+        is_fling
+            ? ui::GestureEventDetails(ui::ET_SCROLL_FLING_START, 0, velocity_y)
+            : ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END);
+    SendGestureEventToController(start.x(), start.y() + scroll_delta, timestamp,
+                                 details, window);
   }
 
  private:
@@ -2235,14 +2241,14 @@ TEST_F(SplitViewAppDraggingTest, DragMaximizedWindow) {
 
   // Move the window by a small amount of distance will maximize the window
   // again.
-  SendGestureEvents(gfx::Point(0, 0), 10, window.get());
+  gfx::Point start = gfx::Point(0, 0);
+  SendGestureEvents(start, 10, window.get());
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
 
   // Drag the window long enough (pass one fourth of the screen vertical
   // height) to snap the window to splitscreen.
   const float long_scroll_delta = display_bounds.height() / 4 + 5;
   base::TimeTicks timestamp = base::TimeTicks::Now();
-  gfx::Point start = gfx::Point(0, 0);
   SendScrollStartAndUpdate(start, long_scroll_delta, timestamp, window.get());
   WindowSelectorController* window_selector_controller =
       Shell::Get()->window_selector_controller();
@@ -2275,6 +2281,68 @@ TEST_F(SplitViewAppDraggingTest, DragMaximizedWindow) {
   EXPECT_FALSE(window_selector_controller->IsSelecting());
   EXPECT_FALSE(split_view_controller()->IsSplitViewModeActive());
   EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized());
+
+  // FLING the window with small velocity (smaller than
+  // kFlingToOverviewThreshold) will not able to drop the window into overview.
+  timestamp = base::TimeTicks::Now();
+  SendScrollStartAndUpdate(start, 10, timestamp, window.get());
+  window_selector_controller = Shell::Get()->window_selector_controller();
+  EXPECT_TRUE(window_selector_controller->IsSelecting());
+  EndScrollSequence(
+      start, 10, timestamp, window.get(), /*is_fling=*/true,
+      /*velocity_y=*/
+      TabletModeAppWindowDragController::kFlingToOverviewThreshold - 10.f);
+  EXPECT_FALSE(window_selector_controller->IsSelecting());
+
+  // FLING the window with large veloicty (larger than
+  // kFlingToOverviewThreshold) will drop the window into overview.
+  timestamp = base::TimeTicks::Now();
+  SendScrollStartAndUpdate(start, 10, timestamp, window.get());
+  window_selector_controller = Shell::Get()->window_selector_controller();
+  EXPECT_TRUE(window_selector_controller->IsSelecting());
+  EndScrollSequence(
+      start, 10, timestamp, window.get(), /*is_fling=*/true,
+      /*velocity_y=*/
+      TabletModeAppWindowDragController::kFlingToOverviewThreshold + 10.f);
+  EXPECT_TRUE(window_selector_controller->IsSelecting());
+}
+
+// Tests the shelf visibility when a fullscreened window is being dragged.
+TEST_F(SplitViewAppDraggingTest, ShelfVisibilityIfDraggingFullscreenedWindow) {
+  UpdateDisplay("800x600");
+  std::unique_ptr<aura::Window> window(
+      CreateAppWindow(gfx::Rect(0, 0, 500, 500)));
+  ShelfLayoutManager* shelf_layout_manager =
+      AshTestBase::GetPrimaryShelf()->shelf_layout_manager();
+  gfx::Rect display_bounds =
+      split_view_controller()->GetDisplayWorkAreaBoundsInScreen(window.get());
+
+  // Shelf will be auto-hidden if the winodw requests to be fullscreened.
+  wm::WindowState* window_state = wm::GetWindowState(window.get());
+  const wm::WMEvent fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
+  window_state->OnWMEvent(&fullscreen_event);
+  window_state->SetHideShelfWhenFullscreen(false);
+  window_state->SetInImmersiveFullscreen(true);
+  shelf_layout_manager->UpdateVisibilityState();
+  EXPECT_TRUE(window_state->IsFullscreen());
+  EXPECT_FALSE(shelf_layout_manager->IsVisible());
+
+  // Drag the window by a small amount of distance, the window will back to
+  // fullscreened, and shelf will be hidden again.
+  gfx::Point start = gfx::Point(0, 0);
+  SendGestureEvents(start, 10, window.get());
+  EXPECT_TRUE(wm::GetWindowState(window.get())->IsFullscreen());
+  EXPECT_FALSE(shelf_layout_manager->IsVisible());
+
+  // Shelf is visible during dragging.
+  base::TimeTicks timestamp = base::TimeTicks::Now();
+  const float long_scroll_delta = display_bounds.height() / 4 + 5;
+  SendScrollStartAndUpdate(start, long_scroll_delta, timestamp, window.get());
+  EXPECT_TRUE(shelf_layout_manager->IsVisible());
+  EndScrollSequence(start, long_scroll_delta, timestamp, window.get());
+  EXPECT_TRUE(split_view_controller()->IsSplitViewModeActive());
+  EXPECT_TRUE(wm::GetWindowState(window.get())->IsSnapped());
+  EXPECT_TRUE(shelf_layout_manager->IsVisible());
 }
 
 }  // namespace ash

ash/wm/tablet_mode/tablet_mode_app_window_drag_controller.cc

@@ -4,6 +4,12 @@
 
 #include "ash/wm/tablet_mode/tablet_mode_app_window_drag_controller.h"
 
+#include "ash/root_window_controller.h"
+#include "ash/shelf/shelf_layout_manager.h"
+#include "ash/shell.h"
+#include "ash/wm/overview/window_grid.h"
+#include "ash/wm/overview/window_selector_controller.h"
+#include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/splitview/split_view_drag_indicators.h"
 #include "ash/wm/tablet_mode/tablet_mode_window_drag_delegate.h"
 #include "ash/wm/window_state.h"
@@ -84,6 +90,16 @@ void TabletModeAppWindowDragController::StartWindowDrag(
   initial_location_in_screen_ = GetEventLocationInScreen(event);
   drag_delegate_->StartWindowDrag(static_cast<aura::Window*>(event->target()),
                                   initial_location_in_screen_);
+
+  WindowSelectorController* window_selector_controller =
+      Shell::Get()->window_selector_controller();
+  DCHECK(window_selector_controller->IsSelecting());
+  WindowGrid* window_grid =
+      window_selector_controller->window_selector()->GetGridWithRootWindow(
+          drag_delegate_->dragged_window()->GetRootWindow());
+  const std::vector<std::unique_ptr<WindowSelectorItem>>& selector_items =
+      window_grid->window_list();
+  new_selector_item_bounds_ = selector_items.back().get()->target_bounds();
 }
 
 void TabletModeAppWindowDragController::UpdateWindowDrag(
@@ -98,21 +114,22 @@ void TabletModeAppWindowDragController::EndWindowDrag(
     wm::WmToplevelWindowEventHandler::DragResult result) {
   const gfx::Point location_in_screen(GetEventLocationInScreen(event));
   drag_delegate_->dragged_window()->SetTransform(gfx::Transform());
+  if (event->type() == ui::ET_SCROLL_FLING_START &&
+      event->details().velocity_y() > kFlingToOverviewThreshold) {
+    Shell::Get()->window_selector_controller()->window_selector()->AddItem(
+        drag_delegate_->dragged_window(), /*reposition=*/true);
+  }
   drag_delegate_->EndWindowDrag(result, location_in_screen);
 }
 
 void TabletModeAppWindowDragController::UpdateDraggedWindow(
     const gfx::Point& location_in_screen) {
-  gfx::PointF gesture_drag_amount =
-      gfx::PointF(location_in_screen.x() - initial_location_in_screen_.x(),
-                  location_in_screen.y() - initial_location_in_screen_.y());
-  const gfx::Size display_size =
-      drag_delegate_->dragged_window()->GetRootWindow()->bounds().size();
-  const float x_scale =
-      1.0f - fabsf(gesture_drag_amount.x()) / display_size.width();
-  const float y_scale =
-      1.0f - fabsf(gesture_drag_amount.y()) / display_size.height();
-  const float scale = std::min(x_scale, y_scale);
+  DCHECK(drag_delegate_->dragged_window());
+  RootWindowController::ForWindow(drag_delegate_->dragged_window())
+      ->GetShelfLayoutManager()
+      ->UpdateVisibilityState();
+
+  float scale = CalculateWindowScale(location_in_screen.y());
   gfx::Transform transform;
   transform.Translate(
       location_in_screen.x() - initial_location_in_screen_.x() * scale,
@@ -121,4 +138,17 @@ void TabletModeAppWindowDragController::UpdateDraggedWindow(
   drag_delegate_->dragged_window()->SetTransform(transform);
 }
 
+float TabletModeAppWindowDragController::CalculateWindowScale(
+    int y_location_in_screen) const {
+  float minimum_scale =
+      static_cast<float>(new_selector_item_bounds_.height()) /
+      static_cast<float>(drag_delegate_->dragged_window()->bounds().height());
+  int y_full = new_selector_item_bounds_.y();
+  int y_diff = y_full - y_location_in_screen;
+  if (y_diff < 0)
+    return minimum_scale;
+
+  return (1.0f - minimum_scale) * y_diff / y_full + minimum_scale;
+}
+
 }  // namespace ash

ash/wm/tablet_mode/tablet_mode_app_window_drag_controller.h

@@ -19,6 +19,9 @@ class TabletModeWindowDragDelegate;
 // splitscreen through swiping from the top of the screen in tablet mode.
 class ASH_EXPORT TabletModeAppWindowDragController {
  public:
+  // Threshold of the fling velocity to drop the window into overview.
+  static constexpr float kFlingToOverviewThreshold = 100.0f;
+
   TabletModeAppWindowDragController();
   ~TabletModeAppWindowDragController();
 
@@ -38,10 +41,22 @@ class ASH_EXPORT TabletModeAppWindowDragController {
   // Apply transform to the dragged window during dragging.
   void UpdateDraggedWindow(const gfx::Point& location_in_screen);
 
+  // The scale of the window during drag is based on the distance from
+  // |y_location_in_screen| to the y position of |new_selector_item_bounds_|.
+  // The dragged window will become smaller when it becomes nearer to the new
+  // selector item. And then keep the minimum scale if it has been dragged
+  // further than the new selector item.
+  float CalculateWindowScale(int y_location_in_screen) const;
+
   std::unique_ptr<TabletModeWindowDragDelegate> drag_delegate_;
 
   gfx::Point initial_location_in_screen_;
 
+  // Overview mode will be triggered if a window is being dragged from the top
+  // of the display, and a new selector item will be created in the overview
+  // grid. See |new_selector_item_widget_| in WindowGrid for more info.
+  gfx::Rect new_selector_item_bounds_;
+
   DISALLOW_COPY_AND_ASSIGN(TabletModeAppWindowDragController);
 };