Refactor LauncherItemController and LauncherItemDelegate

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 804 matching lines @@
       last_visible_index_ > 0 && last_visible_index_ < last_button_index)
     --last_visible_index_;
   for (int i = 0; i < view_model_->view_size(); ++i) {
     bool visible = i <= last_visible_index_ || i > last_hidden_index_;
     // Always show the app list.
     if (!ash::switches::UseAlternateShelfLayout())
       visible |= (i == last_button_index);
     // To receive drag event continously from |drag_view_| during the dragging
     // off from the shelf, don't make |drag_view_| invisible. It will be
     // eventually invisible and removed from the |view_model_| by
     // FinalizeRipOffDrag().

[Mr4D (OOO till 08-26), 2013/10/09 00:38:22]

Actually that is a problem: There are two views
a. the view inside the LauncherView and 
b. the dragged view.

Even if they are kept on top of each other, they would - as long as they stay
within the view's boundaries - add alpha transparency due to double blending.
This will be noticeable in alpha containing regions. Furthermore, when you leave
the bounding (layer) view the pixels outside the area will not be double blended
and the one inside will be -> which gives another artifact.

=> Which will not look good.

As such it might look correct on a first glimpse to keep both visible, but you
will see artifacts.

     if (dragged_off_shelf_ && view_model_->view_at(i) == drag_view_)
       continue;
     view_model_->view_at(i)->SetVisible(visible);
   }
 
   overflow_button_->SetVisible(show_overflow);
   if (show_overflow) {
     DCHECK_NE(0, view_model_->view_size());
     if (last_visible_index_ == -1) {
       x = shelf->SelectValueForShelfAlignment(inset, 0, 0, inset);
@@ skipping 150 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_].type);
-  if (!item_delegate->IsDraggable(model_->items()[start_drag_index_])) {
+      model_->items()[start_drag_index_].id);
+  if (item_delegate && !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 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].type);
-  if (!item_delegate->IsDraggable(model_->items()[current_index])) {
+      model_->items()[current_index].id);
+  if (item_delegate && !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) {
     if (HandleRipOffDrag(event))
       return;
@@ skipping 513 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].type);
+      model_->items()[index].id);
   if (view_model_->view_size() <= 1 ||
-      !item_delegate->IsDraggable(model_->items()[index]))
+      (item_delegate && !item_delegate->IsDraggable()))
     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].type);
-  return item_delegate->GetTitle(model_->items()[view_index]);
+      model_->items()[view_index].id);
+  return item_delegate ? item_delegate->GetTitle() : base::string16();
 }
 
 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].type);
-    item_delegate->ItemSelected(model_->items()[view_index], event);
+            model_->items()[view_index].id);
+    if (item_delegate)
+      item_delegate->ItemSelected(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.type);
-  menu_model.reset(item_delegate->CreateApplicationMenu(item, event.flags()));
+      item_manager_->GetLauncherItemDelegate(item.id);
+  if (item_delegate)
+    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(),
@@ 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].type);
-  menu_model.reset(item_delegate->CreateContextMenu(
-      model_->items()[view_index],
-      source->GetWidget()->GetNativeView()->GetRootWindow()));
+      model_->items()[view_index].id);
+  if (item_delegate) {
+    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);
 
   ShowMenu(scoped_ptr<views::MenuModelAdapter>(
                new views::MenuModelAdapter(menu_model.get())),
            source,
@@ skipping 68 matching lines @@
           NULL,
           anchor_point,
           menu_alignment,
           source_type,
           context_menu ? views::MenuRunner::CONTEXT_MENU : 0) ==
       views::MenuRunner::MENU_DELETED) {
     if (!got_deleted) {
       got_deleted_ = NULL;
       shelf->ForceUndimming(false);
     }
   LOG(ERROR) << __FUNCTION__;

[Mr4D (OOO till 08-26), 2013/10/09 00:38:22]

I guess this can be removed?

     return;
   }
   LOG(ERROR) << __FUNCTION__ << " " << IsShowingMenu();

[Mr4D (OOO till 08-26), 2013/10/09 00:38:22]

And this?

   got_deleted_ = NULL;
   shelf->ForceUndimming(false);
 
   // If it is a context menu and we are showing overflow bubble
   // we want to hide overflow bubble.
   //if (owner_overflow_bubble_)
   //  owner_overflow_bubble_->HideBubbleAndRefreshButton();

[Mr4D (OOO till 08-26), 2013/10/09 00:38:22]

I think this can go?

 
   // Unpinning an item will reset the |launcher_menu_runner_| before coming
   // here.
   if (launcher_menu_runner_)
     closing_event_time_ = launcher_menu_runner_->closing_event_time();
   Shell::GetInstance()->UpdateShelfVisibility();
 }
 
 void LauncherView::OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) {
   FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
@@ skipping 42 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->type);
-  return item_delegate->ShouldShowTooltip(*item);
+      item_manager_->GetLauncherItemDelegate(item->id);
+  return item_delegate ? item_delegate->ShouldShowTooltip() : false;
 }
 
 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