// Copyright 2024 The Chromium Authors
// 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/mahi/mahi_menu_view.h"

#include <algorithm>
#include <memory>
#include <string>

#include "base/check_deref.h"
#include "base/check_is_test.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ref.h"
#include "base/metrics/histogram_functions.h"
#include "base/notreached.h"
#include "chrome/browser/ui/ash/editor_menu/utils/pre_target_handler.h"
#include "chrome/browser/ui/ash/editor_menu/utils/pre_target_handler_view.h"
#include "chrome/browser/ui/ash/editor_menu/utils/utils.h"
#include "chrome/browser/ui/ash/magic_boost/magic_boost_constants.h"
#include "chrome/browser/ui/views/mahi/mahi_menu_constants.h"
#include "chromeos/components/magic_boost/public/cpp/views/experiment_badge.h"
#include "chromeos/components/mahi/public/cpp/mahi_browser_util.h"
#include "chromeos/components/mahi/public/cpp/mahi_manager.h"
#include "chromeos/components/mahi/public/cpp/mahi_media_app_content_manager.h"
#include "chromeos/components/mahi/public/cpp/mahi_util.h"
#include "chromeos/components/mahi/public/cpp/mahi_web_contents_manager.h"
#include "chromeos/strings/grit/chromeos_strings.h"
#include "chromeos/ui/vector_icons/vector_icons.h"
#include "components/application_locale_storage/application_locale_storage.h"
#include "components/vector_icons/vector_icons.h"
#include "ui/accessibility/ax_enums.mojom-shared.h"
#include "ui/accessibility/ax_node_data.h"
#include "ui/aura/window.h"
#include "ui/base/ime/text_input_type.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/base/models/image_model.h"
#include "ui/base/ui_base_features.h"
#include "ui/color/color_id.h"
#include "ui/display/screen.h"
#include "ui/events/event.h"
#include "ui/events/keycodes/keyboard_codes_posix.h"
#include "ui/events/types/event_type.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/vector_icon_types.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/background.h"
#include "ui/views/border.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/controls/button/image_button.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/focus_ring.h"
#include "ui/views/controls/highlight_path_generator.h"
#include "ui/views/controls/label.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/views/controls/textfield/textfield_controller.h"
#include "ui/views/layout/flex_layout.h"
#include "ui/views/layout/flex_layout_view.h"
#include "ui/views/layout/layout_provider.h"
#include "ui/views/layout/layout_types.h"
#include "ui/views/metadata/view_factory.h"
#include "ui/views/style/typography.h"
#include "ui/views/view.h"
#include "ui/views/view_class_properties.h"
#include "ui/views/view_utils.h"
#include "ui/views/widget/unique_widget_ptr.h"
#include "ui/views/widget/widget.h"
#include "ui/wm/public/activation_client.h"

