ash: Replace launcher app type with Extension launch type.

chrome/browser/ui/views/ash/launcher/chrome_launcher_delegate.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_ASH_LAUNCHER_CHROME_LAUNCHER_DELEGATE_H_
 #define CHROME_BROWSER_UI_VIEWS_ASH_LAUNCHER_CHROME_LAUNCHER_DELEGATE_H_
 #pragma once
 
 #include <map>
 #include <queue>
 #include <string>
 
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_model_observer.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/wm/shelf_auto_hide_behavior.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
+#include "chrome/browser/extensions/extension_prefs.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 namespace ash {
 class LauncherModel;
 }
 
 class LauncherUpdater;
 class LauncherUpdaterTest;
 class PrefService;
 class Profile;
 class TabContentsWrapper;
 
 // ChromeLauncherDelegate manages the launcher items needed for tabbed browsers
 // and apps. It does this by way of LauncherUpdaters.
 // TODO: rename this. ChromeLauncherDelegate is a poor name for what it actually
 // does.
 class ChromeLauncherDelegate : public ash::LauncherDelegate,
                                public ash::LauncherModelObserver,
                                public content::NotificationObserver {
  public:
-  // Indicates what should happen when the app is launched.
-  enum AppType {
-    APP_TYPE_WINDOW,
-    APP_TYPE_APP_PANEL,  // Panel opened from the app list.
-    APP_TYPE_EXTENSION_PANEL,  // Panel opened by an extension.
-    APP_TYPE_TAB
-  };
-
   // Indicates if a launcher item is incognito or not.
   enum IncognitoState {
     STATE_INCOGNITO,
     STATE_NOT_INCOGNITO,
   };
 
   // Interface used to load app icons. This is in it's own class so that it can
   // be mocked.
   class AppIconLoader {
    public:
@@ skipping 26 matching lines @@
 
   // Creates a new tabbed item on the launcher for |updater|.
   ash::LauncherID CreateTabbedLauncherItem(LauncherUpdater* updater,
                                            IncognitoState is_incognito,
                                            ash::LauncherItemStatus status);
 
   // Creates a new app item on the launcher for |updater|. If there is an
   // existing pinned app that isn't running on the launcher, its id is returned.
   ash::LauncherID CreateAppLauncherItem(LauncherUpdater* updater,
                                         const std::string& app_id,
-                                        AppType app_type,
                                         ash::LauncherItemStatus status);
 
   // Updates the running status of an item.
   void SetItemStatus(ash::LauncherID id, ash::LauncherItemStatus status);
 
   // Invoked when the underlying browser/app is closed.
   void LauncherItemClosed(ash::LauncherID id);
 
   // Unpins the specified id, closing if not running.
   void Unpin(ash::LauncherID id);
@@ skipping 10 matching lines @@
 
   // Opens the specified item.
   void Open(ash::LauncherID id);
 
   // Closes the specified item.
   void Close(ash::LauncherID id);
 
   // Returns true if the specified item is open.
   bool IsOpen(ash::LauncherID id);
 
-  // Returns the type of app for the specified id.
-  AppType GetAppType(ash::LauncherID id);
+  // Returns the launch type of app for the specified id.
+  ExtensionPrefs::LaunchType GetLaunchType(ash::LauncherID id);
 
   // Returns the id of the app for the specified tab.
   std::string GetAppID(TabContentsWrapper* tab);
 
   // Sets the image for an app tab. This is intended to be invoked from the
   // AppIconLoader.
   void SetAppImage(const std::string& app_id, const SkBitmap* image);
 
   // Returns true if a pinned launcher item with given |app_id| could be found.
   bool IsAppPinned(const std::string& app_id);
 
   // Pins an app with |app_id| to launcher. If there is a running instance in
   // launcher, the running instance is pinned. If there is no running instance,
-  // a new launcher item is created with |app_type| and pinned.
-  void PinAppWithID(const std::string& app_id, AppType app_type);
+  // a new launcher item is created and pinned.
+  void PinAppWithID(const std::string& app_id);
 
-  // Modifies an app shortcut to open with the new |app_type|.
-  void SetAppType(ash::LauncherID id, AppType app_type);
+  // Updates the launche type of the app for the specified id to |launch_type|.
+  void SetLaunchType(ash::LauncherID id,
+                     ExtensionPrefs::LaunchType launch_type);
 
   // Unpins any app items whose id is |app_id|.
   void UnpinAppsWithID(const std::string& app_id);
 
   ash::LauncherModel* model() { return model_; }
 
   Profile* profile() { return profile_; }
 
   void SetAutoHideBehavior(ash::ShelfAutoHideBehavior behavior);
 
@@ skipping 31 matching lines @@
   // Used to identity an item on the launcher.
   struct Item {
     Item();
     ~Item();
 
     bool is_pinned() const { return updater == NULL; }
 
     // Type of item.
     ItemType item_type;
 
-    // If |item_type| is |TYPE_APP|, this identifies how the app is launched.
-    AppType app_type;
-
     // ID of the app.
     std::string app_id;
 
     // The LauncherUpdater this item came from. NULL if a shortcut.
     LauncherUpdater* updater;
   };
 
   typedef std::map<ash::LauncherID, Item> IDToItemMap;
 
   // Updates the pinned pref state. The pinned state consists of a list pref.
   // Each item of the list is a dictionary. The key |kAppIDPath| gives the
-  // id of the app. |kAppTypePath| is one of |kAppTypeTab| or |kAppTypeWindow|
-  // and indicates how the app is opened.
+  // id of the app.
   void PersistPinnedState();
 
   // Sets the AppIconLoader, taking ownership of |loader|. This is intended for
   // testing.
   void SetAppIconLoaderForTest(AppIconLoader* loader);
 
   // Returns the profile used for new windows.
   Profile* GetProfileForNewWindows();
 
   // Checks |pending_pinnned_apps_| list and creates pinned app items for apps
@@ skipping 19 matching lines @@
   // are installed (via sync or external extension provider.) The order of the
   // list reflects the original order in pinned app list.
   std::queue<Item> pending_pinned_apps_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherDelegate);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_ASH_LAUNCHER_CHROME_LAUNCHER_DELEGATE_H_