Implement new network change notifier that uses NetworkStateHandler

net/base/network_change_notifier_chromeos.cc

Index: net/base/network_change_notifier_chromeos.cc
diff --git a/net/base/network_change_notifier_chromeos.cc b/net/base/network_change_notifier_chromeos.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c98152f5c9deb11618224b666b3f8c76601079d8
--- /dev/null
+++ b/net/base/network_change_notifier_chromeos.cc
@@ -0,0 +1,172 @@
+// 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 <string>
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
+#include "net/base/network_change_notifier.h"
+#include "net/base/network_change_notifier_chromeos.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace net {
+
+NetworkChangeNotifierChromeos::NetworkChangeNotifierChromeos()
+    : NetworkChangeNotifier(NetworkChangeCalculatorParamsChromeos()),
+      connection_type_(CONNECTION_NONE) {
+}
+
+NetworkChangeNotifierChromeos::~NetworkChangeNotifierChromeos() {
+}
+
+void NetworkChangeNotifierChromeos::Initialize() {
+  chromeos::NetworkStateHandler::Get()->AddObserver(this);
+
+  dns_config_service_.reset(new DnsConfigService());
+  dns_config_service_->WatchConfig(
+      base::Bind(NetworkChangeNotifier::SetDnsConfig));
+
+  // Update initial connection state.
+  ActiveNetworkChanged(chromeos::NetworkStateHandler::Get()->ActiveNetwork());
+}
+
+void NetworkChangeNotifierChromeos::Shutdown() {
+  dns_config_service_.reset();
+  if(chromeos::NetworkStateHandler::Get())
+    chromeos::NetworkStateHandler::Get()->RemoveObserver(this);
+}
+
+NetworkChangeNotifier::ConnectionType
+NetworkChangeNotifierChromeos::GetCurrentConnectionType() const {
+  return connection_type_;
+}
+
+void NetworkChangeNotifierChromeos::ActiveNetworkChanged(
+    const chromeos::NetworkState* active_network) {
+  bool connection_type_changed = false, ip_address_changed = false,
+      dns_changed = false;

[stevenjb, 2012/12/13 19:28:22]

Use a separate line for each of these.

[gauravsh, 2012/12/15 00:42:45]

Done.

+
+  UpdateActiveNetwork(active_network, &connection_type_changed,
+                      &ip_address_changed, &dns_changed);
+
+  if (connection_type_changed)
+    NetworkChangeNotifierChromeos:: NotifyObserversOfConnectionTypeChange();
+  if (ip_address_changed)
+    NetworkChangeNotifierChromeos::NotifyObserversOfIPAddressChange();
+  if (dns_changed)
+    dns_config_service_->OnNetworkChange();
+}
+
+void NetworkChangeNotifierChromeos::ActiveNetworkStateChanged(
+    const chromeos::NetworkState* active_network) {
+  ActiveNetworkChanged(active_network);
+}
+
+NetworkChangeNotifierChromeos::DnsConfigService::DnsConfigService()
+{}

[stevenjb, 2012/12/13 19:28:22]

