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

ash/shelf/shelf_widget.cc

 // Copyright 2012 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/shelf/shelf_widget.h"
 
 #include "ash/ash_switches.h"
 #include "ash/aura/wm_window_aura.h"
+#include "ash/common/shelf/shelf_constants.h"
+#include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.h"
-#include "ash/common/wm/shelf/wm_shelf_constants.h"
-#include "ash/common/wm/shelf/wm_shelf_util.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/focus_cycler.h"
 #include "ash/session/session_state_delegate.h"
-#include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_navigator.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_view.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/wm/status_area_layout_manager.h"
@@ skipping 150 matching lines @@
   if (is_hovered_ || force_hovered_ != is_hovered_ || previous)
     SetHovered(is_hovered_);
 }
 
 void DimmerView::OnPaintBackground(gfx::Canvas* canvas) {
   SkPaint paint;
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   gfx::ImageSkia shelf_background =
       *rb->GetImageNamed(IDR_ASH_SHELF_DIMMING).ToImageSkia();
 
-  if (!wm::IsHorizontalAlignment(shelf_->GetAlignment())) {
+  if (!IsHorizontalAlignment(shelf_->GetAlignment())) {
     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        shelf_background, shelf_->GetAlignment() == wm::SHELF_ALIGNMENT_LEFT
+        shelf_background, shelf_->GetAlignment() == SHELF_ALIGNMENT_LEFT
                               ? SkBitmapOperations::ROTATION_90_CW
                               : SkBitmapOperations::ROTATION_270_CW);
   }
   paint.setAlpha(alpha_);
   canvas->DrawImageInt(shelf_background, 0, 0, shelf_background.width(),
                        shelf_background.height(), 0, 0, width(), height(),
                        false, paint);
 }
 
 DimmerView::DimmerEventFilter::DimmerEventFilter(DimmerView* owner)
@@ skipping 49 matching lines @@
     shelf_->AddObserver(this);
   }
 
   ~ShelfWindowTargeter() override {
     // |shelf_| may have been destroyed by this time.
     if (shelf_)
       shelf_->RemoveObserver(this);
   }
 
  private:
-  gfx::Insets GetInsetsForAlignment(int distance,
-                                    wm::ShelfAlignment alignment) {
-    if (alignment == wm::SHELF_ALIGNMENT_LEFT)
+  gfx::Insets GetInsetsForAlignment(int distance, ShelfAlignment alignment) {
+    if (alignment == SHELF_ALIGNMENT_LEFT)
       return gfx::Insets(0, 0, 0, distance);
-    if (alignment == wm::SHELF_ALIGNMENT_RIGHT)
+    if (alignment == SHELF_ALIGNMENT_RIGHT)
       return gfx::Insets(0, distance, 0, 0);
     return gfx::Insets(distance, 0, 0, 0);
   }
 
   // ShelfLayoutManagerObserver:
   void WillDeleteShelfLayoutManager() override {
     shelf_->RemoveObserver(this);
     shelf_ = NULL;
   }
 
@@ skipping 173 matching lines @@
 void ShelfWidget::DelegateView::SetParentLayer(ui::Layer* layer) {
   layer->Add(&opaque_background_);
   layer->Add(&opaque_foreground_);
   ReorderLayers();
 }
 
 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   gfx::ImageSkia shelf_background =
       *rb->GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
-  const bool horizontal = wm::IsHorizontalAlignment(shelf_->GetAlignment());
+  const bool horizontal = IsHorizontalAlignment(shelf_->GetAlignment());
   if (!horizontal) {
     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        shelf_background, shelf_->GetAlignment() == wm::SHELF_ALIGNMENT_LEFT
+        shelf_background, shelf_->GetAlignment() == SHELF_ALIGNMENT_LEFT
                               ? SkBitmapOperations::ROTATION_90_CW
                               : SkBitmapOperations::ROTATION_270_CW);
   }
   const gfx::Rect dock_bounds(shelf_->shelf_layout_manager()->dock_bounds());
   SkPaint paint;
   paint.setAlpha(alpha_);
   canvas->DrawImageInt(
       shelf_background, 0, 0, shelf_background.width(),
       shelf_background.height(),
       (horizontal && dock_bounds.x() == 0 && dock_bounds.width() > 0)
@@ skipping 84 matching lines @@
 
 void ShelfWidget::DelegateView::UpdateBackground(int alpha) {
   alpha_ = alpha;
   SchedulePaint();
 }
 
 ShelfWidget::ShelfWidget(WmWindow* wm_shelf_container,
                          WmWindow* wm_status_container,
                          WorkspaceController* workspace_controller)
     : delegate_view_(new DelegateView(this)),
-      background_animator_(delegate_view_, 0, wm::kShelfBackgroundAlpha),
+      background_animator_(delegate_view_, 0, kShelfBackgroundAlpha),
       activating_as_fallback_(false) {
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = delegate_view_;
   wm_shelf_container->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           this, wm_shelf_container->GetShellWindowId(), &params);
   Init(params);
@@ skipping 34 matching lines @@
 
 ShelfWidget::~ShelfWidget() {
   // Must call Shutdown() before destruction.
   DCHECK(!status_area_widget_);
   Shell::GetInstance()->focus_cycler()->RemoveWidget(this);
   SetFocusCycler(nullptr);
   RemoveObserver(this);
 }
 
 void ShelfWidget::SetPaintsBackground(
-    wm::ShelfBackgroundType background_type,
+    ShelfBackgroundType background_type,
     BackgroundAnimatorChangeType change_type) {
   ui::Layer* opaque_background = delegate_view_->opaque_background();
   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(mukai): use ui::Layer on both opaque_background and normal background
   // retire background_animator_ at all. It would be simpler.
   // See also DockedBackgroundWidget::SetPaintsBackground.
   background_animator_.SetPaintsBackground(
-      background_type != wm::SHELF_BACKGROUND_DEFAULT, change_type);
+      background_type != SHELF_BACKGROUND_DEFAULT, change_type);
 }
 
