src/chrome/browser/ui/content_settings/content_setting_bubble_model.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_UI_CONTENT_SETTINGS_CONTENT_SETTING_BUBBLE_MODEL_H_
   6 #define CHROME_BROWSER_UI_CONTENT_SETTINGS_CONTENT_SETTING_BUBBLE_MODEL_H_
   7
   8 #include <map>
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/compiler_specific.h"
  14 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
  15 #include "chrome/common/content_settings.h"
  16 #include "chrome/common/custom_handlers/protocol_handler.h"
  17 #include "content/public/browser/notification_observer.h"
  18 #include "content/public/browser/notification_registrar.h"
  19 #include "content/public/common/media_stream_request.h"
  20 #include "ui/gfx/image/image.h"
  21 #include "url/gurl.h"
  22
  23 class ContentSettingBubbleModelDelegate;
  24 class Profile;
  25 class ProtocolHandlerRegistry;
  26
  27 namespace content {
  28 class WebContents;
  29 }
  30
  31 // This model provides data for ContentSettingBubble, and also controls
  32 // the action triggered when the allow / block radio buttons are triggered.
  33 class ContentSettingBubbleModel : public content::NotificationObserver {
  34  public:
  35   typedef ContentSettingBubbleModelDelegate Delegate;
  36
  37   struct PopupItem {
  38     PopupItem(const gfx::Image& image, const std::string& title, int32 popup_id)
  39         : image(image), title(title), popup_id(popup_id) {}
  40
  41     gfx::Image image;
  42     std::string title;
  43     int32 popup_id;
  44   };
  45   typedef std::vector<PopupItem> PopupItems;
  46
  47   typedef std::vector<std::string> RadioItems;
  48   struct RadioGroup {
  49     RadioGroup();
  50     ~RadioGroup();
  51
  52     GURL url;
  53     std::string title;
  54     RadioItems radio_items;
  55     int default_item;
  56   };
  57
  58   struct DomainList {
  59     DomainList();
  60     ~DomainList();
  61
  62     std::string title;
  63     std::set<std::string> hosts;
  64   };
  65
  66   struct MediaMenu {
  67     MediaMenu();
  68     ~MediaMenu();
  69
  70     std::string label;
  71     content::MediaStreamDevice default_device;
  72     content::MediaStreamDevice selected_device;
  73     bool disabled;
  74   };
  75   typedef std::map<content::MediaStreamType, MediaMenu> MediaMenuMap;
  76
  77   struct BubbleContent {
  78     BubbleContent();
  79     ~BubbleContent();
  80
  81     std::string title;
  82     PopupItems popup_items;
  83     RadioGroup radio_group;
  84     bool radio_group_enabled;
  85     std::vector<DomainList> domain_lists;
  86     std::set<std::string> resource_identifiers;
  87     std::string custom_link;
  88     bool custom_link_enabled;
  89     std::string manage_link;
  90     MediaMenuMap media_menus;
  91
  92    private:
  93     DISALLOW_COPY_AND_ASSIGN(BubbleContent);
  94   };
  95
  96   static ContentSettingBubbleModel* CreateContentSettingBubbleModel(
  97       Delegate* delegate,
  98       content::WebContents* web_contents,
  99       Profile* profile,
 100       ContentSettingsType content_type);
 101
 102   virtual ~ContentSettingBubbleModel();
 103
 104   ContentSettingsType content_type() const { return content_type_; }
 105
 106   const BubbleContent& bubble_content() const { return bubble_content_; }
 107
 108   // content::NotificationObserver:
 109   virtual void Observe(int type,
 110                        const content::NotificationSource& source,
 111                        const content::NotificationDetails& details) OVERRIDE;
 112
 113   virtual void OnRadioClicked(int radio_index) {}
 114   virtual void OnPopupClicked(int index) {}
 115   virtual void OnCustomLinkClicked() {}
 116   virtual void OnManageLinkClicked() {}
 117   virtual void OnMediaMenuClicked(content::MediaStreamType type,
 118                                   const std::string& selected_device_id) {}
 119
 120   // Called by the view code when the cancel button in clicked by the user.
 121   virtual void OnCancelClicked() {}
 122
 123   // Called by the view code when the bubble is closed by the user using the
 124   // Done button.
 125   virtual void OnDoneClicked() {}
 126
 127   // Called by the view code when the save button in clicked by the user.
 128   virtual void OnSaveClicked() {}
 129
 130  protected:
 131   ContentSettingBubbleModel(
 132       content::WebContents* web_contents,
 133       Profile* profile,
 134       ContentSettingsType content_type);
 135
 136   content::WebContents* web_contents() const { return web_contents_; }
 137   Profile* profile() const { return profile_; }
 138
 139   void set_title(const std::string& title) { bubble_content_.title = title; }
 140   void add_popup(const PopupItem& popup) {
 141     bubble_content_.popup_items.push_back(popup);
 142   }
 143   void set_radio_group(const RadioGroup& radio_group) {
 144     bubble_content_.radio_group = radio_group;
 145   }
 146   void set_radio_group_enabled(bool enabled) {
 147     bubble_content_.radio_group_enabled = enabled;
 148   }
 149   void add_domain_list(const DomainList& domain_list) {
 150     bubble_content_.domain_lists.push_back(domain_list);
 151   }
 152   void set_custom_link(const std::string& link) {
 153     bubble_content_.custom_link = link;
 154   }
 155   void set_custom_link_enabled(bool enabled) {
 156     bubble_content_.custom_link_enabled = enabled;
 157   }
 158   void set_manage_link(const std::string& link) {
 159     bubble_content_.manage_link = link;
 160   }
 161   void add_media_menu(content::MediaStreamType type, const MediaMenu& menu) {
 162     bubble_content_.media_menus[type] = menu;
 163   }
 164   void set_selected_device(const content::MediaStreamDevice& device) {
 165     bubble_content_.media_menus[device.type].selected_device = device;
 166   }
 167   void AddBlockedResource(const std::string& resource_identifier);
 168
 169  private:
 170   content::WebContents* web_contents_;
 171   Profile* profile_;
 172   ContentSettingsType content_type_;
 173   BubbleContent bubble_content_;
 174   // A registrar for listening for WEB_CONTENTS_DESTROYED notifications.
 175   content::NotificationRegistrar registrar_;
 176
 177   DISALLOW_COPY_AND_ASSIGN(ContentSettingBubbleModel);
 178 };
 179
 180 class ContentSettingTitleAndLinkModel : public ContentSettingBubbleModel {
 181  public:
 182   ContentSettingTitleAndLinkModel(Delegate* delegate,
 183                                   content::WebContents* web_contents,
 184                                   Profile* profile,
 185                                   ContentSettingsType content_type);
 186   virtual ~ContentSettingTitleAndLinkModel() {}
 187   Delegate* delegate() const { return delegate_; }
 188
 189  private:
 190   void SetBlockedResources();
 191   void SetTitle();
 192   void SetManageLink();
 193   virtual void OnManageLinkClicked() OVERRIDE;
 194
 195   Delegate* delegate_;
 196 };
 197
 198 class SavePasswordBubbleModel : public ContentSettingTitleAndLinkModel {
 199  public:
 200   SavePasswordBubbleModel(Delegate* delegate,
 201                           content::WebContents* web_contents,
 202                           Profile* profile);
 203   virtual ~SavePasswordBubbleModel();
 204   virtual void OnCancelClicked() OVERRIDE;
 205   virtual void OnDoneClicked() OVERRIDE;
 206   virtual void OnSaveClicked() OVERRIDE;
 207
 208  private:
 209   void SetTitle();
 210
 211   TabSpecificContentSettings::PasswordSavingState state_;
 212
 213   DISALLOW_COPY_AND_ASSIGN(SavePasswordBubbleModel);
 214 };
 215
 216 class ContentSettingRPHBubbleModel : public ContentSettingTitleAndLinkModel {
 217  public:
 218   ContentSettingRPHBubbleModel(Delegate* delegate,
 219                                content::WebContents* web_contents,
 220                                Profile* profile,
 221                                ProtocolHandlerRegistry* registry,
 222                                ContentSettingsType content_type);
 223
 224   virtual void OnRadioClicked(int radio_index) OVERRIDE;
 225   virtual void OnDoneClicked() OVERRIDE;
 226
 227  private:
 228   // These states must match the order of appearance of the radio buttons
 229   // in the XIB file for the Mac port.
 230   enum RPHState {
 231     RPH_ALLOW = 0,
 232     RPH_BLOCK,
 233     RPH_IGNORE,
 234   };
 235
 236   void RegisterProtocolHandler();
 237   void UnregisterProtocolHandler();
 238   void IgnoreProtocolHandler();
 239   void ClearOrSetPreviousHandler();
 240
 241   int selected_item_;
 242   ProtocolHandlerRegistry* registry_;
 243   ProtocolHandler pending_handler_;
 244   ProtocolHandler previous_handler_;
 245 };
 246
 247 #endif  // CHROME_BROWSER_UI_CONTENT_SETTINGS_CONTENT_SETTING_BUBBLE_MODEL_H_