Restore auto-launched state on kiosk restart within session

chrome/browser/chromeos/app_mode/kiosk_app_manager.cc

 // 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.
 
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 22 matching lines @@
 #include "chrome/browser/extensions/external_loader.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "components/ownership/owner_key_util.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/known_user.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
+#include "third_party/cros_system_api/switches/chrome_switches.h"
 
 namespace chromeos {
 
 namespace {
 
 // Domain that is used for kiosk-app account IDs.
 const char kKioskAppAccountDomain[] = "kiosk-apps";
 
 // Preference for the dictionary of user ids for which cryptohomes have to be
 // removed upon browser restart.
@@ skipping 76 matching lines @@
 base::Version GetPlatformVersion() {
   int32_t major_version;
   int32_t minor_version;
   int32_t bugfix_version;
   base::SysInfo::OperatingSystemVersionNumbers(&major_version, &minor_version,
                                                &bugfix_version);
   return base::Version(base::StringPrintf("%d.%d.%d", major_version,
                                           minor_version, bugfix_version));
 }
 
+// Converts a flag constant to actual command line switch value.
+std::string GetSwitchString(const std::string& flag_name) {
+  base::CommandLine cmd_line(base::CommandLine::NO_PROGRAM);
+  cmd_line.AppendSwitch(flag_name);
+  DCHECK_EQ(2U, cmd_line.argv().size());
+  return cmd_line.argv()[1];
+}
+
 }  // namespace
 
 // static
 const char KioskAppManager::kKioskDictionaryName[] = "kiosk";
 const char KioskAppManager::kKeyApps[] = "apps";
 const char KioskAppManager::kKeyAutoLoginState[] = "auto_login_state";
 const char KioskAppManager::kIconCacheDir[] = "kiosk/icon";
 const char KioskAppManager::kCrxCacheDir[] = "kiosk/crx";
 const char KioskAppManager::kCrxUnpackDir[] = "kiosk_unpack";
 
@@ skipping 74 matching lines @@
 void KioskAppManager::SetAppWasAutoLaunchedWithZeroDelay(
     const std::string& app_id) {
   DCHECK_EQ(auto_launch_app_id_, app_id);
   currently_auto_launched_with_zero_delay_app_ = app_id;
 }
 
 void KioskAppManager::InitSession(Profile* profile,
                                    const std::string& app_id) {
   LOG_IF(FATAL, app_session_) << "Kiosk session is already initialized.";
 
+  base::CommandLine session_flags(base::CommandLine::NO_PROGRAM);
+  if (GetSwitchesForSessionRestore(app_id, &session_flags)) {
+    base::CommandLine::StringVector flags;
+    // argv[0] is the program name |base::CommandLine::NO_PROGRAM|.
+    flags.assign(session_flags.argv().begin() + 1, session_flags.argv().end());
+
+    // Update user flags, but do not restart Chrome - the purpose of the flags
+    // set here is to be able to properly restore session if the session is
+    // restarted - e.g. due to crash. For example, this will ensure restarted
+    // app session restores auto-launched state.
+    DBusThreadManager::Get()->GetSessionManagerClient()->SetFlagsForUser(
+        cryptohome::Identification(
+            user_manager::UserManager::Get()->GetActiveUser()->GetAccountId()),
+        flags);
+  }
+
   app_session_.reset(new AppSession);
   app_session_->Init(profile, app_id);
 }
 
+bool KioskAppManager::GetSwitchesForSessionRestore(
+    const std::string& app_id,
+    base::CommandLine* switches) {
+  bool auto_launched = app_id == currently_auto_launched_with_zero_delay_app_;
+  const base::CommandLine* current_command_line =
+      base::CommandLine::ForCurrentProcess();
+  bool has_auto_launched_flag =
+      current_command_line->HasSwitch(switches::kAppAutoLaunched);
+  if (auto_launched == has_auto_launched_flag)
+    return false;
+
+  // Collect current policy defined switches, so they can be passed on to the
+  // session manager as well - otherwise they would get lost on restart.
+  // This ignores 'flag-switches-begin' - 'flag-switches-end' flags, but those
+  // should not be present for kiosk sessions.
+  bool in_policy_switches_block = false;
+  const std::string policy_switches_begin =
+      GetSwitchString(switches::kPolicySwitchesBegin);
+  const std::string policy_switches_end =
+      GetSwitchString(switches::kPolicySwitchesEnd);
+
+  for (const auto& it : current_command_line->argv()) {
+    if (it == policy_switches_begin) {
+      DCHECK(!in_policy_switches_block);
+      in_policy_switches_block = true;
+    }
+
+    if (in_policy_switches_block)
+      switches->AppendSwitch(it);
+
+    if (it == policy_switches_end) {
+      DCHECK(in_policy_switches_block);
+      in_policy_switches_block = false;
+    }
+  }
+
+  DCHECK(!in_policy_switches_block);
+
+  if (auto_launched)
+    switches->AppendSwitch(switches::kAppAutoLaunched);
+
+  return true;
+}
+
 void KioskAppManager::AddAppForTest(
     const std::string& app_id,
     const AccountId& account_id,
     const GURL& update_url,
     const std::string& required_platform_version) {
   for (auto it = apps_.begin(); it != apps_.end(); ++it) {
     if ((*it)->app_id() == app_id) {
       apps_.erase(it);
       break;
     }
@@ skipping 640 matching lines @@
 base::TimeDelta KioskAppManager::GetAutoLaunchDelay() const {
   int delay;
   if (!CrosSettings::Get()->GetInteger(
           kAccountsPrefDeviceLocalAccountAutoLoginDelay, &delay)) {
     return base::TimeDelta();  // Default delay is 0ms.
   }
   return base::TimeDelta::FromMilliseconds(delay);
 }
 
 }  // namespace chromeos