Make the combobox in ContentSettingBubbleContents an actual combobox.

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/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/plugins/plugin_finder.h"
 #include "chrome/browser/plugins/plugin_metadata.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/layout_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/components_strings.h"
 #include "ui/base/cursor/cursor.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/font_list.h"
 #include "ui/gfx/text_utils.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/button/radio_button.h"
+#include "ui/views/controls/combobox/combobox.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_config.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"
 #include "ui/views/native_cursor.h"
 
 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 buttons.
-const int kMinMediaMenuButtonWidth = 150;
-
 }  // namespace
 
 using content::PluginService;
 using content::WebContents;
 
+// ContentSettingBubbleContents::MediaComboboxModel ----------------------------
+
+ContentSettingBubbleContents::MediaComboboxModel::MediaComboboxModel(
+    content::MediaStreamType type)
+    : type_(type) {
+  DCHECK(type_ == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
+         type_ == content::MEDIA_DEVICE_VIDEO_CAPTURE);
+}
+
+ContentSettingBubbleContents::MediaComboboxModel::~MediaComboboxModel() {}
+
+const content::MediaStreamDevices&
+ContentSettingBubbleContents::MediaComboboxModel::GetDevices() const {
+  MediaCaptureDevicesDispatcher* dispatcher =
+      MediaCaptureDevicesDispatcher::GetInstance();
+  return type_ == content::MEDIA_DEVICE_AUDIO_CAPTURE
+             ? dispatcher->GetAudioCaptureDevices()
+             : dispatcher->GetVideoCaptureDevices();
+}
+
+int ContentSettingBubbleContents::MediaComboboxModel::GetDeviceIndex(
+    const content::MediaStreamDevice& device) const {
+  const auto& devices = GetDevices();
+  for (size_t i = 0; i < devices.size(); ++i) {
+    if (device.id == devices[i].id)
+      return i;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+int ContentSettingBubbleContents::MediaComboboxModel::GetItemCount() const {
+  return std::max(1UL, GetDevices().size());
+}
+
+base::string16 ContentSettingBubbleContents::MediaComboboxModel::GetItemAt(
+    int index) {
+  return GetDevices().empty()
+             ? l10n_util::GetStringUTF16(IDS_MEDIA_MENU_NO_DEVICE_TITLE)
+             : base::UTF8ToUTF16(GetDevices()[index].name);
+}
 
 // ContentSettingBubbleContents::Favicon --------------------------------------
 
 class ContentSettingBubbleContents::Favicon : public views::ImageView {
  public:
   Favicon(const gfx::Image& image,
           ContentSettingBubbleContents* parent,
           views::Link* link);
   ~Favicon() override;
 
@@ skipping 31 matching lines @@
     parent_->LinkClicked(link_, event.flags());
   }
 }
 
 gfx::NativeCursor ContentSettingBubbleContents::Favicon::GetCursor(
     const ui::MouseEvent& event) {
   return views::GetNativeHandCursor();
 }
 
 
-// ContentSettingBubbleContents::MediaMenuParts -------------------------------
-
-struct ContentSettingBubbleContents::MediaMenuParts {
-  explicit MediaMenuParts(content::MediaStreamType type);
-  ~MediaMenuParts();
-
-  content::MediaStreamType type;
-  std::unique_ptr<ui::SimpleMenuModel> menu_model;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MediaMenuParts);
-};
-
-ContentSettingBubbleContents::MediaMenuParts::MediaMenuParts(
-    content::MediaStreamType type)
-    : type(type) {}
-
-ContentSettingBubbleContents::MediaMenuParts::~MediaMenuParts() {}
-
 // ContentSettingBubbleContents -----------------------------------------------
 
 ContentSettingBubbleContents::ContentSettingBubbleContents(
     ContentSettingBubbleModel* content_setting_bubble_model,
     content::WebContents* web_contents,
     views::View* anchor_view,
     views::BubbleBorder::Arrow arrow)
     : content::WebContentsObserver(web_contents),
       BubbleDialogDelegateView(anchor_view, arrow),
       content_setting_bubble_model_(content_setting_bubble_model),
       custom_link_(NULL),
       manage_link_(NULL),
       learn_more_link_(NULL),
       close_button_(NULL) {
   // Compensate for built-in vertical padding in the anchor view's image.
   set_anchor_view_insets(gfx::Insets(
       GetLayoutConstant(LOCATION_BAR_BUBBLE_ANCHOR_VERTICAL_INSET), 0));
 }
 
 ContentSettingBubbleContents::~ContentSettingBubbleContents() {
-  STLDeleteValues(&media_menus_);
+  // Must remove the children here so the comboboxes get destroyed before
+  // their associated models.
+  RemoveAllChildViews(true);
 }
 
 gfx::Size ContentSettingBubbleContents::GetPreferredSize() const {
   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(base::UTF8ToUTF16(label));
-      it->first->Layout();
-      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 107 matching lines @@
     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* label =
           new views::Label(base::UTF8ToUTF16(i->second.label));
       label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+      layout->AddView(label);
 
-      views::MenuButton* menu_button = new views::MenuButton(
-          base::UTF8ToUTF16((i->second.selected_device.name)), this, true);
-      menu_button->SetStyle(views::Button::STYLE_BUTTON);
-      menu_button->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-      menu_button->set_animate_on_state_change(false);
-
-      MediaMenuParts* menu_view = new MediaMenuParts(i->first);
-      menu_view->menu_model.reset(new ContentSettingMediaMenuModel(
-          i->first,
-          content_setting_bubble_model_.get(),
-          base::Bind(&ContentSettingBubbleContents::UpdateMenuLabel,
-                     base::Unretained(this))));
-      media_menus_[menu_button] = menu_view;
-
-      if (!menu_view->menu_model->GetItemCount()) {
-        // Show a "None available" title and grey out the menu when there are
-        // no available devices.
-        menu_button->SetText(
-            l10n_util::GetStringUTF16(IDS_MEDIA_MENU_NO_DEVICE_TITLE));
-        menu_button->SetEnabled(false);
-      }
-
+      combobox_models_.emplace_back(i->first);
+      MediaComboboxModel* model = &combobox_models_.back();
+      views::Combobox* combobox = new views::Combobox(model);
       // Disable the device selection when the website is managing the devices
-      // itself.
-      if (i->second.disabled)
-        menu_button->SetEnabled(false);
-
-      layout->AddView(label);
-      layout->AddView(menu_button);
+      // itself or if there are no devices present.
+      if (i->second.disabled || model->GetDevices().empty())
+        combobox->SetEnabled(false);

[msw, 2016/05/13 18:18:13]

optional nit: inline the inverse of the conditional.

[Evan Stade, 2016/05/13 18:46:12]

Done.

+      combobox->set_listener(this);
+      combobox->SetSelectedIndex(
+          model->GetDeviceIndex(i->second.selected_device));
+      layout->AddView(combobox);
 
       bubble_content_empty = false;
     }
   }
 
