Add button to page info to revoke user certificate decisions.

chrome/browser/ui/views/website_settings/website_settings_popup_view.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/ui/views/website_settings/website_settings_popup_view.h"
 
 #include <algorithm>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/certificate_viewer.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/views/collected_cookies_views.h"
 #include "chrome/browser/ui/views/website_settings/permission_selector_view.h"
 #include "chrome/browser/ui/website_settings/website_settings.h"
 #include "chrome/browser/ui/website_settings/website_settings_utils.h"
 #include "chrome/common/url_constants.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cert_store.h"
+#include "content/public/browser/ssl_host_state.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_list.h"
@@ skipping 269 matching lines @@
       browser_(browser),
       header_(NULL),
       tabbed_pane_(NULL),
       site_data_content_(NULL),
       cookie_dialog_link_(NULL),
       permissions_content_(NULL),
       connection_tab_(NULL),
       identity_info_content_(NULL),
       certificate_dialog_link_(NULL),
       signed_certificate_timestamps_link_(NULL),
+      reset_decisions_button_(NULL),
       cert_id_(0),
       help_center_link_(NULL),
       connection_info_content_(NULL),
       page_info_content_(NULL),
       weak_factory_(this) {
   // Compensate for built-in vertical padding in the anchor view's image.
   set_anchor_view_insets(gfx::Insets(kLocationIconVerticalMargin, 0,
                                      kLocationIconVerticalMargin, 0));
 
   views::GridLayout* layout = new views::GridLayout(this);
@@ skipping 48 matching lines @@
 void WebsiteSettingsPopupView::OnPermissionChanged(
     const WebsiteSettingsUI::PermissionInfo& permission) {
   presenter_->OnSitePermissionChanged(permission.type, permission.setting);
 }
 
 void WebsiteSettingsPopupView::OnWidgetDestroying(views::Widget* widget) {
   is_popup_showing = false;
   presenter_->OnUIClosing();
 }
 
-void WebsiteSettingsPopupView::ButtonPressed(
-    views::Button* button,
-    const ui::Event& event) {
-  GetWidget()->Close();
-}
-
 void WebsiteSettingsPopupView::LinkClicked(views::Link* source,
                                            int event_flags) {
   // The popup closes automatically when the collected cookies dialog or the
   // certificate viewer opens. So delay handling of the link clicked to avoid
   // a crash in the base class which needs to complete the mouse event handling.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&WebsiteSettingsPopupView::HandleLinkClickedAsync,
                  weak_factory_.GetWeakPtr(), source));
 }
 
+void WebsiteSettingsPopupView::ButtonPressed(views::Button* button,
+                                             const ui::Event& event) {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&WebsiteSettingsPopupView::HandleButtonPressedAsync,

[Peter Kasting, 2014/08/06 01:19:07]

Do you really need to do this asynchronously?  The LinkClicked() machinery has
commentary explaining why it does things that way, but your newly added code has
no such commentary.

Honestly, I'm uncomfortable even with how the link click handling here is done. 
I don't think handling actions that can destroy the window should be
accomplished by making the click handling async, because then the click handling
gets pushed behind whatever else is in the message queue, which could be who
knows how much stuff.

The normal way we deal with things like this is to disconnect and/or hide the
widget synchronously, but tell it to close asynchronously, so that from the
user's perspective, everything we do appears synchronous.  Another way is to
ensure that the calling framework doesn't attempt to do any further processing
after this point.

I'm not going to tell you to fix all this in this patch, but it would be nice to
not add more such code unless we really need it; and especially if we DO need
it, I hope you can come back as a followup and fix this architecture.  You might
want to ask sky for advice as well, he's more familiar with event
handling/widget closure than I am and might be able to consult on technical
details.

[jww, 2014/08/06 17:58:18]

This UI stuff is a bit of a mystery to me, and I was really just trying to mimic
the behavior of the already working link click handler. Superficially, it
appears that nothing crazy is happening when I make it synchronous, so I'll make
it synchronous in the next patch.

+                 weak_factory_.GetWeakPtr(),
+                 button));
+}
+
 void WebsiteSettingsPopupView::TabSelectedAt(int index) {
   tabbed_pane_->GetSelectedTab()->Layout();
   SizeToContents();
 }
 
 gfx::Size WebsiteSettingsPopupView::GetPreferredSize() const {
   if (header_ == NULL && tabbed_pane_ == NULL)
     return views::View::GetPreferredSize();
 
   int height = 0;
@@ skipping 141 matching lines @@
         l10n_util::GetStringUTF16(IDS_PAGEINFO_CERT_INFO_BUTTON));
     certificate_dialog_link_->set_listener(this);
 
     if (!signed_certificate_timestamp_ids_.empty()) {
       signed_certificate_timestamps_link_ =
           new views::Link(l10n_util::GetStringUTF16(
               IDS_PAGEINFO_CERT_TRANSPARENCY_INFO_BUTTON));
       signed_certificate_timestamps_link_->set_listener(this);
     }
 
