Cleanup enums for shelf

ash/wm/shelf_layout_manager.cc

 // Copyright (c) 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/wm/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/ash_switches.h"
@@ skipping 139 matching lines @@
       root_window_(status_area_widget->GetNativeView()->GetRootWindow()),
       in_layout_(false),
       auto_hide_behavior_(SHELF_AUTO_HIDE_BEHAVIOR_NEVER),
       alignment_(SHELF_ALIGNMENT_BOTTOM),
       launcher_(NULL),
       status_area_widget_(status_area_widget),
       workspace_controller_(NULL),
       window_overlaps_shelf_(false),
       gesture_drag_status_(GESTURE_DRAG_NONE),
       gesture_drag_amount_(0.f),
-      gesture_drag_auto_hide_state_(AUTO_HIDE_SHOWN),
+      gesture_drag_auto_hide_state_(SHELF_AUTO_HIDE_SHOWN),
       update_shelf_observer_(NULL) {
   Shell::GetInstance()->AddShellObserver(this);
   aura::client::GetActivationClient(root_window_)->AddObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   FOR_EACH_OBSERVER(Observer, observers_, WillDeleteShelf());
   Shell::GetInstance()->RemoveShellObserver(this);
   aura::client::GetActivationClient(root_window_)->RemoveObserver(this);
 }
 
 void ShelfLayoutManager::SetAutoHideBehavior(ShelfAutoHideBehavior behavior) {
   if (auto_hide_behavior_ == behavior)
     return;
   auto_hide_behavior_ = behavior;
   UpdateVisibilityState();
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnAutoHideStateChanged(state_.auto_hide_state));
 }
 
 bool ShelfLayoutManager::IsVisible() const {
   return status_area_widget_->IsVisible() &&
-      (state_.visibility_state == VISIBLE ||
-       (state_.visibility_state == AUTO_HIDE &&
-        state_.auto_hide_state == AUTO_HIDE_SHOWN));
+      (state_.visibility_state == SHELF_VISIBLE ||
+       (state_.visibility_state == SHELF_AUTO_HIDE &&
+        state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN));
 }
 
 void ShelfLayoutManager::SetLauncher(Launcher* launcher) {
   if (launcher == launcher_)
     return;
 
   launcher_ = launcher;
   if (launcher_)
     launcher_->SetAlignment(alignment_);
   LayoutShelf();
@@ skipping 52 matching lines @@
           target_bounds.status_bounds_in_root));
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(),
       target_bounds.work_area_insets);
   UpdateHitTestBounds();
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
   ShellDelegate* delegate = Shell::GetInstance()->delegate();
   if (delegate && delegate->IsScreenLocked()) {
-    SetState(VISIBLE);
+    SetState(SHELF_VISIBLE);
   } else if (gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS) {
-    SetState(AUTO_HIDE);
+    SetState(SHELF_AUTO_HIDE);
   } else {
     WorkspaceWindowState window_state(workspace_controller_->GetWindowState());
     switch (window_state) {
       case WORKSPACE_WINDOW_STATE_FULL_SCREEN:
-        SetState(HIDDEN);
+        SetState(SHELF_HIDDEN);
         break;
 
       case WORKSPACE_WINDOW_STATE_MAXIMIZED:
           SetState(auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS ?
-                   AUTO_HIDE : VISIBLE);
+                   SHELF_AUTO_HIDE : SHELF_VISIBLE);
         break;
 
       case WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF:
       case WORKSPACE_WINDOW_STATE_DEFAULT:
         SetState(auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS ?
-                 AUTO_HIDE : VISIBLE);
+                 SHELF_AUTO_HIDE : SHELF_VISIBLE);
         SetWindowOverlapsShelf(window_state ==
                                WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF);
         break;
     }
   }
 }
 
 void ShelfLayoutManager::UpdateAutoHideState() {
-  AutoHideState auto_hide_state =
+  ShelfAutoHideState auto_hide_state =
       CalculateAutoHideState(state_.visibility_state);
   if (auto_hide_state != state_.auto_hide_state) {
-    if (auto_hide_state == AUTO_HIDE_HIDDEN) {
+    if (auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
       // Hides happen immediately.
       SetState(state_.visibility_state);
       FOR_EACH_OBSERVER(Observer, observers_,
                         OnAutoHideStateChanged(auto_hide_state));
     } else {
       auto_hide_timer_.Stop();
       auto_hide_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kAutoHideDelayMS),
           this, &ShelfLayoutManager::UpdateAutoHideStateNow);
@@ skipping 17 matching lines @@
 void ShelfLayoutManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, Gesture dragging:
 
 void ShelfLayoutManager::StartGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_status_ = GESTURE_DRAG_IN_PROGRESS;
   gesture_drag_amount_ = 0.f;
-  gesture_drag_auto_hide_state_ = visibility_state() == AUTO_HIDE ?
-      auto_hide_state() : AUTO_HIDE_SHOWN;
+  gesture_drag_auto_hide_state_ = visibility_state() == SHELF_AUTO_HIDE ?
+      auto_hide_state() : SHELF_AUTO_HIDE_SHOWN;
   UpdateShelfBackground(internal::BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 ShelfLayoutManager::DragState ShelfLayoutManager::UpdateGestureDrag(
     const ui::GestureEvent& gesture) {
   bool horizontal = alignment() == SHELF_ALIGNMENT_BOTTOM;
   gesture_drag_amount_ += horizontal ? gesture.details().scroll_y() :
                                        gesture.details().scroll_x();
   LayoutShelf();
 
   // Start reveling the status menu when:
   //   - dragging up on an already visible shelf
   //   - dragging up on a hidden shelf, but it is currently completely visible.
   if (horizontal && gesture.details().scroll_y() < 0) {
     int min_height = 0;
-    if (gesture_drag_auto_hide_state_ == AUTO_HIDE_HIDDEN && launcher_widget())
+    if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
+        launcher_widget())
       min_height = launcher_widget()->GetContentsView()->
           GetPreferredSize().height();
 
     if (min_height < launcher_widget()->GetWindowBoundsInScreen().height() &&
         gesture.root_location().x() >=
         status_area_widget_->GetWindowBoundsInScreen().x() &&
         IsDraggingTrayEnabled())
       return DRAG_TRAY;
   }
 
   return DRAG_SHELF;
 }
 
 void ShelfLayoutManager::CompleteGestureDrag(const ui::GestureEvent& gesture) {
   bool horizontal = alignment() == SHELF_ALIGNMENT_BOTTOM;
   bool should_change = false;
   if (gesture.type() == ui::ET_GESTURE_SCROLL_END) {
     // The visibility of the shelf changes only if the shelf was dragged X%
     // along the correct axis. If the shelf was already visible, then the
     // direction of the drag does not matter.
     const float kDragHideThreshold = 0.4f;
     gfx::Rect bounds = GetIdealBounds();
     float drag_ratio = fabs(gesture_drag_amount_) /
                        (horizontal ?  bounds.height() : bounds.width());
-    if (gesture_drag_auto_hide_state_ == AUTO_HIDE_SHOWN) {
+    if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
       should_change = drag_ratio > kDragHideThreshold;
     } else {
       bool correct_direction = false;
       switch (alignment()) {
         case SHELF_ALIGNMENT_BOTTOM:
         case SHELF_ALIGNMENT_RIGHT:
           correct_direction = gesture_drag_amount_ < 0;
           break;
         case SHELF_ALIGNMENT_LEFT:
           correct_direction = gesture_drag_amount_ > 0;
           break;
       }
       should_change = correct_direction && drag_ratio > kDragHideThreshold;
     }
   } else if (gesture.type() == ui::ET_SCROLL_FLING_START) {
-    if (gesture_drag_auto_hide_state_ == AUTO_HIDE_SHOWN) {
+    if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
       should_change = horizontal ? fabs(gesture.details().velocity_y()) > 0 :
                                    fabs(gesture.details().velocity_x()) > 0;
     } else {
       if (horizontal)
         should_change = gesture.details().velocity_y() < 0;
       else if (alignment() == SHELF_ALIGNMENT_LEFT)
         should_change = gesture.details().velocity_x() > 0;
       else
         should_change = gesture.details().velocity_x() < 0;
     }
   } else {
     NOTREACHED();
   }
 
   if (!should_change) {
     CancelGestureDrag();
     return;
   }
 
   gesture_drag_auto_hide_state_ =
-      gesture_drag_auto_hide_state_ == AUTO_HIDE_SHOWN ? AUTO_HIDE_HIDDEN :
-                                                         AUTO_HIDE_SHOWN;
+      gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN ?
+      SHELF_AUTO_HIDE_HIDDEN : SHELF_AUTO_HIDE_SHOWN;
   if (launcher_widget())
     launcher_widget()->Deactivate();
   status_area_widget_->Deactivate();
-  if (gesture_drag_auto_hide_state_ == AUTO_HIDE_HIDDEN &&
+  if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
       auto_hide_behavior_ != SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) {
     gesture_drag_status_ = GESTURE_DRAG_NONE;
     SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
-  } else if (gesture_drag_auto_hide_state_ == AUTO_HIDE_SHOWN &&
+  } else if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN &&
              auto_hide_behavior_ != SHELF_AUTO_HIDE_BEHAVIOR_NEVER) {
     gesture_drag_status_ = GESTURE_DRAG_NONE;
     SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   } else {
     gesture_drag_status_ = GESTURE_DRAG_COMPLETE_IN_PROGRESS;
     UpdateVisibilityState();
     gesture_drag_status_ = GESTURE_DRAG_NONE;
   }
 }
 
@@ skipping 46 matching lines @@
 void ShelfLayoutManager::OnWindowActivated(aura::Window* active,
                                            aura::Window* old_active) {
   UpdateAutoHideStateNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 ShelfLayoutManager::TargetBounds::TargetBounds() : opacity(0.0f) {}
 
-void ShelfLayoutManager::SetState(VisibilityState visibility_state) {
+void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
   ShellDelegate* delegate = Shell::GetInstance()->delegate();
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
   state.is_screen_locked = delegate && delegate->IsScreenLocked();
 
   // It's possible for SetState() when a window becomes maximized but the state
   // won't have changed value. Do the dimming check before the early exit.
   if (launcher_ && workspace_controller_) {
     launcher_->SetDimsShelf(
-        (state.visibility_state == VISIBLE) &&
+        (state.visibility_state == SHELF_VISIBLE) &&
           workspace_controller_->GetWindowState() ==
               WORKSPACE_WINDOW_STATE_MAXIMIZED);
   }
 
   if (state_.Equals(state))
     return;  // Nothing changed.
 
   FOR_EACH_OBSERVER(Observer, observers_,
                     WillChangeVisibilityState(visibility_state));
 
-  if (state.visibility_state == AUTO_HIDE) {
-    // When state is AUTO_HIDE we need to track when the mouse is over the
+  if (state.visibility_state == SHELF_AUTO_HIDE) {
+    // When state is SHELF_AUTO_HIDE we need to track when the mouse is over the
     // launcher to unhide the shelf. AutoHideEventFilter does that for us.
     if (!event_filter_.get())
       event_filter_.reset(new AutoHideEventFilter(this));
   } else {
     event_filter_.reset(NULL);
   }
 
   auto_hide_timer_.Stop();
 
   // Animating the background when transitioning from auto-hide & hidden to
   // visible is janky. Update the background immediately in this case.
   internal::BackgroundAnimator::ChangeType change_type =
-      (state_.visibility_state == AUTO_HIDE &&
-       state_.auto_hide_state == AUTO_HIDE_HIDDEN &&
-       state.visibility_state == VISIBLE) ?
+      (state_.visibility_state == SHELF_AUTO_HIDE &&
+       state_.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
+       state.visibility_state == SHELF_VISIBLE) ?
       internal::BackgroundAnimator::CHANGE_IMMEDIATE :
       internal::BackgroundAnimator::CHANGE_ANIMATE;
   StopAnimating();
 
   State old_state = state_;
   state_ = state;
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   if (launcher_widget()) {
     ui::ScopedLayerAnimationSettings launcher_animation_setter(
         GetLayer(launcher_widget())->GetAnimator());
     launcher_animation_setter.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kWorkspaceSwitchTimeMS));
     launcher_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
     GetLayer(launcher_widget())->SetBounds(
         target_bounds.launcher_bounds_in_root);
     GetLayer(launcher_widget())->SetOpacity(target_bounds.opacity);
   }
   ui::ScopedLayerAnimationSettings status_animation_setter(
       GetLayer(status_area_widget_)->GetAnimator());
   status_animation_setter.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kWorkspaceSwitchTimeMS));
   status_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
 
