ash: Rename more Launcher classes to Shelf*.

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"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/launcher/launcher_delegate.h"
-#include "ash/launcher/launcher_item_delegate.h"
-#include "ash/launcher/launcher_item_delegate_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/scoped_target_root_window.h"
 #include "ash/shelf/alternate_app_list_button.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/overflow_button.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_icon_observer.h"
+#include "ash/shelf/shelf_item_delegate.h"
+#include "ash/shelf/shelf_item_delegate_manager.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell_delegate.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "base/auto_reset.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "grit/ash_resources.h"
@@ skipping 352 matching lines @@
       context_menu_id_(0),
       leading_inset_(kDefaultLeadingInset),
       cancelling_drag_model_changed_(false),
       last_hidden_index_(0),
       closing_event_time_(base::TimeDelta()),
       got_deleted_(NULL),
       drag_and_drop_item_pinned_(false),
       drag_and_drop_launcher_id_(0),
       dragged_off_shelf_(false),
       snap_back_from_rip_off_view_(NULL),
-      item_manager_(Shell::GetInstance()->launcher_item_delegate_manager()),
+      item_manager_(Shell::GetInstance()->shelf_item_delegate_manager()),
       layout_manager_(shelf_layout_manager),
       overflow_mode_(false) {
   DCHECK(model_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new LauncherFocusSearch(view_model_.get()));
   tooltip_.reset(new ShelfTooltipManager(shelf_layout_manager, this));
 }
 
@@ skipping 565 matching lines @@
   DCHECK(drag_view_);
   drag_pointer_ = pointer;
   start_drag_index_ = view_model_->GetIndexOfView(drag_view_);
 
   if (start_drag_index_== -1) {
     CancelDrag(-1);
     return;
   }
 
   // If the item is no longer draggable, bail out.