+    if (identity_info.certificate_decision_made) {
+      reset_decisions_button_ = new views::LabelButton(
+          this,
+          l10n_util::GetStringUTF16(
+              IDS_PAGEINFO_RESET_INVALID_CERTIFICATE_DECISIONS_BUTTON));
+      reset_decisions_button_->SetStyle(views::Button::STYLE_BUTTON);
+    }
+
     headline = base::UTF8ToUTF16(identity_info.site_identity);
   }
   ResetConnectionSection(
       identity_info_content_,
       WebsiteSettingsUI::GetIdentityIcon(identity_info.identity_status),
       base::string16(),  // The identity section has no headline.
       base::UTF8ToUTF16(identity_info.identity_status_description),
       certificate_dialog_link_,
-      signed_certificate_timestamps_link_);
+      signed_certificate_timestamps_link_,
+      reset_decisions_button_);
 
   ResetConnectionSection(
       connection_info_content_,
       WebsiteSettingsUI::GetConnectionIcon(identity_info.connection_status),
       base::string16(),  // The connection section has no headline.
       base::UTF8ToUTF16(identity_info.connection_status_description),
       NULL,
+      NULL,
       NULL);
 
   connection_tab_->InvalidateLayout();
   Layout();
   SizeToContents();
 }
 
 void WebsiteSettingsPopupView::SetFirstVisit(
     const base::string16& first_visit) {
   ResetConnectionSection(
       page_info_content_,
       WebsiteSettingsUI::GetFirstVisitIcon(first_visit),
       l10n_util::GetStringUTF16(IDS_PAGE_INFO_SITE_INFO_TITLE),
       first_visit,
       NULL,
+      NULL,
       NULL);
   connection_tab_->InvalidateLayout();
   Layout();
   SizeToContents();
 }
 
 void WebsiteSettingsPopupView::SetSelectedTab(TabId tab_id) {
   tabbed_pane_->SelectTabAt(tab_id);
 }
 
@@ skipping 98 matching lines @@
   layout->AddPaddingRow(1, kPermissionsSectionPaddingBottom);
   return container;
 }
 
 void WebsiteSettingsPopupView::ResetConnectionSection(
     views::View* section_container,
     const gfx::Image& icon,
     const base::string16& headline,
     const base::string16& text,
     views::Link* link,
-    views::Link* secondary_link) {
+    views::Link* secondary_link,
+    views::LabelButton* reset_decisions_button) {
   section_container->RemoveAllChildViews(true);
 
   views::GridLayout* layout = new views::GridLayout(section_container);
   section_container->SetLayoutManager(layout);
   views::ColumnSet* column_set = layout->AddColumnSet(0);
   column_set->AddPaddingColumn(0, kConnectionSectionPaddingLeft);
   column_set->AddColumn(views::GridLayout::LEADING,
                         views::GridLayout::LEADING,
                         0,
                         views::GridLayout::USE_PREF,
@@ skipping 52 matching lines @@
   if (link) {
     content_layout->StartRow(1, 0);
     content_layout->AddView(link);
   }
 
   if (secondary_link) {
     content_layout->StartRow(1, 0);
     content_layout->AddView(secondary_link);
   }
 
+  if (reset_decisions_button) {
+    content_layout->StartRow(1, 0);
+    content_layout->AddView(reset_decisions_button);
+  }
+
   layout->AddView(content_pane, 1, 1, views::GridLayout::LEADING,
                   views::GridLayout::LEADING);
   layout->AddPaddingRow(0, kConnectionSectionPaddingBottom);
 }
 
 // Used to asynchronously handle clicks since these calls may cause the
 // destruction of the settings view and the base class window still
 // needs to be alive to finish handling the mouse click.
 void WebsiteSettingsPopupView::HandleLinkClickedAsync(views::Link* source) {
   if (source == cookie_dialog_link_) {
@@ skipping 11 matching lines @@
         web_contents_, signed_certificate_timestamp_ids_);
   } else if (source == help_center_link_) {
     browser_->OpenURL(content::OpenURLParams(
         GURL(chrome::kPageInfoHelpCenterURL),
         content::Referrer(),
         NEW_FOREGROUND_TAB,
         content::PAGE_TRANSITION_LINK,
         false));
   }
 }
+
+void WebsiteSettingsPopupView::HandleButtonPressedAsync(views::Button* button) {
+  if (button == reset_decisions_button_) {
+    content::BrowserContext* context = web_contents_->GetBrowserContext();
+    content::SSLHostState host_state(context);
+    host_state.RevokeAllowAndDenyPreferencesHard(presenter_->site_url().host());
+    GetWidget()->Close();
+  }
+}