-  // Delay updating the background when going from AUTO_HIDE_SHOWN to
-  // AUTO_HIDE_HIDDEN until the shelf animates out. Otherwise during the
+  // Delay updating the background when going from SHELF_AUTO_HIDE_SHOWN to
+  // SHELF_AUTO_HIDE_HIDDEN until the shelf animates out. Otherwise during the
   // animation you see the background change.
   // Also delay the animation when the shelf was hidden, and has just been made
   // visible (e.g. using a gesture-drag).
   bool delay_shelf_update =
-      state.visibility_state == AUTO_HIDE &&
-      state.auto_hide_state == AUTO_HIDE_HIDDEN &&
-      old_state.visibility_state == AUTO_HIDE;
+      state.visibility_state == SHELF_AUTO_HIDE &&
+      state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
+      old_state.visibility_state == SHELF_AUTO_HIDE;
 
-  if (state.visibility_state == VISIBLE &&
-      old_state.visibility_state == AUTO_HIDE &&
-      old_state.auto_hide_state == AUTO_HIDE_HIDDEN)
+  if (state.visibility_state == SHELF_VISIBLE &&
+      old_state.visibility_state == SHELF_AUTO_HIDE &&
+      old_state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN)
     delay_shelf_update = true;
 
   if (delay_shelf_update) {
     if (update_shelf_observer_)
       update_shelf_observer_->Detach();
     // UpdateShelfBackground deletes itself when the animation is done.
     update_shelf_observer_ = new UpdateShelfObserver(this);
     status_animation_setter.AddObserver(update_shelf_observer_);
   }
   ui::Layer* layer = GetLayer(status_area_widget_);
