mash: Move ash/common/wm/shelf to ash/common/shelf

ash/common/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/common/wm/dock/docked_window_layout_manager.h"
 
+#include "ash/common/shelf/shelf_constants.h"
+#include "ash/common/shelf/wm_shelf.h"
+#include "ash/common/shelf/wm_shelf_observer.h"
 #include "ash/common/shell_window_ids.h"
-#include "ash/common/wm/shelf/wm_shelf.h"
-#include "ash/common/wm/shelf/wm_shelf_constants.h"
-#include "ash/common/wm/shelf/wm_shelf_observer.h"
 #include "ash/common/wm/window_animation_types.h"
 #include "ash/common/wm/window_parenting_utils.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "base/auto_reset.h"
 #include "base/metrics/histogram.h"
@@ skipping 19 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 wm::WmShelfObserver {
+                               public WmShelfObserver {
  public:
   explicit DockedBackgroundWidget(DockedWindowLayoutManager* manager)
       : manager_(manager),
         alignment_(DOCKED_ALIGNMENT_NONE),
-        background_animator_(this, 0, wm::kShelfBackgroundAlpha),
+        background_animator_(this, 0, kShelfBackgroundAlpha),
         alpha_(0),
         opaque_background_(ui::LAYER_SOLID_COLOR),
         visible_background_type_(manager_->shelf()->GetBackgroundType()),
         visible_background_change_type_(BACKGROUND_CHANGE_IMMEDIATE) {
     manager_->shelf()->AddObserver(this);
     InitWidget(manager_->dock_container());
   }
 
   ~DockedBackgroundWidget() override {
     manager_->shelf()->RemoveObserver(this);
@@ skipping 38 matching lines @@
         local_window_bounds.height(), false, paint);
   }
 
   // BackgroundAnimatorDelegate:
   void UpdateBackground(int alpha) override {
     alpha_ = alpha;
     SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
   }
 
   // ShelfLayoutManagerObserver:
-  void OnBackgroundUpdated(wm::ShelfBackgroundType background_type,
+  void OnBackgroundUpdated(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() {
-    wm::ShelfBackgroundType background_type =
-        IsVisible() ? visible_background_type_ : wm::SHELF_BACKGROUND_DEFAULT;
+    ShelfBackgroundType background_type =
+        IsVisible() ? visible_background_type_ : SHELF_BACKGROUND_DEFAULT;
     BackgroundAnimatorChangeType change_type =
         IsVisible() ? visible_background_change_type_
                     : BACKGROUND_CHANGE_IMMEDIATE;
 
     float target_opacity =
-        (background_type == wm::SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
+        (background_type == 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));
+          base::TimeDelta::FromMilliseconds(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 != wm::SHELF_BACKGROUND_DEFAULT, change_type);
+        background_type != 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.
-  wm::ShelfBackgroundType visible_background_type_;
+  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 312 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(wm::WmShelf* shelf) {
+void DockedWindowLayoutManager::SetShelf(WmShelf* shelf) {
   DCHECK(!shelf_);
   shelf_ = shelf;
   shelf_observer_.reset(new ShelfWindowObserver(this));
 }
 
 DockedAlignment DockedWindowLayoutManager::GetAlignmentOfWindow(
     const WmWindow* window) const {
   const gfx::Rect& bounds(window->GetBoundsInScreen());
 
   // Test overlap with an existing docked area first.
@@ skipping 67 matching lines @@
   if (desired_alignment != DOCKED_ALIGNMENT_NONE &&
       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;
+  ShelfAlignment shelf_alignment =
+      shelf_ ? shelf_->GetAlignment() : SHELF_ALIGNMENT_BOTTOM;
   if ((alignment == DOCKED_ALIGNMENT_LEFT &&
-       shelf_alignment == wm::SHELF_ALIGNMENT_LEFT) ||
+       shelf_alignment == SHELF_ALIGNMENT_LEFT) ||
       (alignment == DOCKED_ALIGNMENT_RIGHT &&
-       shelf_alignment == wm::SHELF_ALIGNMENT_RIGHT)) {
+       shelf_alignment == 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 141 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.
-  wm::ShelfAlignment shelf_alignment = shelf_->GetAlignment();
+  ShelfAlignment shelf_alignment = shelf_->GetAlignment();
   if (alignment_ == DOCKED_ALIGNMENT_LEFT &&
-      shelf_alignment == wm::SHELF_ALIGNMENT_LEFT) {
+      shelf_alignment == SHELF_ALIGNMENT_LEFT) {
     alignment_ = DOCKED_ALIGNMENT_RIGHT;
   } else if (alignment_ == DOCKED_ALIGNMENT_RIGHT &&
-             shelf_alignment == wm::SHELF_ALIGNMENT_RIGHT) {
+             shelf_alignment == SHELF_ALIGNMENT_RIGHT) {
     alignment_ = DOCKED_ALIGNMENT_LEFT;
   }
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::SHELF_ALIGNMENT_CHANGED);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, WindowStateObserver implementation:
 
 void DockedWindowLayoutManager::OnPreWindowStateTypeChange(
@@ skipping 502 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