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

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

 // 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.
 
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 
 #include <stddef.h>
 
 #include <string>
-#include <unordered_map>
 
 #include "base/files/file_util.h"
-#include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/app_list/arc/arc_package_syncable_service.h"
 #include "chrome/common/pref_names.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/crx_file/id_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace {
 
-const char kName[] = "name";
-const char kPackageName[] = "package_name";
-const char kPackageVersion[] = "package_version";
 const char kActivity[] = "activity";
-const char kShortcut[] = "shortcut";
+const char kIconResourceId[] = "icon_resource_id";
+const char kInstallTime[] = "install_time";
 const char kIntentUri[] = "intent_uri";
-const char kIconResourceId[] = "icon_resource_id";
-const char kSticky[] = "sticky";
-const char kNotificationsEnabled[] = "notifications_enabled";
 const char kLastBackupAndroidId[] = "last_backup_android_id";
 const char kLastBackupTime[] = "last_backup_time";
 const char kLastLaunchTime[] = "lastlaunchtime";
 const char kLaunchable[] = "launchable";
+const char kName[] = "name";
+const char kNotificationsEnabled[] = "notifications_enabled";
+const char kOrientationLock[] = "orientation_lock";
+const char kPackageName[] = "package_name";
+const char kPackageVersion[] = "package_version";
+const char kSticky[] = "sticky";
+const char kShortcut[] = "shortcut";
 const char kShouldSync[] = "should_sync";
 const char kSystem[] = "system";
-const char kOrientationLock[] = "orientation_lock";
-const char kInstallTime[] = "install_time";
+const char kUninstalled[] = "uninstalled";
 
 constexpr int kSetNotificationsEnabledMinVersion = 6;
 
 // Provider of write access to a dictionary storing ARC prefs.
 class ScopedArcPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedArcPrefUpdate(PrefService* service,
                       const std::string& id,
                       const std::string& path)
       : DictionaryPrefUpdate(service, path), id_(id) {}
@@ skipping 99 matching lines @@
 
   if (!base::StringToInt64(value_str, value)) {
     VLOG(2) << "Can't change string to int64_t. Invalid string value: "
             << value_str << ".";
     return false;
   }
 
   return true;
 }
 
-// Add or update local pref for given package.
-void AddOrUpdatePackagePrefs(PrefService* prefs,
-                             const arc::mojom::ArcPackageInfo& package) {
-  DCHECK(IsArcEnabled());
-  const std::string& package_name = package.package_name;
-  if (package_name.empty()) {
-    VLOG(2) << "Package name cannot be empty.";
-    return;
-  }
-  ScopedArcPrefUpdate update(prefs, package_name, prefs::kArcPackages);
-  base::DictionaryValue* package_dict = update.Get();
-  const std::string id_str =
-      base::Int64ToString(package.last_backup_android_id);
-  const std::string time_str = base::Int64ToString(package.last_backup_time);
-
-  package_dict->SetBoolean(kShouldSync, package.sync);
-  package_dict->SetInteger(kPackageVersion, package.package_version);
-  package_dict->SetString(kLastBackupAndroidId, id_str);
-  package_dict->SetString(kLastBackupTime, time_str);
-  package_dict->SetBoolean(kSystem, package.system);
-}
-
-// Remove given package from local pref.
-void RemovePackageFromPrefs(PrefService* prefs,
-                            const std::string& package_name) {
-  DCHECK(IsArcEnabled());
-  DictionaryPrefUpdate update(prefs, prefs::kArcPackages);
-  base::DictionaryValue* packages = update.Get();
-  const bool removed = packages->RemoveWithoutPathExpansion(package_name,
-                                                            nullptr);
-  DCHECK(removed);
-}
-
 }  // namespace
 
 // static
 ArcAppListPrefs* ArcAppListPrefs::Create(
     Profile* profile,
     arc::InstanceHolder<arc::mojom::AppInstance>* app_instance_holder) {
   return new ArcAppListPrefs(profile, app_instance_holder);
 }
 
 // static
