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

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.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_IMPL_H_
 #define CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_IMPL_H_
 
 #include <list>
 #include <memory>
 
 #include "ash/common/shelf/shelf_item_delegate_manager.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 "build/build_config.h"
 #include "chrome/browser/ui/app_icon_loader.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_controller.h"
 #include "chrome/browser/ui/ash/launcher/launcher_app_updater.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "ui/aura/window_observer.h"
 
 class AppSyncUIState;
 class BrowserStatusMonitor;
 class LauncherControllerHelper;
 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;
 }
 
 namespace extensions {
 class Extension;
 }
 
 class ChromeLauncherControllerUserSwitchObserver;
 
 // Implementation of ChromeLauncherController, used for classic Ash.
 // In addition to implementing ChromeLauncherController, this class performs
 // a lot of other responsibilities, such as implementing ash::ShelfDelegate,
 // updating the UI state and the shelf model when apps are uninstalled, etc.
 class ChromeLauncherControllerImpl
     : public ChromeLauncherController,
       public ash::ShelfDelegate,
       public LauncherAppUpdater::Delegate,
       private ash::ShelfModelObserver,
       private ash::WindowTreeHostManager::Observer,
       private AppIconLoaderDelegate,
       private AppSyncUIStateObserver,
-      private ash::ShelfItemDelegateManagerObserver {
+      private ash::ShelfItemDelegateManagerObserver,
+      private app_list::AppListSyncableService::Observer {
  public:
   ChromeLauncherControllerImpl(Profile* profile, ash::ShelfModel* model);
   ~ChromeLauncherControllerImpl() override;
 
   // Create ChromeLauncherControllerImpl instance and set is as the
   // ChromeLauncherController singleton.
   static ChromeLauncherControllerImpl* CreateInstance(Profile* profile,
                                                       ash::ShelfModel* model);
 
   // ChromeLauncherController:
@@ skipping 21 matching lines @@
                  int event_flags) override;
   void ActivateApp(const std::string& app_id,
                    ash::LaunchSource source,
                    int event_flags) override;
   extensions::LaunchType GetLaunchType(ash::ShelfID id) override;
   void SetLauncherItemImage(ash::ShelfID shelf_id,
                             const gfx::ImageSkia& image) override;
   bool IsWindowedAppInLauncher(const std::string& app_id) override;
   void SetLaunchType(ash::ShelfID id,
                      extensions::LaunchType launch_type) override;
-  void PersistPinnedState() override;
   Profile* GetProfile() override;
   void UpdateAppState(content::WebContents* contents,
                       AppState app_state) override;
   ash::ShelfID GetShelfIDForWebContents(
       content::WebContents* contents) override;
   void SetRefocusURLPatternForTest(ash::ShelfID id, const GURL& url) override;
   const extensions::Extension* GetExtensionForAppID(
       const std::string& app_id) const override;
   ash::ShelfItemDelegate::PerformedAction ActivateWindowOrMinimizeIfActive(
       ui::BaseWindow* window,
@@ skipping 107 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);
-
-  // 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();
+  int FindInsertionPoint();
 
   // 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);
@@ skipping 19 matching lines @@
   // ash::WindowTreeHostManager::Observer:
   void OnDisplayConfigurationChanged() 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;
+
   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(ChromeLauncherControllerImpl);
 };
 
 #endif  // CHROME_BROWSER_UI_ASH_LAUNCHER_CHROME_LAUNCHER_CONTROLLER_IMPL_H_