Revert 226547 "Refactor LauncherItemController and LauncherItemD..."

trunk/src/chrome/browser/ui/ash/launcher/chrome_launcher_controller.cc

 // 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller.h"
@@ skipping 25 matching lines @@
 #include "chrome/browser/ui/ash/app_sync_ui_state.h"
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/browser/ui/ash/launcher/app_shortcut_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_shortcut_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_status_monitor.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item_browser.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item_tab.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_types.h"
 #include "chrome/browser/ui/ash/launcher/launcher_app_tab_helper.h"
+#include "chrome/browser/ui/ash/launcher/launcher_application_menu_item_model.h"
+#include "chrome/browser/ui/ash/launcher/launcher_context_menu.h"
 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/shell_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/shell_window_launcher_item_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
@@ skipping 18 matching lines @@
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/url_util.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/views/corewm/window_animations.h"
 
 #if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/login/default_pinned_apps_field_trial.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/wallpaper_manager.h"
 #include "chrome/browser/ui/ash/chrome_shell_delegate.h"
 #endif
 
 using extensions::Extension;
 using extension_misc::kGmailAppId;
 using content::WebContents;
 
 // static
@@ skipping 152 matching lines @@
   // and wallpapers are not synchronized across multiple desktops.
   if (chromeos::WallpaperManager::Get())
     chromeos::WallpaperManager::Get()->SetUserWallpaper(user_email);
 }
 #endif
 
 ChromeLauncherController::ChromeLauncherController(
     Profile* profile,
     ash::LauncherModel* model)
     : model_(model),
-      item_delegate_manager_(NULL),
       profile_(profile),
       app_sync_ui_state_(NULL),
       ignore_persist_pinned_state_change_(false) {
   if (!profile_) {
     // Use the original profile as on chromeos we may get a temporary off the
     // record profile.
     profile_ = ProfileManager::GetDefaultProfile()->GetOriginalProfile();
 
     app_sync_ui_state_ = AppSyncUIState::Get(profile_);
     if (app_sync_ui_state_)
       app_sync_ui_state_->AddObserver(this);
   }
 
   // All profile relevant settings get bound to the current profile.
   AttachProfile(profile_);
 
   browser_status_monitor_.reset(new BrowserStatusMonitor(this));
   model_->AddObserver(this);
   // Right now ash::Shell isn't created for tests.
   // TODO(mukai): Allows it to observe display change and write tests.
-  if (ash::Shell::HasInstance()) {
+  if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->display_controller()->AddObserver(this);
-    item_delegate_manager_ =
-        ash::Shell::GetInstance()->launcher_item_delegate_manager();
-  }
   // TODO(stevenjb): Find a better owner for shell_window_controller_?
   shell_window_controller_.reset(new ShellWindowLauncherController(this));
 
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_EXTENSION_LOADED,
                               content::Source<Profile>(profile_));
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_EXTENSION_UNLOADED,
                               content::Source<Profile>(profile_));
 