@@ skipping 17 matching lines @@
 }
 
 ArcAppListPrefs::ArcAppListPrefs(
     Profile* profile,
     arc::InstanceHolder<arc::mojom::AppInstance>* app_instance_holder)
     : profile_(profile),
       prefs_(profile->GetPrefs()),
       app_instance_holder_(app_instance_holder),
       sync_service_(nullptr),
       binding_(this),
+      default_apps_(this),
       weak_ptr_factory_(this) {
   DCHECK(profile);
   DCHECK(app_instance_holder);
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   const base::FilePath& base_path = profile->GetPath();
   base_path_ = base_path.AppendASCII(prefs::kArcApps);
 
   arc::ArcAuthService* auth_service = arc::ArcAuthService::Get();
   if (!auth_service)
     return;
 
-  if (auth_service->state() != arc::ArcAuthService::State::NOT_INITIALIZED)
-    OnOptInEnabled(auth_service->IsArcEnabled());
-  auth_service->AddObserver(this);
+  DCHECK(arc::ArcAuthService::IsAllowedForProfile(profile));
 
-  app_instance_holder_->AddObserver(this);
-  if (!app_instance_holder_->instance())
-    OnInstanceClosed();
+  // Once default apps are ready OnDefaultAppsReady is called.
 }
 
 ArcAppListPrefs::~ArcAppListPrefs() {
   // A reference to ArcBridgeService is kept here so that it would crash the
   // tests where ArcBridgeService and ArcAppListPrefs are not destroyed in right
   // order.
   arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
   if (bridge_service)
     app_instance_holder_->RemoveObserver(this);
 
   arc::ArcAuthService* auth_service = arc::ArcAuthService::Get();
   if (auth_service)
     auth_service->RemoveObserver(this);
 }
 
