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

chrome/browser/chromeos/net/network_portal_detector_impl.cc

 // Copyright (c) 2013 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_portal_detector_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 83 matching lines @@
                  content::NotificationService::AllSources());
 }
 
 NetworkPortalDetectorImpl::~NetworkPortalDetectorImpl() {
 }
 
 void NetworkPortalDetectorImpl::Init() {
   DCHECK(CalledOnValidThread());
 
   state_ = STATE_IDLE;
-  NetworkStateHandler::Get()->AddObserver(this);
+  NetworkHandler::Get()->network_state_handler()->AddObserver(this);
 }
 
 void NetworkPortalDetectorImpl::Shutdown() {
   DCHECK(CalledOnValidThread());
 
   detection_task_.Cancel();
   detection_timeout_.Cancel();
 
   captive_portal_detector_->Cancel();
   captive_portal_detector_.reset();
   observers_.Clear();
-  if (NetworkStateHandler::IsInitialized())
-    NetworkStateHandler::Get()->RemoveObserver(this);
+  if (NetworkHandler::IsInitialized())
+    NetworkHandler::Get()->network_state_handler()->RemoveObserver(this);
 }
 
 void NetworkPortalDetectorImpl::AddObserver(Observer* observer) {
   DCHECK(CalledOnValidThread());
   if (!observer || observers_.HasObserver(observer))
     return;
   observers_.AddObserver(observer);
 }
 
 void NetworkPortalDetectorImpl::AddAndFireObserver(Observer* observer) {
   DCHECK(CalledOnValidThread());
   if (!observer)
     return;
   AddObserver(observer);
-  const NetworkState* network = NetworkStateHandler::Get()->DefaultNetwork();
+  const NetworkState* network =
+      NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   observer->OnPortalDetectionCompleted(network, GetCaptivePortalState(network));
 }
 
 void NetworkPortalDetectorImpl::RemoveObserver(Observer* observer) {
   DCHECK(CalledOnValidThread());
   if (observer)
     observers_.RemoveObserver(observer);
 }
 
 bool NetworkPortalDetectorImpl::IsEnabled() {
   return enabled_;
 }
 
 void NetworkPortalDetectorImpl::Enable(bool start_detection) {
   DCHECK(CalledOnValidThread());
   if (enabled_)
     return;
   enabled_ = true;
   DCHECK(!IsPortalCheckPending());
   DCHECK(!IsCheckingForPortal());
   DCHECK(!lazy_detection_enabled());
   if (!start_detection)
     return;
   state_ = STATE_IDLE;
   attempt_count_ = 0;
   const NetworkState* default_network =
-      NetworkStateHandler::Get()->DefaultNetwork();
+      NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   if (!default_network)
     return;
   portal_state_map_.erase(default_network->path());
   DCHECK(CanPerformDetection());
   DetectCaptivePortal(base::TimeDelta());
 }
 
 NetworkPortalDetectorImpl::CaptivePortalState
 NetworkPortalDetectorImpl::GetCaptivePortalState(const NetworkState* network) {
   DCHECK(CalledOnValidThread());
@@ skipping 26 matching lines @@
 
 void NetworkPortalDetectorImpl::DisableLazyDetection() {
   CHECK(lazy_detection_enabled());
   lazy_detection_enabled_ = false;
   VLOG(1) << "Lazy detection mode disabled.";
 }
 
 void NetworkPortalDetectorImpl::NetworkManagerChanged() {
   DCHECK(CalledOnValidThread());
   const NetworkState* default_network =
-      NetworkStateHandler::Get()->DefaultNetwork();
+      NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   if (!default_network) {
     default_network_id_.clear();
     return;
   }
 
   default_network_id_ = default_network->guid();
 
   bool network_changed = (default_service_path_ != default_network->path());
   default_service_path_ = default_network->path();
 
@@ skipping 137 matching lines @@
   VLOG(1) << "Portal detection completed: "
           << "network=" << default_network_id_ << ", "
           << "result=" << CaptivePortalDetector::CaptivePortalResultToString(
               results.result) << ", "
           << "response_code=" << results.response_code;
 
   state_ = STATE_IDLE;
   detection_timeout_.Cancel();
 
   const NetworkState* default_network =
-      NetworkStateHandler::Get()->DefaultNetwork();
+      NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
 
   CaptivePortalState state;
   state.response_code = results.response_code;
   switch (results.result) {
     case captive_portal::RESULT_NO_RESPONSE:
       if (attempt_count_ >= kMaxRequestAttempts) {
         if (state.response_code == net::HTTP_PROXY_AUTHENTICATION_REQUIRED) {
           state.status = CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
         } else if (default_network && (default_network->connection_state() ==
                                        flimflam::kStatePortal)) {
@@ skipping 97 matching lines @@
     return base::TimeTicks::Now();
   return time_ticks_for_testing_;
 }
 
 bool NetworkPortalDetectorImpl::DetectionTimeoutIsCancelledForTesting() const {
   return detection_timeout_.IsCancelled();
 }
 
 int NetworkPortalDetectorImpl::GetRequestTimeoutSec() const {
   DCHECK_LE(0, attempt_count_);
-  const NetworkState* network = NetworkStateHandler::Get()->DefaultNetwork();
+  const NetworkState* network =
+      NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   if (!network)
     return kBaseRequestTimeoutSec;
   if (lazy_detection_enabled_)
     return kLazyRequestTimeoutSec;
   return attempt_count_ * kBaseRequestTimeoutSec;
 }
 
 }  // namespace chromeos