Rename NetworkChangeNotifierChromeos to NetworkChangeNotifierNetworkLibrary

chrome/browser/chromeos/net/network_change_notifier_network_library.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 "chrome/browser/chromeos/net/network_change_notifier_chromeos.h"
+#include "chrome/browser/chromeos/net/network_change_notifier_network_library.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/root_power_manager_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/dns/dns_config_service_posix.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Delay for online change notification reporting.
 const int kOnlineNotificationDelayMS = 500;
 const int kInitialNotificationCheckDelayMS = 1000;
 
 bool IsOnline(chromeos::ConnectionState state) {
   return state == chromeos::STATE_ONLINE ||
          state == chromeos::STATE_PORTAL;
 }
 
 }
 
 namespace chromeos {
 
-class NetworkChangeNotifierChromeos::DnsConfigServiceChromeos
+class NetworkChangeNotifierNetworkLibrary::DnsConfigServiceChromeos
     : public net::internal::DnsConfigServicePosix {
  public:
   DnsConfigServiceChromeos() {}
 
   virtual ~DnsConfigServiceChromeos() {}
 
   // net::DnsConfigServicePosix:
   virtual bool StartWatching() OVERRIDE {
     // Notifications from NetworkLibrary are sent to
-    // NetworkChangeNotifierChromeos.
+    // NetworkChangeNotifierNetworkLibrary.
     return true;
   }
 
   void OnNetworkChange() {
     InvalidateConfig();
     InvalidateHosts();
     ReadNow();
   }
 };
 
-NetworkChangeNotifierChromeos::NetworkChangeNotifierChromeos()
+NetworkChangeNotifierNetworkLibrary::NetworkChangeNotifierNetworkLibrary()
     : NetworkChangeNotifier(NetworkChangeCalculatorParamsChromeos()),
       has_active_network_(false),
       connection_state_(chromeos::STATE_UNKNOWN),
       connection_type_(CONNECTION_NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   BrowserThread::PostDelayedTask(
          BrowserThread::UI, FROM_HERE,
          base::Bind(
-             &NetworkChangeNotifierChromeos::UpdateInitialState, this),
+             &NetworkChangeNotifierNetworkLibrary::UpdateInitialState, this),
          base::TimeDelta::FromMilliseconds(kInitialNotificationCheckDelayMS));
 }
 
