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

chrome/browser/metrics/variations/resource_request_allowed_notifier.cc

Index: chrome/browser/metrics/variations/resource_request_allowed_notifier.cc
diff --git a/chrome/browser/metrics/variations/resource_request_allowed_notifier.cc b/chrome/browser/metrics/variations/resource_request_allowed_notifier.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8ef3a83a4e02f15502f021446c62e6566306aae0
--- /dev/null
+++ b/chrome/browser/metrics/variations/resource_request_allowed_notifier.cc
@@ -0,0 +1,114 @@
+// 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/resource_request_allowed_notifier.h"
+
+#include "base/metrics/histogram.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/notification_service.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/login/wizard_controller.h"
+#endif
+
+ResourceRequestAllowedNotifier::ResourceRequestAllowedNotifier() :
+#if defined(OS_CHROMEOS)
+    was_waiting_for_user_to_accept_eula_(false),
+#endif
+    was_waiting_for_network_(false),
+    observer_(NULL) {
+  net::NetworkChangeNotifier::AddConnectionTypeObserver(this);

[Alexei Svitkine (slow), 2012/09/20 21:39:03]

Do this in Init() so that there's no timing hole between construction and Init()
where we could be notified.

[SteveT, 2012/09/21 15:16:17]

Done.

+}
+
+ResourceRequestAllowedNotifier::~ResourceRequestAllowedNotifier() {
+  net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);

[Alexei Svitkine (slow), 2012/09/20 21:39:03]

After the above change, surround this in if (observer_), so that this does the
right thing if Init() wasn't called.

[SteveT, 2012/09/21 15:16:17]

Done.

+}
+
+void ResourceRequestAllowedNotifier::Init(Observer* observer) {
+  DCHECK(!observer_ && observer);
+  observer_ = observer;
+
+  // Check this state during initialization. It is not expected to change until
+  // the corresponding notification is received.
+  was_waiting_for_user_to_accept_eula_ = !IsEulaAccepted();
+#if defined(OS_CHROMEOS)
+  if (was_waiting_for_user_to_accept_eula_) {
+    // Note that this must listen on AllSources due to the difficulty in knowing
+    // when the WizardController instance is created, and to avoid over-coupling
+    // the Chrome OS code with the VariationsService by directly attaching as an
+    // observer. This is OK because WizardController is essentially a singleton.
+    registrar_.Add(this, chrome::NOTIFICATION_WIZARD_EULA_ACCEPTED,
+                   content::NotificationService::AllSources());
+  }
+#endif
+}
+
+bool ResourceRequestAllowedNotifier::ResourceRequestsAllowed() {
+  was_waiting_for_network_ = net::NetworkChangeNotifier::IsOffline();
+
+  return
+#if defined(OS_CHROMEOS)
+      !was_waiting_for_user_to_accept_eula_ &&
+#endif
+      !was_waiting_for_network_;
+}
+
+void ResourceRequestAllowedNotifier::
+    SetWasWaitingForNetworkForTesting(bool waiting) {
+  was_waiting_for_network_ = waiting;
+}
+
+#if defined(OS_CHROMEOS)
+void ResourceRequestAllowedNotifier::
+    SetWasWaitingForEulaForTesting(bool waiting) {
+  was_waiting_for_user_to_accept_eula_ = waiting;
+}
+#endif
+
+void ResourceRequestAllowedNotifier::MaybeNotifyObservers() {
+  // Need to ensure that all criteria are met before notifying observers.
+  if (observer_ && ResourceRequestsAllowed()) {

[Alexei Svitkine (slow), 2012/09/20 21:39:03]

No need to check for |observer_| here once the above changed are done. If
|observer_| wasn't set - i.e. Init() wasn't called, then we wouldn't be
listening for notifications.

[SteveT, 2012/09/21 15:16:17]

Done.

+    DVLOG(1) << "Notifying observer of state change.";
+    observer_->OnResourceRequestsAllowed();
+  }
+}
+
+bool ResourceRequestAllowedNotifier::IsEulaAccepted() {
+  return chromeos::WizardController::IsEulaAccepted();
+}
+
+void ResourceRequestAllowedNotifier::OnConnectionTypeChanged(
+    net::NetworkChangeNotifier::ConnectionType type) {
+  // Only attempt to notify observers if this was previously waiting for the
+  // network to reconnect, and new network state is actually available. This
+  // prevents the notifier from notifying the observer if the notifier was never
+  // waiting on the network, or if the network changes from one online state
+  // to another (for example, Wifi to 3G, or Wifi to Wifi, if the network were
+  // flaky).
+  if (was_waiting_for_network_ &&
+      type != net::NetworkChangeNotifier::CONNECTION_NONE) {
+    DVLOG(1) << "Network came back online.";
+    MaybeNotifyObservers();
+  }
+}
+
+#if defined(OS_CHROMEOS)
+void ResourceRequestAllowedNotifier::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK_EQ(chrome::NOTIFICATION_WIZARD_EULA_ACCEPTED, type);
+  // This should only ever be received once. Remove it after this call.
+  DCHECK(!registrar_.IsEmpty());
+  registrar_.Remove(this, chrome::NOTIFICATION_WIZARD_EULA_ACCEPTED,
+                    content::NotificationService::AllSources());
+
+  // This flag should have been set if this was waiting on the EULA
+  // notification.
+  DCHECK(was_waiting_for_user_to_accept_eula_);
+  DVLOG(1) << "EULA was accepted.";
+  was_waiting_for_user_to_accept_eula_ = false;
+  MaybeNotifyObservers();
+}
+#endif