Fetch ARC Kiosk app name and icon from Android side.

chrome/browser/chromeos/app_mode/arc/arc_kiosk_app_manager.cc

 // Copyright 2016 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/chromeos/app_mode/arc/arc_kiosk_app_manager.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "components/arc/arc_util.h"
 #include "components/prefs/pref_registry_simple.h"
@@ skipping 64 matching lines @@
                                   base::Closure()));
   }
 }
 
 // This class is owned by ChromeBrowserMainPartsChromeos.
 static ArcKioskAppManager* g_arc_kiosk_app_manager = nullptr;
 
 }  // namespace
 
 // static
+const char ArcKioskAppManager::kArcKioskDictionaryName[] = "arc-kiosk";
+
+// static
 void ArcKioskAppManager::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterDictionaryPref(kArcKioskDictionaryName);
   registry->RegisterListPref(kArcKioskUsersToRemove);
 }
 
 // static
 void ArcKioskAppManager::RemoveObsoleteCryptohomes() {
   chromeos::CryptohomeClient* const client =
       chromeos::DBusThreadManager::Get()->GetCryptohomeClient();
   client->WaitForServiceToBeAvailable(
       base::Bind(&PerformDelayedCryptohomeRemovals));
 }
 
-ArcKioskAppManager::ArcKioskApp::ArcKioskApp(const ArcKioskApp& other) =
-    default;
-
-ArcKioskAppManager::ArcKioskApp::ArcKioskApp(
-    const policy::ArcKioskAppBasicInfo& app_info,
-    const AccountId& account_id,
-    const std::string& name)
-    : app_info_(app_info), account_id_(account_id), name_(name) {}
-
-ArcKioskAppManager::ArcKioskApp::~ArcKioskApp() = default;
-
-bool ArcKioskAppManager::ArcKioskApp::operator==(
-    const policy::ArcKioskAppBasicInfo& app_info) const {
-  return this->app_info_ == app_info;
-}
-
 // static
 ArcKioskAppManager* ArcKioskAppManager::Get() {
   return g_arc_kiosk_app_manager;
 }
 
 ArcKioskAppManager::ArcKioskAppManager()
     : auto_launch_account_id_(EmptyAccountId()) {
   DCHECK(!g_arc_kiosk_app_manager);  // Only one instance is allowed.
   UpdateApps();
   local_accounts_subscription_ = CrosSettings::Get()->AddSettingsObserver(
@@ skipping 10 matching lines @@
   local_accounts_subscription_.reset();
   local_account_auto_login_id_subscription_.reset();
   apps_.clear();
   g_arc_kiosk_app_manager = nullptr;
 }
 
 const AccountId& ArcKioskAppManager::GetAutoLaunchAccountId() const {
   return auto_launch_account_id_;
 }
 
-const ArcKioskAppManager::ArcKioskApp* ArcKioskAppManager::GetAppByAccountId(
+const ArcKioskAppData* ArcKioskAppManager::GetAppByAccountId(
     const AccountId& account_id) {
-  for (auto& app : GetAllApps())
-    if (app.account_id() == account_id)
-      return &app;
+  for (auto& app : apps_) {
+    if (app->account_id() == account_id)
+      return app.get();
+  }
   return nullptr;
 }
 
+void ArcKioskAppManager::GetAllApps(Apps* apps) const {
+  apps->clear();
+  apps->reserve(apps_.size());
+  for (auto& app : apps_)
+    apps->push_back(app.get());
+}
+
+void ArcKioskAppManager::UpdateNameAndIcon(const std::string& app_id,
+                                           const std::string& name,
+                                           const gfx::ImageSkia& icon) {
+  for (auto& app : apps_) {
+    if (app->app_id() == app_id) {
+      app->SetCache(name, icon);
+      return;
+    }
+  }
+}
+
 void ArcKioskAppManager::AddObserver(ArcKioskAppManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ArcKioskAppManager::RemoveObserver(ArcKioskAppManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ArcKioskAppManager::UpdateApps() {
   // Do not populate ARC kiosk apps if ARC kiosk apps can't be run on the
   // device.
   // Apps won't be added to kiosk Apps menu and won't be auto-launched.
   if (!arc::IsArcKioskAvailable()) {
     VLOG(1) << "Device doesn't support ARC kiosk";
     return;
   }
 
   // Store current apps. We will compare old and new apps to determine which
   // apps are new, and which were deleted.
-  ArcKioskApps old_apps(std::move(apps_));
-
+  std::map<std::string, std::unique_ptr<ArcKioskAppData>> old_apps;
+  for (auto& app : apps_)
+    old_apps[app->app_id()] = std::move(app);
+  apps_.clear();
   auto_launch_account_id_.clear();
   auto_launched_with_zero_delay_ = false;
   std::string auto_login_account_id_from_settings;
   CrosSettings::Get()->GetString(kAccountsPrefDeviceLocalAccountAutoLoginId,
                                  &auto_login_account_id_from_settings);
 
   // Re-populates |apps_| and reuses existing apps when possible.
   const std::vector<policy::DeviceLocalAccount> device_local_accounts =
       policy::GetDeviceLocalAccounts(CrosSettings::Get());
   for (auto account : device_local_accounts) {
     if (account.type != policy::DeviceLocalAccount::TYPE_ARC_KIOSK_APP)
       continue;
 
     const AccountId account_id(AccountId::FromUserEmail(account.user_id));
 
     if (account.account_id == auto_login_account_id_from_settings) {
       auto_launch_account_id_ = account_id;
       int auto_launch_delay = 0;
       CrosSettings::Get()->GetInteger(
           kAccountsPrefDeviceLocalAccountAutoLoginDelay, &auto_launch_delay);
       auto_launched_with_zero_delay_ = auto_launch_delay == 0;
     }
 
-    auto old_it =
-        std::find(old_apps.begin(), old_apps.end(), account.arc_kiosk_app_info);
+    // Apps are keyed by package name. http://crbug.com/665904
+    auto old_it = old_apps.find(account.arc_kiosk_app_info.package_name());
     if (old_it != old_apps.end()) {
-      apps_.push_back(std::move(*old_it));
+      apps_.push_back(std::move(old_it->second));
       old_apps.erase(old_it);
     } else {
       // Use package name when display name is not specified.
       std::string name = account.arc_kiosk_app_info.package_name();
       if (!account.arc_kiosk_app_info.display_name().empty())
         name = account.arc_kiosk_app_info.display_name();
-      apps_.push_back(
-          ArcKioskApp(account.arc_kiosk_app_info, account_id, name));
+      apps_.push_back(base::MakeUnique<ArcKioskAppData>(
+          account.arc_kiosk_app_info.package_name(), account_id, name));
+      apps_.back()->LoadFromCache();
     }
     CancelDelayedCryptohomeRemoval(cryptohome::Identification(account_id));
   }
 
   ClearRemovedApps(old_apps);
 
   for (auto& observer : observers_) {
     observer.OnArcKioskAppsChanged();
   }
 }
 
 void ArcKioskAppManager::ClearRemovedApps(
-    const std::vector<ArcKioskApp>& old_apps) {
+    const std::map<std::string, std::unique_ptr<ArcKioskAppData>>& old_apps) {
   // Check if currently active user must be deleted.
   bool active_user_to_be_deleted = false;
   const user_manager::User* active_user =
       user_manager::UserManager::Get()->GetActiveUser();
   if (active_user) {
     const AccountId active_account_id = active_user->GetAccountId();
     for (const auto& it : old_apps) {
-      if (it.account_id() == active_account_id) {
+      if (it.second->account_id() == active_account_id) {
         active_user_to_be_deleted = true;
         break;
       }
     }
   }
 
   // Remove cryptohome
   for (auto& entry : old_apps) {
-    const cryptohome::Identification cryptohome_id(entry.account_id());
+    entry.second->ClearCache();
+    const cryptohome::Identification cryptohome_id(entry.second->account_id());
     if (active_user_to_be_deleted) {
       // Schedule cryptohome removal after active user logout.
       ScheduleDelayedCryptohomeRemoval(cryptohome_id);
     } else {
       cryptohome::AsyncMethodCaller::GetInstance()->AsyncRemove(
           cryptohome_id, base::Bind(&OnRemoveAppCryptohomeComplete,
                                     cryptohome_id, base::Closure()));
     }
   }
 
   if (active_user_to_be_deleted)
     chrome::AttemptUserExit();
 }
 
 }  // namespace chromeos