Moves handful of files to ash/wm/common

ash/wm/common/window_state.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/window_state.h"
+#include "ash/wm/common/window_state.h"
 
 #include <utility>
 
+#include "ash/wm/common/default_state.h"
 #include "ash/wm/common/window_positioning_utils.h"
+#include "ash/wm/common/window_state_delegate.h"
+#include "ash/wm/common/window_state_observer.h"
 #include "ash/wm/common/wm_event.h"
 #include "ash/wm/common/wm_screen_util.h"
 #include "ash/wm/common/wm_window.h"
-#include "ash/wm/default_state.h"
-#include "ash/wm/window_state_delegate.h"
-#include "ash/wm/window_state_observer.h"
 #include "base/auto_reset.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 namespace wm {
 
 namespace {
 
 WMEventType WMEventTypeFromShowState(ui::WindowShowState requested_show_state) {
@@ skipping 13 matching lines @@
       return WM_EVENT_DOCK;
     case ui::SHOW_STATE_END:
       NOTREACHED() << "No WMEvent defined for the show state:"
                    << requested_show_state;
   }
   return WM_EVENT_NORMAL;
 }
 
 }  // namespace
 
-WindowState::~WindowState() {
-}
+WindowState::~WindowState() {}
 
 bool WindowState::HasDelegate() const {
   return !!delegate_;
 }
 
 void WindowState::SetDelegate(std::unique_ptr<WindowStateDelegate> delegate) {
   DCHECK(!delegate_.get());
   delegate_ = std::move(delegate);
 }
 
 WindowStateType WindowState::GetStateType() const {
   return current_state_->GetType();
 }
 
 bool WindowState::IsMinimized() const {
   return GetStateType() == WINDOW_STATE_TYPE_MINIMIZED ||
          GetStateType() == WINDOW_STATE_TYPE_DOCKED_MINIMIZED;
 }
 
 bool WindowState::IsMaximized() const {
   return GetStateType() == WINDOW_STATE_TYPE_MAXIMIZED;
 }
 
 bool WindowState::IsFullscreen() const {
   return GetStateType() == WINDOW_STATE_TYPE_FULLSCREEN;
 }
 
 bool WindowState::IsMaximizedOrFullscreen() const {
   return GetStateType() == WINDOW_STATE_TYPE_FULLSCREEN ||
-      GetStateType() == WINDOW_STATE_TYPE_MAXIMIZED;
+         GetStateType() == WINDOW_STATE_TYPE_MAXIMIZED;
 }
 
 bool WindowState::IsSnapped() const {
   return GetStateType() == WINDOW_STATE_TYPE_LEFT_SNAPPED ||
-      GetStateType() == WINDOW_STATE_TYPE_RIGHT_SNAPPED;
+         GetStateType() == WINDOW_STATE_TYPE_RIGHT_SNAPPED;
 }
 
 bool WindowState::IsNormalStateType() const {
   return GetStateType() == WINDOW_STATE_TYPE_NORMAL ||
-      GetStateType() == WINDOW_STATE_TYPE_DEFAULT;
+         GetStateType() == WINDOW_STATE_TYPE_DEFAULT;
 }
 
 bool WindowState::IsNormalOrSnapped() const {
   return IsNormalStateType() || IsSnapped();
 }
 
 bool WindowState::IsActive() const {
   return window_->IsActive();
 }
 
@@ skipping 138 matching lines @@
 
 std::unique_ptr<WindowState::State> WindowState::SetStateObject(
     std::unique_ptr<WindowState::State> new_state) {
   current_state_->DetachState(this);
   std::unique_ptr<WindowState::State> old_object = std::move(current_state_);
   current_state_ = std::move(new_state);
   current_state_->AttachState(this, old_object.get());
   return old_object;
 }
 
-void WindowState::SetPreAutoManageWindowBounds(
-    const gfx::Rect& bounds) {
+void WindowState::SetPreAutoManageWindowBounds(const gfx::Rect& bounds) {
   pre_auto_manage_window_bounds_.reset(new gfx::Rect(bounds));
 }
 
 void WindowState::AddObserver(WindowStateObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void WindowState::RemoveObserver(WindowStateObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
@@ skipping 46 matching lines @@
       current_state_(new DefaultState(ToWindowStateType(GetShowState()))) {}
 
 bool WindowState::GetAlwaysOnTop() const {
   return window_->IsAlwaysOnTop();
 }
 
 ui::WindowShowState WindowState::GetShowState() const {
   return window_->GetShowState();
 }
 
-void WindowState::SetBoundsInScreen(
-    const gfx::Rect& bounds_in_screen) {
+void WindowState::SetBoundsInScreen(const gfx::Rect& bounds_in_screen) {
   gfx::Rect bounds_in_parent =
       window_->GetParent()->ConvertRectFromScreen(bounds_in_screen);
   window_->SetBounds(bounds_in_parent);
 }
 
 void WindowState::AdjustSnappedBounds(gfx::Rect* bounds) {
   if (is_dragged() || !IsSnapped())
     return;
   gfx::Rect maximized_bounds = GetMaximizedWindowBoundsInParent(window_);
   if (GetStateType() == WINDOW_STATE_TYPE_LEFT_SNAPPED)
@@ skipping 60 matching lines @@
   if (!window_->GetTargetVisibility()) {
     SetBoundsConstrained(new_bounds);
     return;
   }
 
   window_->SetBoundsDirectCrossFade(new_bounds);
 }
 
 }  // namespace wm
 }  // namespace ash