Move CaptivePortalDetector to src/components/captive_portal

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 22 matching lines @@
 const int kProxyChangeDelaySec = 1;
 
 const NetworkState* DefaultNetwork() {
   return NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
 }
 
 bool InSession() {
   return UserManager::IsInitialized() && UserManager::Get()->IsUserLoggedIn();
 }
 
-void RecordDetectionResult(NetworkPortalDetector::CaptivePortalStatus status) {
+void RecordDetectionResult(captive_portal::CaptivePortalStatus status) {
   if (InSession()) {
     UMA_HISTOGRAM_ENUMERATION(
         NetworkPortalDetectorImpl::kSessionDetectionResultHistogram,
         status,
-        NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+        captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
   } else {
     UMA_HISTOGRAM_ENUMERATION(
         NetworkPortalDetectorImpl::kOobeDetectionResultHistogram,
         status,
-        NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+        captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
   }
 }
 
 void RecordDetectionDuration(const base::TimeDelta& duration) {
   if (InSession()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         NetworkPortalDetectorImpl::kSessionDetectionDurationHistogram,
         duration);
   } else {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         NetworkPortalDetectorImpl::kOobeDetectionDurationHistogram, duration);
   }
 }
 
 void RecordDiscrepancyWithShill(
     const NetworkState* network,
-    const NetworkPortalDetector::CaptivePortalStatus status) {
+    const captive_portal::CaptivePortalStatus status) {
   if (InSession()) {
     if (network->connection_state() == shill::kStateOnline) {
       UMA_HISTOGRAM_ENUMERATION(
           NetworkPortalDetectorImpl::kSessionShillOnlineHistogram,
           status,
-          NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+          captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
     } else if (network->connection_state() == shill::kStatePortal) {
       UMA_HISTOGRAM_ENUMERATION(
           NetworkPortalDetectorImpl::kSessionShillPortalHistogram,
           status,
-          NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+          captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
     } else if (network->connection_state() == shill::kStateOffline) {
       UMA_HISTOGRAM_ENUMERATION(
           NetworkPortalDetectorImpl::kSessionShillOfflineHistogram,
           status,
-          NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+          captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
     }
   } else {
     if (network->connection_state() == shill::kStateOnline) {
       UMA_HISTOGRAM_ENUMERATION(
           NetworkPortalDetectorImpl::kOobeShillOnlineHistogram,
           status,
-          NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+          captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
     } else if (network->connection_state() == shill::kStatePortal) {
       UMA_HISTOGRAM_ENUMERATION(
           NetworkPortalDetectorImpl::kOobeShillPortalHistogram,
           status,
-          NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+          captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
     } else if (network->connection_state() == shill::kStateOffline) {
       UMA_HISTOGRAM_ENUMERATION(
           NetworkPortalDetectorImpl::kOobeShillOfflineHistogram,
           status,
-          NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT);
+          captive_portal::CAPTIVE_PORTAL_STATUS_COUNT);
     }
   }
 }
 
 void RecordPortalToOnlineTransition(const base::TimeDelta& duration) {
   if (InSession()) {
     UMA_HISTOGRAM_LONG_TIMES(
         NetworkPortalDetectorImpl::kSessionPortalToOnlineHistogram,
         duration);
   } else {
@@ skipping 142 matching lines @@
     const NetworkState* default_network) {
   DCHECK(CalledOnValidThread());
 
   if (!default_network) {
     default_network_name_.clear();
     default_network_id_.clear();
 
     StopDetection();
 
     CaptivePortalState state;
-    state.status = CAPTIVE_PORTAL_STATUS_OFFLINE;
+    state.status = captive_portal::CAPTIVE_PORTAL_STATUS_OFFLINE;
     OnDetectionCompleted(NULL, state);
     return;
   }
 
   default_network_name_ = default_network->name();
   default_network_id_ = default_network->guid();
 
   bool network_changed = (default_service_path_ != default_network->path());
   default_service_path_ = default_network->path();
 
   bool connection_state_changed =
       (default_connection_state_ != default_network->connection_state());
   default_connection_state_ = default_network->connection_state();
 
   if (network_changed || connection_state_changed)
     StopDetection();
 
   if (CanPerformAttempt() &&
       NetworkState::StateIsConnected(default_connection_state_)) {
     // Initiate Captive Portal detection if network's captive
     // portal state is unknown (e.g. for freshly created networks),
     // offline or if network connection state was changed.
     CaptivePortalState state = GetCaptivePortalState(default_network->path());
-    if (state.status == CAPTIVE_PORTAL_STATUS_UNKNOWN ||
-        state.status == CAPTIVE_PORTAL_STATUS_OFFLINE ||
+    if (state.status == captive_portal::CAPTIVE_PORTAL_STATUS_UNKNOWN ||
+        state.status == captive_portal::CAPTIVE_PORTAL_STATUS_OFFLINE ||
         (!network_changed && connection_state_changed)) {
       ScheduleAttempt(base::TimeDelta());
     }
   }
 }
 
 int NetworkPortalDetectorImpl::AttemptCount() { return attempt_count_; }
 
 base::TimeTicks NetworkPortalDetectorImpl::AttemptStartTime() {
   return attempt_start_time_;
@@ skipping 82 matching lines @@
           << "id=" << default_network_id_;
 
   captive_portal_detector_->Cancel();
   CaptivePortalDetector::Results results;
   results.result = captive_portal::RESULT_NO_RESPONSE;
   OnAttemptCompleted(results);
 }
 
 void NetworkPortalDetectorImpl::OnAttemptCompleted(
     const CaptivePortalDetector::Results& results) {
-  captive_portal::Result result = results.result;
+  captive_portal::CaptivePortalResult result = results.result;
   int response_code = results.response_code;
 
   DCHECK(CalledOnValidThread());
   DCHECK(is_checking_for_portal());
 
   VLOG(1) << "Detection attempt completed: "
           << "name=" << default_network_name_ << ", "
           << "id=" << default_network_id_ << ", "
           << "result="
-          << CaptivePortalDetector::CaptivePortalResultToString(results.result)
+          << captive_portal::CaptivePortalResultToString(results.result)
           << ", "
           << "response_code=" << results.response_code;
 
   state_ = STATE_IDLE;
   attempt_timeout_.Cancel();
   ++attempt_count_;
 
   const NetworkState* network = DefaultNetwork();
 
   // If using a fake profile client, also fake being behind a captive portal
   // if the default network is in portal state.
   if (result != captive_portal::RESULT_NO_RESPONSE &&
       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface() &&
       network && network->connection_state() == shill::kStatePortal) {
     result = captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL;
     response_code = 200;
   }
 
   CaptivePortalState state;
   state.response_code = response_code;
   state.time = GetCurrentTimeTicks();
   switch (result) {
     case captive_portal::RESULT_NO_RESPONSE:
       if (state.response_code == net::HTTP_PROXY_AUTHENTICATION_REQUIRED) {
-        state.status = CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
+        state.status =
+            captive_portal::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED;
       } else if (CanPerformAttempt()) {
         ScheduleAttempt(results.retry_after_delta);
         return;
       } else if (network &&
                  (network->connection_state() == shill::kStatePortal)) {
         // Take into account shill's detection results.
-        state.status = CAPTIVE_PORTAL_STATUS_PORTAL;
+        state.status = captive_portal::CAPTIVE_PORTAL_STATUS_PORTAL;
         LOG(WARNING) << "Network name=" << network->name() << ", "
-                     << "id=" << network->guid() << " "
-                     << "is marked as "
-                     << CaptivePortalStatusString(state.status) << " "
-                     << "despite the fact that CaptivePortalDetector "
-                     << "received no response";
+                     << "id=" << network->guid() << " is marked as "
+                     << captive_portal::CaptivePortalStatusString(state.status)
+                     << " despite no response from CaptivePortalDetector.";
       } else {
-        state.status = CAPTIVE_PORTAL_STATUS_OFFLINE;
+        state.status = captive_portal::CAPTIVE_PORTAL_STATUS_OFFLINE;
       }
       break;
     case captive_portal::RESULT_INTERNET_CONNECTED:
-      state.status = CAPTIVE_PORTAL_STATUS_ONLINE;
+      state.status = captive_portal::CAPTIVE_PORTAL_STATUS_ONLINE;
       break;
     case captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL:
-      state.status = CAPTIVE_PORTAL_STATUS_PORTAL;
+      state.status = captive_portal::CAPTIVE_PORTAL_STATUS_PORTAL;
       break;
     default:
       break;
   }
 
   OnDetectionCompleted(network, state);
   if (CanPerformAttempt() && strategy_->CanPerformAttemptAfterDetection())
     ScheduleAttempt(base::TimeDelta());
 }
 
@@ skipping 22 matching lines @@
     NotifyDetectionCompleted(network, state);
     return;
   }
 
   CaptivePortalStateMap::const_iterator it =
       portal_state_map_.find(network->path());
   if (it == portal_state_map_.end() || it->second.status != state.status ||
       it->second.response_code != state.response_code) {
     VLOG(1) << "Updating Chrome Captive Portal state: "
             << "name=" << network->name() << ", "
-            << "id=" << network->guid() << ", "
-            << "status=" << CaptivePortalStatusString(state.status) << ", "
-            << "response_code=" << state.response_code;
+            << "id=" << network->guid() << ", status="
+            << captive_portal::CaptivePortalStatusString(state.status)
+            << ", response_code=" << state.response_code;
 
     // Record detection duration iff detection result differs from the
     // previous one for this network. The reason is to record all stats
     // only when network changes it's state.
     RecordDetectionStats(network, state.status);
     if (it != portal_state_map_.end() &&
-        it->second.status == CAPTIVE_PORTAL_STATUS_PORTAL &&
-        state.status == CAPTIVE_PORTAL_STATUS_ONLINE) {
+        it->second.status == captive_portal::CAPTIVE_PORTAL_STATUS_PORTAL &&
+        state.status == captive_portal::CAPTIVE_PORTAL_STATUS_ONLINE) {
       RecordPortalToOnlineTransition(state.time - it->second.time);
     }
 
     portal_state_map_[network->path()] = state;
   }
   NotifyDetectionCompleted(network, state);
 }
 
 void NetworkPortalDetectorImpl::NotifyDetectionCompleted(
     const NetworkState* network,
     const CaptivePortalState& state) {
   FOR_EACH_OBSERVER(
       Observer, observers_, OnPortalDetectionCompleted(network, state));
   notification_controller_.OnPortalDetectionCompleted(network, state);
 }
 
 bool NetworkPortalDetectorImpl::AttemptTimeoutIsCancelledForTesting() const {
   return attempt_timeout_.IsCancelled();
 }
 
 void NetworkPortalDetectorImpl::RecordDetectionStats(
     const NetworkState* network,
-    CaptivePortalStatus status) {
+    captive_portal::CaptivePortalStatus status) {
   // Don't record stats for offline state.
   if (!network)
     return;
 
   if (!detection_start_time_.is_null())
     RecordDetectionDuration(GetCurrentTimeTicks() - detection_start_time_);
   RecordDetectionResult(status);
 
   switch (status) {
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN:
+    case captive_portal::CAPTIVE_PORTAL_STATUS_UNKNOWN:
       NOTREACHED();
       break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE:
+    case captive_portal::CAPTIVE_PORTAL_STATUS_OFFLINE:
       if (network->connection_state() == shill::kStateOnline ||
           network->connection_state() == shill::kStatePortal) {
         RecordDiscrepancyWithShill(network, status);
       }
       break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE:
+    case captive_portal::CAPTIVE_PORTAL_STATUS_ONLINE:
       if (network->connection_state() != shill::kStateOnline)
         RecordDiscrepancyWithShill(network, status);
       break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL:
+    case captive_portal::CAPTIVE_PORTAL_STATUS_PORTAL:
       if (network->connection_state() != shill::kStatePortal)
         RecordDiscrepancyWithShill(network, status);
       break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
+    case captive_portal::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED:
       if (network->connection_state() != shill::kStateOnline)
         RecordDiscrepancyWithShill(network, status);
       break;
-    case NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_COUNT:
+    case captive_portal::CAPTIVE_PORTAL_STATUS_COUNT:
       NOTREACHED();
       break;
   }
 }
 
 void NetworkPortalDetectorImpl::UpdateCurrentStrategy() {
   if (InSession()) {
     SetStrategy(PortalDetectorStrategy::STRATEGY_ID_SESSION);
     return;
   }
   if (error_screen_displayed_) {
     SetStrategy(PortalDetectorStrategy::STRATEGY_ID_ERROR_SCREEN);
     return;
   }
   SetStrategy(PortalDetectorStrategy::STRATEGY_ID_LOGIN_SCREEN);
 }
 
 void NetworkPortalDetectorImpl::SetStrategy(
     PortalDetectorStrategy::StrategyId id) {
   if (id == strategy_->Id())
     return;
   strategy_.reset(PortalDetectorStrategy::CreateById(id).release());
   strategy_->set_delegate(this);
   StopDetection();
   StartDetectionIfIdle();
 }
 
 }  // namespace chromeos