Moves handful of files to ash/wm/common

ash/wm/common/dock/docked_window_layout_manager.cc

 // Copyright (c) 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/dock/docked_window_layout_manager.h"
+#include "ash/wm/common/dock/docked_window_layout_manager.h"
 
 #include "ash/wm/common/shelf/wm_shelf.h"
 #include "ash/wm/common/shelf/wm_shelf_constants.h"
 #include "ash/wm/common/shelf/wm_shelf_observer.h"
 #include "ash/wm/common/window_animation_types.h"
 #include "ash/wm/common/window_parenting_utils.h"
+#include "ash/wm/common/window_resizer.h"
+#include "ash/wm/common/window_state.h"
 #include "ash/wm/common/wm_globals.h"
 #include "ash/wm/common/wm_root_window_controller.h"
 #include "ash/wm/common/wm_shell_window_ids.h"
 #include "ash/wm/common/wm_window.h"
-#include "ash/wm/window_resizer.h"
-#include "ash/wm/window_state.h"
 #include "base/auto_reset.h"
 #include "base/metrics/histogram.h"
 #include "grit/ash_resources.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
@@ skipping 46 matching lines @@
  private:
   // views::Widget:
   void OnNativeWidgetVisibilityChanged(bool visible) override {
     views::Widget::OnNativeWidgetVisibilityChanged(visible);
     UpdateBackground();
   }
 
   void OnNativeWidgetPaint(const ui::PaintContext& context) override {
     gfx::Rect local_window_bounds(GetWindowBoundsInScreen().size());
     ui::PaintRecorder recorder(context, local_window_bounds.size());
-    const gfx::ImageSkia& shelf_background(
-        alignment_ == DOCKED_ALIGNMENT_LEFT ?
-            shelf_background_left_ : shelf_background_right_);
+    const gfx::ImageSkia& shelf_background(alignment_ == DOCKED_ALIGNMENT_LEFT
+                                               ? shelf_background_left_
+                                               : shelf_background_right_);
     SkPaint paint;
     paint.setAlpha(alpha_);
     recorder.canvas()->DrawImageInt(
         shelf_background, 0, 0, shelf_background.width(),
         shelf_background.height(),
         alignment_ == DOCKED_ALIGNMENT_LEFT
             ? local_window_bounds.width() - shelf_background.width()
             : 0,
         0, shelf_background.width(), local_window_bounds.height(), false,
         paint);
@@ skipping 56 matching lines @@
     // added to the container, and UpdateStacking only manages user windows, not
     // the background widget.
     parent->StackChildAtBottom(wm_window);
   }
 
   // Transitions to |visible_background_type_| if the widget is visible and to
   // SHELF_BACKGROUND_DEFAULT if it is not.
   void UpdateBackground() {
     wm::ShelfBackgroundType background_type =
         IsVisible() ? visible_background_type_ : wm::SHELF_BACKGROUND_DEFAULT;
-    BackgroundAnimatorChangeType change_type = IsVisible() ?
-        visible_background_change_type_ : BACKGROUND_CHANGE_IMMEDIATE;
+    BackgroundAnimatorChangeType change_type =
+        IsVisible() ? visible_background_change_type_
+                    : BACKGROUND_CHANGE_IMMEDIATE;
 
     float target_opacity =
         (background_type == wm::SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
     std::unique_ptr<ui::ScopedLayerAnimationSettings>
         opaque_background_animation;
     if (change_type != BACKGROUND_CHANGE_IMMEDIATE) {
       opaque_background_animation.reset(new ui::ScopedLayerAnimationSettings(
           opaque_background_.GetAnimator()));
       opaque_background_animation->SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(wm::kTimeToSwitchBackgroundMs));
@@ skipping 65 matching lines @@
 
 // Returns width that is as close as possible to |target_width| while being
 // consistent with docked min and max restrictions and respects the |window|'s
 // minimum and maximum size.
 int GetWindowWidthCloseTo(const wm::WmWindow* window, int target_width) {
   if (!window->GetWindowState()->CanResize()) {
     DCHECK_LE(window->GetBounds().width(),
               DockedWindowLayoutManager::kMaxDockWidth);
     return window->GetBounds().width();
   }
-  int width = std::max(DockedWindowLayoutManager::kMinDockWidth,
-                       std::min(target_width,
-                                DockedWindowLayoutManager::kMaxDockWidth));
+  int width = std::max(
+      DockedWindowLayoutManager::kMinDockWidth,
+      std::min(target_width, DockedWindowLayoutManager::kMaxDockWidth));
   width = std::max(width, window->GetMinimumSize().width());
   if (window->GetMaximumSize().width() != 0)
     width = std::min(width, window->GetMaximumSize().width());
   DCHECK_LE(width, DockedWindowLayoutManager::kMaxDockWidth);
   return width;
 }
 
 // Returns height that is as close as possible to |target_height| while
 // respecting the |window|'s minimum and maximum size.
 int GetWindowHeightCloseTo(const wm::WmWindow* window, int target_height) {
@@ skipping 90 matching lines @@
   wm::WmWindow* dragged_window_;
   wm::WmWindow* docked_container_;
   float delta_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // A class that observes shelf for bounds changes.
 class DockedWindowLayoutManager::ShelfWindowObserver
     : public wm::WmWindowObserver {
  public:
-  explicit ShelfWindowObserver(
-      DockedWindowLayoutManager* docked_layout_manager)
+  explicit ShelfWindowObserver(DockedWindowLayoutManager* docked_layout_manager)
       : docked_layout_manager_(docked_layout_manager) {
     DCHECK(docked_layout_manager_->shelf()->GetWindow());
     docked_layout_manager_->shelf()->GetWindow()->AddObserver(this);
   }
 
   ~ShelfWindowObserver() override {
     if (docked_layout_manager_->shelf() &&
         docked_layout_manager_->shelf()->GetWindow()) {
       docked_layout_manager_->shelf()->GetWindow()->RemoveObserver(this);
     }
@@ skipping 85 matching lines @@
 void DockedWindowLayoutManager::StartDragging(wm::WmWindow* window) {
   DCHECK(!dragged_window_);
   dragged_window_ = window;
   DCHECK(!IsPopupOrTransient(window));
   // Start observing a window unless it is docked container's child in which
   // case it is already observed.
   wm::WindowState* dragged_state = dragged_window_->GetWindowState();
   if (dragged_window_->GetParent() != dock_container_) {
     dragged_window_->AddObserver(this);
     dragged_state->AddObserver(this);
-  } else if (!IsAnyWindowDocked() &&
-             dragged_state->drag_details() &&
+  } else if (!IsAnyWindowDocked() && dragged_state->drag_details() &&
              !(dragged_state->drag_details()->bounds_change &
-                 WindowResizer::kBoundsChange_Resizes)) {
+               WindowResizer::kBoundsChange_Resizes)) {
     // If there are no other docked windows clear alignment when a docked window
     // is moved (but not when it is resized or the window could get undocked
     // when resized away from the edge while docked).
     alignment_ = DOCKED_ALIGNMENT_NONE;
   }
   is_dragged_from_dock_ = window->GetParent() == dock_container_;
   DCHECK(!is_dragged_window_docked_);
 
   // Resize all windows that are flush with the dock edge together if one of
   // them gets resized.
@@ skipping 24 matching lines @@
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
   is_dragged_from_dock_ = false;
 }
 
 void DockedWindowLayoutManager::FinishDragging(DockedAction action,
                                                DockedActionSource source) {
   DCHECK(dragged_window_);
   DCHECK(!IsPopupOrTransient(dragged_window_));
   if (is_dragged_window_docked_)
     OnDraggedWindowUndocked();
-  DCHECK (!is_dragged_window_docked_);
+  DCHECK(!is_dragged_window_docked_);
   // Stop observing a window unless it is docked container's child in which
   // case it needs to keep being observed after the drag completes.
   if (dragged_window_->GetParent() != dock_container_) {
     dragged_window_->RemoveObserver(this);
     dragged_window_->GetWindowState()->RemoveObserver(this);
     if (last_active_window_ == dragged_window_)
       last_active_window_ = nullptr;
   } else {
     // If this is the first window that got docked by a move update alignment.
     if (alignment_ == DOCKED_ALIGNMENT_NONE)
@@ skipping 58 matching lines @@
   return DOCKED_ALIGNMENT_NONE;
 }
 
 bool DockedWindowLayoutManager::CanDockWindow(
     wm::WmWindow* window,
     DockedAlignment desired_alignment) {
   // Don't allow interactive docking of windows with transient parents such as
   // modal browser dialogs. Prevent docking of panels attached to shelf during
   // the drag.
   wm::WindowState* window_state = window->GetWindowState();
-  bool should_attach_to_shelf = window_state->drag_details() &&
+  bool should_attach_to_shelf =
+      window_state->drag_details() &&
       window_state->drag_details()->should_attach_to_shelf;
   if (IsPopupOrTransient(window) || should_attach_to_shelf)
     return false;
   // If a window is wide and cannot be resized down to maximum width allowed
   // then it cannot be docked.
   // TODO(varkha). Prevent windows from changing size programmatically while
   // they are docked. The size will take effect only once a window is undocked.
   // See http://crbug.com/307792.
   if (window->GetBounds().width() > kMaxDockWidth &&
       (!window_state->CanResize() ||
        (window->GetMinimumSize().width() != 0 &&
         window->GetMinimumSize().width() > kMaxDockWidth))) {
     return false;
   }
   // If a window is tall and cannot be resized down to maximum height allowed
   // then it cannot be docked.
   const gfx::Rect work_area =
       dock_container_->GetDisplayNearestWindow().work_area();
   if (GetWindowHeightCloseTo(window, work_area.height()) > work_area.height())
     return false;
   // Cannot dock on the other size from an existing dock.
   const DockedAlignment alignment = CalculateAlignmentExcept(window);
   if (desired_alignment != DOCKED_ALIGNMENT_NONE &&
-      alignment != DOCKED_ALIGNMENT_NONE &&
-      alignment != desired_alignment) {
+      alignment != DOCKED_ALIGNMENT_NONE && alignment != desired_alignment) {
     return false;
   }
   // Do not allow docking on the same side as shelf.
   return IsDockedAlignmentValid(desired_alignment);
 }
 
 bool DockedWindowLayoutManager::IsDockedAlignmentValid(
     DockedAlignment alignment) const {
   wm::ShelfAlignment shelf_alignment =
       shelf_ ? shelf_->GetAlignment() : wm::SHELF_ALIGNMENT_BOTTOM;
   if ((alignment == DOCKED_ALIGNMENT_LEFT &&
        shelf_alignment == wm::SHELF_ALIGNMENT_LEFT) ||
       (alignment == DOCKED_ALIGNMENT_RIGHT &&
        shelf_alignment == wm::SHELF_ALIGNMENT_RIGHT)) {
     return false;
   }
   return true;
 }
 
 void DockedWindowLayoutManager::MaybeSetDesiredDockedAlignment(
     DockedAlignment alignment) {
   // If the requested alignment is |NONE| or there are no
   // docked windows return early as we can't change whether there is a
   // dock or not. If the requested alignment is the same as the current
   // alignment return early as an optimization.
   if (alignment == DOCKED_ALIGNMENT_NONE ||
-      alignment_ == DOCKED_ALIGNMENT_NONE ||
-      alignment_ == alignment ||
+      alignment_ == DOCKED_ALIGNMENT_NONE || alignment_ == alignment ||
       !IsDockedAlignmentValid(alignment)) {
     return;
   }
   alignment_ = alignment;
 
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
 void DockedWindowLayoutManager::OnShelfBoundsChanged() {
@@ skipping 16 matching lines @@
     return;
   // Dragged windows are already observed by StartDragging and do not change
   // docked alignment during the drag.
   if (child == dragged_window_)
     return;
   // If this is the first window getting docked - update alignment.
   // A window can be added without proper bounds when window is moved to another
   // display via API or due to display configuration change, so the alignment
   // is set based on which edge is closer in the new display.
   if (alignment_ == DOCKED_ALIGNMENT_NONE) {
-    alignment_ = preferred_alignment_ != DOCKED_ALIGNMENT_NONE ?
-        preferred_alignment_ : GetEdgeNearestWindow(child);
+    alignment_ = preferred_alignment_ != DOCKED_ALIGNMENT_NONE
+                     ? preferred_alignment_
+                     : GetEdgeNearestWindow(child);
   }
   MaybeMinimizeChildrenExcept(child);
   child->AddObserver(this);
   child->GetWindowState()->AddObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 
   // Only keyboard-initiated actions are recorded here. Dragging cases
   // are handled in FinishDragging.
   if (event_source_ != DOCKED_ACTION_SOURCE_UNKNOWN)
@@ skipping 208 matching lines @@
   int available_room = work_area.height();
   bool gap_needed = !!child;
   if (child)
     available_room -= GetWindowHeightCloseTo(child, 0);
   // Use a copy of children array because a call to Minimize can change order.
   std::vector<wm::WmWindow*> children(dock_container_->GetChildren());
   for (auto iter = children.rbegin(); iter != children.rend(); ++iter) {
     wm::WmWindow* window(*iter);
     if (window == child || !IsWindowDocked(window))
       continue;
-    int room_needed = GetWindowHeightCloseTo(window, 0) +
-        (gap_needed ? kMinDockGap : 0);
+    int room_needed =
+        GetWindowHeightCloseTo(window, 0) + (gap_needed ? kMinDockGap : 0);
     gap_needed = true;
     if (available_room > room_needed) {
       available_room -= room_needed;
     } else {
       // Slow down minimizing animations. Lock duration so that it is not
       // overridden by other ScopedLayerAnimationSettings down the stack.
       ui::ScopedLayerAnimationSettings settings(
           window->GetLayer()->GetAnimator());
       settings.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kMinimizeDurationMs));
@@ skipping 40 matching lines @@
 void DockedWindowLayoutManager::RecordUmaAction(DockedAction action,
                                                 DockedActionSource source) {
   if (action == DOCKED_ACTION_NONE)
     return;
   UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Action", action, DOCKED_ACTION_COUNT);
   UMA_HISTOGRAM_ENUMERATION("Ash.Dock.ActionSource", source,
                             DOCKED_ACTION_SOURCE_COUNT);
   base::Time time_now = base::Time::Now();
   base::TimeDelta time_between_use = time_now - last_action_time_;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.Dock.TimeBetweenUse",
-                              time_between_use.InSeconds(),
-                              1,
-                              base::TimeDelta::FromHours(10).InSeconds(),
-                              100);
+                              time_between_use.InSeconds(), 1,
+                              base::TimeDelta::FromHours(10).InSeconds(), 100);
   last_action_time_ = time_now;
   int docked_all_count = 0;
   int docked_visible_count = 0;
   int docked_panels_count = 0;
   int large_windows_count = 0;
   for (wm::WmWindow* window : dock_container_->GetChildren()) {
     if (IsPopupOrTransient(window))
       continue;
     docked_all_count++;
     if (!IsWindowDocked(window))
@@ skipping 20 matching lines @@
   docked_width_ = width;
   UMA_HISTOGRAM_COUNTS_10000("Ash.Dock.Width", docked_width_);
 }
 
 void DockedWindowLayoutManager::OnDraggedWindowDocked(wm::WmWindow* window) {
   DCHECK(!is_dragged_window_docked_);
   is_dragged_window_docked_ = true;
 }
 
 void DockedWindowLayoutManager::OnDraggedWindowUndocked() {
-  DCHECK (is_dragged_window_docked_);
+  DCHECK(is_dragged_window_docked_);
   is_dragged_window_docked_ = false;
 }
 
 bool DockedWindowLayoutManager::IsAnyWindowDocked() {
   return CalculateAlignment() != DOCKED_ALIGNMENT_NONE;
 }
 
 DockedAlignment DockedWindowLayoutManager::GetEdgeNearestWindow(
     const wm::WmWindow* window) const {
   const gfx::Rect bounds(window->GetBoundsInScreen());
@@ skipping 40 matching lines @@
   if (is_dragged_window_docked_) {
     visible_windows.push_back(WindowWithHeight(dragged_window_));
     DCHECK(!active_window);
     active_window = dragged_window_;
   }
 
   // Position docked windows as well as the window being dragged.
   gfx::Rect work_area = dock_container_->GetDisplayNearestWindow().work_area();
   if (shelf_observer_)
     work_area.Subtract(shelf_observer_->shelf_bounds_in_screen());
-  int available_room = CalculateWindowHeightsAndRemainingRoom(work_area,
-                                                              &visible_windows);
-  FanOutChildren(work_area,
-                 CalculateIdealWidth(visible_windows),
-                 available_room,
-                 &visible_windows);
+  int available_room =
+      CalculateWindowHeightsAndRemainingRoom(work_area, &visible_windows);
+  FanOutChildren(work_area, CalculateIdealWidth(visible_windows),
+                 available_room, &visible_windows);
 
   // After the first Relayout allow the windows to change their order easier
   // since we know they are docked.
   is_dragged_from_dock_ = true;
   UpdateStacking(active_window);
 }
 
 int DockedWindowLayoutManager::CalculateWindowHeightsAndRemainingRoom(
     const gfx::Rect& work_area,
     std::vector<WindowWithHeight>* visible_windows) {
   int available_room = work_area.height();
   int remaining_windows = visible_windows->size();
   int gap_height = remaining_windows > 1 ? kMinDockGap : 0;
 
   // Sort windows by their minimum heights and calculate target heights.
   std::sort(visible_windows->begin(), visible_windows->end(),
             CompareMinimumHeight());
   // Distribute the free space among the docked windows. Since the windows are
   // sorted (tall windows first) we can now assume that any window which
   // required more space than the current window will have already been
   // accounted for previously in this loop, so we can safely give that window
   // its proportional share of the remaining space.
   for (std::vector<WindowWithHeight>::reverse_iterator iter =
            visible_windows->rbegin();
-      iter != visible_windows->rend(); ++iter) {
+       iter != visible_windows->rend(); ++iter) {
     iter->height = GetWindowHeightCloseTo(
         iter->window,
         (available_room + gap_height) / remaining_windows - gap_height);
     available_room -= (iter->height + gap_height);
     remaining_windows--;
   }
   return available_room + gap_height;
 }
 
 int DockedWindowLayoutManager::CalculateIdealWidth(
@@ skipping 10 matching lines @@
     const wm::WmWindow* window = iter->window;
     int min_window_width = window->GetBounds().width();
     int max_window_width = min_window_width;
     if (!window->GetWindowState()->bounds_changed_by_user()) {
       min_window_width = GetWindowWidthCloseTo(window, kMinDockWidth);
       max_window_width = GetWindowWidthCloseTo(window, kMaxDockWidth);
     }
     largest_min_width = std::max(largest_min_width, min_window_width);
     smallest_max_width = std::min(smallest_max_width, max_window_width);
   }
-  int ideal_width = std::max(largest_min_width,
-                             std::min(smallest_max_width, kIdealWidth));
+  int ideal_width =
+      std::max(largest_min_width, std::min(smallest_max_width, kIdealWidth));
   // Restrict docked area width regardless of window restrictions.
   ideal_width = std::max(std::min(ideal_width, kMaxDockWidth), kMinDockWidth);
   return ideal_width;
 }
 
 void DockedWindowLayoutManager::FanOutChildren(
     const gfx::Rect& work_area,
     int ideal_docked_width,
     int available_room,
     std::vector<WindowWithHeight>* visible_windows) {
   gfx::Rect dock_bounds = dock_container_->GetBoundsInScreen();
 
   // Calculate initial vertical offset and the gap or overlap between windows.
   const int num_windows = visible_windows->size();
-  const float delta = static_cast<float>(available_room) /
-      ((available_room > 0 || num_windows <= 1) ?
-          num_windows + 1 : num_windows - 1);
+  const float delta =
+      static_cast<float>(available_room) /
+      ((available_room > 0 || num_windows <= 1) ? num_windows + 1
+                                                : num_windows - 1);
   float y_pos = work_area.y() + ((delta > 0) ? delta : 0);
 
   // Docked area is shown only if there is at least one non-dragged visible
   // docked window.
   int new_width = ideal_docked_width;
   if (visible_windows->empty() ||
       (visible_windows->size() == 1 &&
        (*visible_windows)[0].window == dragged_window_)) {
     new_width = 0;
   }
@@ skipping 17 matching lines @@
                     ? bounds.width()
                     : ideal_docked_width));
     DCHECK_LE(bounds.width(), ideal_docked_width);
 
     DockedAlignment alignment = alignment_;
     if (alignment == DOCKED_ALIGNMENT_NONE && window == dragged_window_)
       alignment = GetEdgeNearestWindow(window);
 
     // Fan out windows evenly distributing the overlap or remaining free space.
     bounds.set_height(iter->height);
-    bounds.set_y(std::max(work_area.y(),
-                          std::min(work_area.bottom() - bounds.height(),
-                                   static_cast<int>(y_pos + 0.5))));
+    bounds.set_y(
+        std::max(work_area.y(), std::min(work_area.bottom() - bounds.height(),
+                                         static_cast<int>(y_pos + 0.5))));
     y_pos += bounds.height() + delta + kMinDockGap;
 
     // All docked windows other than the one currently dragged remain stuck
     // to the screen edge (flush with the edge or centered in the dock area).
     switch (alignment) {
       case DOCKED_ALIGNMENT_LEFT:
         bounds.set_x(dock_bounds.x() +
                      (ideal_docked_width - bounds.width()) / 2);
         break;
       case DOCKED_ALIGNMENT_RIGHT:
@@ skipping 26 matching lines @@
 void DockedWindowLayoutManager::UpdateDockBounds(
     DockedWindowLayoutManagerObserver::Reason reason) {
   int dock_inset = docked_width_ + (docked_width_ > 0 ? kMinDockGap : 0);
   const gfx::Rect work_area =
       dock_container_->GetDisplayNearestWindow().work_area();
   gfx::Rect bounds = gfx::Rect(
       alignment_ == DOCKED_ALIGNMENT_RIGHT && dock_inset > 0
           ? dock_container_->GetBounds().right() - dock_inset
           : dock_container_->GetBounds().x(),
       dock_container_->GetBounds().y(), dock_inset, work_area.height());
-  docked_bounds_ = bounds +
-      dock_container_->GetBoundsInScreen().OffsetFromOrigin();
-  FOR_EACH_OBSERVER(
-      DockedWindowLayoutManagerObserver,
-      observer_list_,
-      OnDockBoundsChanging(bounds, reason));
+  docked_bounds_ =
+      bounds + dock_container_->GetBoundsInScreen().OffsetFromOrigin();
+  FOR_EACH_OBSERVER(DockedWindowLayoutManagerObserver, observer_list_,
+                    OnDockBoundsChanging(bounds, reason));
   // Show or hide background for docked area.
   gfx::Rect background_bounds(docked_bounds_);
   if (shelf_observer_)
     background_bounds.Subtract(shelf_observer_->shelf_bounds_in_screen());
   if (docked_width_ > 0) {
     if (!background_widget_)
       background_widget_.reset(new DockedBackgroundWidget(this));
     background_widget_->SetBackgroundBounds(background_bounds, alignment_);
     background_widget_->Show();
   } else if (background_widget_) {
@@ skipping 59 matching lines @@
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace ash