+  // This check is needed for win7_aura. Without this, all tests in
+  // ChromeLauncherControllerTest will fail by win7_aura.
+  if (ash::Shell::HasInstance())
+    RegisterLauncherItemDelegate();
+
 #if defined(OS_CHROMEOS)
   // On Chrome OS using multi profile we want to switch the content of the shelf
   // with a user change. Note that for unit tests the instance can be NULL.
   if (ChromeShellDelegate::instance() &&
       ChromeShellDelegate::instance()->IsMultiProfilesEnabled()) {
     user_switch_observer_.reset(
         new ChromeLauncherControllerUserSwitchObserverChromeOS(this));
   }
 #endif
 }
 
 ChromeLauncherController::~ChromeLauncherController() {
   // Reset the BrowserStatusMonitor as it has a weak pointer to this.
   browser_status_monitor_.reset();
 
   // Reset the shell window controller here since it has a weak pointer to this.
   shell_window_controller_.reset();
 
   for (std::set<ash::Launcher*>::iterator iter = launchers_.begin();
        iter != launchers_.end();
        ++iter)
     (*iter)->shelf_widget()->shelf_layout_manager()->RemoveObserver(this);
 
   model_->RemoveObserver(this);
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->display_controller()->RemoveObserver(this);
   for (IDToItemControllerMap::iterator i = id_to_item_controller_map_.begin();
        i != id_to_item_controller_map_.end(); ++i) {
+    i->second->OnRemoved();
     int index = model_->ItemIndexByID(i->first);
     // A "browser proxy" is not known to the model and this removal does
     // therefore not need to be propagated to the model.
     if (index != -1 &&
         model_->items()[index].type != ash::TYPE_BROWSER_SHORTCUT)
       model_->RemoveItemAt(index);
   }
 
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->RemoveShellObserver(this);
@@ skipping 64 matching lines @@
     model_->Set(index, item);
   }
 }
 
 void ChromeLauncherController::SetItemController(
     ash::LauncherID id,
     LauncherItemController* controller) {
   CHECK(controller);
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   CHECK(iter != id_to_item_controller_map_.end());
+  iter->second->OnRemoved();
+  iter->second = controller;
   controller->set_launcher_id(id);
-  iter->second = controller;
-  // Existing controller is destroyed and replaced by registering again.
-  SetLauncherItemDelegate(id, controller);
 }
 
 void ChromeLauncherController::CloseLauncherItem(ash::LauncherID id) {
   CHECK(id);
   if (IsPinned(id)) {
     // Create a new shortcut controller.
     IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
     CHECK(iter != id_to_item_controller_map_.end());
     SetItemStatus(id, ash::STATUS_CLOSED);
     std::string app_id = iter->second->app_id();
+    iter->second->OnRemoved();
     iter->second = new AppShortcutLauncherItemController(app_id, this);
     iter->second->set_launcher_id(id);
-    // Existing controller is destroyed and replaced by registering again.
-    SetLauncherItemDelegate(id, iter->second);
   } else {
     LauncherItemClosed(id);
   }
 }
 
 void ChromeLauncherController::Pin(ash::LauncherID id) {
   DCHECK(HasItemController(id));
 
   int index = model_->ItemIndexByID(id);
   DCHECK_GE(index, 0);
@@ skipping 503 matching lines @@
                     views::corewm::WINDOW_ANIMATION_TYPE_BOUNCE);
     } else {
       window->Minimize();
     }
   } else {
     window->Show();
     window->Activate();
   }
 }
 
+void ChromeLauncherController::ItemSelected(const ash::LauncherItem& item,
+                                            const ui::Event& event) {
+  DCHECK(HasItemController(item.id));
+  LauncherItemController* item_controller = id_to_item_controller_map_[item.id];
+#if defined(OS_CHROMEOS)
+  if (!item_controller->app_id().empty()) {
+    chromeos::default_pinned_apps_field_trial::RecordShelfAppClick(
+        item_controller->app_id());
+  }
+#endif
+  item_controller->Clicked(event);
+}
+
+string16 ChromeLauncherController::GetTitle(const ash::LauncherItem& item) {
+  DCHECK(HasItemController(item.id));
+  return id_to_item_controller_map_[item.id]->GetTitle();
+}
+
+ui::MenuModel* ChromeLauncherController::CreateContextMenu(
+    const ash::LauncherItem& item,
+    aura::RootWindow* root_window) {
+  return new LauncherContextMenu(this, &item, root_window);
+}
+
+ash::LauncherMenuModel* ChromeLauncherController::CreateApplicationMenu(
+    const ash::LauncherItem& item,
+    int event_flags) {
+  return new LauncherApplicationMenuItemModel(GetApplicationList(item,
+                                                                 event_flags));
+}
+
 ash::LauncherID ChromeLauncherController::GetIDByWindow(aura::Window* window) {
   int browser_index = ash::GetBrowserItemIndex(*model_);
   DCHECK_GE(browser_index, 0);
   ash::LauncherID browser_id = model_->items()[browser_index].id;
 
   IDToItemControllerMap::const_iterator i = id_to_item_controller_map_.begin();
   for (; i != id_to_item_controller_map_.end(); ++i) {
     // Since a |window| can be used by multiple applications, an explicit
     // application always gets chosen over the generic browser.
     if (i->first != browser_id && i->second->IsCurrentlyShownInWindow(window))
       return i->first;
   }
 
   if (i == id_to_item_controller_map_.end() &&
       GetBrowserShortcutLauncherItemController()->
           IsCurrentlyShownInWindow(window))
     return browser_id;
 
   return 0;
 }
 
