Cleanup enums for shelf

ash/wm/shelf_layout_manager.h

 // 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.
 
 #ifndef ASH_WM_SHELF_LAYOUT_MANAGER_H_
 #define ASH_WM_SHELF_LAYOUT_MANAGER_H_
 
 #include "ash/ash_export.h"
 #include "ash/launcher/launcher.h"
+#include "ash/shelf_types.h"
 #include "ash/shell_observer.h"
-#include "ash/wm/shelf_types.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/observer_list.h"
 #include "base/timer.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/corewm/activation_change_shim.h"
 
@@ skipping 17 matching lines @@
 // status widgets. The launcher is given the total available width and told the
 // width of the status area. This allows the launcher to draw the background and
 // layout to the status area.
 // To respond to bounds changes in the status area StatusAreaLayoutManager works
 // closely with ShelfLayoutManager.
 class ASH_EXPORT ShelfLayoutManager :
     public aura::LayoutManager,
     public ash::ShellObserver,
     public views::corewm::ActivationChangeShim {
  public:
-  enum VisibilityState {
-    // Completely visible.
-    VISIBLE,
-
-    // A couple of pixels are reserved at the bottom for the shelf.
-    AUTO_HIDE,
-
-    // Nothing is shown. Used for fullscreen windows.
-    HIDDEN,
-  };
-
-  enum AutoHideState {
-    AUTO_HIDE_SHOWN,
-    AUTO_HIDE_HIDDEN,
-  };
-
   class ASH_EXPORT Observer {
    public:
     // Called when the target ShelfLayoutManager will be deleted.
     virtual void WillDeleteShelf() {}
 
     // Called when the visibility change is scheduled.
-    virtual void WillChangeVisibilityState(VisibilityState new_state) {}
+    virtual void WillChangeVisibilityState(ShelfVisibilityState new_state) {}
 
     // Called when the auto hide state is changed.
-    virtual void OnAutoHideStateChanged(AutoHideState new_state) {}
+    virtual void OnAutoHideStateChanged(ShelfAutoHideState new_state) {}
   };
 
   // We reserve a small area at the bottom of the workspace area to ensure that
   // the bottom-of-window resize handle can be hit.
   static const int kWorkspaceAreaBottomInset;
 
   // Size of the shelf when auto-hidden.
   static const int kAutoHideSize;
 
   explicit ShelfLayoutManager(StatusAreaWidget* status);
@@ skipping 38 matching lines @@
   // Stops any animations and sets the bounds of the launcher and status
   // widgets.
   void LayoutShelf();
 
   // Updates the visibility state.
   void UpdateVisibilityState();
 
   // Invoked by the shelf/launcher when the auto-hide state may have changed.
   void UpdateAutoHideState();
 
-  VisibilityState visibility_state() const { return state_.visibility_state; }
-  AutoHideState auto_hide_state() const { return state_.auto_hide_state; }
+  ShelfVisibilityState visibility_state() const {
+    return state_.visibility_state;
+  }
+  ShelfAutoHideState auto_hide_state() const { return state_.auto_hide_state; }
 
   // Sets whether any windows overlap the shelf. If a window overlaps the shelf
   // the shelf renders slightly differently.
   void SetWindowOverlapsShelf(bool value);
   bool window_overlaps_shelf() const { return window_overlaps_shelf_; }
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Gesture dragging related functions:
@@ skipping 36 matching lines @@
   struct TargetBounds {
     TargetBounds();
 
     float opacity;
     gfx::Rect launcher_bounds_in_root;
     gfx::Rect status_bounds_in_root;
     gfx::Insets work_area_insets;
   };
 
   struct State {
-    State() : visibility_state(VISIBLE),
-              auto_hide_state(AUTO_HIDE_HIDDEN),
+    State() : visibility_state(SHELF_VISIBLE),
+              auto_hide_state(SHELF_AUTO_HIDE_HIDDEN),
               is_screen_locked(false) {}
 
     // Returns true if the two states are considered equal. As
-    // |auto_hide_state| only matters if |visibility_state| is |AUTO_HIDE|,
-    // Equals() ignores the |auto_hide_state| as appropriate.
+    // |auto_hide_state| only matters if |visibility_state| is
+    // |SHELF_AUTO_HIDE|, Equals() ignores the |auto_hide_state| as
+    // appropriate.
     bool Equals(const State& other) const {
       return other.visibility_state == visibility_state &&
-          (visibility_state != AUTO_HIDE ||
+          (visibility_state != SHELF_AUTO_HIDE ||
            other.auto_hide_state == auto_hide_state) &&
           other.is_screen_locked == is_screen_locked;
     }
 
-    VisibilityState visibility_state;
-    AutoHideState auto_hide_state;
+    ShelfVisibilityState visibility_state;
+    ShelfAutoHideState auto_hide_state;
     bool is_screen_locked;
   };
 
   // Sets the visibility of the shelf to |state|.
-  void SetState(VisibilityState visibility_state);
+  void SetState(ShelfVisibilityState visibility_state);
 
   // Stops any animations.
   void StopAnimating();
 
   // Returns the width (if aligned to the side) or height (if aligned to the
   // bottom).
   void GetShelfSize(int* width, int* height);
 
   // Insets |bounds| by |inset| on the edge the shelf is aligned to.
   void AdjustBoundsBasedOnAlignment(int inset, gfx::Rect* bounds) const;
 
   // Calculates the target bounds assuming visibility of |visible|.
   void CalculateTargetBounds(const State& state, TargetBounds* target_bounds);
 
   // Updates the target bounds if a gesture-drag is in progress. This is only
   // used by |CalculateTargetBounds()|.
   void UpdateTargetBoundsForGesture(TargetBounds* target_bounds) const;
 
   // Updates the background of the shelf.
   void UpdateShelfBackground(BackgroundAnimator::ChangeType type);
 
   // Returns whether the launcher should draw a background.
   bool GetLauncherPaintsBackground() const;
 
   // Updates the auto hide state immediately.
   void UpdateAutoHideStateNow();
 
   // Returns the AutoHideState. This value is determined from the launcher and
   // tray.
-  AutoHideState CalculateAutoHideState(VisibilityState visibility_state) const;
+  ShelfAutoHideState CalculateAutoHideState(
+      ShelfVisibilityState visibility_state) const;
 
   // Updates the hit test bounds override for launcher and status area.
   void UpdateHitTestBounds();
 
   // Returns true if |window| is a descendant of the shelf.
   bool IsShelfWindow(aura::Window* window);
 
   int GetWorkAreaSize(const State& state, int size) const;
 
   int axis_position(int x, int y) const {
@@ skipping 42 matching lines @@
     GESTURE_DRAG_IN_PROGRESS,
     GESTURE_DRAG_COMPLETE_IN_PROGRESS
   };
   GestureDragStatus gesture_drag_status_;
 
   // Tracks the amount of the drag. The value is only valid when
   // |gesture_drag_status_| is set to GESTURE_DRAG_IN_PROGRESS.
   float gesture_drag_amount_;
 
   // Manage the auto-hide state during the gesture.
-  AutoHideState gesture_drag_auto_hide_state_;
+  ShelfAutoHideState gesture_drag_auto_hide_state_;
 
   // Used to delay updating shelf background.
   UpdateShelfObserver* update_shelf_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutManager);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_SHELF_LAYOUT_MANAGER_H_