CrOS Tablet Window management - Split Screen part I

ash/wm/overview/window_selector.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 "ash/wm/overview/window_selector.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/accessibility_types.h"
 #include "ash/metrics/user_metrics_action.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/wm/mru_window_tracker.h"
+#include "ash/wm/overview/overview_window_drag_controller.h"
 #include "ash/wm/overview/window_grid.h"
 #include "ash/wm/overview/window_selector_delegate.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/panels/panel_layout_manager.h"
+#include "ash/wm/splitview/split_view_controller.h"
 #include "ash/wm/switchable_windows.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/metrics/histogram_macros.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
@@ skipping 94 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(RoundedContainerView);
 };
 
 // Triggers a shelf visibility update on all root window controllers.
 void UpdateShelfVisibility() {
   for (aura::Window* root : Shell::GetAllRootWindows())
     Shelf::ForWindow(root)->UpdateVisibilityState();
 }
 
+// Returns the bounds for the overview window grids according to the split view
+// state.
+gfx::Rect GetGridsBoundsInScreen(aura::Window* root_window) {
+  gfx::Rect bounds_in_screen;
+  if (Shell::Get()->IsSplitViewModeActive()) {
+    SplitViewController::State state =
+        Shell::Get()->split_view_controller()->state();
+    DCHECK(state != SplitViewController::NOSNAP);
+    if (state == SplitViewController::RIGHT_SNAPPED) {
+      // Open overview in the left side of the screen.
+      bounds_in_screen =
+          Shell::Get()->split_view_controller()->GetLeftWindowBoundsInScreen(

[oshima, 2017/06/14 00:19:27]

it's probably better to have

GetSnappedWindowBoundsInScreen(root_window, snap_state);

[xdai1, 2017/06/15 22:11:41]

Done.

+              root_window);
+    } else if (state == SplitViewController::LEFT_SNAPPED) {
+      // Open overview in the right side of the screen.
+      bounds_in_screen =
+          Shell::Get()->split_view_controller()->GetRightWindowBoundsInScreen(
+              root_window);
+    }
+  } else {
+    bounds_in_screen = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+        root_window->GetChildById(kShellWindowId_DefaultContainer));
+    ::wm::ConvertRectToScreen(root_window, &bounds_in_screen);
+  }
+
+  return bounds_in_screen;
+}
+
 gfx::Rect GetTextFilterPosition(aura::Window* root_window) {
-  gfx::Rect total_bounds = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-      root_window->GetChildById(kShellWindowId_DefaultContainer));
-  ::wm::ConvertRectToScreen(root_window, &total_bounds);
+  gfx::Rect total_bounds = GetGridsBoundsInScreen(root_window);
   return gfx::Rect(
       0.5 * (total_bounds.width() -
-             std::min(kTextFilterWidth, total_bounds.width())),
+             std::min(kTextFilterWidth, total_bounds.width())) +
+          total_bounds.x(),
       total_bounds.y() + total_bounds.height() * kTextFilterTopScreenProportion,
       std::min(kTextFilterWidth, total_bounds.width()), kTextFilterHeight);
 }
 
 // Initializes the text filter on the top of the main root window and requests
 // focus on its textfield. Uses |image| to place an icon to the left of the text
 // field.
 views::Widget* CreateTextFilter(views::TextfieldController* controller,
                                 aura::Window* root_window,
                                 const gfx::ImageSkia& image,
@@ skipping 106 matching lines @@
       aura::Window* container =
           root->GetChildById(wm::kSwitchableWindowContainerIds[i]);
       container->AddObserver(this);
       observed_windows_.insert(container);
     }
 
     // Hide the callout widgets for panels. It is safe to call this for
     // root windows that don't contain any panel windows.
     PanelLayoutManager::Get(root)->SetShowCalloutWidgets(false);
 
-    std::unique_ptr<WindowGrid> grid(new WindowGrid(root, windows, this));
+    std::unique_ptr<WindowGrid> grid(
+        new WindowGrid(root, windows, this, GetGridsBoundsInScreen(root)));
     if (grid->empty())
       continue;
     num_items_ += grid->size();
     grid_list_.push_back(std::move(grid));
   }
 
   {
     // The calls to WindowGrid::PrepareForOverview() and CreateTextFilter(...)
     // requires some LayoutManagers (ie PanelLayoutManager) to perform layouts
     // so that windows are correctly visible and properly animated in overview
@@ skipping 16 matching lines @@
                                           kTextFilterIconColor);
     aura::Window* root_window = Shell::GetPrimaryRootWindow();
     text_filter_widget_.reset(CreateTextFilter(this, root_window, search_image_,
                                                &text_filter_bottom_));
   }
 
   DCHECK(!grid_list_.empty());
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_);
 
   Shell::Get()->activation_client()->AddObserver(this);
