Moves handful of files to ash/wm/common

ash/wm/common/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/wm/common/default_state.h"
 
-#include "ash/shell_window_ids.h"
+#include "ash/wm/common/dock/docked_window_layout_manager.h"
 #include "ash/wm/common/window_animation_types.h"
 #include "ash/wm/common/window_parenting_utils.h"
 #include "ash/wm/common/window_positioning_utils.h"
+#include "ash/wm/common/window_state.h"
+#include "ash/wm/common/window_state_delegate.h"
 #include "ash/wm/common/window_state_util.h"
 #include "ash/wm/common/wm_event.h"
 #include "ash/wm/common/wm_globals.h"
 #include "ash/wm/common/wm_root_window_controller.h"
 #include "ash/wm/common/wm_screen_util.h"
+#include "ash/wm/common/wm_shell_window_ids.h"
 #include "ash/wm/common/wm_window.h"
-#include "ash/wm/dock/docked_window_layout_manager.h"
-#include "ash/wm/window_state.h"
-#include "ash/wm/window_state_delegate.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 namespace wm {
 namespace {
 
 // This specifies how much percent (30%) of a window rect
 // must be visible when the window is added to the workspace.
 const float kMinimumPercentOnScreenArea = 0.3f;
@@ skipping 71 matching lines @@
 
  private:
   DockedWindowLayoutManager* docked_window_layout_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedDockedLayoutEventSourceResetter);
 };
 
 void CycleSnapDock(WindowState* window_state, WMEventType event) {
   DockedWindowLayoutManager* dock_layout =
       GetDockedWindowLayoutManager(window_state->window()->GetGlobals());
-  wm::WindowStateType desired_snap_state = event ==
-      WM_EVENT_CYCLE_SNAP_DOCK_LEFT ? wm::WINDOW_STATE_TYPE_LEFT_SNAPPED :
-      wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED;
-  DockedAlignment desired_dock_alignment = event ==
-      WM_EVENT_CYCLE_SNAP_DOCK_LEFT ?
-      DOCKED_ALIGNMENT_LEFT : DOCKED_ALIGNMENT_RIGHT;
-  DockedAlignment current_dock_alignment = dock_layout ?
-      dock_layout->CalculateAlignment() : DOCKED_ALIGNMENT_NONE;
+  wm::WindowStateType desired_snap_state =
+      event == WM_EVENT_CYCLE_SNAP_DOCK_LEFT
+          ? wm::WINDOW_STATE_TYPE_LEFT_SNAPPED
+          : wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED;
+  DockedAlignment desired_dock_alignment =
+      event == WM_EVENT_CYCLE_SNAP_DOCK_LEFT ? DOCKED_ALIGNMENT_LEFT
+                                             : DOCKED_ALIGNMENT_RIGHT;
+  DockedAlignment current_dock_alignment =
+      dock_layout ? dock_layout->CalculateAlignment() : DOCKED_ALIGNMENT_NONE;
 
   if (!window_state->IsDocked() ||
       (current_dock_alignment != DOCKED_ALIGNMENT_NONE &&
        current_dock_alignment != desired_dock_alignment)) {
     if (window_state->CanSnap() &&
         window_state->GetStateType() != desired_snap_state &&
         window_state->window()->GetType() != ui::wm::WINDOW_TYPE_PANEL) {
       const wm::WMEvent event(desired_snap_state ==
-                              wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ?
-                              wm::WM_EVENT_SNAP_LEFT : wm::WM_EVENT_SNAP_RIGHT);
+                                      wm::WINDOW_STATE_TYPE_LEFT_SNAPPED
+                                  ? wm::WM_EVENT_SNAP_LEFT
+                                  : wm::WM_EVENT_SNAP_RIGHT);
       window_state->OnWMEvent(&event);
       return;
     }
 
     if (dock_layout &&
         dock_layout->CanDockWindow(window_state->window(),
                                    desired_dock_alignment)) {
       if (window_state->IsDocked()) {
         dock_layout->MaybeSetDesiredDockedAlignment(desired_dock_alignment);
         return;
@@ skipping 15 matching lines @@
   }
   window_state->window()->Animate(::wm::WINDOW_ANIMATION_TYPE_BOUNCE);
 }
 
 }  // namespace
 
 DefaultState::DefaultState(WindowStateType initial_state_type)
     : state_type_(initial_state_type), stored_window_state_(nullptr) {}
 DefaultState::~DefaultState() {}
 
