Adding device selection menus to the content setting bubble

chrome/browser/ui/views/content_setting_bubble_contents.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/content_setting_bubble_contents.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/prefs/pref_service.h"
+#include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/plugins/plugin_finder.h"
 #include "chrome/browser/plugins/plugin_metadata.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/chrome_style.h"
 #include "chrome/browser/ui/content_settings/content_setting_bubble_model.h"
+#include "chrome/browser/ui/content_settings/content_setting_media_menu_model.h"
 #include "chrome/browser/ui/views/browser_dialogs.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
+#include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
+#include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/models/simple_menu_model.h"
+#include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/button/radio_button.h"
 #include "ui/views/controls/button/text_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/link.h"
+#include "ui/views/controls/menu/menu.h"
+#include "ui/views/controls/menu/menu_model_adapter.h"
+#include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/separator.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/layout/layout_constants.h"
 
 #if defined(USE_AURA)
 #include "ui/base/cursor/cursor.h"
 #endif
 
+namespace {
+
 // If we don't clamp the maximum width, then very long URLs and titles can make
 // the bubble arbitrarily wide.
 const int kMaxContentsWidth = 500;
 
 // When we have multiline labels, we should set a minimum width lest we get very
 // narrow bubbles with lots of line-wrapping.
 const int kMinMultiLineContentsWidth = 250;
 
+// The minimum width of the media menu button.
+const int kMinMediaMenuButtonWidth = 100;
+
+}
+
 using content::PluginService;
 using content::WebContents;
 
+
+// Favicon --------------------------------------------------------------------

[Peter Kasting, 2013/02/18 18:23:18]

Nit: I would write the class name as "ContentSettingBubbleContents::Favicon"
since it's a member class.  (2 places)

[no longer working on chromium, 2013/02/19 14:37:36]

Done.

+
 class ContentSettingBubbleContents::Favicon : public views::ImageView {
  public:
   Favicon(const gfx::Image& image,
           ContentSettingBubbleContents* parent,
           views::Link* link);
   virtual ~Favicon();
 
  private:
   // views::View overrides:
   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
   virtual gfx::NativeCursor GetCursor(const ui::MouseEvent& event) OVERRIDE;
 
   ContentSettingBubbleContents* parent_;
   views::Link* link_;
 };
 
 ContentSettingBubbleContents::Favicon::Favicon(
     const gfx::Image& image,
     ContentSettingBubbleContents* parent,
     views::Link* link)
     : parent_(parent),
       link_(link) {
   SetImage(image.AsImageSkia());
 }
 
 ContentSettingBubbleContents::Favicon::~Favicon() {
 }
 
+
+// MediaMenuParts -------------------------------------------------------------
+
+struct ContentSettingBubbleContents::MediaMenuParts {
+  explicit MediaMenuParts(content::MediaStreamType type);
+  ~MediaMenuParts();
+
+  content::MediaStreamType type;
+  scoped_ptr<ui::SimpleMenuModel> menu_model;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MediaMenuParts);
+};
+
+ContentSettingBubbleContents::MediaMenuParts::MediaMenuParts(
+    content::MediaStreamType type)
+    : type(type) {}
+
+ContentSettingBubbleContents::MediaMenuParts::~MediaMenuParts() {}
+
 bool ContentSettingBubbleContents::Favicon::OnMousePressed(
     const ui::MouseEvent& event) {
   return event.IsLeftMouseButton() || event.IsMiddleMouseButton();
 }
 
 void ContentSettingBubbleContents::Favicon::OnMouseReleased(
     const ui::MouseEvent& event) {
   if ((event.IsLeftMouseButton() || event.IsMiddleMouseButton()) &&
      HitTestPoint(event.location())) {
     parent_->LinkClicked(link_, event.flags());
   }
 }
 
 gfx::NativeCursor ContentSettingBubbleContents::Favicon::GetCursor(

[Peter Kasting, 2013/02/18 18:23:18]

This function needs to go with the rest of the class.

[no longer working on chromium, 2013/02/19 14:37:36]

Done.

     const ui::MouseEvent& event) {
 #if defined(USE_AURA)
   return ui::kCursorHand;
 #elif defined(OS_WIN)
   static HCURSOR g_hand_cursor = LoadCursor(NULL, IDC_HAND);
   return g_hand_cursor;
 #endif
 }
 
 ContentSettingBubbleContents::ContentSettingBubbleContents(

[Peter Kasting, 2013/02/18 18:23:18]

You should have a divider above this.

[no longer working on chromium, 2013/02/19 14:37:36]

Done.

     ContentSettingBubbleModel* content_setting_bubble_model,
     WebContents* web_contents,
     views::View* anchor_view,
     views::BubbleBorder::ArrowLocation arrow_location)
     : BubbleDelegateView(anchor_view, arrow_location),
       content_setting_bubble_model_(content_setting_bubble_model),
       web_contents_(web_contents),
       custom_link_(NULL),
       manage_link_(NULL),
       close_button_(NULL) {
   // Compensate for built-in vertical padding in the anchor view's image.
   set_anchor_insets(gfx::Insets(5, 0, 5, 0));
 
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                  content::Source<WebContents>(web_contents));
 }
 
 ContentSettingBubbleContents::~ContentSettingBubbleContents() {
+  STLDeleteValues(&media_menus_);
 }
 
 gfx::Size ContentSettingBubbleContents::GetPreferredSize() {
   gfx::Size preferred_size(views::View::GetPreferredSize());
   int preferred_width =
       (!content_setting_bubble_model_->bubble_content().domain_lists.empty() &&
        (kMinMultiLineContentsWidth > preferred_size.width())) ?
       kMinMultiLineContentsWidth : preferred_size.width();
   preferred_size.set_width(std::min(preferred_width, kMaxContentsWidth));
   return preferred_size;
 }
 
