Activate the VariationsService for ChromeOS and ensure that it does not ping the server until the E…

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/base64.h"
 #include "base/build_time.h"
@@ skipping 10 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/login/wizard_controller.h"

[Nikita (slow), 2012/09/10 14:48:55]

nit: Should be removed as already included in the header.

[SteveT, 2012/09/10 16:33:02]

Done.

+#endif
+
 namespace chrome_variations {
 
 namespace {
 
 // Default server of Variations seed info.
 const char kDefaultVariationsServerURL[] =
     "https://clients4.google.com/chrome-variations/seed";
 const int kMaxRetrySeedFetch = 5;
 
 // Time between seed fetches, in hours.
@@ skipping 52 matching lines @@
   GURL url_as_gurl = GURL(server_url);
   DCHECK(url_as_gurl.is_valid());
   return url_as_gurl;
 }
 
 }  // namespace
 
 VariationsService::VariationsService()
     : variations_server_url_(GetVariationsServerURL()),
       create_trials_from_seed_called_(false),
+#if defined(OS_CHROMEOS)
+      waiting_for_user_to_accept_eula_(false),
+#endif
       was_offline_during_last_request_attempt_(false) {
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
 }
 
 VariationsService::~VariationsService() {
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 bool VariationsService::CreateTrialsFromSeed(PrefService* local_prefs) {
   create_trials_from_seed_called_ = true;
@@ skipping 43 matching lines @@
 
   was_offline_during_last_request_attempt_ =
       net::NetworkChangeNotifier::IsOffline();
   UMA_HISTOGRAM_BOOLEAN("Variations.NetworkAvailability",
                         !was_offline_during_last_request_attempt_);
   if (was_offline_during_last_request_attempt_) {
     DVLOG(1) << "Network was offline.";
     return;
   }
 
+#if defined(OS_CHROMEOS)
+  if (!chromeos::WizardController::IsEulaAccepted()) {
+    // The WizardController should notify this class when the EULA has been
+    // accepted.
+    VLOG(1) << "EULA was not accepted.";
+    waiting_for_user_to_accept_eula_ = true;
+    return;
+  }
+#endif
+
   pending_seed_request_.reset(net::URLFetcher::Create(
       variations_server_url_, net::URLFetcher::GET, this));
   pending_seed_request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                       net::LOAD_DO_NOT_SAVE_COOKIES);
   pending_seed_request_->SetRequestContext(
       g_browser_process->system_request_context());
   pending_seed_request_->SetMaxRetries(kMaxRetrySeedFetch);
   if (!variations_serial_number_.empty()) {
     pending_seed_request_->AddExtraRequestHeader("If-Match:" +
                                                  variations_serial_number_);
   }
   pending_seed_request_->Start();
 }
 
 void VariationsService::SetWasOfflineDuringLastRequestAttemptForTesting(
     bool offline) {
   was_offline_during_last_request_attempt_ = offline;
 }
 
+#if defined(OS_CHROMEOS)
+  void VariationsService::OnScreenChanged(chromeos::WizardScreen* next_screen) {
+  }
+
+  void VariationsService::OnSessionStart() {
+  }
+
+  void VariationsService::OnEulaAccepted() {
+    // If an earlier request attempt was aborted because the EULA was not
+    // accepted, retry the request now.
+    if (!waiting_for_user_to_accept_eula_)
+      return;
+    DCHECK(chromeos::WizardController::IsEulaAccepted());
+    waiting_for_user_to_accept_eula_ = false;
+
+    DCHECK(chromeos::WizardController::default_controller());
+    chromeos::WizardController::default_controller()->RemoveObserver(this);
+
+    VLOG(1) << "Starting ping because the EULA was accepted.";
+    FetchVariationsSeed();
+
+    // Since FetchVariationsSeed was explicitly called here, reset the timer to
+    // avoid retrying for a full period.
+    if (timer_.IsRunning())
+      timer_.Reset();
+  }
+#endif
+
 // static
 void VariationsService::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kVariationsSeed, std::string());
   prefs->RegisterInt64Pref(prefs::kVariationsSeedDate,
                            base::Time().ToInternalValue());
 }
 
 void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK_EQ(pending_seed_request_.get(), source);
   // The fetcher will be deleted when the request is handled.
@@ skipping 300 matching lines @@
                                       variation_id);
     }
   }
 
   trial->SetForced();
   if (IsStudyExpired(study, reference_date))
     trial->Disable();
 }
 
 }  // namespace chrome_variations