-wm::ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
+ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
   if (delegate_view_->opaque_background()->GetTargetOpacity() == 1.0f)
-    return wm::SHELF_BACKGROUND_MAXIMIZED;
+    return SHELF_BACKGROUND_MAXIMIZED;
   if (background_animator_.paints_background())
-    return wm::SHELF_BACKGROUND_OVERLAP;
+    return SHELF_BACKGROUND_OVERLAP;
 
-  return wm::SHELF_BACKGROUND_DEFAULT;
+  return SHELF_BACKGROUND_DEFAULT;
 }
 
 void ShelfWidget::HideShelfBehindBlackBar(bool hide, int animation_time_ms) {
   if (IsShelfHiddenBehindBlackBar() == hide)
     return;
 
   ui::Layer* opaque_foreground = delegate_view_->opaque_foreground();
   float target_opacity = hide ? 1.0f : 0.0f;
   std::unique_ptr<ui::ScopedLayerAnimationSettings> opaque_foreground_animation;
   opaque_foreground_animation.reset(new ui::ScopedLayerAnimationSettings(
@@ skipping 30 matching lines @@
     case user::LOGGED_IN_GUEST:
     case user::LOGGED_IN_KIOSK_APP:
     case user::LOGGED_IN_NONE:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
-wm::ShelfAlignment ShelfWidget::GetAlignment() const {
+ShelfAlignment ShelfWidget::GetAlignment() const {
   // TODO(msw): This should not be called before |shelf_| is created.
-  return shelf_ ? shelf_->alignment() : wm::SHELF_ALIGNMENT_BOTTOM_LOCKED;
+  return shelf_ ? shelf_->alignment() : SHELF_ALIGNMENT_BOTTOM_LOCKED;
 }
 
 void ShelfWidget::OnShelfAlignmentChanged() {
   status_area_widget_->SetShelfAlignment(GetAlignment());
   delegate_view_->SchedulePaint();
 }
 
 void ShelfWidget::SetDimsShelf(bool dimming) {
   delegate_view_->SetDimmed(dimming);
   // Repaint all children, allowing updates to reflect dimmed state eg:
@@ skipping 102 matching lines @@
     shelf_layout_manager_->UpdateAutoHideForMouseEvent(event);
 }
 
 void ShelfWidget::OnGestureEvent(ui::GestureEvent* event) {
   Widget::OnGestureEvent(event);
   if (Shell::GetInstance()->in_mus() && shelf_layout_manager_)
     shelf_layout_manager_->UpdateAutoHideForGestureEvent(event);
 }
 
 }  // namespace ash