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_menu_model.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"
 #include "grit/ash_strings.h"
@@ skipping 76 matching lines @@
 // separates.
 const int kRipOffDistance = 48;
 
 // The rip off drag and drop proxy image should get scaled by this factor.
 const float kDragAndDropProxyScale = 1.5f;
 
 namespace {
 
 // The MenuModelAdapter gets slightly changed to adapt the menu appearance to
 // our requirements.
-class LauncherMenuModelAdapter
-    : public views::MenuModelAdapter {
+class ShelfMenuModelAdapter : public views::MenuModelAdapter {
  public:
-  explicit LauncherMenuModelAdapter(ash::LauncherMenuModel* menu_model);
+  explicit ShelfMenuModelAdapter(ShelfMenuModel* menu_model);
 
-  // Overriding MenuModelAdapter's MenuDelegate implementation.
+  // views::MenuModelAdapter:
   virtual const gfx::Font* GetLabelFont(int command_id) const OVERRIDE;
   virtual bool IsCommandEnabled(int id) const OVERRIDE;
   virtual void GetHorizontalIconMargins(int id,
                                         int icon_size,
                                         int* left_margin,
                                         int* right_margin) const OVERRIDE;
   virtual bool GetForegroundColor(int command_id,
                                   bool is_hovered,
                                   SkColor* override_color) const OVERRIDE;
   virtual bool GetBackgroundColor(int command_id,
                                   bool is_hovered,
                                   SkColor* override_color) const OVERRIDE;
   virtual int GetMaxWidthForMenu(views::MenuItemView* menu) OVERRIDE;
   virtual bool ShouldReserveSpaceForSubmenuIndicator() const OVERRIDE;
 
  private:
-  ash::LauncherMenuModel* launcher_menu_model_;
+  ShelfMenuModel* menu_model_;
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherMenuModelAdapter);
+  DISALLOW_COPY_AND_ASSIGN(ShelfMenuModelAdapter);
 };
 
-LauncherMenuModelAdapter::LauncherMenuModelAdapter(
-    ash::LauncherMenuModel* menu_model)
+ShelfMenuModelAdapter::ShelfMenuModelAdapter(ShelfMenuModel* menu_model)
     : MenuModelAdapter(menu_model),
-      launcher_menu_model_(menu_model) {}
+      menu_model_(menu_model) {
+}
 
-const gfx::Font* LauncherMenuModelAdapter::GetLabelFont(
-    int command_id) const {
+const gfx::Font* ShelfMenuModelAdapter::GetLabelFont(int command_id) const {
   if (command_id != kCommandIdOfMenuName)
     return MenuModelAdapter::GetLabelFont(command_id);
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   return &rb.GetFont(ui::ResourceBundle::BoldFont);
 }
 
-bool LauncherMenuModelAdapter::IsCommandEnabled(int id) const {
+bool ShelfMenuModelAdapter::IsCommandEnabled(int id) const {
   return id != kCommandIdOfMenuName;
 }
 
-bool LauncherMenuModelAdapter::GetForegroundColor(
-    int command_id,
-    bool is_hovered,
-    SkColor* override_color) const {
+bool ShelfMenuModelAdapter::GetForegroundColor(int command_id,
+                                               bool is_hovered,
+                                               SkColor* override_color) const {
   if (command_id != kCommandIdOfMenuName)
     return false;
 
   *override_color = kCaptionItemForegroundColor;
   return true;
 }
 
-bool LauncherMenuModelAdapter::GetBackgroundColor(
-    int command_id,
-    bool is_hovered,
-    SkColor* override_color) const {
-  if (!launcher_menu_model_->IsCommandActive(command_id))
+bool ShelfMenuModelAdapter::GetBackgroundColor(int command_id,
+                                               bool is_hovered,
+                                               SkColor* override_color) const {
+  if (!menu_model_->IsCommandActive(command_id))
     return false;
 
   *override_color = is_hovered ? kFocusedActiveListItemBackgroundColor :
                                  kActiveListItemBackgroundColor;
   return true;
 }
 
-void LauncherMenuModelAdapter::GetHorizontalIconMargins(
-    int command_id,
-    int icon_size,
-    int* left_margin,
-    int* right_margin) const {
+void ShelfMenuModelAdapter::GetHorizontalIconMargins(int command_id,
+                                                     int icon_size,
+                                                     int* left_margin,
+                                                     int* right_margin) const {
   *left_margin = kHorizontalIconSpacing;
   *right_margin = (command_id != kCommandIdOfMenuName) ?
       kHorizontalIconSpacing : -(icon_size + kHorizontalNoIconInsetSpacing);
 }
 
-int LauncherMenuModelAdapter::GetMaxWidthForMenu(views::MenuItemView* menu) {
+int ShelfMenuModelAdapter::GetMaxWidthForMenu(views::MenuItemView* menu) {
   return kMaximumAppMenuItemLength;
 }
 
-bool LauncherMenuModelAdapter::ShouldReserveSpaceForSubmenuIndicator() const {
+bool ShelfMenuModelAdapter::ShouldReserveSpaceForSubmenuIndicator() const {
   return false;
 }
 
 // Custom FocusSearch used to navigate the launcher in the order items are in
 // the ViewModel.
 class LauncherFocusSearch : public views::FocusSearch {
  public:
   explicit LauncherFocusSearch(views::ViewModel* view_model)
       : FocusSearch(NULL, true, true),
         view_model_(view_model) {}
@@ skipping 156 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 567 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<ShelfMenuModel> 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())),
+               new ShelfMenuModelAdapter(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