mash: Move LauncherItemController to ash, rename ShelfItemDelegate.

chrome/browser/ui/ash/launcher/browser_shortcut_launcher_item_controller.cc

 // Copyright (c) 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/browser_shortcut_launcher_item_controller.h"
 
 #include <limits>
 #include <vector>
 
 #include "ash/common/shelf/shelf_delegate.h"
@@ skipping 88 matching lines @@
 // Get the title for the browser list entry for |web_contents|.
 // If |web_contents| has not loaded, returns "New Tab".
 base::string16 GetBrowserListTitle(content::WebContents* web_contents) {
   const base::string16& title = web_contents->GetTitle();
   return title.empty() ? l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE) : title;
 }
 
 }  // namespace
 
 BrowserShortcutLauncherItemController::BrowserShortcutLauncherItemController(
-    ChromeLauncherController* launcher_controller,
     ash::ShelfModel* shelf_model)
-    : LauncherItemController(ash::AppLaunchId(extension_misc::kChromeAppId),
-                             launcher_controller),
+    : ash::ShelfItemDelegate(ash::AppLaunchId(extension_misc::kChromeAppId)),
       shelf_model_(shelf_model) {
   // Tag all open browser windows with the appropriate shelf id property. This
   // associates each window with the shelf item for the active web contents.
   for (auto* browser : *BrowserList::GetInstance()) {
     if (IsBrowserRepresentedInBrowserList(browser) &&
         browser->tab_strip_model()->GetActiveWebContents()) {
       SetShelfIDForBrowserWindowContents(
           browser, browser->tab_strip_model()->GetActiveWebContents());
     }
   }
@@ skipping 16 matching lines @@
     // a windowed app, a popup or any other item which is not a browser of
     // interest.
     Browser* browser = chrome::FindBrowserWithWindow(window);
     if (IsBrowserRepresentedInBrowserList(browser)) {
       browser_status = ash::STATUS_ACTIVE;
       // If an app that has item is running in active WebContents, browser item
       // status cannot be active.
       content::WebContents* contents =
           browser->tab_strip_model()->GetActiveWebContents();
       if (contents &&
-          (launcher_controller()->GetShelfIDForWebContents(contents) !=
-              browser_item.id))
+          (ChromeLauncherController::instance()->GetShelfIDForWebContents(
+               contents) != browser_item.id))
         browser_status = ash::STATUS_RUNNING;
     }
   }
 
   if (browser_status == ash::STATUS_CLOSED) {
     for (auto* browser : *BrowserList::GetInstance()) {
       if (IsBrowserRepresentedInBrowserList(browser)) {
         browser_status = ash::STATUS_RUNNING;
         break;
       }
     }
   }
 
   if (browser_status != browser_item.status) {
     browser_item.status = browser_status;
     shelf_model_->Set(browser_index, browser_item);
   }
 }
 
 void BrowserShortcutLauncherItemController::SetShelfIDForBrowserWindowContents(
     Browser* browser,
     content::WebContents* web_contents) {
   // We need to set the window ShelfID for V1 applications since they are
   // content which might change and as such change the application type.
-  if (!browser || !IsBrowserFromActiveUser(browser) ||
-      IsSettingsBrowser(browser))
+  // The browser window may not exist in unit tests.
+  if (!browser || !browser->window() || !browser->window()->GetNativeWindow() ||
+      !IsBrowserFromActiveUser(browser) || IsSettingsBrowser(browser)) {
     return;
+  }
 
   browser->window()->GetNativeWindow()->SetProperty(
       ash::kShelfIDKey,
-      launcher_controller()->GetShelfIDForWebContents(web_contents));
+      ChromeLauncherController::instance()->GetShelfIDForWebContents(
+          web_contents));
 }
 
 void BrowserShortcutLauncherItemController::ItemSelected(
     std::unique_ptr<ui::Event> event,
     int64_t display_id,
     ash::ShelfLaunchSource source,
     const ItemSelectedCallback& callback) {
   if (event && (event->flags() & ui::EF_CONTROL_DOWN)) {
-    chrome::NewEmptyWindow(launcher_controller()->profile());
+    chrome::NewEmptyWindow(ChromeLauncherController::instance()->profile());
     callback.Run(ash::SHELF_ACTION_NEW_WINDOW_CREATED, base::nullopt);
     return;
   }
 
-  MenuItemList items = GetAppMenuItems(event ? event->flags() : ui::EF_NONE);
+  ash::MenuItemList items =
+      GetAppMenuItems(event ? event->flags() : ui::EF_NONE);
 
   // In case of a keyboard event, we were called by a hotkey. In that case we
   // activate the next item in line if an item of our list is already active.
   if (event && event->type() == ui::ET_KEY_RELEASED) {
     callback.Run(ActivateOrAdvanceToNextBrowser(), std::move(items));
     return;
   }
 
-  Browser* last_browser =
-      chrome::FindTabbedBrowser(launcher_controller()->profile(), true);
+  Profile* profile = ChromeLauncherController::instance()->profile();
+  Browser* last_browser = chrome::FindTabbedBrowser(profile, true);
 
   if (!last_browser) {
-    chrome::NewEmptyWindow(launcher_controller()->profile());
+    chrome::NewEmptyWindow(profile);
     callback.Run(ash::SHELF_ACTION_NEW_WINDOW_CREATED, base::nullopt);
     return;
   }
 
   ash::ShelfAction action =
-      launcher_controller()->ActivateWindowOrMinimizeIfActive(
+      ChromeLauncherController::instance()->ActivateWindowOrMinimizeIfActive(
           last_browser->window(), items.size() == 1);
   callback.Run(action, std::move(items));
 }
 
-MenuItemList BrowserShortcutLauncherItemController::GetAppMenuItems(
+ash::MenuItemList BrowserShortcutLauncherItemController::GetAppMenuItems(
     int event_flags) {
   browser_menu_items_.clear();
   registrar_.RemoveAll();
 
-  MenuItemList items;
+  ash::MenuItemList items;
   bool found_tabbed_browser = false;
+  ChromeLauncherController* controller = ChromeLauncherController::instance();
   for (auto* browser : GetListOfActiveBrowsers()) {
     if (browser_menu_items_.size() >= kMaxItems)
       break;
     TabStripModel* tab_strip = browser->tab_strip_model();
     const int tab_index = tab_strip->active_index();
     if (tab_index < 0 || tab_index >= kMaxItems)
       continue;
     if (browser->is_type_tabbed())
       found_tabbed_browser = true;
     if (!(event_flags & ui::EF_SHIFT_DOWN)) {
       content::WebContents* tab = tab_strip->GetWebContentsAt(tab_index);
       ash::mojom::MenuItemPtr item(ash::mojom::MenuItem::New());
       item->command_id = GetCommandId(browser_menu_items_.size(), kNoTab);
       item->label = GetBrowserListTitle(tab);
       item->image = *GetBrowserListIcon(tab).ToSkBitmap();
       items.push_back(std::move(item));
     } else {
       for (uint16_t i = 0; i < tab_strip->count() && i < kMaxItems; ++i) {
         content::WebContents* tab = tab_strip->GetWebContentsAt(i);
         ash::mojom::MenuItemPtr item(ash::mojom::MenuItem::New());
         item->command_id = GetCommandId(browser_menu_items_.size(), i);
-        item->label = launcher_controller()->GetAppListTitle(tab);
-        item->image = *launcher_controller()->GetAppListIcon(tab).ToSkBitmap();
+        item->label = controller->GetAppListTitle(tab);
+        item->image = *controller->GetAppListIcon(tab).ToSkBitmap();
         items.push_back(std::move(item));
       }
     }
     browser_menu_items_.push_back(browser);
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSING,
                    content::Source<Browser>(browser));
   }
   // If only windowed applications are open, we return an empty list to
   // enforce the creation of a new browser.
   if (!found_tabbed_browser) {
@@ skipping 51 matching lines @@
   // We use the list in the order of how the browsers got created - not the LRU
   // order.
   const BrowserList* browser_list = BrowserList::GetInstance();
   for (BrowserList::const_iterator it = browser_list->begin();
        it != browser_list->end(); ++it) {
     if (IsBrowserRepresentedInBrowserList(*it))
       items.push_back(*it);
   }
   // If there are no suitable browsers we create a new one.
   if (items.empty()) {
-    chrome::NewEmptyWindow(launcher_controller()->profile());
+    chrome::NewEmptyWindow(ChromeLauncherController::instance()->profile());
     return ash::SHELF_ACTION_NEW_WINDOW_CREATED;
   }
   Browser* browser = chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow());
   if (items.size() == 1) {
     // If there is only one suitable browser, we can either activate it, or
     // bounce it (if it is already active).
     if (browser == items[0]) {
       AnimateWindow(browser->window()->GetNativeWindow(),
                     wm::WINDOW_ANIMATION_TYPE_BOUNCE);
       return ash::SHELF_ACTION_NONE;
     }
     browser = items[0];
   } else {
     // If there is more than one suitable browser, we advance to the next if
     // |browser| is already active - or - check the last used browser if it can
     // be used.
     std::vector<Browser*>::iterator i =
         std::find(items.begin(), items.end(), browser);
     if (i != items.end()) {
       browser = (++i == items.end()) ? items[0] : *i;
     } else {
-      browser =
-          chrome::FindTabbedBrowser(launcher_controller()->profile(), true);
+      browser = chrome::FindTabbedBrowser(
+          ChromeLauncherController::instance()->profile(), true);
       if (!browser || !IsBrowserRepresentedInBrowserList(browser))
         browser = items[0];
     }
   }
   DCHECK(browser);
   browser->window()->Show();
   browser->window()->Activate();
   return ash::SHELF_ACTION_WINDOW_ACTIVATED;
 }
 
@@ skipping 47 matching lines @@
   Browser* browser = content::Source<Browser>(source).ptr();
   DCHECK(browser);
   BrowserList::BrowserVector::iterator item = std::find(
       browser_menu_items_.begin(), browser_menu_items_.end(), browser);
   DCHECK(item != browser_menu_items_.end());
   // Clear the entry for the closed browser and leave other indices intact.
   *item = nullptr;
   registrar_.Remove(this, chrome::NOTIFICATION_BROWSER_CLOSING,
                     content::Source<Browser>(browser));
 }