[Variations] Read the policy from profile prefs if on Android

chrome/browser/metrics/variations/variations_service.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/metrics/variations/variations_service.h"
 
 #include <set>
 
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/network_time/network_time_tracker.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "components/user_prefs/pref_registry_syncable.h"
 #include "components/variations/proto/variations_seed.pb.h"
 #include "components/variations/variations_seed_processor.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_util.h"
@@ skipping 67 matching lines @@
   return "android";
 #elif defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)
   // Default BSD and SOLARIS to Linux to not break those builds, although these
   // platforms are not officially supported by Chrome.
   return "linux";
 #else
 #error Unknown platform
 #endif
 }
 
-// Gets the restrict parameter from |local_state| or from Chrome OS settings in
-// the case of that platform.
-std::string GetRestrictParameterPref(PrefService* local_state) {
+// Gets the restrict parameter from |policy_pref_service| or from Chrome OS
+// settings in the case of that platform.
+std::string GetRestrictParameterPref(PrefService* policy_pref_service) {
   std::string parameter;
 #if defined(OS_CHROMEOS)
   chromeos::CrosSettings::Get()->GetString(
       chromeos::kVariationsRestrictParameter, &parameter);
 #else
-  if (local_state)
-    parameter = local_state->GetString(prefs::kVariationsRestrictParameter);
+  if (policy_pref_service) {
+    parameter =
+        policy_pref_service->GetString(prefs::kVariationsRestrictParameter);
+  }
 #endif
   return parameter;
 }
 
 enum ResourceRequestsAllowedState {
   RESOURCE_REQUESTS_ALLOWED,
   RESOURCE_REQUESTS_NOT_ALLOWED,
   RESOURCE_REQUESTS_ALLOWED_NOTIFIED,
   RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED,
   RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN,
@@ skipping 38 matching lines @@
       return Study_FormFactor_DESKTOP;
   }
   NOTREACHED();
   return Study_FormFactor_DESKTOP;
 }
 
 }  // namespace
 
 VariationsService::VariationsService(PrefService* local_state)
     : local_state_(local_state),
+      policy_pref_service_(local_state),
       seed_store_(local_state),
-      variations_server_url_(GetVariationsServerURL(local_state)),
       create_trials_from_seed_called_(false),
       initial_request_completed_(false),
       resource_request_allowed_notifier_(
           new ResourceRequestAllowedNotifier) {
   resource_request_allowed_notifier_->Init(this);
 }
 
 VariationsService::VariationsService(ResourceRequestAllowedNotifier* notifier,
                                      PrefService* local_state)
     : local_state_(local_state),
       seed_store_(local_state),

[Joao da Silva, 2014/02/11 16:28:33]

You need to initialize policy_pref_service_ here

[Mathieu, 2014/02/11 18:02:47]

Done.

-      variations_server_url_(GetVariationsServerURL(NULL)),
       create_trials_from_seed_called_(false),
       initial_request_completed_(false),
       resource_request_allowed_notifier_(notifier) {
   resource_request_allowed_notifier_->Init(this);
 }
 
 VariationsService::~VariationsService() {
 }
 
 bool VariationsService::CreateTrialsFromSeed() {
@@ skipping 36 matching lines @@
     UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.SeedFreshness", delta.InMinutes(),
         1, base::TimeDelta::FromDays(30).InMinutes(), 50);
   }
 
   return true;
 }
 
 void VariationsService::StartRepeatedVariationsSeedFetch() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
+  // Initialize the Variations server URL.
+  variations_server_url_ = GetVariationsServerURL(policy_pref_service_);
+
   // Check that |CreateTrialsFromSeed| was called, which is necessary to
   // retrieve the serial number that will be sent to the server.
   DCHECK(create_trials_from_seed_called_);
 
   DCHECK(!request_scheduler_.get());
   // Note that the act of instantiating the scheduler will start the fetch, if
   // the scheduler deems appropriate. Using Unretained is fine here since the
   // lifespan of request_scheduler_ is guaranteed to be shorter than that of
   // this service.
   request_scheduler_.reset(VariationsRequestScheduler::Create(
       base::Bind(&VariationsService::FetchVariationsSeed,
           base::Unretained(this)), local_state_));
   request_scheduler_->Start();
 }
 
 // static
-GURL VariationsService::GetVariationsServerURL(PrefService* local_state) {
+GURL VariationsService::GetVariationsServerURL(
+    PrefService* policy_pref_service) {
   std::string server_url_string(CommandLine::ForCurrentProcess()->
       GetSwitchValueASCII(switches::kVariationsServerURL));
   if (server_url_string.empty())
     server_url_string = kDefaultVariationsServerURL;
   GURL server_url = GURL(server_url_string);
 
-  const std::string restrict_param = GetRestrictParameterPref(local_state);
+  const std::string restrict_param =
+      GetRestrictParameterPref(policy_pref_service);
   if (!restrict_param.empty()) {
     server_url = net::AppendOrReplaceQueryParameter(server_url,
                                                     "restrict",
                                                     restrict_param);
   }
 
   server_url = net::AppendOrReplaceQueryParameter(server_url, "osname",
                                                   GetPlatformString());
 
   DCHECK(server_url.is_valid());
@@ skipping 12 matching lines @@
 
 // static
 std::string VariationsService::GetDefaultVariationsServerURLForTesting() {
   return kDefaultVariationsServerURL;
 }
 
 // static
 void VariationsService::RegisterPrefs(PrefRegistrySimple* registry) {
   VariationsSeedStore::RegisterPrefs(registry);
   registry->RegisterInt64Pref(prefs::kVariationsLastFetchTime, 0);
+  // This preference will only be written by the policy service, which will fill
+  // it according to a value stored in the User Policy.
   registry->RegisterStringPref(prefs::kVariationsRestrictParameter,
                                std::string());
 }
 
 // static
+void VariationsService::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  // This preference will only be written by the policy service, which will fill
+  // it according to a value stored in the User Policy.
+  registry->RegisterStringPref(
+      prefs::kVariationsRestrictParameter,
+      std::string(),
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+// static
 VariationsService* VariationsService::Create(PrefService* local_state) {
 #if !defined(GOOGLE_CHROME_BUILD)
   // Unless the URL was provided, unsupported builds should return NULL to
   // indicate that the service should not be used.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kVariationsServerURL)) {
     DVLOG(1) << "Not creating VariationsService in unofficial build without --"
              << switches::kVariationsServerURL << " specified.";
     return NULL;
   }
@@ skipping 132 matching lines @@
 
 void VariationsService::RecordLastFetchTime() {
   // local_state_ is NULL in tests, so check it first.
   if (local_state_) {
     local_state_->SetInt64(prefs::kVariationsLastFetchTime,
                            base::Time::Now().ToInternalValue());
   }
 }
 
 }  // namespace chrome_variations