Refactor LauncherItemController and LauncherItemDelegate

* Remove LauncherItem parameter of LauncherItemDelegate method
* LauncherItemController subclasses LauncherItemDelegate
* Register/Unregister when LauncherItemDelegate is created/removed
* LauncherItemDelegateManager handles LauncherItemDelegate by LauncherID
* LauncherItemDelegateManager take ownership of all LauncherItemDelegate

R=sky@chromium.org, skuhne@chromium.org
BUG=279105
TEST=unit_tests, browser_tests, ash_unittests, ash_shell

Review URL: https://codereview.chromium.org/23606016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@226547 0039d316-1c4b-4281-b951-d872f2087c98

24 files changed, 473 insertions, 221 deletions

diff --git a/ash/ash.gyp b/ash/ash.gyp
index 13ea12f..c604f50 100644
--- a/ash/ash.gyp
+++ b/ash/ash.gyp
@@ -612,6 +612,8 @@
         'test/launcher_view_test_api.h',
         'test/display_manager_test_api.cc',
         'test/display_manager_test_api.h',
+        'test/launcher_item_delegate_manager_test_api.cc',
+        'test/launcher_item_delegate_manager_test_api.h',
         'test/mirror_window_test_api.cc',
         'test/mirror_window_test_api.h',
         'test/shell_test_api.cc',
@@ -622,10 +624,12 @@
         'test/test_user_wallpaper_delegate.h',
         'test/test_launcher_delegate.cc',
         'test/test_launcher_delegate.h',
+        'test/test_launcher_item_delegate.cc',
+        'test/test_launcher_item_delegate.h',
         'test/test_screenshot_delegate.cc',
         'test/test_screenshot_delegate.cc',
         'test/test_session_state_delegate.cc',
-        'test/test_session_state_delegate.cc',
+        'test/test_session_state_delegate.h',
         'test/test_shell_delegate.cc',
         'test/test_shell_delegate.h',
         'test/test_suite.cc',
@@ -738,14 +742,21 @@
         'shell/context_menu.cc',
         'shell/context_menu.h',
         'shell/launcher_delegate_impl.cc',
+        'shell/launcher_delegate_impl.h',
         'shell/lock_view.cc',
         'shell/panel_window.cc',
+        'shell/panel_window.h',
         'shell/shell_delegate_impl.cc',
         'shell/shell_delegate_impl.h',
         'shell/toplevel_window.cc',
+        'shell/toplevel_window.h',
         'shell/widgets.cc',
         'shell/window_type_launcher.cc',
+        'shell/window_type_launcher.h',
         'shell/window_watcher.cc',
+        'shell/window_watcher.h',
+        'shell/window_watcher_launcher_item_delegate.cc',
+        'shell/window_watcher_launcher_item_delegate.h',
         'shell/window_watcher_unittest.cc',
         'system/chromeos/managed/tray_locally_managed_user_unittest.cc',
         'system/chromeos/network/network_state_notifier_unittest.cc',
@@ -901,6 +912,8 @@
         'shell/window_type_launcher.h',
         'shell/window_watcher.cc',
         'shell/window_watcher.h',
+        'shell/window_watcher_launcher_item_delegate.cc',
+        'shell/window_watcher_launcher_item_delegate.h',
         '../content/app/startup_helper_win.cc',
         '../ui/views/test/test_views_delegate.cc',
       ],
diff --git a/ash/launcher/launcher.cc b/ash/launcher/launcher.cc
index 68a8da7..2d5397a 100644
--- a/ash/launcher/launcher.cc
+++ b/ash/launcher/launcher.cc
@@ -108,8 +108,11 @@ void Launcher::ActivateLauncherItem(int index) {
                      false);
 
   const ash::LauncherItem& item = launcher_view_->model()->items()[index];
