<?xml version="1.0" encoding="utf-8"?>
<!--
Copyright 2014 The Chromium Authors
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file.
-->

<resources xmlns:tools="http://schemas.android.com/tools">
    <!-- TabSwitcher - The space between tabs in the toolbar swiping transition. -->
    <dimen name="toolbar_swipe_space_between_tabs">30dp</dimen>
    <!-- TabSwitcher - The minimum distance from the edge to commit a toolbar side swap. -->
    <dimen name="toolbar_swipe_commit_distance">90dp</dimen>
    <!-- Toolbar IPH dimens. -->
    <dimen name="toolbar_iph_y_inset">4dp</dimen>

    <!-- Tab title -->
    <dimen name="border_texture_title_fade">24dp</dimen>                    <!-- 40px hdpi -->
    <dimen name="tab_title_favicon_start_padding">10dp</dimen>
    <dimen name="tab_title_favicon_end_padding">7dp</dimen>

    <!-- Shared group avatar padding for tablet tab strip -->
    <dimen name="tablet_shared_group_avatar_padding">4dp</dimen>

    <!-- Overlay Panel dimensions -->
    <dimen name="overlay_panel_end_buttons_width">94dp</dimen>
    <dimen name="overlay_panel_padded_button_width">41dp</dimen>
    <dimen name="overlay_panel_text_layer_min_height">38dp</dimen>
    <dimen name="overlay_panel_button_padding">12dp</dimen>
    <dimen name="overlay_panel_caption_spacing">1.5dp</dimen>

    <!-- Contextual Search dimensions -->
    <dimen name="contextual_search_bar_image_size">36dp</dimen>
    <dimen name="contextual_search_minimum_base_page_height">600dp</dimen>
    <dimen name="contextual_search_text_layer_min_height">
        @dimen/overlay_panel_text_layer_min_height
    </dimen>
    <dimen name="contextual_search_term_caption_spacing">
        @dimen/overlay_panel_caption_spacing
    </dimen>
    <dimen name="contextual_search_callout_icon_size">36dp</dimen>
    <dimen name="contextual_search_callout_icon_margin">12dp</dimen>
    <dimen name="contextual_search_padded_button_width">
      @dimen/overlay_panel_padded_button_width
    </dimen>
    <!-- This is in sp because we want the chip width to scale with the font it holds. -->
    <dimen name="contextual_search_chip_max_width">115sp</dimen>
    <dimen name="contextual_search_chip_list_chip_spacing">4dp</dimen>
    <dimen name="contextual_search_chip_list_side_padding">16dp</dimen>
    <!-- Padding at the end of the Bar. -->
    <dimen name="contextual_search_end_padding">7dp</dimen>
    <!-- Padding amount that should be removed between the Related Searches chips carousel
         in the Bar and the content above it due to overlapping whitespace margins. This
         effectively removes the whitespace from the top of the chips carousel because there's
         already plenty of whitespace above provided by the existing Bar content.-->
    <dimen name="related_searches_in_bar_redundant_padding">@dimen/chip_bg_vertical_inset</dimen>

    <!-- Overlay panel dimensions -->
    <dimen name="overlay_panel_bar_height">70dp</dimen>

    <!-- Preview tab dimensions -->
    <dimen name="preview_tab_favicon_size">24dp</dimen>

    <!-- Sheet tab toolbar dimensions -->
    <dimen name="sheet_tab_toolbar_height">70dp</dimen>

    <!-- Autofill address prompt dimensions -->
    <dimen name="address_prompt_end_margin">16dp</dimen>
    <dimen name="address_prompt_edit_button_size">48dp</dimen>
    <dimen name="address_prompt_edit_button_padding">12dp</dimen>

    <!-- Autofill keyboard accessory dimensions -->
    <dimen name="keyboard_accessory_height_with_shadow">56dp</dimen>
    <dimen name="keyboard_accessory_sheet_height">330dp</dimen>

    <!-- Password manager illustration dialogs -->
    <dimen name="password_manager_dialog_padding">8dp</dimen>
    <dimen name="password_manager_dialog_illustration_height">156dp</dimen>
    <dimen name="password_manager_dialog_illustration_margin">8dp</dimen>
    <dimen name="password_manager_dialog_min_vertical_space_to_show_illustration">350dp</dimen>
    <dimen name="password_manager_dialog_text_horizontal_padding">16dp</dimen>
    <dimen name="password_manager_dialog_title_padding_top">16dp</dimen>
    <dimen name="password_manager_dialog_text_margin">24dp</dimen>
    <dimen name="password_manager_dialog_title_compact_margin">16dp</dimen>
    <dimen name="password_manager_dialog_details_padding_bottom">8dp</dimen>
    <dimen name="password_manager_dialog_details_padding_top">12dp</dimen>

    <!-- The size of the text for tab titles. -->
    <dimen name="compositor_tab_title_text_size">13sp</dimen>
    <!-- The size of the bounding box for favicons. -->
    <dimen name="compositor_tab_title_favicon_size">16dp</dimen>

    <!-- The activity indicator bubble dimensions on tab favicons for tablet tab strip. -->
    <dimen name="compositor_tab_title_favicon_bubble_inner_size">6dp</dimen>
    <dimen name="compositor_tab_title_favicon_bubble_outer_size">10dp</dimen>
    <dimen name="compositor_tab_title_favicon_bubble_offset">6dp</dimen>

    <!-- First Run Experience dimensions -->
    <dimen name="fre_loading_spinner_size">48dp</dimen>
    <dimen name="fre_policy_privacy_disclaimer_icon_size">18dp</dimen>
    <dimen name="fre_policy_privacy_disclaimer_icon_padding">8dp</dimen>

    <!-- Account Signin dimensions -->
    <!-- The Account Signin page appears in the First Run Experience (amongst other places), so uses
    a lot of the fre_* dimensions for consistency. -->
    <dimen name="signin_chooser_padding">16dp</dimen>
    <dimen name="signin_screen_top_padding">50dp</dimen>

    <!-- Should match toolbar_height_no_shadow -->
    <dimen name="control_container_height">@dimen/default_action_bar_height</dimen>
    <dimen name="custom_tabs_control_container_height">@dimen/default_action_bar_height</dimen>

    <!-- Find in Page dimensions -->
    <dimen name="find_in_page_popup_width">375dp</dimen>
    <dimen name="find_in_page_popup_height">64dp</dimen>
    <dimen name="find_in_page_popup_margin_end">62dp</dimen>

    <!-- NTP dimensions -->
    <!-- Spacing between sections. -->
    <dimen name="ntp_section_top_margin">12dp</dimen>
    <dimen name="ntp_section_bottom_margin">4dp</dimen>
    <!-- Specific margins and paddings, ordered by appearance. -->
    <dimen name="ntp_search_box_transition_start_offset">16dp</dimen>
    <dimen name="ntp_search_box_transition_end_offset">4dp</dimen>
    <dimen name="composeplate_view_margin_top">4dp</dimen>
    <dimen name="mvt_container_top_padding">17dp</dimen>
    <dimen name="mvt_container_bottom_padding">22dp</dimen>
    <dimen name="tile_layout_no_logo_top_margin">16dp</dimen>

    <dimen name="content_suggestions_card_bottom_margin">12dp</dimen>
    <!-- This is in sp because we want the icon to scale with the TextView it sits alongside. -->
    <dimen name="md_incognito_ntp_line_spacing">6sp</dimen>
    <dimen name="md_incognito_ntp_padding_horizontal">12dp</dimen>
    <dimen name="md_incognito_ntp_padding_vertical">16dp</dimen>
    <!-- This offset is to account for the span background stroke horizontal padding for clickable
    text flushed to the edges of the incognito NTP's TextView's. -->
    <dimen name="md_incognito_ntp_view_horizontal_offset">@dimen/span_background_horizontal_padding</dimen>

    <!-- Incognito NTP -->
    <dimen name="incognito_ntp_total_space_between_views">14sp</dimen>
    <dimen name="incognito_ntp_fading_shadow_size">16dp</dimen>

    <!-- Recent tabs page -->
    <dimen name="recent_tabs_visible_separator_padding">8dp</dimen>
    <dimen name="recent_tabs_group_view_vertical_padding">8dp</dimen>
    <dimen name="recent_tabs_list_item_side_padding">16dp</dimen>
    <dimen name="recent_tabs_show_history_item_size">60dp</dimen>
    <dimen name="recent_tabs_foreign_session_group_item_height">64dp</dimen>
    <dimen name="recent_tabs_default_group_item_height">48dp</dimen>
    <dimen name="recent_tabs_count_text_size">10dp</dimen>

    <!-- New Tab Animation -->
    <dimen name="new_tab_animation_rect_corner_radius">10dp</dimen>
    <dimen name="new_bg_tab_animation_size">32dp</dimen>
    <dimen name="new_bg_tab_animation_link_elevation">13dp</dimen>
    <dimen name="new_bg_tab_animation_tab_switcher_elevation">6dp</dimen>
    <dimen name="new_bg_tab_animation_padding">4dp</dimen>

    <!-- Bookmarks dimensions -->
    <dimen name="bookmark_minimum_dialog_size_tablet">500dp</dimen>
    <dimen name="bookmark_dialog_toolbar_shadow_height">4dp</dimen>
    <dimen name="bookmark_reading_list_section_header_padding_top">15dp</dimen>
    <dimen name="improved_bookmark_favicon_text_size">18dp</dimen>

     <!-- Improved bookmark row properties. -->
     <!-- The size of the start image for compact rows. -->
    <dimen name="improved_bookmark_start_image_size_compact">48dp</dimen>
     <!-- The size of the start image for visual rows. -->
    <dimen name="improved_bookmark_start_image_size_visual">80dp</dimen>
    <dimen name="improved_bookmark_icon_radius">24dp</dimen>
    <dimen name="add_new_folder_dialog_horizontal_margin">24dp</dimen>
    <dimen name="bookmark_folder_picker_button_container_top_padding">10dp</dimen>
    <dimen name="bookmark_folder_picker_button_container_bottom_padding">16dp</dimen>
    <dimen name="improved_bookmark_row_horizontal_margin">10dp</dimen>
    <dimen name="improved_bookmark_row_horizontal_padding">6dp</dimen>
    <dimen name="improved_bookmark_row_horizontal_negative_margin">-10dp</dimen>
    <dimen name="improved_bookmark_row_vertical_margin">1dp</dimen>
    <dimen name="shopping_chip_padding">8dp</dimen>

    <!-- Improved bookmark save flow properties-->
    <dimen name="improved_bookmark_save_flow_outer_radius">8dp</dimen>
    <dimen name="improved_bookmark_save_flow_inner_radius">4dp</dimen>
    <dimen name="improved_bookmark_save_flow_image_size">75dp</dimen>

    <!-- Bookmark widget dimensions -->
    <dimen name="bookmark_widget_min_width">64dp</dimen>
    <dimen name="bookmark_widget_min_height">48dp</dimen>
    <dimen name="bookmark_widget_section_header_min_height">32dp</dimen>
    <dimen name="bookmark_widget_section_header_padding_start">20dp</dimen>

    <!-- Bookmark bar -->
    <dimen name="bookmark_bar_button_padding_horizontal">8dp</dimen>
    <dimen name="bookmark_bar_button_padding_vertical">4dp</dimen>
    <dimen name="bookmark_bar_button_icon_margin_end">8dp</dimen>
    <dimen name="bookmark_bar_button_icon_size">16dp</dimen>
    <dimen name="bookmark_bar_divider_height">20dp</dimen>
    <dimen name="bookmark_bar_divider_width">2dp</dimen>
    <dimen name="bookmark_bar_item_min_width">84dp</dimen>
    <dimen name="bookmark_bar_item_max_width">124dp</dimen>
    <dimen name="bookmark_bar_item_spacing">4dp</dimen>
    <dimen name="bookmark_bar_padding">8dp</dimen>
    <dimen name="bookmark_bar_overflow_button_margin_start">4dp</dimen>
    <dimen name="bookmark_bar_overflow_button_height_total">32dp</dimen>
    <!-- bookmark_bar_overflow_button_height_total(32) + bookmark_bar_padding(8) -->
    <dimen name="bookmark_bar_min_height">40dp</dimen>

    <!-- Custom Tabs dimensions -->
    <dimen name="custom_tabs_drag_handle_padding_top">12dp</dimen>
    <dimen name="custom_tabs_drag_handle_padding_bottom">32dp</dimen>
    <dimen name="custom_tabs_drag_handle_padding_side">4dp</dimen>
    <dimen name="custom_tabs_toolbar_maxWidth">60dp</dimen>
    <dimen name="custom_tabs_toolbar_button_horizontal_padding">12dp</dimen>
    <dimen name="custom_tabs_adaptive_button_bg_height">36dp</dimen>
    <dimen name="custom_tabs_adaptive_button_bg_horizontal_padding">6dp</dimen>
    <dimen name="custom_tabs_adaptive_button_bg_padding_vert">10dp</dimen>
    <dimen name="custom_tabs_toolbar_vertical_padding">16dp</dimen>
    <dimen name="custom_tabs_toolbar_horizontal_padding">8dp</dimen>
    <dimen name="custom_tabs_toolbar_horizontal_margin_no_start">8dp</dimen>
    <dimen name="custom_tabs_toolbar_menu_dot_top_margin">6dp</dimen>
    <dimen name="custom_tabs_toolbar_menu_dot_end_margin">10dp</dimen>
    <dimen name="min_toolbar_icon_side_padding">6dp</dimen>
    <dimen name="custom_tabs_url_text_size">12sp</dimen>
    <dimen name="custom_tabs_title_text_size">16sp</dimen>
    <dimen name="custom_tabs_bottom_bar_max_height">120dp</dimen>
    <dimen name="custom_tabs_bottom_bar_shadow_height">4dp</dimen>
    <dimen name="custom_tabs_handle_height">16dp</dimen>
    <dimen name="custom_tabs_elevation">8dp</dimen>
    <dimen name="custom_tabs_shadow_offset">4dp</dimen>
    <dimen name="custom_tabs_outline_width">1dp</dimen>
    <dimen name="custom_tabs_default_corner_radius">16dp</dimen>
    <dimen name="custom_tabs_security_icon_width">32dp</dimen>
    <dimen name="custom_tabs_security_icon_padding_left">0dp</dimen>
    <dimen name="custom_tabs_security_icon_padding_right">8dp</dimen>
    <dimen name="custom_tabs_security_icon_width_nested">20dp</dimen>
    <dimen name="custom_tabs_security_icon_padding_left_nested">0dp</dimen>
    <dimen name="custom_tabs_security_icon_padding_right_nested">4dp</dimen>
    <dimen name="custom_tabs_location_bar_start_spacing">24dp</dimen>
    <dimen name="custom_tabs_location_bar_horizontal_padding">12dp</dimen>
    <dimen name="custom_tabs_incognito_icon_width">32dp</dimen>
    <dimen name="custom_tabs_menu_footer_icon_size">16sp</dimen>
    <dimen name="custom_tabs_menu_footer_margin_horizontal">8dp</dimen>
    <dimen name="custom_tabs_menu_footer_margin_vertical">12dp</dimen>

    <dimen name="custom_tabs_toast_branding_icon_size">28dp</dimen>
    <dimen name="custom_tabs_toast_branding_height">50dp</dimen>
    <dimen name="custom_tabs_toast_branding_padding">16dp</dimen>
    <dimen name="custom_tabs_max_width_bottom_sheet_elev">3dp</dimen>

    <!-- Tab title won't show up in the caption bar of a popup window if the
         widest unoccludded rect of the caption bar is narrower than this. -->
    <dimen name="custom_tabs_popup_title_bar_min_width">48sp</dimen>

    <!-- Minimum height of the title bar to satisfy a11y requirements. -->
    <dimen name="custom_tabs_popup_title_bar_min_height">@dimen/min_touch_target_size</dimen>

    <!-- Minimum height of the title bar to fit the tab title text. -->
    <dimen name="custom_tabs_popup_title_bar_text_height">24sp</dimen>

    <!-- Search in CCT specific dimensions for presenting interactable Omnibox -->
    <dimen name="custom_tabs_location_bar_active_height">40dp</dimen>
    <dimen name="custom_tabs_url_bar_active_height">48dp</dimen>
    <dimen name="custom_tabs_url_bar_bg_horizontal_padding">4dp</dimen>

    <!-- Account chooser dialog dimensions -->
    <dimen name="account_chooser_dialog_margin">24dp</dimen>
    <dimen name="account_chooser_dialog_item_margin">24dp</dimen>

    <!-- Public Suffix List (PSL) info button and tooltip dimensions -->
    <dimen name="psl_info_tooltip_margin">8dp</dimen>

    <!-- Clear browsing data preferences dimensions -->
    <dimen name="clear_browsing_data_button_margin">16dp</dimen>

    <dimen name="pref_languages_add_button_padding">24dp</dimen>
    <dimen name="pref_languages_item_popup_width">260dp</dimen>

    <!-- Drag-Reorderable List dimensions -->
    <dimen name="draggable_list_item_padding">16dp</dimen>

    <!-- Dialog dimensions.
         https://www.google.com/design/spec/components/dialogs.html#dialogs-simple-dialogs -->
    <dimen name="dialog_width_unit">56dp</dimen>  <!-- MD dialog widths are multiples of this. -->

    <!--  Used as a margin to force the shadow view to overlap other views. -->
    <dimen name="legacy_sync_promo_view_padding">16dp</dimen>
    <!-- 18dp padding is added to each side of the remove button to limit the image width to 20dp (56dp - 2 * 18dp). -->
    <dimen name="history_item_remove_button_lateral_padding">18dp</dimen>
    <dimen name="history_item_leading_padding">2dp</dimen>
    <dimen name="history_item_spark_size">18dp</dimen>
    <!--
        Calculated to align the spark center with the favicon bottom-right corner.
        Favicon right edge = list_item_default_margin(16dp) + list_item_start_icon_width(36dp) = 52dp.
        Spark margin start = 52dp - (history_item_spark_size(18dp) / 2) = 43dp.
    -->
    <dimen name="history_item_spark_margin_start">43dp</dimen>
    <!-- Calculated using list_item_min_height(64dp) / 2. -->
    <dimen name="history_item_spark_margin_top">32dp</dimen>
    <dimen name="history_item_spark_padding">4dp</dimen>

    <!-- Context Menu Dimensions -->
    <!-- Prevent the chip from reaching the edges of the screen for long translations. -->
    <dimen name="context_menu_chip_max_width">338dp</dimen>
    <dimen name="context_menu_chip_vertical_margin">24dp</dimen>
    <!-- The chip touch target is 48dp. This reduces the chip size by 8dp to get to the desired
         40dp height (24dp for content + 4dp of padding at the top and bottom. -->
    <dimen name="context_menu_chip_vertical_inset">4dp</dimen>
    <dimen name="context_menu_chip_icon_size">24dp</dimen>

    <dimen name="context_menu_popup_header_image_max_size">36dp</dimen>
    <dimen name="context_menu_popup_header_monogram_size">16dp</dimen>

    <!-- History Navigation UI Item -->
    <dimen name="navigation_bubble_size">44dp</dimen>
    <dimen name="navigation_bubble_arrow_size">32dp</dimen>
    <dimen name="navigation_bubble_start_padding">2dp</dimen>
    <dimen name="navigation_bubble_top_padding">4dp</dimen>
    <dimen name="navigation_bubble_bottom_padding">4dp</dimen>
    <dimen name="navigation_bubble_text_top_padding">3dp</dimen>
    <dimen name="navigation_bubble_text_bottom_padding">5dp</dimen>
    <dimen name="navigation_bubble_text_start_padding">2dp</dimen>
    <dimen name="navigation_bubble_text_end_padding">8dp</dimen>
    <dimen name="navigation_sheet_content_top_padding">18dp</dimen>
    <dimen name="navigation_sheet_content_bottom_padding">4dp</dimen>
    <dimen name="navigation_sheet_peek_height">120dp</dimen>

    <!-- RadioButtonWithDescriptionLayout dimensions -->
    <dimen name="radio_button_accessory_view_padding_start">60dp</dimen>
    <dimen name="radio_button_accessory_view_padding_end">16dp</dimen>

    <!-- Appearance Settings dimensions -->
    <dimen name="theme_preferences_checkbox_margin_end">8dp</dimen>
    <dimen name="homepage_preference_title_lateral_padding">16dp</dimen>
    <dimen name="homepage_preference_title_vertical_padding">10dp</dimen>
    <dimen name="homepage_radio_button_managed_lateral_padding">20dp</dimen>
    <dimen name="homepage_managed_icon_padding">8dp</dimen>

    <!-- Dimens of tab indicator -->
    <dimen name="tab_indicator_height">3dp</dimen>
    <dimen name="tab_indicator_radius">3dp</dimen>
    <dimen name="tab_indicator_padding">2dp</dimen>

    <!-- Status indicator dimensions -->
    <dimen name="status_indicator_min_height">21dp</dimen>
    <dimen name="status_indicator_icon_padding">8dp</dimen>
    <dimen name="status_indicator_icon_size">12dp</dimen>

    <!-- Overflow Menu Dimensions -->
    <dimen name="overflow_menu_update_min_height">40sp</dimen>
    <dimen name="overflow_menu_update_padding">12dp</dimen>

    <!-- Settings dimensions -->
    <dimen name="settings_single_column_layout_margin">16dp</dimen>
    <dimen name="settings_two_column_layout_margin">32dp</dimen>
    <dimen name="settings_wide_display_min_padding">16dp</dimen>
    <dimen name="settings_min_multi_column_screen_width">840dp</dimen>
    <dimen name="settings_narrow_header_width">360dp</dimen>
    <dimen name="settings_wide_header_width">412dp</dimen>
    <dimen name="settings_search_ui_height">48dp</dimen>
    <dimen name="settings_search_ui_top_margin">4dp</dimen>
    <dimen name="settings_search_ui_bottom_margin">12dp</dimen>
    <dimen name="settings_search_icon_padding">8dp</dimen>
    <dimen name="settings_search_icon_margin">8dp</dimen>
    <dimen name="settings_detailed_title_padding">10dp</dimen>
    <dimen name="settings_detailed_title_height">48dp</dimen>
    <dimen name="settings_multi_column_divider_size">24dp</dimen>
    <dimen name="settings_detailed_title_offset">16dp</dimen>
    <dimen name="settings_help_icon_size">24dp</dimen>

    <!-- Sharing Hub dimensions -->
    <dimen name="sharing_hub_preview_icon_padding">12dp</dimen>
    <dimen name="sharing_hub_preview_icon_rounded_corner_radius">4dp</dimen>
    <dimen name="sharing_hub_preview_icon_size">48dp</dimen>
    <dimen name="sharing_hub_preview_inner_icon_size">24dp</dimen>
    <dimen name="sharing_hub_3p_icon_size">36dp</dimen>
    <dimen name="sharing_hub_3p_icon_padding_top">20dp</dimen>

    <!-- Long Screenshots dimensions -->
    <dimen name="long_screenshots_button_size">40dp</dimen>
    <dimen name="long_screenshots_button_padding">8dp</dimen>
    <dimen name="long_screenshots_button_margin">17dp</dimen>
    <dimen name="long_screenshots_button_elev">6dp</dimen>

    <!-- IPH shared highlighting builder padding top -->
    <dimen name="iph_shared_highlighting_padding_top">120dp</dimen>

    <dimen name="sharing_hub_tile_width">69sp</dimen>
    <dimen name="sharing_hub_tile_margin">8sp</dimen>

    <!-- Virtual card enrollment dialog -->
    <dimen name="virtual_card_enrollment_dialog_padding">24dp</dimen>
    <dimen name="virtual_card_enrollment_dialog_title_margin_top">24dp</dimen>
    <dimen name="virtual_card_enrollment_dialog_card_container_padding">12dp</dimen>
    <dimen name="virtual_card_enrollment_dialog_card_container_issuer_icon_margin_end">12dp</dimen>
    <dimen name="virtual_card_enrollment_dialog_description_margin_top">16dp</dimen>
    <dimen name="virtual_card_enrollment_dialog_google_legal_message_margin_top">20dp</dimen>
    <dimen name="virtual_card_enrollment_dialog_google_issuer_message_margin_top">8dp</dimen>

    <!-- Improved bookmark row folder dimensions. -->
    <dimen name="improved_bookmark_row_outer_corner_radius">16dp</dimen>
    <dimen name="improved_bookmark_row_inner_corner_radius">4dp</dimen>
    <dimen name="improved_bookmark_row_size">80dp</dimen>
    <dimen name="improved_bookmark_row_secondary_outer_size">41dp</dimen>
    <dimen name="improved_bookmark_row_secondary_inner_size">39dp</dimen>
    <dimen name="improved_bookmark_row_secondary_inner_half_size">19.5dp</dimen>

    <!-- Autofill "save card" bottom sheet dimensions. -->
    <dimen name="autofill_bottom_sheet_credit_card_height">24dp</dimen>
    <dimen name="autofill_bottom_sheet_credit_card_spacing">16dp</dimen>
    <dimen name="autofill_bottom_sheet_credit_card_width">40dp</dimen>
    <dimen name="autofill_bottom_sheet_loading_view_bottom_margin">64dp</dimen>
    <dimen name="autofill_bottom_sheet_logo_height">32dp</dimen>
    <dimen name="autofill_bottom_sheet_google_pay_pill_width">60dp</dimen>

    <!-- Autofill "save card" anchored dialog dimensions. -->
    <dimen name="anchored_dialog_elevation">3dp</dimen>
    <dimen name="anchored_dialog_margin">18dp</dimen>
    <dimen name="anchored_dialog_width">412dp</dimen>

    <!-- Autofill "virtual card number enrollment" bottom sheet dimensions. -->
    <dimen name="autofill_bottom_sheet_drag_handlebar_height">4dp</dimen>
    <dimen name="autofill_bottom_sheet_drag_handlebar_width">32dp</dimen>
    <dimen name="autofill_bottom_sheet_illustration_min_height">93dp</dimen>
    <dimen name="autofill_bottom_sheet_logo_min_height">32dp</dimen>
    <dimen name="autofill_bottom_sheet_spacing_large">22dp</dimen>
    <dimen name="autofill_bottom_sheet_spacing_small">12dp</dimen>

    <!-- Autofill "save IBAN" bottom sheet dimensions. -->
    <dimen name="autofill_bottom_sheet_iban_text_input_top_margin">20dp</dimen>

    <!-- Common autofill bottom sheet dimensions. -->
    <dimen name="autofill_bottom_sheet_chip_top_margin">22dp</dimen>
    <dimen name="autofill_bottom_sheet_confirm_button_top_margin">22dp</dimen>
    <dimen name="autofill_bottom_sheet_drag_handlebar_spacing_top">8dp</dimen>
    <dimen name="autofill_bottom_sheet_padding_horizontal">24dp</dimen>
    <dimen name="autofill_bottom_sheet_spacing_extra_small">8dp</dimen>
    <dimen name="autofill_bottom_sheet_spacing_medium">16dp</dimen>
    <dimen name="autofill_bottom_sheet_title_top_margin">24dp</dimen>

    <!-- Autofill dialog dimensions. -->
    <dimen name="autofill_dialog_progress_bar_size">36dp</dimen>

    <!-- tab strip context menu-->
    <dimen name="tab_strip_group_context_menu_max_width">392dp</dimen>
    <dimen name="tab_strip_context_menu_min_width">200dp</dimen>
    <dimen name="tab_strip_context_menu_max_width">300dp</dimen>

    <!-- Link Hover Status Bar dimensions. -->
    <dimen name="link_hover_status_bar_max_width">300dp</dimen>
    <dimen name="link_hover_status_bar_margin">16dp</dimen>
    <dimen name="link_hover_status_bar_mouse_padding">20dp</dimen>

    <!--  Reader mode prefs dimensions. -->
    <dimen name="reader_mode_prefs_font_style_button_separator_padding">16dp</dimen>
    <dimen name="reader_mode_prefs_font_style_button_size">72dp</dimen>
    <dimen name="reader_mode_prefs_font_style_signifier_text_size">24dp</dimen>
    <dimen name="reader_mode_prefs_font_style_name_text_size">10dp</dimen>
    <dimen name="reader_mode_theme_button_unselected_stroke_width">1dp</dimen>
    <dimen name="reader_mode_theme_button_selected_stroke_width">2dp</dimen>

    <!-- Tab Strip Reorder dimensions -->
    <dimen name="tab_strip_dragged_tab_shadow_thickness">8dp</dimen>

    <!-- Tips Notifications dimensions -->
    <dimen name="tips_notifications_bottom_sheet_button_padding">4dp</dimen>
    <dimen name="tips_notifications_bottom_sheet_horizontal_margin">24dp</dimen>
    <dimen name="tips_notifications_bottom_sheet_step_content_margin_start">16dp</dimen>
    <dimen name="tips_notifications_bottom_sheet_step_number_width">25dp</dimen>
    <dimen name="tips_notifications_bottom_sheet_title_padding">24dp</dimen>
    <dimen name="tips_notifications_bottom_sheet_vertical_margin">20dp</dimen>

    <!-- View list background dimensions -->
    <dimen name="view_list_item_large_radius">24dp</dimen>
    <dimen name="view_list_item_small_radius">3dp</dimen>

    <!-- Caret browsing dimensions -->
    <dimen name="caret_top_padding">18dp</dimen>
    <dimen name="caret_external_margin">16dp</dimen>

    <!-- Auto PiP permission dialog dimensions -->
    <dimen name="auto_pip_permission_dialog_width">320dp</dimen>
    <dimen name="auto_pip_permission_dialog_padding">24dp</dimen>
    <!-- Minimum window dimensions required to comfortably fit the permission dialog.
         If auto_pip_permission_dialog_width changes, update this to match. -->
    <dimen name="document_picture_in_picture_min_width_with_prompt">340dp</dimen>
    <dimen name="document_picture_in_picture_min_height_with_prompt">280dp</dimen>

    <!-- Document PiP dimensions -->
    <dimen name="document_picture_in_picture_header_component_size">48dp</dimen>
    <dimen name="document_picture_in_picture_url_bar_margin">6dp</dimen>
    <dimen name="document_picture_in_picture_header_min_height">48dp</dimen>
    <!-- The minimum width of the unoccluded rect of the header to fit the
         header content. Calculated as: 48dp (page info button) + 6dp (margin)
         + 48dp (url bar) + 6dp (margin) + 48dp (back to tab button) = 156dp -->
    <dimen name="document_picture_in_picture_header_min_unoccluded_width">156dp</dimen>

    <!-- Chrome Finds dimensions -->
    <dimen name="finds_opt_in_bottom_sheet_horizontal_margin">24dp</dimen>

    <!-- Gesture User Education Iph-->
    <dimen name="gesture_user_education_arrow_margin_bottom">36dp</dimen>
    <dimen name="iph_bubble_margin_top">255dp</dimen>
    <dimen name="iph_bubble_margin_start">5dp</dimen>
    <dimen name="iph_bubble_text_padding">16dp</dimen>
    <dimen name="iph_bubble_triangle_width">8dp</dimen>
    <dimen name="iph_bubble_triangle_height">20dp</dimen>
    <dimen name="tap_to_dismiss_text_margin_bottom">36dp</dimen>

    <!-- Accessibility Annotator dimensions -->
    <dimen name="accessibility_annotator_sheet_padding_horizontal">24dp</dimen>
    <dimen name="accessibility_annotator_spacing_large">16dp</dimen>
    <dimen name="accessibility_annotator_spacing_medium">12dp</dimen>
</resources>