+bool ChromeLauncherController::IsDraggable(const ash::LauncherItem& item) {
+  return (item.type == ash::TYPE_APP_SHORTCUT ||
+          item.type == ash::TYPE_WINDOWED_APP) ? CanPin() : true;
+}
+
+bool ChromeLauncherController::ShouldShowTooltip(
+    const ash::LauncherItem& item) {
+  if (item.type == ash::TYPE_APP_PANEL &&
+      id_to_item_controller_map_[item.id]->IsVisible())
+    return false;
+  return true;
+}
+
 void ChromeLauncherController::OnLauncherCreated(ash::Launcher* launcher) {
   launchers_.insert(launcher);
   launcher->shelf_widget()->shelf_layout_manager()->AddObserver(this);
 }
 
 void ChromeLauncherController::OnLauncherDestroyed(ash::Launcher* launcher) {
   launchers_.erase(launcher);
   // RemoveObserver is not called here, since by the time this method is called
   // Launcher is already in its destructor.
 }
@@ skipping 259 matching lines @@
 void ChromeLauncherController::SetAppIconLoaderForTest(
     extensions::AppIconLoader* loader) {
   app_icon_loader_.reset(loader);
 }
 
 const std::string& ChromeLauncherController::GetAppIdFromLauncherIdForTest(
     ash::LauncherID id) {
   return id_to_item_controller_map_[id]->app_id();
 }
 
-void ChromeLauncherController::SetLauncherItemDelegateManagerForTest(
-    ash::LauncherItemDelegateManager* manager) {
-  item_delegate_manager_ = manager;
-}
-
 ash::LauncherID ChromeLauncherController::CreateAppShortcutLauncherItemWithType(
     const std::string& app_id,
     int index,
     ash::LauncherItemType launcher_item_type) {
   AppShortcutLauncherItemController* controller =
       new AppShortcutLauncherItemController(app_id, this);
   ash::LauncherID launcher_id = InsertAppLauncherItem(
       controller, app_id, ash::STATUS_CLOSED, index, launcher_item_type);
   return launcher_id;
 }
 
-LauncherItemController* ChromeLauncherController::GetLauncherItemController(
-    const ash::LauncherID id) {
-  if (!HasItemController(id))
-    return NULL;
-  return id_to_item_controller_map_[id];
-}
-
 Profile* ChromeLauncherController::GetProfileForNewWindows() {
   return ProfileManager::GetDefaultProfileOrOffTheRecord();
 }
 
 void ChromeLauncherController::LauncherItemClosed(ash::LauncherID id) {
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   CHECK(iter != id_to_item_controller_map_.end());
   CHECK(iter->second);
   app_icon_loader_->ClearImage(iter->second->app_id());
+  iter->second->OnRemoved();
   id_to_item_controller_map_.erase(iter);
   int index = model_->ItemIndexByID(id);
   // A "browser proxy" is not known to the model and this removal does
   // therefore not need to be propagated to the model.
   if (index != -1)
     model_->RemoveItemAt(index);
 }
 
 void ChromeLauncherController::DoPinAppWithID(const std::string& app_id) {
   // If there is an item, do nothing and return.
@@ skipping 297 matching lines @@
       status = ash::STATUS_ACTIVE;
     else
       status = ash::STATUS_RUNNING;
   }
   item.status = status;
 
   model_->AddAt(index, item);
 
   app_icon_loader_->FetchImage(app_id);
 
