Rename Launcher to Shelf.

chrome/browser/ui/ash/launcher/chrome_launcher_controller.h

 // 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 CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_H_
 #define CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 83 matching lines @@
                                  public ash::ShelfModelObserver,
                                  public ash::ShellObserver,
                                  public ash::DisplayController::Observer,
                                  public content::NotificationObserver,
                                  public extensions::AppIconLoader::Delegate,
                                  public PrefServiceSyncableObserver,
                                  public AppSyncUIStateObserver,
                                  public ExtensionEnableFlowDelegate,
                                  public ash::ShelfLayoutManagerObserver {
  public:
-  // Indicates if a launcher item is incognito or not.
+  // Indicates if a shelf item is incognito or not.
   enum IncognitoState {
     STATE_INCOGNITO,
     STATE_NOT_INCOGNITO,
   };
 
   // Used to update the state of non plaform apps, as web contents change.
   enum AppState {
     APP_STATE_ACTIVE,
     APP_STATE_WINDOW_ACTIVE,
     APP_STATE_INACTIVE,
@@ skipping 25 matching lines @@
   // Initializes this ChromeLauncherController.
   void Init();
 
   // Creates an instance.
   static ChromeLauncherController* CreateInstance(Profile* profile,
                                                   ash::ShelfModel* model);
 
   // Returns the single ChromeLauncherController instance.
   static ChromeLauncherController* instance() { return instance_; }
 
-  // Creates a new app item on the launcher for |controller|.
+  // Creates a new app item on the shelf for |controller|.
   ash::LauncherID CreateAppLauncherItem(LauncherItemController* controller,
                                         const std::string& app_id,
                                         ash::LauncherItemStatus status);
 
   // Updates the running status of an item. It will also update the status of
-  // browsers launcher item if needed.
+  // browsers shelf item if needed.
   void SetItemStatus(ash::LauncherID id, ash::LauncherItemStatus status);
 
   // Updates the controller associated with id (which should be a shortcut).
   // |controller| remains owned by caller.
   void SetItemController(ash::LauncherID id,
                          LauncherItemController* controller);
 
-  // Closes or unpins the launcher item.
+  // Closes or unpins the shelf item.
   void CloseLauncherItem(ash::LauncherID id);
 
   // Pins the specified id. Currently only supports platform apps.
   void Pin(ash::LauncherID id);
 
   // Unpins the specified id, closing if not running.
   void Unpin(ash::LauncherID id);
 
   // Returns true if the item identified by |id| is pinned.
   bool IsPinned(ash::LauncherID id);
 
   // Pins/unpins the specified id.
   void TogglePinned(ash::LauncherID id);
 
   // Returns true if the specified item can be pinned or unpinned. Only apps can
   // be pinned.
   bool IsPinnable(ash::LauncherID id) const;
 
-  // If there is no launcher item in the launcher for application |app_id|, one
-  // gets created. The (existing or created) launcher items get then locked
+  // If there is no shelf item in the shelf for application |app_id|, one
+  // gets created. The (existing or created) shelf items get then locked
   // against a users un-pinning removal.
   void LockV1AppWithID(const std::string& app_id);
 
-  // A previously locked launcher item of type |app_id| gets unlocked. If the
+  // A previously locked shelf item of type |app_id| gets unlocked. If the
   // lock count reaches 0 and the item is not pinned it will go away.
   void UnlockV1AppWithID(const std::string& app_id);
 
-  // Requests that the launcher item controller specified by |id| open a new
+  // Requests that the shelf item controller specified by |id| open a new
   // instance of the app.  |event_flags| holds the flags of the event which
   // triggered this command.
   void Launch(ash::LauncherID id, int event_flags);
 
   // Closes the specified item.
   void Close(ash::LauncherID id);
 
   // Returns true if the specified item is open.
   bool IsOpen(ash::LauncherID id);
 
   // Returns true if the specified item is for a platform app.
   bool IsPlatformApp(ash::LauncherID id);
 
   // Opens a new instance of the application identified by |app_id|.
-  // Used by the app-list, and by pinned-app launcher items.
+  // Used by the app-list, and by pinned-app shelf items.
   void LaunchApp(const std::string& app_id,
                  ash::LaunchSource source,
                  int event_flags);
 
   // If |app_id| is running, reactivates the app's most recently active window,
   // otherwise launches and activates the app.
-  // Used by the app-list, and by pinned-app launcher items.
+  // Used by the app-list, and by pinned-app shelf items.
   void ActivateApp(const std::string& app_id,
                    ash::LaunchSource source,
                    int event_flags);
 
   // Returns the launch type of app for the specified id.
   extensions::LaunchType GetLaunchType(ash::LauncherID id);
 
-  // Set the image for a specific launcher item (e.g. when set by the app).
+  // Set the image for a specific shelf item (e.g. when set by the app).
   void SetLauncherItemImage(ash::LauncherID launcher_id,
                             const gfx::ImageSkia& image);
 
   // Find out if the given application |id| is a windowed app item and not a
-  // pinned item in the launcher.
+  // pinned item in the shelf.
   bool IsWindowedAppInLauncher(const std::string& app_id);
 
   // Updates the launch type of the app for the specified id to |launch_type|.
   void SetLaunchType(ash::LauncherID id,
                      extensions::LaunchType launch_type);
 
   // Returns true if the user is currently logged in as a guest.
   // Makes virtual for unittest in LauncherContextMenuTest.
   virtual bool IsLoggedInAsGuest();
 
-  // Invoked when user clicks on button in the launcher and there is no last
+  // Invoked when user clicks on button in the shelf and there is no last
   // used window (or CTRL is held with the click).
   void CreateNewWindow();
 
-  // Invoked when the user clicks on button in the launcher to create a new
+  // Invoked when the user clicks on button in the shelf to create a new
   // incognito window.
   void CreateNewIncognitoWindow();
 
   // 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.
   void PersistPinnedState();
 
   ash::ShelfModel* model();
 
@@ skipping 31 matching lines @@
   // Returns the extension identified by |app_id|.
   const extensions::Extension* GetExtensionForAppID(
       const std::string& app_id) const;
 
   // Activates a |window|. If |allow_minimize| is true and the system allows
   // it, the the window will get minimized instead.
   void ActivateWindowOrMinimizeIfActive(ui::BaseWindow* window,
                                         bool allow_minimize);
 
   // ash::ShelfDelegate overrides:
-  virtual void OnLauncherCreated(ash::Launcher* launcher) OVERRIDE;
-  virtual void OnLauncherDestroyed(ash::Launcher* launcher) OVERRIDE;
+  virtual void OnShelfCreated(ash::Shelf* shelf) OVERRIDE;
+  virtual void OnShelfDestroyed(ash::Shelf* shelf) OVERRIDE;
   virtual ash::LauncherID GetLauncherIDForAppID(
       const std::string& app_id) OVERRIDE;
   virtual const std::string& GetAppIDForLauncherID(ash::LauncherID id) OVERRIDE;
   virtual void PinAppWithID(const std::string& app_id) OVERRIDE;
   virtual bool IsAppPinned(const std::string& app_id) OVERRIDE;
   virtual bool CanPin() const OVERRIDE;
   virtual void UnpinAppWithID(const std::string& app_id) OVERRIDE;
 
   // ash::ShelfModelObserver overrides:
   virtual void ShelfItemAdded(int index) OVERRIDE;
@@ skipping 84 matching lines @@
   BrowserStatusMonitor* browser_status_monitor_for_test() {
     return browser_status_monitor_.get();
   }
 
   // Access to the ShellWindowController for tests.
   ShellWindowLauncherController* shell_window_controller_for_test() {
     return shell_window_controller_.get();
   }
 
  protected:
-  // Creates a new app shortcut item and controller on the launcher at |index|.
+  // Creates a new app shortcut item and controller on the shelf at |index|.
   // Use kInsertItemAtEnd to add a shortcut as the last item.
   ash::LauncherID CreateAppShortcutLauncherItem(const std::string& app_id,
                                                 int index);
 
   // Sets the AppTabHelper/AppIconLoader, taking ownership of the helper class.
   // These are intended for testing.
   void SetAppTabHelperForTest(AppTabHelper* helper);
   void SetAppIconLoaderForTest(extensions::AppIconLoader* loader);
   const std::string& GetAppIdFromLauncherIdForTest(ash::LauncherID id);
 
   // Sets the ash::ShelfItemDelegateManager only for unittests and doesn't
   // take an ownership of it.
   void SetShelfItemDelegateManagerForTest(
       ash::ShelfItemDelegateManager* manager);
 
  private:
   friend class ChromeLauncherControllerTest;
   friend class LauncherAppBrowserTest;
   friend class LauncherPlatformAppBrowserTest;
 
   typedef std::map<ash::LauncherID, LauncherItemController*>
           IDToItemControllerMap;
   typedef std::list<content::WebContents*> WebContentsList;
   typedef std::map<std::string, WebContentsList> AppIDToWebContentsListMap;
   typedef std::map<content::WebContents*, std::string> WebContentsToAppIDMap;
 
-  // Creates a new app shortcut item and controller on the launcher at |index|.
+  // Creates a new app shortcut item and controller on the shelf at |index|.
   // Use kInsertItemAtEnd to add a shortcut as the last item.
   ash::LauncherID CreateAppShortcutLauncherItemWithType(
       const std::string& app_id,
       int index,
       ash::LauncherItemType launcher_item_type);
 
   // Invoked when the associated browser or app is closed.
   void LauncherItemClosed(ash::LauncherID id);
 
   // Internal helpers for pinning and unpinning that handle both
   // client-triggered and internal pinning operations.
   void DoPinAppWithID(const std::string& app_id);
   void DoUnpinAppWithID(const std::string& app_id);
 
   // Pin a running app with |launcher_id| internally to |index|. It returns
   // the index where the item was pinned.
   int PinRunningAppInternal(int index, ash::LauncherID launcher_id);
 
   // Unpin a locked application. This is an internal call which converts the
   // model type of the given app index from a shortcut into an unpinned running
   // app.
   void UnpinRunningAppInternal(int index);
 
-  // Re-syncs launcher model with prefs::kPinnedLauncherApps.
+  // Re-syncs shelf model with prefs::kPinnedLauncherApps.
   void UpdateAppLaunchersFromPref();
 
   // Persists the shelf auto-hide behavior to prefs.
   void SetShelfAutoHideBehaviorPrefs(ash::ShelfAutoHideBehavior behavior,
                                      aura::Window* root_window);
 
   // Sets the shelf auto-hide behavior from prefs.
   void SetShelfAutoHideBehaviorFromPrefs();
 
   // Sets the shelf alignment from prefs.
@@ skipping 103 matching lines @@
   scoped_ptr<extensions::AppIconLoader> app_icon_loader_;
 
   content::NotificationRegistrar notification_registrar_;
 
   PrefChangeRegistrar pref_change_registrar_;
 
   AppSyncUIState* app_sync_ui_state_;
 
   scoped_ptr<ExtensionEnableFlow> extension_enable_flow_;
 
-  // Launchers that are currently being observed.
-  std::set<ash::Launcher*> launchers_;
+  // Shelfs that are currently being observed.
+  std::set<ash::Shelf*> shelfs_;

[James Cook, 2013/12/16 23:34:52]

nit: shelfs_ -> shelves_.  English is such a weird language.

[tfarina, 2013/12/17 00:45:24]

Done.

 
   // The owned browser status monitor.
   scoped_ptr<BrowserStatusMonitor> browser_status_monitor_;
 
   // A special observer class to detect user switches.
   scoped_ptr<ChromeLauncherControllerUserSwitchObserver> user_switch_observer_;
 
   // If true, incoming pinned state changes should be ignored.
   bool ignore_persist_pinned_state_change_;
 
   // True if each user has an own desktop.
   bool multi_profile_desktop_separation_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherController);
 };
 
 #endif  // CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_H_