Bring up a content settings icon for ungestured registerProtocolHandler call.

chrome/browser/ui/content_settings/content_setting_bubble_model.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/content_settings/content_setting_bubble_model.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
+#include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h"
 #include "chrome/browser/ui/collected_cookies_infobar_delegate.h"
 #include "chrome/browser/ui/content_settings/content_setting_bubble_model_delegate.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 97 matching lines @@
   }
 
   void SetManageLink() {
     static const ContentSettingsTypeIdEntry kLinkIDs[] = {
       {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_LINK},
       {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_LINK},
       {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_LINK},
       {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_LINK},
       {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_LINK},
       {CONTENT_SETTINGS_TYPE_GEOLOCATION, IDS_GEOLOCATION_BUBBLE_MANAGE_LINK},
+      {CONTENT_SETTINGS_TYPE_REGISTER_PROTOCOL_HANDLER,
+        IDS_HANDLERS_BUBBLE_MANAGE_LINK}
     };
     set_manage_link(l10n_util::GetStringUTF8(
         GetIdForContentType(kLinkIDs, arraysize(kLinkIDs), content_type())));
   }
 
   virtual void OnManageLinkClicked() {
     if (delegate_)
       delegate_->ShowContentSettingsPage(content_type());
   }
 
@@ skipping 365 matching lines @@
       settings_map->SetContentSetting(
           ContentSettingsPattern::FromURLNoWildcard(it->first),
           ContentSettingsPattern::FromURLNoWildcard(embedder_url),
           CONTENT_SETTINGS_TYPE_GEOLOCATION,
           std::string(),
           CONTENT_SETTING_DEFAULT);
     }
   }
 };
 
