Use kMetricsReportingEnabled instead of kStatsReporingPref on metrics side

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/logging.h"
@@ skipping 68 matching lines @@
     kServiceAccountIdentity,
     kSignedDataRoamingEnabled,
     kStartUpFlags,
     kStatsReportingPref,
     kSystemTimezonePolicy,
     kSystemUse24HourClock,
     kUpdateDisabled,
     kVariationsRestrictParameter,
 };
 
-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
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  return GoogleUpdateSettings::GetCollectStatsConsent();
-}
-
 void DecodeLoginPolicies(
     const em::ChromeDeviceSettingsProto& policy,
     PrefValueMap* new_values_cache) {
   // For all our boolean settings the following is applicable:
   // true is default permissive value and false is safe prohibitive value.
   // Exceptions:
   //   kAccountsPrefEphemeralUsersEnabled has a default value of false.
   //   kAccountsPrefSupervisedUsersEnabled has a default value of false
   //     for enterprise devices and true for consumer devices.
   //   kAccountsPrefTransferSAMLCookies has a default value of false.
@@ skipping 256 matching lines @@
         heartbeat_policy.heartbeat_frequency());
   }
 }
 
 void DecodeGenericPolicies(
     const em::ChromeDeviceSettingsProto& policy,
     PrefValueMap* new_values_cache) {
   if (policy.has_metrics_enabled()) {
     new_values_cache->SetBoolean(kStatsReportingPref,
                                  policy.metrics_enabled().metrics_enabled());
-  } else {
-    new_values_cache->SetBoolean(kStatsReportingPref, HasOldMetricsFile());
   }
 
   if (!policy.has_release_channel() ||
       !policy.release_channel().has_release_channel()) {
     // Default to an invalid channel (will be ignored).
     new_values_cache->SetString(kReleaseChannel, "");
   } else {
     new_values_cache->SetString(kReleaseChannel,
                                 policy.release_channel().release_channel());
   }
@@ skipping 153 matching lines @@
     // Set the cache to the updated value.
     UpdateValuesCache(data, device_settings_, TEMPORARILY_UNTRUSTED);
 
     if (!device_settings_cache::Store(data, g_browser_process->local_state())) {
       LOG(ERROR) << "Couldn't store to the temp storage.";
       NotifyObservers(path);
       return;
     }
   }
 
-  bool metrics_value;
-  if (path == kStatsReportingPref && in_value.GetAsBoolean(&metrics_value))
-    ApplyMetricsSetting(false, metrics_value);
 }
 
 void DeviceSettingsProvider::OwnershipStatusChanged() {
   DeviceSettingsService::OwnershipStatus new_ownership_status =
       device_settings_service_->GetOwnershipStatus();
 
   if (device_settings_service_->GetOwnerSettingsService())
     device_settings_service_->GetOwnerSettingsService()->AddObserver(this);
 
   // If the device just became owned, write the settings accumulated in the
@@ skipping 19 matching lines @@
 
     scoped_ptr<em::PolicyData> policy(new em::PolicyData());
     policy->set_username(device_settings_service_->GetUsername());
     CHECK(device_settings_.SerializeToString(policy->mutable_policy_value()));
     if (!device_settings_service_->GetOwnerSettingsService()
              ->CommitTentativeDeviceSettings(policy.Pass())) {
       LOG(ERROR) << "Can't store policy";
     }
   }
 
-  // The owner key might have become available, allowing migration to happen.
-  AttemptMigration();
-
   ownership_status_ = new_ownership_status;
 }
 
 void DeviceSettingsProvider::DeviceSettingsUpdated() {
   if (!store_callback_factory_.HasWeakPtrs())
     UpdateAndProceedStoring();
 }
 
 void DeviceSettingsProvider::OnDeviceSettingsServiceShutdown() {
   device_settings_service_ = nullptr;
@@ skipping 65 matching lines @@
     if (!new_values_cache.GetValue(iter->first, &value))
       notifications.push_back(iter->first);
   }
   // Swap and notify.
   values_cache_.Swap(&new_values_cache);
   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) {
-    new_value = HasOldMetricsFile();
-    // Make sure the values will get eventually written to the policy file.
-    migration_values_.SetBoolean(kStatsReportingPref, new_value);
-    AttemptMigration();
-    VLOG(1) << "No metrics policy set will revert to checking "
-            << "consent file which is "
-            << (new_value ? "on." : "off.");
-    UMA_HISTOGRAM_COUNTS("DeviceSettings.MetricsMigrated", 1);
-  }
-  VLOG(1) << "Metrics policy is being set to : " << new_value
-          << "(use file : " << use_file << ")";
-  // TODO(pastarmovj): Remove this once we don't need to regenerate the
-  // consent file for the GUID anymore.
-  InitiateMetricsReportingChange(new_value, OnMetricsReportingCallbackType());
-}
-
-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);
-}
-
 bool DeviceSettingsProvider::MitigateMissingPolicy() {
   // First check if the device has been owned already and if not exit
   // immediately.
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   if (connector->GetDeviceMode() != policy::DEVICE_MODE_CONSUMER)
     return false;
 
   // If we are here the policy file were corrupted or missing. This can happen
   // because we are migrating Pre R11 device to the new secure policies or there
@@ skipping 60 matching lines @@
       const em::ChromeDeviceSettingsProto* device_settings =
           device_settings_service_->device_settings();
       if (policy_data && device_settings) {
         if (!device_settings_cache::Store(*policy_data,
                                           g_browser_process->local_state())) {
           LOG(ERROR) << "Couldn't update the local state cache.";
         }
         UpdateValuesCache(*policy_data, *device_settings, TRUSTED);
         device_settings_ = *device_settings;
 
-        // TODO(pastarmovj): Make those side effects responsibility of the
-        // respective subsystems.
-        ApplySideEffects(*device_settings);
-
         settings_loaded = true;
       } else {
         // Initial policy load is still pending.
         trusted_status_ = TEMPORARILY_UNTRUSTED;
       }
       break;
     }
     case DeviceSettingsService::STORE_NO_POLICY:
       if (MitigateMissingPolicy())
         break;
@@ skipping 21 matching lines @@
 
   // Notify the observers we are done.
   std::vector<base::Closure> callbacks;
   callbacks.swap(callbacks_);
   for (size_t i = 0; i < callbacks.size(); ++i)
     callbacks[i].Run();
 
   return settings_loaded;
 }
 
-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