@@ skipping 43 matching lines @@
 void ShelfLayoutManager::CalculateTargetBounds(
     const State& state,
     TargetBounds* target_bounds) {
   const gfx::Rect& available_bounds(root_window_->bounds());
   gfx::Rect status_size(status_area_widget_->GetWindowBoundsInScreen().size());
   gfx::Size launcher_size = launcher_ ?
       launcher_widget()->GetContentsView()->GetPreferredSize() : gfx::Size();
   int shelf_size = 0;
   int shelf_width = 0, shelf_height = 0;
   GetShelfSize(&shelf_width, &shelf_height);
-  if (state.visibility_state == VISIBLE ||
-      (state.visibility_state == AUTO_HIDE &&
-       state.auto_hide_state == AUTO_HIDE_SHOWN)) {
+  if (state.visibility_state == SHELF_VISIBLE ||
+      (state.visibility_state == SHELF_AUTO_HIDE &&
+       state.auto_hide_state == SHELF_AUTO_HIDE_SHOWN)) {
     shelf_size = std::max(shelf_width, shelf_height);
     launcher_size.set_width(std::max(shelf_width,launcher_size.width()));
     launcher_size.set_height(std::max(shelf_height,launcher_size.height()));
-  } else if (state.visibility_state == AUTO_HIDE &&
-             state.auto_hide_state == AUTO_HIDE_HIDDEN) {
+  } else if (state.visibility_state == SHELF_AUTO_HIDE &&
+             state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
     shelf_size = kAutoHideSize;
     // Keep the launcher to its full height when dragging is in progress.
     if (gesture_drag_status_ == GESTURE_DRAG_NONE) {
       if (SHELF_ALIGNMENT_BOTTOM == alignment_)
         launcher_size.set_height(kAutoHideSize);
       else
         launcher_size.set_width(kAutoHideSize);
     }
   }
   switch(alignment_) {
@@ skipping 36 matching lines @@
         target_bounds->launcher_bounds_in_root = gfx::Rect(
             available_bounds.right() - launcher_size.width(),
             available_bounds.y(),
             launcher_size.width(), available_bounds.height());
       target_bounds->work_area_insets.Set(
           0, 0, 0, GetWorkAreaSize(state, launcher_size.width()));
       break;
   }
   target_bounds->opacity =
       (gesture_drag_status_ != GESTURE_DRAG_NONE ||
-       state.visibility_state == VISIBLE ||
-       state.visibility_state == AUTO_HIDE) ? 1.0f : 0.0f;
+       state.visibility_state == SHELF_VISIBLE ||
+       state.visibility_state == SHELF_AUTO_HIDE) ? 1.0f : 0.0f;
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS)
     UpdateTargetBoundsForGesture(target_bounds);
 }
 
 void ShelfLayoutManager::UpdateTargetBoundsForGesture(
     TargetBounds* target_bounds) const {
   CHECK_EQ(GESTURE_DRAG_IN_PROGRESS, gesture_drag_status_);
   bool horizontal = alignment() == SHELF_ALIGNMENT_BOTTOM;
   int resistance_free_region = 0;
 
-  if (gesture_drag_auto_hide_state_ == AUTO_HIDE_HIDDEN &&
-      visibility_state() == AUTO_HIDE && auto_hide_state() != AUTO_HIDE_SHOWN) {
+  if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
+      visibility_state() == SHELF_AUTO_HIDE &&
+      auto_hide_state() != SHELF_AUTO_HIDE_SHOWN) {
     // If the shelf was hidden when the drag started (and the state hasn't
     // changed since then, e.g. because the tray-menu was shown because of the
     // drag), then allow the drag some resistance-free region at first to make
     // sure the shelf sticks with the finger until the shelf is visible.
     resistance_free_region += horizontal ?
         target_bounds->launcher_bounds_in_root.height() :
         target_bounds->launcher_bounds_in_root.width();
     resistance_free_region -= kAutoHideSize;
   }
 
@@ skipping 79 matching lines @@
   ShellDelegate* delegate = Shell::GetInstance()->delegate();
   bool delegate_allows_tray_bg =
       delegate->IsUserLoggedIn() && !delegate->IsScreenLocked();
   bool status_area_paints = !launcher_paints && delegate_allows_tray_bg;
   status_area_widget_->SetPaintsBackground(status_area_paints, type);
 }
 
 bool ShelfLayoutManager::GetLauncherPaintsBackground() const {
   return gesture_drag_status_ != GESTURE_DRAG_NONE ||
       (!state_.is_screen_locked && window_overlaps_shelf_) ||
-      (state_.visibility_state == AUTO_HIDE) ;
+      (state_.visibility_state == SHELF_AUTO_HIDE) ;
 }
 
 void ShelfLayoutManager::UpdateAutoHideStateNow() {
   SetState(state_.visibility_state);
 }
 
