Rename Launcher to Shelf.

ash/shelf/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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
-#include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/session_state_delegate.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_bezel_event_filter.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_animations.h"
@@ skipping 17 matching lines @@
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
-// Delay before showing the launcher. This is after the mouse stops moving.
+// Delay before showing the shelf. This is after the mouse stops moving.
 const int kAutoHideDelayMS = 200;
 
 // To avoid hiding the shelf when the mouse transitions from a message bubble
 // into the shelf, the hit test area is enlarged by this amount of pixels to
 // keep the shelf from hiding.
 const int kNotificationBubbleGapHeight = 6;
 
 // The maximum size of the region on the display opposing the shelf managed by
 // this ShelfLayoutManager which can trigger showing the shelf.
 // For instance:
@@ skipping 212 matching lines @@
       gfx::Rect(bounds.x(), bounds.y(), width, bounds.height()),
       gfx::Rect(bounds.right() - width, bounds.y(), width, bounds.height()),
       gfx::Rect(bounds.x(), bounds.y(), bounds.width(), height));
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, false, NULL);
 
-  if (shelf_->launcher()) {
+  if (shelf_->shelf()) {
     // This is not part of UpdateBoundsAndOpacity() because
     // SetShelfViewBounds() sets the bounds immediately and does not animate.
     // The height of the ShelfView for a horizontal shelf and the width of
     // the ShelfView for a vertical shelf are set when |shelf_|'s bounds
     // are changed via UpdateBoundsAndOpacity(). This sets the origin and the
     // dimension in the other direction.
-    shelf_->launcher()->SetShelfViewBounds(
-        target_bounds.launcher_bounds_in_shelf);
+    shelf_->shelf()->SetShelfViewBounds(
+        target_bounds.shelf_bounds_in_shelf);
   }
 }
 
 ShelfVisibilityState ShelfLayoutManager::CalculateShelfVisibility() {
   switch(auto_hide_behavior_) {
     case SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS:
       return SHELF_AUTO_HIDE;
     case SHELF_AUTO_HIDE_BEHAVIOR_NEVER:
       return SHELF_VISIBLE;
     case SHELF_AUTO_HIDE_ALWAYS_HIDDEN:
@@ skipping 229 matching lines @@
                                            aura::Window* lost_active) {
   UpdateAutoHideStateNow();
 }
 
 bool ShelfLayoutManager::IsHorizontalAlignment() const {
   return GetAlignment() == SHELF_ALIGNMENT_BOTTOM ||
          GetAlignment() == SHELF_ALIGNMENT_TOP;
 }
 
 // static
-ShelfLayoutManager* ShelfLayoutManager::ForLauncher(aura::Window* window) {
-  ShelfWidget* shelf = RootWindowController::ForLauncher(window)->shelf();
+ShelfLayoutManager* ShelfLayoutManager::ForShelf(aura::Window* window) {
+  ShelfWidget* shelf = RootWindowController::ForShelf(window)->shelf();
   return shelf ? shelf->shelf_layout_manager() : NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 ShelfLayoutManager::TargetBounds::TargetBounds() : opacity(0.0f) {}
 ShelfLayoutManager::TargetBounds::~TargetBounds() {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
@@ skipping 15 matching lines @@
        gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS);
 
   if (!force_update && state_.Equals(state))
     return;  // Nothing changed.
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state));
 
   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.
+    // shelf to unhide it. AutoHideEventFilter does that for us.
     if (!auto_hide_event_filter_)
       auto_hide_event_filter_.reset(new AutoHideEventFilter(this));
   } else {
     auto_hide_event_filter_.reset(NULL);
   }
 
   StopAutoHideTimer();
 
   State old_state = state_;
   state_ = state;
@@ skipping 48 matching lines @@
                       OnAutoHideStateChanged(state_.auto_hide_state));
   }
 }
 
 void ShelfLayoutManager::UpdateBoundsAndOpacity(
     const TargetBounds& target_bounds,
     bool animate,
     ui::ImplicitAnimationObserver* observer) {
   base::AutoReset<bool> auto_reset_updating_bounds(&updating_bounds_, true);
 
-  ui::ScopedLayerAnimationSettings launcher_animation_setter(
+  ui::ScopedLayerAnimationSettings shelf_animation_setter(
       GetLayer(shelf_)->GetAnimator());
   ui::ScopedLayerAnimationSettings status_animation_setter(
       GetLayer(shelf_->status_area_widget())->GetAnimator());
   if (animate) {
-    launcher_animation_setter.SetTransitionDuration(
+    shelf_animation_setter.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS));
-    launcher_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
-    launcher_animation_setter.SetPreemptionStrategy(
+    shelf_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
+    shelf_animation_setter.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     status_animation_setter.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS));
     status_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
     status_animation_setter.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   } else {
     StopAnimating();
-    launcher_animation_setter.SetTransitionDuration(base::TimeDelta());
+    shelf_animation_setter.SetTransitionDuration(base::TimeDelta());
     status_animation_setter.SetTransitionDuration(base::TimeDelta());
   }
   if (observer)
     status_animation_setter.AddObserver(observer);
 
   GetLayer(shelf_)->SetOpacity(target_bounds.opacity);
   shelf_->SetBounds(ScreenAsh::ConvertRectToScreen(
        shelf_->GetNativeView()->parent(),
        target_bounds.shelf_bounds_in_root));
 