+void ContentSettingBubbleContents::UpdateMenuLabel(
+    content::MediaStreamType type,
+    const std::string& label) {
+  for (MediaMenuPartsMap::const_iterator it = media_menus_.begin();
+       it != media_menus_.end(); ++it) {
+    if (it->second->type == type) {
+      it->first->SetText(UTF8ToUTF16(label));
+      return;
+    }
+  }
+  NOTREACHED();
+}
+
 void ContentSettingBubbleContents::Init() {
   using views::GridLayout;
 
   GridLayout* layout = new views::GridLayout(this);
   SetLayoutManager(layout);
 
   const int kSingleColumnSetId = 0;
   views::ColumnSet* column_set = layout->AddColumnSet(kSingleColumnSetId);
   column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 1,
                         GridLayout::USE_PREF, 0, 0);
@@ skipping 77 matching lines @@
       layout->StartRow(0, indented_kSingleColumnSetId);
       layout->AddView(radio);
       bubble_content_empty = false;
     }
     DCHECK(!radio_group_.empty());
     // Now that the buttons have been added to the view hierarchy, it's safe
     // to call SetChecked() on them.
     radio_group_[radio_group.default_item]->SetChecked(true);
   }
 
+  // Layout code for the media device menus.
+  if (content_setting_bubble_model_->content_type() ==
+      CONTENT_SETTINGS_TYPE_MEDIASTREAM) {
+    const int kMediaMenuColumnSetId = 2;
+    views::ColumnSet* menu_column_set =
+        layout->AddColumnSet(kMediaMenuColumnSetId);
+    menu_column_set->AddPaddingColumn(
+        0, chrome_style::kCheckboxIndent);
+    menu_column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 0,
+                               GridLayout::USE_PREF, 0, 0);
+    menu_column_set->AddPaddingColumn(
+        0, views::kRelatedControlHorizontalSpacing);
+    menu_column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 1,
+                               GridLayout::USE_PREF, 0, 0);
+
+    int max_menu_label_width = 0;
+    int menu_width = 0;
+    for (ContentSettingBubbleModel::MediaMenuMap::const_iterator i(
+         bubble_content.media_menus.begin());
+         i != bubble_content.media_menus.end(); ++i) {
+      if (!bubble_content_empty)
+        layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
+      layout->StartRow(0, kMediaMenuColumnSetId);
+
+      views::Label* menu_label =
+          new views::Label(UTF8ToUTF16(i->second.label));
+      menu_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+      views::MenuButton* menu_button = new views::MenuButton(
+          NULL, UTF8ToUTF16((i->second.selected_device.name)), this, false);
+      menu_button->set_alignment(views::TextButton::ALIGN_LEFT);
+      menu_button->set_border(
+          new views::TextButtonNativeThemeBorder(menu_button));
+      menu_button->set_animate_on_state_change(false);
+
+      MediaMenuParts* menu_view = new MediaMenuParts(i->first);
+      menu_view->menu_model.reset(new ContentSettingMediaMenuModel(
+          Profile::FromBrowserContext(
+              web_contents_->GetBrowserContext())->GetPrefs(),
+          i->first,
+          content_setting_bubble_model_.get(),
+          base::Bind(&ContentSettingBubbleContents::UpdateMenuLabel,
+                     base::Unretained(this))));
+      media_menus_[menu_button] = menu_view;
+
+      // Calculate the width for the menus based on the longest item in the
+      // menus and the available with of the bubble.
+      int menu_preferred_width = GetPreferredMediaMenuWidth(
+          menu_button, menu_view->menu_model.get());
+      menu_width = std::max(menu_width, menu_preferred_width);
+      max_menu_label_width = std::max(max_menu_label_width,
+                                      menu_label->GetPreferredSize().width());
+      int available_width =
+          layout->GetPreferredSize(this).width() -
+          chrome_style::kCheckboxIndent -
+          max_menu_label_width -
+          2 * views::kRelatedControlHorizontalSpacing;
+      menu_width = std::min(std::max(menu_width, kMinMediaMenuButtonWidth),
+                            available_width);

[Peter Kasting, 2013/02/18 18:23:18]

This code isn't right.  The available_width you calculate is changing each
iteration because max_menu_label_width is changing each iteration.  Plus even if
this were right it's still inefficient.

You should remove all the stuff about min widths and available widths from here.
 Only keep track of the max label width.  Then after the end of the loop, do any
further calculations a single time.

Furthermore I don't even understand what the available_width is calculating. 
You already subtract max_menu_label_width when calculating it so you're not
actually calculating the amount of space available for a label.  I'm confused.

[no longer working on chromium, 2013/02/19 14:37:36]

The UI looks like that
Microphone:  menu_button
Camera:      menu_button

The |menu_label| in the code mean Microphone: or Camera:, not the label on top
of the menu. I have already changed the name to avoid confusion on this.

The available width is calculating the pixel from the beginning of the menu
button til the right padding of the bubble - kRelatedControlHorizontalSpacing.

I also agree that we don't need to calculate the menu_width within the
iteration, though the result might be the same. Anyhow, the available_width
calculation has been removed from the new upload.

+
+      layout->AddView(menu_label);
+      layout->AddView(menu_button);
+
+      bubble_content_empty = false;
+    }
+
+    // Set all the menus to the width we calculated above.
+    for (MediaMenuPartsMap::const_iterator i = media_menus_.begin();
+         i != media_menus_.end(); ++i) {
+      i->first->set_min_width(menu_width);
+      i->first->set_max_width(menu_width);
+    }
+  }
+
   gfx::Font domain_font =
       views::Label().font().DeriveFont(0, gfx::Font::BOLD);
   for (std::vector<ContentSettingBubbleModel::DomainList>::const_iterator i(
        bubble_content.domain_lists.begin());
        i != bubble_content.domain_lists.end(); ++i) {
     layout->StartRow(0, kSingleColumnSetId);
     views::Label* section_title = new views::Label(UTF8ToUTF16(i->title));
     section_title->SetMultiLine(true);
     section_title->SetHorizontalAlignment(gfx::ALIGN_LEFT);
     layout->AddView(section_title, 1, 1, GridLayout::FILL, GridLayout::LEADING);
@@ skipping 75 matching lines @@
     // CAREFUL: Showing the settings window activates it, which deactivates the
     // info bubble, which causes it to close, which deletes us.
     return;
   }
 
   PopupLinks::const_iterator i(popup_links_.find(source));
   DCHECK(i != popup_links_.end());
   content_setting_bubble_model_->OnPopupClicked(i->second);
 }
 
