Expose API on VariationsService to set the restrict mode param.

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"
@@ skipping 308 matching lines @@
     }
   }
 
   return true;
 }
 
 void VariationsService::StartRepeatedVariationsSeedFetch() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Initialize the Variations server URL.
-  variations_server_url_ = GetVariationsServerURL(policy_pref_service_);
+  variations_server_url_ =
+      GetVariationsServerURL(policy_pref_service_, restrict_mode_);
 
   // 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.
+  // the scheduler deems appropriate.
   request_scheduler_.reset(VariationsRequestScheduler::Create(
       base::Bind(&VariationsService::FetchVariationsSeed,
-          base::Unretained(this)), local_state_));
+                 weak_ptr_factory_.GetWeakPtr()),
+      local_state_));
   request_scheduler_->Start();
 }
 
 void VariationsService::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void VariationsService::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 // TODO(rkaplow): Handle this and the similar event in metrics_service by
 // observing an 'OnAppEnterForeground' event in RequestScheduler instead of
 // requiring the frontend code to notify each service individually. Since the
 // scheduler will handle it directly the VariationService shouldn't need to
 // know details of this anymore.
 void VariationsService::OnAppEnterForeground() {
   request_scheduler_->OnAppEnterForeground();
 }
 
 #if defined(OS_WIN)
 void VariationsService::StartGoogleUpdateRegistrySync() {
   registry_syncer_.RequestRegistrySync();
 }
 #endif
 
+void VariationsService::SetRestrictMode(const std::string& restrict_mode) {
+  // This should be called before the server URL has been computed.
+  DCHECK(variations_server_url_.is_empty());
+  restrict_mode_ = restrict_mode;
+}
+
 void VariationsService::SetCreateTrialsFromSeedCalledForTesting(bool called) {
   create_trials_from_seed_called_ = called;
 }
 
 // static
 GURL VariationsService::GetVariationsServerURL(
-    PrefService* policy_pref_service) {
+    PrefService* policy_pref_service,
+    const std::string& restrict_mode_override) {
   std::string server_url_string(
       base::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(policy_pref_service);
+  const std::string restrict_param = !restrict_mode_override.empty() ?
+      restrict_mode_override : 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 243 matching lines @@
     local_state_->SetInt64(prefs::kVariationsLastFetchTime,
                            base::Time::Now().ToInternalValue());
   }
 }
 
 std::string VariationsService::GetInvalidVariationsSeedSignature() const {
   return seed_store_.GetInvalidSignature();
 }
 
 }  // namespace chrome_variations