Provide NetworkChangeNotifierAndroid with the actual initial connection type.

net/android/network_change_notifier_android_unittest.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.
 
 // See network_change_notifier_android.h for design explanations.
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 14 matching lines @@
 class ObserverImpl : public BaseObserver {
  public:
   ObserverImpl()
       : times_connection_type_changed_(0),
         current_connection_(NetworkChangeNotifier::CONNECTION_UNKNOWN) {
   }
 
   // BaseObserver:
   virtual void OnConnectionTypeChanged(
       NetworkChangeNotifier::ConnectionType type) OVERRIDE {
+    if (type == current_connection_)
+      return;
     times_connection_type_changed_++;
     current_connection_ = type;
   }
 
   int times_connection_type_changed() const {
     return times_connection_type_changed_;
   }
 
   NetworkChangeNotifier::ConnectionType current_connection() const {
     return current_connection_;
@@ skipping 30 matching lines @@
     EXPECT_EQ(1, times_connection_type_changed_callback.Run());
     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
               connection_type_getter.Run());
 
     ForceConnectivityState(NetworkChangeNotifierDelegateAndroid::ONLINE);
     EXPECT_EQ(2, times_connection_type_changed_callback.Run());
     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
               connection_type_getter.Run());
   }
 
+  void AddObserverToDelegate(
+      NetworkChangeNotifierDelegateAndroid::Observer* observer) {
+    delegate_.AddObserver(observer);
+    // Note that this is needed because ObserverListThreadSafe uses PostTask().
+    MessageLoop::current()->RunUntilIdle();
+  }
+
   void ForceConnectivityState(
       NetworkChangeNotifierDelegateAndroid::ConnectivityState state) {
     delegate_.ForceConnectivityState(state);
-    // Note that this is needed because ObserverListThreadSafe uses PostTask().
+    // See AddObserverToDelegate() above.
     MessageLoop::current()->RunUntilIdle();
   }
 
   NetworkChangeNotifierDelegateAndroid delegate_;
 };
 
+// Tests that a notification is fired when
+// a NetworkChangeNotifierDelegateAndroid's observer registers. This validates
+// that NetworkChangeNotifierAndroid (the observer used in production) is
+// initialized with the actual connection type rather than CONNECTION_UNKNOWN.
+TEST_F(BaseNetworkChangeNotifierAndroidTest,
+       NotifierIsInitializedWithCurrentDelegateConnectionType) {
+  ObserverImpl<NetworkChangeNotifierDelegateAndroid::Observer> observer;
+
+  ASSERT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
+            delegate_.GetConnectionType(NULL, NULL));
+
+  ForceConnectivityState(NetworkChangeNotifierDelegateAndroid::OFFLINE);
+  ASSERT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
+            delegate_.GetConnectionType(NULL, NULL));
+
+  AddObserverToDelegate(&observer);
+  EXPECT_EQ(1, observer.times_connection_type_changed());
+  EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
+            observer.current_connection());
+  delegate_.RemoveObserver(&observer);
+}
+
 class NetworkChangeNotifierDelegateAndroidTest
     : public BaseNetworkChangeNotifierAndroidTest {
  protected:
   typedef ObserverImpl<
       NetworkChangeNotifierDelegateAndroid::Observer> TestDelegateObserver;
 
   NetworkChangeNotifierDelegateAndroidTest() {
-    delegate_.AddObserver(&delegate_observer_);
-    delegate_.AddObserver(&other_delegate_observer_);
+    AddObserverToDelegate(&delegate_observer_);
+    AddObserverToDelegate(&other_delegate_observer_);
   }
 
   virtual ~NetworkChangeNotifierDelegateAndroidTest() {
     delegate_.RemoveObserver(&delegate_observer_);
     delegate_.RemoveObserver(&other_delegate_observer_);
   }
 
   TestDelegateObserver delegate_observer_;
   TestDelegateObserver other_delegate_observer_;
 };
@@ skipping 64 matching lines @@
           &TestConnectionTypeObserver::current_connection,
           base::Unretained(&connection_type_observer_)));
   // Check that *all* the observers are notified.
   EXPECT_EQ(connection_type_observer_.times_connection_type_changed(),
             other_connection_type_observer_.times_connection_type_changed());
   EXPECT_EQ(connection_type_observer_.current_connection(),
             other_connection_type_observer_.current_connection());
 }
 
 }  // namespace net