Add NetworkHandler to own network handlers in src/chromeos/network

ash/system/chromeos/network/network_state_notifier.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 "ash/system/chromeos/network/network_state_notifier.h"
 
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_observer.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "grit/ash_strings.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using chromeos::NetworkHandler;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 namespace {
 
 const int kMinTimeBetweenOutOfCreditsNotifySeconds = 10 * 60;
 
 ash::NetworkObserver::NetworkType GetAshNetworkType(
     const NetworkState* network) {
   const std::string& type = network->type();
@@ skipping 70 matching lines @@
                                     UTF8ToUTF16(error));
 }
 
 }  // namespace
 
 namespace ash {
 namespace internal {
 
 NetworkStateNotifier::NetworkStateNotifier()
     : cellular_out_of_credits_(false) {
-  if (!NetworkStateHandler::Get())
-    return;
-  NetworkStateHandler::Get()->AddObserver(this);
+  NetworkHandler::Get()->network_state_handler()->AddObserver(this);
   InitializeNetworks();
 }
 
 NetworkStateNotifier::~NetworkStateNotifier() {
-  if (NetworkStateHandler::Get())
-    NetworkStateHandler::Get()->RemoveObserver(this);
+  NetworkHandler::Get()->network_state_handler()->RemoveObserver(this);
 }
 
 void NetworkStateNotifier::DefaultNetworkChanged(const NetworkState* network) {
   if (!network || !network->IsConnectedState())
     return;
   if (network->path() != last_active_network_) {
     last_active_network_ = network->path();
     // Reset state for new connected network
     cellular_out_of_credits_ = false;
   }
 }
 
 void NetworkStateNotifier::NetworkConnectionStateChanged(
     const NetworkState* network) {
-  NetworkStateHandler* handler = NetworkStateHandler::Get();
+  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   std::string prev_state;
   std::string new_state = network->connection_state();
   CachedStateMap::iterator iter = cached_state_.find(network->path());
   if (iter != cached_state_.end()) {
     prev_state = iter->second;
     if (prev_state == new_state)
       return;  // No state change
     VLOG(1) << "NetworkStateNotifier: State: " << prev_state
             << " ->: " << new_state;
     iter->second = new_state;
@@ skipping 64 matching lines @@
       Shell::GetInstance()->system_tray_delegate()->ConfigureNetwork(
           cellular_network_);
     }
     ash::Shell::GetInstance()->system_tray_notifier()->
         NotifyClearNetworkMessage(message_type);
   }
 }
 
 void NetworkStateNotifier::InitializeNetworks() {
   NetworkStateList network_list;
-  NetworkStateHandler::Get()->GetNetworkList(&network_list);
+  NetworkHandler::Get()->network_state_handler()->GetNetworkList(&network_list);
   VLOG(1) << "NetworkStateNotifier:InitializeNetworks: "
           << network_list.size();
   for (NetworkStateList::iterator iter = network_list.begin();
        iter != network_list.end(); ++iter) {
     const NetworkState* network = *iter;
     VLOG(2) << " Network: " << network->path();
     cached_state_[network->path()] = network->connection_state();
   }
   const NetworkState* default_network =
-      NetworkStateHandler::Get()->DefaultNetwork();
+      NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   if (default_network && default_network->IsConnectedState())
     last_active_network_ = default_network->path();
 }
 
 }  // namespace internal
 }  // namespace ash