Move CaptivePortalDetector to src/components/captive_portal

components/captive_portal/captive_portal_detector.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 "chrome/browser/captive_portal/captive_portal_detector.h"
+#include "components/captive_portal/captive_portal_detector.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
-#include "chrome/browser/profiles/profile.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_status.h"
 
 namespace captive_portal {
 
-namespace {
-
-const char* const kCaptivePortalResultNames[] = {
-  "InternetConnected",
-  "NoResponse",
-  "BehindCaptivePortal",
-  "NumCaptivePortalResults",
-};
-COMPILE_ASSERT(arraysize(kCaptivePortalResultNames) == RESULT_COUNT + 1,
-               captive_portal_result_name_count_mismatch);
-
-}  // namespace
-
 const char CaptivePortalDetector::kDefaultURL[] =
     "http://www.gstatic.com/generate_204";
 
 CaptivePortalDetector::CaptivePortalDetector(
     const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : request_context_(request_context) {
 }
 
 CaptivePortalDetector::~CaptivePortalDetector() {
 }
 
-// static
-std::string CaptivePortalDetector::CaptivePortalResultToString(Result result) {
-  DCHECK_GE(result, 0);
-  DCHECK_LT(static_cast<unsigned int>(result),
-            arraysize(kCaptivePortalResultNames));
-  return kCaptivePortalResultNames[result];
-}
-
 void CaptivePortalDetector::DetectCaptivePortal(
     const GURL& url,
     const DetectionCallback& detection_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!FetchingURL());
   DCHECK(detection_callback_.is_null());
 
   detection_callback_ = detection_callback;
 
   // The first 0 means this can use a TestURLFetcherFactory in unit tests.
@@ skipping 35 matching lines @@
 }
 
 // Takes a net::URLFetcher that has finished trying to retrieve the test
 // URL, and returns a CaptivePortalService::Result based on its result.
 void CaptivePortalDetector::GetCaptivePortalResultFromResponse(
     const net::URLFetcher* url_fetcher,
     Results* results) const {
   DCHECK(results);
   DCHECK(!url_fetcher->GetStatus().is_io_pending());
 
-  results->result = RESULT_NO_RESPONSE;
+  results->result = captive_portal::RESULT_NO_RESPONSE;

[ygorshenin1, 2014/04/21 13:36:45]

Why did you explicitly specify namespace here?

[stevenjb, 2014/04/21 16:42:27]

In this case, I prefer explicitly namespaced enums, it makes it easier to tell
that the enum is not class or file local.

   results->response_code = url_fetcher->GetResponseCode();
   results->retry_after_delta = base::TimeDelta();
   results->landing_url = url_fetcher->GetURL();
 
   // If there's a network error of some sort when fetching a file via HTTP,
   // there may be a networking problem, rather than a captive portal.
   // TODO(mmenke):  Consider special handling for redirects that end up at
   //                errors, especially SSL certificate errors.
   if (url_fetcher->GetStatus().status() != net::URLRequestStatus::SUCCESS)
     return;
@@ skipping 17 matching lines @@
       if (full_date > now)
         results->retry_after_delta = full_date - now;
     }
     return;
   }
 
   // A 511 response (Network Authentication Required) means that the user needs
   // to login to whatever server issued the response.
   // See:  http://tools.ietf.org/html/rfc6585
   if (results->response_code == 511) {
-    results->result = RESULT_BEHIND_CAPTIVE_PORTAL;
+    results->result = captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL;
     return;
   }
 
   // Other non-2xx/3xx HTTP responses may indicate server errors.
   if (results->response_code >= 400 || results->response_code < 200)
     return;
 
   // A 204 response code indicates there's no captive portal.
   if (results->response_code == 204) {
-    results->result = RESULT_INTERNET_CONNECTED;
+    results->result = captive_portal::RESULT_INTERNET_CONNECTED;
     return;
   }
 
   // Otherwise, assume it's a captive portal.
-  results->result = RESULT_BEHIND_CAPTIVE_PORTAL;
+  results->result = captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL;
 }
 
 base::Time CaptivePortalDetector::GetCurrentTime() const {
   if (time_for_testing_.is_null())
     return base::Time::Now();
   else
     return time_for_testing_;
 }
 
 bool CaptivePortalDetector::FetchingURL() const {
   return url_fetcher_.get() != NULL;
 }
 
 }  // namespace captive_portal