(Merge to M-51) Revise the shelf alignment locking mechanism.

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/focus_cycler.h"
 #include "ash/root_window_controller.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/shell_window_ids.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/wm/status_area_layout_manager.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/workspace_controller.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/accessible_pane_view.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/easy_resize_window_targeter.h"
 #include "ui/wm/public/activation_client.h"
 
+namespace ash {
+
 namespace {
 // Size of black border at bottom (or side) of shelf.
 const int kNumBlackPixels = 3;
 // Alpha to paint dimming image with.
 const int kDimAlpha = 128;
 
 // The time to dim and un-dim.
 const int kTimeToDimMs = 3000;  // Slow in dimming.
 const int kTimeToUnDimMs = 200;  // Fast in activating.
 
 // Class used to slightly dim shelf items when maximized and visible.
 class DimmerView : public views::View,
                    public views::WidgetDelegate,
-                   ash::BackgroundAnimatorDelegate {
+                   BackgroundAnimatorDelegate {
  public:
   // If |disable_dimming_animations_for_test| is set, all alpha animations will
   // be performed instantly.
-  DimmerView(ash::ShelfWidget* shelf_widget,
+  DimmerView(ShelfWidget* shelf_widget,
              bool disable_dimming_animations_for_test);
   ~DimmerView() override;
 
   // Called by |DimmerEventFilter| when the mouse |hovered| state changes.
   void SetHovered(bool hovered);
 
   // Force the dimmer to be undimmed.
   void ForceUndimming(bool force);
 
   // views::WidgetDelegate overrides:
   views::Widget* GetWidget() override { return View::GetWidget(); }
   const views::Widget* GetWidget() const override { return View::GetWidget(); }
 
-  // ash::BackgroundAnimatorDelegate overrides:
+  // BackgroundAnimatorDelegate overrides:
   void UpdateBackground(int alpha) override {
     alpha_ = alpha;
     SchedulePaint();
   }
 
   // views::View overrides:
   void OnPaintBackground(gfx::Canvas* canvas) override;
 
   // A function to test the current alpha used.
   int get_dimming_alpha_for_test() { return alpha_; }
@@ skipping 15 matching lines @@
 
     // TRUE if the mouse is inside the shelf.
     bool mouse_inside_;
 
     // TRUE if a touch event is inside the shelf.
     bool touch_inside_;
 
     DISALLOW_COPY_AND_ASSIGN(DimmerEventFilter);
   };
 
-  // The owning shelf.
-  ash::ShelfWidget* shelf_;
+  // The owning shelf widget.
+  ShelfWidget* shelf_;
 
   // The alpha to use for covering the shelf.
   int alpha_;
 
   // True if the event filter claims that we should not be dimmed.
   bool is_hovered_;
 
   // True if someone forces us not to be dimmed (e.g. a menu is open).
   bool force_hovered_;
 
   // True if animations should be suppressed for a test.
   bool disable_dimming_animations_for_test_;
 
   // The animator for the background transitions.
-  ash::BackgroundAnimator background_animator_;
+  BackgroundAnimator background_animator_;
 
   // Notification of entering / exiting of the shelf area by mouse.
   std::unique_ptr<DimmerEventFilter> event_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(DimmerView);
 };
 
-DimmerView::DimmerView(ash::ShelfWidget* shelf_widget,
+DimmerView::DimmerView(ShelfWidget* shelf_widget,
                        bool disable_dimming_animations_for_test)
     : shelf_(shelf_widget),
       alpha_(kDimAlpha),
       is_hovered_(false),
       force_hovered_(false),
       disable_dimming_animations_for_test_(disable_dimming_animations_for_test),
       background_animator_(this, 0, kDimAlpha) {
   event_filter_.reset(new DimmerEventFilter(this));
   // Make sure it is undimmed at the beginning and then fire off the dimming
   // animation.
-  background_animator_.SetPaintsBackground(false,
-                                           ash::BACKGROUND_CHANGE_IMMEDIATE);
+  background_animator_.SetPaintsBackground(false, BACKGROUND_CHANGE_IMMEDIATE);
   SetHovered(false);
 }
 
 DimmerView::~DimmerView() {
 }
 
 void DimmerView::SetHovered(bool hovered) {
   // Remember the hovered state so that we can correct the state once a
   // possible force state has disappeared.
   is_hovered_ = hovered;
   // Undimm also if we were forced to by e.g. an open menu.
   hovered |= force_hovered_;
   background_animator_.SetDuration(hovered ? kTimeToUnDimMs : kTimeToDimMs);
   background_animator_.SetPaintsBackground(!hovered,
-      disable_dimming_animations_for_test_ ?
-          ash::BACKGROUND_CHANGE_IMMEDIATE : ash::BACKGROUND_CHANGE_ANIMATE);
+                                           disable_dimming_animations_for_test_
+                                               ? BACKGROUND_CHANGE_IMMEDIATE
+                                               : BACKGROUND_CHANGE_ANIMATE);
 }
 
 void DimmerView::ForceUndimming(bool force) {
   bool previous = force_hovered_;
   force_hovered_ = force;
   // If the forced change does change the result we apply the change.
   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 (shelf_->GetAlignment() != ash::SHELF_ALIGNMENT_BOTTOM) {
+  if (!IsHorizontalAlignment(shelf_->GetAlignment())) {
     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        shelf_background,
-        shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
-            SkBitmapOperations::ROTATION_90_CW,
-            SkBitmapOperations::ROTATION_90_CW,
-            SkBitmapOperations::ROTATION_270_CW));
+        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);
+  canvas->DrawImageInt(shelf_background, 0, 0, shelf_background.width(),
+                       shelf_background.height(), 0, 0, width(), height(),
+                       false, paint);
 }
 
 DimmerView::DimmerEventFilter::DimmerEventFilter(DimmerView* owner)
     : owner_(owner),
       mouse_inside_(false),
       touch_inside_(false) {
-  ash::Shell::GetInstance()->AddPreTargetHandler(this);
+  Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 DimmerView::DimmerEventFilter::~DimmerEventFilter() {
-  ash::Shell::GetInstance()->RemovePreTargetHandler(this);
+  Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void DimmerView::DimmerEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_MOVED &&
       event->type() != ui::ET_MOUSE_DRAGGED)
     return;
 
   gfx::Point screen_point(event->location());
   ::wm::ConvertPointToScreen(static_cast<aura::Window*>(event->target()),
                              &screen_point);
@@ skipping 11 matching lines @@
     ::wm::ConvertPointToScreen(static_cast<aura::Window*>(event->target()),
                                &screen_point);
     touch_inside = owner_->GetBoundsInScreen().Contains(screen_point);
   }
 
   if (mouse_inside_ || touch_inside_ != mouse_inside_ || touch_inside)
     owner_->SetHovered(mouse_inside_ || touch_inside);
   touch_inside_ = touch_inside;
 }
 
-using ash::ShelfLayoutManager;
-
 // ShelfWindowTargeter makes it easier to resize windows with the mouse when the
 // window-edge slightly overlaps with the shelf edge. The targeter also makes it
 // easier to drag the shelf out with touch while it is hidden.
-class ShelfWindowTargeter : public wm::EasyResizeWindowTargeter,
-                            public ash::ShelfLayoutManagerObserver {
+class ShelfWindowTargeter : public ::wm::EasyResizeWindowTargeter,
+                            public ShelfLayoutManagerObserver {
  public:
-  ShelfWindowTargeter(aura::Window* container,
-                      ShelfLayoutManager* shelf)
-      : wm::EasyResizeWindowTargeter(container, gfx::Insets(), gfx::Insets()),
+  ShelfWindowTargeter(aura::Window* container, ShelfLayoutManager* shelf)
+      : ::wm::EasyResizeWindowTargeter(container, gfx::Insets(), gfx::Insets()),
         shelf_(shelf) {
     WillChangeVisibilityState(shelf_->visibility_state());
     shelf_->AddObserver(this);
   }
 
   ~ShelfWindowTargeter() override {
     // |shelf_| may have been destroyed by this time.
     if (shelf_)
       shelf_->RemoveObserver(this);
   }
 
  private:
-  gfx::Insets GetInsetsForAlignment(int distance,
-                                    ash::ShelfAlignment alignment) {
-    switch (alignment) {
-      case ash::SHELF_ALIGNMENT_BOTTOM:
-        return gfx::Insets(distance, 0, 0, 0);
-      case ash::SHELF_ALIGNMENT_LEFT:
-        return gfx::Insets(0, 0, 0, distance);
-      case ash::SHELF_ALIGNMENT_RIGHT:
-        return gfx::Insets(0, distance, 0, 0);
-    }
-    NOTREACHED();
-    return gfx::Insets();
+  gfx::Insets GetInsetsForAlignment(int distance, ShelfAlignment alignment) {
+    if (alignment == SHELF_ALIGNMENT_LEFT)
+      return gfx::Insets(0, 0, 0, distance);
+    if (alignment == SHELF_ALIGNMENT_RIGHT)
+      return gfx::Insets(0, distance, 0, 0);
+    return gfx::Insets(distance, 0, 0, 0);
   }
 
-  // ash::ShelfLayoutManagerObserver:
+  // ShelfLayoutManagerObserver:
   void WillDeleteShelf() override {
     shelf_->RemoveObserver(this);
     shelf_ = NULL;
   }
 
-  void WillChangeVisibilityState(ash::ShelfVisibilityState new_state) override {
+  void WillChangeVisibilityState(ShelfVisibilityState new_state) override {
     gfx::Insets mouse_insets;
     gfx::Insets touch_insets;
-    if (new_state == ash::SHELF_VISIBLE) {
+    if (new_state == SHELF_VISIBLE) {
       // Let clicks at the very top of the shelf through so windows can be
       // resized with the bottom-right corner and bottom edge.
       mouse_insets = GetInsetsForAlignment(
           ShelfLayoutManager::kWorkspaceAreaVisibleInset,
           shelf_->GetAlignment());
-    } else if (new_state == ash::SHELF_AUTO_HIDE) {
+    } else if (new_state == SHELF_AUTO_HIDE) {
       // Extend the touch hit target out a bit to allow users to drag shelf out
       // while hidden.
       touch_insets = GetInsetsForAlignment(
           -ShelfLayoutManager::kWorkspaceAreaAutoHideInset,
           shelf_->GetAlignment());
     }
 
     set_mouse_extend(mouse_insets);
     set_touch_extend(touch_insets);
   }
 
   ShelfLayoutManager* shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfWindowTargeter);
 };
 
 }  // namespace
 
-namespace ash {
-
 // The contents view of the Shelf. This view contains ShelfView and
 // sizes it to the width of the shelf minus the size of the status area.
 class ShelfWidget::DelegateView : public views::WidgetDelegate,
                                   public views::AccessiblePaneView,
                                   public BackgroundAnimatorDelegate,
                                   public aura::WindowObserver {
  public:
   explicit DelegateView(ShelfWidget* shelf);
   ~DelegateView() override;
 
@@ skipping 135 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);
-  if (SHELF_ALIGNMENT_BOTTOM != shelf_->GetAlignment())
+  const bool horizontal = IsHorizontalAlignment(shelf_->GetAlignment());
+  if (!horizontal) {
     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        shelf_background,
-        shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
-            SkBitmapOperations::ROTATION_90_CW,
-            SkBitmapOperations::ROTATION_90_CW,
-            SkBitmapOperations::ROTATION_270_CW));
+        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(),
-                       (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
-                        dock_bounds.x() == 0 && dock_bounds.width() > 0)
-                           ? dock_bounds.width()
-                           : 0,
-                       0,
-                       SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment()
-                           ? width() - dock_bounds.width()
-                           : width(),
-                       height(),
-                       false,
-                       paint);
-  if (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
-      dock_bounds.width() > 0) {
+  canvas->DrawImageInt(
+      shelf_background, 0, 0, shelf_background.width(),
+      shelf_background.height(),
+      (horizontal && dock_bounds.x() == 0 && dock_bounds.width() > 0)
+          ? dock_bounds.width()
+          : 0,
+      0, horizontal ? width() - dock_bounds.width() : width(), height(), false,
+      paint);
+  if (horizontal && dock_bounds.width() > 0) {
     // The part of the shelf background that is in the corner below the docked
     // windows close to the work area is an arched gradient that blends
     // vertically oriented docked background and horizontal shelf.
     gfx::ImageSkia shelf_corner = *rb->GetImageSkiaNamed(IDR_ASH_SHELF_CORNER);
     if (dock_bounds.x() == 0) {
       shelf_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
           shelf_corner, SkBitmapOperations::ROTATION_90_CW);
     }
     canvas->DrawImageInt(
-        shelf_corner,
-        0,
-        0,
-        shelf_corner.width(),
-        shelf_corner.height(),
+        shelf_corner, 0, 0, shelf_corner.width(), shelf_corner.height(),
         dock_bounds.x() > 0 ? dock_bounds.x() : dock_bounds.width() - height(),
-        0,
-        height(),
-        height(),
-        false,
-        paint);
+        0, height(), height(), false, paint);
     // The part of the shelf background that is just below the docked windows
     // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
     // This avoids showing the border 3D shadow between the shelf and the dock.
-    canvas->DrawImageInt(shelf_background,
-                         0,
-                         shelf_background.height() - 1,
-                         shelf_background.width(),
-                         1,
+    canvas->DrawImageInt(shelf_background, 0, shelf_background.height() - 1,
+                         shelf_background.width(), 1,
                          dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0,
-                         0,
-                         dock_bounds.width() - height(),
-                         height(),
-                         false,
+                         0, dock_bounds.width() - height(), height(), false,
                          paint);
   }
   gfx::Rect black_rect =
       shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
           gfx::Rect(0, height() - kNumBlackPixels, width(), kNumBlackPixels),
           gfx::Rect(0, 0, kNumBlackPixels, height()),
           gfx::Rect(width() - kNumBlackPixels, 0, kNumBlackPixels, height()));
   canvas->FillRect(black_rect, SK_ColorBLACK);
 }
 
@@ skipping 180 matching lines @@
     case user::LOGGED_IN_NONE:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 ShelfAlignment ShelfWidget::GetAlignment() const {
   // TODO(msw): This should not be called before |shelf_| is created.
-  return shelf_ ? shelf_->GetAlignment() : SHELF_ALIGNMENT_BOTTOM;
+  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 84 matching lines @@
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::WillDeleteShelf() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
 }
 
 }  // namespace ash