ash: Rename LauncherModelObserver to ShelfModelObserver.

ash/shelf/shelf_view.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_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 410 matching lines @@
 void ShelfView::Init() {
   model_->AddObserver(this);
 
   const LauncherItems& items(model_->items());
   for (LauncherItems::const_iterator i = items.begin(); i != items.end(); ++i) {
     views::View* child = CreateViewForItem(*i);
     child->SetPaintToLayer(true);
     view_model_->Add(child, static_cast<int>(i - items.begin()));
     AddChildView(child);
   }
-  LauncherStatusChanged();
+  ShelfStatusChanged();
   overflow_button_ = new OverflowButton(this);
   overflow_button_->set_context_menu_controller(this);
   ConfigureChildView(overflow_button_);
   AddChildView(overflow_button_);
   UpdateFirstButtonPadding();
 
   // We'll layout when our bounds change.
 }
 
 void ShelfView::OnShelfAlignmentChanged() {
@@ skipping 941 matching lines @@
 void ShelfView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_TOOLBAR;
   state->name = l10n_util::GetStringUTF16(IDS_ASH_SHELF_ACCESSIBLE_NAME);
 }
 
 void ShelfView::OnGestureEvent(ui::GestureEvent* event) {
   if (gesture_handler_.ProcessGestureEvent(*event))
     event->StopPropagation();
 }
 
-void ShelfView::LauncherItemAdded(int model_index) {
+void ShelfView::ShelfItemAdded(int model_index) {
   {
     base::AutoReset<bool> cancelling_drag(
         &cancelling_drag_model_changed_, true);
     model_index = CancelDrag(model_index);
   }
   views::View* view = CreateViewForItem(model_->items()[model_index]);
   AddChildView(view);
   // Hide the view, it'll be made visible when the animation is done. Using
   // opacity 0 here to avoid messing with CalculateIdealBounds which touches
   // the view's visibility.
@@ skipping 15 matching lines @@
   if (model_index <= last_visible_index_ ||
       model_index >= model_->FirstPanelIndex()) {
     bounds_animator_->SetAnimationDelegate(
         view, new StartFadeAnimationDelegate(this, view), true);
   } else {
     // Undo the hiding if animation does not run.
     view->layer()->SetOpacity(1.0f);
   }
 }
 
-void ShelfView::LauncherItemRemoved(int model_index, LauncherID id) {
+void ShelfView::ShelfItemRemoved(int model_index, LauncherID id) {
   if (id == context_menu_id_)
     launcher_menu_runner_.reset();
   {
     base::AutoReset<bool> cancelling_drag(
         &cancelling_drag_model_changed_, true);
     model_index = CancelDrag(model_index);
   }
   views::View* view = view_model_->view_at(model_index);
   view_model_->Remove(model_index);
 
@@ skipping 19 matching lines @@
     // item is ripped out from the shelf, its |view| is already invisible.
     AnimateToIdealBounds();
   }
 
   // Close the tooltip because it isn't needed any longer and its anchor view
   // will be deleted soon.
   if (tooltip_->GetCurrentAnchorView() == view)
     tooltip_->Close();
 }
 
-void ShelfView::LauncherItemChanged(int model_index,
-                                    const ash::LauncherItem& old_item) {
+void ShelfView::ShelfItemChanged(int model_index,
+                                 const LauncherItem& old_item) {
   const LauncherItem& item(model_->items()[model_index]);
   if (old_item.type != item.type) {
     // Type changed, swap the views.
     model_index = CancelDrag(model_index);
     scoped_ptr<views::View> old_view(view_model_->view_at(model_index));
     bounds_animator_->StopAnimatingView(old_view.get());
     // Removing and re-inserting a view in our view model will strip the ideal
     // bounds from the item. To avoid recalculation of everything the bounds
     // get remembered and restored after the insertion to the previous value.
     gfx::Rect old_ideal_bounds = view_model_->ideal_bounds(model_index);
@@ skipping 23 matching lines @@
         button->SetImage(item.image);
       button->SchedulePaint();
       break;
     }
 
     default:
       break;
   }
 }
 
-void ShelfView::LauncherItemMoved(int start_index, int target_index) {
+void ShelfView::ShelfItemMoved(int start_index, int target_index) {
   view_model_->Move(start_index, target_index);
   // When cancelling a drag due to a launcher item being added, the currently
   // dragged item is moved back to its initial position. AnimateToIdealBounds
   // will be called again when the new item is added to the |view_model_| but
   // at this time the |view_model_| is inconsistent with the |model_|.
   if (!cancelling_drag_model_changed_)
     AnimateToIdealBounds();
 }
 
-void ShelfView::LauncherStatusChanged() {
+void ShelfView::ShelfStatusChanged() {
   if (ash::switches::UseAlternateShelfLayout())
     return;
   AppListButton* app_list_button =
       static_cast<AppListButton*>(GetAppListButtonView());
   if (model_->status() == LauncherModel::STATUS_LOADING)
     app_list_button->StartLoadingAnimation();
   else
     app_list_button->StopLoadingAnimation();
 }
 
@@ skipping 364 matching lines @@
       break;
     case ash::SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace internal
 }  // namespace ash