Add window states docked; and docked minimized. Add wm window event to set docked and undocked.

ash/wm/default_state.cc

 // Copyright 2014 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/default_state.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 60 matching lines @@
 DefaultState::~DefaultState() {}
 
 void DefaultState::OnWMEvent(WindowState* window_state,
                              const WMEvent* event) {
   if (ProcessWorkspaceEvents(window_state, event))
     return;
 
   if (ProcessCompoundEvents(window_state, event))
     return;
 
+  WindowStateType current_state_type = window_state->GetStateType();
   WindowStateType next_state_type = WINDOW_STATE_TYPE_NORMAL;
   switch (event->type()) {
     case WM_EVENT_NORMAL:
-      next_state_type = WINDOW_STATE_TYPE_NORMAL;
+      if (current_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED) {

[varkha, 2014/09/25 22:09:28]

nit: there are still some nits from the first batch of comments. Generally you
make sure that all the comments are answered in some way, this makes it easier
to review knowing that there is no need to go back and revisit old comments.

[dtapuska, 2014/09/26 14:17:07]

Sorry I thought I covered them all; but I should Ack mark them as Done; point
taken.

+        next_state_type = WINDOW_STATE_TYPE_DOCKED;
+      } else {
+        next_state_type = WINDOW_STATE_TYPE_NORMAL;
+      }
       break;
     case WM_EVENT_MAXIMIZE:
       next_state_type = WINDOW_STATE_TYPE_MAXIMIZED;
       break;
     case WM_EVENT_MINIMIZE:
-      next_state_type = WINDOW_STATE_TYPE_MINIMIZED;
+      if (current_state_type == WINDOW_STATE_TYPE_DOCKED) {
+        next_state_type = WINDOW_STATE_TYPE_DOCKED_MINIMIZED;
+      } else {
+        next_state_type = WINDOW_STATE_TYPE_MINIMIZED;
+      }
       break;
     case WM_EVENT_FULLSCREEN:
       next_state_type = WINDOW_STATE_TYPE_FULLSCREEN;
       break;
     case WM_EVENT_SNAP_LEFT:
       next_state_type = WINDOW_STATE_TYPE_LEFT_SNAPPED;
       break;
     case WM_EVENT_SNAP_RIGHT:
       next_state_type = WINDOW_STATE_TYPE_RIGHT_SNAPPED;
       break;
+    case WM_EVENT_DOCK:
+      next_state_type = WINDOW_STATE_TYPE_DOCKED;
+      break;
     case WM_EVENT_SET_BOUNDS:
       SetBounds(window_state, static_cast<const SetBoundsEvent*>(event));
       return;
     case WM_EVENT_SHOW_INACTIVE:
       next_state_type = WINDOW_STATE_TYPE_INACTIVE;
       break;
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
     case WM_EVENT_CENTER:
       NOTREACHED() << "Compound event should not reach here:" << event;
       return;
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       NOTREACHED() << "Workspace event should not reach here:" << event;
       return;
   }
 
-  WindowStateType current = window_state->GetStateType();
-
-  if (next_state_type == current && window_state->IsSnapped()) {
+  if (next_state_type == current_state_type && window_state->IsSnapped()) {
     gfx::Rect snapped_bounds = event->type() == WM_EVENT_SNAP_LEFT ?
         GetDefaultLeftSnappedWindowBoundsInParent(window_state->window()) :
         GetDefaultRightSnappedWindowBoundsInParent(window_state->window());
     window_state->SetBoundsDirectAnimated(snapped_bounds);
     return;
   }
 
   EnterToNextState(window_state, next_state_type);
 }
 
@@ skipping 131 matching lines @@
       CenterWindow(window_state);
       return true;
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
+    case WM_EVENT_DOCK:
       break;
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       NOTREACHED() << "Workspace event should not reach here:" << event;
       break;
   }
   return false;
 }
 