+class ContentSettingRPHBubbleModel : public ContentSettingTitleAndLinkModel {
+ public:
+  ContentSettingRPHBubbleModel(Delegate* delegate,
+                               TabContents* tab_contents,
+                               Profile* profile,
+                               ContentSettingsType content_type)
+      : ContentSettingTitleAndLinkModel(
+            delegate, tab_contents, profile, content_type),
+        selected_item_(0),
+        pending_handler_(ProtocolHandler::EmptyProtocolHandler()),
+        previous_handler_(ProtocolHandler::EmptyProtocolHandler()) {
+    DCHECK_EQ(CONTENT_SETTINGS_TYPE_REGISTER_PROTOCOL_HANDLER, content_type);
+
+    TabSpecificContentSettings* content_settings =
+        tab_contents->content_settings();
+    pending_handler_ = content_settings->GetPendingProtocolHandler();
+    previous_handler_ = content_settings->GetPreviousProtocolHandler();
+
+    string16 protocol = UTF8ToUTF16(pending_handler_.protocol());
+    if (pending_handler_.protocol() == "mailto") {
+      protocol = l10n_util::GetStringUTF16(
+          IDS_REGISTER_PROTOCOL_HANDLER_MAILTO_NAME);
+    }
+    if (pending_handler_.protocol() == "webcal") {
+      protocol = l10n_util::GetStringUTF16(
+          IDS_REGISTER_PROTOCOL_HANDLER_WEBCAL_NAME);
+    }
+    if (previous_handler_.IsEmpty()) {
+      set_title(l10n_util::GetStringFUTF8(
+          IDS_REGISTER_PROTOCOL_HANDLER_CONFIRM,
+          pending_handler_.title(), UTF8ToUTF16(pending_handler_.url().host()),
+          protocol));
+    } else {
+      set_title(l10n_util::GetStringFUTF8(
+          IDS_REGISTER_PROTOCOL_HANDLER_CONFIRM_REPLACE,
+          pending_handler_.title(), UTF8ToUTF16(pending_handler_.url().host()),
+          protocol, previous_handler_.title()));
+    }
+
+    std::string radio_allow_label =
+        l10n_util::GetStringFUTF8(IDS_REGISTER_PROTOCOL_HANDLER_ACCEPT,
+                                  pending_handler_.title());
+    std::string radio_deny_label =
+        l10n_util::GetStringUTF8(IDS_REGISTER_PROTOCOL_HANDLER_DENY);
+    std::string radio_ignore_label =
+        l10n_util::GetStringUTF8(IDS_REGISTER_PROTOCOL_HANDLER_IGNORE);
+
+    GURL url = tab_contents->web_contents()->GetURL();
+    RadioGroup radio_group;
+    radio_group.url = url;
+
+    radio_group.radio_items.push_back(radio_allow_label);
+    radio_group.radio_items.push_back(radio_deny_label);
+    radio_group.radio_items.push_back(radio_ignore_label);
+    radio_group.default_item = 2;
+    selected_item_ = radio_group.default_item;
+    set_radio_group_enabled(true);
+    set_radio_group(radio_group);
+  }
+
+  virtual void OnCustomLinkClicked() {
+    RegisterProtocolHandler();
+  }
+
+  virtual void OnRadioClicked(int radio_index) {
+    if (selected_item_ != radio_index) {
+      selected_item_ = radio_index;
+
+      if (radio_index == 0) {
+        RegisterProtocolHandler();
+      } else if (radio_index == 1) {
+        UnregisterProtocolHandler();
+      } else if (radio_index == 2) {
+        IgnoreProtocolHandler();
+      }
+    }
+  }
+
+  void RegisterProtocolHandler() {
+    profile()->GetProtocolHandlerRegistry()->OnAcceptRegisterProtocolHandler(
+        pending_handler_);
+  }
+
+  void UnregisterProtocolHandler() {
+    profile()->GetProtocolHandlerRegistry()->OnDenyRegisterProtocolHandler(
+        pending_handler_);
+    if (!previous_handler_.IsEmpty()) {

[koz (OOO until 15th September), 2012/06/21 23:03:50]

There's still a subtle bug here. If the user clicks accept and then deny,
previous_handler_ will be empty and so nothing will happen (OnDenyRPH() being
idempotent once OnAcceptRPH() is called), meaning the original protocol handler
will still be registered. In the case where previous_handler_ is empty, I think
the correct thing to do is to call ClearDefault(). That, rather than
RemoveHandler(pending_handler_), because the latter will cause the same prompt
to appear the next time the user visits the page, as all memory of the protocol
handler will be erased.

The code for this method should be simply:

if (previous_handler_.IsEmpty())
  phr->ClearDefault(pending_handler_.scheme());
else
  phr->OnAcceptRegisterProtocolHandler(previous_handler_);

[Greg Billock, 2012/06/21 23:10:59]

I found this as well. Also added a tracker to make sure the current status of
the flag is known in between the bubble showing up.

On 2012/06/21 23:03:50, koz wrote:

+      profile()->GetProtocolHandlerRegistry()->OnAcceptRegisterProtocolHandler(
+          previous_handler_);
+    }
+  }
+
+  void IgnoreProtocolHandler() {
+    profile()->GetProtocolHandlerRegistry()->OnIgnoreRegisterProtocolHandler(
+        pending_handler_);
+  }
+
+ private:
+  int selected_item_;
+  ProtocolHandler pending_handler_;
+  ProtocolHandler previous_handler_;
+};
+
+
 // static
 ContentSettingBubbleModel*
     ContentSettingBubbleModel::CreateContentSettingBubbleModel(
         Delegate* delegate,
         TabContents* tab_contents,
         Profile* profile,
         ContentSettingsType content_type) {
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
     return new ContentSettingCookiesBubbleModel(delegate, tab_contents, profile,
                                                 content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_POPUPS) {
     return new ContentSettingPopupBubbleModel(delegate, tab_contents, profile,
                                               content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
     return new ContentSettingDomainListBubbleModel(delegate, tab_contents,
                                                    profile, content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_PLUGINS) {
     return new ContentSettingPluginBubbleModel(delegate, tab_contents, profile,
                                                content_type);
   }
+  if (content_type == CONTENT_SETTINGS_TYPE_REGISTER_PROTOCOL_HANDLER) {
+    return new ContentSettingRPHBubbleModel(delegate, tab_contents, profile,
+                                            content_type);
+  }
   return new ContentSettingSingleRadioGroup(delegate, tab_contents, profile,
                                             content_type);
 }
 
 ContentSettingBubbleModel::ContentSettingBubbleModel(
     TabContents* tab_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : tab_contents_(tab_contents),
       profile_(profile),
@@ skipping 34 matching lines @@
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED) {
     DCHECK_EQ(tab_contents_, content::Source<TabContents>(source).ptr());
     tab_contents_ = NULL;
   } else {
     DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
     DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
     profile_ = NULL;
   }
 }