Merge 94322 - Rewire the metrics pref to the signed settings store on chromeos.

chrome/browser/chromeos/user_cros_settings_provider.cc

 // Copyright (c) 2011 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/user_cros_settings_provider.h"
 
 #include <map>
 #include <set>
 
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/login_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/ui/options/options_util.h"
+#include "chrome/installer/util/google_update_settings.h"
 #include "content/browser/browser_thread.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kTrueIncantation[] = "true";
 const char kFalseIncantation[] = "false";
 const char kTrustedSuffix[] = "/trusted";
 
 // For all our boolean settings following is applicable:
 // true is default permissive value and false is safe prohibitic value.
 // Exception: kSignedDataRoamingEnabled which has default value of false.
 const char* kBooleanSettings[] = {
   kAccountsPrefAllowNewUser,
   kAccountsPrefAllowGuest,
   kAccountsPrefShowUserNamesOnSignIn,
   kSignedDataRoamingEnabled,
+  kStatsReportingPref
 };
 
 const char* kStringSettings[] = {
   kDeviceOwner,
   kReleaseChannel
 };
 
 const char* kListSettings[] = {
   kAccountsPrefUsers
 };
 
 bool IsControlledBooleanSetting(const std::string& pref_path) {
   // TODO(nkostylev): Using std::find for 4 value array generates this warning
   // in chroot stl_algo.h:231: error: array subscript is above array bounds.
   // GCC 4.4.3
   return (pref_path == kAccountsPrefAllowNewUser) ||
          (pref_path == kAccountsPrefAllowGuest) ||
          (pref_path == kAccountsPrefShowUserNamesOnSignIn) ||
-         (pref_path == kSignedDataRoamingEnabled);
+         (pref_path == kSignedDataRoamingEnabled) ||
+         (pref_path == kStatsReportingPref);
 }
 
 bool IsControlledStringSetting(const std::string& pref_path) {
   return std::find(kStringSettings,
                    kStringSettings + arraysize(kStringSettings),
                    pref_path) !=
       kStringSettings + arraysize(kStringSettings);
 }
 
 bool IsControlledListSetting(const std::string& pref_path) {
   return std::find(kListSettings,
                    kListSettings + arraysize(kListSettings),
                    pref_path) !=
       kListSettings + arraysize(kListSettings);
 }
 
 void RegisterSetting(PrefService* local_state, const std::string& pref_path) {
   local_state->RegisterBooleanPref((pref_path + kTrustedSuffix).c_str(),
                                    false,
                                    PrefService::UNSYNCABLE_PREF);
   if (IsControlledBooleanSetting(pref_path)) {
-    if (pref_path == kSignedDataRoamingEnabled)
+    if (pref_path == kSignedDataRoamingEnabled ||
+        pref_path == kStatsReportingPref)
       local_state->RegisterBooleanPref(pref_path.c_str(),
                                        false,
                                        PrefService::UNSYNCABLE_PREF);
     else
       local_state->RegisterBooleanPref(pref_path.c_str(),
                                        true,
                                        PrefService::UNSYNCABLE_PREF);
   } else if (IsControlledStringSetting(pref_path)) {
     local_state->RegisterStringPref(pref_path.c_str(),
                                     "",
@@ skipping 183 matching lines @@
   }
 
   // Called right before boolean property is changed.
   void OnBooleanPropertyChange(const std::string& path, bool new_value) {
     if (path == kSignedDataRoamingEnabled) {
       if (!CrosLibrary::Get()->EnsureLoaded())
         return;
 
       NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
       cros->SetCellularDataRoamingAllowed(new_value);
+    } else if (path == kStatsReportingPref) {
+      // TODO(pastarmovj): Remove this once we don't need to regenerate the
+      // consent file for the GUID anymore.
+      OptionsUtil::ResolveMetricsReportingEnabled(new_value);
     }
   }
 
   // Called right after signed value was checked.
   void OnBooleanPropertyRetrieve(const std::string& path,
                                  bool value,
                                  UseValue use_value) {
     if (path == kSignedDataRoamingEnabled) {
       if (!CrosLibrary::Get()->EnsureLoaded())
         return;
 
       NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
       const NetworkDevice* cellular = cros->FindCellularDevice();
       if (cellular) {
         bool device_value = cellular->data_roaming_allowed();
         bool new_value = (use_value == USE_VALUE_SUPPLIED) ? value : false;
         if (device_value != new_value)
           cros->SetCellularDataRoamingAllowed(new_value);
       }
+    } else if (path == kStatsReportingPref) {
+      bool stats_consent = (use_value == USE_VALUE_SUPPLIED) ? value : false;
+      // TODO(pastarmovj): Remove this once we don't need to regenerate the
+      // consent file for the GUID anymore.
+      VLOG(1) << "Metrics policy is being set to : " << stats_consent
+              << "(reason : " << use_value << ")";
+      OptionsUtil::ResolveMetricsReportingEnabled(stats_consent);
     }
   }
 
   void StartFetchingSetting(const std::string& name) {
     DCHECK(g_browser_process);
     PrefService* prefs = g_browser_process->local_state();
     if (!prefs)
       return;
     // Do not trust before fetching complete.
     prefs->ClearPref((name + kTrustedSuffix).c_str());
@@ skipping 163 matching lines @@
     Task* callback) {
   return UserCrosSettingsTrust::GetInstance()->RequestTrustedEntity(
       kSignedDataRoamingEnabled, callback);
 }
 
 bool UserCrosSettingsProvider::RequestTrustedOwner(Task* callback) {
   return UserCrosSettingsTrust::GetInstance()->RequestTrustedEntity(
       kDeviceOwner, callback);
 }
 
+bool UserCrosSettingsProvider::RequestTrustedReportingEnabled(Task* callback) {
+  return UserCrosSettingsTrust::GetInstance()->RequestTrustedEntity(
+      kStatsReportingPref, callback);
+}
+
 void UserCrosSettingsProvider::Reload() {
   UserCrosSettingsTrust::GetInstance()->Reload();
 }
 
 // static
 bool UserCrosSettingsProvider::cached_allow_guest() {
   // Trigger prefetching if singleton object still does not exist.
   UserCrosSettingsTrust::GetInstance();
   return g_browser_process->local_state()->GetBoolean(kAccountsPrefAllowGuest);
 }
@@ skipping 16 matching lines @@
 
 // static
 bool UserCrosSettingsProvider::cached_show_users_on_signin() {
   // Trigger prefetching if singleton object still does not exist.
   UserCrosSettingsTrust::GetInstance();
   return g_browser_process->local_state()->GetBoolean(
       kAccountsPrefShowUserNamesOnSignIn);
 }
 
 // static
+bool UserCrosSettingsProvider::cached_reporting_enabled() {
+  // Trigger prefetching if singleton object still does not exist.
+  UserCrosSettingsTrust::GetInstance();
+  return g_browser_process->local_state()->GetBoolean(
+      kStatsReportingPref);
+}
+
+// static
 const ListValue* UserCrosSettingsProvider::cached_whitelist() {
   PrefService* prefs = g_browser_process->local_state();
   const ListValue* cached_users = prefs->GetList(kAccountsPrefUsers);
   if (!prefs->IsManagedPreference(kAccountsPrefUsers)) {
     if (cached_users == NULL) {
       // Update whitelist cache.
       GetUserWhitelist(NULL);
       cached_users = prefs->GetList(kAccountsPrefUsers);
     }
   }
@@ skipping 53 matching lines @@
         !UserManager::Get()->current_user_is_owner());
     return true;
   }
 
   return false;
 }
 
 bool UserCrosSettingsProvider::HandlesSetting(const std::string& path) {
   return ::StartsWithASCII(path, "cros.accounts.", true) ||
       ::StartsWithASCII(path, "cros.signed.", true) ||
+      ::StartsWithASCII(path, "cros.metrics.", true) ||
       path == kReleaseChannel;
 }
 
 void UserCrosSettingsProvider::WhitelistUser(const std::string& email) {
   SignedSettingsHelper::Get()->StartWhitelistOp(
       email, true, UserCrosSettingsTrust::GetInstance());
   PrefService* prefs = g_browser_process->local_state();
   ListPrefUpdate cached_whitelist_update(prefs, kAccountsPrefUsers);
   cached_whitelist_update->Append(Value::CreateStringValue(email));
   prefs->ScheduleSavePersistentPrefs();
 }
 
 void UserCrosSettingsProvider::UnwhitelistUser(const std::string& email) {
   SignedSettingsHelper::Get()->StartWhitelistOp(
       email, false, UserCrosSettingsTrust::GetInstance());
 
   PrefService* prefs = g_browser_process->local_state();
   ListPrefUpdate cached_whitelist_update(prefs, kAccountsPrefUsers);
   StringValue email_value(email);
   if (cached_whitelist_update->Remove(email_value) != -1)
     prefs->ScheduleSavePersistentPrefs();
 }
 
 // static
 void UserCrosSettingsProvider::UpdateCachedOwner(const std::string& email) {
   UpdateCacheString(kDeviceOwner, email, USE_VALUE_SUPPLIED);
 }
 
 }  // namespace chromeos