@@ skipping 79 matching lines @@
     case WM_EVENT_TOGGLE_FULLSCREEN:
     case WM_EVENT_CENTER:
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
+    case WM_EVENT_DOCK:
       break;
   }
   return false;
 }
 
 // static
 bool DefaultState::SetMaximizedOrFullscreenBounds(WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
   if (window_state->IsMaximized()) {
     window_state->SetBoundsDirect(
@@ skipping 32 matching lines @@
     return;
 
   WindowStateType previous_state_type = state_type_;
   state_type_ = next_state_type;
 
   window_state->UpdateWindowShowStateFromStateType();
   window_state->NotifyPreStateTypeChange(previous_state_type);
 
   // This Docked/Snapped hack is due to the issue that IsDocked returns
   // true for dragging window.  TODO(oshima): Make docked window a state
   // and remove this hack.

[varkha, 2014/09/25 22:09:28]

This comment can now be moved to above line 449.

[dtapuska, 2014/09/26 14:17:07]

Done.

-  if (window_state->window()->parent() &&
-      (window_state->IsSnapped() ||
-       (!window_state->IsDocked() && !IsPanel(window_state->window())))) {
+  if (window_state->window()->parent()) {
     if (!window_state->HasRestoreBounds() &&
         (previous_state_type == WINDOW_STATE_TYPE_DEFAULT ||
          previous_state_type == WINDOW_STATE_TYPE_NORMAL) &&
         !window_state->IsMinimized() &&
         !window_state->IsNormalStateType()) {
       window_state->SaveCurrentBoundsForRestore();
     }
 
-    // When restoring from a minimized state, we want to restore to the previous
-    // bounds. However, we want to maintain the restore bounds. (The restore
-    // bounds are set if a user maximized the window in one axis by double
-    // clicking the window border for example).
-    gfx::Rect restore_bounds_in_screen;
-    if (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED &&
-        window_state->IsNormalStateType() &&
-        window_state->HasRestoreBounds() &&
-        !window_state->unminimize_to_restore_bounds()) {
-      restore_bounds_in_screen = window_state->GetRestoreBoundsInScreen();
-      window_state->SaveCurrentBoundsForRestore();
-    }
+    if (window_state->IsSnapped() ||
+        (!window_state->IsDocked() && !IsPanel(window_state->window()))) {
 

[varkha, 2014/09/25 22:09:28]

nit: no need for empty line.

[dtapuska, 2014/09/26 14:17:07]

Done.

-    if (window_state->IsMaximizedOrFullscreen())
-      MoveToDisplayForRestore(window_state);
+      // When restoring from a minimized state, we want to restore to the
+      // previousbounds. However, we want to maintain the restore bounds.

[varkha, 2014/09/25 22:09:28]

nit: space after 'previous'.

[dtapuska, 2014/09/26 14:17:07]

Done.

+      // (The restore bounds are set if a user maximized the window in one
+      // axis by double clicking the window border for example).
+      gfx::Rect restore_bounds_in_screen;
+      if (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED &&
+          window_state->IsNormalStateType() &&
+          window_state->HasRestoreBounds() &&
+          !window_state->unminimize_to_restore_bounds()) {
+        restore_bounds_in_screen = window_state->GetRestoreBoundsInScreen();
+        window_state->SaveCurrentBoundsForRestore();
+      }
 
-    UpdateBoundsFromState(window_state, previous_state_type);
+      if (window_state->IsMaximizedOrFullscreen())
+        MoveToDisplayForRestore(window_state);
 
-    // Normal state should have no restore bounds unless it's
-    // unminimzied.
-    if (!restore_bounds_in_screen.IsEmpty())
-      window_state->SetRestoreBoundsInScreen(restore_bounds_in_screen);
-    else if (window_state->IsNormalStateType())
-      window_state->ClearRestoreBounds();
+      UpdateBoundsFromState(window_state, previous_state_type);
+
+      // Normal state should have no restore bounds unless it's
+      // unminimized.
+      if (!restore_bounds_in_screen.IsEmpty())
+        window_state->SetRestoreBoundsInScreen(restore_bounds_in_screen);
+      else if (window_state->IsNormalStateType())
+        window_state->ClearRestoreBounds();
+      }
   }
   window_state->NotifyPostStateTypeChange(previous_state_type);
 }
 
 void DefaultState::ReenterToCurrentState(
     WindowState* window_state,
     WindowState::State* state_in_previous_mode) {
   WindowStateType previous_state_type = state_in_previous_mode->GetType();
   if (previous_state_type == wm::WINDOW_STATE_TYPE_FULLSCREEN) {
     // A state change should not move a window out of full screen since full
@@ skipping 27 matching lines @@
                                          WindowStateType previous_state_type) {
   aura::Window* window = window_state->window();
   gfx::Rect bounds_in_parent;
   switch (state_type_) {
     case WINDOW_STATE_TYPE_LEFT_SNAPPED:
     case WINDOW_STATE_TYPE_RIGHT_SNAPPED:
       bounds_in_parent = state_type_ == WINDOW_STATE_TYPE_LEFT_SNAPPED ?
           GetDefaultLeftSnappedWindowBoundsInParent(window_state->window()) :
           GetDefaultRightSnappedWindowBoundsInParent(window_state->window());
       break;
+    case WINDOW_STATE_TYPE_DOCKED:
+    case WINDOW_STATE_TYPE_DOCKED_MINIMIZED:
+      break;

[varkha, 2014/09/25 22:09:28]

nit: I suggest merging this with case WINDOW_STATE_TYPE_MINIMIZED below.

[dtapuska, 2014/09/26 14:17:07]

Slightly modified; but adjusted.

     case WINDOW_STATE_TYPE_DEFAULT:
     case WINDOW_STATE_TYPE_NORMAL: {
       gfx::Rect work_area_in_parent =
           ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
       if (window_state->HasRestoreBounds()) {
         bounds_in_parent = window_state->GetRestoreBoundsInParent();
         // Check if the |window|'s restored size is bigger than the working area
         // This may happen if a window was resized to maximized bounds or if the
         // display resolution changed while the window was maximized.
         if (previous_state_type == WINDOW_STATE_TYPE_MAXIMIZED &&
@@ skipping 21 matching lines @@
       break;
 
     case WINDOW_STATE_TYPE_MINIMIZED:
       break;
     case WINDOW_STATE_TYPE_INACTIVE:
     case WINDOW_STATE_TYPE_END:
     case WINDOW_STATE_TYPE_AUTO_POSITIONED:
       return;
   }
 
   if (state_type_ != WINDOW_STATE_TYPE_MINIMIZED) {

[varkha, 2014/09/25 22:09:28]

Should this account for the new WINDOW_STATE_DOCKED_MINIMIZED state as well?
Here and in other places where we check for WINDOW_STATE_TYPE_MINIMIZED rather
than IsMinimized?

[dtapuska, 2014/09/26 14:17:07]

Done.

     if (previous_state_type == WINDOW_STATE_TYPE_MINIMIZED ||
         window_state->IsFullscreen()) {
       window_state->SetBoundsDirect(bounds_in_parent);
     } else if (window_state->IsMaximized() ||
                IsMaximizedOrFullscreenWindowStateType(previous_state_type)) {
       window_state->SetBoundsDirectCrossFade(bounds_in_parent);
     } else if (window_state->is_dragged()) {
       // SetBoundsDirectAnimated does not work when the window gets reparented.
       // TODO(oshima): Consider fixing it and reenable the animation.
       window_state->SetBoundsDirect(bounds_in_parent);
@@ skipping 46 matching lines @@
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->bounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash