Refactors DockedWindowLayoutManager in terms of ash/wm/common

ash/wm/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/shelf/shelf.h"
-#include "ash/shelf/shelf_constants.h"
-#include "ash/shelf/shelf_layout_manager.h"
-#include "ash/shelf/shelf_layout_manager_observer.h"
-#include "ash/shelf/shelf_types.h"
-#include "ash/shelf/shelf_widget.h"
 #include "ash/shell_window_ids.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/wm_globals.h"
 #include "ash/wm/common/wm_root_window_controller.h"
 #include "ash/wm/common/wm_window.h"
-#include "ash/wm/window_animations.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"
@@ skipping 13 matching lines @@
 const int DockedWindowLayoutManager::kMinDockGap = 2;
 // static
 const int DockedWindowLayoutManager::kIdealWidth = 250;
 const int kMinimumHeight = 250;
 const int kSlideDurationMs = 120;
 const int kFadeDurationMs = 60;
 const int kMinimizeDurationMs = 720;
 
 class DockedBackgroundWidget : public views::Widget,
                                public BackgroundAnimatorDelegate,
-                               public ShelfLayoutManagerObserver {
+                               public wm::WmShelfObserver {
  public:
   explicit DockedBackgroundWidget(DockedWindowLayoutManager* manager)
       : manager_(manager),
         alignment_(DOCKED_ALIGNMENT_NONE),
-        background_animator_(this, 0, kShelfBackgroundAlpha),
+        background_animator_(this, 0, wm::kShelfBackgroundAlpha),
         alpha_(0),
         opaque_background_(ui::LAYER_SOLID_COLOR),
-        visible_background_type_(
-            manager_->shelf()->shelf_widget()->GetBackgroundType()),
+        visible_background_type_(manager_->shelf()->GetBackgroundType()),
         visible_background_change_type_(BACKGROUND_CHANGE_IMMEDIATE) {
-    manager_->shelf()->shelf_layout_manager()->AddObserver(this);
+    manager_->shelf()->AddObserver(this);
     InitWidget(manager_->dock_container());
   }
 
   ~DockedBackgroundWidget() override {
-    manager_->shelf()->shelf_layout_manager()->RemoveObserver(this);
+    manager_->shelf()->RemoveObserver(this);
   }
 
   // Sets widget bounds and sizes opaque background layer to fill the widget.
   void SetBackgroundBounds(const gfx::Rect& bounds, DockedAlignment alignment) {
     SetBounds(bounds);
     opaque_background_.SetBounds(gfx::Rect(bounds.size()));
     alignment_ = alignment;
   }
 
  private:
@@ skipping 28 matching lines @@
         local_window_bounds.height(), false, paint);
   }
 
   // BackgroundAnimatorDelegate:
   void UpdateBackground(int alpha) override {
     alpha_ = alpha;
     SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
   }
 
   // ShelfLayoutManagerObserver:
-  void OnBackgroundUpdated(ShelfBackgroundType background_type,
+  void OnBackgroundUpdated(wm::ShelfBackgroundType background_type,
                            BackgroundAnimatorChangeType change_type) override {
     // Sets the background type. Starts an animation to transition to
     // |background_type| if the widget is visible. If the widget is not visible,
     // the animation is postponed till the widget becomes visible.
     visible_background_type_ = background_type;
     visible_background_change_type_ = change_type;
     if (IsVisible())
       UpdateBackground();
   }
 
@@ skipping 27 matching lines @@
     // This background should be explicitly stacked below any windows already in
     // the dock, otherwise the z-order is set by the order in which windows were
     // 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() {
-    ShelfBackgroundType background_type = IsVisible() ?
-        visible_background_type_ : SHELF_BACKGROUND_DEFAULT;
+    wm::ShelfBackgroundType background_type =
+        IsVisible() ? visible_background_type_ : wm::SHELF_BACKGROUND_DEFAULT;
     BackgroundAnimatorChangeType change_type = IsVisible() ?
         visible_background_change_type_ : BACKGROUND_CHANGE_IMMEDIATE;
 
     float target_opacity =
-        (background_type == SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
+        (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(kTimeToSwitchBackgroundMs));
+          base::TimeDelta::FromMilliseconds(wm::kTimeToSwitchBackgroundMs));
     }
     opaque_background_.SetOpacity(target_opacity);
 
     // TODO(varkha): use ui::Layer on both opaque_background and normal
     // background retire background_animator_ at all. It would be simpler.
     // See also ShelfWidget::SetPaintsBackground.
     background_animator_.SetPaintsBackground(
-        background_type != SHELF_BACKGROUND_DEFAULT,
-        change_type);
+        background_type != wm::SHELF_BACKGROUND_DEFAULT, change_type);
     SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
   }
 
   DockedWindowLayoutManager* manager_;
 
   DockedAlignment alignment_;
 
   // The animator for the background transitions.
   BackgroundAnimator background_animator_;
 
   // The alpha to use for drawing image assets covering the docked background.
   int alpha_;
 
   // Solid black background that can be made fully opaque.
   ui::Layer opaque_background_;
 
   // Backgrounds created from shelf background by 90 or 270 degree rotation.
   gfx::ImageSkia shelf_background_left_;
   gfx::ImageSkia shelf_background_right_;
 
   // The background type to use when the widget is visible. When not visible,
   // the widget uses SHELF_BACKGROUND_DEFAULT.
-  ShelfBackgroundType visible_background_type_;
+  wm::ShelfBackgroundType visible_background_type_;
 
   // Whether the widget should animate to |visible_background_type_|.
   BackgroundAnimatorChangeType visible_background_change_type_;
 
   DISALLOW_COPY_AND_ASSIGN(DockedBackgroundWidget);
 };
 
 namespace {
 
 // Returns true if a window is a popup or a transient child.
@@ skipping 140 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // A class that observes shelf for bounds changes.
 class DockedWindowLayoutManager::ShelfWindowObserver
     : public wm::WmWindowObserver {
  public:
   explicit ShelfWindowObserver(
       DockedWindowLayoutManager* docked_layout_manager)
       : docked_layout_manager_(docked_layout_manager) {
-    DCHECK(docked_layout_manager_->shelf()->shelf_widget());
-    wm::WmWindow::Get(docked_layout_manager_->shelf()->shelf_widget())
-        ->AddObserver(this);
+    DCHECK(docked_layout_manager_->shelf()->GetWindow());
+    docked_layout_manager_->shelf()->GetWindow()->AddObserver(this);
   }
 
   ~ShelfWindowObserver() override {
     if (docked_layout_manager_->shelf() &&
-        docked_layout_manager_->shelf()->shelf_widget()) {
-      wm::WmWindow::Get(docked_layout_manager_->shelf()->shelf_widget())
-          ->RemoveObserver(this);
+        docked_layout_manager_->shelf()->GetWindow()) {
+      docked_layout_manager_->shelf()->GetWindow()->RemoveObserver(this);
     }
   }
 
   // wm::WmWindowObserver:
   void OnWindowBoundsChanged(wm::WmWindow* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override {
     shelf_bounds_in_screen_ =
         window->GetParent()->ConvertRectToScreen(new_bounds);
     docked_layout_manager_->OnShelfBoundsChanged();
@@ skipping 149 matching lines @@
     // count limit so do it here.
     MaybeMinimizeChildrenExcept(dragged_window_);
   }
   dragged_window_ = nullptr;
   dragged_bounds_ = gfx::Rect();
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
   RecordUmaAction(action, source);
 }
 
-void DockedWindowLayoutManager::SetShelf(Shelf* shelf) {
+void DockedWindowLayoutManager::SetShelf(wm::WmShelf* shelf) {
   DCHECK(!shelf_);
   shelf_ = shelf;
   shelf_observer_.reset(new ShelfWindowObserver(this));
 }
 
 DockedAlignment DockedWindowLayoutManager::GetAlignmentOfWindow(
     const wm::WmWindow* window) const {
   const gfx::Rect& bounds(window->GetBoundsInScreen());
 
   // Test overlap with an existing docked area first.
@@ skipping 67 matching lines @@
       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 {
-  ShelfAlignment shelf_alignment = shelf_ ? shelf_->alignment() :
-      SHELF_ALIGNMENT_BOTTOM;
+  wm::ShelfAlignment shelf_alignment =
+      shelf_ ? shelf_->GetAlignment() : wm::SHELF_ALIGNMENT_BOTTOM;
   if ((alignment == DOCKED_ALIGNMENT_LEFT &&
-       shelf_alignment == SHELF_ALIGNMENT_LEFT) ||
+       shelf_alignment == wm::SHELF_ALIGNMENT_LEFT) ||
       (alignment == DOCKED_ALIGNMENT_RIGHT &&
-       shelf_alignment == SHELF_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
@@ skipping 97 matching lines @@
         std::max(min_size.width(), actual_new_bounds.width()));
     actual_new_bounds.set_height(
         std::max(min_size.height(), actual_new_bounds.height()));
   }
   if (IsWindowDocked(child) && child != dragged_window_)
     return;
   wm::WmSnapToPixelLayoutManager::SetChildBounds(child, actual_new_bounds);
   if (IsPopupOrTransient(child))
     return;
   // Whenever one of our windows is moved or resized enforce layout.
-  ShelfLayoutManager* shelf_layout = shelf_->shelf_layout_manager();
-  if (shelf_layout)
-    shelf_layout->UpdateVisibilityState();
+  if (shelf_)
+    shelf_->UpdateVisibilityState();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, ash::ShellObserver implementation:
 
 void DockedWindowLayoutManager::OnWorkAreaChanged() {
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::DISPLAY_INSETS_CHANGED);
   MaybeMinimizeChildrenExcept(dragged_window_);
 }
@@ skipping 23 matching lines @@
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
 void DockedWindowLayoutManager::OnShelfAlignmentChanged() {
   if (!shelf_ || alignment_ == DOCKED_ALIGNMENT_NONE)
     return;
 
   // Do not allow shelf and dock on the same side. Switch side that
   // the dock is attached to and move all dock windows to that new side.
-  ShelfAlignment shelf_alignment = shelf_->alignment();
+  wm::ShelfAlignment shelf_alignment = shelf_->GetAlignment();
   if (alignment_ == DOCKED_ALIGNMENT_LEFT &&
-      shelf_alignment == SHELF_ALIGNMENT_LEFT) {
+      shelf_alignment == wm::SHELF_ALIGNMENT_LEFT) {
     alignment_ = DOCKED_ALIGNMENT_RIGHT;
   } else if (alignment_ == DOCKED_ALIGNMENT_RIGHT &&
-             shelf_alignment == SHELF_ALIGNMENT_RIGHT) {
+             shelf_alignment == wm::SHELF_ALIGNMENT_RIGHT) {
     alignment_ = DOCKED_ALIGNMENT_LEFT;
   }
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::SHELF_ALIGNMENT_CHANGED);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, WindowStateObserver implementation:
 
 void DockedWindowLayoutManager::OnPreWindowStateTypeChange(
@@ skipping 510 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