| // Copyright 2012 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/omnibox/omnibox_popup_view_views.h" |
| |
| #include <memory> |
| #include <numeric> |
| #include <optional> |
| |
| #include "base/auto_reset.h" |
| #include "base/functional/bind.h" |
| #include "base/memory/weak_ptr.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/ui/color/chrome_color_id.h" |
| #include "chrome/browser/ui/views/location_bar/location_bar_view.h" |
| #include "chrome/browser/ui/views/omnibox/omnibox_header_view.h" |
| #include "chrome/browser/ui/views/omnibox/omnibox_result_view.h" |
| #include "chrome/browser/ui/views/omnibox/omnibox_row_view.h" |
| #include "chrome/browser/ui/views/omnibox/omnibox_view_views.h" |
| #include "chrome/browser/ui/views/omnibox/rounded_omnibox_results_frame.h" |
| #include "chrome/browser/ui/views/theme_copying_widget.h" |
| #include "chrome/browser/ui/views/user_education/browser_feature_promo_controller.h" |
| #include "components/omnibox/browser/omnibox_controller.h" |
| #include "components/omnibox/browser/omnibox_edit_model.h" |
| #include "components/omnibox/common/omnibox_features.h" |
| #include "ui/accessibility/ax_node_data.h" |
| #include "ui/base/metadata/metadata_impl_macros.h" |
| #include "ui/compositor/closure_animation_observer.h" |
| #include "ui/compositor/layer.h" |
| #include "ui/compositor/scoped_layer_animation_settings.h" |
| #include "ui/gfx/image/image.h" |
| #include "ui/views/accessibility/view_accessibility.h" |
| #include "ui/views/cascading_property.h" |
| #include "ui/views/layout/box_layout.h" |
| #include "ui/views/widget/widget.h" |
| |
| class OmniboxPopupViewViews::AutocompletePopupWidget final |
| : public ThemeCopyingWidget { |
| public: |
| // TODO(tapted): Remove |role_model| when the omnibox is completely decoupled |
| // from NativeTheme. |
| explicit AutocompletePopupWidget(views::Widget* role_model) |
| : ThemeCopyingWidget(role_model) {} |
| |
| AutocompletePopupWidget(const AutocompletePopupWidget&) = delete; |
| AutocompletePopupWidget& operator=(const AutocompletePopupWidget&) = delete; |
| |
| ~AutocompletePopupWidget() override {} |
| |
| void InitOmniboxPopup(views::Widget* parent_widget) { |
| views::Widget::InitParams params( |
| views::Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET, |
| views::Widget::InitParams::TYPE_POPUP); |
| #if BUILDFLAG(IS_WIN) |
| // On Windows use the software compositor to ensure that we don't block |
| // the UI thread during command buffer creation. We can revert this change |
| // once http://crbug.com/125248 is fixed. |
| params.force_software_compositing = true; |
| #endif |
| params.opacity = views::Widget::InitParams::WindowOpacity::kTranslucent; |
| params.parent = parent_widget->GetNativeView(); |
| params.context = parent_widget->GetNativeWindow(); |
| |
| RoundedOmniboxResultsFrame::OnBeforeWidgetInit(¶ms, this); |
| |
| Init(std::move(params)); |
| } |
| |
| void SetPopupContentsView(OmniboxPopupViewViews* contents) { |
| SetContentsView(std::make_unique<RoundedOmniboxResultsFrame>( |
| contents, contents->location_bar_view_)); |
| } |
| |
| void SetTargetBounds(const gfx::Rect& bounds) { |
| base::AutoReset<bool> reset(&is_setting_popup_bounds_, true); |
| SetBounds(bounds); |
| } |
| |
| void ShowAnimated() { |
| // Set the initial opacity to 0 and ease into fully opaque. |
| GetLayer()->SetOpacity(0.0); |
| ShowInactive(); |
| |
| auto scoped_settings = GetScopedAnimationSettings(); |
| GetLayer()->SetOpacity(1.0); |
| } |
| |
| void CloseAnimated() { |
| // If the opening or shrinking animations still running, abort them, as the |
| // popup is closing. This is an edge case for superhumanly fast users. |
| GetLayer()->GetAnimator()->AbortAllAnimations(); |
| |
| auto scoped_settings = GetScopedAnimationSettings(); |
| GetLayer()->SetOpacity(0.0); |
| is_animating_closed_ = true; |
| |
| // Destroy the popup when done. The observer deletes itself on completion. |
| scoped_settings->AddObserver(new ui::ClosureAnimationObserver( |
| base::BindOnce(&AutocompletePopupWidget::Close, AsWeakPtr()))); |
| } |
| |
| void OnNativeWidgetDestroying() override { |
| // End all our animations immediately, as our closing animation may trigger |
| // a Close call which will be invalid once the native widget is gone. |
| GetLayer()->GetAnimator()->AbortAllAnimations(); |
| |
| ThemeCopyingWidget::OnNativeWidgetDestroying(); |
| } |
| |
| void OnMouseEvent(ui::MouseEvent* event) override { |
| // Ignore mouse events if the popup is closed or animating closed. |
| if (IsClosed() || is_animating_closed_) { |
| if (event->cancelable()) { |
| event->SetHandled(); |
| } |
| return; |
| } |
| |
| ThemeCopyingWidget::OnMouseEvent(event); |
| } |
| |
| void OnGestureEvent(ui::GestureEvent* event) override { |
| // Ignore gesture events if the popup is closed or animating closed. |
| // However, just like the base class, we do not capture the event, so |
| // multiple widgets may get tap events at the same time. |
| if (IsClosed() || is_animating_closed_) { |
| return; |
| } |
| |
| ThemeCopyingWidget::OnGestureEvent(event); |
| } |
| |
| bool is_setting_popup_bounds() const { return is_setting_popup_bounds_; } |
| |
| base::WeakPtr<AutocompletePopupWidget> AsWeakPtr() { |
| return weak_ptr_factory_.GetWeakPtr(); |
| } |
| |
| private: |
| std::unique_ptr<ui::ScopedLayerAnimationSettings> |
| GetScopedAnimationSettings() { |
| auto settings = std::make_unique<ui::ScopedLayerAnimationSettings>( |
| GetLayer()->GetAnimator()); |
| |
| settings->SetTweenType(gfx::Tween::Type::FAST_OUT_SLOW_IN); |
| |
| constexpr base::TimeDelta kPopupOpacityAnimationDuration = |
| base::Milliseconds(82); |
| settings->SetTransitionDuration(kPopupOpacityAnimationDuration); |
| |
| return settings; |
| } |
| |
| // True if the popup is in the process of closing via animation. |
| bool is_animating_closed_ = false; |
| |
| // True if the popup's bounds are currently being set. |
| bool is_setting_popup_bounds_ = false; |
| |
| base::WeakPtrFactory<AutocompletePopupWidget> weak_ptr_factory_{this}; |
| }; |
| |
| OmniboxPopupViewViews::OmniboxPopupViewViews(OmniboxViewViews* omnibox_view, |
| OmniboxController* controller, |
| LocationBarView* location_bar_view) |
| : OmniboxPopupView(controller), |
| omnibox_view_(omnibox_view), |
| location_bar_view_(location_bar_view) { |
| model()->set_popup_view(this); |
| |
| if (omnibox_view_) { |
| GetViewAccessibility().SetPopupForId( |
| omnibox_view_->GetViewAccessibility().GetUniqueId()); |
| } |
| |
| // The contents is owned by the LocationBarView. |
| set_owned_by_client(); |
| |
| SetLayoutManager(std::make_unique<views::BoxLayout>( |
| views::BoxLayout::Orientation::kVertical)); |
| |
| UpdateExpandedCollapsedAccessibleState(); |
| } |
| |
| OmniboxPopupViewViews::~OmniboxPopupViewViews() { |
| // We don't need to close or delete |popup_| here. The OS either has already |
| // closed the window, in which case it's been deleted, or it will soon. |
| if (popup_) { |
| popup_->RemoveObserver(this); |
| } |
| CHECK(!IsInObserverList()); |
| model()->set_popup_view(nullptr); |
| } |
| |
| gfx::Image OmniboxPopupViewViews::GetMatchIcon( |
| const AutocompleteMatch& match, |
| SkColor vector_icon_color) const { |
| return model()->GetMatchIcon(match, vector_icon_color); |
| } |
| |
| void OmniboxPopupViewViews::SetSelectedIndex(size_t index) { |
| DCHECK(HasMatchAt(index)); |
| |
| if (index != model()->GetPopupSelection().line) { |
| OmniboxPopupSelection::LineState line_state = OmniboxPopupSelection::NORMAL; |
| model()->SetPopupSelection(OmniboxPopupSelection(index, line_state)); |
| OnPropertyChanged(model(), views::kPropertyEffectsNone); |
| } |
| } |
| |
| size_t OmniboxPopupViewViews::GetSelectedIndex() const { |
| return GetSelection().line; |
| } |
| |
| OmniboxPopupSelection OmniboxPopupViewViews::GetSelection() const { |
| return model()->GetPopupSelection(); |
| } |
| |
| bool OmniboxPopupViewViews::IsOpen() const { |
| return popup_ != nullptr; |
| } |
| |
| void OmniboxPopupViewViews::InvalidateLine(size_t line) { |
| // TODO(tommycli): This is weird, but https://crbug.com/1063071 shows that |
| // crashes like this have happened, so we add this to avoid it for now. |
| if (line >= children().size()) { |
| return; |
| } |
| |
| static_cast<OmniboxRowView*>(children()[line])->OnSelectionStateChanged(); |
| } |
| |
| void OmniboxPopupViewViews::OnSelectionChanged( |
| OmniboxPopupSelection old_selection, |
| OmniboxPopupSelection new_selection) { |
| // Do not invalidate the same line twice, in order to avoid redundant |
| // accessibility events. |
| if (old_selection.line != OmniboxPopupSelection::kNoMatch && |
| old_selection.line != new_selection.line) { |
| InvalidateLine(old_selection.line); |
| } |
| |
| if (new_selection.line != OmniboxPopupSelection::kNoMatch) { |
| InvalidateLine(new_selection.line); |
| } |
| } |
| |
| void OmniboxPopupViewViews::UpdatePopupAppearance() { |
| const auto* autocomplete_controller = controller()->autocomplete_controller(); |
| if (autocomplete_controller->result().empty() || |
| omnibox_view_->IsImeShowingPopup()) { |
| // No matches or the IME is showing a popup window which may overlap |
| // the omnibox popup window. Close any existing popup. |
| if (popup_) { |
| // Check whether omnibox should be not closed according to the UI |
| // DevTools settings. |
| if (!popup_->ShouldHandleNativeWidgetActivationChanged(false)) { |
| return; |
| } |
| popup_->CloseAnimated(); // This will eventually delete the popup. |
| popup_.reset(); |
| UpdateExpandedCollapsedAccessibleState(); |
| // The active descendant should be cleared when the popup closes. |
| FireAXEventsForNewActiveDescendant(nullptr); |
| } |
| return; |
| } |
| |
| // Ensure that we have an existing popup widget prior to creating the result |
| // views to ensure the proper initialization of the views hierarchy. |
| bool popup_created = false; |
| if (!popup_) { |
| views::Widget* popup_parent = location_bar_view_->GetWidget(); |
| |
| // If the popup is currently closed, we need to create it. |
| popup_create_start_time_ = base::TimeTicks::Now(); |
| popup_ = (new AutocompletePopupWidget(popup_parent))->AsWeakPtr(); |
| popup_->InitOmniboxPopup(popup_parent); |
| // Third-party software such as DigitalPersona identity verification can |
| // hook the underlying window creation methods and use SendMessage to |
| // synchronously change focus/activation, resulting in the popup being |
| // destroyed by the time control returns here. Bail out in this case to |
| // avoid a nullptr dereference. |
| if (!popup_) { |
| return; |
| } |
| |
| popup_->SetVisibilityAnimationTransition(views::Widget::ANIMATE_NONE); |
| popup_->SetPopupContentsView(this); |
| popup_->AddObserver(this); |
| |
| popup_created = true; |
| } |
| |
| // Update the match cached by each row, in the process of doing so make sure |
| // we have enough row views. |
| const size_t result_size = autocomplete_controller->result().size(); |
| std::u16string previous_row_header = u""; |
| for (size_t i = 0; i < result_size; ++i) { |
| // Create child views lazily. Since especially the first result view may |
| // be expensive to create due to loading font data, this saves time and |
| // memory during browser startup. https://crbug.com/1021323 |
| if (children().size() == i) { |
| AddChildView(std::make_unique<OmniboxRowView>(i, /*popup_view=*/this)); |
| } |
| |
| OmniboxRowView* const row_view = |
| static_cast<OmniboxRowView*>(children()[i]); |
| row_view->SetVisible(true); |
| |
| const AutocompleteMatch& match = GetMatchAtIndex(i); |
| std::u16string current_row_header = |
| match.suggestion_group_id.has_value() |
| ? autocomplete_controller->result().GetHeaderForSuggestionGroup( |
| match.suggestion_group_id.value()) |
| : u""; |
| bool row_hidden = controller()->IsSuggestionHidden(match); |
| bool group_hidden = match.suggestion_group_id.has_value() && |
| controller()->IsSuggestionGroupHidden( |
| match.suggestion_group_id.value()); |
| // Show the header if it's distinct from the previous match's header. |
| if (!current_row_header.empty() && |
| current_row_header != previous_row_header) { |
| // Set toggle state of the header based on whether the group is hidden. |
| row_view->ShowHeader(current_row_header, group_hidden); |
| } else { |
| row_view->HideHeader(); |
| } |
| previous_row_header = current_row_header; |
| |
| OmniboxResultView* const result_view = row_view->result_view(); |
| result_view->SetMatch(match); |
| // Set visibility of the result view based on whether the group is hidden. |
| result_view->SetVisible(!group_hidden && !row_hidden); |
| |
| const SkBitmap* bitmap = model()->GetPopupRichSuggestionBitmap(i); |
| if (bitmap) { |
| result_view->SetRichSuggestionImage( |
| gfx::ImageSkia::CreateFrom1xBitmap(*bitmap)); |
| } |
| } |
| // If we have more views than matches, hide the surplus ones. |
| for (auto i = children().begin() + result_size; i != children().end(); ++i) { |
| (*i)->SetVisible(false); |
| } |
| |
| popup_->SetTargetBounds(GetTargetBounds()); |
| |
| if (popup_created) { |
| popup_->ShowAnimated(); |
| |
| // Popup is now expanded and first item will be selected. |
| UpdateExpandedCollapsedAccessibleState(); |
| OmniboxResultView* result_view = result_view_at(0); |
| if (result_view) { |
| FireAXEventsForNewActiveDescendant(result_view); |
| } |
| |
| NotifyOpenListeners(); |
| } |
| InvalidateLayout(); |
| } |
| |
| void OmniboxPopupViewViews::ProvideButtonFocusHint(size_t line) { |
| DCHECK(GetSelection().IsButtonFocused()); |
| |
| views::View* active_button = static_cast<OmniboxRowView*>(children()[line]) |
| ->GetActiveAuxiliaryButtonForAccessibility(); |
| // TODO(tommycli): |active_button| can sometimes be nullptr, because the |
| // suggestion button row is not completely implemented. |
| if (active_button) { |
| FireAXEventsForNewActiveDescendant(active_button); |
| } |
| } |
| |
| void OmniboxPopupViewViews::OnMatchIconUpdated(size_t match_index) { |
| if (OmniboxResultView* result_view = result_view_at(match_index)) { |
| result_view->OnMatchIconUpdated(); |
| } |
| } |
| |
| void OmniboxPopupViewViews::OnDragCanceled() { |
| SetMouseAndGestureHandler(nullptr); |
| } |
| |
| void OmniboxPopupViewViews::GetPopupAccessibleNodeData( |
| ui::AXNodeData* node_data) { |
| return GetViewAccessibility().GetAccessibleNodeData(node_data); |
| } |
| |
| void OmniboxPopupViewViews::AddPopupAccessibleNodeData( |
| ui::AXNodeData* node_data) { |
| // Establish a "CONTROLS" relationship between the omnibox and the |
| // the popup. This allows a screen reader to understand the relationship |
| // between the omnibox and the list of suggestions, and determine which |
| // suggestion is currently selected, even though focus remains here on |
| // the omnibox. |
| int32_t popup_view_id = GetViewAccessibility().GetUniqueId(); |
| node_data->AddIntListAttribute(ax::mojom::IntListAttribute::kControlsIds, |
| {popup_view_id}); |
| size_t selected_line = GetSelection().line; |
| if (selected_line != OmniboxPopupSelection::kNoMatch) { |
| if (OmniboxResultView* result_view = result_view_at(selected_line)) { |
| node_data->AddIntAttribute( |
| ax::mojom::IntAttribute::kActivedescendantId, |
| result_view->GetViewAccessibility().GetUniqueId()); |
| } |
| } |
| } |
| |
| std::u16string OmniboxPopupViewViews::GetAccessibleButtonTextForResult( |
| size_t line) { |
| if (OmniboxResultView* result_view = result_view_at(line)) { |
| return static_cast<views::LabelButton*>( |
| result_view->GetActiveAuxiliaryButtonForAccessibility()) |
| ->GetText(); |
| } else { |
| return u""; |
| } |
| } |
| |
| bool OmniboxPopupViewViews::OnMouseDragged(const ui::MouseEvent& event) { |
| size_t index = GetIndexForPoint(event.location()); |
| |
| // If the drag event is over the bounds of one of the result views, pass |
| // control to that view. |
| if (HasMatchAt(index)) { |
| SetMouseAndGestureHandler(result_view_at(index)); |
| return false; |
| } |
| |
| // If the drag event is not over any of the result views, that means that it |
| // has passed outside the bounds of the popup view. Return true to keep |
| // receiving the drag events, as the drag may return in which case we will |
| // want to respond to it again. |
| return true; |
| } |
| |
| void OmniboxPopupViewViews::OnGestureEvent(ui::GestureEvent* event) { |
| const size_t index = GetIndexForPoint(event->location()); |
| if (!HasMatchAt(index)) { |
| return; |
| } |
| |
| switch (event->type()) { |
| case ui::ET_GESTURE_TAP_DOWN: |
| case ui::ET_GESTURE_SCROLL_BEGIN: |
| case ui::ET_GESTURE_SCROLL_UPDATE: |
| SetSelectedIndex(index); |
| break; |
| case ui::ET_GESTURE_TAP: |
| case ui::ET_GESTURE_SCROLL_END: { |
| DCHECK(HasMatchAt(index)); |
| model()->OpenSelection(OmniboxPopupSelection(index), event->time_stamp()); |
| break; |
| } |
| default: |
| return; |
| } |
| event->SetHandled(); |
| } |
| |
| void OmniboxPopupViewViews::FireAXEventsForNewActiveDescendant( |
| View* descendant_view) { |
| if (descendant_view) { |
| descendant_view->NotifyAccessibilityEvent(ax::mojom::Event::kSelection, |
| true); |
| } |
| // Selected children changed is fired on the popup. |
| NotifyAccessibilityEvent(ax::mojom::Event::kSelectedChildrenChanged, true); |
| // Active descendant changed is fired on the focused text field. |
| omnibox_view_->NotifyAccessibilityEvent( |
| ax::mojom::Event::kActiveDescendantChanged, true); |
| } |
| |
| void OmniboxPopupViewViews::OnWidgetBoundsChanged(views::Widget* widget, |
| const gfx::Rect& new_bounds) { |
| // Because we don't directly control the lifetime of the widget, gracefully |
| // handle "stale" notifications by ignoring them. https://crbug.com/1108762 |
| if (!popup_ || popup_.get() != widget) { |
| return; |
| } |
| |
| // This is called on rotation or device scale change. We have to re-align to |
| // the new location bar location. |
| |
| // Ignore cases when we are internally updating the popup bounds. |
| if (popup_->is_setting_popup_bounds()) { |
| return; |
| } |
| |
| UpdatePopupAppearance(); |
| } |
| |
| void OmniboxPopupViewViews::OnWidgetVisibilityChanged(views::Widget* widget, |
| bool visible) { |
| if (!popup_ || widget != popup_.get()) { |
| return; |
| } |
| |
| if (visible && popup_create_start_time_.has_value()) { |
| // Use the popup's compositor. The next presentation time will correspond to |
| // the first visual presentation of the bubble's content after the Widget |
| // has been created. |
| popup_->GetCompositor()->RequestSuccessfulPresentationTimeForNextFrame( |
| base::BindOnce( |
| [](base::TimeTicks popup_create_start_time, |
| const viz::FrameTimingDetails& frame_timing_details) { |
| base::TimeTicks presentation_timestamp = |
| frame_timing_details.presentation_feedback.timestamp; |
| base::UmaHistogramTimes( |
| "Omnibox.Views.PopupFirstPaint", |
| presentation_timestamp - popup_create_start_time); |
| }, |
| popup_create_start_time_.value())); |
| popup_create_start_time_.reset(); |
| } |
| } |
| |
| gfx::Rect OmniboxPopupViewViews::GetTargetBounds() const { |
| int popup_height = 0; |
| const auto* autocomplete_controller = controller()->autocomplete_controller(); |
| DCHECK_GE(children().size(), autocomplete_controller->result().size()); |
| popup_height = std::accumulate( |
| children().cbegin(), |
| children().cbegin() + autocomplete_controller->result().size(), 0, |
| [](int height, const views::View* v) { |
| return height + v->GetPreferredSize().height(); |
| }); |
| |
| // Add 8dp at the bottom for aesthetic reasons. https://crbug.com/1076646 |
| // It's expected that this space is dead unclickable/unhighlightable space. |
| // This extra padding is not added if the results section has no height |
| // (result set is empty or all results are hidden). |
| if (popup_height != 0) { |
| constexpr int kExtraBottomPadding = 8; |
| popup_height += kExtraBottomPadding; |
| } |
| |
| // Add enough space on the top and bottom so it looks like there is the same |
| // amount of space between the text and the popup border as there is in the |
| // interior between each row of text. |
| popup_height += RoundedOmniboxResultsFrame::GetNonResultSectionHeight(); |
| |
| // The rounded popup is always offset the same amount from the omnibox. |
| gfx::Rect content_rect = location_bar_view_->GetBoundsInScreen(); |
| content_rect.Inset( |
| -RoundedOmniboxResultsFrame::GetLocationBarAlignmentInsets()); |
| content_rect.set_height(popup_height); |
| |
| // Finally, expand the widget to accommodate the custom-drawn shadows. |
| content_rect.Inset(-RoundedOmniboxResultsFrame::GetShadowInsets()); |
| return content_rect; |
| } |
| |
| OmniboxHeaderView* OmniboxPopupViewViews::header_view_at(size_t i) { |
| if (i >= children().size()) { |
| return nullptr; |
| } |
| |
| return static_cast<OmniboxRowView*>(children()[i])->header_view(); |
| } |
| |
| OmniboxResultView* OmniboxPopupViewViews::result_view_at(size_t i) { |
| if (i >= children().size()) { |
| return nullptr; |
| } |
| |
| return static_cast<OmniboxRowView*>(children()[i])->result_view(); |
| } |
| |
| bool OmniboxPopupViewViews::HasMatchAt(size_t index) const { |
| return index < controller()->autocomplete_controller()->result().size(); |
| } |
| |
| const AutocompleteMatch& OmniboxPopupViewViews::GetMatchAtIndex( |
| size_t index) const { |
| return controller()->autocomplete_controller()->result().match_at(index); |
| } |
| |
| size_t OmniboxPopupViewViews::GetIndexForPoint(const gfx::Point& point) { |
| if (!HitTestPoint(point)) { |
| return OmniboxPopupSelection::kNoMatch; |
| } |
| |
| size_t nb_match = controller()->autocomplete_controller()->result().size(); |
| DCHECK_LE(nb_match, children().size()); |
| for (size_t i = 0; i < nb_match; ++i) { |
| views::View* child = children()[i]; |
| gfx::Point point_in_child_coords(point); |
| View::ConvertPointToTarget(this, child, &point_in_child_coords); |
| if (child->GetVisible() && child->HitTestPoint(point_in_child_coords)) { |
| return i; |
| } |
| } |
| return OmniboxPopupSelection::kNoMatch; |
| } |
| |
| void OmniboxPopupViewViews::SetSuggestionGroupVisibility( |
| size_t match_index, |
| bool suggestion_group_hidden) { |
| if (OmniboxHeaderView* header_view = header_view_at(match_index)) { |
| header_view->SetSuggestionGroupVisibility(suggestion_group_hidden); |
| } |
| if (OmniboxResultView* result_view = result_view_at(match_index)) { |
| result_view->SetVisible(!suggestion_group_hidden); |
| } |
| |
| // This is necssary for the popup to actually resize to accommodate newly |
| // shown or hidden matches. |
| if (popup_) { |
| popup_->SetTargetBounds(GetTargetBounds()); |
| } |
| |
| InvalidateLayout(); |
| } |
| |
| void OmniboxPopupViewViews::GetAccessibleNodeData(ui::AXNodeData* node_data) { |
| node_data->role = ax::mojom::Role::kListBox; |
| if (!IsOpen()) { |
| node_data->AddState(ax::mojom::State::kInvisible); |
| } |
| } |
| |
| void OmniboxPopupViewViews::UpdateExpandedCollapsedAccessibleState() const { |
| if (IsOpen()) { |
| GetViewAccessibility().SetIsExpanded(); |
| } else { |
| GetViewAccessibility().SetIsCollapsed(); |
| } |
| } |
| |
| BEGIN_METADATA(OmniboxPopupViewViews) |
| ADD_PROPERTY_METADATA(size_t, SelectedIndex) |
| ADD_READONLY_PROPERTY_METADATA(gfx::Rect, TargetBounds) |
| END_METADATA |