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 = window_state->GetStateType();

[varkha, 2014/09/23 22:35:31]

nit: current_state_type would be more expressive now that you've expanded the
scope where it is used.

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

Acknowledged.

   WindowStateType next_state_type = WINDOW_STATE_TYPE_NORMAL;
   switch (event->type()) {
     case WM_EVENT_NORMAL:
-      next_state_type = WINDOW_STATE_TYPE_NORMAL;
+      if (current == WINDOW_STATE_TYPE_DOCKED_MINIMIZED) {

[varkha, 2014/09/23 22:35:31]

nit: Ternary? Here and below.

+        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 == 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_UNDOCK:

[varkha, 2014/09/23 22:35:31]

Can we make it work without this event type?

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

Done.

+      if (current == WINDOW_STATE_TYPE_DOCKED) {
+        next_state_type = WINDOW_STATE_TYPE_NORMAL;
+      } else if (current == WINDOW_STATE_TYPE_DOCKED_MINIMIZED) {
+        next_state_type = WINDOW_STATE_TYPE_MINIMIZED;
+      } else {
+        return;

[varkha, 2014/09/23 22:35:31]

Does this ever happen (if not - NOTREACHED() would be good)?

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

Done.

+      }
+      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()) {
     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 132 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:
+    case WM_EVENT_UNDOCK:
       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:
+    case WM_EVENT_UNDOCK:
       break;
   }
   return false;
 }
 
 // static
 bool DefaultState::SetMaximizedOrFullscreenBounds(WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
   if (window_state->IsMaximized()) {
     window_state->SetBoundsDirect(
@@ skipping 115 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;
     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 88 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