namespace chromeos::mahi {

namespace {

using ::chromeos::mahi::ButtonType;

constexpr char kWidgetName[] = "MahiMenuViewWidget";
constexpr char16_t kCardShownAnnouncement[] =
    u"Help Me Read, press tab to focus the Help Me Read card.";

constexpr gfx::Insets kMenuPadding = gfx::Insets::TLBR(12, 16, 12, 14);
constexpr int kButtonHeight = 16;
constexpr int kButtonCornerRadius = 8;
constexpr gfx::Insets kButtonPadding = gfx::Insets::VH(6, 8);
constexpr gfx::Insets kHeaderRowPadding = gfx::Insets::TLBR(0, 0, 12, 0);
constexpr int kHeaderRowSpacing = 8;
constexpr int kButtonsRowSpacing = 12;
constexpr int kButtonTextfieldSpacing = 16;
constexpr int kButtonImageLabelSpacing = 4;
constexpr int kButtonBorderThickness = 1;
constexpr int kTextfieldContainerSpacing = 8;
constexpr int kInputContainerCornerRadius = 8;
constexpr gfx::Insets kTextfieldButtonPadding = gfx::Insets::VH(0, 8);

void StyleMenuButton(views::LabelButton* button, const gfx::VectorIcon& icon) {
  button->SetLabelStyle(views::style::STYLE_BODY_4_EMPHASIS);
  button->SetImageModel(views::Button::ButtonState::STATE_NORMAL,
                        ui::ImageModel::FromVectorIcon(
                            icon, ui::kColorSysOnSurface, kButtonHeight));
  button->SetImageModel(views::Button::ButtonState::STATE_DISABLED,
                        ui::ImageModel::FromVectorIcon(
                            icon, ui::kColorSysStateDisabled, kButtonHeight));
  button->SetTextColor(views::LabelButton::ButtonState::STATE_NORMAL,
                       ui::kColorSysOnSurface);
  button->SetTextColor(views::LabelButton::ButtonState::STATE_DISABLED,
                       ui::kColorSysStateDisabled);
  button->SetImageLabelSpacing(kButtonImageLabelSpacing);

  auto color_id = button->GetEnabled() ? ui::kColorSysTonalOutline
                                       : ui::kColorButtonBorderDisabled;
  button->SetBorder(views::CreatePaddedBorder(
      views::CreateRoundedRectBorder(kButtonBorderThickness,
                                     kButtonCornerRadius, color_id),
      kButtonPadding));
}

std::u16string GetSimplifyButtonTooltipText(SelectedTextState text_state) {
  switch (text_state) {
    case SelectedTextState::kTooShort:
      return l10n_util::GetStringUTF16(
          IDS_MAHI_SIMPLIFY_BUTTON_TOOL_TIP_DISABLED_SELECTION_TOO_SHORT);
    case SelectedTextState::kTooLong:
      return l10n_util::GetStringUTF16(
          IDS_MAHI_SIMPLIFY_BUTTON_TOOL_TIP_DISABLED_SELECTION_TOO_LONG);
    case SelectedTextState::kEmpty:
      return l10n_util::GetStringUTF16(
          IDS_MAHI_SIMPLIFY_BUTTON_TOOL_TIP_DISABLED_SELECTION_EMPTY);
    case SelectedTextState::kEligible:
    default:
      break;
  }

  return std::u16string();
}

// Custom widget to ensure the MahiMenuView follows the same theme as the
// browser context menu.
class MahiMenuWidget : public views::Widget {
 public:
  explicit MahiMenuWidget(views::Widget::InitParams init_params)
      : views::Widget(std::move(init_params)) {}
  MahiMenuWidget(const MahiMenuWidget&) = delete;
  MahiMenuWidget& operator=(const MahiMenuWidget&) = delete;
  ~MahiMenuWidget() override = default;

