Move pref backing up flags from local state to device settings on ChromeOS.

chrome/browser/chromeos/settings/device_settings_provider.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/settings/device_settings_provider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/chromeos/settings/device_settings_cache.h"
 #include "chrome/browser/policy/app_pack_updater.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud_policy_constants.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/ui/options/options_util.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/installer/util/google_update_settings.h"
 
 using google::protobuf::RepeatedPtrField;
 
 namespace em = enterprise_management;
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 17 matching lines @@
   kReportDeviceBootMode,
   kReportDeviceLocation,
   kReportDeviceVersionInfo,
   kScreenSaverExtensionId,
   kScreenSaverTimeout,
   kSettingProxyEverywhere,
   kSignedDataRoamingEnabled,
   kStartUpUrls,
   kStatsReportingPref,
   kSystemTimezonePolicy,
+  kStartUpFlags,
 };
 
 // Legacy policy file location. Used to detect migration from pre v12 ChromeOS.
 const char kLegacyPolicyFile[] = "/var/lib/whitelist/preferences";
 
 bool HasOldMetricsFile() {
   // TODO(pastarmovj): Remove this once migration is not needed anymore.
   // If the value is not set we should try to migrate legacy consent file.
   // Loading consent file state causes us to do blocking IO on UI thread.
   // Temporarily allow it until we fix http://crbug.com/62626
@@ skipping 191 matching lines @@
     bool metrics_value = false;
     if (value->GetAsBoolean(&metrics_value))
       metrics->set_metrics_enabled(metrics_value);
     else
       NOTREACHED();
     ApplyMetricsSetting(false, metrics_value);
   } else if (prop == kAccountsPrefUsers) {
     em::UserWhitelistProto* whitelist_proto =
         device_settings_.mutable_user_whitelist();
     whitelist_proto->clear_user_whitelist();
-    base::ListValue& users = static_cast<base::ListValue&>(*value);
-    for (base::ListValue::const_iterator i = users.begin();
-         i != users.end(); ++i) {
-      std::string email;
-      if ((*i)->GetAsString(&email))
-        whitelist_proto->add_user_whitelist(email.c_str());
+    const base::ListValue* users;
+    if (value->GetAsList(&users)) {
+      for (base::ListValue::const_iterator i = users->begin();
+           i != users->end(); ++i) {
+        std::string email;
+        if ((*i)->GetAsString(&email))
+          whitelist_proto->add_user_whitelist(email);
+      }
     }
   } else if (prop == kAccountsPrefEphemeralUsersEnabled) {
     em::EphemeralUsersEnabledProto* ephemeral_users_enabled =
         device_settings_.mutable_ephemeral_users_enabled();
     bool ephemeral_users_enabled_value = false;
     if (value->GetAsBoolean(&ephemeral_users_enabled_value)) {
       ephemeral_users_enabled->set_ephemeral_users_enabled(
           ephemeral_users_enabled_value);
     } else {
       NOTREACHED();
     }
   } else if (prop == kAllowRedeemChromeOsRegistrationOffers) {
     em::AllowRedeemChromeOsRegistrationOffersProto* allow_redeem_offers =
         device_settings_.mutable_allow_redeem_offers();
     bool allow_redeem_offers_value = true;
     if (value->GetAsBoolean(&allow_redeem_offers_value)) {
       allow_redeem_offers->set_allow_redeem_offers(
           allow_redeem_offers_value);
     } else {
       NOTREACHED();
     }
+  } else if (prop == kStartUpFlags) {
+    em::StartUpFlagsProto* flags_proto =
+        device_settings_.mutable_start_up_flags();
+    flags_proto->Clear();
+    const base::ListValue* flags;
+    if (value->GetAsList(&flags)) {
+      for (base::ListValue::const_iterator i = flags->begin();
+           i != flags->end(); ++i) {
+        std::string flag;
+        if ((*i)->GetAsString(&flag))
+          flags_proto->add_flags(flag);
+      }
+    }
   } else {
     // The remaining settings don't support Set(), since they are not
     // intended to be customizable by the user:
     //   kAppPack
     //   kDeviceOwner
     //   kIdleLogoutTimeout
     //   kIdleLogoutWarningDuration
     //   kReleaseChannelDelegated
     //   kReportDeviceVersionInfo
     //   kReportDeviceActivityTimes
@@ skipping 85 matching lines @@
   if (!command_line->HasSwitch(switches::kDisableLocalAccounts)) {
     const RepeatedPtrField<em::DeviceLocalAccountInfoProto>& accounts =
         policy.device_local_accounts().account();
     RepeatedPtrField<em::DeviceLocalAccountInfoProto>::const_iterator entry;
     for (entry = accounts.begin(); entry != accounts.end(); ++entry) {
       if (entry->has_id())
         account_list->AppendString(entry->id());
     }
   }
   new_values_cache->SetValue(kAccountsPrefDeviceLocalAccounts, account_list);
+
+  if (policy.has_start_up_flags()) {
+    base::ListValue* list = new base::ListValue();
+    const em::StartUpFlagsProto& flags_proto = policy.start_up_flags();
+    const RepeatedPtrField<std::string>& flags = flags_proto.flags();
+    for (RepeatedPtrField<std::string>::const_iterator it = flags.begin();
+         it != flags.end(); ++it) {
+      list->Append(new base::StringValue(*it));
+    }
+    new_values_cache->SetValue(kStartUpFlags, list);
+  }
 }
 
 void DeviceSettingsProvider::DecodeKioskPolicies(
     const em::ChromeDeviceSettingsProto& policy,
     PrefValueMap* new_values_cache) const {
   if (policy.has_forced_logout_timeouts()) {
     if (policy.forced_logout_timeouts().has_idle_logout_timeout()) {
       new_values_cache->SetInteger(
           kIdleLogoutTimeout,
           policy.forced_logout_timeouts().idle_logout_timeout());
@@ skipping 178 matching lines @@
   trusted_status_ = trusted_status;
   for (size_t i = 0; i < notifications.size(); ++i)
     NotifyObservers(notifications[i]);
 }
 
 void DeviceSettingsProvider::ApplyMetricsSetting(bool use_file,
                                                  bool new_value) {
   // TODO(pastarmovj): Remove this once migration is not needed anymore.
   // If the value is not set we should try to migrate legacy consent file.
   if (use_file) {
+    UMA_HISTOGRAM_COUNTS("DeviceSettings.MetricsMigrated", 1);
     new_value = HasOldMetricsFile();
     // Make sure the values will get eventually written to the policy file.
     migration_values_.SetValue(kStatsReportingPref,
                                base::Value::CreateBooleanValue(new_value));
     AttemptMigration();
     LOG(INFO) << "No metrics policy set will revert to checking "
               << "consent file which is "
               << (new_value ? "on." : "off.");
   }
   VLOG(1) << "Metrics policy is being set to : " << new_value
@@ skipping 19 matching lines @@
 }
 
 void DeviceSettingsProvider::ApplySideEffects(
     const em::ChromeDeviceSettingsProto& settings) {
   // First migrate metrics settings as needed.
   if (settings.has_metrics_enabled())
     ApplyMetricsSetting(false, settings.metrics_enabled().metrics_enabled());
   else
     ApplyMetricsSetting(true, false);
 
+  // TODO(pastarmovj): Remove this after we don't need it anymore.
+  // See: http://crosbug.com/39553
+  // Migrate flags to device settings.
+  PrefService* local_state = g_browser_process->local_state();
+  if (local_state->HasPrefPath(prefs::kEnabledLabsExperiments)) {
+    if (!settings.has_start_up_flags()) {
+      const base::ListValue* flags =
+          local_state->GetList(prefs::kEnabledLabsExperiments);
+      migration_values_.SetValue(kStartUpFlags, flags->DeepCopy());
+      AttemptMigration();
+    } else {
+      // Either it has been properly migrated or the user already specified new
+      // flags in the device policy.
+      UMA_HISTOGRAM_COUNTS("DeviceSettings.FlagsMigrated", 1);
+      local_state->ClearPref(prefs::kEnabledLabsExperiments);
+    }
+  }
+
   // Next set the roaming setting as needed.
   ApplyRoamingSetting(
       settings.has_data_roaming_enabled() ?
           settings.data_roaming_enabled().data_roaming_enabled() :
           false);
 }
 
 bool DeviceSettingsProvider::MitigateMissingPolicy() {
   // First check if the device has been owned already and if not exit
   // immediately.
@@ skipping 138 matching lines @@
 void DeviceSettingsProvider::AttemptMigration() {
   if (device_settings_service_->HasPrivateOwnerKey()) {
     PrefValueMap::const_iterator i;
     for (i = migration_values_.begin(); i != migration_values_.end(); ++i)
       DoSet(i->first, *i->second);
     migration_values_.Clear();
   }
 }
 
 }  // namespace chromeos