src/chrome/browser/chromeos/app_mode/kiosk_app_manager.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
   6
   7 #include <map>
   8 #include <set>
   9
  10 #include "base/bind.h"
  11 #include "base/logging.h"
  12 #include "base/path_service.h"
  13 #include "base/prefs/pref_registry_simple.h"
  14 #include "base/prefs/pref_service.h"
  15 #include "base/prefs/scoped_user_pref_update.h"
  16 #include "base/stl_util.h"
  17 #include "base/sys_info.h"
  18 #include "chrome/browser/browser_process.h"
  19 #include "chrome/browser/chromeos/app_mode/kiosk_app_data.h"
  20 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager_observer.h"
  21 #include "chrome/browser/chromeos/login/user_manager.h"
  22 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
  23 #include "chrome/browser/chromeos/policy/device_local_account.h"
  24 #include "chrome/browser/chromeos/settings/cros_settings.h"
  25 #include "chrome/browser/chromeos/settings/owner_key_util.h"
  26 #include "chrome/common/chrome_paths.h"
  27 #include "chromeos/cryptohome/async_method_caller.h"
  28 #include "chromeos/settings/cros_settings_names.h"
  29 #include "content/public/browser/browser_thread.h"
  30
  31 namespace chromeos {
  32
  33 namespace {
  34
  35 // Domain that is used for kiosk-app account IDs.
  36 const char kKioskAppAccountDomain[] = "kiosk-apps";
  37
  38 std::string GenerateKioskAppAccountId(const std::string& app_id) {
  39   return app_id + '@' + kKioskAppAccountDomain;
  40 }
  41
  42 void OnRemoveAppCryptohomeComplete(const std::string& app,
  43                                    bool success,
  44                                    cryptohome::MountError return_code) {
  45   if (!success) {
  46     LOG(ERROR) << "Remove cryptohome for " << app
  47         << " failed, return code: " << return_code;
  48   }
  49 }
  50
  51 // Check for presence of machine owner public key file.
  52 void CheckOwnerFilePresence(bool *present) {
  53   scoped_refptr<OwnerKeyUtil> util = OwnerKeyUtil::Create();
  54   *present = util->IsPublicKeyPresent();
  55 }
  56
  57 }  // namespace
  58
  59 // static
  60 const char KioskAppManager::kKioskDictionaryName[] = "kiosk";
  61 const char KioskAppManager::kKeyApps[] = "apps";
  62 const char KioskAppManager::kKeyAutoLoginState[] = "auto_login_state";
  63 const char KioskAppManager::kIconCacheDir[] = "kiosk";
  64
  65 // static
  66 static base::LazyInstance<KioskAppManager> instance = LAZY_INSTANCE_INITIALIZER;
  67 KioskAppManager* KioskAppManager::Get() {
  68   return instance.Pointer();
  69 }
  70
  71 // static
  72 void KioskAppManager::Shutdown() {
  73   if (instance == NULL)
  74     return;
  75
  76   instance.Pointer()->CleanUp();
  77 }
  78
  79 // static
  80 void KioskAppManager::RegisterPrefs(PrefRegistrySimple* registry) {
  81   registry->RegisterDictionaryPref(kKioskDictionaryName);
  82 }
  83
  84 KioskAppManager::App::App(const KioskAppData& data)
  85     : app_id(data.app_id()),
  86       user_id(data.user_id()),
  87       name(data.name()),
  88       icon(data.icon()),
  89       is_loading(data.IsLoading()) {
  90 }
  91
  92 KioskAppManager::App::App() : is_loading(false) {}
  93 KioskAppManager::App::~App() {}
  94
  95 std::string KioskAppManager::GetAutoLaunchApp() const {
  96   return auto_launch_app_id_;
  97 }
  98
  99 void KioskAppManager::SetAutoLaunchApp(const std::string& app_id) {
 100   SetAutoLoginState(AUTOLOGIN_REQUESTED);
 101   // Clean first, so the proper change callbacks are triggered even
 102   // if we are only changing AutoLoginState here.
 103   if (!auto_launch_app_id_.empty()) {
 104     CrosSettings::Get()->SetString(kAccountsPrefDeviceLocalAccountAutoLoginId,
 105                                    std::string());
 106   }
 107
 108   CrosSettings::Get()->SetString(
 109       kAccountsPrefDeviceLocalAccountAutoLoginId,
 110       app_id.empty() ? std::string() : GenerateKioskAppAccountId(app_id));
 111   CrosSettings::Get()->SetInteger(
 112       kAccountsPrefDeviceLocalAccountAutoLoginDelay, 0);
 113 }
 114
 115 void KioskAppManager::EnableConsumerKioskAutoLaunch(
 116     const KioskAppManager::EnableKioskAutoLaunchCallback& callback) {
 117   policy::BrowserPolicyConnectorChromeOS* connector =
 118       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 119   connector->GetInstallAttributes()->LockDevice(
 120       std::string(),  // user
 121       policy::DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH,
 122       std::string(),  // device_id
 123       base::Bind(
 124           &KioskAppManager::OnLockDevice, base::Unretained(this), callback));
 125 }
 126
 127 void KioskAppManager::GetConsumerKioskAutoLaunchStatus(
 128     const KioskAppManager::GetConsumerKioskAutoLaunchStatusCallback& callback) {
 129   policy::BrowserPolicyConnectorChromeOS* connector =
 130       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 131   connector->GetInstallAttributes()->ReadImmutableAttributes(
 132       base::Bind(&KioskAppManager::OnReadImmutableAttributes,
 133                  base::Unretained(this),
 134                  callback));
 135 }
 136
 137 void KioskAppManager::OnLockDevice(
 138     const KioskAppManager::EnableKioskAutoLaunchCallback& callback,
 139     policy::EnterpriseInstallAttributes::LockResult result) {
 140   if (callback.is_null())
 141     return;
 142
 143   callback.Run(result == policy::EnterpriseInstallAttributes::LOCK_SUCCESS);
 144 }
 145
 146 void KioskAppManager::OnOwnerFileChecked(
 147     const KioskAppManager::GetConsumerKioskAutoLaunchStatusCallback& callback,
 148     bool* owner_present) {
 149   ownership_established_ = *owner_present;
 150
 151   if (callback.is_null())
 152     return;
 153
 154   // If we have owner already established on the machine, don't let
 155   // consumer kiosk to be enabled.
 156   if (ownership_established_)
 157     callback.Run(CONSUMER_KIOSK_AUTO_LAUNCH_DISABLED);
 158   else
 159     callback.Run(CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE);
 160 }
 161
 162 void KioskAppManager::OnReadImmutableAttributes(
 163     const KioskAppManager::GetConsumerKioskAutoLaunchStatusCallback&
 164         callback) {
 165   if (callback.is_null())
 166     return;
 167
 168   ConsumerKioskAutoLaunchStatus status =
 169       CONSUMER_KIOSK_AUTO_LAUNCH_DISABLED;
 170   policy::BrowserPolicyConnectorChromeOS* connector =
 171       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 172   policy::EnterpriseInstallAttributes* attributes =
 173       connector->GetInstallAttributes();
 174   switch (attributes->GetMode()) {
 175     case policy::DEVICE_MODE_NOT_SET: {
 176       if (!base::SysInfo::IsRunningOnChromeOS()) {
 177         status = CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE;
 178       } else if (!ownership_established_) {
 179         bool* owner_present = new bool(false);
 180         content::BrowserThread::PostBlockingPoolTaskAndReply(
 181             FROM_HERE,
 182             base::Bind(&CheckOwnerFilePresence,
 183                        owner_present),
 184             base::Bind(&KioskAppManager::OnOwnerFileChecked,
 185                        base::Unretained(this),
 186                        callback,
 187                        base::Owned(owner_present)));
 188         return;
 189       }
 190       break;
 191     }
 192     case policy::DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH:
 193       status = CONSUMER_KIOSK_AUTO_LAUNCH_ENABLED;
 194       break;
 195     default:
 196       break;
 197   }
 198
 199   callback.Run(status);
 200 }
 201
 202 void KioskAppManager::SetEnableAutoLaunch(bool value) {
 203   SetAutoLoginState(value ? AUTOLOGIN_APPROVED : AUTOLOGIN_REJECTED);
 204 }
 205
 206 bool KioskAppManager::IsAutoLaunchRequested() const {
 207   if (GetAutoLaunchApp().empty())
 208     return false;
 209
 210   // Apps that were installed by the policy don't require machine owner
 211   // consent through UI.
 212   policy::BrowserPolicyConnectorChromeOS* connector =
 213       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 214   if (connector->IsEnterpriseManaged())
 215     return false;
 216
 217   return GetAutoLoginState() == AUTOLOGIN_REQUESTED;
 218 }
 219
 220 bool KioskAppManager::IsAutoLaunchEnabled() const {
 221   if (GetAutoLaunchApp().empty())
 222     return false;
 223
 224   // Apps that were installed by the policy don't require machine owner
 225   // consent through UI.
 226   policy::BrowserPolicyConnectorChromeOS* connector =
 227       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 228   if (connector->IsEnterpriseManaged())
 229     return true;
 230
 231   return GetAutoLoginState() == AUTOLOGIN_APPROVED;
 232 }
 233
 234 void KioskAppManager::AddApp(const std::string& app_id) {
 235   std::vector<policy::DeviceLocalAccount> device_local_accounts =
 236       policy::GetDeviceLocalAccounts(CrosSettings::Get());
 237
 238   // Don't insert the app if it's already in the list.
 239   for (std::vector<policy::DeviceLocalAccount>::const_iterator
 240            it = device_local_accounts.begin();
 241        it != device_local_accounts.end(); ++it) {
 242     if (it->type == policy::DeviceLocalAccount::TYPE_KIOSK_APP &&
 243         it->kiosk_app_id == app_id) {
 244       return;
 245     }
 246   }
 247
 248   // Add the new account.
 249   device_local_accounts.push_back(policy::DeviceLocalAccount(
 250       policy::DeviceLocalAccount::TYPE_KIOSK_APP,
 251       GenerateKioskAppAccountId(app_id),
 252       app_id));
 253
 254   policy::SetDeviceLocalAccounts(CrosSettings::Get(), device_local_accounts);
 255 }
 256
 257 void KioskAppManager::RemoveApp(const std::string& app_id) {
 258   // Resets auto launch app if it is the removed app.
 259   if (auto_launch_app_id_ == app_id)
 260     SetAutoLaunchApp(std::string());
 261
 262   std::vector<policy::DeviceLocalAccount> device_local_accounts =
 263       policy::GetDeviceLocalAccounts(CrosSettings::Get());
 264   if (device_local_accounts.empty())
 265     return;
 266
 267   // Remove entries that match |app_id|.
 268   for (std::vector<policy::DeviceLocalAccount>::iterator
 269            it = device_local_accounts.begin();
 270        it != device_local_accounts.end(); ++it) {
 271     if (it->type == policy::DeviceLocalAccount::TYPE_KIOSK_APP &&
 272         it->kiosk_app_id == app_id) {
 273       device_local_accounts.erase(it);
 274       break;
 275     }
 276   }
 277
 278   policy::SetDeviceLocalAccounts(CrosSettings::Get(), device_local_accounts);
 279 }
 280
 281 void KioskAppManager::GetApps(Apps* apps) const {
 282   apps->clear();
 283   apps->reserve(apps_.size());
 284   for (size_t i = 0; i < apps_.size(); ++i)
 285     apps->push_back(App(*apps_[i]));
 286 }
 287
 288 bool KioskAppManager::GetApp(const std::string& app_id, App* app) const {
 289   const KioskAppData* data = GetAppData(app_id);
 290   if (!data)
 291     return false;
 292
 293   *app = App(*data);
 294   return true;
 295 }
 296
 297 const base::RefCountedString* KioskAppManager::GetAppRawIcon(
 298     const std::string& app_id) const {
 299   const KioskAppData* data = GetAppData(app_id);
 300   if (!data)
 301     return NULL;
 302
 303   return data->raw_icon();
 304 }
 305
 306 bool KioskAppManager::GetDisableBailoutShortcut() const {
 307   bool enable;
 308   if (CrosSettings::Get()->GetBoolean(
 309           kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled, &enable)) {
 310     return !enable;
 311   }
 312
 313   return false;
 314 }
 315
 316 void KioskAppManager::ClearAppData(const std::string& app_id) {
 317   KioskAppData* app_data = GetAppDataMutable(app_id);
 318   if (!app_data)
 319     return;
 320
 321   app_data->ClearCache();
 322 }
 323
 324 void KioskAppManager::UpdateAppDataFromProfile(
 325     const std::string& app_id,
 326     Profile* profile,
 327     const extensions::Extension* app) {
 328   KioskAppData* app_data = GetAppDataMutable(app_id);
 329   if (!app_data)
 330     return;
 331
 332   app_data->LoadFromInstalledApp(profile, app);
 333 }
 334
 335 void KioskAppManager::AddObserver(KioskAppManagerObserver* observer) {
 336   observers_.AddObserver(observer);
 337 }
 338
 339 void KioskAppManager::RemoveObserver(KioskAppManagerObserver* observer) {
 340   observers_.RemoveObserver(observer);
 341 }
 342
 343 KioskAppManager::KioskAppManager() : ownership_established_(false) {
 344   UpdateAppData();
 345   local_accounts_subscription_ =
 346       CrosSettings::Get()->AddSettingsObserver(
 347           kAccountsPrefDeviceLocalAccounts,
 348           base::Bind(&KioskAppManager::UpdateAppData, base::Unretained(this)));
 349   local_account_auto_login_id_subscription_ =
 350       CrosSettings::Get()->AddSettingsObserver(
 351           kAccountsPrefDeviceLocalAccountAutoLoginId,
 352           base::Bind(&KioskAppManager::UpdateAppData, base::Unretained(this)));
 353 }
 354
 355 KioskAppManager::~KioskAppManager() {}
 356
 357 void KioskAppManager::CleanUp() {
 358   local_accounts_subscription_.reset();
 359   local_account_auto_login_id_subscription_.reset();
 360   apps_.clear();
 361 }
 362
 363 const KioskAppData* KioskAppManager::GetAppData(
 364     const std::string& app_id) const {
 365   for (size_t i = 0; i < apps_.size(); ++i) {
 366     const KioskAppData* data = apps_[i];
 367     if (data->app_id() == app_id)
 368       return data;
 369   }
 370
 371   return NULL;
 372 }
 373
 374 KioskAppData* KioskAppManager::GetAppDataMutable(const std::string& app_id) {
 375   return const_cast<KioskAppData*>(GetAppData(app_id));
 376 }
 377
 378 void KioskAppManager::UpdateAppData() {
 379   // Gets app id to data mapping for existing apps.
 380   std::map<std::string, KioskAppData*> old_apps;
 381   for (size_t i = 0; i < apps_.size(); ++i)
 382     old_apps[apps_[i]->app_id()] = apps_[i];
 383   apps_.weak_clear();  // |old_apps| takes ownership
 384
 385   auto_launch_app_id_.clear();
 386   std::string auto_login_account_id;
 387   CrosSettings::Get()->GetString(kAccountsPrefDeviceLocalAccountAutoLoginId,
 388                                  &auto_login_account_id);
 389
 390   // Re-populates |apps_| and reuses existing KioskAppData when possible.
 391   const std::vector<policy::DeviceLocalAccount> device_local_accounts =
 392       policy::GetDeviceLocalAccounts(CrosSettings::Get());
 393   for (std::vector<policy::DeviceLocalAccount>::const_iterator
 394            it = device_local_accounts.begin();
 395        it != device_local_accounts.end(); ++it) {
 396     if (it->type != policy::DeviceLocalAccount::TYPE_KIOSK_APP)
 397       continue;
 398
 399     if (it->account_id == auto_login_account_id)
 400       auto_launch_app_id_ = it->kiosk_app_id;
 401
 402     // TODO(mnissler): Support non-CWS update URLs.
 403
 404     std::map<std::string, KioskAppData*>::iterator old_it =
 405         old_apps.find(it->kiosk_app_id);
 406     if (old_it != old_apps.end()) {
 407       apps_.push_back(old_it->second);
 408       old_apps.erase(old_it);
 409     } else {
 410       KioskAppData* new_app =
 411           new KioskAppData(this, it->kiosk_app_id, it->user_id);
 412       apps_.push_back(new_app);  // Takes ownership of |new_app|.
 413       new_app->Load();
 414     }
 415   }
 416
 417   // Clears cache and deletes the remaining old data.
 418   for (std::map<std::string, KioskAppData*>::iterator it = old_apps.begin();
 419        it != old_apps.end(); ++it) {
 420     it->second->ClearCache();
 421     cryptohome::AsyncMethodCaller::GetInstance()->AsyncRemove(
 422         it->second->user_id(),
 423         base::Bind(&OnRemoveAppCryptohomeComplete, it->first));
 424   }
 425   STLDeleteValues(&old_apps);
 426
 427   FOR_EACH_OBSERVER(KioskAppManagerObserver, observers_,
 428                     OnKioskAppsSettingsChanged());
 429 }
 430
 431 void KioskAppManager::GetKioskAppIconCacheDir(base::FilePath* cache_dir) {
 432   base::FilePath user_data_dir;
 433   CHECK(PathService::Get(chrome::DIR_USER_DATA, &user_data_dir));
 434   *cache_dir = user_data_dir.AppendASCII(kIconCacheDir);
 435 }
 436
 437 void KioskAppManager::OnKioskAppDataChanged(const std::string& app_id) {
 438   FOR_EACH_OBSERVER(KioskAppManagerObserver,
 439                     observers_,
 440                     OnKioskAppDataChanged(app_id));
 441 }
 442
 443 void KioskAppManager::OnKioskAppDataLoadFailure(const std::string& app_id) {
 444   FOR_EACH_OBSERVER(KioskAppManagerObserver,
 445                     observers_,
 446                     OnKioskAppDataLoadFailure(app_id));
 447   RemoveApp(app_id);
 448 }
 449
 450 KioskAppManager::AutoLoginState KioskAppManager::GetAutoLoginState() const {
 451   PrefService* prefs = g_browser_process->local_state();
 452   const base::DictionaryValue* dict =
 453       prefs->GetDictionary(KioskAppManager::kKioskDictionaryName);
 454   int value;
 455   if (!dict->GetInteger(kKeyAutoLoginState, &value))
 456     return AUTOLOGIN_NONE;
 457
 458   return static_cast<AutoLoginState>(value);
 459 }
 460
 461 void KioskAppManager::SetAutoLoginState(AutoLoginState state) {
 462   PrefService* prefs = g_browser_process->local_state();
 463   DictionaryPrefUpdate dict_update(prefs,
 464                                    KioskAppManager::kKioskDictionaryName);
 465   dict_update->SetInteger(kKeyAutoLoginState, state);
 466   prefs->CommitPendingWrite();
 467 }
 468
 469 }  // namespace chromeos