Remove knowledge about SSLClientAuthHandler from chrome. Instead a callback is given to the embed...

chrome/browser/ui/gtk/ssl_client_certificate_selector.cc

 // Copyright (c) 2011 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_client_certificate_selector.h"
 
 #include <gtk/gtk.h>
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/certificate_viewer.h"
+#include "chrome/browser/ssl/ssl_client_auth_observer.h"
 #include "chrome/browser/ui/crypto_module_password_dialog.h"
 #include "chrome/browser/ui/gtk/constrained_window_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/net/x509_certificate_model.h"
-#include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/generated_resources.h"
+#include "net/base/ssl_cert_request_info.h"
 #include "net/base/x509_certificate.h"
 #include "ui/base/gtk/gtk_compat.h"
 #include "ui/base/gtk/gtk_hig_constants.h"
 #include "ui/base/gtk/gtk_signal.h"
 #include "ui/base/gtk/owned_widget_gtk.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/native_widget_types.h"
 
 using content::BrowserThread;
 
 namespace {
 
 enum {
   RESPONSE_SHOW_CERT_INFO = 1,
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // SSLClientCertificateSelector
 
 class SSLClientCertificateSelector : public SSLClientAuthObserver,
                                      public ConstrainedWindowGtkDelegate {
  public:
   explicit SSLClientCertificateSelector(
       TabContentsWrapper* parent,
+      const net::HttpNetworkSession* network_session,
       net::SSLCertRequestInfo* cert_request_info,
-      SSLClientAuthHandler* delegate);
+      const base::Callback<void(net::X509Certificate*)>& callback);
   ~SSLClientCertificateSelector();
 
   void Show();
 
   // SSLClientAuthObserver implementation:
   virtual void OnCertSelectedByNotification();
 
   // ConstrainedWindowGtkDelegate implementation:
   virtual GtkWidget* GetWidgetRoot() { return root_widget_.get(); }
   virtual GtkWidget* GetFocusWidget();
@@ skipping 13 matching lines @@
   // Callback after unlocking certificate slot.
   void Unlocked();
 
   CHROMEGTK_CALLBACK_0(SSLClientCertificateSelector, void, OnComboBoxChanged);
   CHROMEGTK_CALLBACK_0(SSLClientCertificateSelector, void, OnViewClicked);
   CHROMEGTK_CALLBACK_0(SSLClientCertificateSelector, void, OnCancelClicked);
   CHROMEGTK_CALLBACK_0(SSLClientCertificateSelector, void, OnOkClicked);
   CHROMEGTK_CALLBACK_1(SSLClientCertificateSelector, void, OnPromptShown,
                        GtkWidget*);
 
-  scoped_refptr<net::SSLCertRequestInfo> cert_request_info_;
-
   std::vector<std::string> details_strings_;
 
   GtkWidget* cert_combo_box_;
   GtkTextBuffer* cert_details_buffer_;
 
-  scoped_refptr<SSLClientAuthHandler> delegate_;
-
   ui::OwnedWidgetGtk root_widget_;
   // Hold on to the select button to focus it.
   GtkWidget* select_button_;
 
   TabContentsWrapper* wrapper_;
   ConstrainedWindow* window_;
 
   DISALLOW_COPY_AND_ASSIGN(SSLClientCertificateSelector);
 };
 
 SSLClientCertificateSelector::SSLClientCertificateSelector(
     TabContentsWrapper* wrapper,
+    const net::HttpNetworkSession* network_session,
     net::SSLCertRequestInfo* cert_request_info,
-    SSLClientAuthHandler* delegate)
-    : SSLClientAuthObserver(cert_request_info, delegate),
-      cert_request_info_(cert_request_info),
-      delegate_(delegate),
+    const base::Callback<void(net::X509Certificate*)>& callback)
+    : SSLClientAuthObserver(network_session, cert_request_info, callback),
       wrapper_(wrapper),
       window_(NULL) {
   root_widget_.Own(gtk_vbox_new(FALSE, ui::kControlSpacing));
 
   GtkWidget* site_vbox = gtk_vbox_new(FALSE, ui::kControlSpacing);
   gtk_box_pack_start(GTK_BOX(root_widget_.get()), site_vbox,
                      FALSE, FALSE, 0);
 
   GtkWidget* site_description_label = gtk_util::CreateBoldLabel(
       l10n_util::GetStringUTF8(IDS_CERT_SELECTOR_SITE_DESCRIPTION_LABEL));
@@ skipping 77 matching lines @@
 SSLClientCertificateSelector::~SSLClientCertificateSelector() {
   root_widget_.Destroy();
 }
 
 void SSLClientCertificateSelector::Show() {
   DCHECK(!window_);
   window_ = new ConstrainedWindowGtk(wrapper_, this);
 }
 
 void SSLClientCertificateSelector::OnCertSelectedByNotification() {
-  delegate_ = NULL;
   DCHECK(window_);
   window_->CloseConstrainedWindow();
 }
 
 GtkWidget* SSLClientCertificateSelector::GetFocusWidget() {
   return select_button_;
 }
 
 void SSLClientCertificateSelector::DeleteDelegate() {
-  if (delegate_) {
-    // The dialog was closed by escape key.
-    StopObserving();
-    delegate_->CertificateSelected(NULL);
-  }
+  // The dialog was closed by escape key.
+  StopObserving();
+  CertificateSelected(NULL);
   delete this;
 }
 
 void SSLClientCertificateSelector::PopulateCerts() {
   std::vector<std::string> nicknames;
   x509_certificate_model::GetNicknameStringsFromCertList(
-      cert_request_info_->client_certs,
+      cert_request_info()->client_certs,
       l10n_util::GetStringUTF8(IDS_CERT_SELECTOR_CERT_EXPIRED),
       l10n_util::GetStringUTF8(IDS_CERT_SELECTOR_CERT_NOT_YET_VALID),
       &nicknames);
 
   DCHECK_EQ(nicknames.size(),
-            cert_request_info_->client_certs.size());
+            cert_request_info()->client_certs.size());
 
-  for (size_t i = 0; i < cert_request_info_->client_certs.size(); ++i) {
+  for (size_t i = 0; i < cert_request_info()->client_certs.size(); ++i) {
     net::X509Certificate::OSCertHandle cert =
-        cert_request_info_->client_certs[i]->os_cert_handle();
+        cert_request_info()->client_certs[i]->os_cert_handle();
 
     details_strings_.push_back(FormatDetailsText(cert));
 
     gtk_combo_box_append_text(
         GTK_COMBO_BOX(cert_combo_box_),
         FormatComboBoxText(cert, nicknames[i]).c_str());
   }
 
   // Auto-select the first cert.
   gtk_combo_box_set_active(GTK_COMBO_BOX(cert_combo_box_), 0);
 }
 
 net::X509Certificate* SSLClientCertificateSelector::GetSelectedCert() {
   int selected = gtk_combo_box_get_active(GTK_COMBO_BOX(cert_combo_box_));
   if (selected >= 0 &&
       selected < static_cast<int>(
-          cert_request_info_->client_certs.size()))
-    return cert_request_info_->client_certs[selected];
+          cert_request_info()->client_certs.size()))
+    return cert_request_info()->client_certs[selected];
   return NULL;
 }
 
 // static
 std::string SSLClientCertificateSelector::FormatComboBoxText(
     net::X509Certificate::OSCertHandle cert, const std::string& nickname) {
   std::string rv(nickname);
   rv += " [";
   rv += x509_certificate_model::GetSerialNumberHexified(cert, "");
   rv += ']';
@@ skipping 58 matching lines @@
     rv += '\n';
     rv += l10n_util::GetStringFUTF8(IDS_CERT_TOKEN_FORMAT, token);
   }
 
   return rv;
 }
 
 void SSLClientCertificateSelector::Unlocked() {
   // TODO(mattm): refactor so we don't need to call GetSelectedCert again.
   net::X509Certificate* cert = GetSelectedCert();
-  delegate_->CertificateSelected(cert);
-  delegate_ = NULL;
+  CertificateSelected(cert);
   DCHECK(window_);
   window_->CloseConstrainedWindow();
 }
 
 void SSLClientCertificateSelector::OnComboBoxChanged(GtkWidget* combo_box) {
   int selected = gtk_combo_box_get_active(
       GTK_COMBO_BOX(cert_combo_box_));
   if (selected < 0)
     return;
   gtk_text_buffer_set_text(cert_details_buffer_,
                            details_strings_[selected].c_str(),
                            details_strings_[selected].size());
 }
 
 void SSLClientCertificateSelector::OnViewClicked(GtkWidget* button) {
   net::X509Certificate* cert = GetSelectedCert();
   if (cert) {
     GtkWidget* toplevel = gtk_widget_get_toplevel(root_widget_.get());
     ShowCertificateViewer(GTK_WINDOW(toplevel), cert);
   }
 }
 
 void SSLClientCertificateSelector::OnCancelClicked(GtkWidget* button) {
-  StopObserving();
-  delegate_->CertificateSelected(NULL);
-  delegate_ = NULL;
+  CertificateSelected(NULL);
   DCHECK(window_);
   window_->CloseConstrainedWindow();
 }
 
 void SSLClientCertificateSelector::OnOkClicked(GtkWidget* button) {
   net::X509Certificate* cert = GetSelectedCert();
 
   // Remove the observer before we try unlocking, otherwise we might act on a
   // notification while waiting for the unlock dialog, causing us to delete
   // ourself before the Unlocked callback gets called.
   StopObserving();
 
   browser::UnlockCertSlotIfNecessary(
       cert,
       browser::kCryptoModulePasswordClientAuth,
-      cert_request_info_->host_and_port,
+      cert_request_info()->host_and_port,
       base::Bind(&SSLClientCertificateSelector::Unlocked,
                  base::Unretained(this)));
 }
 
 void SSLClientCertificateSelector::OnPromptShown(GtkWidget* widget,
                                                  GtkWidget* previous_toplevel) {
   if (!root_widget_.get() ||
       !gtk_widget_is_toplevel(gtk_widget_get_toplevel(root_widget_.get())))
     return;
   gtk_widget_set_can_default(select_button_, TRUE);
   gtk_widget_grab_default(select_button_);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // SSLClientAuthHandler platform specific implementation:
 
 namespace browser {
 
 void ShowNativeSSLClientCertificateSelector(
     TabContentsWrapper* wrapper,
+    const net::HttpNetworkSession* network_session,
     net::SSLCertRequestInfo* cert_request_info,
-    SSLClientAuthHandler* delegate) {
+    const base::Callback<void(net::X509Certificate*)>& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  (new SSLClientCertificateSelector(wrapper,
-                                    cert_request_info,
-                                    delegate))->Show();
+  (new SSLClientCertificateSelector(
+      wrapper, network_session, cert_request_info, callback))->Show();
 }
 
 }  // namespace browser