arc: Support pinned apps across Arc-enabled and Arc-disabled platforms.

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 <memory>
 #include <string>
 #include <vector>
 
 #include "ash/common/shelf/shelf_item_delegate.h"
 #include "ash/common/shelf/shelf_item_delegate_manager.h"
 #include "ash/common/shelf/shelf_item_types.h"
 #include "ash/common/shelf/shelf_model_observer.h"
 #include "ash/common/shelf/shelf_types.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "build/build_config.h"
 #include "chrome/browser/ui/app_icon_loader.h"
 #include "chrome/browser/ui/app_list/app_list_controller_delegate.h"
+#include "chrome/browser/ui/app_list/app_list_syncable_service.h"
 #include "chrome/browser/ui/ash/app_sync_ui_state_observer.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_types.h"
 #include "chrome/browser/ui/ash/launcher/launcher_app_updater.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "extensions/common/constants.h"
 #include "ui/aura/window_observer.h"
 
 class AppSyncUIState;
 class ArcAppDeferredLauncherController;
 class Browser;
 class BrowserShortcutLauncherItemController;
 class BrowserStatusMonitor;
 class GURL;
 class LauncherControllerHelper;
 class LauncherItemController;
 class Profile;
 class AppWindowLauncherController;
 class TabContents;
 
 namespace ash {
-class ChromeLauncherPrefsObserver;
 class ShelfItemDelegateManager;
 class ShelfModel;
+namespace launcher {
+class ChromeLauncherPrefsObserver;
+}
 }
 
 namespace aura {
 class Window;
 }
 
 namespace content {
 class BrowserContext;
 class WebContents;
 }
@@ skipping 19 matching lines @@
 // * App windows have AppWindowLauncherItemController, owned by
 //   AppWindowLauncherController.
 // * Shortcuts have no LauncherItemController.
 class ChromeLauncherController
     : public ash::ShelfDelegate,
       public ash::ShelfModelObserver,
       public ash::WindowTreeHostManager::Observer,
       public AppIconLoaderDelegate,
       public AppSyncUIStateObserver,
       public LauncherAppUpdater::Delegate,