-  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[start_drag_index_].id);
   if (!item_delegate->IsDraggable()) {
     CancelDrag(-1);
     return;
   }
 
   // Move the view to the front so that it appears on top of other views.
   ReorderChildView(drag_view_, -1);
   bounds_animator_->StopAnimatingView(drag_view_);
 }
 
 void ShelfView::ContinueDrag(const ui::LocatedEvent& event) {
   // Due to a syncing operation the application might have been removed.
   // Bail if it is gone.
   int current_index = view_model_->GetIndexOfView(drag_view_);
   DCHECK_NE(-1, current_index);
 
-  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[current_index].id);
   if (!item_delegate->IsDraggable()) {
     CancelDrag(-1);
     return;
   }
 
   // If this is not a drag and drop host operation and not the app list item,
   // check if the item got ripped off the shelf - if it did we are done.
   if (!drag_and_drop_launcher_id_ && ash::switches::UseDragOffShelf() &&
       RemovableByRipOff(current_index) != NOT_REMOVABLE) {
@@ skipping 596 matching lines @@
 void ShelfView::PointerPressedOnButton(views::View* view,
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   if (drag_view_)
     return;
 
   int index = view_model_->GetIndexOfView(view);
   if (index == -1)
     return;
 
-  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[index].id);
   if (view_model_->view_size() <= 1 || !item_delegate->IsDraggable())
     return;  // View is being deleted or not draggable, ignore request.
 
   drag_view_ = view;
   drag_offset_ = layout_manager_->PrimaryAxisValue(event.x(), event.y());
   UMA_HISTOGRAM_ENUMERATION("Ash.ShelfAlignmentUsage",
       layout_manager_->SelectValueForShelfAlignment(
           SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
           SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
@@ skipping 55 matching lines @@
   if (!tooltip_->IsVisible())
     tooltip_->StopTimer();
 }
 
 base::string16 ShelfView::GetAccessibleName(const views::View* view) {
   int view_index = view_model_->GetIndexOfView(view);
   // May be -1 while in the process of animating closed.
   if (view_index == -1)
     return base::string16();
 
-  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[view_index].id);
   return item_delegate->GetTitle();
 }
 
 void ShelfView::ButtonPressed(views::Button* sender, const ui::Event& event) {
   // Do not handle mouse release during drag.
   if (dragging())
     return;
 
   if (sender == overflow_button_) {
@@ skipping 37 matching lines @@
         break;
 
       case TYPE_APP_PANEL:
         break;
 
       case TYPE_UNDEFINED:
         NOTREACHED() << "LauncherItemType must be set.";
         break;
     }
 
-    LauncherItemDelegate* item_delegate =
-        item_manager_->GetLauncherItemDelegate(
-            model_->items()[view_index].id);
+    ShelfItemDelegate* item_delegate =
+        item_manager_->GetShelfItemDelegate(model_->items()[view_index].id);
     if (!item_delegate->ItemSelected(event))
       ShowListMenuForView(model_->items()[view_index], sender, event);
   }
 }
 
 bool ShelfView::ShowListMenuForView(const LauncherItem& item,
                                     views::View* source,
                                     const ui::Event& event) {
-  scoped_ptr<ash::LauncherMenuModel> menu_model;
-  LauncherItemDelegate* item_delegate =
-      item_manager_->GetLauncherItemDelegate(item.id);
+  scoped_ptr<LauncherMenuModel> menu_model;
+  ShelfItemDelegate* item_delegate =
+      item_manager_->GetShelfItemDelegate(item.id);
   menu_model.reset(item_delegate->CreateApplicationMenu(event.flags()));
 
   // Make sure we have a menu and it has at least two items in addition to the
   // application title and the 3 spacing separators.
   if (!menu_model.get() || menu_model->GetItemCount() <= 5)
     return false;
 
   ShowMenu(scoped_ptr<views::MenuModelAdapter>(
                new LauncherMenuModelAdapter(menu_model.get())),
            source,
            gfx::Point(),
            false,
            ui::GetMenuSourceTypeForEvent(event));
   return true;
 }
 
 void ShelfView::ShowContextMenuForView(views::View* source,
                                        const gfx::Point& point,
                                        ui::MenuSourceType source_type) {
   int view_index = view_model_->GetIndexOfView(source);
   // TODO(simon.hong81): Create LauncherContextMenu for applist in its
-  // LauncherItemDelegate.
-  if (view_index != -1 &&
-      model_->items()[view_index].type == TYPE_APP_LIST) {
+  // ShelfItemDelegate.
+  if (view_index != -1 && model_->items()[view_index].type == TYPE_APP_LIST) {
     view_index = -1;
   }
 
   if (view_index == -1) {
     Shell::GetInstance()->ShowContextMenu(point, source_type);
     return;
   }
   scoped_ptr<ui::MenuModel> menu_model;
-  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[view_index].id);
   menu_model.reset(item_delegate->CreateContextMenu(
       source->GetWidget()->GetNativeView()->GetRootWindow()));
   if (!menu_model)
     return;
 
   base::AutoReset<LauncherID> reseter(
       &context_menu_id_,
       view_index == -1 ? 0 : model_->items()[view_index].id);
 
@@ skipping 140 matching lines @@
   return &(model_->items()[view_index]);
 }
 
 bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
   if (view == GetAppListButtonView() &&
       Shell::GetInstance()->GetAppListWindow())
     return false;
   const LauncherItem* item = LauncherItemForView(view);
   if (!item)
     return true;
-  LauncherItemDelegate* item_delegate =
-      item_manager_->GetLauncherItemDelegate(item->id);
+  ShelfItemDelegate* item_delegate =
+      item_manager_->GetShelfItemDelegate(item->id);
   return item_delegate->ShouldShowTooltip();
 }
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   ShelfWidget* shelf = RootWindowController::ForLauncher(
       GetWidget()->GetNativeView())->shelf();
   ash::ShelfAlignment align = shelf->GetAlignment();
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = 0;
   switch (align) {
     case ash::SHELF_ALIGNMENT_BOTTOM:
       distance = bounds.y() - coordinate.y();
       break;
     case ash::SHELF_ALIGNMENT_LEFT:
       distance = coordinate.x() - bounds.right();
       break;
     case ash::SHELF_ALIGNMENT_RIGHT:
       distance = bounds.x() - coordinate.x();
       break;
     case ash::SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace internal
 }  // namespace ash