-void DefaultState::OnWMEvent(WindowState* window_state,
-                             const WMEvent* event) {
+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 =
-          current_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED ?
-              WINDOW_STATE_TYPE_DOCKED : WINDOW_STATE_TYPE_NORMAL;
+      next_state_type = current_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED
+                            ? WINDOW_STATE_TYPE_DOCKED
+                            : WINDOW_STATE_TYPE_NORMAL;
       break;
     case WM_EVENT_MAXIMIZE:
       next_state_type = WINDOW_STATE_TYPE_MAXIMIZED;
       break;
     case WM_EVENT_MINIMIZE:
-      next_state_type =
-          current_state_type == WINDOW_STATE_TYPE_DOCKED ?
-              WINDOW_STATE_TYPE_DOCKED_MINIMIZED : WINDOW_STATE_TYPE_MINIMIZED;
+      next_state_type = current_state_type == WINDOW_STATE_TYPE_DOCKED
+                            ? WINDOW_STATE_TYPE_DOCKED_MINIMIZED
+                            : 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;
@@ skipping 17 matching lines @@
       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;
   }
 
   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());
+    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);
 }
 
 WindowStateType DefaultState::GetType() const {
   return state_type_;
 }
 
-void DefaultState::AttachState(
-    WindowState* window_state,
-    WindowState::State* state_in_previous_mode) {
+void DefaultState::AttachState(WindowState* window_state,
+                               WindowState::State* state_in_previous_mode) {
   DCHECK_EQ(stored_window_state_, window_state);
 
   ReenterToCurrentState(window_state, state_in_previous_mode);
 
   // If the display has changed while in the another mode,
   // we need to let windows know the change.
   gfx::Display current_display =
       window_state->window()->GetDisplayNearestWindow();
   if (stored_display_state_.bounds() != current_display.bounds()) {
     const WMEvent event(wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED);
     window_state->OnWMEvent(&event);
   } else if (stored_display_state_.work_area() != current_display.work_area()) {
     const WMEvent event(wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED);
     window_state->OnWMEvent(&event);
   }
 }
 
 void DefaultState::DetachState(WindowState* window_state) {
   stored_window_state_ = window_state;
   stored_bounds_ = window_state->window()->GetBounds();
-  stored_restore_bounds_ = window_state->HasRestoreBounds() ?
-      window_state->GetRestoreBoundsInParent() : gfx::Rect();
+  stored_restore_bounds_ = window_state->HasRestoreBounds()
+                               ? window_state->GetRestoreBoundsInParent()
+                               : gfx::Rect();
   // Remember the display state so that in case of the display change
   // while in the other mode, we can perform necessary action to
   // restore the window state to the proper state for the current
   // display.
   stored_display_state_ = window_state->window()->GetDisplayNearestWindow();
 }
 
 // static
 bool DefaultState::ProcessCompoundEvents(WindowState* window_state,
                                          const WMEvent* event) {
@@ skipping 256 matching lines @@
   WindowStateType previous_state_type = state_type_;
   state_type_ = next_state_type;
 
   window_state->UpdateWindowShowStateFromStateType();
   window_state->NotifyPreStateTypeChange(previous_state_type);
 
   if (window_state->window()->GetParent()) {
     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->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->IsNormalStateType() && window_state->HasRestoreBounds() &&
         !window_state->unminimize_to_restore_bounds()) {
       restore_bounds_in_screen = window_state->GetRestoreBoundsInScreen();
       window_state->SaveCurrentBoundsForRestore();
     }
 
     if (window_state->IsMaximizedOrFullscreen())
       MoveToDisplayForRestore(window_state);
 
     UpdateBoundsFromState(window_state, previous_state_type);
 
@@ skipping 164 matching lines @@
     gfx::Rect center_in_parent = GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->GetBounds().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