+  Shell::Get()->split_view_controller()->AddObserver(this);
 
   display::Screen::GetScreen()->AddObserver(this);
   ShellPort::Get()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
   // Send an a11y alert.
   Shell::Get()->accessibility_delegate()->TriggerAccessibilityAlert(
       A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 
   UpdateShelfVisibility();
 }
 
 // NOTE: The work done in Shutdown() is not done in the destructor because it
 // may cause other, unrelated classes, (ie PanelLayoutManager) to make indirect
 // calls to restoring_minimized_windows() on a partially destructed object.
 void WindowSelector::Shutdown() {
   is_shut_down_ = true;
   // Stop observing screen metrics changes first to avoid auto-positioning
   // windows in response to work area changes from window activation.
   display::Screen::GetScreen()->RemoveObserver(this);
 
+  // Stop observing split view state changes before restoring window focus.
+  // Otherwise the activation of the window triggers OnSplitViewStateChanged()
+  // that will call into this function again.
+  Shell::Get()->split_view_controller()->RemoveObserver(this);
+
   size_t remaining_items = 0;
   for (std::unique_ptr<WindowGrid>& window_grid : grid_list_) {
     for (const auto& window_selector_item : window_grid->window_list())
       window_selector_item->RestoreWindow();
     remaining_items += window_grid->size();
   }
 
   // Setting focus after restoring windows' state avoids unnecessary animations.
   ResetFocusRestoreWindow(true);
   RemoveAllObservers();
@@ skipping 99 matching lines @@
     }
   }
   item->EnsureVisible();
   wm::GetWindowState(window)->Activate();
 }
 
 void WindowSelector::WindowClosing(WindowSelectorItem* window) {
   grid_list_[selected_grid_index_]->WindowClosing(window);
 }
 
+void WindowSelector::SetBoundsForWindowGridsInScreen(const gfx::Rect bounds) {
+  for (std::unique_ptr<WindowGrid>& grid : grid_list_)
+    grid->SetBoundsInScreen(bounds);
+}
+
+void WindowSelector::RemoveWindowSelectorItem(WindowSelectorItem* item) {
+  if (item->GetWindow()->HasObserver(this)) {
+    item->GetWindow()->RemoveObserver(this);
+    observed_windows_.erase(item->GetWindow());
+    if (item->GetWindow() == restore_focus_window_)
+      restore_focus_window_ = nullptr;
+  }
+
+  // Remove |item| from the corresponding grid.
+  for (std::unique_ptr<WindowGrid>& grid : grid_list_) {
+    if (grid->Contains(item->GetWindow())) {
+      grid->RemoveItem(item);
+      break;
+    }
+  }
+}
+
+void WindowSelector::InitiateDrag(WindowSelectorItem* item,
+                                  const gfx::Point& location_in_screen) {
+  window_drag_controller_.reset(new OverviewWindowDragController(this));

[oshima, 2017/06/14 00:19:27]

MakeUnique

[xdai1, 2017/06/15 22:11:42]

reset is better here since |window_drag_controller_| might not be nullptr?

+  window_drag_controller_->InitiateDrag(item, location_in_screen);
+}
+
+void WindowSelector::Drag(WindowSelectorItem* item,
+                          const gfx::Point& location_in_screen) {
+  DCHECK(window_drag_controller_.get());

[oshima, 2017/06/14 00:19:27]

it'll crash immediately, so you don't need this.

[xdai1, 2017/06/15 22:11:41]

I don't understand. Why will it crash immediately? 

+  window_drag_controller_->Drag(item, location_in_screen);
+}
+
+void WindowSelector::CompleteDrag(WindowSelectorItem* item) {
+  DCHECK(window_drag_controller_.get());

[oshima, 2017/06/14 00:19:27]

same here

[xdai1, 2017/06/15 22:11:41]

ditto

+  window_drag_controller_->CompleteDrag(item);
+}
+
 bool WindowSelector::HandleKeyEvent(views::Textfield* sender,
                                     const ui::KeyEvent& key_event) {
   if (key_event.type() != ui::ET_KEY_PRESSED)
     return false;
 
   switch (key_event.key_code()) {
     case ui::VKEY_ESCAPE:
       CancelSelection();
       break;
     case ui::VKEY_UP:
@@ skipping 46 matching lines @@
 
 void WindowSelector::OnDisplayAdded(const display::Display& display) {}
 
 void WindowSelector::OnDisplayRemoved(const display::Display& display) {
   // TODO(flackr): Keep window selection active on remaining displays.
   CancelSelection();
 }
 
 void WindowSelector::OnDisplayMetricsChanged(const display::Display& display,
                                              uint32_t metrics) {
+  // Re-calculate the bounds for the window grids and position all the windows.
+  for (std::unique_ptr<WindowGrid>& grid : grid_list_) {
+    SetBoundsForWindowGridsInScreen(
+        GetGridsBoundsInScreen(const_cast<aura::Window*>(grid->root_window())));
+  }
   PositionWindows(/* animate */ false);
   RepositionTextFilterOnDisplayMetricsChange();
 }
 
 void WindowSelector::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
   // Only care about newly added children of |observed_windows_|.
   if (!observed_windows_.count(params.receiver) ||
       !observed_windows_.count(params.new_parent)) {
     return;
@@ skipping 42 matching lines @@
       windows.begin(), windows.end(),
       [gained_active](const std::unique_ptr<WindowSelectorItem>& window) {
         return window->Contains(gained_active);
       });
 
   if (iter == windows.end() && showing_text_filter_ &&
       lost_active == GetTextFilterWidgetWindow()) {
     return;
   }
 
+  if (Shell::Get()->IsSplitViewModeActive())
+    return;

[oshima, 2017/06/14 00:19:27]

not clear to me why you need this. Can you elaborate?

[xdai1, 2017/06/15 22:11:41]

The window activation might be caused by window snap. In this case we should not
cancel overview mode. 

Only when two windows are both snapped to both sides of the screen, the overview
mode should be cancelled, and this logic is addressed in line 718-719 in this
patch.

+
   // Don't restore focus on exit if a window was just activated.
   ResetFocusRestoreWindow(false);
   CancelSelection();
 }
 
 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
                                                  aura::Window* actual_active) {
   OnWindowActivated(ActivationReason::ACTIVATION_CLIENT, request_active,
                     actual_active);
 }
