Update from https://crrev.com/308996

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"
 #include "base/message_loop/message_loop.h"
 #include "net/android/network_change_notifier_android.h"
 #include "net/android/network_change_notifier_delegate_android.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class NetworkChangeNotifierDelegateAndroidObserver
     : public NetworkChangeNotifierDelegateAndroid::Observer {
  public:
-  NetworkChangeNotifierDelegateAndroidObserver() : notifications_count_(0) {}
+  NetworkChangeNotifierDelegateAndroidObserver()
+      : type_notifications_count_(0), max_bandwidth_notifications_count_(0) {}
 
   // NetworkChangeNotifierDelegateAndroid::Observer:
   virtual void OnConnectionTypeChanged() override {
-    notifications_count_++;
+    type_notifications_count_++;
   }
 
-  int notifications_count() const {
-    return notifications_count_;
+  virtual void OnMaxBandwidthChanged(double max_bandwidth_mbps) override {
+    max_bandwidth_notifications_count_++;
+  }
+
+  int type_notifications_count() const { return type_notifications_count_; }
+  int bandwidth_notifications_count() const {
+    return max_bandwidth_notifications_count_;
   }
 
  private:
-  int notifications_count_;
+  int type_notifications_count_;
+  int max_bandwidth_notifications_count_;
 };
 
 class NetworkChangeNotifierObserver
     : public NetworkChangeNotifier::ConnectionTypeObserver {
  public:
   NetworkChangeNotifierObserver() : notifications_count_(0) {}
 
   // NetworkChangeNotifier::Observer:
   virtual void OnConnectionTypeChanged(
       NetworkChangeNotifier::ConnectionType connection_type) override {
@@ skipping 101 matching lines @@
 
   NetworkChangeNotifierDelegateAndroidObserver delegate_observer_;
   NetworkChangeNotifierDelegateAndroidObserver other_delegate_observer_;
 };
 
 // Tests that the NetworkChangeNotifierDelegateAndroid's observers are notified.
 // A testing-only observer is used here for testing. In production the
 // delegate's observers are instances of NetworkChangeNotifierAndroid.
 TEST_F(NetworkChangeNotifierDelegateAndroidTest, DelegateObserverNotified) {
   // Test the logic with a single observer.
-  RunTest(
-      base::Bind(
-          &NetworkChangeNotifierDelegateAndroidObserver::notifications_count,
-          base::Unretained(&delegate_observer_)),
-      base::Bind(
-          &NetworkChangeNotifierDelegateAndroid::GetCurrentConnectionType,
-          base::Unretained(&delegate_)));
+  RunTest(base::Bind(&NetworkChangeNotifierDelegateAndroidObserver::
+                         type_notifications_count,
+                     base::Unretained(&delegate_observer_)),
+          base::Bind(
+              &NetworkChangeNotifierDelegateAndroid::GetCurrentConnectionType,
+              base::Unretained(&delegate_)));
   // Check that *all* the observers are notified. Both observers should have the
   // same state.
-  EXPECT_EQ(delegate_observer_.notifications_count(),
-            other_delegate_observer_.notifications_count());
+  EXPECT_EQ(delegate_observer_.type_notifications_count(),
+            other_delegate_observer_.type_notifications_count());
 }
 
 class NetworkChangeNotifierAndroidTest
     : public BaseNetworkChangeNotifierAndroidTest {
  protected:
   NetworkChangeNotifierAndroidTest() : notifier_(&delegate_) {
     NetworkChangeNotifier::AddConnectionTypeObserver(
         &connection_type_observer_);
     NetworkChangeNotifier::AddConnectionTypeObserver(
         &other_connection_type_observer_);
@@ skipping 33 matching lines @@
   EXPECT_EQ(connection_type_observer_.notifications_count(),
             other_connection_type_observer_.notifications_count());
 }
 
 TEST_F(NetworkChangeNotifierAndroidTest, MaxBandwidth) {
   SetOnline();
   EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
             notifier_.GetConnectionType());
   EXPECT_EQ(std::numeric_limits<double>::infinity(),
             notifier_.GetMaxBandwidth());
-
   SetOffline();
   EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
             notifier_.GetConnectionType());
   EXPECT_EQ(0.0, notifier_.GetMaxBandwidth());
 }
 
+TEST_F(NetworkChangeNotifierDelegateAndroidTest,
+       MaxBandwidthNotifiedOnConnectionChange) {
+  EXPECT_EQ(0, delegate_observer_.bandwidth_notifications_count());
+  SetOffline();
+  EXPECT_EQ(1, delegate_observer_.bandwidth_notifications_count());
+  SetOnline();
+  EXPECT_EQ(2, delegate_observer_.bandwidth_notifications_count());
+  SetOnline();
+  EXPECT_EQ(2, delegate_observer_.bandwidth_notifications_count());
+}
+
 }  // namespace net