{ on line 68

[gauravsh, 2012/12/15 00:42:45]

Done.

+
+NetworkChangeNotifierChromeos::DnsConfigService::~DnsConfigService()
+{}

[stevenjb, 2012/12/13 19:28:22]

{ on line 71

[gauravsh, 2012/12/15 00:42:45]

Done.

+
+bool NetworkChangeNotifierChromeos::DnsConfigService::StartWatching() {
+  // DNS config changes are handled and notified by the network state handlers.
+  return true;
+}
+
+void NetworkChangeNotifierChromeos::DnsConfigService::OnNetworkChange() {
+  InvalidateConfig();
+  InvalidateHosts();
+  ReadNow();
+}
+
+void NetworkChangeNotifierChromeos::UpdateActiveNetwork(
+    const chromeos::NetworkState* active_network,
+    bool* connection_type_changed,
+    bool* ip_address_changed,
+    bool* dns_changed) {
+  *connection_type_changed = *ip_address_changed = *dns_changed = false;

[stevenjb, 2012/12/13 19:28:22]

Use separate lines for each, here and below.

[gauravsh, 2012/12/15 00:42:45]

Done.

+  // TODO(gauravsh): DNS changes will be detected once ip config
+  //   support is hooked into NetworkStateHandler. For now,

[stevenjb, 2012/12/13 19:28:22]

nit: No extra WS indentation in comment

[gauravsh, 2012/12/15 00:42:45]

Done.

+  //   we report a DNS change on changes to the active network (including
+  //   loss).
+  if (!active_network || !active_network->IsConnectedState()) {
+    // If we lost an active network, we must update our state and notify
+    // observers, otherwise we have nothing do. (Under normal circumstances,
+    // we should never ever get duplicate no active network notifications).
+    if (connection_type_ != CONNECTION_NONE) {
+      *ip_address_changed = *dns_changed = *connection_type_changed = true;
+      connection_type_ = CONNECTION_NONE;
+      service_path_.clear();
+      ip_address_.clear();
+    }
+  } else {
+    // We do have an active network and it is connected.
+    NetworkChangeNotifier::ConnectionType new_connection_type =
+        ConnectionTypeFromShill(active_network->type(),
+                                active_network->technology());
+    if (new_connection_type != connection_type_) {
+      VLOG(1) << "Connection type changed from " << connection_type_ << " -> "
+          << new_connection_type;
+      *connection_type_changed = *dns_changed = true;
+    }
+    if (active_network->path() != service_path_ ||
+        active_network->ip_address() != ip_address_) {
+      VLOG(1) << "Service path changed from " << service_path_ << " -> "
+              << active_network->path();
+      VLOG(1) << "IP Address changed from " << ip_address_ << " -> "
+              << active_network->ip_address();
+      *ip_address_changed = *dns_changed = true;
+    }
+    connection_type_ = new_connection_type;
+    service_path_ = active_network->path();
+    ip_address_ = active_network->ip_address();
+  }
+}
+
+// static
+NetworkChangeNotifier::ConnectionType
+NetworkChangeNotifierChromeos::ConnectionTypeFromShill(
+    const std::string& type, const std::string& technology) {
+  if (type == flimflam::kTypeEthernet)
+    return CONNECTION_ETHERNET;
+  else if (type == flimflam::kTypeWifi)
+    return CONNECTION_WIFI;
+  else if (type == flimflam::kTypeWimax)
+    return CONNECTION_4G;
+
+  if (type != flimflam::kTypeCellular)
+    return CONNECTION_UNKNOWN;
+
+  // For cellular types, mapping depends on the technology.
+  if (technology == flimflam::kNetworkTechnologyEvdo ||
+      technology == flimflam::kNetworkTechnologyGsm ||
+      technology == flimflam::kNetworkTechnologyUmts ||
+      technology == flimflam::kNetworkTechnologyHspa)
+    return CONNECTION_3G;
+  else if (technology == flimflam::kNetworkTechnologyHspaPlus ||
+    technology == flimflam::kNetworkTechnologyLte ||
+    technology == flimflam::kNetworkTechnologyLteAdvanced)
+    return CONNECTION_4G;
+  else
+    return CONNECTION_2G;  // Default cellular type is 2G.

[stevenjb, 2012/12/13 19:28:22]

{} around each of these clauses for multi-line if()

[gauravsh, 2012/12/15 00:42:45]

Done.

+}
+
+// static
+net::NetworkChangeNotifier::NetworkChangeCalculatorParams
+NetworkChangeNotifierChromeos::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(500);
+  params.connection_type_online_delay_ = base::TimeDelta::FromMilliseconds(500);
+  return params;
+}
+
+}  // namespace chromeos
+