Remove retail mode.

chrome/browser/chromeos/policy/device_policy_decoder_chromeos.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/device_policy_decoder_chromeos.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"

[bartfab (slow), 2014/10/15 09:52:20]

Nit: No longer needed.

[rkc, 2014/11/20 21:06:33]

Replied below.

 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/update_engine_client.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/schema.h"
 #include "policy/policy_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 239 matching lines @@
       policies->Set(key::kDeviceTransferSAMLCookies,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     new base::FundamentalValue(
                         container.transfer_saml_cookies()),
                     NULL);
     }
   }
 }
 
-void DecodeKioskPolicies(const em::ChromeDeviceSettingsProto& policy,
-                         PolicyMap* policies,
-                         EnterpriseInstallAttributes* install_attributes) {
-  // No policies if this is not KIOSK.
-  if (install_attributes->GetMode() != DEVICE_MODE_RETAIL_KIOSK)
-    return;
-
-  if (policy.has_forced_logout_timeouts()) {
-    const em::ForcedLogoutTimeoutsProto& container(
-        policy.forced_logout_timeouts());
-    if (container.has_idle_logout_timeout()) {
-      policies->Set(
-          key::kDeviceIdleLogoutTimeout,
-          POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE,
-          DecodeIntegerValue(container.idle_logout_timeout()).release(),
-          NULL);
-    }
-    if (container.has_idle_logout_warning_duration()) {
-      policies->Set(key::kDeviceIdleLogoutWarningDuration,
-                    POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE,
-                    DecodeIntegerValue(container.idle_logout_warning_duration())
-                        .release(),
-                    NULL);
-    }
-  }
-
-  if (policy.has_login_screen_saver()) {
-    const em::ScreenSaverProto& container(
-        policy.login_screen_saver());
-    if (container.has_screen_saver_extension_id()) {
-      policies->Set(key::kDeviceLoginScreenSaverId,
-                    POLICY_LEVEL_MANDATORY,
-                    POLICY_SCOPE_MACHINE,
-                    new base::StringValue(
-                        container.screen_saver_extension_id()),
-                    NULL);
-    }
-    if (container.has_screen_saver_timeout()) {
-      policies->Set(
-          key::kDeviceLoginScreenSaverTimeout,
-          POLICY_LEVEL_MANDATORY,
-          POLICY_SCOPE_MACHINE,
-          DecodeIntegerValue(container.screen_saver_timeout()).release(),
-          NULL);
-    }
-  }
-
-  if (policy.has_app_pack()) {
-    const em::AppPackProto& container(policy.app_pack());
-    base::ListValue* app_pack_list = new base::ListValue();
-    for (int i = 0; i < container.app_pack_size(); ++i) {
-      const em::AppPackEntryProto& entry(container.app_pack(i));
-      if (entry.has_extension_id() && entry.has_update_url()) {
-        base::DictionaryValue* dict = new base::DictionaryValue();
-        dict->SetString(chromeos::kAppPackKeyExtensionId, entry.extension_id());
-        dict->SetString(chromeos::kAppPackKeyUpdateUrl, entry.update_url());
-        app_pack_list->Append(dict);
-      }
-    }
-    policies->Set(key::kDeviceAppPack,
-                  POLICY_LEVEL_MANDATORY,
-                  POLICY_SCOPE_MACHINE,
-                  app_pack_list,
-                  NULL);
-  }
-
-  if (policy.has_pinned_apps()) {
-    const em::PinnedAppsProto& container(policy.pinned_apps());
-    base::ListValue* pinned_apps_list = new base::ListValue();
-    for (int i = 0; i < container.app_id_size(); ++i) {
-      pinned_apps_list->Append(
-          new base::StringValue(container.app_id(i)));
-    }
-
-    policies->Set(key::kPinnedLauncherApps,
-                  POLICY_LEVEL_RECOMMENDED,
-                  POLICY_SCOPE_MACHINE,
-                  pinned_apps_list,
-                  NULL);
-  }
-}
-
 void DecodeNetworkPolicies(const em::ChromeDeviceSettingsProto& policy,
                            PolicyMap* policies,
                            EnterpriseInstallAttributes* install_attributes) {

[bartfab (slow), 2014/10/15 09:52:20]

Nit: No longer needed.

[rkc, 2014/11/20 21:06:33]

Since DEVICE_MODE_RETAIL_KIOSK will still exist (and used to start up the
Offline Demo MOde), should we still leave the code below still in? I don't know
enough about the policy code to know if it is still relevant.

[bartfab (slow), 2014/11/27 16:25:47]

If I understand "offline demo mode" correctly, it should be entirely offline.
Hence, the proxy is irrelevant and we can remove the special case handling we
had for retail mode.

[rkc, 2014/12/01 19:15:04]

Ah - I honestly don't completely understand this code, hence am relying on you
to correct me :)
Changed this to no longer look at install attributes and check for the device
mode when setting the proxy settings policy (I am presuming that with the retail
mode code gone, we'll if the proxy settings are empty, we'll just set the policy
level to POLICY_LEVEL_RECOMMENDED?).

