Enabled consumer kiosk mode for all.

chrome/browser/chromeos/policy/enterprise_install_attributes.cc

 // Copyright (c) 2012 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/policy/enterprise_install_attributes.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 13 matching lines @@
 
 // Translates DeviceMode constants to strings used in the lockbox.
 std::string GetDeviceModeString(DeviceMode mode) {
   switch (mode) {
     case DEVICE_MODE_CONSUMER:
       return EnterpriseInstallAttributes::kConsumerDeviceMode;
     case DEVICE_MODE_ENTERPRISE:
       return EnterpriseInstallAttributes::kEnterpiseDeviceMode;
     case DEVICE_MODE_RETAIL_KIOSK:
       return EnterpriseInstallAttributes::kRetailKioskDeviceMode;
-    case DEVICE_MODE_CONSUMER_KIOSK:
+    case DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH:
       return EnterpriseInstallAttributes::kConsumerKioskDeviceMode;
     case DEVICE_MODE_PENDING:
     case DEVICE_MODE_NOT_SET:
       break;
   }
   NOTREACHED() << "Invalid device mode: " << mode;
   return EnterpriseInstallAttributes::kUnknownDeviceMode;
 }
 
 // Translates strings used in the lockbox to DeviceMode values.
 DeviceMode GetDeviceModeFromString(
     const std::string& mode) {
   if (mode == EnterpriseInstallAttributes::kConsumerDeviceMode)
     return DEVICE_MODE_CONSUMER;
   else if (mode == EnterpriseInstallAttributes::kEnterpiseDeviceMode)
     return DEVICE_MODE_ENTERPRISE;
   else if (mode == EnterpriseInstallAttributes::kRetailKioskDeviceMode)
     return DEVICE_MODE_RETAIL_KIOSK;
   else if (mode == EnterpriseInstallAttributes::kConsumerKioskDeviceMode)
-    return DEVICE_MODE_CONSUMER_KIOSK;
+    return DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH;
   NOTREACHED() << "Unknown device mode string: " << mode;
   return DEVICE_MODE_NOT_SET;
 }
 
 bool ReadMapKey(const std::map<std::string, std::string>& map,
                 const std::string& key,
                 std::string* value) {
   std::map<std::string, std::string>::const_iterator entry = map.find(key);
   if (entry == map.end())
     return false;
@@ skipping 118 matching lines @@
     const std::string& user,
     DeviceMode device_mode,
     const std::string& device_id,
     const LockResultCallback& callback) {
   DCHECK(!callback.is_null());
   CHECK_NE(device_mode, DEVICE_MODE_PENDING);
   CHECK_NE(device_mode, DEVICE_MODE_NOT_SET);
 
   // Check for existing lock first.
   if (device_locked_) {
-    if (device_mode == DEVICE_MODE_CONSUMER_KIOSK) {
+    if (device_mode == DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH) {
       callback.Run((registration_mode_ == device_mode) ? LOCK_SUCCESS :
                                                          LOCK_NOT_READY);
     } else {
       std::string domain = gaia::ExtractDomainName(user);
       callback.Run(
           (!registration_domain_.empty() && domain == registration_domain_) ?
               LOCK_SUCCESS : LOCK_WRONG_USER);
     }
     return;
   }
@@ skipping 36 matching lines @@
   if (!cryptohome_util::InstallAttributesIsFirstInstall()) {
     callback.Run(LOCK_WRONG_USER);
     return;
   }
 
   std::string mode = GetDeviceModeString(device_mode);
   std::string registration_user;
   if (!user.empty())
     registration_user = gaia::CanonicalizeEmail(user);
 
-  if (device_mode == DEVICE_MODE_CONSUMER_KIOSK) {
+  if (device_mode == DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH) {
     // Set values in the InstallAttrs and lock it.
     if (!cryptohome_util::InstallAttributesSet(kAttrConsumerKioskEnabled,
                                                "true")) {
       LOG(ERROR) << "Failed writing attributes";
       callback.Run(LOCK_BACKEND_ERROR);
       return;
     }
   } else {
     std::string domain = gaia::ExtractDomainName(registration_user);
     // Set values in the InstallAttrs and lock it.
@@ skipping 35 matching lines @@
     return;
   }
 
   callback.Run(LOCK_SUCCESS);
 }
 
 bool EnterpriseInstallAttributes::IsEnterpriseDevice() {
   return device_locked_ && !registration_user_.empty();
 }
 
-bool EnterpriseInstallAttributes::IsConsumerKioskDevice() {
-  return device_locked_ && registration_mode_ == DEVICE_MODE_CONSUMER_KIOSK;
+bool EnterpriseInstallAttributes::IsConsumerKioskDeviceWithAutoLaunch() {
+  return device_locked_ &&
+         registration_mode_ == DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH;
 }
 
 std::string EnterpriseInstallAttributes::GetRegistrationUser() {
   if (!device_locked_)
     return std::string();
 
   return registration_user_;
 }
 
 std::string EnterpriseInstallAttributes::GetDomain() {
@@ skipping 40 matching lines @@
 
     ReadMapKey(attr_map, kAttrEnterpriseDeviceId, &registration_device_id_);
 
     std::string mode;
     if (ReadMapKey(attr_map, kAttrEnterpriseMode, &mode))
       registration_mode_ = GetDeviceModeFromString(mode);
   } else if (ReadMapKey(attr_map,
                         kAttrConsumerKioskEnabled,
                         &consumer_kiosk_enabled) &&
              consumer_kiosk_enabled == "true") {
-    registration_mode_ = DEVICE_MODE_CONSUMER_KIOSK;
+    registration_mode_ = DEVICE_MODE_CONSUMER_KIOSK_AUTOLAUNCH;
   } else if (enterprise_user.empty() && enterprise_owned != "true") {
     // |registration_user_| is empty on consumer devices.
     registration_mode_ = DEVICE_MODE_CONSUMER;
   }
 }
 
 }  // namespace policy