Revert 226547 "Refactor LauncherItemController and LauncherItemD..."

trunk/src/ash/launcher/launcher_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/launcher/launcher_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 967 matching lines @@
   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(
-      model_->items()[start_drag_index_].id);
-  if (item_delegate && !item_delegate->IsDraggable()) {
+      model_->items()[start_drag_index_].type);
+  if (!item_delegate->IsDraggable(model_->items()[start_drag_index_])) {
     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 LauncherView::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(
-      model_->items()[current_index].id);
-  if (item_delegate && !item_delegate->IsDraggable()) {
+      model_->items()[current_index].type);
+  if (!item_delegate->IsDraggable(model_->items()[current_index])) {
     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) {
     if (HandleRipOffDrag(event))
       return;
@@ skipping 506 matching lines @@
                                           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(
-      model_->items()[index].id);
+      model_->items()[index].type);
   if (view_model_->view_size() <= 1 ||
-      (item_delegate && !item_delegate->IsDraggable()))
+      !item_delegate->IsDraggable(model_->items()[index]))
     return;  // View is being deleted or not draggable, ignore request.
 
   ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
 
   drag_view_ = view;
   drag_offset_ = shelf->PrimaryAxisValue(event.x(), event.y());
 }
 
 void LauncherView::PointerDraggedOnButton(views::View* view,
                                           Pointer pointer,
@@ skipping 49 matching lines @@
     tooltip_->StopTimer();
 }
 
 base::string16 LauncherView::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(
-      model_->items()[view_index].id);
-  return item_delegate ? item_delegate->GetTitle() : base::string16();
+      model_->items()[view_index].type);
+  return item_delegate->GetTitle(model_->items()[view_index]);
 }
 
 void LauncherView::ButtonPressed(views::Button* sender,
                                  const ui::Event& event) {
   // Do not handle mouse release during drag.
   if (dragging())
     return;
 
   if (sender == overflow_button_) {
     ToggleOverflowBubble();
@@ skipping 38 matching lines @@
       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);
-    if (item_delegate)
-      item_delegate->ItemSelected(event);
+            model_->items()[view_index].type);
+    item_delegate->ItemSelected(model_->items()[view_index], event);
 
     ShowListMenuForView(model_->items()[view_index], sender, event);
   }
 }
 
 bool LauncherView::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);
-  if (item_delegate)
-    menu_model.reset(item_delegate->CreateApplicationMenu(event.flags()));
+      item_manager_->GetLauncherItemDelegate(item.type);
+  menu_model.reset(item_delegate->CreateApplicationMenu(item, 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(),
@@ skipping 12 matching lines @@
       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(
-      model_->items()[view_index].id);
-  if (item_delegate) {
-    menu_model.reset(item_delegate->CreateContextMenu(
-        source->GetWidget()->GetNativeView()->GetRootWindow()));
-  }
+      model_->items()[view_index].type);
+  menu_model.reset(item_delegate->CreateContextMenu(
+      model_->items()[view_index],
+      source->GetWidget()->GetNativeView()->GetRootWindow()));
   if (!menu_model)
     return;
 
   base::AutoReset<LauncherID> reseter(
       &context_menu_id_,
       view_index == -1 ? 0 : model_->items()[view_index].id);
 
   ShowMenu(scoped_ptr<views::MenuModelAdapter>(
                new views::MenuModelAdapter(menu_model.get())),
            source,
@@ skipping 134 matching lines @@
 }
 
 bool LauncherView::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);
-  return item_delegate ? item_delegate->ShouldShowTooltip() : false;
+      item_manager_->GetLauncherItemDelegate(item->type);
+  return item_delegate->ShouldShowTooltip(*item);
 }
 
 int LauncherView::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