[Merge-M54] arc: Add support of default and OEM apps.

chrome/browser/ui/app_list/arc/arc_app_list_prefs.h

 // Copyright 2015 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_APP_LIST_ARC_ARC_APP_LIST_PREFS_H_
 #define CHROME_BROWSER_UI_APP_LIST_ARC_ARC_APP_LIST_PREFS_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/arc/arc_auth_service.h"
+#include "chrome/browser/ui/app_list/arc/arc_default_app_list.h"
 #include "components/arc/common/app.mojom.h"
 #include "components/arc/instance_holder.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "ui/base/layout.h"
 
 class PrefService;
 class Profile;
 
 namespace arc {
@@ skipping 10 matching lines @@
 
 // Declares shareable ARC app specific preferences, that keep information
 // about app attributes (name, package_name, activity) and its state. This
 // information is used to pre-create non-ready app items while ARC bridge
 // service is not ready to provide information about available ARC apps.
 // NOTE: ArcAppListPrefs is only created for the primary user.
 class ArcAppListPrefs
     : public KeyedService,
       public arc::mojom::AppHost,
       public arc::InstanceHolder<arc::mojom::AppInstance>::Observer,
-      public arc::ArcAuthService::Observer {
+      public arc::ArcAuthService::Observer,
+      public ArcDefaultAppList::Delegate {
  public:
   struct AppInfo {
     AppInfo(const std::string& name,
             const std::string& package_name,
             const std::string& activity,
             const std::string& intent_uri,
             const std::string& icon_resource_id,
             const base::Time& last_launch_time,
             const base::Time& install_time,
             bool sticky,
@@ skipping 131 matching lines @@
   void RequestIcon(const std::string& app_id, ui::ScaleFactor scale_factor);
 
   // Sets notification enabled flag for given value. If the app or Arc bridge
   // service is not ready, then defer this request until the app gets
   // available. Once new value is set notifies an observer
   // OnNotificationsEnabledChanged.
   void SetNotificationsEnabled(const std::string& app_id, bool enabled);
 
   // Returns true if app is registered.
   bool IsRegistered(const std::string& app_id) const;
+  // Returns true if app is a default app.
+  bool IsDefault(const std::string& app_id) const;
+  // Returns true if app is an OEM app.
+  bool IsOem(const std::string& app_id) const;
   // Returns true if app is a shortcut
   bool IsShortcut(const std::string& app_id) const;
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
   bool HasObserver(Observer* observer);
 
   // arc::ArcAuthService::Observer:
   void OnOptInEnabled(bool enabled) override;
 
+  // ArcDefaultAppList::Delegate:
+  void OnDefaultAppsReady() override;
+
   // Removes app with the given app_id.
   void RemoveApp(const std::string& app_id);
 
   arc::InstanceHolder<arc::mojom::AppInstance>* app_instance_holder() {
     return app_instance_holder_;
   }
 
   std::unordered_set<std::string> GetAppsForPackage(
       const std::string& package_name) const;
 
+  void SetDefaltAppsReadyCallback(base::Closure callback);
+
  private:
   friend class ChromeLauncherControllerImplTest;
 
   // See the Create methods.
   ArcAppListPrefs(
       Profile* profile,
       arc::InstanceHolder<arc::mojom::AppInstance>* app_instance_holder);
 
   // arc::InstanceHolder<arc::mojom::AppInstance>::Observer:
   void OnInstanceReady() override;
@@ skipping 23 matching lines @@
   void OnNotificationsEnabledChanged(const mojo::String& package_name,
                                      bool enabled) override;
   void OnPackageAdded(arc::mojom::ArcPackageInfoPtr package_info) override;
   void OnPackageModified(arc::mojom::ArcPackageInfoPtr package_info) override;
   void OnPackageListRefreshed(
       mojo::Array<arc::mojom::ArcPackageInfoPtr> packages) override;
   void OnTaskOrientationLockRequested(
       int32_t task_id,
       const arc::mojom::OrientationLock orientation_lock) override;
 
+  void StartPrefs();
+
+  // Returns list of packages from prefs. If |installed| is set to true then
+  // returns currently installed packages. If not, returns list of packages that
+  // where uninstalled. Note, we store uninstall packages only for packages of
+  // default apps.
+  std::vector<std::string> GetPackagesFromPrefs(bool installed) const;
+
   void AddApp(const arc::mojom::AppInfo& app_info);
   void AddAppAndShortcut(const std::string& name,
                          const std::string& package_name,
                          const std::string& activity,
                          const std::string& intent_uri,
                          const std::string& icon_resource_id,
                          const bool sticky,
                          const bool notifications_enabled,
                          const bool shortcut,
                          const bool launchable,
                          arc::mojom::OrientationLock orientation_lock);
+  // Adds or updates local pref for given package.
+  void AddOrUpdatePackagePrefs(PrefService* prefs,
+                               const arc::mojom::ArcPackageInfo& package);
+  // Removes given package from local pref.
+  void RemovePackageFromPrefs(PrefService* prefs,
+                              const std::string& package_name);
+
   void DisableAllApps();
   void RemoveAllApps();
   std::vector<std::string> GetAppIdsNoArcEnabledCheck() const;
   // Enumerates apps from preferences and notifies listeners about available
   // apps while Arc is not started yet. All apps in this case have disabled
   // state.
   void NotifyRegisteredApps();
   base::Time GetInstallTime(const std::string& app_id) const;
 
   // Installs an icon to file system in the special folder of the profile
   // directory.
   void InstallIcon(const std::string& app_id,
                    ui::ScaleFactor scale_factor,
                    const std::vector<uint8_t>& contentPng);
   void OnIconInstalled(const std::string& app_id,
                        ui::ScaleFactor scale_factor,
                        bool install_succeed);
 
   // This checks if app is not registered yet and in this case creates
   // non-launchable app entry.
-  void MayAddNonLaunchableApp(const std::string& name,
-                              const std::string& package_name,
-                              const std::string& activity);
+  void MaybeAddNonLaunchableApp(const std::string& name,
+                                const std::string& package_name,
+                                const std::string& activity);
 
   // Reveals first app from provided package in app launcher if package is newly
   // installed by user. If all apps in package are hidden then app list is not
   // shown.
   void MaybeShowPackageInAppLauncher(
       const arc::mojom::ArcPackageInfo& package_info);
 
   Profile* const profile_;
 
   // Owned by the BrowserContext.
@@ skipping 14 matching lines @@
   std::map<std::string, uint32_t> request_icon_deferred_;
   // True if this preference has been initialized once.
   bool is_initialized_ = false;
   // True if apps were restored.
   bool apps_restored_ = false;
 
   arc::ArcPackageSyncableService* sync_service_;
 
   mojo::Binding<arc::mojom::AppHost> binding_;
 
+  bool default_apps_ready_ = false;
+  ArcDefaultAppList default_apps_;
+  base::Closure default_apps_ready_callback_;
+
   base::WeakPtrFactory<ArcAppListPrefs> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcAppListPrefs);
 };
 
 #endif  // CHROME_BROWSER_UI_APP_LIST_ARC_ARC_APP_LIST_PREFS_H_