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

ash/system/chromeos/network/network_icon.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_icon.h"
 
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_icon_animation.h"
 #include "ash/system/chromeos/network/network_icon_animation_observer.h"
 #include "base/utf_string_conversions.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size_conversions.h"
 
 using chromeos::DeviceState;
+using chromeos::NetworkHandler;
+using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
-using chromeos::NetworkState;
 
 namespace ash {
 namespace network_icon {
 
 namespace {
 
 //------------------------------------------------------------------------------
 // Struct to pass icon badges to NetworkIconImageSource.
 struct Badges {
   Badges()
@@ skipping 399 matching lines @@
   } else {
     LOG(WARNING) << "Request for icon for unsupported type: " << type;
     return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
   }
 }
 
 //------------------------------------------------------------------------------
 // Get connecting images
 
 gfx::ImageSkia GetConnectingVpnImage(IconType icon_type) {
-  NetworkStateHandler* handler = NetworkStateHandler::Get();
+  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const NetworkState* connected_network = NULL;
   if (icon_type == ICON_TYPE_TRAY) {
     connected_network = handler->ConnectedNetworkByType(
         NetworkStateHandler::kMatchTypeNonVirtual);
   }
   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 
   if (connected_network) {
     gfx::ImageSkia icon = GetImageForNetwork(connected_network, icon_type);
     Badges badges;
@@ skipping 81 matching lines @@
   }
   std::string roaming_state = network->roaming();
   if (roaming_state != roaming_state_) {
     roaming_state_ = roaming_state;
     dirty = true;
   }
   return dirty;
 }
 
 bool NetworkIconImpl::UpdateVPNBadge() {
-  const NetworkState* vpn =
-      NetworkStateHandler::Get()->ConnectedNetworkByType(flimflam::kTypeVPN);
+  const NetworkState* vpn = NetworkHandler::Get()->network_state_handler()->
+      ConnectedNetworkByType(flimflam::kTypeVPN);
   if (vpn && vpn_badge_ == NULL) {
     vpn_badge_ = BadgeForVPN(icon_type_);
     return true;
   } else if (!vpn && vpn_badge_ != NULL) {
     vpn_badge_ = NULL;
     return true;
   }
   return false;
 }
 
 void NetworkIconImpl::GetBadges(const NetworkState* network, Badges* badges) {
   DCHECK(network);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  NetworkStateHandler* handler = NetworkStateHandler::Get();
+  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 
   const std::string& type = network->type();
   if (type == flimflam::kTypeWifi) {
     if (network->security() != flimflam::kSecurityNone &&
         IconTypeIsDark(icon_type_)) {
       badges->bottom_right = rb.GetImageSkiaNamed(
           IDR_AURA_UBER_TRAY_NETWORK_SECURE_DARK);
     }
   } else if (type == flimflam::kTypeWimax) {
     technology_badge_ = rb.GetImageSkiaNamed(
@@ skipping 109 matching lines @@
     return l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ETHERNET);
   } else {
     return UTF8ToUTF16(network->name());
   }
 }
 
 int GetCellularUninitializedMsg() {
   static base::Time s_uninitialized_state_time;
   static int s_uninitialized_msg(0);
 
-  NetworkStateHandler* handler = NetworkStateHandler::Get();
+  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   if (handler->GetTechnologyState(NetworkStateHandler::kMatchTypeMobile)
       == NetworkStateHandler::TECHNOLOGY_UNINITIALIZED) {
     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_INITIALIZING_CELLULAR;
     s_uninitialized_state_time = base::Time::Now();
     return s_uninitialized_msg;
   } else if (handler->GetScanningByType(
       NetworkStateHandler::kMatchTypeMobile)) {
     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_CELLULAR_SCANNING;
     s_uninitialized_state_time = base::Time::Now();
     return s_uninitialized_msg;
   }
   // There can be a delay between leaving the Initializing state and when
   // a Cellular device shows up, so keep showing the initializing
   // animation for a bit to avoid flashing the disconnect icon.
   const int kInitializingDelaySeconds = 1;
   base::TimeDelta dtime = base::Time::Now() - s_uninitialized_state_time;
   if (dtime.InSeconds() < kInitializingDelaySeconds)
     return s_uninitialized_msg;
   return 0;
 }
 
 }  // namespace network_icon
 }  // namespace ash