Refactor NetworkPortalDetector and NetworkPortalNotificationController.

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"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/chromeos/net/network_portal_notification_controller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/portal_detector/network_portal_detector_stub.h"
 #include "components/device_event_log/device_event_log.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/content_switches.h"
 #include "net/http/http_status_code.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using base::StringPrintf;
 using captive_portal::CaptivePortalDetector;
 
 namespace chromeos {
@@ skipping 171 matching lines @@
 const char NetworkPortalDetectorImpl::kSessionShillPortalHistogram[] =
     "CaptivePortal.Session.DiscrepancyWithShill_RestrictedPool";
 const char NetworkPortalDetectorImpl::kSessionShillOfflineHistogram[] =
     "CaptivePortal.Session.DiscrepancyWithShill_Offline";
 const char NetworkPortalDetectorImpl::kSessionPortalToOnlineHistogram[] =
     "CaptivePortal.Session.PortalToOnlineTransition";
 
 // static
 void NetworkPortalDetectorImpl::Initialize(
     net::URLRequestContextGetter* url_context) {
-  if (NetworkPortalDetector::set_for_testing())
+  if (set_for_testing())
     return;
-  CHECK(!NetworkPortalDetector::network_portal_detector())
+  CHECK(!network_portal_detector())
       << "NetworkPortalDetector was initialized twice.";
-  NET_LOG(EVENT) << "NetworkPortalDetectorImpl::Initialize()";
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(::switches::kTestType))
-    set_network_portal_detector(new NetworkPortalDetectorStubImpl());
-  else
-    set_network_portal_detector(new NetworkPortalDetectorImpl(url_context));
+  NET_LOG(EVENT) << "NetworkPortalDetectorImpl::Initialize";
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          ::switches::kTestType)) {
+    set_network_portal_detector(new NetworkPortalDetectorStub());
+  } else {
+    set_network_portal_detector(
+        new NetworkPortalDetectorImpl(url_context, true));
+  }
 }
 
 NetworkPortalDetectorImpl::NetworkPortalDetectorImpl(
-    const scoped_refptr<net::URLRequestContextGetter>& request_context)
-    : state_(STATE_IDLE),
-      test_url_(CaptivePortalDetector::kDefaultURL),
-      enabled_(false),
+    const scoped_refptr<net::URLRequestContextGetter>& request_context,
+    bool create_notification_controller)
+    : test_url_(CaptivePortalDetector::kDefaultURL),
       strategy_(PortalDetectorStrategy::CreateById(
           PortalDetectorStrategy::STRATEGY_ID_LOGIN_SCREEN,
           this)),
-      last_detection_result_(CAPTIVE_PORTAL_STATUS_UNKNOWN),
-      same_detection_result_count_(0),
-      no_response_result_count_(0),
       weak_factory_(this) {
   NET_LOG(EVENT) << "NetworkPortalDetectorImpl::NetworkPortalDetectorImpl()";
   captive_portal_detector_.reset(new CaptivePortalDetector(request_context));
 
-  notification_controller_.set_retry_detection_callback(base::Bind(
-      &NetworkPortalDetectorImpl::RetryDetection, base::Unretained(this)));
+  if (create_notification_controller) {
+    notification_controller_.reset(
+        new NetworkPortalNotificationController(this));
+    notification_controller_->set_retry_detection_callback(
+        base::Bind(&NetworkPortalDetectorImpl::RetryDetection,
+                   weak_factory_.GetWeakPtr()));
+  }
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_PROXY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_SUPPLIED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTH_CANCELLED,
                  content::NotificationService::AllSources());
@@ skipping 80 matching lines @@
 void NetworkPortalDetectorImpl::SetStrategy(
     PortalDetectorStrategy::StrategyId id) {
   if (id == strategy_->Id())
     return;
   strategy_ = PortalDetectorStrategy::CreateById(id, this).Pass();
   StopDetection();
   StartDetectionIfIdle();
 }
 
 void NetworkPortalDetectorImpl::OnLockScreenRequest() {
-  notification_controller_.CloseDialog();
+  if (notification_controller_)
+    notification_controller_->CloseDialog();
 }
 
 void NetworkPortalDetectorImpl::DefaultNetworkChanged(
     const NetworkState* default_network) {
   DCHECK(CalledOnValidThread());
 
-  notification_controller_.DefaultNetworkChanged(default_network);
   if (!default_network) {
     NET_LOG(EVENT) << "Default network changed: None";
 
     default_network_name_.clear();
 
     StopDetection();
 
     CaptivePortalState state;
     state.status = CAPTIVE_PORTAL_STATUS_OFFLINE;
-    OnDetectionCompleted(NULL, state);
+    OnDetectionCompleted(nullptr, state);
     return;
   }
 
   default_network_name_ = default_network->name();
 
   bool network_changed = (default_network_id_ != default_network->guid());
   default_network_id_ = default_network->guid();
 
   bool connection_state_changed =
       (default_connection_state_ != default_network->connection_state());
@@ skipping 233 matching lines @@
     portal_state_map_[network->guid()] = 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) {
   // Don't record stats for offline state.
@@ skipping 31 matching lines @@
 }
 
 void NetworkPortalDetectorImpl::ResetStrategyAndCounters() {
   last_detection_result_ = CAPTIVE_PORTAL_STATUS_UNKNOWN;
   same_detection_result_count_ = 0;
   no_response_result_count_ = 0;
   strategy_->Reset();
 }
 
 }  // namespace chromeos