API for connection type (Ethernet/WIFI/WWAN ...) in NetworkChangeNotifier.

net/base/network_change_notifier_win.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.
 
 #include "net/base/network_change_notifier_win.h"
 
 #include <iphlpapi.h>
 #include <winsock2.h>
 
 #include "base/bind.h"
@@ skipping 51 matching lines @@
 }
 
 NetworkChangeNotifierWin::~NetworkChangeNotifierWin() {
   if (is_watching_) {
     CancelIPChangeNotify(&addr_overlapped_);
     addr_watcher_.StopWatching();
   }
   WSACloseEvent(addr_overlapped_.hEvent);
 }
 
-// Conceptually we would like to tell whether the user is "online" verus
-// "offline".  This is challenging since the only thing we can test with
-// certainty is whether a *particular* host is reachable.
+// This implementation does not return the actual connection type but merely
+// determines if the user is "online" (in which case it returns
+// CONNECTION_UNKNOWN) or "offline" (and then it returns CONNECTION_NONE).
+// This is challenging since the only thing we can test with certainty is
+// whether a *particular* host is reachable.
 //
 // While we can't conclusively determine when a user is "online", we can at
 // least reliably recognize some of the situtations when they are clearly
 // "offline". For example, if the user's laptop is not plugged into an ethernet
 // network and is not connected to any wireless networks, it must be offline.
 //
 // There are a number of different ways to implement this on Windows, each with
 // their pros and cons. Here is a comparison of various techniques considered:
 //
 // (1) Use InternetGetConnectedState (wininet.dll). This function is really easy
@@ skipping 23 matching lines @@
 // workstation. Here is what I found:
 //   * Approach (1) was pretty much zero-cost after the initial call.
 //   * Approach (2) took an average of 3.25 milliseconds to enumerate the
 //     adapters.
 //   * Approach (3) took an average of 0.8 ms to enumerate the providers.
 //
 // In terms of correctness, all three approaches were comparable for the simple
 // experiments I ran... However none of them correctly returned "offline" when
 // executing 'ipconfig /release'.
 //
-bool NetworkChangeNotifierWin::IsCurrentlyOffline() const {
+NetworkChangeNotifier::ConnectionType
+NetworkChangeNotifierWin::GetCurrentConnectionType() const {
 
   // TODO(eroman): We could cache this value, and only re-calculate it on
   //               network changes. For now we recompute it each time asked,
   //               since it is relatively fast (sub 1ms) and not called often.
 
   EnsureWinsockInit();
 
   // The following code was adapted from:
   // http://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/net/notifier/base/win/async_network_alive_win32.cc?view=markup&pathrev=47343
   // The main difference is we only call WSALookupServiceNext once, whereas
   // the earlier code would traverse the entire list and pass LUP_FLUSHPREVIOUS
   // to skip past the large results.
 
   HANDLE ws_handle;
   WSAQUERYSET query_set = {0};
   query_set.dwSize = sizeof(WSAQUERYSET);
   query_set.dwNameSpace = NS_NLA;
   // Initiate a client query to iterate through the
   // currently connected networks.
   if (0 != WSALookupServiceBegin(&query_set, LUP_RETURN_ALL,
                                  &ws_handle)) {
     LOG(ERROR) << "WSALookupServiceBegin failed with: " << WSAGetLastError();
-    return false;
+    return NetworkChangeNotifier::CONNECTION_UNKNOWN;
   }
 
   bool found_connection = false;
 
   // Retrieve the first available network. In this function, we only
   // need to know whether or not there is network connection.
   // Allocate 256 bytes for name, it should be enough for most cases.
   // If the name is longer, it is OK as we will check the code returned and
   // set correct network status.
   char result_buffer[sizeof(WSAQUERYSET) + 256] = {0};
@@ skipping 24 matching lines @@
       // There was nothing to iterate over!
     } else {
       LOG(WARNING) << "WSALookupServiceNext() failed with:" << result;
     }
   }
 
   result = WSALookupServiceEnd(ws_handle);
   LOG_IF(ERROR, result != 0)
       << "WSALookupServiceEnd() failed with: " << result;
 
-  return !found_connection;
+  // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
+  return found_connection ? NetworkChangeNotifier::CONNECTION_UNKNOWN :
+                            NetworkChangeNotifier::CONNECTION_NONE;
 }
 
 void NetworkChangeNotifierWin::OnObjectSignaled(HANDLE object) {
   DCHECK(CalledOnValidThread());
   DCHECK(is_watching_);
   is_watching_ = false;
 
   // Start watching for the next address change.
   WatchForAddressChange();
 
   NotifyObservers();
 }
 
 void NetworkChangeNotifierWin::NotifyObservers() {
   DCHECK(CalledOnValidThread());
   NotifyObserversOfIPAddressChange();
 
-  // Calling IsOffline() at this very moment is likely to give
+  // Calling GetConnectionType() at this very moment is likely to give
   // the wrong result, so we delay that until a little bit later.
   //
   // The one second delay chosen here was determined experimentally
   // by adamk on Windows 7.
   timer_.Stop();  // cancel any already waiting notification
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
-               &NetworkChangeNotifierWin::NotifyParentOfOnlineStateChange);
+               &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
 }
 
 void NetworkChangeNotifierWin::WatchForAddressChange() {
   DCHECK(CalledOnValidThread());
   DCHECK(!is_watching_);
 
   // NotifyAddrChange occasionally fails with ERROR_OPEN_FAILED for unknown
   // reasons.  More rarely, it's also been observed failing with
   // ERROR_NO_SYSTEM_RESOURCES.  When either of these happens, we retry later.
   if (!WatchForAddressChangeInternal()) {
@@ skipping 35 matching lines @@
   DCHECK(CalledOnValidThread());
   HANDLE handle = NULL;
   DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_);
   if (ret != ERROR_IO_PENDING)
     return false;
 
   addr_watcher_.StartWatching(addr_overlapped_.hEvent, this);
   return true;
 }
 
-void NetworkChangeNotifierWin::NotifyParentOfOnlineStateChange() {
-  NotifyObserversOfOnlineStateChange();
+void NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange() {
+  NotifyObserversOfConnectionTypeChange();
 }
 
 }  // namespace net