-ShelfLayoutManager::AutoHideState ShelfLayoutManager::CalculateAutoHideState(
-    VisibilityState visibility_state) const {
-  if (visibility_state != AUTO_HIDE || !launcher_widget())
-    return AUTO_HIDE_HIDDEN;
+ShelfAutoHideState ShelfLayoutManager::CalculateAutoHideState(
+    ShelfVisibilityState visibility_state) const {
+  if (visibility_state != SHELF_AUTO_HIDE || !launcher_widget())
+    return SHELF_AUTO_HIDE_HIDDEN;
 
   if (gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS)
     return gesture_drag_auto_hide_state_;
 
   Shell* shell = Shell::GetInstance();
   if (shell->GetAppListTargetVisibility())
-    return AUTO_HIDE_SHOWN;
+    return SHELF_AUTO_HIDE_SHOWN;
 
   if (status_area_widget_ && status_area_widget_->ShouldShowLauncher())
-    return AUTO_HIDE_SHOWN;
+    return SHELF_AUTO_HIDE_SHOWN;
 
   if (launcher_ && launcher_->IsShowingMenu())
-    return AUTO_HIDE_SHOWN;
+    return SHELF_AUTO_HIDE_SHOWN;
 
   if (launcher_ && launcher_->IsShowingOverflowBubble())
-    return AUTO_HIDE_SHOWN;
+    return SHELF_AUTO_HIDE_SHOWN;
 
   if (launcher_widget()->IsActive() || status_area_widget_->IsActive())
-    return AUTO_HIDE_SHOWN;
+    return SHELF_AUTO_HIDE_SHOWN;
 
   // Don't show if the user is dragging the mouse.
   if (event_filter_.get() && event_filter_->in_mouse_drag())
-    return AUTO_HIDE_HIDDEN;
+    return SHELF_AUTO_HIDE_HIDDEN;
 
   gfx::Rect shelf_region = launcher_widget()->GetWindowBoundsInScreen();
   if (status_area_widget_ &&
       status_area_widget_->IsMessageBubbleShown() &&
       IsVisible()) {
     // Increase the the hit test area to prevent the shelf from disappearing
     // when the mouse is over the bubble gap.
     shelf_region.Inset(alignment_ == SHELF_ALIGNMENT_RIGHT ?
                            -kNotificationBubbleGapHeight : 0,
                        alignment_ == SHELF_ALIGNMENT_BOTTOM ?
                            -kNotificationBubbleGapHeight : 0,
                        alignment_ == SHELF_ALIGNMENT_LEFT ?
                            -kNotificationBubbleGapHeight : 0,
                        0);
   }
   return shelf_region.Contains(Shell::GetScreen()->GetCursorScreenPoint()) ?
-      AUTO_HIDE_SHOWN : AUTO_HIDE_HIDDEN;
+      SHELF_AUTO_HIDE_SHOWN : SHELF_AUTO_HIDE_HIDDEN;
 }
 
 void ShelfLayoutManager::UpdateHitTestBounds() {
   gfx::Insets insets;
   // Only modify the hit test when the shelf is visible, so we don't mess with
   // hover hit testing in the auto-hide state.
-  if (state_.visibility_state == VISIBLE) {
+  if (state_.visibility_state == SHELF_VISIBLE) {
     // Let clicks at the very top of the launcher through so windows can be
     // resized with the bottom-right corner and bottom edge.
     switch (alignment_) {
       case SHELF_ALIGNMENT_BOTTOM:
         insets.Set(kWorkspaceAreaBottomInset, 0, 0, 0);
         break;
       case SHELF_ALIGNMENT_LEFT:
         insets.Set(0, 0, 0, kWorkspaceAreaBottomInset);
         break;
       case SHELF_ALIGNMENT_RIGHT:
@@ skipping 11 matching lines @@
 
 bool ShelfLayoutManager::IsShelfWindow(aura::Window* window) {
   if (!window)
     return false;
   return (launcher_widget() &&
           launcher_widget()->GetNativeWindow()->Contains(window)) ||
       (status_area_widget_->GetNativeWindow()->Contains(window));
 }
 
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
-  if (state.visibility_state == VISIBLE)
+  if (state.visibility_state == SHELF_VISIBLE)
     return size;
-  if (state.visibility_state == AUTO_HIDE)
+  if (state.visibility_state == SHELF_AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
 }  // namespace internal
 }  // namespace ash