-  Shell::GetInstance()->launcher_item_delegate_manager()->
-      GetLauncherItemDelegate(item.type)->ItemSelected(item, event);
+  ash::LauncherItemDelegate* item_delegate =
+      Shell::GetInstance()->launcher_item_delegate_manager()->
+          GetLauncherItemDelegate(item.id);
+  if (item_delegate)
+    item_delegate->ItemSelected(event);
 }
 
 void Launcher::CycleWindowLinear(CycleDirection direction) {
diff --git a/ash/launcher/launcher_delegate.h b/ash/launcher/launcher_delegate.h
index 41d0c29..3766ca3 100644
--- a/ash/launcher/launcher_delegate.h
+++ b/ash/launcher/launcher_delegate.h
@@ -25,6 +25,7 @@ class ASH_EXPORT LauncherDelegate {
   // there isn't one.
   // Note: Windows of tabbed browsers will return the |LauncherID| of the
   // currently active tab or selected tab.
+  // TODO(simon.hong81): Remove this and handle in LauncherItemDelegateManager.
   virtual LauncherID GetIDByWindow(aura::Window* window) = 0;
 
   // Callback used to allow delegate to perform initialization actions that
diff --git a/ash/launcher/launcher_item_delegate.h b/ash/launcher/launcher_item_delegate.h
index e1d940d..a72b6e6 100644
--- a/ash/launcher/launcher_item_delegate.h
+++ b/ash/launcher/launcher_item_delegate.h
@@ -35,7 +35,6 @@ class ASH_EXPORT LauncherMenuModel : public ui::SimpleMenuModel {
 };
 
 // Delegate for the LauncherItem.
-// TODO(simon.hong81): Remove LauncherItem from abstract function parameters.
 class ASH_EXPORT LauncherItemDelegate {
  public:
   virtual ~LauncherItemDelegate() {}
@@ -46,17 +45,15 @@ class ASH_EXPORT LauncherItemDelegate {
   // but not |aura::Window|. If the |event| is of type KeyEvent, it is assumed
   // that this was triggered by keyboard action (Alt+<number>) and special
   // handling might happen.
-  virtual void ItemSelected(const LauncherItem& item,
-                            const ui::Event& event) = 0;
+  virtual void ItemSelected(const ui::Event& event) = 0;
 
-  // Returns the title to display for the specified launcher item.
-  virtual base::string16 GetTitle(const LauncherItem& item) = 0;
+  // Returns the title to display.
+  virtual base::string16 GetTitle() = 0;
 
   // Returns the context menumodel for the specified item on
   // |root_window|.  Return NULL if there should be no context
   // menu. The caller takes ownership of the returned model.
-  virtual ui::MenuModel* CreateContextMenu(const LauncherItem& item,
-                                           aura::RootWindow* root_window) = 0;
+  virtual ui::MenuModel* CreateContextMenu(aura::RootWindow* root_window) = 0;
 
   // Returns the application menu model for the specified item. There are three
   // possible return values:
@@ -67,15 +64,13 @@ class ASH_EXPORT LauncherItemDelegate {
   //  - A list containing the title and the active list of items.
   // The caller takes ownership of the returned model.
   // |event_flags| specifies the flags of the event which triggered this menu.
-  virtual LauncherMenuModel* CreateApplicationMenu(
-      const LauncherItem& item,
-      int event_flags) = 0;
+  virtual ash::LauncherMenuModel* CreateApplicationMenu(int event_flags) = 0;
 
-  // Whether the given launcher item is draggable.
-  virtual bool IsDraggable(const LauncherItem& item) = 0;
+  // Whether the launcher item is draggable.
+  virtual bool IsDraggable() = 0;
 
-  // Returns true if a tooltip should be shown for the item.
-  virtual bool ShouldShowTooltip(const LauncherItem& item) = 0;
+  // Returns true if a tooltip should be shown.
+  virtual bool ShouldShowTooltip() = 0;
 };
 
 }  // namespace ash
diff --git a/ash/launcher/launcher_item_delegate_manager.cc b/ash/launcher/launcher_item_delegate_manager.cc
index 1708fe6..cc85e98 100644
--- a/ash/launcher/launcher_item_delegate_manager.cc
+++ b/ash/launcher/launcher_item_delegate_manager.cc
@@ -4,28 +4,69 @@
 
 #include "ash/launcher/launcher_item_delegate_manager.h"
 
+#include "ash/launcher/launcher_item_delegate.h"
+#include "ash/launcher/launcher_model.h"
+#include "ash/shell.h"
 #include "base/logging.h"
+#include "base/stl_util.h"
 
 namespace ash {
 
-LauncherItemDelegateManager::LauncherItemDelegateManager() {
+LauncherItemDelegateManager::LauncherItemDelegateManager(
+    ash::LauncherModel* model) : model_(model) {
+  DCHECK(model_);
+  model_->AddObserver(this);
 }
 
 LauncherItemDelegateManager::~LauncherItemDelegateManager() {
+  model_->RemoveObserver(this);
+  STLDeleteContainerPairSecondPointers(id_to_item_delegate_map_.begin(),
+                                       id_to_item_delegate_map_.end());
 }
 
-void LauncherItemDelegateManager::RegisterLauncherItemDelegate(
-    ash::LauncherItemType type, LauncherItemDelegate* item_delegate) {
-  // When a new |item_delegate| is registered with an exsiting |type|, it will
-  // get overwritten.
-  item_type_to_item_delegate_map_[type] = item_delegate;
+void LauncherItemDelegateManager::SetLauncherItemDelegate(
+    ash::LauncherID id,
+    scoped_ptr<LauncherItemDelegate> item_delegate) {
+  // If another LauncherItemDelegate is already registered for |id|, we assume
+  // that this request is replacing LauncherItemDelegate for |id| with
+  // |item_delegate|.
+  RemoveLauncherItemDelegate(id);
+  id_to_item_delegate_map_[id] = item_delegate.release();
 }
 
 LauncherItemDelegate* LauncherItemDelegateManager::GetLauncherItemDelegate(
-    ash::LauncherItemType item_type) {
-  DCHECK(item_type_to_item_delegate_map_.find(item_type) !=
-      item_type_to_item_delegate_map_.end());
-  return item_type_to_item_delegate_map_[item_type];
+    ash::LauncherID id) {
+  if (id_to_item_delegate_map_.find(id) != id_to_item_delegate_map_.end())
+    return id_to_item_delegate_map_[id];
+  return NULL;
+}
+
+void LauncherItemDelegateManager::LauncherItemAdded(int index) {
+}
+
+void LauncherItemDelegateManager::LauncherItemRemoved(int index,
+                                                      ash::LauncherID id) {
+  RemoveLauncherItemDelegate(id);
+}
+
+void LauncherItemDelegateManager::LauncherItemMoved(int start_index,
+                                                    int target_index) {
+}
+
+void LauncherItemDelegateManager::LauncherItemChanged(
+    int index,
+    const LauncherItem& old_item) {
+}
+
+void LauncherItemDelegateManager::LauncherStatusChanged() {
+}
+
+void LauncherItemDelegateManager::RemoveLauncherItemDelegate(
+    ash::LauncherID id) {
+  if (id_to_item_delegate_map_.find(id) != id_to_item_delegate_map_.end()) {
+    delete id_to_item_delegate_map_[id];
+    id_to_item_delegate_map_.erase(id);
+  }
 }
 
 }  // namespace ash
diff --git a/ash/launcher/launcher_item_delegate_manager.h b/ash/launcher/launcher_item_delegate_manager.h
index f7c52f5..168a094 100644
--- a/ash/launcher/launcher_item_delegate_manager.h
+++ b/ash/launcher/launcher_item_delegate_manager.h
@@ -8,39 +8,61 @@
 #include <map>
 
 #include "ash/ash_export.h"
+#include "ash/launcher/launcher_model_observer.h"
 #include "ash/launcher/launcher_types.h"
 #include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
 
 namespace ash {
 class LauncherItemDelegate;
+class LauncherModel;
 
-// LauncherItemDelegateManager helps Launcher/LauncherView to choose right
-// LauncherItemDelegate based on LauncherItemType.
-// When new LauncherItemDelegate is created, it must be registered by
-// RegisterLauncherItemDelegate(). If not, Launcher/LauncherView can't get
-// LauncherItem's LauncherItemDelegate.
-// TODO(simon.hong81): This class should own all LauncherItemDelegate.
-class ASH_EXPORT LauncherItemDelegateManager {
+namespace test {
+class LauncherItemDelegateManagerTestAPI;
+}
+
+// LauncherItemDelegateManager manages the set of LauncherItemDelegates for the
+// launcher. LauncherItemDelegateManager does not create LauncherItemDelegates,
+// rather it is expected that someone else invokes SetLauncherItemDelegate
+// appropriately. On the other hand, LauncherItemDelegateManager destroys
+// LauncherItemDelegates when the corresponding item from the model is removed.
+class ASH_EXPORT LauncherItemDelegateManager
+    : public ash::LauncherModelObserver {
  public:
-  LauncherItemDelegateManager();
+  explicit LauncherItemDelegateManager(ash::LauncherModel* model);
   virtual ~LauncherItemDelegateManager();
 
-  // Returns LauncherItemDelegate for |item_type|.
-  // This class doesn't own each LauncherItemDelegate for now.
-  LauncherItemDelegate* GetLauncherItemDelegate(
-      ash::LauncherItemType item_type);
+  // Set |item_delegate| for |id| and take an ownership.
+  void SetLauncherItemDelegate(
+      ash::LauncherID id,
+      scoped_ptr<ash::LauncherItemDelegate> item_delegate);
+
+  // Returns LauncherItemDelegate for |item_type|. Always returns non-NULL.
+  LauncherItemDelegate* GetLauncherItemDelegate(ash::LauncherID id);
 
-  // Register |item_delegate| for |type|.
-  // For now, This class doesn't own |item_delegate|.
-  // TODO(simon.hong81): Register LauncherItemDelegate with LauncherID.
-  void RegisterLauncherItemDelegate(
-      ash::LauncherItemType type, LauncherItemDelegate* item_delegate);
+  // ash::LauncherModelObserver overrides:
+  virtual void LauncherItemAdded(int model_index) OVERRIDE;
+  virtual void LauncherItemRemoved(int index, ash::LauncherID id) OVERRIDE;
+  virtual void LauncherItemMoved(int start_index, int targetindex) OVERRIDE;
+  virtual void LauncherItemChanged(
+      int index,
+      const ash::LauncherItem& old_item) OVERRIDE;
+  virtual void LauncherStatusChanged() OVERRIDE;
 
  private:
-  typedef std::map<ash::LauncherItemType, LauncherItemDelegate*>
-      LauncherItemTypeToItemDelegateMap;
+  friend class ash::test::LauncherItemDelegateManagerTestAPI;
+
+  typedef std::map<ash::LauncherID, LauncherItemDelegate*>
+      LauncherIDToItemDelegateMap;
+
+  // Remove and destroy LauncherItemDelegate for |id|.
+  void RemoveLauncherItemDelegate(ash::LauncherID id);
+
+  // Clear all exsiting LauncherItemDelegate for test.
+  // Not owned by LauncherItemDelegate.
+  ash::LauncherModel* model_;
 
-  LauncherItemTypeToItemDelegateMap item_type_to_item_delegate_map_;
+  LauncherIDToItemDelegateMap id_to_item_delegate_map_;
 
   DISALLOW_COPY_AND_ASSIGN(LauncherItemDelegateManager);
 };
diff --git a/ash/launcher/launcher_unittest.cc b/ash/launcher/launcher_unittest.cc
index c1ea47b..c6a6672 100644
--- a/ash/launcher/launcher_unittest.cc
+++ b/ash/launcher/launcher_unittest.cc
@@ -6,7 +6,6 @@
 #include "ash/launcher/launcher_button.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_view.h"
-
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
diff --git a/ash/launcher/launcher_view.cc b/ash/launcher/launcher_view.cc
index 3491b1b..7d79a80 100644
--- a/ash/launcher/launcher_view.cc
+++ b/ash/launcher/launcher_view.cc
@@ -985,8 +985,8 @@ void LauncherView::PrepareForDrag(Pointer pointer,
 
   // 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;
   }
@@ -1003,8 +1003,8 @@ void LauncherView::ContinueDrag(const ui::LocatedEvent& event) {
   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;
   }
@@ -1531,9 +1531,9 @@ void LauncherView::PointerPressedOnButton(views::View* view,
     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();
@@ -1603,8 +1603,8 @@ base::string16 LauncherView::GetAccessibleName(const views::View* view) {
     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,
@@ -1663,8 +1663,9 @@ void LauncherView::ButtonPressed(views::Button* sender,
 
     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);
   }
@@ -1675,8 +1676,9 @@ bool LauncherView::ShowListMenuForView(const LauncherItem& item,
                                        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.
@@ -1709,10 +1711,11 @@ void LauncherView::ShowContextMenuForView(views::View* source,
   }
   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;
 
@@ -1867,8 +1870,8 @@ bool LauncherView::ShouldShowTooltipForView(const views::View* view) const {
   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 {
diff --git a/ash/launcher/launcher_view_unittest.cc b/ash/launcher/launcher_view_unittest.cc
index 4fc7d7a..1e35a9c 100644
--- a/ash/launcher/launcher_view_unittest.cc
+++ b/ash/launcher/launcher_view_unittest.cc
@@ -11,6 +11,7 @@
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_button.h"
 #include "ash/launcher/launcher_icon_observer.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/launcher_types.h"
@@ -24,6 +25,7 @@
 #include "ash/test/launcher_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_launcher_delegate.h"
+#include "ash/test/test_launcher_item_delegate.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ -212,6 +214,10 @@ class LauncherViewTest : public AshTestBase {
     test_api_.reset(new LauncherViewTestAPI(launcher_view_));
     test_api_->SetAnimationDuration(1);  // Speeds up animation for test.
 
+    item_manager_ =
+        ash::Shell::GetInstance()->launcher_item_delegate_manager();
+    DCHECK(item_manager_);
+
     // Add browser shortcut launcher item at index 0 for test.
     AddBrowserShortcut();
   }
@@ -222,12 +228,19 @@ class LauncherViewTest : public AshTestBase {
   }
 
  protected:
+  void CreateAndSetLauncherItemDelegateForID(LauncherID id) {
+    scoped_ptr<LauncherItemDelegate> delegate(
+        new ash::test::TestLauncherItemDelegate(NULL));
+    item_manager_->SetLauncherItemDelegate(id, delegate.Pass());
+  }
+
   LauncherID AddBrowserShortcut() {
     LauncherItem browser_shortcut;
     browser_shortcut.type = TYPE_BROWSER_SHORTCUT;
 
     LauncherID id = model_->next_id();
     model_->AddAt(browser_index_, browser_shortcut);
+    CreateAndSetLauncherItemDelegateForID(id);
     test_api_->RunMessageLoopUntilAnimationsDone();
     return id;
   }
@@ -239,6 +252,7 @@ class LauncherViewTest : public AshTestBase {
 
     LauncherID id = model_->next_id();
     model_->Add(item);
+    CreateAndSetLauncherItemDelegateForID(id);
     test_api_->RunMessageLoopUntilAnimationsDone();
     return id;
   }
@@ -256,6 +270,7 @@ class LauncherViewTest : public AshTestBase {
 
     LauncherID id = model_->next_id();
     model_->Add(item);
+    CreateAndSetLauncherItemDelegateForID(id);
     return id;
   }
 
@@ -266,6 +281,7 @@ class LauncherViewTest : public AshTestBase {
 
     LauncherID id = model_->next_id();
     model_->Add(item);
+    CreateAndSetLauncherItemDelegateForID(id);
     return id;
   }
 
@@ -386,6 +402,7 @@ class LauncherViewTest : public AshTestBase {
   LauncherModel* model_;
   internal::LauncherView* launcher_view_;
   int browser_index_;
+  LauncherItemDelegateManager* item_manager_;
 
   scoped_ptr<LauncherViewTestAPI> test_api_;
 
diff --git a/ash/shelf/app_list_shelf_item_delegate.cc b/ash/shelf/app_list_shelf_item_delegate.cc
index 615a381..231f68d 100644
--- a/ash/shelf/app_list_shelf_item_delegate.cc
+++ b/ash/shelf/app_list_shelf_item_delegate.cc
@@ -4,10 +4,8 @@
 
 #include "ash/shelf/app_list_shelf_item_delegate.h"
 
-#include "ash/launcher/launcher_item_delegate_manager.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/shell.h"
-#include "ash/shell_delegate.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
@@ -18,23 +16,18 @@ AppListShelfItemDelegate::AppListShelfItemDelegate() {
   LauncherItem app_list;
   app_list.type = TYPE_APP_LIST;
   Shell::GetInstance()->launcher_model()->Add(app_list);
-
-  ash::Shell::GetInstance()->launcher_item_delegate_manager()->
-      RegisterLauncherItemDelegate(ash::TYPE_APP_LIST, this);
 }
 
 AppListShelfItemDelegate::~AppListShelfItemDelegate() {
-  // Don't unregister this from LauncherItemDelegateManager.
-  // LauncherItemDelegateManager is already destroyed.
+  // LauncherItemDelegateManager owns and destroys this class.
 }
 
-void AppListShelfItemDelegate::ItemSelected(const LauncherItem& item,
-                                            const ui::Event& event) {
+void AppListShelfItemDelegate::ItemSelected(const ui::Event& event) {
   // Pass NULL here to show the app list in the currently active RootWindow.
   Shell::GetInstance()->ToggleAppList(NULL);
 }
 
-base::string16 AppListShelfItemDelegate::GetTitle(const LauncherItem& item) {
+base::string16 AppListShelfItemDelegate::GetTitle() {
   LauncherModel* model = Shell::GetInstance()->launcher_model();
   DCHECK(model);
   return model->status() == LauncherModel::STATUS_LOADING ?
@@ -43,23 +36,21 @@ base::string16 AppListShelfItemDelegate::GetTitle(const LauncherItem& item) {
 }
 
 ui::MenuModel* AppListShelfItemDelegate::CreateContextMenu(
-    const LauncherItem& item,
     aura::RootWindow* root_window) {
   return NULL;
 }
 
 LauncherMenuModel* AppListShelfItemDelegate::CreateApplicationMenu(
-    const LauncherItem& item,
     int event_flags) {
   // AppList does not show an application menu.
   return NULL;
 }
 
-bool AppListShelfItemDelegate::IsDraggable(const LauncherItem& item) {
+bool AppListShelfItemDelegate::IsDraggable() {
   return false;
 }
 
-bool AppListShelfItemDelegate::ShouldShowTooltip(const LauncherItem& item) {
+bool AppListShelfItemDelegate::ShouldShowTooltip() {
   return true;
 }
 
diff --git a/ash/shelf/app_list_shelf_item_delegate.h b/ash/shelf/app_list_shelf_item_delegate.h
index fe3c94e..2827599 100644
--- a/ash/shelf/app_list_shelf_item_delegate.h
+++ b/ash/shelf/app_list_shelf_item_delegate.h
@@ -20,17 +20,13 @@ class AppListShelfItemDelegate : public LauncherItemDelegate {
   virtual ~AppListShelfItemDelegate();
 
   // ash::LauncherItemDelegate overrides:
-  virtual void ItemSelected(const LauncherItem& item,
-                            const ui::Event& event) OVERRIDE;
-  virtual base::string16 GetTitle(const LauncherItem& item) OVERRIDE;
+  virtual void ItemSelected(const ui::Event& event) OVERRIDE;
+  virtual base::string16 GetTitle() OVERRIDE;
   virtual ui::MenuModel* CreateContextMenu(
-      const LauncherItem& item,
       aura::RootWindow* root_window) OVERRIDE;
-  virtual LauncherMenuModel* CreateApplicationMenu(
-      const LauncherItem& item,
-      int event_flags) OVERRIDE;
-  virtual bool IsDraggable(const LauncherItem& item) OVERRIDE;
-  virtual bool ShouldShowTooltip(const LauncherItem& item) OVERRIDE;
+  virtual LauncherMenuModel* CreateApplicationMenu(int event_flags) OVERRIDE;
+  virtual bool IsDraggable() OVERRIDE;
+  virtual bool ShouldShowTooltip() OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppListShelfItemDelegate);
diff --git a/ash/shell.cc b/ash/shell.cc
index bea797a..8fcfb6a 100644
--- a/ash/shell.cc
+++ b/ash/shell.cc
@@ -38,6 +38,7 @@
 #include "ash/session_state_delegate.h"
 #include "ash/shelf/app_list_shelf_item_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
+#include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
@@ -261,6 +262,9 @@ Shell::~Shell() {
   user_action_client_.reset();
   visibility_controller_.reset();
   launcher_delegate_.reset();
+  // |launcher_item_delegate_manager_| observes |launcher_model_|. It must be
+  // destroyed before |launcher_model_| is destroyed.
+  launcher_item_delegate_manager_.reset();
   launcher_model_.reset();
   video_detector_.reset();
 
@@ -817,13 +821,28 @@ SystemTray* Shell::GetPrimarySystemTray() {
 
 LauncherDelegate* Shell::GetLauncherDelegate() {
   if (!launcher_delegate_) {
-    // Creates LauncherItemDelegateManager before LauncherDelegate.
-    launcher_item_delegate_manager_.reset(new LauncherItemDelegateManager);
     launcher_model_.reset(new LauncherModel);
+    // Creates LauncherItemDelegateManager before LauncherDelegate.
+    launcher_item_delegate_manager_.reset(
+        new LauncherItemDelegateManager(launcher_model_.get()));
+
     launcher_delegate_.reset(
         delegate_->CreateLauncherDelegate(launcher_model_.get()));
-    app_list_shelf_item_delegate_.reset(
+    scoped_ptr<LauncherItemDelegate> controller(
         new internal::AppListShelfItemDelegate);
+
+    ash::LauncherID app_list_id = 0;
+    // TODO(simon.hong81): Make function for this in shelf_util.h
+    for (size_t i = 0; i < launcher_model_->items().size(); ++i) {
+      if (launcher_model_->items()[i].type == ash::TYPE_APP_LIST) {
+        app_list_id = launcher_model_->items()[i].id;
+        break;
+      }
+    }
+    DCHECK(app_list_id);
+    launcher_item_delegate_manager_->SetLauncherItemDelegate(
+        app_list_id,
+        controller.Pass());
   }
   return launcher_delegate_.get();
 }
diff --git a/ash/shell.h b/ash/shell.h
index b6caac1..d32ea24 100644
--- a/ash/shell.h
+++ b/ash/shell.h
@@ -75,6 +75,7 @@ class DisplayController;
 class HighContrastController;
 class Launcher;
 class LauncherDelegate;
+class LauncherItemDelegate;
 class LauncherItemDelegateManager;
 class LauncherModel;
 class MagnificationController;
@@ -101,7 +102,6 @@ class WindowSelectorController;
 namespace internal {
 class AcceleratorFilter;
 class AppListController;
-class AppListShelfItemDelegate;
 class CaptureController;
 class DisplayChangeObserver;
 class DisplayErrorObserver;
@@ -541,8 +541,6 @@ class ASH_EXPORT Shell
   scoped_ptr<SessionStateDelegate> session_state_delegate_;
   scoped_ptr<LauncherDelegate> launcher_delegate_;
   scoped_ptr<LauncherItemDelegateManager> launcher_item_delegate_manager_;
-  scoped_ptr<internal::AppListShelfItemDelegate>
-      app_list_shelf_item_delegate_;
 
   scoped_ptr<LauncherModel> launcher_model_;
 
diff --git a/ash/shell/launcher_delegate_impl.cc b/ash/shell/launcher_delegate_impl.cc
index 882431c..4ec47ae 100644
--- a/ash/shell/launcher_delegate_impl.cc
+++ b/ash/shell/launcher_delegate_impl.cc
@@ -4,67 +4,27 @@
 
 #include "ash/shell/launcher_delegate_impl.h"
 
-#include "ash/launcher/launcher_item_delegate_manager.h"
-#include "ash/shelf/shelf_util.h"
 #include "ash/shell.h"
 #include "ash/shell/toplevel_window.h"
 #include "ash/shell/window_watcher.h"
 #include "ash/wm/window_util.h"
 #include "base/strings/string_util.h"
 #include "grit/ash_resources.h"
-#include "ui/aura/window.h"
 
 namespace ash {
 namespace shell {
 
 LauncherDelegateImpl::LauncherDelegateImpl(WindowWatcher* watcher)
     : watcher_(watcher) {
-  ash::LauncherItemDelegateManager* manager =
-      ash::Shell::GetInstance()->launcher_item_delegate_manager();
-  manager->RegisterLauncherItemDelegate(ash::TYPE_APP_PANEL, this);
-  manager->RegisterLauncherItemDelegate(ash::TYPE_PLATFORM_APP, this);
 }
 
 LauncherDelegateImpl::~LauncherDelegateImpl() {
 }
 
-void LauncherDelegateImpl::ItemSelected(const ash::LauncherItem& item,
-                                       const ui::Event& event) {
-  aura::Window* window = watcher_->GetWindowByID(item.id);
-  if (window->type() == aura::client::WINDOW_TYPE_PANEL)
-    ash::wm::MoveWindowToEventRoot(window, event);
-  window->Show();
-  ash::wm::ActivateWindow(window);
-}
-
-base::string16 LauncherDelegateImpl::GetTitle(const ash::LauncherItem& item) {
-  return watcher_->GetWindowByID(item.id)->title();
-}
-
-ui::MenuModel* LauncherDelegateImpl::CreateContextMenu(
-    const ash::LauncherItem& item,
-    aura::RootWindow* root_window) {
-  return NULL;
-}
-
-ash::LauncherMenuModel* LauncherDelegateImpl::CreateApplicationMenu(
-    const ash::LauncherItem& item,
-    int event_flags) {
-  return NULL;
-}
-
 ash::LauncherID LauncherDelegateImpl::GetIDByWindow(aura::Window* window) {
   return watcher_ ? watcher_->GetIDByWindow(window) : 0;
 }
 
-bool LauncherDelegateImpl::IsDraggable(const ash::LauncherItem& item) {
-  return true;
-}
-
-bool LauncherDelegateImpl::ShouldShowTooltip(const ash::LauncherItem& item) {
-  return true;
-}
-
 void LauncherDelegateImpl::OnLauncherCreated(Launcher* launcher) {
 }
 
diff --git a/ash/shell/launcher_delegate_impl.h b/ash/shell/launcher_delegate_impl.h
index b6f7658..71c943d 100644
--- a/ash/shell/launcher_delegate_impl.h
+++ b/ash/shell/launcher_delegate_impl.h
@@ -6,7 +6,6 @@
 #define ASH_SHELL_LAUNCHER_DELEGATE_IMPL_H_
 
 #include "ash/launcher/launcher_delegate.h"
-#include "ash/launcher/launcher_item_delegate.h"
 #include "base/compiler_specific.h"
 
 namespace aura {
@@ -18,8 +17,7 @@ namespace shell {
 
 class WindowWatcher;
 
-class LauncherDelegateImpl : public ash::LauncherDelegate,
-                             public ash::LauncherItemDelegate {
+class LauncherDelegateImpl : public ash::LauncherDelegate {
  public:
   explicit LauncherDelegateImpl(WindowWatcher* watcher);
   virtual ~LauncherDelegateImpl();
@@ -37,19 +35,6 @@ class LauncherDelegateImpl : public ash::LauncherDelegate,
   virtual bool CanPin() const OVERRIDE;
   virtual void UnpinAppWithID(const std::string& app_id) OVERRIDE;
 
-  // LauncherItemDelegate overrides:
-  virtual void ItemSelected(const ash::LauncherItem& item,
-                           const ui::Event& event) OVERRIDE;
-  virtual base::string16 GetTitle(const ash::LauncherItem& item) OVERRIDE;
-  virtual ui::MenuModel* CreateContextMenu(
-      const ash::LauncherItem& item,
-      aura::RootWindow* root) OVERRIDE;
-  virtual ash::LauncherMenuModel* CreateApplicationMenu(
-      const ash::LauncherItem&,
-      int event_flags) OVERRIDE;
-  virtual bool IsDraggable(const ash::LauncherItem& item) OVERRIDE;
-  virtual bool ShouldShowTooltip(const LauncherItem& item) OVERRIDE;
-
  private:
   // Used to update Launcher. Owned by main.
   WindowWatcher* watcher_;
diff --git a/ash/shell/window_watcher.cc b/ash/shell/window_watcher.cc
index f076483..7c72e27 100644
--- a/ash/shell/window_watcher.cc
+++ b/ash/shell/window_watcher.cc
@@ -6,9 +6,11 @@
 
 #include "ash/display/display_controller.h"
 #include "ash/launcher/launcher.h"
+#include "ash/launcher/launcher_item_delegate_manager.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
+#include "ash/shell/window_watcher_launcher_item_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
@@ -108,7 +110,8 @@ void WindowWatcher::OnWindowAdded(aura::Window* new_window) {
   ash::LauncherItem item;
   item.type = new_window->type() == aura::client::WINDOW_TYPE_PANEL ?
       ash::TYPE_APP_PANEL : ash::TYPE_PLATFORM_APP;
-  id_to_window_[model->next_id()] = new_window;
+  ash::LauncherID id = model->next_id();
+  id_to_window_[id] = new_window;
 
   SkBitmap icon_bitmap;
   icon_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
@@ -121,6 +124,12 @@ void WindowWatcher::OnWindowAdded(aura::Window* new_window) {
   item.image = gfx::ImageSkia(gfx::ImageSkiaRep(icon_bitmap, 1.0f));
 
   model->Add(item);
+
+  ash::LauncherItemDelegateManager* manager =
+      ash::Shell::GetInstance()->launcher_item_delegate_manager();
+  scoped_ptr<LauncherItemDelegate> delegate(
+      new WindowWatcherLauncherItemDelegate(id, this));
+  manager->SetLauncherItemDelegate(id, delegate.Pass());
 }
 
 void WindowWatcher::OnWillRemoveWindow(aura::Window* window) {
diff --git a/ash/shell/window_watcher_launcher_item_delegate.cc b/ash/shell/window_watcher_launcher_item_delegate.cc
new file mode 100644
index 0000000..553b9fc
--- /dev/null
+++ b/ash/shell/window_watcher_launcher_item_delegate.cc
@@ -0,0 +1,58 @@
+// Copyright 2013 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/shell/window_watcher_launcher_item_delegate.h"
+
+#include "ash/shell/window_watcher.h"
+#include "ash/wm/window_util.h"
+#include "ui/aura/window.h"
+
+namespace ash {
+namespace shell {
+
+WindowWatcherLauncherItemDelegate::WindowWatcherLauncherItemDelegate(
+    ash::LauncherID id,
+    ash::shell::WindowWatcher* watcher)
+    : id_(id),
+      watcher_(watcher) {
+  DCHECK_GT(id_, 0);
+  DCHECK(watcher_);
+}
+
+WindowWatcherLauncherItemDelegate::~WindowWatcherLauncherItemDelegate() {
+}
+
+void WindowWatcherLauncherItemDelegate::ItemSelected(const ui::Event& event) {
+  aura::Window* window = watcher_->GetWindowByID(id_);
+  if (window->type() == aura::client::WINDOW_TYPE_PANEL)
+    ash::wm::MoveWindowToEventRoot(window, event);
+  window->Show();
+  ash::wm::ActivateWindow(window);
+}
+
+base::string16 WindowWatcherLauncherItemDelegate::GetTitle() {
+  return watcher_->GetWindowByID(id_)->title();
+}
+
+ui::MenuModel* WindowWatcherLauncherItemDelegate::CreateContextMenu(
+    aura::RootWindow* root_window) {
+  return NULL;
+}
+
+ash::LauncherMenuModel*
+WindowWatcherLauncherItemDelegate::CreateApplicationMenu(
+    int event_flags) {
+  return NULL;
+}
+
+bool WindowWatcherLauncherItemDelegate::IsDraggable() {
+  return true;
+}
+
+bool WindowWatcherLauncherItemDelegate::ShouldShowTooltip() {
+  return true;
+}
+
+}  // namespace shell
+}  // namespace ash
diff --git a/ash/shell/window_watcher_launcher_item_delegate.h b/ash/shell/window_watcher_launcher_item_delegate.h
new file mode 100644
index 0000000..e7d0b22
--- /dev/null
+++ b/ash/shell/window_watcher_launcher_item_delegate.h
@@ -0,0 +1,44 @@
+// Copyright 2013 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.
+
+#ifndef ASH_SHELL_WINDOW_WATCHER_LAUNCHER_ITEM_DELEGATE_
+#define ASH_SHELL_WINDOW_WATCHER_LAUNCHER_ITEM_DELEGATE_
+
+#include "ash/launcher/launcher_item_delegate.h"
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+
+namespace ash {
+namespace shell {
+
+class WindowWatcher;
+
+// LauncherItemDelegate implementation used by WindowWatcher.
+class WindowWatcherLauncherItemDelegate : public ash::LauncherItemDelegate {
+ public:
+  WindowWatcherLauncherItemDelegate(ash::LauncherID id,
+                                    ash::shell::WindowWatcher* watcher);
+  virtual ~WindowWatcherLauncherItemDelegate();
+
+  // ash::LauncherItemDelegate overrides:
+  virtual void ItemSelected(const ui::Event& event) OVERRIDE;
+  virtual base::string16 GetTitle() OVERRIDE;
+  virtual ui::MenuModel* CreateContextMenu(
+      aura::RootWindow* root_window) OVERRIDE;
+  virtual ash::LauncherMenuModel* CreateApplicationMenu(
+      int event_flags) OVERRIDE;
+  virtual bool IsDraggable() OVERRIDE;
+  virtual bool ShouldShowTooltip() OVERRIDE;
+
+ private:
+  ash::LauncherID id_;
+  ash::shell::WindowWatcher* watcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowWatcherLauncherItemDelegate);
+};
+
+}  // namespace shell
+}  // namespace ash
+
+#endif  // ASH_SHELL_WINDOW_WATCHER_LAUNCHER_ITEM_DELEGATE_
diff --git a/ash/test/launcher_item_delegate_manager_test_api.cc b/ash/test/launcher_item_delegate_manager_test_api.cc
new file mode 100644
index 0000000..159f7da
--- /dev/null
+++ b/ash/test/launcher_item_delegate_manager_test_api.cc
@@ -0,0 +1,29 @@
+// Copyright 2013 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/test/launcher_item_delegate_manager_test_api.h"
+
+#include "ash/launcher/launcher_item_delegate.h"
+#include "ash/launcher/launcher_item_delegate_manager.h"
+#include "base/stl_util.h"
+
+namespace ash {
+namespace test {
+
+LauncherItemDelegateManagerTestAPI::LauncherItemDelegateManagerTestAPI(
+    LauncherItemDelegateManager* manager)
+    : manager_(manager) {
+  DCHECK(manager_);
+}
+
+void
+LauncherItemDelegateManagerTestAPI::RemoveAllLauncherItemDelegateForTest() {
+  STLDeleteContainerPairSecondPointers(
+      manager_->id_to_item_delegate_map_.begin(),
+      manager_->id_to_item_delegate_map_.end());
+  manager_->id_to_item_delegate_map_.clear();
+}
+
+}  // namespace test
+}  // namespace ash
diff --git a/ash/test/launcher_item_delegate_manager_test_api.h b/ash/test/launcher_item_delegate_manager_test_api.h
new file mode 100644
index 0000000..d916a055
--- /dev/null
+++ b/ash/test/launcher_item_delegate_manager_test_api.h
@@ -0,0 +1,34 @@
+// Copyright 2013 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.
+
+#ifndef ASH_TEST_LAUNCHER_ITEM_DELEGATE_MANAGER_TEST_API_H_
+#define ASH_TEST_LAUNCHER_ITEM_DELEGATE_MANAGER_TEST_API_H_
+
+#include "base/basictypes.h"
+
+namespace ash {
+
+class LauncherItemDelegateManager;
+
+namespace test {
+
+// Accesses private methods from a LauncherItemDelegateManager for testing.
+class LauncherItemDelegateManagerTestAPI {
+ public:
+  explicit LauncherItemDelegateManagerTestAPI(
+      LauncherItemDelegateManager* manager);
+
+  // Clear all exsiting LauncherItemDelegate for test.
+  void RemoveAllLauncherItemDelegateForTest();
+
+ private:
+  LauncherItemDelegateManager* manager_;  // Not owned.
+
+  DISALLOW_COPY_AND_ASSIGN(LauncherItemDelegateManagerTestAPI);
+};
+
+}  // namespace test
+}  // namespace ash
+
+#endif  // ASH_TEST_LAUNCHER_ITEM_DELEGATE_MANAGER_TEST_API_H_
diff --git a/ash/test/test_launcher_delegate.cc b/ash/test/test_launcher_delegate.cc
index 508947e..98f1db0 100644
--- a/ash/test/test_launcher_delegate.cc
+++ b/ash/test/test_launcher_delegate.cc
@@ -8,7 +8,7 @@
 #include "ash/launcher/launcher_model.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shell.h"
-#include "ash/wm/window_util.h"
+#include "ash/test/test_launcher_item_delegate.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ash_resources.h"
@@ -23,14 +23,6 @@ TestLauncherDelegate::TestLauncherDelegate(LauncherModel* model)
     : model_(model) {
   CHECK(!instance_);
   instance_ = this;
-
-  ash::LauncherItemDelegateManager* manager =
-      ash::Shell::GetInstance()->launcher_item_delegate_manager();
-  manager->RegisterLauncherItemDelegate(ash::TYPE_APP_PANEL, this);
-  manager->RegisterLauncherItemDelegate(ash::TYPE_APP_SHORTCUT, this);
-  manager->RegisterLauncherItemDelegate(ash::TYPE_BROWSER_SHORTCUT, this);
-  manager->RegisterLauncherItemDelegate(ash::TYPE_PLATFORM_APP, this);
-  manager->RegisterLauncherItemDelegate(ash::TYPE_WINDOWED_APP, this);
 }
 
 TestLauncherDelegate::~TestLauncherDelegate() {
@@ -54,6 +46,13 @@ void TestLauncherDelegate::AddLauncherItem(
   item.status = status;
   model_->Add(item);
   window->AddObserver(this);
+
+  ash::LauncherItemDelegateManager* manager =
+      ash::Shell::GetInstance()->launcher_item_delegate_manager();
+  // |manager| owns TestLauncherItemDelegate.
+  scoped_ptr<LauncherItemDelegate> delegate(
+      new TestLauncherItemDelegate(window));
+  manager->SetLauncherItemDelegate(window_to_id_[window], delegate.Pass());
 }
 
 void TestLauncherDelegate::RemoveLauncherItemForWindow(aura::Window* window) {
@@ -80,32 +79,6 @@ void TestLauncherDelegate::OnWindowHierarchyChanging(
     RemoveLauncherItemForWindow(params.target);
 }
 
-void TestLauncherDelegate::ItemSelected(const ash::LauncherItem& item,
-                                       const ui::Event& event) {
-  aura::Window* window = GetWindowByID(item.id);
-  if (window->type() == aura::client::WINDOW_TYPE_PANEL)
-    ash::wm::MoveWindowToEventRoot(window, event);
-  window->Show();
-  ash::wm::ActivateWindow(window);
-}
-
-base::string16 TestLauncherDelegate::GetTitle(const ash::LauncherItem& item) {
-  aura::Window* window = GetWindowByID(item.id);
-  return window ? window->title() : base::string16();
-}
-
-ui::MenuModel* TestLauncherDelegate::CreateContextMenu(
-    const ash::LauncherItem& item,
-    aura::RootWindow* root) {
-  return NULL;
-}
-
-ash::LauncherMenuModel* TestLauncherDelegate::CreateApplicationMenu(
-    const ash::LauncherItem& item,
-    int event_flags) {
-  return NULL;
-}
-
 ash::LauncherID TestLauncherDelegate::GetIDByWindow(aura::Window* window) {
   WindowToID::const_iterator found = window_to_id_.find(window);
   if (found == window_to_id_.end())
@@ -113,24 +86,6 @@ ash::LauncherID TestLauncherDelegate::GetIDByWindow(aura::Window* window) {
   return found->second;
 }
 
-aura::Window* TestLauncherDelegate::GetWindowByID(ash::LauncherID id) {
-  for (WindowToID::const_iterator it = window_to_id_.begin();
-      it != window_to_id_.end();
-      it++) {
-    if (it->second == id)
-      return it->first;
-  }
-  return NULL;
-}
-
-bool TestLauncherDelegate::IsDraggable(const ash::LauncherItem& item) {
-  return true;
-}
-
-bool TestLauncherDelegate::ShouldShowTooltip(const ash::LauncherItem& item) {
-  return true;
-}
-
 void TestLauncherDelegate::OnLauncherCreated(Launcher* launcher) {
 }
 
diff --git a/ash/test/test_launcher_delegate.h b/ash/test/test_launcher_delegate.h
index 60e6d4f..4198665 100644
--- a/ash/test/test_launcher_delegate.h
+++ b/ash/test/test_launcher_delegate.h
@@ -9,7 +9,6 @@
 #include <set>
 
 #include "ash/launcher/launcher_delegate.h"
-#include "ash/launcher/launcher_item_delegate.h"
 #include "base/compiler_specific.h"
 #include "ui/aura/window_observer.h"
 
@@ -22,7 +21,6 @@ namespace test {
 // Test implementation of LauncherDelegate.
 // Tests may create icons for windows by calling AddLauncherItem
 class TestLauncherDelegate : public LauncherDelegate,
-                             public LauncherItemDelegate,
                              public aura::WindowObserver {
  public:
   explicit TestLauncherDelegate(LauncherModel* model);
@@ -50,26 +48,12 @@ class TestLauncherDelegate : public LauncherDelegate,
   virtual bool IsAppPinned(const std::string& app_id) OVERRIDE;
   virtual void UnpinAppWithID(const std::string& app_id) OVERRIDE;
 
-  // LauncherItemDelegate implementation.
-  virtual void ItemSelected(const LauncherItem& item,
-                           const ui::Event& event) OVERRIDE;
-  virtual base::string16 GetTitle(const LauncherItem& item) OVERRIDE;
-  virtual ui::MenuModel* CreateContextMenu(const LauncherItem& item,
-                                           aura::RootWindow* root) OVERRIDE;
-  virtual ash::LauncherMenuModel* CreateApplicationMenu(
-      const LauncherItem& item,
-      int event_flags) OVERRIDE;
-  virtual bool IsDraggable(const ash::LauncherItem& item) OVERRIDE;
-  virtual bool ShouldShowTooltip(const LauncherItem& item) OVERRIDE;
-
  private:
   typedef std::map<aura::Window*, ash::LauncherID> WindowToID;
   typedef std::set<aura::Window*> ObservedWindows;
 
   static TestLauncherDelegate* instance_;
 
-  aura::Window* GetWindowByID(ash::LauncherID id);
-
   LauncherModel* model_;
 
   // Maps from window to the id we gave it.
diff --git a/ash/test/test_launcher_item_delegate.cc b/ash/test/test_launcher_item_delegate.cc
new file mode 100644
index 0000000..9cb56bb
--- /dev/null
+++ b/ash/test/test_launcher_item_delegate.cc
@@ -0,0 +1,52 @@
+// Copyright 2013 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/test/test_launcher_item_delegate.h"
+
+#include "ash/wm/window_util.h"
+#include "ui/aura/window.h"
+
+namespace ash {
+namespace test {
+
+TestLauncherItemDelegate::TestLauncherItemDelegate(aura::Window* window)
+    : window_(window) {
+}
+
+TestLauncherItemDelegate::~TestLauncherItemDelegate() {
+}
+
+void TestLauncherItemDelegate::ItemSelected(const ui::Event& event) {
+  if (window_) {
+    if (window_->type() == aura::client::WINDOW_TYPE_PANEL)
+      ash::wm::MoveWindowToEventRoot(window_, event);
+    window_->Show();
+    ash::wm::ActivateWindow(window_);
+  }
+}
+
+base::string16 TestLauncherItemDelegate::GetTitle() {
+  return window_ ? window_->title() : base::string16();
+}
+
+ui::MenuModel* TestLauncherItemDelegate::CreateContextMenu(
+    aura::RootWindow* root_window) {
+  return NULL;
+}
+
+ash::LauncherMenuModel* TestLauncherItemDelegate::CreateApplicationMenu(
+    int event_flags) {
+  return NULL;
+}
+
+bool TestLauncherItemDelegate::IsDraggable() {
+  return true;
+}
+
+bool TestLauncherItemDelegate::ShouldShowTooltip() {
+  return true;
+}
+
+}  // namespace test
+}  // namespace ash
diff --git a/ash/test/test_launcher_item_delegate.h b/ash/test/test_launcher_item_delegate.h
new file mode 100644
index 0000000..138a772
--- /dev/null
+++ b/ash/test/test_launcher_item_delegate.h
@@ -0,0 +1,44 @@
+// Copyright 2013 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.
+
+#ifndef ASH_TEST_TEST_LAUNCHER_ITEM_DELEGATE_
+#define ASH_TEST_TEST_LAUNCHER_ITEM_DELEGATE_
+
+#include "ash/launcher/launcher_item_delegate.h"
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+
+namespace aura {
+class Window;
+}
+
+namespace ash {
+namespace test {
+
+// Test implementation of ash::LauncherItemDelegate.
+class TestLauncherItemDelegate : public ash::LauncherItemDelegate {
+ public:
+  explicit TestLauncherItemDelegate(aura::Window* window);
+  virtual ~TestLauncherItemDelegate();
+
+  // ash::LauncherItemDelegate overrides:
+  virtual void ItemSelected(const ui::Event& event) OVERRIDE;
+  virtual base::string16 GetTitle() OVERRIDE;
+  virtual ui::MenuModel* CreateContextMenu(
+      aura::RootWindow* root_window) OVERRIDE;
+  virtual ash::LauncherMenuModel* CreateApplicationMenu(
+      int event_flags) OVERRIDE;
+  virtual bool IsDraggable() OVERRIDE;
+  virtual bool ShouldShowTooltip() OVERRIDE;
+
+ private:
+  aura::Window* window_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestLauncherItemDelegate);
+};
+
+}  // namespace test
+}  // namespace ash
+
+#endif  // ASH_TEST_TEST_LAUNCHER_ITEM_DELEGATE_