Convert Register Protocol Handler dialog for Harmony/Material Design

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/webrtc/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/layout_constants.h"
+#include "chrome/browser/ui/views/harmony/layout_delegate.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/strings/grit/components_strings.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/base/cursor/cursor.h"
+#include "ui/base/default_style.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_border.h"
 #include "ui/views/controls/button/md_text_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"
@@ skipping 132 matching lines @@
 }
 
 ContentSettingBubbleContents::~ContentSettingBubbleContents() {
   // 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();
+  int preferred_width = LayoutDelegate::Get()->GetDialogPreferredWidth(
+      LayoutDelegate::DialogWidthType::SMALL);
+  if (!preferred_width)
+    preferred_width = (!content_setting_bubble_model_->bubble_content()
+                            .domain_lists.empty() &&
+                       (kMinMultiLineContentsWidth > preferred_size.width()))
+                          ? kMinMultiLineContentsWidth
+                          : preferred_size.width();
+  else
+    preferred_width -= margins().width();
   if (content_setting_bubble_model_->AsSubresourceFilterBubbleModel()) {
     preferred_size.set_width(std::min(preferred_width,
                                       kMaxDefaultContentsWidth));
   } else {
     preferred_size.set_width(std::min(preferred_width, kMaxContentsWidth));
   }
   return preferred_size;
 }
 
 void ContentSettingBubbleContents::Init() {
   using views::GridLayout;
 
   GridLayout* layout = new views::GridLayout(this);
   SetLayoutManager(layout);
+  const LayoutDelegate* layout_delegate = LayoutDelegate::Get();
+  const int related_control_horizontal_spacing =
+      layout_delegate->GetLayoutDistance(
+          LayoutDelegate::LayoutDistanceType::
+              RELATED_CONTROL_HORIZONTAL_SPACING);
+  const int related_control_vertical_spacing =
+      layout_delegate->GetLayoutDistance(
+          LayoutDelegate::LayoutDistanceType::RELATED_CONTROL_VERTICAL_SPACING);
+  const int unrelated_control_vertical_spacing =
+      layout_delegate->GetLayoutDistance(
+          LayoutDelegate::LayoutDistanceType::
+              UNRELATED_CONTROL_VERTICAL_SPACING);
 
   const int kSingleColumnSetId = 0;
   views::ColumnSet* column_set = layout->AddColumnSet(kSingleColumnSetId);
   column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 1,
                         GridLayout::USE_PREF, 0, 0);
-  column_set->AddPaddingColumn(0, views::kRelatedControlHorizontalSpacing);
+  column_set->AddPaddingColumn(0, related_control_horizontal_spacing);
   column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 1,
                         GridLayout::USE_PREF, 0, 0);
 
   const ContentSettingBubbleModel::BubbleContent& bubble_content =
       content_setting_bubble_model_->bubble_content();
   bool bubble_content_empty = true;
 
   if (!bubble_content.title.empty()) {
     views::Label* title_label = new views::Label(bubble_content.title);
     title_label->SetMultiLine(true);
     title_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+    if (layout_delegate->IsHarmonyMode()) {
+      ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+      title_label->SetFontList(
+          rb.GetFontListWithDelta(ui::kTitleFontSizeDelta));
+    }
     layout->StartRow(0, kSingleColumnSetId);
     layout->AddView(title_label);
     bubble_content_empty = false;
   }
 
   if (!bubble_content.message.empty()) {
     views::Label* message_label = new views::Label(bubble_content.message);
-    layout->AddPaddingRow(0, views::kUnrelatedControlVerticalSpacing);
+    layout->AddPaddingRow(0, unrelated_control_vertical_spacing);
     message_label->SetMultiLine(true);
     message_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
     layout->StartRow(0, kSingleColumnSetId);
     layout->AddView(message_label);
     bubble_content_empty = false;
   }
 
   if (!bubble_content.learn_more_link.empty()) {
     learn_more_link_ =
         new views::Link(base::UTF8ToUTF16(bubble_content.learn_more_link));
     learn_more_link_->set_listener(this);
     learn_more_link_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
     layout->AddView(learn_more_link_);
     bubble_content_empty = false;
   }
 
   // Layout for the item list (blocked plugins and popups).
   if (!bubble_content.list_items.empty()) {
     const int kItemListColumnSetId = 2;
     views::ColumnSet* item_list_column_set =
         layout->AddColumnSet(kItemListColumnSetId);
     item_list_column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 0,
                                     GridLayout::USE_PREF, 0, 0);
-    item_list_column_set->AddPaddingColumn(
-        0, views::kRelatedControlHorizontalSpacing);
+    item_list_column_set->AddPaddingColumn(0,
+                                           related_control_horizontal_spacing);
     item_list_column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 1,
                                     GridLayout::USE_PREF, 0, 0);
 
     int row = 0;
     for (const ContentSettingBubbleModel::ListItem& list_item :
          bubble_content.list_items) {
       if (!bubble_content_empty)
-        layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
+        layout->AddPaddingRow(0, related_control_vertical_spacing);
       layout->StartRow(0, kItemListColumnSetId);
       if (list_item.has_link) {
         views::Link* link = new views::Link(base::UTF8ToUTF16(list_item.title));
         link->set_listener(this);
         link->SetElideBehavior(gfx::ELIDE_MIDDLE);
         list_item_links_[link] = row;
         layout->AddView(new Favicon(list_item.image, this, link));
         layout->AddView(link);
       } else {
         views::ImageView* icon = new views::ImageView();
         icon->SetImage(list_item.image.AsImageSkia());
         layout->AddView(icon);
         layout->AddView(new views::Label(base::UTF8ToUTF16(list_item.title)));
       }
       row++;
       bubble_content_empty = false;
     }
   }
 
   const int indented_kSingleColumnSetId = 3;
   // Insert a column set with greater indent.
   views::ColumnSet* indented_single_column_set =
       layout->AddColumnSet(indented_kSingleColumnSetId);
