Refactor LauncherDelegate

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"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/launcher/launcher_button.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_icon_observer.h"
+#include "ash/launcher/launcher_item_delegate.h"
+#include "ash/launcher/launcher_item_delegate_manager.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_tooltip_manager.h"
 #include "ash/launcher/overflow_bubble.h"
 #include "ash/launcher/overflow_button.h"
 #include "ash/launcher/tabbed_launcher_button.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/shelf_layout_manager.h"
@@ skipping 376 matching lines @@
       drag_offset_(0),
       start_drag_index_(-1),
       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) {
+      dragged_off_shelf_(false),
+      item_manager_(Shell::GetInstance()->launcher_item_delegate_manager()) {
   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 LauncherTooltipManager(
       shelf_layout_manager, this));
 }
 
 LauncherView::~LauncherView() {
@@ skipping 552 matching lines @@
       view, new FadeInAnimationDelegate(view), true);
 }
 
 void LauncherView::PrepareForDrag(Pointer pointer,
                                   const ui::LocatedEvent& event) {
   DCHECK(!dragging());
   DCHECK(drag_view_);
   drag_pointer_ = pointer;
   start_drag_index_ = view_model_->GetIndexOfView(drag_view_);
 
-  // If the item is no longer draggable, bail out.
-  if (start_drag_index_ == -1 ||
-      !delegate_->IsDraggable(model_->items()[start_drag_index_])) {
+  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_])) {
+    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);
-  if (current_index == -1 ||
-      !delegate_->IsDraggable(model_->items()[current_index])) {
+
+  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+      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, check if the item got
   // ripped off the shelf - if it did we are done.
   if (!drag_and_drop_launcher_id_ && ash::switches::UseDragOffShelf()) {
     if (HandleRipOffDrag(event))
       return;
     // The rip off handler could have changed the location of the item.
@@ skipping 476 matching lines @@
 }
 
 void LauncherView::PointerPressedOnButton(views::View* view,
                                           Pointer pointer,
                                           const ui::LocatedEvent& event) {
   if (drag_view_)
     return;
 
   tooltip_->Close();
   int index = view_model_->GetIndexOfView(view);
-  if (index == -1 ||
-      view_model_->view_size() <= 1 ||
-      !delegate_->IsDraggable(model_->items()[index]))
+  if (index == -1)
+    return;
+
+  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+      model_->items()[index].type);
+  if (view_model_->view_size() <= 1 ||
+      !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 48 matching lines @@
   if (!tooltip_->IsVisible())
     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();
 
-  switch (model_->items()[view_index].type) {
-    case TYPE_TABBED:
-    case TYPE_APP_PANEL:
-    case TYPE_APP_SHORTCUT:
-    case TYPE_WINDOWED_APP:
-    case TYPE_PLATFORM_APP:
-    case TYPE_BROWSER_SHORTCUT:
-      return delegate_->GetTitle(model_->items()[view_index]);
-
-    case TYPE_APP_LIST:
-      return model_->status() == LauncherModel::STATUS_LOADING ?
-          l10n_util::GetStringUTF16(IDS_AURA_APP_LIST_SYNCING_TITLE) :
-          l10n_util::GetStringUTF16(IDS_AURA_APP_LIST_TITLE);
-  }
-  return base::string16();
+  LauncherItemDelegate* item_delegate = item_manager_->GetLauncherItemDelegate(
+      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;
 
   tooltip_->Close();
 
@@ skipping 23 matching lines @@
     }
 
     // Collect usage statistics before we decide what to do with the click.
     switch (model_->items()[view_index].type) {
       case TYPE_APP_SHORTCUT:
       case TYPE_WINDOWED_APP:
       case TYPE_PLATFORM_APP:
       case TYPE_BROWSER_SHORTCUT:
         Shell::GetInstance()->delegate()->RecordUserMetricsAction(
             UMA_LAUNCHER_CLICK_ON_APP);
-        // Fallthrough
-      case TYPE_TABBED:
-      case TYPE_APP_PANEL:
-        delegate_->ItemSelected(model_->items()[view_index], event);
-        // Don't show the menu when the user creates a new browser using ctrl
-        // click.
-        if (model_->items()[view_index].type != TYPE_BROWSER_SHORTCUT ||
-            !(event.flags() & ui::EF_CONTROL_DOWN))
-          ShowListMenuForView(model_->items()[view_index], sender, event);
         break;
 
       case TYPE_APP_LIST:
         Shell::GetInstance()->delegate()->RecordUserMetricsAction(
             UMA_LAUNCHER_CLICK_ON_APPLIST_BUTTON);
-        Shell::GetInstance()->ToggleAppList(GetWidget()->GetNativeView());
+        break;
+
+      case TYPE_TABBED:
+      case TYPE_APP_PANEL:
         break;
     }
+
+    LauncherItemDelegate* item_delegate =
+        item_manager_->GetLauncherItemDelegate(
+            model_->items()[view_index].type);
+    item_delegate->ItemSelected(model_->items()[view_index], event);
+
+    ShowListMenuForView(model_->items()[view_index], sender, event);

[simonhong_, 2013/08/27 21:52:00]

I moved this refactoring code into ScopedTargetRootWindow scoped_target
parentheses.
WindowSizerTest.OpenBrowserUsingShelfOnOhterDisplay was fail because of above
code.

[Mr4D (OOO till 08-26), 2013/08/28 00:06:06]

Sorry, but did you test why this was failing?

This makes me worried. Because Oshima was working on this just a few weeks ago.
From my understanding of that change I think this should be fine, but he should
have a quick look at this.

[simonhong_, 2013/08/28 00:33:58]

Yes, I tested and found failing reason.
Failing reason is calling ItemSelected() outside of ScopedTargetRootWindow
scope.

[oshima, 2013/08/28 05:27:46]

Yes, that's correct fix.

   }
 }
 
 bool LauncherView::ShowListMenuForView(const LauncherItem& item,
                                        views::View* source,
                                        const ui::Event& event) {
   scoped_ptr<ash::LauncherMenuModel> menu_model;
-  menu_model.reset(delegate_->CreateApplicationMenu(item, event.flags()));
+  LauncherItemDelegate* item_delegate =
+      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(),
            false,
            ui::GetMenuSourceTypeForEvent(event));
   return true;
 }
 
 void LauncherView::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) {
     view_index = -1;
   }
 
   tooltip_->Close();
 
   if (view_index == -1) {
     Shell::GetInstance()->ShowContextMenu(point, source_type);
     return;
   }
-  scoped_ptr<ui::MenuModel> menu_model(delegate_->CreateContextMenu(
+  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()));
   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,
            point,
            true,
            source_type);
@@ skipping 111 matching lines @@
   if (view_index == -1)
     return NULL;
   return &(model_->items()[view_index]);
 }
 
 bool LauncherView::ShouldShowTooltipForView(const views::View* view) const {
   if (view == GetAppListButtonView() &&
       Shell::GetInstance()->GetAppListWindow())
     return false;
   const LauncherItem* item = LauncherItemForView(view);
-  return (!item || delegate_->ShouldShowTooltip(*item));
+  if (!item)
+    return true;
+  LauncherItemDelegate* item_delegate =
+      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