-  SetLauncherItemDelegate(id, controller);
-
   return id;
 }
 
 bool ChromeLauncherController::HasItemController(ash::LauncherID id) const {
   return id_to_item_controller_map_.find(id) !=
          id_to_item_controller_map_.end();
 }
 
 std::vector<content::WebContents*>
 ChromeLauncherController::GetV1ApplicationsFromController(
@@ skipping 22 matching lines @@
 }
 
 ash::LauncherID ChromeLauncherController::CreateBrowserShortcutLauncherItem() {
   ash::LauncherItem browser_shortcut;
   browser_shortcut.type = ash::TYPE_BROWSER_SHORTCUT;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   browser_shortcut.image = *rb.GetImageSkiaNamed(IDR_PRODUCT_LOGO_32);
   ash::LauncherID id = model_->next_id();
   size_t index = GetChromeIconIndexForCreation();
   model_->AddAt(index, browser_shortcut);
-  id_to_item_controller_map_[id] =
-      new BrowserShortcutLauncherItemController(this);
+  browser_item_controller_.reset(
+      new BrowserShortcutLauncherItemController(this));
+  id_to_item_controller_map_[id] = browser_item_controller_.get();
   id_to_item_controller_map_[id]->set_launcher_id(id);
-  // LauncherItemDelegateManager owns BrowserShortcutLauncherItemController.
-  SetLauncherItemDelegate(id, id_to_item_controller_map_[id]);
   return id;
 }
 
 void ChromeLauncherController::PersistChromeItemIndex(int index) {
   profile_->GetPrefs()->SetInteger(prefs::kShelfChromeIconIndex, index);
 }
 
 int ChromeLauncherController::GetChromeIconIndexFromPref() const {
   size_t index = profile_->GetPrefs()->GetInteger(prefs::kShelfChromeIconIndex);
   const base::ListValue* pinned_apps_pref =
@@ skipping 154 matching lines @@
       browser_to_close.push_back(browser);
     }
   }
   while (!browser_to_close.empty()) {
     TabStripModel* tab_strip = browser_to_close.back()->tab_strip_model();
     tab_strip->CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
     browser_to_close.pop_back();
   }
 }
 
-void ChromeLauncherController::SetLauncherItemDelegate(
-    ash::LauncherID id,
-    ash::LauncherItemDelegate* item_delegate) {
-  DCHECK_GT(id, 0);
-  DCHECK(item_delegate);
-  DCHECK(item_delegate_manager_);
-  item_delegate_manager_->SetLauncherItemDelegate(id,
-      scoped_ptr<ash::LauncherItemDelegate>(item_delegate).Pass());
+void ChromeLauncherController::RegisterLauncherItemDelegate() {
+  // TODO(simon.hong81): Register LauncherItemDelegate when LauncherItemDelegate
+  // is created.
+  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);
 }
 
 void ChromeLauncherController::AttachProfile(Profile* profile) {
   profile_ = profile;
   // Either add the profile to the list of known profiles and make it the active
   // one for some functions of AppTabHelper or create a new one.
   if (!app_tab_helper_.get())
     app_tab_helper_.reset(new LauncherAppTabHelper(profile_));
   else
     app_tab_helper_->SetCurrentUser(profile_);
@@ skipping 26 matching lines @@
 }
 
 void ChromeLauncherController::ReleaseProfile() {
   if (app_sync_ui_state_)
     app_sync_ui_state_->RemoveObserver(this);
 
   PrefServiceSyncable::FromProfile(profile_)->RemoveObserver(this);
 
   pref_change_registrar_.RemoveAll();
 }