@@ skipping 30 matching lines @@
   for (auto iter = grid_list_.begin(); iter != grid_list_.end(); iter++)
     (*iter)->FilterItems(new_contents);
 
   // If the selection widget is not active, execute a Move() command so that it
   // shows up on the first undimmed item.
   if (grid_list_[selected_grid_index_]->is_selecting())
     return;
   Move(WindowSelector::RIGHT, false);
 }
 
-aura::Window* WindowSelector::GetTextFilterWidgetWindow() {
-  return text_filter_widget_->GetNativeWindow();
+void WindowSelector::OnSplitViewStateChanged(
+    SplitViewController::State previous_state,
+    SplitViewController::State state) {
+  if (state != SplitViewController::NOSNAP) {
+    // Do not restore focus if a window was just snapped and activated.
+    ResetFocusRestoreWindow(false);
+  }
+
+  if (state == SplitViewController::BOTH_SNAPPED) {
+    CancelSelection();
+  } else if (state == SplitViewController::LEFT_SNAPPED) {
+    aura::Window* snapped_window =
+        Shell::Get()->split_view_controller()->left_window();
+    gfx::Rect bounds_in_screen =

[oshima, 2017/06/14 00:19:27]

nit: const

[xdai1, 2017/06/15 22:11:42]

Done.

+        Shell::Get()->split_view_controller()->GetRightWindowBoundsInScreen(
+            snapped_window);
+    SetBoundsForWindowGridsInScreen(bounds_in_screen);
+  } else if (state == SplitViewController::RIGHT_SNAPPED) {
+    aura::Window* snapped_window =
+        Shell::Get()->split_view_controller()->right_window();
+    gfx::Rect bounds_in_screen =

[oshima, 2017/06/14 00:19:27]

const

[xdai1, 2017/06/15 22:11:41]

Done.

+        Shell::Get()->split_view_controller()->GetLeftWindowBoundsInScreen(
+            snapped_window);
+    SetBoundsForWindowGridsInScreen(bounds_in_screen);
+  } else {
+    DCHECK(state == SplitViewController::NOSNAP);

[oshima, 2017/06/14 00:19:27]

DCHECK_EQ

[xdai1, 2017/06/15 22:11:41]

Done.

+    // TODO(xdai): Decide what to do here.
+  }
 }
 
 void WindowSelector::PositionWindows(bool animate) {
   for (std::unique_ptr<WindowGrid>& grid : grid_list_)
     grid->PositionWindows(animate);
 }
 
+aura::Window* WindowSelector::GetTextFilterWidgetWindow() {
+  return text_filter_widget_->GetNativeWindow();
+}
+
 void WindowSelector::RepositionTextFilterOnDisplayMetricsChange() {
   const gfx::Rect rect = GetTextFilterPosition(Shell::GetPrimaryRootWindow());
   text_filter_bottom_ = rect.bottom() + kTextFieldBottomMargin;
   text_filter_widget_->SetBounds(rect);
 
   gfx::Transform transform;
   transform.Translate(
       0, text_filter_string_length_ == 0 ? -text_filter_bottom_ : 0);
   aura::Window* text_filter_window = GetTextFilterWidgetWindow();
   text_filter_window->layer()->SetOpacity(text_filter_string_length_ == 0 ? 0
@@ skipping 33 matching lines @@
   for (size_t i = 0; i <= grid_list_.size() &&
                      grid_list_[selected_grid_index_]->Move(direction, animate);
        i++) {
     selected_grid_index_ =
         (selected_grid_index_ + display_direction + grid_list_.size()) %
         grid_list_.size();
   }
 }
 
 }  // namespace ash