Rename Launcher to Shelf.

ash/shelf/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_SHELF_SHELF_LAYOUT_MANAGER_H_
 #define ASH_SHELF_SHELF_LAYOUT_MANAGER_H_
 
 #include <vector>
 
 #include "ash/ash_export.h"
-#include "ash/launcher/launcher.h"
 #include "ash/shelf/background_animator.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shell_observer.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/wm/dock/docked_window_layout_manager_observer.h"
 #include "ash/wm/lock_state_observer.h"
 #include "ash/wm/workspace/workspace_types.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
@@ skipping 21 matching lines @@
 FORWARD_DECLARE_TEST(WebNotificationTrayTest, PopupAndFullscreen);
 
 namespace internal {
 
 class PanelLayoutManagerTest;
 class ShelfBezelEventFilter;
 class ShelfLayoutManagerTest;
 class StatusAreaWidget;
 class WorkspaceController;
 
-// ShelfLayoutManager is the layout manager responsible for the launcher and
-// 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
+// ShelfLayoutManager is the layout manager responsible for the shelf and
+// status widgets. The shelf is given the total available width and told the
+// width of the status area. This allows the shelf 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 aura::client::ActivationChangeObserver,
     public DockedWindowLayoutManagerObserver,
     public keyboard::KeyboardControllerObserver,
     public LockStateObserver {
  public:
 
   // We reserve a small area on the edge of the workspace area to ensure that
   // the resize handle at the edge of the window can be hit.
   static const int kWorkspaceAreaVisibleInset;
 
   // When autohidden we extend the touch hit target onto the screen so that the
   // user can drag the shelf out.
   static const int kWorkspaceAreaAutoHideInset;
 
   // Size of the shelf when auto-hidden.
   static const int kAutoHideSize;
 
   // The size of the shelf when shown (currently only used in alternate
   // settings see ash::switches::UseAlternateShelfLayout).
   static const int kShelfSize;
 
   // Inset between the inner edge of the shelf (towards centre of screen), and
-  // the launcher items, notifications, status area etc.
+  // the shelf items, notifications, status area etc.
   static const int kShelfItemInset;
 
   // Returns the preferred size for the shelf (either kLauncherPreferredSize or
   // kShelfSize).
   static int GetPreferredShelfSize();
 
   explicit ShelfLayoutManager(ShelfWidget* shelf);
   virtual ~ShelfLayoutManager();
 
   // Sets the ShelfAutoHideBehavior. See enum description for details.
@@ skipping 12 matching lines @@
 
   void set_workspace_controller(WorkspaceController* controller) {
     workspace_controller_ = controller;
   }
 
   bool updating_bounds() const { return updating_bounds_; }
 
   // Clears internal data for shutdown process.
   void PrepareForShutdown();
 
-  // Returns whether the shelf and its contents (launcher, status) are visible
+  // Returns whether the shelf and its contents (shelf, status) are visible
   // on the screen.
   bool IsVisible() const;
 
   // Returns the ideal bounds of the shelf assuming it is visible.
   gfx::Rect GetIdealBounds();
 
   // Returns the docked area bounds.
   const gfx::Rect& dock_bounds() const { return dock_bounds_; }
 
-  // Stops any animations and sets the bounds of the launcher and status
+  // Stops any animations and sets the bounds of the shelf and status
   // widgets.
   void LayoutShelf();
 
   // Returns shelf visibility state based on current value of auto hide
   // behavior setting.
   ShelfVisibilityState CalculateShelfVisibility();
 
   // Updates the visibility state.
   void UpdateVisibilityState();
 
-  // Invoked by the shelf/launcher when the auto-hide state may have changed.
+  // Invoked by the shelf when the auto-hide state may have changed.
   void UpdateAutoHideState();
 
   ShelfVisibilityState visibility_state() const {
     return state_.visibility_state;
   }
   ShelfAutoHideState auto_hide_state() const { return state_.auto_hide_state; }
 
   ShelfWidget* shelf_widget() { return shelf_; }
 
   // Sets whether any windows overlap the shelf. If a window overlaps the shelf
@@ skipping 58 matching lines @@
   }
 
   template<typename T>
   T PrimaryAxisValue(T horizontal, T vertical) const {
     return IsHorizontalAlignment() ? horizontal : vertical;
   }
 
   // Is the shelf's alignment horizontal?
   bool IsHorizontalAlignment() const;
 
-  // Returns a ShelfLayoutManager on the display which has a launcher for
-  // given |window|. See RootWindowController::ForLauncher for more info.
-  static ShelfLayoutManager* ForLauncher(aura::Window* window);
+  // Returns a ShelfLayoutManager on the display which has a shelf for
+  // given |window|. See RootWindowController::ForShelf for more info.
+  static ShelfLayoutManager* ForShelf(aura::Window* window);
 
  private:
   class AutoHideEventFilter;
   class UpdateShelfObserver;
   friend class ash::ScreenAsh;
   friend class PanelLayoutManagerTest;
   friend class ShelfLayoutManagerTest;
   FRIEND_TEST_ALL_PREFIXES(ash::WebNotificationTrayTest, PopupAndFullscreen);
 
   struct TargetBounds {
     TargetBounds();
     ~TargetBounds();
 
     float opacity;
     float status_opacity;
     gfx::Rect shelf_bounds_in_root;
-    gfx::Rect launcher_bounds_in_shelf;
+    gfx::Rect shelf_bounds_in_shelf;
     gfx::Rect status_bounds_in_shelf;
     gfx::Insets work_area_insets;
   };
 
   struct State {
     State() : visibility_state(SHELF_VISIBLE),
               auto_hide_state(SHELF_AUTO_HIDE_HIDDEN),
               window_state(WORKSPACE_WINDOW_STATE_DEFAULT),
               is_screen_locked(false) {}
 
@@ skipping 11 matching lines @@
 
     ShelfVisibilityState visibility_state;
     ShelfAutoHideState auto_hide_state;
     WorkspaceWindowState window_state;
     bool is_screen_locked;
   };
 
   // Sets the visibility of the shelf to |state|.
   void SetState(ShelfVisibilityState visibility_state);
 
-  // Updates the bounds and opacity of the launcher and status widgets.
+  // Updates the bounds and opacity of the shelf and status widgets.
   // If |observer| is specified, it will be called back when the animations, if
   // any, are complete.
   void UpdateBoundsAndOpacity(const TargetBounds& target_bounds,
                               bool animate,
                               ui::ImplicitAnimationObserver* observer);
 
   // Stops any animations and progresses them to the end.
   void StopAnimating();
 
   // Returns the width (if aligned to the side) or height (if aligned to the
@@ skipping 22 matching lines @@
   // Stops the auto hide timer and clears
   // |mouse_over_shelf_when_auto_hide_timer_started_|.
   void StopAutoHideTimer();
 
   // Returns the bounds of an additional region which can trigger showing the
   // shelf. This region exists to make it easier to trigger showing the shelf
   // when the shelf is auto hidden and the shelf is on the boundary between
   // two displays.
   gfx::Rect GetAutoHideShowShelfRegionInScreen() const;
 
-  // Returns the AutoHideState. This value is determined from the launcher and
+  // Returns the AutoHideState. This value is determined from the shelf and
   // tray.
   ShelfAutoHideState CalculateAutoHideState(
       ShelfVisibilityState visibility_state) const;
 
-  // Updates the hit test bounds override for launcher and status area.
+  // Updates the hit test bounds override for shelf 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;
 
   // Return the bounds available in the parent, taking into account the bounds
   // of the keyboard if necessary.
   gfx::Rect GetAvailableBounds() const;
@@ skipping 34 matching lines @@
 
   // Do any windows overlap the shelf? This is maintained by WorkspaceManager.
   bool window_overlaps_shelf_;
 
   base::OneShotTimer<ShelfLayoutManager> auto_hide_timer_;
 
   // Whether the mouse was over the shelf when the auto hide timer started.
   // False when neither the auto hide timer nor the timer task are running.
   bool mouse_over_shelf_when_auto_hide_timer_started_;
 
-  // EventFilter used to detect when user moves the mouse over the launcher to
-  // trigger showing the launcher.
+  // EventFilter used to detect when user moves the mouse over the shelf to
+  // trigger showing the shelf.
   scoped_ptr<AutoHideEventFilter> auto_hide_event_filter_;
 
   // EventFilter used to detect when user issues a gesture on a bezel sensor.
   scoped_ptr<ShelfBezelEventFilter> bezel_event_filter_;
 
   ObserverList<ShelfLayoutManagerObserver> observers_;
 
   // The shelf reacts to gesture-drags, and can be set to auto-hide for certain
   // gestures. Some shelf behaviour (e.g. visibility state, background color
   // etc.) are affected by various stages of the drag. The enum keeps track of
@@ skipping 22 matching lines @@
   // The bounds of the dock.
   gfx::Rect dock_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutManager);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_SHELF_SHELF_LAYOUT_MANAGER_H_