+void ArcAppListPrefs::StartPrefs() {
+  arc::ArcAuthService* auth_service = arc::ArcAuthService::Get();
+  CHECK(auth_service);
+
+  if (auth_service->state() != arc::ArcAuthService::State::NOT_INITIALIZED)
+    OnOptInEnabled(auth_service->IsArcEnabled());
+  auth_service->AddObserver(this);
+
+  app_instance_holder_->AddObserver(this);
+  if (!app_instance_holder_->instance())
+    OnInstanceClosed();
+}
+
 base::FilePath ArcAppListPrefs::GetAppPath(const std::string& app_id) const {
+  const ArcDefaultAppList::AppInfo* default_app = default_apps_.GetApp(app_id);
+  if (default_app) {
+    const base::DictionaryValue* app = nullptr;
+    const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
+    // If app is not ready yet, use resources from pre-build.
+    if (!apps || !apps->GetDictionaryWithoutPathExpansion(app_id, &app))
+      return default_app->app_path;
+  }
+
   return base_path_.AppendASCII(app_id);
 }
 
 base::FilePath ArcAppListPrefs::GetIconPath(
     const std::string& app_id,
     ui::ScaleFactor scale_factor) const {
   const base::FilePath app_path = GetAppPath(app_id);
   switch (scale_factor) {
     case ui::SCALE_FACTOR_100P:
       return app_path.AppendASCII("icon_100p.png");
@@ skipping 133 matching lines @@
   package->GetInteger(kPackageVersion, &package_version);
   package->GetBoolean(kShouldSync, &should_sync);
   package->GetBoolean(kSystem, &system);
 
   return base::MakeUnique<PackageInfo>(package_name, package_version,
                                        last_backup_android_id, last_backup_time,
                                        should_sync, system);
 }
 
 std::vector<std::string> ArcAppListPrefs::GetAppIds() const {
-  if (!IsArcEnabled())
-    return std::vector<std::string>();
+  if (!IsArcEnabled()) {
+    // Default Arc apps available before OptIn.
+    std::vector<std::string> ids;
+    for (const auto& default_app : default_apps_.app_map()) {
+      if (default_apps_.HasApp(default_app.first))
+        ids.push_back(default_app.first);
+    }
+    return ids;
+  }
   return GetAppIdsNoArcEnabledCheck();
 }
 
 std::vector<std::string> ArcAppListPrefs::GetAppIdsNoArcEnabledCheck() const {
   std::vector<std::string> ids;
 
+  const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
+  DCHECK(apps);
+
+  // Include default app ids into the list. In order not to list app twice,
+  // at first step include default apps that do not exist yet.
+  for (const auto& default_app : default_apps_.app_map()) {
+    const std::string& app_id = default_app.first;
+    const base::DictionaryValue* app = nullptr;
+    if (default_apps_.HasApp(default_app.first) &&
+        !apps->GetDictionaryWithoutPathExpansion(app_id, &app)) {
+      ids.push_back(app_id);
+    }
+  }
+
   // crx_file::id_util is de-facto utility for id generation.
-  const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   for (base::DictionaryValue::Iterator app_id(*apps); !app_id.IsAtEnd();
        app_id.Advance()) {
     if (!crx_file::id_util::IdIsValid(app_id.key()))
       continue;
 
     ids.push_back(app_id.key());
   }
 
   return ids;
 }
 
 std::unique_ptr<ArcAppListPrefs::AppInfo> ArcAppListPrefs::GetApp(
     const std::string& app_id) const {
-  if (!IsArcEnabled())
+  // Information for default app is available before Arc enabled.
+  const ArcDefaultAppList::AppInfo* default_app = default_apps_.GetApp(app_id);
+  if (!IsArcEnabled() && !default_app)
     return std::unique_ptr<AppInfo>();
 
   const base::DictionaryValue* app = nullptr;
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
-  if (!apps || !apps->GetDictionaryWithoutPathExpansion(app_id, &app))
+  if (!apps || !apps->GetDictionaryWithoutPathExpansion(app_id, &app)) {
+    // Default app may not be available at this point so create app info based
+    // on its forward declaration.
+    if (default_app) {
+      return base::MakeUnique<AppInfo>(
+          default_app->name, default_app->package_name, default_app->activity,
+          std::string() /* intent_uri */, std::string() /* icon_resource_id */,
+          base::Time() /* last_launch_time */, base::Time() /* install_time */,
+          false /* sticky */, false /* notifications_enabled */,
+          false /* ready */, true /* showInLauncher */, false /* shortcut */,
+          true /* launchable */,  arc::mojom::OrientationLock::NONE);
+    }
     return std::unique_ptr<AppInfo>();
+  }
 
   std::string name;
   std::string package_name;
   std::string activity;
   std::string intent_uri;
   std::string icon_resource_id;
   bool sticky = false;
   bool notifications_enabled = true;
   bool shortcut = false;
   bool launchable = true;
@@ skipping 28 matching lines @@
 
   return base::MakeUnique<AppInfo>(
       name, package_name, activity, intent_uri, icon_resource_id,
       last_launch_time, GetInstallTime(app_id), sticky, notifications_enabled,
       ready_apps_.count(app_id) > 0,
       launchable && arc::ShouldShowInLauncher(app_id), shortcut, launchable,
       orientation_lock);
 }
 
 bool ArcAppListPrefs::IsRegistered(const std::string& app_id) const {
+  if (default_apps_.HasApp(app_id))
+    return true;
+
   if (!IsArcEnabled())
     return false;
 
   const base::DictionaryValue* app = nullptr;
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   return apps && apps->GetDictionaryWithoutPathExpansion(app_id, &app);
 }
 
+bool ArcAppListPrefs::IsDefault(const std::string& app_id) const {
+  return default_apps_.HasApp(app_id);
+}
+
+bool ArcAppListPrefs::IsOem(const std::string& app_id) const {
+  const ArcDefaultAppList::AppInfo* app_info = default_apps_.GetApp(app_id);
+  return app_info && app_info->oem;
+}
+
 bool ArcAppListPrefs::IsShortcut(const std::string& app_id) const {
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = GetApp(app_id);
   return app_info && app_info->shortcut;
 }
 
 void ArcAppListPrefs::SetLastLaunchTime(const std::string& app_id,
                                         const base::Time& time) {
   if (!IsRegistered(app_id)) {
     NOTREACHED();
     return;
@@ skipping 23 matching lines @@
     return;
 
   DCHECK(ready_apps_.empty());
   std::vector<std::string> app_ids = GetAppIdsNoArcEnabledCheck();
   for (const auto& app_id : app_ids) {
     std::unique_ptr<AppInfo> app_info = GetApp(app_id);
     if (!app_info) {
       NOTREACHED();
       continue;
     }
+    // Default apps are reported earlier.
+    if (default_apps_.HasApp(app_id))
+      continue;
     FOR_EACH_OBSERVER(Observer, observer_list_,
                       OnAppRegistered(app_id, *app_info));
   }
 
   apps_restored_ = true;
 }
 
 void ArcAppListPrefs::RemoveAllApps() {
   std::vector<std::string> app_ids = GetAppIdsNoArcEnabledCheck();
-  for (const auto& app_id : app_ids)
-    RemoveApp(app_id);
+  for (const auto& app_id : app_ids) {
+    if (!default_apps_.HasApp(app_id))
+      RemoveApp(app_id);
+  }
 }
 
 void ArcAppListPrefs::OnOptInEnabled(bool enabled) {
   if (enabled)
     NotifyRegisteredApps();
   else
     RemoveAllApps();
 }
 
+void ArcAppListPrefs::OnDefaultAppsReady() {
+  // Apply uninstalled packages now.
+  const std::vector<std::string> uninstalled_package_names =
+      GetPackagesFromPrefs(false);
+  for (const auto& uninstalled_package_name : uninstalled_package_names)
+    default_apps_.MaybeMarkPackageUninstalled(uninstalled_package_name, true);
+
+  // Report default apps first.
+  for (const auto& default_app : default_apps_.app_map()) {
+    const std::string& app_id = default_app.first;
+    std::unique_ptr<AppInfo> app_info = GetApp(app_id);
+    if (app_info) {
+      FOR_EACH_OBSERVER(Observer, observer_list_,
+                        OnAppRegistered(app_id, *app_info));
+    }
+  }
+
+  default_apps_ready_ = true;
+  if (!default_apps_ready_callback_.is_null())
+    default_apps_ready_callback_.Run();
+
+  StartPrefs();
+}
+
+void ArcAppListPrefs::SetDefaltAppsReadyCallback(base::Closure callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(default_apps_ready_callback_.is_null());
+  default_apps_ready_callback_ = callback;
+  if (default_apps_ready_)
+    default_apps_ready_callback_.Run();
+}
+
 void ArcAppListPrefs::OnInstanceReady() {
   arc::mojom::AppInstance* app_instance = app_instance_holder_->instance();
 
   sync_service_ = arc::ArcPackageSyncableService::Get(profile_);
   DCHECK(sync_service_);
 
   // In some tests app_instance may not be set.
   if (!app_instance) {
     VLOG(2) << "Request to refresh app list when bridge service is not ready.";
     return;
@@ skipping 10 matching lines @@
   binding_.Close();
 
   if (sync_service_) {
     sync_service_->StopSyncing(syncer::ARC_PACKAGE);
     sync_service_ = nullptr;
   }
 
   is_initialized_ = false;
 }
 
-void ArcAppListPrefs::MayAddNonLaunchableApp(const std::string& name,
-                                             const std::string& package_name,
-                                             const std::string& activity) {
+void ArcAppListPrefs::MaybeAddNonLaunchableApp(const std::string& name,
+                                               const std::string& package_name,
+                                               const std::string& activity) {
   DCHECK(IsArcEnabled());
   if (IsRegistered(GetAppId(package_name, activity)))
     return;
 
   AddAppAndShortcut(name, package_name, activity,
                     std::string() /* intent_uri */,
                     std::string() /* icon_resource_id */, false /* sticky */,
                     false /* notifications_enabled */, false /* shortcut */,
                     false /* launchable */, arc::mojom::OrientationLock::NONE);
 }
 
 void ArcAppListPrefs::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,
     const arc::mojom::OrientationLock orientation_lock) {
-  std::string app_id = shortcut ? GetAppId(package_name, intent_uri)
-                                : GetAppId(package_name, activity);
+  const std::string app_id = shortcut ? GetAppId(package_name, intent_uri)
+                                      : GetAppId(package_name, activity);
   const bool was_registered = IsRegistered(app_id);
   if (was_registered) {
     std::unique_ptr<ArcAppListPrefs::AppInfo> app_old_info = GetApp(app_id);
     DCHECK(app_old_info);
     DCHECK(launchable);
     if (name != app_old_info->name) {
       FOR_EACH_OBSERVER(Observer, observer_list_,
                         OnAppNameUpdated(app_id, name));
     }
   }
@@ skipping 60 matching lines @@
 void ArcAppListPrefs::RemoveApp(const std::string& app_id) {
   // Delete cached icon if there is any.
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = GetApp(app_id);
   if (app_info && !app_info->icon_resource_id.empty()) {
     arc::RemoveCachedIcon(app_info->icon_resource_id);
   }
 
   // From now, app is not available.
   ready_apps_.erase(app_id);
 
+  // app_id may be released by observers, get the path first. It should be done
+  // before removing prefs entry in order not to mix with pre-build default apps
+  // files.
+  const base::FilePath app_path = GetAppPath(app_id);
+
   // Remove from prefs.
   DictionaryPrefUpdate update(prefs_, prefs::kArcApps);
   base::DictionaryValue* apps = update.Get();
   const bool removed = apps->Remove(app_id, nullptr);
   DCHECK(removed);
-  // app_id may be released by observers, get the path first.
-  const base::FilePath app_path = GetAppPath(app_id);
 
   FOR_EACH_OBSERVER(Observer, observer_list_, OnAppRemoved(app_id));
 
   // Remove local data on file system.
   content::BrowserThread::GetBlockingPool()->PostTask(
       FROM_HERE, base::Bind(&DeleteAppFolderFromFileThread, app_path));
 }
 
+void ArcAppListPrefs::AddOrUpdatePackagePrefs(
+    PrefService* prefs, const arc::mojom::ArcPackageInfo& package) {
+  DCHECK(IsArcEnabled());
+  const std::string& package_name = package.package_name;
+  default_apps_.MaybeMarkPackageUninstalled(package_name, false);
+  if (package_name.empty()) {
+    VLOG(2) << "Package name cannot be empty.";
+    return;
+  }
+  ScopedArcPrefUpdate update(prefs, package_name, prefs::kArcPackages);
+  base::DictionaryValue* package_dict = update.Get();
+  const std::string id_str =
+      base::Int64ToString(package.last_backup_android_id);
+  const std::string time_str = base::Int64ToString(package.last_backup_time);
+
+  package_dict->SetBoolean(kShouldSync, package.sync);
+  package_dict->SetInteger(kPackageVersion, package.package_version);
+  package_dict->SetString(kLastBackupAndroidId, id_str);
+  package_dict->SetString(kLastBackupTime, time_str);
+  package_dict->SetBoolean(kSystem, package.system);
+}
+
+void ArcAppListPrefs::RemovePackageFromPrefs(PrefService* prefs,
+                                             const std::string& package_name) {
+  DCHECK(IsArcEnabled());
+  default_apps_.MaybeMarkPackageUninstalled(package_name, true);
+  if (!default_apps_.HasPackage(package_name)) {
+    DictionaryPrefUpdate update(prefs, prefs::kArcPackages);
+    base::DictionaryValue* packages = update.Get();
+    const bool removed = packages->RemoveWithoutPathExpansion(package_name,
+                                                              nullptr);
+    DCHECK(removed);
+  } else {
+    ScopedArcPrefUpdate update(prefs, package_name, prefs::kArcPackages);
+    base::DictionaryValue* package_dict = update.Get();
+    package_dict->SetBoolean(kUninstalled, true);
+  }
+}
+
 void ArcAppListPrefs::OnAppListRefreshed(
     mojo::Array<arc::mojom::AppInfoPtr> apps) {
   DCHECK(IsArcEnabled());
   std::vector<std::string> old_apps = GetAppIds();
 
   ready_apps_.clear();
   for (const auto& app : apps) {
     // TODO(oshima): Do we have to update orientation?
     AddAppAndShortcut(app->name, app->package_name, app->activity,
                       std::string() /* intent_uri */,
                       std::string() /* icon_resource_id */, app->sticky,
                       app->notifications_enabled, false /* shortcut */,
                       true /* launchable */, app->orientation_lock);
   }
 
   // Detect removed ARC apps after current refresh.
   for (const auto& app_id : old_apps) {
     if (ready_apps_.count(app_id))
       continue;
 
     if (IsShortcut(app_id)) {
       // If this is a shortcut, we just mark it as ready.
       ready_apps_.insert(app_id);
     } else {
-      RemoveApp(app_id);
+      // Default apps may not be installed yet at this moment.
+      if (!default_apps_.HasApp(app_id))
+        RemoveApp(app_id);
     }
   }
 
   if (!is_initialized_) {
     is_initialized_ = true;
     UMA_HISTOGRAM_COUNTS_1000("Arc.AppsInstalledAtStartup", ready_apps_.size());
   }
 }
 
 void ArcAppListPrefs::OnTaskOrientationLockRequested(
@@ skipping 120 matching lines @@
   }
 
   InstallIcon(app_id, static_cast<ui::ScaleFactor>(scale_factor),
               icon_png_data.To<std::vector<uint8_t>>());
 }
 
 void ArcAppListPrefs::OnTaskCreated(int32_t task_id,
                                     const mojo::String& package_name,
                                     const mojo::String& activity,
                                     const mojo::String& name) {
-  MayAddNonLaunchableApp(name, package_name, activity);
+  MaybeAddNonLaunchableApp(name, package_name, activity);
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnTaskCreated(task_id, package_name, activity));
 }
 
 void ArcAppListPrefs::OnTaskDestroyed(int32_t task_id) {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnTaskDestroyed(task_id));
 }
 
 void ArcAppListPrefs::OnTaskSetActive(int32_t task_id) {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnTaskSetActive(task_id));
@@ skipping 89 matching lines @@
 
   // Start ArcPackageSyncService ASAP. This is the call_back of
   // app_instance->RefreshAppList() in OnInstanceReady(). SyncStarted() should
   // only be called after packagelist refresh is completed. SyncStarted() is
   // no-op after first time setup or if sync is disabled.
   DCHECK(sync_service_);
   sync_service_->SyncStarted();
 }
 
 std::vector<std::string> ArcAppListPrefs::GetPackagesFromPrefs() const {
+  return GetPackagesFromPrefs(true);
+}
+
+std::vector<std::string> ArcAppListPrefs::GetPackagesFromPrefs(
+    bool installed) const {
   std::vector<std::string> packages;
-  if (!IsArcEnabled())
+  if (!IsArcEnabled() && installed)
     return packages;
 
   const base::DictionaryValue* package_prefs =
       prefs_->GetDictionary(prefs::kArcPackages);
   for (base::DictionaryValue::Iterator package(*package_prefs);
        !package.IsAtEnd(); package.Advance()) {
+
+    bool uninstalled = false;
+    package_prefs->GetBoolean(kSystem, &uninstalled);
+    if (installed != !uninstalled)
+      continue;
+
     packages.push_back(package.key());
   }
 
   return packages;
 }
 
 base::Time ArcAppListPrefs::GetInstallTime(const std::string& app_id) const {
   const base::DictionaryValue* app = nullptr;
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   if (!apps || !apps->GetDictionaryWithoutPathExpansion(app_id, &app))
@@ skipping 70 matching lines @@
                                           int64_t last_backup_android_id,
                                           int64_t last_backup_time,
                                           bool should_sync,
                                           bool system)
     : package_name(package_name),
       package_version(package_version),
       last_backup_android_id(last_backup_android_id),
       last_backup_time(last_backup_time),
       should_sync(should_sync),
       system(system) {}