Add checkbox for reporting invalid TLS/SSL cert chains

chrome/browser/ssl/ssl_error_handler.cc

 // Copyright 2014 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/ssl/ssl_error_handler.h"
 
+#include "base/memory/ref_counted.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
+#include "chrome/browser/net/certificate_error_reporter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
 #include "chrome/browser/captive_portal/captive_portal_service.h"
 #include "chrome/browser/captive_portal/captive_portal_service_factory.h"
 #include "chrome/browser/captive_portal/captive_portal_tab_helper.h"
@@ skipping 61 matching lines @@
 }  // namespace
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(SSLErrorHandler);
 
 void SSLErrorHandler::HandleSSLError(
     content::WebContents* web_contents,
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
     int options_mask,
+    const scoped_refptr<chrome_browser_net::CertificateErrorReporter>&
+        certificate_error_reporter,

[Ryan Sleevi, 2015/03/14 03:09:42]

Rather than require this to be passed, you could do
CertificateErrorReporter::FromWebContents(web_contents); in the ctor of the
SSLErrorHandler

Or grab the Profile from the WebContents and grab the CertificateErrorReporter
off the profile's structures.

     const base::Callback<void(bool)>& callback) {
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
   CaptivePortalTabHelper* captive_portal_tab_helper =
       CaptivePortalTabHelper::FromWebContents(web_contents);
   if (captive_portal_tab_helper) {
     captive_portal_tab_helper->OnSSLCertError(ssl_info);
   }
 #endif
   DCHECK(!FromWebContents(web_contents));
-  web_contents->SetUserData(UserDataKey(),
-                            new SSLErrorHandler(web_contents, cert_error,
-                                                ssl_info, request_url,
-                                                options_mask, callback));
+  web_contents->SetUserData(
+      UserDataKey(),
+      new SSLErrorHandler(web_contents, cert_error, ssl_info, request_url,
+                          options_mask, certificate_error_reporter, callback));
 
   SSLErrorHandler* error_handler =
       SSLErrorHandler::FromWebContents(web_contents);
   error_handler->StartHandlingError();
 }
 
 // static
 void SSLErrorHandler::SetInterstitialDelayTypeForTest(
     SSLErrorHandler::InterstitialDelayType delay) {
   g_interstitial_delay_type = delay;
 }
 
 // static
 void SSLErrorHandler::SetInterstitialTimerStartedCallbackForTest(
     TimerStartedCallback* callback) {
   DCHECK(!callback || !callback->is_null());
   g_timer_started_callback = callback;
 }
 
-SSLErrorHandler::SSLErrorHandler(content::WebContents* web_contents,
-                                 int cert_error,
-                                 const net::SSLInfo& ssl_info,
-                                 const GURL& request_url,
-                                 int options_mask,
-                                 const base::Callback<void(bool)>& callback)
+SSLErrorHandler::SSLErrorHandler(
+    content::WebContents* web_contents,
+    int cert_error,
+    const net::SSLInfo& ssl_info,
+    const GURL& request_url,
+    int options_mask,
+    scoped_refptr<chrome_browser_net::CertificateErrorReporter>
+        certificate_error_reporter,
+    const base::Callback<void(bool)>& callback)
     : web_contents_(web_contents),
       cert_error_(cert_error),
       ssl_info_(ssl_info),
       request_url_(request_url),
       options_mask_(options_mask),
+      certificate_error_reporter_(certificate_error_reporter),
       callback_(callback) {
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
   Profile* profile = Profile::FromBrowserContext(
       web_contents->GetBrowserContext());
   registrar_.Add(this,
                  chrome::NOTIFICATION_CAPTIVE_PORTAL_CHECK_RESULT,
                  content::Source<Profile>(profile));
 #endif
 }
 
@@ skipping 50 matching lines @@
 #endif
 }
 
 void SSLErrorHandler::ShowSSLInterstitial() {
   // Show SSL blocking page. The interstitial owns the blocking page.
   RecordUMA(SSLBlockingPage::IsOptionsOverridable(options_mask_) ?
             SHOW_SSL_INTERSTITIAL_OVERRIDABLE :
             SHOW_SSL_INTERSTITIAL_NONOVERRIDABLE);
   (new SSLBlockingPage(web_contents_, cert_error_, ssl_info_, request_url_,
                        options_mask_, base::Time::NowFromSystemTime(),
-                       callback_))->Show();
+                       certificate_error_reporter_, callback_))->Show();

[Ryan Sleevi, 2015/03/14 03:09:42]

namespace {

void SendReport(const base::WeakPtr<CertificateErrorReporter>& reporter, const
net::SSLHostInfo& info, const std::string& hostname) {
   PostTask(BrowserThread::IO,
                  base::Bind(&CertificateErrorReporter::SendReport, reporter,
info, hostname));
}

}

....
base::WeakPtr<CertificateErrorReporter> reporter = ...;  // From Profile? From
WebContents
new SSLBlockingPage(...,
   base::Bind(&SendReport, reporter, ssl_info_, request_url_.host()),
callback_))->Show();

   // Once an interstitial is displayed, no need to keep the handler around.
   // This is the equivalent of "delete this".
   web_contents_->RemoveUserData(UserDataKey());
 }
 
 void SSLErrorHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
   if (type == chrome::NOTIFICATION_CAPTIVE_PORTAL_CHECK_RESULT) {
     timer_.Stop();
     CaptivePortalService::Results* results =
         content::Details<CaptivePortalService::Results>(details).ptr();
     if (results->result == captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL)
       ShowCaptivePortalInterstitial(results->landing_url);
     else
       ShowSSLInterstitial();
   }
 #endif
 }