@@ skipping 134 matching lines @@
       (state.visibility_state == SHELF_AUTO_HIDE &&
        state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
        gesture_drag_status_ != GESTURE_DRAG_IN_PROGRESS) ?
       0.0f : target_bounds->opacity;
 
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS)
     UpdateTargetBoundsForGesture(target_bounds);
 
   // This needs to happen after calling UpdateTargetBoundsForGesture(), because
   // that can change the size of the shelf.
-  target_bounds->launcher_bounds_in_shelf = SelectValueForShelfAlignment(
+  target_bounds->shelf_bounds_in_shelf = SelectValueForShelfAlignment(
       gfx::Rect(0, 0,
                 shelf_width - status_size.width(),
                 target_bounds->shelf_bounds_in_root.height()),
       gfx::Rect(0, 0, target_bounds->shelf_bounds_in_root.width(),
                 shelf_height - status_size.height()),
       gfx::Rect(0, 0, target_bounds->shelf_bounds_in_root.width(),
                 shelf_height - status_size.height()),
       gfx::Rect(0, 0,
                 shelf_width - status_size.width(),
                 target_bounds->shelf_bounds_in_root.height()));
@@ skipping 28 matching lines @@
     diff = std::min(diff, sqrtf(diff));
     if (gesture_drag_amount_ < 0)
       translate = -resistance_free_region - diff;
     else
       translate = resistance_free_region + diff;
   } else {
     translate = gesture_drag_amount_;
   }
 
   if (horizontal) {
-    // Move and size the launcher with the gesture.
+    // Move and size the shelf with the gesture.
     int shelf_height = target_bounds->shelf_bounds_in_root.height() - translate;
     shelf_height = std::max(shelf_height, kAutoHideSize);
     target_bounds->shelf_bounds_in_root.set_height(shelf_height);
     if (GetAlignment() == SHELF_ALIGNMENT_BOTTOM) {
       target_bounds->shelf_bounds_in_root.set_y(
           available_bounds.bottom() - shelf_height);
     }
 
     if (ash::switches::UseAlternateShelfLayout()) {
       target_bounds->status_bounds_in_shelf.set_y(0);
     } else {
       // The statusbar should be in the center of the shelf.
       gfx::Rect status_y = target_bounds->shelf_bounds_in_root;
       status_y.set_y(0);
       status_y.ClampToCenteredSize(
           target_bounds->status_bounds_in_shelf.size());
       target_bounds->status_bounds_in_shelf.set_y(status_y.y());
     }
   } else {
-    // Move and size the launcher with the gesture.
+    // Move and size the shelf with the gesture.
     int shelf_width = target_bounds->shelf_bounds_in_root.width();
     bool right_aligned = GetAlignment() == SHELF_ALIGNMENT_RIGHT;
     if (right_aligned)
       shelf_width -= translate;
     else
       shelf_width += translate;
     shelf_width = std::max(shelf_width, kAutoHideSize);
     target_bounds->shelf_bounds_in_root.set_width(shelf_width);
     if (right_aligned) {
       target_bounds->shelf_bounds_in_root.set_x(
@@ skipping 76 matching lines @@
 ShelfAutoHideState ShelfLayoutManager::CalculateAutoHideState(
     ShelfVisibilityState visibility_state) const {
   if (visibility_state != SHELF_AUTO_HIDE || !shelf_)
     return SHELF_AUTO_HIDE_HIDDEN;
 
   Shell* shell = Shell::GetInstance();
   if (shell->GetAppListTargetVisibility())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->status_area_widget() &&
-      shelf_->status_area_widget()->ShouldShowLauncher())
+      shelf_->status_area_widget()->ShouldShowShelf())
     return SHELF_AUTO_HIDE_SHOWN;
 
-  if (shelf_->launcher() && shelf_->launcher()->IsShowingMenu())
+  if (shelf_->shelf() && shelf_->shelf()->IsShowingMenu())
     return SHELF_AUTO_HIDE_SHOWN;
 
-  if (shelf_->launcher() && shelf_->launcher()->IsShowingOverflowBubble())
+  if (shelf_->shelf() && shelf_->shelf()->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->IsActive() || shelf_->status_area_widget()->IsActive())
     return SHELF_AUTO_HIDE_SHOWN;
 
   const std::vector<aura::Window*> windows =
       ash::MruWindowTracker::BuildWindowList(false);
 
   // Process the window list and check if there are any visible windows.
   bool visible_window = false;
@@ skipping 63 matching lines @@
     return SHELF_AUTO_HIDE_SHOWN;
   }
 
   return SHELF_AUTO_HIDE_HIDDEN;
 }
 
 void ShelfLayoutManager::UpdateHitTestBounds() {
   gfx::Insets mouse_insets;
   gfx::Insets touch_insets;
   if (state_.visibility_state == SHELF_VISIBLE) {
-    // Let clicks at the very top of the launcher through so windows can be
+    // 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(kWorkspaceAreaVisibleInset);
   } else if (state_.visibility_state == SHELF_AUTO_HIDE) {
     // Extend the touch hit target out a bit to allow users to drag shelf out
     // while hidden.
     touch_insets = GetInsetsForAlignment(-kWorkspaceAreaAutoHideInset);
   }
 
   if (shelf_ && shelf_->GetNativeWindow())
     shelf_->GetNativeWindow()->SetHitTestBoundsOverrideOuter(mouse_insets,
@@ skipping 65 matching lines @@
       return gfx::Insets(0, distance, 0, 0);
     case SHELF_ALIGNMENT_TOP:
       return gfx::Insets(0, 0, distance, 0);
   }
   NOTREACHED();
   return gfx::Insets();
 }
 
 }  // namespace internal
 }  // namespace ash