 protected:
  const ui::ColorProvider* GetColorProvider() const override {
    // Get the color provider for the active window if possible to match the
    // color theme for the browser.
    aura::Window& native_window = CHECK_DEREF(GetNativeWindow());
    aura::Window& root_window = CHECK_DEREF(native_window.GetRootWindow());
    if (auto* activation_client = wm::GetActivationClient(&root_window)) {
      if (auto* active_window = activation_client->GetActiveWindow()) {
        if (auto* widget =
                views::Widget::GetWidgetForNativeWindow(active_window)) {
          return widget->GetColorProvider();
        }
      }
    }

    return views::Widget::GetColorProvider();
  }
};

}  // namespace

// Controller for the `textfield_` owned by `MahiMenuView`. Enables the
// `submit_question_button` only when the `textfield_` contains some input.
// Also, submits a question if the user presses the enter key while focused on
// the textfield.
class MahiMenuView::MenuTextfieldController
    : public views::TextfieldController {
 public:
  explicit MenuTextfieldController(base::WeakPtr<MahiMenuView> menu_view)
      : menu_view_(menu_view) {}
  MenuTextfieldController(const MenuTextfieldController&) = delete;
  MenuTextfieldController& operator=(const MenuTextfieldController&) = delete;
  ~MenuTextfieldController() override = default;

 private:
  // views::TextfieldController:
  bool HandleKeyEvent(views::Textfield* sender,
                      const ui::KeyEvent& event) override {
    // Do not try to send a reply if no text has been input.
    if (!menu_view_ || sender->GetText().empty()) {
      return false;
    }

    if (event.type() == ui::EventType::kKeyPressed &&
        event.key_code() == ui::VKEY_RETURN) {
      menu_view_->OnQuestionSubmitted();
      return true;
    }

    return false;
  }
  void OnAfterUserAction(views::Textfield* sender) override {
    if (!menu_view_) {
      return;
    }

    bool enabled = !sender->GetText().empty();
    menu_view_->GetViewByID(ViewID::kSubmitQuestionButton)->SetEnabled(enabled);
  }

  base::WeakPtr<MahiMenuView> menu_view_;
};

MahiMenuView::MahiMenuView(
    const ApplicationLocaleStorage* application_locale_storage,
    ButtonStatus button_status,
    Surface surface)
    : chromeos::editor_menu::PreTargetHandlerView(
          chromeos::editor_menu::CardType::kMahiDefaultMenu),
      application_locale_storage_(CHECK_DEREF(application_locale_storage)),
      surface_(surface) {
  SetBackground(views::CreateRoundedRectBackground(
      ui::kColorPrimaryBackground,
      views::LayoutProvider::Get()->GetCornerRadiusMetric(
          views::ShapeContextTokens::kMenuRadius)));

  auto* layout = SetLayoutManager(std::make_unique<views::FlexLayout>());
  layout->SetOrientation(views::LayoutOrientation::kVertical);
  layout->SetInteriorMargin(kMenuPadding);

  auto header_row = std::make_unique<views::FlexLayoutView>();
  header_row->SetOrientation(views::LayoutOrientation::kHorizontal);
  header_row->SetInteriorMargin(kHeaderRowPadding);

  auto header_left_container = std::make_unique<views::FlexLayoutView>();
  header_left_container->SetOrientation(views::LayoutOrientation::kHorizontal);
  header_left_container->SetMainAxisAlignment(views::LayoutAlignment::kStart);
  header_left_container->SetCrossAxisAlignment(views::LayoutAlignment::kCenter);
  header_left_container->SetDefault(
      views::kMarginsKey, gfx::Insets::TLBR(0, 0, 0, kHeaderRowSpacing));
  header_left_container->SetProperty(
      views::kFlexBehaviorKey,
      views::FlexSpecification(
          views::FlexSpecification(views::MinimumFlexSizeRule::kPreferred,
                                   views::MaximumFlexSizeRule::kUnbounded)));

  auto* header_label =
      header_left_container->AddChildView(std::make_unique<views::Label>(
          l10n_util::GetStringUTF16(IDS_ASH_MAHI_MENU_TITLE),
          views::style::CONTEXT_DIALOG_TITLE, views::style::STYLE_HEADLINE_5));
  header_label->SetEnabledColor(ui::kColorSysOnSurface);
  header_label->SetHorizontalAlignment(gfx::HorizontalAlignment::ALIGN_LEFT);
  header_label->GetViewAccessibility().SetRole(ax::mojom::Role::kHeading);

  header_left_container->AddChildView(
      std::make_unique<chromeos::ExperimentBadge>());

  header_row->AddChildView(std::move(header_left_container));

  settings_button_ =
      header_row->AddChildView(views::ImageButton::CreateIconButton(
          base::BindRepeating(&MahiMenuView::OnButtonPressed,
                              weak_ptr_factory_.GetWeakPtr(),
                              ButtonType::kSettings),
          ::features::IsRoundedIconsEnabled()
              ? vector_icons::kSettingsIcon
              : vector_icons::kSettingsOutlineOldIcon,
          l10n_util::GetStringUTF16(IDS_EDITOR_MENU_SETTINGS_TOOLTIP)));
  settings_button_->SetID(ViewID::kSettingsButton);

  AddChildView(std::move(header_row));

  // Keeps this logic a separate block instead of inline to make it clear.
  // The summary button can be used for summarizing the whole document ( when
  // text_state = kEmpty), or summarizing the selected text.
  // If the selected text is non empty but too short to summarize, we show a
  // disabled summary button with proper tooltip.
  const auto text_state = button_status.summary_of_selection_eligibility;
  CHECK(text_state == SelectedTextState::kEmpty ||
        text_state == SelectedTextState::kTooShort ||
        text_state == SelectedTextState::kEligible);
  const bool summary_button_enabled =
      text_state != SelectedTextState::kTooShort;
  const ButtonType summary_button_type = text_state == SelectedTextState::kEmpty
                                             ? ButtonType::kSummary
                                             : ButtonType::kSummaryOfSelection;

  // Create row containing the `summary_button_` and `outline_button_`.
  AddChildView(
      views::Builder<views::FlexLayoutView>()
          .SetOrientation(views::LayoutOrientation::kHorizontal)
          .SetProperty(views::kCrossAxisAlignmentKey,
                       views::LayoutAlignment::kStart)
          .AddChildren(
              views::Builder<views::LabelButton>()
                  .SetID(ViewID::kSummaryButton)
                  .CopyAddressTo(&summary_button_)
                  .SetCallback(base::BindRepeating(
                      &MahiMenuView::OnButtonPressed,
                      weak_ptr_factory_.GetWeakPtr(), summary_button_type))
                  .SetText(l10n_util::GetStringUTF16(
                      IDS_MAHI_SUMMARIZE_BUTTON_LABEL_TEXT))
                  .SetProperty(views::kMarginsKey,
                               gfx::Insets::TLBR(0, 0, 0, kButtonsRowSpacing))
                  .SetEnabled(summary_button_enabled),
              views::Builder<views::LabelButton>()
                  .SetID(ViewID::kElucidationButton)
                  .CopyAddressTo(&elucidation_button_)
                  .SetCallback(base::BindRepeating(
                      &MahiMenuView::OnButtonPressed,
                      weak_ptr_factory_.GetWeakPtr(), ButtonType::kElucidation))
                  .SetText(l10n_util::GetStringUTF16(
                      IDS_MAHI_SIMPLIFY_BUTTON_LABEL_TEXT))
                  .SetProperty(views::kMarginsKey,
                               gfx::Insets::TLBR(0, 0, 0, kButtonsRowSpacing))
                  // kUnknown mean hiding.
                  .SetVisible(button_status.elucidation_eligiblity !=
                              SelectedTextState::kUnknown)
                  .SetEnabled(button_status.elucidation_eligiblity ==
                              SelectedTextState::kEligible))
          .Build());

  std::u16string elucidation_button_tooltip =
      GetSimplifyButtonTooltipText(button_status.elucidation_eligiblity);
  if (elucidation_button_->GetVisible() &&
      !elucidation_button_tooltip.empty()) {
    elucidation_button_->SetTooltipText(elucidation_button_tooltip);
  }

  if (button_status.summary_of_selection_eligibility ==
      SelectedTextState::kTooShort) {
    summary_button_->SetTooltipText(l10n_util::GetStringUTF16(
        IDS_MAHI_SUMMARIZE_BUTTON_TOOL_TIP_FOR_SELECTION_TOO_SHORT));
  }

  StyleMenuButton(summary_button_, chromeos::kMahiSummarizeIcon);
  StyleMenuButton(elucidation_button_, chromeos::kMahiSimplifyIcon);

  textfield_controller_ =
      std::make_unique<MenuTextfieldController>(weak_ptr_factory_.GetWeakPtr());
  AddChildView(CreateInputContainer());

  GetViewAccessibility().SetRole(ax::mojom::Role::kDialog);
  GetViewAccessibility().SetName(
      l10n_util::GetStringUTF16(IDS_ASH_MAHI_MENU_TITLE));

  base::UmaHistogramEnumeration(kMahiContextMenuElucidationState,
                                button_status.elucidation_eligiblity);
}

MahiMenuView::~MahiMenuView() {
  // `textfield_` keeps a raw pointer to `textfield_controller_` - reset that
  // before destroying the controller.
  textfield_->SetController(nullptr);
}

// static
views::UniqueWidgetPtr MahiMenuView::CreateWidget(
    const ApplicationLocaleStorage* application_locale_storage,
    const gfx::Rect& anchor_view_bounds,
    const ButtonStatus& button_status,
    Surface surface) {
  views::Widget::InitParams params(
      views::Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET,
      views::Widget::InitParams::TYPE_POPUP);
  params.opacity = views::Widget::InitParams::WindowOpacity::kTranslucent;
  params.activatable = views::Widget::InitParams::Activatable::kYes;
  params.shadow_elevation = 2;
  params.shadow_type = views::Widget::InitParams::ShadowType::kDrop;
  params.name = GetWidgetName();
#if BUILDFLAG(IS_CHROMEOS)
  params.init_properties_container.SetProperty(kIsMahiMenuKey, true);
#endif

  views::UniqueWidgetPtr widget =
      std::make_unique<MahiMenuWidget>(std::move(params));
  MahiMenuView* mahi_menu_view =
      widget->SetContentsView(std::make_unique<MahiMenuView>(
          application_locale_storage, button_status, surface));
  mahi_menu_view->UpdateBounds(anchor_view_bounds);

  return widget;
}

// static
const char* MahiMenuView::GetWidgetName() {
  return kWidgetName;
}

void MahiMenuView::RequestFocus() {
  views::View::RequestFocus();

  // TODO(b/319735347): Add browsertest for this behavior.
  settings_button_->RequestFocus();
}

void MahiMenuView::UpdateBounds(const gfx::Rect& anchor_view_bounds) {
  // TODO(b/318733414): Move `editor_menu::GetEditorMenuBounds` to a common
  // place for use
  GetWidget()->SetBounds(editor_menu::GetEditorMenuBounds(
      anchor_view_bounds, this, application_locale_storage_->Get(),
      editor_menu::CardType::kMahiDefaultMenu));
}

void MahiMenuView::OnWidgetVisibilityChanged(views::Widget* widget,
                                             bool visible) {
  if (visible && !announcement_alerted_) {
    GetViewAccessibility().AnnounceAlert(kCardShownAnnouncement);
    announcement_alerted_ = true;
  } else if (!visible) {
    announcement_alerted_ = false;
  }
}

void MahiMenuView::OnButtonPressed(ButtonType button_type) {
  auto display = display::Screen::Get()->GetDisplayNearestWindow(
      GetWidget()->GetNativeWindow());
  if (surface_ == Surface::kBrowser) {
    chromeos::MahiWebContentsManager::Get()->OnContextMenuClicked(
        display.id(), button_type,
        /*question=*/std::u16string(), GetBoundsInScreen());
  } else if (surface_ == Surface::kMediaApp) {
#if BUILDFLAG(IS_CHROMEOS)
    // Only ash chrome has `surface_` = kMediaApp
    CHECK(chromeos::MahiMediaAppContentManager::Get());
    chromeos::MahiMediaAppContentManager::Get()->OnMahiContextMenuClicked(
        display.id(), button_type,
        /*question=*/std::u16string(), GetBoundsInScreen());
#endif
  }

  MahiMenuButton histogram_button_type;
  switch (button_type) {
    case ButtonType::kSummary:
      histogram_button_type = MahiMenuButton::kSummaryButton;
      break;
    case ButtonType::kSummaryOfSelection:
      histogram_button_type = MahiMenuButton::kSummaryOfSelectionButton;
      break;
    case ButtonType::kElucidation:
      histogram_button_type = MahiMenuButton::kElucidationButton;
      break;
    case ButtonType::kOutline:
      // TODO(b/330643995): Remove CHECK_IS_TEST when outlines are
      // ready.
      CHECK_IS_TEST();
      histogram_button_type = MahiMenuButton::kOutlineButton;
      break;
    case ButtonType::kSettings:
      histogram_button_type = MahiMenuButton::kSettingsButton;
      break;
    default:
      // This function only handles clicks of type 'kSummary',
      // 'kOutline' and `kSettings`. Other click types are not passed
      // here.
      NOTREACHED();
  }
  base::UmaHistogramEnumeration(kMahiContextMenuButtonClickHistogram,
                                histogram_button_type);
}

void MahiMenuView::OnQuestionSubmitted() {
  auto display = display::Screen::Get()->GetDisplayNearestWindow(
      GetWidget()->GetNativeWindow());
  if (surface_ == Surface::kBrowser) {
    chromeos::MahiWebContentsManager::Get()->OnContextMenuClicked(
        display.id(), /*button_type=*/ButtonType::kQA, textfield_->GetText(),
        GetBoundsInScreen());
  } else if (surface_ == Surface::kMediaApp) {
#if BUILDFLAG(IS_CHROMEOS)
    // Only ash chrome has `surface_` = kMediaApp
    CHECK(chromeos::MahiMediaAppContentManager::Get());
    chromeos::MahiMediaAppContentManager::Get()->OnMahiContextMenuClicked(
        display.id(), ButtonType::kQA, textfield_->GetText(),
        GetBoundsInScreen());
#endif
  }

  base::UmaHistogramEnumeration(kMahiContextMenuButtonClickHistogram,
                                MahiMenuButton::kSubmitQuestionButton);
}

std::unique_ptr<views::FlexLayoutView> MahiMenuView::CreateInputContainer() {
  auto input_container =
      views::Builder<views::FlexLayoutView>()
          .SetOrientation(views::LayoutOrientation::kHorizontal)
          .SetBackground(views::CreateRoundedRectBackground(
              ui::kColorSysStateHoverOnSubtle, kInputContainerCornerRadius))
          .SetCrossAxisAlignment(views::LayoutAlignment::kCenter)
          .SetProperty(views::kMarginsKey,
                       gfx::Insets::TLBR(kButtonTextfieldSpacing, 0, 0, 0))
          .AddChildren(
              views::Builder<views::Textfield>()
                  .SetID(ViewID::kTextfield)
                  .CopyAddressTo(&textfield_)
                  .SetController(textfield_controller_.get())
                  .SetTextInputType(ui::TEXT_INPUT_TYPE_TEXT)
                  .SetPlaceholderText(
                      l10n_util::GetStringUTF16(IDS_MAHI_MENU_INPUT_TEXTHOLDER))
                  .SetAccessibleName(
                      l10n_util::GetStringUTF16(IDS_MAHI_MENU_INPUT_TEXTHOLDER))
                  .SetProperty(
                      views::kFlexBehaviorKey,
                      views::FlexSpecification(views::FlexSpecification(
                          views::LayoutOrientation::kHorizontal,
                          views::MinimumFlexSizeRule::kPreferred,
                          views::MaximumFlexSizeRule::kUnbounded)))
                  .SetProperty(views::kMarginsKey,
                               gfx::Insets::TLBR(0, kTextfieldContainerSpacing,
                                                 0, kTextfieldContainerSpacing))
                  .SetBackgroundEnabled(false)
                  .SetBorder(nullptr),
              views::Builder<views::ImageButton>()
                  .SetID(ViewID::kSubmitQuestionButton)
                  .CopyAddressTo(&submit_question_button_)
                  .SetCallback(
                      base::BindRepeating(&MahiMenuView::OnQuestionSubmitted,
                                          weak_ptr_factory_.GetWeakPtr()))
                  .SetImageModel(views::Button::STATE_NORMAL,
                                 ui::ImageModel::FromVectorIcon(
                                     ::features::IsRoundedIconsEnabled()
                                         ? vector_icons::kSendIcon
                                         : vector_icons::kSendOldIcon))
                  .SetImageModel(views::Button::STATE_DISABLED,
                                 ui::ImageModel::FromVectorIcon(
                                     ::features::IsRoundedIconsEnabled()
                                         ? vector_icons::kSendIcon
                                         : vector_icons::kSendOldIcon,
                                     ui::kColorSysStateDisabled))
                  .SetAccessibleName(l10n_util::GetStringUTF16(
                      IDS_MAHI_MENU_INPUT_SEND_BUTTON_ACCESSIBLE_NAME))
                  .SetProperty(views::kMarginsKey, kTextfieldButtonPadding)
                  .SetEnabled(false))
          .Build();

  // Focus ring insets need to be negative because we want the focus rings to
  // exceed the textfield bounds horizontally to cover the entire `container`.
  int focus_ring_left_inset = -1 * (kTextfieldContainerSpacing);
  int focus_ring_right_inset =
      -1 * (kTextfieldContainerSpacing + kTextfieldButtonPadding.width() +
            submit_question_button_->GetPreferredSize().width());

  views::FocusRing::Install(textfield_);
  views::FocusRing::Get(textfield_)->SetColorId(ui::kColorSysStateFocusRing);
  views::InstallRoundRectHighlightPathGenerator(
      textfield_,
      gfx::Insets::TLBR(0, focus_ring_left_inset, 0, focus_ring_right_inset),
      kInputContainerCornerRadius);

  return input_container;
}

BEGIN_METADATA(MahiMenuView)
END_METADATA

}  // namespace chromeos::mahi