[bartfab (slow), 2014/12/02 21:25:26]

Proxy settings are documented as a mandatory user policy only. I do not
understand why we decode it as a recommended device policy here. I started a
thread to discuss this and CC'd you on it.

[rkc, 2014/12/04 19:50:06]

I'll leave this behavior as is for now? We can always create another CL to
remove this once we have a definitive answer on the thread.

[bartfab (slow), 2014/12/10 23:24:39]

Please add a TODO and file an M41 bug against me to kill this policy. I verified
that it was used by retail mode domains only. I will remove it once your CL has
landed.

[rkc, 2014/12/15 20:45:57]

Done.

   if (policy.has_device_proxy_settings()) {
     const em::DeviceProxySettingsProto& container(
         policy.device_proxy_settings());
     scoped_ptr<base::DictionaryValue> proxy_settings(new base::DictionaryValue);
     if (container.has_proxy_mode())
       proxy_settings->SetString(key::kProxyMode, container.proxy_mode());
     if (container.has_proxy_server())
       proxy_settings->SetString(key::kProxyServer, container.proxy_server());
     if (container.has_proxy_pac_url())
       proxy_settings->SetString(key::kProxyPacUrl, container.proxy_pac_url());
     if (container.has_proxy_bypass_list()) {
       proxy_settings->SetString(key::kProxyBypassList,
                                 container.proxy_bypass_list());
     }
 
-    // Figure out the level. Proxy policy is mandatory in kiosk mode.
-    PolicyLevel level = POLICY_LEVEL_RECOMMENDED;
-    if (install_attributes->GetMode() == DEVICE_MODE_RETAIL_KIOSK)
-      level = POLICY_LEVEL_MANDATORY;
-
     if (!proxy_settings->empty()) {
       policies->Set(key::kProxySettings,
-                    level,
+                    POLICY_LEVEL_RECOMMENDED,
                     POLICY_SCOPE_MACHINE,
                     proxy_settings.release(),
                     NULL);
     }
   }
 
   if (policy.has_data_roaming_enabled()) {
     const em::DataRoamingEnabledProto& container(policy.data_roaming_enabled());
     if (container.has_data_roaming_enabled()) {
       policies->Set(key::kDeviceDataRoamingEnabled,
@@ skipping 252 matching lines @@
     if (container.has_metrics_enabled()) {
       policies->Set(key::kDeviceMetricsReportingEnabled,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     new base::FundamentalValue(
                         container.metrics_enabled()),
                     NULL);
     }
   }
 
-  if (policy.has_start_up_urls()) {
-    const em::StartUpUrlsProto& container(policy.start_up_urls());
-    base::ListValue* urls = new base::ListValue();
-    RepeatedPtrField<std::string>::const_iterator entry;
-    for (entry = container.start_up_urls().begin();
-         entry != container.start_up_urls().end();
-         ++entry) {
-      urls->Append(new base::StringValue(*entry));
-    }
-    policies->Set(key::kDeviceStartUpUrls,
-                  POLICY_LEVEL_MANDATORY,
-                  POLICY_SCOPE_MACHINE,
-                  urls,
-                  NULL);
-  }
-
   if (policy.has_system_timezone()) {
     if (policy.system_timezone().has_timezone()) {
       policies->Set(key::kSystemTimezone,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     new base::StringValue(
                         policy.system_timezone().timezone()),
                     NULL);
     }
   }
@@ skipping 108 matching lines @@
           new base::FundamentalValue(container.block_devmode()),
           NULL);
     }
   }
 }
 
 }  // namespace
 
 void DecodeDevicePolicy(const em::ChromeDeviceSettingsProto& policy,
                         PolicyMap* policies,
                         EnterpriseInstallAttributes* install_attributes) {

[bartfab (slow), 2014/10/15 09:52:20]

Nit: No longer needed.

[rkc, 2014/11/20 21:06:33]

As above.

   // TODO(achuith): Remove this once crbug.com/263527 is resolved.
   VLOG(2) << "DecodeDevicePolicy " << policy.SerializeAsString();
 
   // Decode the various groups of policies.
   DecodeLoginPolicies(policy, policies);
-  DecodeKioskPolicies(policy, policies, install_attributes);
   DecodeNetworkPolicies(policy, policies, install_attributes);
   DecodeReportingPolicies(policy, policies);
   DecodeAutoUpdatePolicies(policy, policies);
   DecodeAccessibilityPolicies(policy, policies);
   DecodeGenericPolicies(policy, policies);
 }
 
 }  // namespace policy