-      public ash::ShelfItemDelegateManagerObserver {
+      public ash::ShelfItemDelegateManagerObserver,
+      public app_list::AppListSyncableService::Observer {
  public:
   // 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,
     APP_STATE_REMOVED
   };
 
   ChromeLauncherController(Profile* profile, ash::ShelfModel* model);
@@ skipping 85 matching lines @@
   // Set the image for a specific shelf item (e.g. when set by the app).
   void SetLauncherItemImage(ash::ShelfID shelf_id, const gfx::ImageSkia& image);
 
   // Find out if the given application |id| is a windowed app item and not a
   // 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::ShelfID id, extensions::LaunchType launch_type);
 
-  // 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();
-
   // Accessor to the currently loaded profile. Note that in multi profile use
   // cases this might change over time.
   Profile* profile();
 
   // Notify the controller that the state of an non platform app's tabs
   // have changed,
   void UpdateAppState(content::WebContents* contents, AppState app_state);
 
   // Returns ShelfID for |contents|. If |contents| is not an app or is not
   // pinned, returns the id of browser shrotcut.
@@ skipping 50 matching lines @@
   void OnAppUninstalled(content::BrowserContext* browser_context,
                         const std::string& app_id) override;
 
   // AppSyncUIStateObserver:
   void OnAppSyncUIStatusChanged() override;
 
   // AppIconLoaderDelegate:
   void OnAppImageUpdated(const std::string& app_id,
                          const gfx::ImageSkia& image) override;
 
+  // app_list::AppListSyncableService::Observer:
+  void OnSyncModelUpdated() override;
+
   // Called when the active user has changed.
   void ActiveUserChanged(const std::string& user_email);
 
   // Called when a user got added to the session.
   void AdditionalUserAddedToSession(Profile* profile);
 
   // Get the list of all running incarnations of this item.
   // |event_flags| specifies the flags which were set by the event which
   // triggered this menu generation. It can be used to generate different lists.
   ChromeLauncherAppMenuItems GetApplicationList(const ash::ShelfItem& item,
@@ skipping 109 matching lines @@
 
   // Pin a running app with |shelf_id| internally to |index|. It returns
   // the index where the item was pinned.
   int PinRunningAppInternal(int index, ash::ShelfID shelf_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 shelf model with prefs::kPinnedLauncherApps.
+  // Updates pin position for the item specified by |id| in sync model.
+  void SyncPinPosition(ash::ShelfID id);
+
+  // Re-syncs shelf model.
   void UpdateAppLaunchersFromPref();
 
   // Sets the shelf auto-hide behavior from prefs.
   void SetShelfAutoHideBehaviorFromPrefs();
 
   // Sets the shelf alignment from prefs.
   void SetShelfAlignmentFromPrefs();
 
   // Sets both of auto-hide behavior and alignment from prefs.
   void SetShelfBehaviorsFromPrefs();
@@ skipping 18 matching lines @@
   // Enumerate all Web contents which match a given shortcut |controller|.
   std::vector<content::WebContents*> GetV1ApplicationsFromController(
       LauncherItemController* controller);
 
   // Create ShelfItem for Browser Shortcut.
   ash::ShelfID CreateBrowserShortcutLauncherItem();
 
   // Check if the given |web_contents| is in incognito mode.
   bool IsIncognito(const content::WebContents* web_contents) const;
 
-  // Update browser shortcut's index.
-  void PersistChromeItemIndex(int index);
-
-  // Depending on the provided flags, move either the chrome icon, the app icon
-  // or none to the given |target_index|. The provided |chrome_index| and
-  // |app_list_index| locations will get adjusted within this call to finalize
-  // the action and to make sure that the other item can still be moved
-  // afterwards (index adjustments).
-  void MoveChromeOrApplistToFinalPosition(
-      bool is_chrome,
-      bool is_app_list,
-      int target_index,
-      int* chrome_index,
-      int* app_list_index);
-
   // Finds the index of where to insert the next item.
-  int FindInsertionPoint(bool is_app_list);
+  int FindInsertionPoint();
 
   // Get the browser shortcut's index in the shelf using the current's systems
   // configuration of pinned and known (but not running) apps.
   int GetChromeIconIndexForCreation();
 
   // Close all windowed V1 applications of a certain extension which was already
   // deleted.
   void CloseWindowedAppsFromRemovedExtension(const std::string& app_id,
                                              const Profile* profile);
 
   // Set ShelfItemDelegate |item_delegate| for |id| and take an ownership.
   // TODO(simon.hong81): Make this take a scoped_ptr of |item_delegate|.
   void SetShelfItemDelegate(ash::ShelfID id,
                             ash::ShelfItemDelegate* item_delegate);
 
   // Attach to a specific profile.
   void AttachProfile(Profile* proifile);
 
   // Forget the current profile to allow attaching to a new one.
   void ReleaseProfile();
 
   AppIconLoader* GetAppIconLoaderForApp(const std::string& app_id);
 
   static ChromeLauncherController* instance_;
 
   ash::ShelfModel* model_;
 
-  ash::ShelfItemDelegateManager* item_delegate_manager_;
+  ash::ShelfItemDelegateManager* item_delegate_manager_ = nullptr;
 
   // Profile used for prefs and loading extensions. This is NOT necessarily the
   // profile new windows are created with.
   Profile* profile_;
 
   // Controller items in this map are owned by |ShelfItemDelegateManager|.
   IDToItemControllerMap id_to_item_controller_map_;
 
   // Direct access to app_id for a web contents.
   WebContentsToAppIDMap web_contents_to_app_id_;
 
   // Used to track app windows.
   std::vector<std::unique_ptr<AppWindowLauncherController>>
       app_window_controllers_;
 
   // Used to get app info for tabs.
   std::unique_ptr<LauncherControllerHelper> launcher_controller_helper_;
 
   // Used to load the images for app items.
   std::vector<std::unique_ptr<AppIconLoader>> app_icon_loaders_;
 
   // Used to handle app load/unload events.
   std::vector<std::unique_ptr<LauncherAppUpdater>> app_updaters_;
 
   PrefChangeRegistrar pref_change_registrar_;
 
-  AppSyncUIState* app_sync_ui_state_;
+  AppSyncUIState* app_sync_ui_state_ = nullptr;
 
   // The owned browser status monitor.
   std::unique_ptr<BrowserStatusMonitor> browser_status_monitor_;
 
   // A special observer class to detect user switches.
   std::unique_ptr<ChromeLauncherControllerUserSwitchObserver>
       user_switch_observer_;
 
-  std::unique_ptr<ash::ChromeLauncherPrefsObserver> prefs_observer_;
+  std::unique_ptr<ash::launcher::ChromeLauncherPrefsObserver> prefs_observer_;
 
   std::unique_ptr<ArcAppDeferredLauncherController> arc_deferred_launcher_;
 
   // If true, incoming pinned state changes should be ignored.
-  bool ignore_persist_pinned_state_change_;
+  bool ignore_persist_pinned_state_change_ = false;
 
   // The list of running & un-pinned applications for different users on hidden
   // desktops.
   typedef std::vector<std::string> RunningAppListIds;
   typedef std::map<std::string, RunningAppListIds> RunningAppListIdMap;
   RunningAppListIdMap last_used_running_application_order_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherController);
 };
 
 #endif  // CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_H_