-NetworkChangeNotifierChromeos::~NetworkChangeNotifierChromeos() {
+NetworkChangeNotifierNetworkLibrary::~NetworkChangeNotifierNetworkLibrary() {
 }
 
-void NetworkChangeNotifierChromeos::Init() {
+void NetworkChangeNotifierNetworkLibrary::Init() {
   chromeos::NetworkLibrary* network_library =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   network_library->AddNetworkManagerObserver(this);
 
   DBusThreadManager::Get()->GetRootPowerManagerClient()->AddObserver(this);
 
   dns_config_service_.reset(new DnsConfigServiceChromeos());
   dns_config_service_->WatchConfig(
       base::Bind(NetworkChangeNotifier::SetDnsConfig));
 
   UpdateNetworkState(network_library);
 }
 
-void NetworkChangeNotifierChromeos::Shutdown() {
+void NetworkChangeNotifierNetworkLibrary::Shutdown() {
   weak_factory_.InvalidateWeakPtrs();
 
   dns_config_service_.reset();
 
   if (!chromeos::CrosLibrary::Get())
     return;
 
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
 
   DBusThreadManager::Get()->GetRootPowerManagerClient()->RemoveObserver(this);
 }
 
-void NetworkChangeNotifierChromeos::OnResume(
+void NetworkChangeNotifierNetworkLibrary::OnResume(
     const base::TimeDelta& sleep_duration) {
   // Force invalidation of various net resources on system resume.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &NetworkChangeNotifier::NotifyObserversOfIPAddressChange));
 }
 
 
-void NetworkChangeNotifierChromeos::OnNetworkManagerChanged(
+void NetworkChangeNotifierNetworkLibrary::OnNetworkManagerChanged(
     chromeos::NetworkLibrary* cros) {
   UpdateNetworkState(cros);
 }
 
 net::NetworkChangeNotifier::ConnectionType
-NetworkChangeNotifierChromeos::GetCurrentConnectionType() const {
+NetworkChangeNotifierNetworkLibrary::GetCurrentConnectionType() const {
   return connection_type_;
 }
 
-void NetworkChangeNotifierChromeos::OnNetworkChanged(
+void NetworkChangeNotifierNetworkLibrary::OnNetworkChanged(
     chromeos::NetworkLibrary* cros,
     const chromeos::Network* network) {
   CHECK(network);
 
   // Active network changed?
   if (network->service_path() != service_path_)
     UpdateNetworkState(cros);
   else
     UpdateConnectivityState(network);
 }
 
-void NetworkChangeNotifierChromeos::UpdateNetworkState(
+void NetworkChangeNotifierNetworkLibrary::UpdateNetworkState(
     chromeos::NetworkLibrary* lib) {
   const chromeos::Network* network = lib->active_network();
   if (network) {
     lib->GetIPConfigs(
         network->device_path(),
         chromeos::NetworkLibrary::FORMAT_COLON_SEPARATED_HEX,
-        base::Bind(&NetworkChangeNotifierChromeos::UpdateNetworkStateCallback,
-                   weak_factory_.GetWeakPtr(),
-                   lib));
+        base::Bind(
+            &NetworkChangeNotifierNetworkLibrary::UpdateNetworkStateCallback,
+            weak_factory_.GetWeakPtr(),
+            lib));
   } else {
     // If we don't have a network, then we can't fetch ipconfigs, but we still
     // need to process state updates when we lose a network (i.e. when
     // has_active_network_ is still set, but we don't have one anymore).
     NetworkIPConfigVector empty_ipconfigs;
     UpdateNetworkStateCallback(lib, empty_ipconfigs, "");
   }
 }
 
-void NetworkChangeNotifierChromeos::UpdateNetworkStateCallback(
+void NetworkChangeNotifierNetworkLibrary::UpdateNetworkStateCallback(
     chromeos::NetworkLibrary* lib,
     const NetworkIPConfigVector& ipconfigs,
     const std::string& hardware_address) {
   const chromeos::Network* network = lib->active_network();
 
   if (network) {
     VLOG(1) << "UpdateNetworkStateCallback: " << network->name()
             << ", type= " << network->type()
             << ", device= " << network->device_path()
             << ", state= " << network->state();
@@ skipping 45 matching lines @@
     if (network)
       lib->AddNetworkObserver(network->service_path(), this);
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
             &NetworkChangeNotifier::NotifyObserversOfIPAddressChange));
   }
 }
 
-void NetworkChangeNotifierChromeos::UpdateConnectivityState(
+void NetworkChangeNotifierNetworkLibrary::UpdateConnectivityState(
       const chromeos::Network* network) {
   if (network) {
     VLOG(1) << "UpdateConnectivityState: " << network->name()
             << ", type= " << network->type()
             << ", device= " << network->device_path()
             << ", state= " << network->state()
             << ", connect= " << connection_state_
             << ", type= " << connection_type_;
   }
 
@@ skipping 23 matching lines @@
             << ", new_connection_type = " << new_connection_type;
     ReportConnectionChange();
   }
   VLOG(2) << " UpdateConnectivityState4: "
           << "new_cs = " << new_connection_state
           << ", end_cs_ = " << connection_state_
           << "prev_type = " << prev_connection_type
           << ", new_type_ = " << new_connection_type;
 }
 
-void NetworkChangeNotifierChromeos::ReportConnectionChange() {
+void NetworkChangeNotifierNetworkLibrary::ReportConnectionChange() {
   if (weak_factory_.HasWeakPtrs()) {
     // If we have a pending task, cancel it.
     DVLOG(1) << "ReportConnectionChange: has pending task";
     weak_factory_.InvalidateWeakPtrs();
     DVLOG(1) << "ReportConnectionChange: canceled pending task";
   }
   // Posting task with delay allows us to cancel it when connection type is
   // changed frequently. This should help us avoid transient edge reporting
   // while switching between connection types (e.g. ethernet->wifi).
+  base::Closure task = base::Bind(
+      &NetworkChangeNotifierNetworkLibrary::ReportConnectionChangeOnUIThread,
+      weak_factory_.GetWeakPtr());
+
   BrowserThread::PostDelayedTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(
-          &NetworkChangeNotifierChromeos::ReportConnectionChangeOnUIThread,
-          weak_factory_.GetWeakPtr()),
+      BrowserThread::UI, FROM_HERE, task,
       base::TimeDelta::FromMilliseconds(kOnlineNotificationDelayMS));
 }
 
-void NetworkChangeNotifierChromeos::ReportConnectionChangeOnUIThread() {
+void NetworkChangeNotifierNetworkLibrary::ReportConnectionChangeOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
-         &NetworkChangeNotifierChromeos::
+         &NetworkChangeNotifierNetworkLibrary::
              NotifyObserversOfConnectionTypeChange));
 }
 
 // static
-void NetworkChangeNotifierChromeos::UpdateInitialState(
-    NetworkChangeNotifierChromeos* self) {
+void NetworkChangeNotifierNetworkLibrary::UpdateInitialState(
+    NetworkChangeNotifierNetworkLibrary* self) {
   chromeos::NetworkLibrary* net =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   self->UpdateNetworkState(net);
 }
 
 // static
 net::NetworkChangeNotifier::ConnectionType
-NetworkChangeNotifierChromeos::GetNetworkConnectionType(
+NetworkChangeNotifierNetworkLibrary::GetNetworkConnectionType(
     const chromeos::Network* network) {
   if (!network || !IsOnline(network->connection_state()))
     return net::NetworkChangeNotifier::CONNECTION_NONE;
 
   switch (network->type()) {
     case chromeos::TYPE_ETHERNET:
       return CONNECTION_ETHERNET;
     case chromeos::TYPE_WIFI:
       return CONNECTION_WIFI;
     case chromeos::TYPE_WIMAX:
@@ skipping 19 matching lines @@
     case chromeos::TYPE_BLUETOOTH:
     case chromeos::TYPE_VPN:
     case chromeos::TYPE_UNKNOWN:
       break;
   }
   return net::NetworkChangeNotifier::CONNECTION_UNKNOWN;
 }
 
 // static
 net::NetworkChangeNotifier::NetworkChangeCalculatorParams
-NetworkChangeNotifierChromeos::NetworkChangeCalculatorParamsChromeos() {
+NetworkChangeNotifierNetworkLibrary::NetworkChangeCalculatorParamsChromeos() {
   NetworkChangeCalculatorParams params;
   // Delay values arrived at by simple experimentation and adjusted so as to
   // produce a single signal when switching between network connections.
   params.ip_address_offline_delay_ = base::TimeDelta::FromMilliseconds(4000);
   params.ip_address_online_delay_ = base::TimeDelta::FromMilliseconds(1000);
   params.connection_type_offline_delay_ = base::TimeDelta::FromMilliseconds(0);
   params.connection_type_online_delay_ = base::TimeDelta::FromMilliseconds(0);
   return params;
 }
 
 }  // namespace chromeos