-  UpdateMenuButtonSizes();
-
   const gfx::FontList& domain_font =
       ui::ResourceBundle::GetSharedInstance().GetFontList(
           ui::ResourceBundle::BoldFont);
   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(base::UTF8ToUTF16(i->title));
     section_title->SetMultiLine(true);
     section_title->SetHorizontalAlignment(gfx::ALIGN_LEFT);
@@ skipping 83 matching lines @@
     // CAREFUL: Showing the settings window activates it, which deactivates the
     // info bubble, which causes it to close, which deletes us.
     return;
   }
 
   ListItemLinks::const_iterator i(list_item_links_.find(source));
   DCHECK(i != list_item_links_.end());
   content_setting_bubble_model_->OnListItemClicked(i->second);
 }
 
-void ContentSettingBubbleContents::OnMenuButtonClicked(
-    views::MenuButton* source,
-    const gfx::Point& point,
-    const ui::Event* event) {
-  MediaMenuPartsMap::iterator j(
-      media_menus_.find(static_cast<views::MenuButton*>(source)));
-  DCHECK(j != media_menus_.end());
-  menu_runner_.reset(new views::MenuRunner(j->second->menu_model.get(),
-                                           views::MenuRunner::HAS_MNEMONICS));
-
-  gfx::Point screen_location;
-  views::View::ConvertPointToScreen(j->first, &screen_location);
-  ignore_result(menu_runner_->RunMenuAt(
-      source->GetWidget(), j->first,
-      gfx::Rect(screen_location, j->first->size()), views::MENU_ANCHOR_TOPLEFT,
-      ui::MENU_SOURCE_NONE));
+void ContentSettingBubbleContents::OnPerformAction(views::Combobox* combobox) {
+  MediaComboboxModel* model =
+      static_cast<MediaComboboxModel*>(combobox->model());
+  content_setting_bubble_model_->OnMediaMenuClicked(
+      model->type(), model->GetDevices()[combobox->selected_index()].id);
 }
-
-void ContentSettingBubbleContents::UpdateMenuButtonSizes() {
-  const views::MenuConfig& config = views::MenuConfig::instance();
-  const int margins = config.item_left_margin + config.check_width +
-                      config.label_to_arrow_padding + config.arrow_width +
-                      config.arrow_to_edge_padding;
-
-  // The preferred media menu size sort of copies the logic in
-  // MenuItemView::CalculateDimensions(). When this was using TextButton, it
-  // completely coincidentally matched the logic in MenuItemView. We now need
-  // to redo this manually.
-  int menu_width = 0;
-  for (MediaMenuPartsMap::const_iterator i = media_menus_.begin();
-       i != media_menus_.end(); ++i) {
-    for (int j = 0; j < i->second->menu_model->GetItemCount(); ++j) {
-      int string_width = gfx::GetStringWidth(
-          i->second->menu_model->GetLabelAt(j),
-          config.font_list);
-
-      menu_width = std::max(menu_width, string_width);
-    }
-  }
-
-  // Make sure the width is at least kMinMediaMenuButtonWidth. The
-  // maximum width will be clamped by kMaxContentsWidth of the view.
-  menu_width = std::max(kMinMediaMenuButtonWidth, menu_width + margins);
-
-  for (MediaMenuPartsMap::const_iterator i = media_menus_.begin();
-       i != media_menus_.end(); ++i) {
-    i->first->SetMinSize(gfx::Size(menu_width, 0));
-    i->first->SetMaxSize(gfx::Size(menu_width, 0));
-  }
-}