+void ContentSettingBubbleContents::OnMenuButtonClicked(
+    views::View* source,
+    const gfx::Point& point) {
+  MediaMenuPartsMap::iterator i(media_menus_.find(
+      static_cast<views::MenuButton*>(source)));
+  DCHECK(i != media_menus_.end());
+
+  views::MenuModelAdapter menu_model_adapter(i->second->menu_model.get());
+  menu_runner_.reset(new views::MenuRunner(menu_model_adapter.CreateMenu()));
+
+  gfx::Point screen_location;
+  views::View::ConvertPointToScreen(i->first, &screen_location);
+  ignore_result(menu_runner_->RunMenuAt(
+      source->GetWidget(),
+      i->first,
+      gfx::Rect(screen_location, i->first->size()),
+      views::MenuItemView::TOPLEFT,
+      views::MenuRunner::HAS_MNEMONICS));
+}
+
 void ContentSettingBubbleContents::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(content::NOTIFICATION_WEB_CONTENTS_DESTROYED, type);
   DCHECK(source == content::Source<WebContents>(web_contents_));
   web_contents_ = NULL;
 }
+
+int ContentSettingBubbleContents::GetPreferredMediaMenuWidth(
+    views::MenuButton* button,
+    ui::SimpleMenuModel* menu_model) {
+  string16 title = button->text();
+
+  int width = button->GetPreferredSize().width();
+  for (int i = 0; i < menu_model->GetItemCount(); ++i) {
+    button->SetText(menu_model->GetLabelAt(i));
+    width = std::max(width, button->GetPreferredSize().width());
+  }
+
+  // Recover the title for the menu button.
+  button->SetText(title);
+  return width;
+}