-  indented_single_column_set->AddPaddingColumn(0, views::kCheckboxIndent);
+  indented_single_column_set->AddPaddingColumn(
+      0, layout_delegate->GetLayoutDistance(
+             LayoutDelegate::LayoutDistanceType::CHECKBOX_INDENT));
   indented_single_column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL,
                                         1, GridLayout::USE_PREF, 0, 0);
 
   const ContentSettingBubbleModel::RadioGroup& radio_group =
       bubble_content.radio_group;
   if (!radio_group.radio_items.empty()) {
     if (!bubble_content_empty)
-      layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
+      layout->AddPaddingRow(0, related_control_vertical_spacing);
     for (ContentSettingBubbleModel::RadioItems::const_iterator i(
          radio_group.radio_items.begin());
          i != radio_group.radio_items.end(); ++i) {
       views::RadioButton* radio =
           new views::RadioButton(base::UTF8ToUTF16(*i), 0);
       radio->SetEnabled(bubble_content.radio_group_enabled);
       radio->set_listener(this);
+      if (layout_delegate->IsHarmonyMode()) {
+        std::unique_ptr<views::LabelButtonBorder> border =
+            radio->CreateDefaultBorder();
+        gfx::Insets insets = border->GetInsets();
+        border->set_insets(
+            gfx::Insets(insets.top(), 0, insets.bottom(), insets.right()));
+        radio->SetBorder(std::move(border));
+      }
       radio_group_.push_back(radio);
       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_->AsMediaStreamBubbleModel()) {
     const int kMediaMenuColumnSetId = 4;
     views::ColumnSet* menu_column_set =
         layout->AddColumnSet(kMediaMenuColumnSetId);
-    menu_column_set->AddPaddingColumn(0, views::kCheckboxIndent);
+    menu_column_set->AddPaddingColumn(
+        0, layout_delegate->GetLayoutDistance(
+               LayoutDelegate::LayoutDistanceType::CHECKBOX_INDENT));
     menu_column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 0,
                                GridLayout::USE_PREF, 0, 0);
-    menu_column_set->AddPaddingColumn(
-        0, views::kRelatedControlHorizontalSpacing);
+    menu_column_set->AddPaddingColumn(0, related_control_horizontal_spacing);
     menu_column_set->AddColumn(GridLayout::LEADING, GridLayout::FILL, 1,
                                GridLayout::USE_PREF, 0, 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->AddPaddingRow(0, related_control_vertical_spacing);
       layout->StartRow(0, kMediaMenuColumnSetId);
 
       views::Label* label =
           new views::Label(base::UTF8ToUTF16(i->second.label));
       label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
       layout->AddView(label);
 
       combobox_models_.emplace_back(i->first);
       MediaComboboxModel* model = &combobox_models_.back();
       views::Combobox* combobox = new views::Combobox(model);
@@ skipping 30 matching lines @@
     }
     bubble_content_empty = false;
   }
 
   if (!bubble_content.custom_link.empty()) {
     custom_link_ =
         new views::Link(base::UTF8ToUTF16(bubble_content.custom_link));
     custom_link_->SetEnabled(bubble_content.custom_link_enabled);
     custom_link_->set_listener(this);
     if (!bubble_content_empty)
-      layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
+      layout->AddPaddingRow(0, related_control_vertical_spacing);
     layout->StartRow(0, kSingleColumnSetId);
     layout->AddView(custom_link_);
     bubble_content_empty = false;
   }
 
   if (!bubble_content_empty) {
-    layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
-    layout->StartRow(0, kSingleColumnSetId);
-    layout->AddView(new views::Separator(views::Separator::HORIZONTAL), 1, 1,
-                    GridLayout::FILL, GridLayout::FILL);
-    layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
+    if (!layout_delegate->IsHarmonyMode()) {
+      layout->AddPaddingRow(0, related_control_vertical_spacing);
+      layout->StartRow(0, kSingleColumnSetId);
+      layout->AddView(new views::Separator(views::Separator::HORIZONTAL), 1, 1,
+                      GridLayout::FILL, GridLayout::FILL);
+    }
+    layout->AddPaddingRow(0, related_control_vertical_spacing);
   }
 }
 
 views::View* ContentSettingBubbleContents::CreateExtraView() {
   if (content_setting_bubble_model_->bubble_content()
           .show_manage_text_as_button) {
     manage_button_ = views::MdTextButton::CreateSecondaryUiButton(
         this, base::UTF8ToUTF16(
                   content_setting_bubble_model_->bubble_content().manage_text));
     return manage_button_;
@@ skipping 68 matching lines @@
   DCHECK(i != list_item_links_.end());
   content_setting_bubble_model_->OnListItemClicked(i->second);
 }
 
 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);
 }