Override OnSSLCertificateError() in connectivity_checker.

chromecast/net/connectivity_checker.cc

 // Copyright 2015 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 "chromecast/net/connectivity_checker.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chromecast/net/net_switches.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 
 namespace chromecast {
 
 namespace {
 
-// How often connectivity checks are performed in seconds
+// How often connectivity checks are performed in seconds.
 const unsigned int kConnectivityPeriodSeconds = 1;
 
-// Number of consecutive bad responses received before connectivity status is
-// changed to offline
-const unsigned int kNumBadResponses = 3;
+// Number of consecutive connectivity check errors before status is changed
+// to offline.
+const unsigned int kNumErrorsToNotifyOffline = 3;
 
 // Default url for connectivity checking.
 const char kDefaultConnectivityCheckUrl[] =
     "https://clients3.google.com/generate_204";
 
 }  // namespace
 
 ConnectivityChecker::ConnectivityChecker(
     const scoped_refptr<base::MessageLoopProxy>& loop_proxy)
     : connectivity_observer_list_(
           new ObserverListThreadSafe<ConnectivityObserver>()),
       loop_proxy_(loop_proxy),
       connected_(false),
-      bad_responses_(0) {
+      check_errors_(0) {
   DCHECK(loop_proxy_.get());
   loop_proxy->PostTask(FROM_HERE,
                        base::Bind(&ConnectivityChecker::Initialize, this));
 }
 
 void ConnectivityChecker::Initialize() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   base::CommandLine::StringType check_url_str =
       command_line->GetSwitchValueNative(switches::kConnectivityCheckUrl);
   connectivity_check_url_.reset(new GURL(
@@ skipping 44 matching lines @@
 }
 
 void ConnectivityChecker::Check() {
   if (!loop_proxy_->BelongsToCurrentThread()) {
     loop_proxy_->PostTask(FROM_HERE,
                           base::Bind(&ConnectivityChecker::Check, this));
     return;
   }
   DCHECK(url_request_context_.get());
 
-  // Don't check connectivity if network is offline, because internet could be
+  // Don't check connectivity if network is offline, because Internet could be
   // accessible via netifs ignored.
   if (net::NetworkChangeNotifier::IsOffline())
     return;
 
   // If url_request_ is non-null, there is already a check going on. Don't
   // start another.
   if (url_request_.get())
     return;
 
   VLOG(1) << "Connectivity check: url=" << *connectivity_check_url_;
@@ skipping 25 matching lines @@
       (request->status().is_success() &&
        request->response_info().headers.get() != NULL)
           ? request->response_info().headers->response_code()
           : net::HTTP_BAD_REQUEST;
 
   // Clears resources.
   url_request_.reset(NULL);  // URLRequest::Cancel() is called in destructor.
 
   if (http_response_code < 400) {
     VLOG(1) << "Connectivity check succeeded";
-    bad_responses_ = 0;
+    check_errors_ = 0;
     SetConnectivity(true);
     return;
   }
+  VLOG(1) << "Connectivity check failed: " << http_response_code;
+  OnUrlRequestError();
+}
 
-  VLOG(1) << "Connectivity check failed: " << http_response_code;
-  ++bad_responses_;
-  if (bad_responses_ > kNumBadResponses) {
-    bad_responses_ = kNumBadResponses;
+void ConnectivityChecker::OnSSLCertificateError(net::URLRequest* request,
+                                                const net::SSLInfo& ssl_info,
+                                                bool fatal) {
+  LOG(ERROR) << "OnSSLCertificateError";
+  OnUrlRequestError();
+}
+
+void ConnectivityChecker::OnUrlRequestError() {
+  ++check_errors_;
+  if (check_errors_ > kNumErrorsToNotifyOffline) {
+    check_errors_ = kNumErrorsToNotifyOffline;
     SetConnectivity(false);
   }
-
-  // Check again
+  url_request_.reset(NULL);
+  // Check again.
   loop_proxy_->PostDelayedTask(
       FROM_HERE, base::Bind(&ConnectivityChecker::Check, this),
       base::TimeDelta::FromSeconds(kConnectivityPeriodSeconds));
 }
 
 void ConnectivityChecker::OnReadCompleted(net::URLRequest* request,
                                           int bytes_read) {
   NOTREACHED();
 }
 
 void ConnectivityChecker::Cancel() {
   if (url_request_.get()) {
     VLOG(2) << "Cancel connectivity check in progress";
     url_request_.reset(NULL);  // URLRequest::Cancel() is called in destructor.
   }
 }
 
 }  // namespace chromecast