Adding platform support check for NetworkObserver

net/android/network_change_notifier_android.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.
 
 ////////////////////////////////////////////////////////////////////////////////
 // Threading considerations:
 //
 // This class is designed to meet various threading guarantees starting from the
 // ones imposed by NetworkChangeNotifier:
 // - The notifier can be constructed on any thread.
@@ skipping 41 matching lines @@
 // delegate then forwards these notifications to the threads of each observer
 // (network change notifier). The network change notifier than processes the
 // state change, and notifies each of its observers on their threads.
 //
 // This can also be seen as:
 // Android platform -> NetworkChangeNotifier (Java) ->
 // NetworkChangeNotifierDelegateAndroid -> NetworkChangeNotifierAndroid.
 
 #include "net/android/network_change_notifier_android.h"
 
+#include "base/android/build_info.h"
 #include "base/threading/thread.h"
 #include "net/base/address_tracker_linux.h"
 #include "net/dns/dns_config_service_posix.h"
 
 namespace net {
 
 // Expose kInvalidNetworkHandle out to Java as NetId.INVALID. The notion of
 // a NetID is an Android framework one, see android.net.Network.netId.
 // NetworkChangeNotifierAndroid implements NetworkHandle to simply be the NetID.
 // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.net
@@ skipping 83 matching lines @@
   return delegate_->GetCurrentConnectionType();
 }
 
 void NetworkChangeNotifierAndroid::GetCurrentMaxBandwidthAndConnectionType(
     double* max_bandwidth_mbps,
     ConnectionType* connection_type) const {
   delegate_->GetCurrentMaxBandwidthAndConnectionType(max_bandwidth_mbps,
                                                      connection_type);
 }
 
+void NetworkChangeNotifierAndroid::ForceNetworkHandlesSupportedForTesting() {
+  force_network_handles_supported_for_testing_ = true;
+}
+
+bool NetworkChangeNotifierAndroid::AreNetworkHandlesCurrentlySupported() const {
+  // Notifications for API using NetworkHandles and querying using
+  // NetworkHandles only implemented for Android versions >= L.
+  return force_network_handles_supported_for_testing_ ||
+         (base::android::BuildInfo::GetInstance()->sdk_int() >=
+          base::android::SDK_VERSION_LOLLIPOP);
+}
+
 void NetworkChangeNotifierAndroid::GetCurrentConnectedNetworks(
     NetworkChangeNotifier::NetworkList* networks) const {
   delegate_->GetCurrentlyConnectedNetworks(networks);
 }
 
 NetworkChangeNotifier::ConnectionType
 NetworkChangeNotifierAndroid::GetCurrentNetworkConnectionType(
     NetworkHandle network) const {
   return delegate_->GetNetworkConnectionType(network);
 }
@@ skipping 40 matching lines @@
 bool NetworkChangeNotifierAndroid::Register(JNIEnv* env) {
   return NetworkChangeNotifierDelegateAndroid::Register(env);
 }
 
 NetworkChangeNotifierAndroid::NetworkChangeNotifierAndroid(
     NetworkChangeNotifierDelegateAndroid* delegate,
     const DnsConfig* dns_config_for_testing)
     : NetworkChangeNotifier(NetworkChangeCalculatorParamsAndroid()),
       delegate_(delegate),
       dns_config_service_thread_(
-          new DnsConfigServiceThread(dns_config_for_testing)) {
+          new DnsConfigServiceThread(dns_config_for_testing)),
+      force_network_handles_supported_for_testing_(false) {
   CHECK_EQ(NetId::INVALID, NetworkChangeNotifier::kInvalidNetworkHandle)
       << "kInvalidNetworkHandle doesn't match NetId::INVALID";
   delegate_->AddObserver(this);
   dns_config_service_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   // Wait until Init is called on the DNS config thread before
   // calling InitAfterStart.
   dns_config_service_thread_->WaitUntilThreadStarted();
   dns_config_service_thread_->InitAfterStart();
 }
 
 // static
 NetworkChangeNotifier::NetworkChangeCalculatorParams
 NetworkChangeNotifierAndroid::NetworkChangeCalculatorParamsAndroid() {
   NetworkChangeCalculatorParams params;
   // IPAddressChanged is produced immediately prior to ConnectionTypeChanged
   // so delay IPAddressChanged so they get merged with the following
   // ConnectionTypeChanged signal.
   params.ip_address_offline_delay_ = base::TimeDelta::FromSeconds(1);
   params.ip_address_online_delay_ = base::TimeDelta::FromSeconds(1);
   params.connection_type_offline_delay_ = base::TimeDelta::FromSeconds(0);
   params.connection_type_online_delay_ = base::TimeDelta::FromSeconds(0);
   return params;
 }
 
 }  // namespace net