[NetInfo] Add Blink support for connection.change, connection.downlinkMax, and wimax

Source/core/page/NetworkStateNotifierTest.cpp

 /*
  * Copyright (c) 2014, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 23 matching lines @@
 #include "core/dom/Document.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebConnectionType.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Functional.h"
 #include <gtest/gtest.h>
 
 namespace blink {
 
+namespace {
+    const double kNoneMaxBandwidthMbps = 0.0;
+    const double kBluetoothMaxBandwidthMbps = 1.0;
+    const double kEthernetMaxBandwidthMbps = 2.0;
+}
+
 class StateObserver : public NetworkStateNotifier::NetworkStateObserver {
 public:
     StateObserver()
         : m_observedType(ConnectionTypeNone)
+        , m_observedMaxBandwidthMbps(0.0)
         , m_callbackCount(0)
     {
     }
 
-    virtual void connectionTypeChange(WebConnectionType type)
+    virtual void connectionChange(WebConnectionType type, double maxBandwidthMbps)
     {
         m_observedType = type;
+        m_observedMaxBandwidthMbps = maxBandwidthMbps;
         m_callbackCount += 1;
 
         if (m_closure)
             (*m_closure)();
     }
 
     WebConnectionType observedType() const
     {
         return m_observedType;
     }
 
+    double observedMaxBandwidth() const
+    {
+        return m_observedMaxBandwidthMbps;
+    }
+
     int callbackCount() const
     {
         return m_callbackCount;
     }
 
     void setNotificationCallback(PassOwnPtr<Closure> closure)
     {
         m_closure = closure;
     }
 
 private:
     OwnPtr<Closure> m_closure;
     WebConnectionType m_observedType;
+    double m_observedMaxBandwidthMbps;
     int m_callbackCount;
 };
 
 class NetworkStateNotifierTest : public ::testing::Test {
 public:
     NetworkStateNotifierTest()
         : m_document(Document::create())
         , m_document2(Document::create())
     {
     }
 
     ExecutionContext* executionContext()
     {
         return m_document.get();
     }
 
     ExecutionContext* executionContext2()
     {
         return m_document2.get();
     }
 
 protected:
-    void setType(WebConnectionType type)
+    void setConnection(WebConnectionType type, double maxBandwidthMbps)
     {
-        m_notifier.setWebConnectionType(type);
+        m_notifier.setWebConnection(type, maxBandwidthMbps);
         testing::runPendingTasks();
     }
 
     void addObserverOnNotification(StateObserver* observer, StateObserver* observerToAdd)
     {
         observer->setNotificationCallback(bind(&NetworkStateNotifier::addObserver, &m_notifier, observerToAdd, executionContext()));
     }
 
     void removeObserverOnNotification(StateObserver* observer, StateObserver* observerToRemove)
     {
         observer->setNotificationCallback(bind(&NetworkStateNotifier::removeObserver, &m_notifier, observerToRemove, executionContext()));
     }
 
+    bool verifyObservations(const StateObserver& observer, WebConnectionType type, double maxBandwidthMbps)
+    {
+        EXPECT_EQ(observer.observedType(), type);
+        EXPECT_EQ(observer.observedMaxBandwidth(), maxBandwidthMbps);
+        return observer.observedType() == type && observer.observedMaxBandwidth() == maxBandwidthMbps;
+    }
+
     RefPtrWillBePersistent<Document> m_document;
     RefPtrWillBePersistent<Document> m_document2;
     NetworkStateNotifier m_notifier;
 };
 
 TEST_F(NetworkStateNotifierTest, AddObserver)
 {
     StateObserver observer;
     m_notifier.addObserver(&observer, executionContext());
-    EXPECT_EQ(observer.observedType(), ConnectionTypeNone);
+    EXPECT_TRUE(verifyObservations(observer, ConnectionTypeNone, kNoneMaxBandwidthMbps));
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
     EXPECT_EQ(observer.callbackCount(), 1);
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveObserver)
 {
     StateObserver observer1, observer2;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.removeObserver(&observer1, executionContext());
     m_notifier.addObserver(&observer2, executionContext());
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeNone);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeNone, kNoneMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveSoleObserver)
 {
-    StateObserver observer1, observer2;
+    StateObserver observer1;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.removeObserver(&observer1, executionContext());
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeNone);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeNone, kNoneMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, AddObserverWhileNotifying)
 {
     StateObserver observer1, observer2;
     m_notifier.addObserver(&observer1, executionContext());
     addObserverOnNotification(&observer1, &observer2);
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveSoleObserverWhileNotifying)
 {
     StateObserver observer1;
     m_notifier.addObserver(&observer1, executionContext());
     removeObserverOnNotification(&observer1, &observer1);
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
 
-    setType(ConnectionTypeEthernet);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveCurrentObserverWhileNotifying)
 {
     StateObserver observer1, observer2;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.addObserver(&observer2, executionContext());
     removeObserverOnNotification(&observer1, &observer1);
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
 
-    setType(ConnectionTypeEthernet);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeEthernet);
+    setConnection(ConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeEthernet, kEthernetMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemovePastObserverWhileNotifying)
 {
     StateObserver observer1, observer2;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.addObserver(&observer2, executionContext());
     removeObserverOnNotification(&observer2, &observer1);
 
-    setType(ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
     EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
     EXPECT_EQ(observer2.observedType(), ConnectionTypeBluetooth);
 
-    setType(ConnectionTypeEthernet);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeEthernet);
+    setConnection(ConnectionTypeEthernet, kEthernetMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeEthernet, kEthernetMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveFutureObserverWhileNotifying)
 {
     StateObserver observer1, observer2, observer3;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.addObserver(&observer2, executionContext());
     m_notifier.addObserver(&observer3, executionContext());
     removeObserverOnNotification(&observer1, &observer2);
 
-    setType(ConnectionTypeBluetooth);
-
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeNone);
-    EXPECT_EQ(observer3.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeNone, kNoneMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer3, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, MultipleContextsAddObserver)
 {
     StateObserver observer1, observer2;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.addObserver(&observer2, executionContext2());
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeBluetooth);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveContext)
 {
     StateObserver observer1, observer2;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.addObserver(&observer2, executionContext2());
     m_notifier.removeObserver(&observer2, executionContext2());
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeBluetooth);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeNone);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeNone, kNoneMaxBandwidthMbps));
 }
 
 TEST_F(NetworkStateNotifierTest, RemoveAllContexts)
 {
     StateObserver observer1, observer2;
     m_notifier.addObserver(&observer1, executionContext());
     m_notifier.addObserver(&observer2, executionContext2());
     m_notifier.removeObserver(&observer1, executionContext());
     m_notifier.removeObserver(&observer2, executionContext2());
 
-    setType(ConnectionTypeBluetooth);
-    EXPECT_EQ(observer1.observedType(), ConnectionTypeNone);
-    EXPECT_EQ(observer2.observedType(), ConnectionTypeNone);
+    setConnection(ConnectionTypeBluetooth, kBluetoothMaxBandwidthMbps);
+    EXPECT_TRUE(verifyObservations(observer1, ConnectionTypeNone, kNoneMaxBandwidthMbps));
+    EXPECT_TRUE(verifyObservations(observer2, ConnectionTypeNone, kNoneMaxBandwidthMbps));
 }
 
 } // namespace blink