<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <!-- The name of the application. -->
    <string name="application_name">Browser</string>
    <!-- Displayed with a file picker to choose a file to upload -->
    <string name="choose_upload">Choose file for upload</string>
    <!-- Toast to show the user after they try to open the file picker but no apps on the
         system can provide a file [CHAR-LIMIT=NONE]-->
    <string name="uploads_disabled">File uploads are disabled.</string>
    <!-- Name of menu item of a new tab.  Also used in the title bar when displaying a new tab -->
    <string name="new_tab">New tab</string>
    <!-- Name of menu item of a new incognito tab.  Also used in the
         title bar when displaying a new tab [CHAR LIMIT=30] -->
    <string name="new_incognito_tab">New incognito tab</string>
    <!-- Name of tab containing bookmarks -->
    <string name="tab_bookmarks">Bookmarks</string>
    <!-- Name of tab containing the user's most visited websites, organized by number of visits -->
    <string name="tab_most_visited">Most visited</string>
    <!-- Name of tab containing the user's complete history, organized by time of last visit -->
    <string name="tab_history">History</string>
    <!-- Name of tab containing the user's saved pages, organized by time created [CHAR LIMIT=20] -->
    <string name="tab_snapshots">Saved pages</string>
    <!-- Toast shown when a history item's star is clicked, converting it to a bookmark -->
    <string name="added_to_bookmarks">Added to bookmarks.</string>
    <!-- Toast shown when a history item's star is clicked off, removing its bookmark -->
    <string name="removed_from_bookmarks">Removed from bookmarks.</string>
    <!-- Sign-in dialog -->
    <!-- This is used as the title of a dialog which is used to sign in to a secure site.
            "%s1"is replaced with the host and "%s2" with realm -->
    <string name="sign_in_to">Sign in to <xliff:g id="hostname">%s1</xliff:g> \"<xliff:g id="realm">%s2</xliff:g>\"</string>
    <!-- Prompt for an input box that allows the user to enter their login name -->
    <string name="username">Name</string>
    <!-- Prompt for an input box that allows the user to enter their password -->
    <string name="password">Password</string>
    <!-- The label on the "sign in" button -->
    <string name="action">Sign in</string>
    <!-- The name of the add bookmark page activity.-->
    <string name="bookmarks_add_page">Save bookmark</string>
    <!-- The name of the bookmarks and history search suggestion source.  -->
    <string name="bookmarks_search">Browser</string>
    <!-- Label for a cancel button.  It is used for multiple cancel buttons in different contexts -->
    <string name="cancel">Cancel</string>
    <!-- Label for a confirm button.  Used in multiple contexts. -->
    <string name="ok">OK</string>

    <!-- Displayed on the title bar while the page is loading -->
    <string name="title_bar_loading">Loading\u2026</string>

    <!-- Menu item -->
    <string name="page_info">Page info</string>
    <!-- Label for a button on an SSL error dialog that allows the user to see
        Page info screen for the current page -->
    <string name="page_info_view">View page info</string>
    <!-- Page Info dialog strings -->
    <!-- Noun.  The url for the current page. Displayed on the Page Info
            screen. -->
    <string name="page_info_address">Address:</string>

    <!-- SSL Error dialogs -->
    <string name="ssl_warnings_header">There are problems with the security certificate for this site.</string>
    <!-- Label for a button on an SSL error dialog that lets the user continue
            and view the page despite the error -->
    <string name="ssl_continue">Continue</string>
    <!-- Title for an SSL error dialog  -->
    <string name="security_warning">Security warning</string>
    <!-- Label for a button on an SSL error dialog that lets the user view the
        certificate -->
    <string name="view_certificate">View certificate</string>
    <!-- Label for a button on an SSL error dialog that lets the user go back to
         the last page they were on instead of continuing to the new page. [CHAR-LIMIT=20] -->
    <string name="ssl_go_back">Go back</string>

    <!-- Message in an SSL Error dialog -->
    <string name="ssl_untrusted">This certificate isn\'t from a trusted authority.</string>
    <!-- Message in an SSL Error dialog -->
    <string name="ssl_mismatch">The name of the site doesn\'t match the name on the certificate.</string>
    <!-- Message in an SSL Error dialog -->
    <string name="ssl_expired">This certificate has expired.</string>
    <!-- Message in an SSL Error dialog -->
    <string name="ssl_not_yet_valid">This certificate isn\'t valid yet.</string>
    <!-- Message in an SSL Error dialog -->
    <string name="ssl_date_invalid">This certificate has an invalid date.</string>
    <!-- Message in an SSL Error dialog -->
    <string name="ssl_invalid">This certificate is invalid.</string>
    <!-- Message in an SSL Error dialog -->
    <string name="ssl_unknown">Unknown certificate error.</string>

    <!-- Toast informing the user that loading has stopped for the current page. -->
    <string name="stopping">Stopping\u2026</string>
    <!-- Menu item to stop the current page from loading. -->
    <string name="stop">Stop</string>
    <!-- Menu item to reload or refresh the current page. -->
    <string name="reload">Refresh</string>
    <!-- Menu item to go back to the previous page -->
    <string name="back">Back</string>
    <!-- Menu item to go to the next page (only useful if the user has previously hit back.) -->
    <string name="forward">Forward</string>
    <!-- Button label to confirm saving a bookmark. -->
    <string name="save">OK</string>
    <!-- Button label to cancel saving a bookmark. -->
    <string name="do_not_save">Cancel</string>
    <!-- Field label in Bookmark dialog box: refers to URL of the page to bookmark -->
    <string name="location">Address</string>
    <!-- Field label in Bookmark dialog box: refers to the account to save the bookmark to -->
    <string name="account">Account</string>
    <!-- Field label in Bookmark dialog box: refers to the folder in which to save the bookmark -->
    <string name="containing_folder">Add to</string>
    <!-- Default name for a new folder and label for a button that allows the user to create a new folder
         in the add bookmark dialog -->
    <string name="new_folder">New folder</string>
    <!-- Context menu item to edit a folder [CHAR LIMIT=50] -->
    <string name="edit_folder">Edit folder</string>
    <!-- Context menu item to delete a folder [CHAR LIMIT=50] -->
    <string name="delete_folder">Delete folder</string>
    <!-- Label stating that the currently open folder has no subfolders
         in the add bookmark dialog [CHAR-LIMIT=none]-->
    <string name="no_subfolders">No subfolders.</string>
    <!-- Menu item to use the top level bookmarks folder to save a bookmark in. [CHAR-LIMIT=30]-->
    <string name="add_to_bookmarks_menu_option">Bookmarks</string>
    <!-- Menu item to save the newly created bookmark to the home screen. [CHAR-LIMIT=30]-->
    <string name="add_to_homescreen_menu_option">Home screen</string>
    <!-- Menu item to open a picker to determine which folder to save a bookmark in. [CHAR-LIMIT=30]-->
    <string name="add_to_other_folder_menu_option">Other folder</string>
    <!-- Field label in Bookmark dialog box: title that the user wishes to use for the bookmark -->
    <string name="name">Label</string>
    <!-- Initial value in Location field in Bookmark dialog box -->
    <string name="http">http://</string>
    <!-- Menu item that opens a dialog to save a bookmark for the current page [CHAR LIMIT=30] -->
    <string name="save_to_bookmarks">Save to bookmarks</string>
    <!-- Title of the dialog to bookmark a page -->
    <string name="bookmark_this_page">Bookmark this page</string>
    <!-- Option on bookmark dialog to remove the bookmark [CHAR LIMIT=30] -->
    <string name="remove">Remove</string>
    <!-- Menu item on the bookmarks page, to edit an existing bookmark -->
    <string name="edit_bookmark">Edit bookmark</string>
    <!-- Context menu item to create a shortcut to the bookmark on the desktop [CHAR LIMIT=50] -->
    <string name="create_shortcut_bookmark">Add shortcut to home</string>
    <!-- Context menu item to open the currently highlighted bookmark -->
    <string name="open_bookmark">Open</string>
    <!-- Menu item to remove the currently highlighted bookmark-->
    <string name="remove_bookmark">Delete bookmark</string>
    <!-- Context menu item to remove a history item from bookmarks -->
    <string name="remove_from_bookmarks">Remove from bookmarks</string>
    <!-- Menu item to remove the currently highlighted history entry from the list of previously visited sites -->
    <string name="remove_history_item">Remove from history</string>
    <!-- Context menu item for setting the bookmark/history item as the homepage -->
    <string name="set_as_homepage">Set as homepage</string>
    <!-- Toast informing the user that their action to save a bookmark has succeeded -->
    <string name="bookmark_saved">Saved to bookmarks.</string>
    <!-- Toast informing the user that their action to save a bookmark did not succeed -->
    <string name="bookmark_not_saved">Couldn\'t save bookmark.</string>
    <!-- Toast confirming that the homepage has been set -->
    <string name="homepage_set">Homepage set.</string>
    <!-- Error that appears in the title of Bookmark dialog when user selects OK with empty Name field -->
    <string name="bookmark_needs_title">"Bookmark must have a name."</string>
        <!-- Error that appears in the title of Bookmark dialog when user selects OK with empty Location field -->
    <string name="bookmark_needs_url">"Bookmark must have a location."</string>
        <!-- Error that appears in the title of Bookmark dialog when user selects OK with invalid URL -->
    <string name="bookmark_url_not_valid">This URL isn\'t valid.</string>
        <!-- Error that appears in the Bookmark dialog when user selects OK with a URL of a type we cannot bookmark -->
    <string name="bookmark_cannot_save_url">This URL can\'t be bookmarked.</string>
    <!-- Menu item in the page that displays all bookmarks. It brings up a
            dialog that allows the user to bookmark the page that the browser is
            currently on, but is not visible because the bookmarks page is
            showing. -->
    <string name="bookmark_page">Bookmark last-viewed page</string>
    <!-- Menu item in the page that displays all bookmarks.  Switches to
            a grid view which shows thumbnails [CHAR LIMIT=20] -->
    <string name="bookmark_thumbnail_view">Thumbnails</string>
    <!-- Menu item in the page that displays all bookmarks.  Switches to a
            list view which shows titles [CHAR LIMIT=20] -->
    <string name="bookmark_list_view">List</string>
    <!-- Summary text under the New Bookmark item on the Bookmarks screen.
            Tells the user that if they select this item, it will bring up a
            dialog to bookmark the page that the browser is currently viewing,
            though it is not currently being displayed, since they are viewing
            the bookmarks screen. -->
    <string name="current_page">from\u0020</string>
    <!-- Confirmation dialog message confirming that the user wishes to delete
            the bookmark they selected for deletion -->
    <string name="delete_bookmark_warning">Delete bookmark \"<xliff:g id="bookmark">%s</xliff:g>\"?</string>
    <!-- Context menu item to open every bookmark in a folder in new tabs [CHAR LIMIT=50] -->
    <string name="open_all_in_new_window">Open all in new tabs</string>
    <!-- Menu item to open a dialog which allows the user to enter a url or do search-->
    <string name="goto_dot">Go</string>
    <!-- Menu item to switch to text selection mode for copy and paste. -->
    <string name="select_dot">Select text</string>
    <!-- Menu item to close all other tabs [CHAR LIMIT=40] -->
    <string name="close_other_tabs">Close other tabs</string>
    <!-- Menu item to open the bookmarks page. This is a shorter version that
            is displayed with an icon -->
    <string name="bookmarks">Bookmarks</string>
    <!-- Secondary name for the Activity "BrowserBookmarksPage" -->
    <string name="shortcut_bookmark">Bookmark</string>
    <!-- Title for the activity asking the user to select a bookmark [CHAR LIMIT=50] -->
    <string name="shortcut_bookmark_title">Choose a bookmark</string>
    <!-- Menu item to display the History of previously visited pages -->
    <string name="history">History</string>
    <!-- Menu item for viewing downloads from the browser -->
    <string name="menu_view_download">Downloads</string>
    <!-- Context menu item for copying the url of the current page from the
            title bar -->
    <string name="copy_page_url">Copy page URL</string>
    <!-- Menu item -->
    <string name="share_page">Share page</string>
    <!-- Menu item for saving a page for offline reading. This is a view-only snapshot of the page. [CHAR LIMIT=50] -->
    <string name="menu_save_snapshot">Save for offline reading</string>
    <!-- Dialog message that is shown while saving a page for offline reading. [CHAR LIMIT=50] -->
    <string name="saving_snapshot">Saving\u2026</string>
    <!-- Toast informing the user that saving the page for offline reading has failed. [CHAR LIMIT=50] -->
    <string name="snapshot_failed">Couldn\'t save for offline reading.</string>
    <!-- The number of bookmarks in a folder [CHAR LIMT=50] -->
    <string name="contextheader_folder_bookmarkcount"><xliff:g id="bookmark_count">%d</xliff:g> bookmarks</string>
    <!-- No bookmarks in the folder [CHAR LIMIT=50] -->
    <string name="contextheader_folder_empty">Empty folder</string>
    <!-- Context Menu item open the currently selected link in the current
            window.-->
    <string name="contextmenu_openlink">Open</string>
    <!-- Context Menu item to open the currently selected link in a new
            window. -->
    <string name="contextmenu_openlink_newwindow">Open in new tab</string>
    <!-- Context Menu item to open the currently selected link in a new
         background window. [CHAR LIMIT=50] -->
    <string name="contextmenu_openlink_newwindow_background">Open in new background tab</string>
    <!-- Context Menu item to save the webpage referred to by this link to the
            SD card (external storage) -->
    <string name="contextmenu_savelink">Save link</string>
    <!-- Context Menu item to send the url of the selected link to someone else,
            via Gmail or another app [CHAR LIMIT=50] -->
    <string name="contextmenu_sharelink">Share link</string>
    <!-- Context Menu item -->
    <string name="contextmenu_copy">Copy</string>
    <!-- Context Menu item to copy the url of the selected link to the
            clipboard -->
    <string name="contextmenu_copylink">Copy link URL</string>
    <!-- Context Menu item to save the image to external storage -->
    <string name="contextmenu_download_image">Save image</string>
    <!-- Context Menu item to view the image by itself in the browser -->
    <string name="contextmenu_view_image">View image</string>
    <!-- Context Menu item to set the image as the home screen wallpaper -->
    <string name="contextmenu_set_wallpaper">Set as wallpaper</string>

    <!-- Context Menu item to open the dialer app with the selected phone number
            -->
    <string name="contextmenu_dial_dot">Dial\u2026</string>
    <!-- Context Menu item to add the selected phone number to the address book.
            -->
    <string name="contextmenu_add_contact">Add contact</string>
    <!-- Context Menu item to send an email using the selected email address.-->
    <string name="contextmenu_send_mail">Send email</string>
    <!-- Context Menu item to show the currently selected address in the Maps
            application -->
    <string name="contextmenu_map">Map</string>

     <!-- Title of the dialog used for selecting the application that should be
            used for sharing a link (e.g. Gmail or another app). See also
            contextmenu_sharelink above -->
    <string name="choosertitle_sharevia">Share via</string>

    <!-- Used as the title of dialogs in the Browser Settings confirming that
            the user wants to clear (cache, history, or cookie data) -->
    <string name="clear">Clear</string>

    <!-- Part of a sentence that says "Replace <url of existing bookmark> with
            <url of new bookmark>?" -->
    <string name="replace">Replace</string>

    <!-- Title displayed when the bookmarks page is shown -->
    <string name="browser_bookmarks_page_bookmarks_text">Bookmarks</string>


    <!-- Settings screen strings -->
    <!-- Menu item to open the Settings screen -->
    <string name="menu_preferences">Settings</string>
    <!-- Settings screen, section title -->
    <string name="pref_content_title">Page content</string>
    <!-- Settings label [CHAR LIMIT=45]-->
    <string name="pref_allow_apptabs">Allow multiple tabs per app</string>
    <!-- Settings label -->
    <string name="pref_content_load_images">Load images</string>
    <!-- Settings label -->
    <string name="pref_content_load_images_summary">Display images on web pages</string>
    <!-- Settings label [CHAR LIMIT=30] -->
    <string name="pref_content_block_popups">Block pop-ups</string>
    <!-- Settings label -->
    <string name="pref_content_javascript">Enable JavaScript</string>
    <!-- Settings label -->
    <string name="pref_content_open_in_background">Open in background</string>
    <!-- Settings label -->
    <string name="pref_content_plugins">Enable plug-ins</string>
    <!-- Plugin options -->
    <string-array name="pref_content_plugins_choices">
        <item>Always on</item>
        <item>On demand</item>
        <item>Off</item>
    </string-array>
    <string-array name="pref_content_plugins_values" translatable="false">
        <item>ON</item>
        <item>ON_DEMAND</item>
        <item>OFF</item>
    </string-array>
    <!-- Settings summary [CHAR LIMIT=50]-->
    <string name="pref_content_open_in_background_summary">Open new tabs behind the current tab</string>
    <!-- Settings label [CHAR LIMIT=50] -->
    <string name="pref_content_homepage">Set homepage</string>
    <!-- Settings label -->
    <string name="pref_content_search_engine">Set search engine</string>
    <!-- Settings summary -->
    <string name="pref_content_search_engine_summary">Choose a search engine</string>
    <!-- Settings button label that to pick what to set the homepage to [CHAR LIMIT=40] -->
    <string name="pref_set_homepage_to">Set to</string>
    <string-array name="pref_homepage_choices">
        <!-- Setting choice to set the homepage to the current page [CHAR LIMIT=40] -->
        <item>Current page</item>
        <!-- Setting choice to set the homepage to a blank page [CHAR LIMIT=40] -->
        <item>Blank page</item>
        <!-- Setting choice to set the homepage to the default page [CHAR LIMIT=40] -->
        <item>Default page</item>
        <!-- Setting choice to set the homepage to the "Most Visited" homepage feature, which is a list of most visited sites [CHAR LIMIT=40] -->
        <item>Most visited sites</item>
        <!-- Setting choice to set the homepage to a user entered URL [CHAR LIMIT=40] -->
        <item>Other</item>
    </string-array>
    <string-array name="pref_homepage_values" translatable="false">
        <item>current</item>
        <item>blank</item>
        <item>default</item>
        <item>most_visited</item>
        <item>other</item>
    </string-array>
    <!-- Settings label -->
    <string name="pref_content_autofit">Auto-fit pages</string>
    <!-- Settings summary -->
    <string name="pref_content_autofit_summary">Format webpages to fit the screen</string>

    <!-- Settings screen & section title for "General settings". These include things like
         configuring bookmark syncing to Google servers and form auto fill settings. [CHAR-LIMIT=32] -->
    <string name="pref_general_title">General</string>
    <!-- Settings category for sync under general settings. This includes bookmark sync with Chrome [CHAR-LIMIT=50] -->
    <string name="pref_general_sync_title">Sync</string>
    <!-- Settings category for autofill under general. [CHAR-LIMIT=50] -->
    <string name="pref_general_autofill_title">Auto-fill</string>

    <!-- Checkbox setting for enabling/disabling the form AutoFill feature [CHAR-LIMIT=32] -->
    <string name="pref_autofill_enabled">Form auto-fill</string>
    <!-- Settings summary for the form AutoFill feature. [CHAR-LIMIT=none] -->
    <string name="pref_autofill_enabled_summary">Fill out web forms with a single touch</string>
    <!-- Label for option that when clicked opens the AutoFill settings screen. Also used as the title of that AutoFill Settings screen. [CHAR-LIMIT=32] -->
    <string name="pref_autofill_profile_editor">Auto-fill text</string>
    <!-- Summary for the AutoFill Settings preference [CHAR-LIMIT=none] -->
    <string name="pref_autofill_profile_editor_summary">Set up text to auto-fill in web forms</string>

    <!-- Auto login preference title [CHAR-LIMIT=32] -->
    <string name="pref_autologin_title">Automatic Google signin</string>
    <!-- Message shown during auto login [CHAR-LIMIT=none] -->
    <string name="pref_autologin_progress">Signing into Google sites using <xliff:g>%s</xliff:g></string>
    <!-- Auto-login bar description [CHAR-LIMIT=40] -->
    <string name="autologin_bar_text">Sign in as</string>
    <!-- Login button [CHAR-LIMIT=10] -->
    <string name="autologin_bar_login_text">Sign in</string>
    <!-- Hide button [CHAR-LIMIT=10] -->
    <string name="autologin_bar_hide_text">Hide</string>
    <!-- Login failure text [CHAR-LIMIT=25] -->
    <string name="autologin_bar_error">Couldn\'t sign in.</string>

    <!-- Heading for the AutoFill profile editor to tell the user what AutoFill does and why they should fill out the profile. [CHAR-LIMIT=None] -->
    <string name="autofill_profile_editor_heading">Type the text you want to auto-fill in web forms.</string>
    <!-- String for the user's full name in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_name">Full name:</string>
    <!-- String for the user's e-mail address in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_email_address">Email:</string>
    <!-- String for the user's company name in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_company_name">Company name:</string>
    <!-- String for the first line of the user's address in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_address_line_1">Address line 1:</string>
    <!-- String to suggest to the user the kind of data to be used for the first line of the address. CHAR-LIMIT=64] -->
    <string name="autofill_profile_editor_address_line_1_hint">Street address, P.O. box, c/o</string>
    <!-- String for the second line of the user's address in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_address_line_2">Address line 2:</string>
    <!-- String to suggest to the user the kind of data to be used for the second line of the address. CHAR-LIMIT=64] -->
    <string name="autofill_profile_editor_address_line_2_hint">Apartment, suite, unit, building, floor, etc.</string>
    <!-- String for the user's city or town in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_city">City/Town:</string>
    <!-- String for the user's state or province or region in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_state">State/Province/Region:</string>
    <!-- String for the user's zip code in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_zip_code">Zip code:</string>
    <!-- String for the user's country in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_country">Country:</string>
    <!-- String for the user's phone number in the AutoFill profile editor. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_phone_number">Phone:</string>
    <!-- String to display in an error tooltip to inform the user the phone number they provided is not valid. [CHAR-LIMIT=32] -->
    <string name="autofill_profile_editor_phone_number_invalid">Invalid phone number.</string>

    <!-- Button text to save the AutoFill profile [CHAR-LIMIT=20] -->
    <string name="autofill_profile_editor_save_profile">Save</string>
    <!-- Toast message displayed when the profile has been successfully saved [CHAR-LIMIT=none] -->
    <string name="autofill_profile_successful_save">Auto-fill text saved.</string>
    <!-- Toast message displayed when the profile has been successfully deleted [CHAR-LIMIT=none] -->
    <string name="autofill_profile_successful_delete">Auto-fill text deleted.</string>
    <!-- Button text to delete all the AutoFill profile data [CHAR-LIMIT=20] -->
    <string name="autofill_profile_editor_delete_profile">Delete</string>

    <!-- Text on a dialog shown to the user when they are prompted to set up the autofill feature [CHAR-LIMIT=NONE] -->
    <string name="autofill_setup_dialog_message">The browser can automatically complete web forms like this one. Do you want to set up your auto-fill text?</string>
    <!-- Toast message displayed when the user decides to not set up autofill at this time. We want to remind them that they can configure
         it through the Browser Settings menu. [CHAR-LIMIT=NONE] -->
    <string name="autofill_setup_dialog_negative_toast">You can always set up your auto-fill text from the Browser &gt; Settings &gt; General screen.</string>
    <!-- Text on a checkbox in the "setup autofill" dialog which is shown to the user when they are prompted to set up the autofill feature.
         The checkbox allows them to specify they would like to disable the feature altogether [CHAR-LIMIT=NONE] -->
    <string name="disable_autofill">Disable auto-fill</string>

    <!-- Settings screen, section title [CHAR-LIMIT=50] -->
    <string name="pref_privacy_security_title">Privacy &amp; security</string>
    <!-- Settings label -->
    <string name="pref_privacy_clear_cache">Clear cache</string>
    <!-- Settings summary -->
    <string name="pref_privacy_clear_cache_summary">Clear locally cached content and databases</string>
    <!-- Confirmation dialog message -->
    <string name="pref_privacy_clear_cache_dlg">Delete locally cached content and databases?</string>
    <!-- Cookie settings category [CHAR-LIMIT=50] -->
    <string name="pref_privacy_cookies_title">Cookies</string>
    <!-- Settings label -->
    <string name="pref_privacy_clear_cookies">Clear all cookie data</string>
    <!-- Settings summary -->
    <string name="pref_privacy_clear_cookies_summary">Clear all browser cookies</string>
    <!-- Confirmation dialog message -->
    <string name="pref_privacy_clear_cookies_dlg">Delete all cookies?</string>
    <!-- Settings label -->
    <string name="pref_privacy_clear_history">Clear history</string>
    <!-- Settings summary -->
    <string name="pref_privacy_clear_history_summary">Clear the browser navigation history</string>
    <!-- Confirmation dialog message -->
    <string name="pref_privacy_clear_history_dlg">Delete the browser navigation history?</string>
    <!-- Formdata settings category [CHAR-LIMIT=50] -->
    <string name="pref_privacy_formdata_title">Form data</string>
    <!-- Settings label -->
    <string name="pref_privacy_clear_form_data">Clear form data</string>
    <!-- Settings summary -->
    <string name="pref_privacy_clear_form_data_summary">Clear all saved form data</string>
    <!-- Confirmation dialog message -->
    <string name="pref_privacy_clear_form_data_dlg">Delete all saved form data?</string>
    <!-- Settings label -->
    <string name="pref_privacy_clear_passwords">Clear passwords</string>
    <!-- Settings summary -->
    <string name="pref_privacy_clear_passwords_summary">Clear all saved passwords</string>
    <!-- Confirmation dialog message -->
    <string name="pref_privacy_clear_passwords_dlg">Delete all saved passwords?</string>
    <!-- Location settings category [CHAR-LIMIT=50] -->
    <string name="pref_privacy_location_title">Location</string>
    <!-- Settings label -->
    <string name="pref_privacy_enable_geolocation">Enable location</string>
    <!-- Settings summary -->
    <string name="pref_privacy_enable_geolocation_summary">Allow sites to request access to your location</string>
    <!-- Settings label -->
    <string name="pref_privacy_clear_geolocation_access">Clear location access</string>
    <!-- Settings summary -->
    <string name="pref_privacy_clear_geolocation_access_summary">Clear location access for all websites</string>
    <!-- Confirmation dialog message -->
    <string name="pref_privacy_clear_geolocation_access_dlg">Clear website location access?</string>
    <!-- Passwords settings category [CHAR-LIMIT=50] -->
    <string name="pref_security_passwords_title">Passwords</string>
    <!-- Settings label -->
    <string name="pref_security_remember_passwords">Remember passwords</string>
    <!-- Settings summary -->
    <string name="pref_security_remember_passwords_summary">Save usernames and passwords for websites</string>
    <!-- Settings label -->
    <string name="pref_security_save_form_data">Remember form data</string>
    <!-- Settings summary -->
    <string name="pref_security_save_form_data_summary">Remember data I type in forms for later use</string>
    <!-- Settings label -->
    <string name="pref_security_show_security_warning">Show security warnings</string>
    <!-- Settings summmary -->
    <string name="pref_security_show_security_warning_summary">Show warning if there\'s a problem with a site\'s security</string>
    <!-- Settings label -->
    <string name="pref_security_accept_cookies">Accept cookies</string>
    <!-- Settings summary -->
    <string name="pref_security_accept_cookies_summary">Allow sites to save and read cookie data</string>
    <!-- Settings text size options; appear in Text size dialog box [CHAR LIMIT=30] -->
    <string-array name="pref_text_size_choices">
        <item>Tiny</item>
        <item>Small</item>
        <item>Normal</item>
        <item>Large</item>
        <item>Huge</item>
    </string-array>
    <!-- Label for minimum font size [CHAR LIMIT=30] -->
    <string name="pref_min_font_size">Minimum font size</string>
    <!-- Label for the current minimum font size value [CHAR LIMIT=6] -->
    <string name="pref_min_font_size_value"><xliff:g id="font_size">%d</xliff:g>pt</string>
    <!-- Label for text scaling (percent) [CHAR LIMIT=30] -->
    <string name="pref_text_zoom">Text scaling</string>
    <!-- Label for zoom on double-tap (percent) [CHAR LIMIT=30] -->
    <string name="pref_zoom_on_double_tap">Zoom on double-tap</string>
    <!-- Label for whether or not to force-enable user scalablity (aka, zoom) [CHAR LIMIT=30] -->
    <string name="pref_force_userscalable">Force enable zoom</string>
    <!-- Summary for whether or not to force-enable user scalablity (aka, zoom) [CHAR LIMIT=30] -->
    <string name="pref_force_userscalable_summary">Override a website\'s request to control zoom behavior</string>
    <!-- Inverted screen category under accessibility settings [CHAR LIMIT=50] -->
    <string name="pref_inverted_category">Inverted screen rendering</string>
    <!-- Title for the inverted screen feature. This causes the screen to render with inverted colors (black becomes white and vice versa) [CHAR LIMIT=40] -->
    <string name="pref_inverted">Inverted rendering</string>
    <!-- Summary for the inverted screen feature. [CHAR LIMIT=120] -->
    <string name="pref_inverted_summary">Black becomes white and vice versa</string>
    <!-- Title for the inverted screen contrast. Change the contrast value from 1.0 to 3.0. [CHAR LIMIT=30] -->
    <string name="pref_inverted_contrast">Contrast</string>
    <!-- Settings label -->
    <string name="pref_default_zoom">Default zoom</string>
    <!-- Settings default zoom options; appear in default zoom dialog box -->
    <string-array name="pref_default_zoom_choices">
        <item>Far</item>
        <item>Medium</item>
        <item>Close</item>
    </string-array>
    <!-- Title of dialog for setting the default zoom -->
    <string name="pref_default_zoom_dialogtitle">Default zoom</string>
    <!-- Do not translate -->
    <string-array name="pref_default_zoom_values" translatable="false">
        <item><xliff:g>FAR</xliff:g></item>
        <item><xliff:g>MEDIUM</xliff:g></item>
        <item><xliff:g>CLOSE</xliff:g></item>
    </string-array>
    <!-- Settings label -->
    <string name="pref_content_load_page">Open pages in overview</string>
    <!-- Settings summary -->
    <string name="pref_content_load_page_summary">Show overview of newly-opened pages</string>
    <!-- Settings screen, section title [CHAR LIMIT=50] -->
    <string name="pref_extras_title">Advanced</string>
    <!-- Settings label -->
    <string name="pref_extras_website_settings">Website settings</string>
    <!-- Settings summary -->
    <string name="pref_extras_website_settings_summary">Advanced settings for individual websites</string>
    <!-- Settings category label [CHAR-LIMIT=50] -->
    <string name="pref_extras_reset_default_title">Reset defaults</string>
    <!-- Settings label -->
    <string name="pref_extras_reset_default">Reset to default</string>
    <!-- Settings summary -->
    <string name="pref_extras_reset_default_summary">Restore default settings</string>
    <!-- Confirmation dialog message -->
    <string name="pref_extras_reset_default_dlg">Revert settings to default values?</string>
    <!-- Title for a group of settings -->
    <string name="pref_development_title">Debug</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_viewport" translatable="false">Use wide viewport</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_single_column_rendering" translatable="false">Single column rendering</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_normal_rendering" translatable="false">Normal rendering</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_trace" translatable="false">Enable tracing</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_nav_dump" translatable="false">Enable nav cache dump</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_hardware_accel" translatable="false">Enable OpenGL Rendering</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_hardware_accel_skia" translatable="false">Enable HW Accelerated Skia</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_visual_indicator" translatable="false">Enable Visual Indicator</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_cpu_upload_path" translatable="false">Enable Cpu Upload Path</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="js_engine_flags" translatable="false">Set JS flags</string>
    <!-- Do not tranlsate.  Development option -->
    <string name="pref_development_uastring" translatable="false">UAString</string>
    <!-- Do not tranlsate.  Development option -->
    <string-array name="pref_development_ua_choices" translatable="false">
        <item>Android</item>
        <item>Desktop</item>
        <item>iPhone</item>
        <item>iPad</item>
        <item>Froyo-N1</item>
        <item>Honeycomb-Xoom</item>
    </string-array>
    <!-- Do not tranlsate.  Development option -->
    <string-array name="pref_development_ua_values" translatable="false">
        <item>0</item>
        <item>1</item>
        <item>2</item>
        <item>3</item>
        <item>4</item>
        <item>5</item>
    </string-array>
    <string name="pref_development_error_console" translatable="false">Show JavaScript Console</string>
    <!-- Do not translate. Development option to reset the prologin time [CHAR LIMIT=20] -->
    <string name="pref_development_reset_prelogin" translatable="false">Reset prelogin</string>
    <!-- Settings screen, setting option name -->
    <string name="pref_default_text_encoding">Text encoding</string>
    <!-- Options in the Default encoding dialog box -->
    <string-array name="pref_default_text_encoding_choices">
        <item>Latin-1 (ISO-8859-1)</item>
        <item>Unicode (UTF-8)</item>
        <item>Chinese (GBK)</item>
        <item>Chinese (Big5)</item>
        <item>Japanese (ISO-2022-JP)</item>
        <item>Japanese (SHIFT_JIS)</item>
        <item>Japanese (EUC-JP)</item>
        <!-- No need to translate a EUC-KR part, and there is no string length limits. -->
        <item>Korean (EUC-KR)</item>
        <!-- TODO: We should add a lot more encodings.  -->
    </string-array>
    <!-- Dialog box title -->
    <string name="pref_default_text_encoding_dialogtitle">Text encoding</string>
    <!-- Do not translate. Actual encoding values. Must be valid text encodings understandable from WebKit. -->
    <string-array name="pref_default_text_encoding_values" translatable="false">
        <item>Latin-1</item>
        <item>UTF-8</item>
        <item>GBK</item>
        <item>Big5</item>
        <item>ISO-2022-JP</item>
        <item>SHIFT_JIS</item>
        <item>EUC-JP</item>
        <item>EUC-KR</item>
    </string-array>
    <string name="pref_default_text_encoding_default" translatable="false">Latin-1</string>
    <!-- Title for accessibility settings [CHAR LIMIT=25] -->
    <string name="pref_accessibility_title">Accessibility</string>
    <!-- Font size settings category under accessibility settings [CHAR LIMIT=50] -->
    <string name="pref_font_size_category">Text size</string>
    <!-- Title for lab settings [CHAR LIMIT=25] -->
    <string name="pref_lab_title">Labs</string>
    <!-- Title for lab quick controls feature [CHAR LIMIT=40] -->
    <string name="pref_lab_quick_controls">Quick controls</string>
    <!-- Summary for lab quick controls feature [CHAR LIMIT=120] -->
    <string name="pref_lab_quick_controls_summary">
        Slide thumb from the left or right edge to open quick controls and hide app and URL bars</string>
    <!-- Title for the "Instant search" lab feature [CHAR LIMIT=40] -->
    <string name="pref_use_instant_search">Google Instant</string>
    <!-- Summary for the "Instant search" lab feature [CHAR LIMIT=120] -->
    <string name="pref_use_instant_search_summary">
      Use Google Instant when you use Google Search, to show results as you
      type (this can increase data use).</string>
    <!-- Title for the fullscreen lab feature [CHAR LIMIT=40] -->
    <string name="pref_lab_fullscreen">Fullscreen</string>
    <!-- Summary for the fullscreen lab feature [CHAR LIMIT=120] -->
    <string name="pref_lab_fullscreen_summary">
      Use fullscreen mode to hide the status bar</string>
    <!-- Title for bandwidth management preference [CHAR LIMIT=25] -->
    <string name="pref_data_title">Bandwidth management</string>
    <!-- Title for search preloading [CHAR LIMIT=40] -->
    <string name="pref_data_preload_title">Search result preloading</string>
    <!-- Search preloading options [CHAR LIMIT=20] -->
    <string-array name="pref_data_preload_choices">
        <item>Never</item>
        <item>Only on Wi-Fi</item>
        <item>Always</item>
    </string-array>
    <!-- Do not translate -->
    <string name="pref_data_preload_value_never" translatable="false">NEVER</string>
    <string name="pref_data_preload_value_wifi_only" translatable="false">WIFI_ONLY</string>
    <string name="pref_data_preload_value_always" translatable="false">ALWAYS</string>
    <string name="pref_data_preload_default_value" translatable="false">@string/pref_data_preload_value_wifi_only</string>
    <string-array name="pref_data_preload_values" translatable="false">
        <item><xliff:g>@string/pref_data_preload_value_never</xliff:g></item>
        <item><xliff:g>@string/pref_data_preload_value_wifi_only</xliff:g></item>
        <item><xliff:g>@string/pref_data_preload_value_always</xliff:g></item>
    </string-array>
    <!-- Summary for search preloading [CHAR LIMIT=80] -->
    <string name="pref_data_preload_summary">Allow browser to preload high confidence search results in the background</string>
    <!-- Title of dialog for search preloading [CHAR LIMIT=40] -->
    <string name="pref_data_preload_dialogtitle">Search result preloading</string>
    <!-- Title for link prefetching [CHAR LIMIT=40] -->
    <string name="pref_link_prefetch_title">Web page preloading</string>
    <!-- Link prefetching options [CHAR LIMIT=20] -->
    <string-array name="pref_link_prefetch_choices">
        <item>Never</item>
        <item>Only on Wi-Fi</item>
        <item>Always</item>
    </string-array>
    <!-- Do not translate -->
    <string name="pref_link_prefetch_value_never" translatable="false">NEVER</string>
    <string name="pref_link_prefetch_value_wifi_only" translatable="false">WIFI_ONLY</string>
    <string name="pref_link_prefetch_value_always" translatable="false">ALWAYS</string>
    <string name="pref_link_prefetch_default_value" translatable="false">@string/pref_link_prefetch_value_wifi_only</string>
    <string-array name="pref_link_prefetch_values" translatable="false">
        <item><xliff:g>@string/pref_link_prefetch_value_never</xliff:g></item>
        <item><xliff:g>@string/pref_link_prefetch_value_wifi_only</xliff:g></item>
        <item><xliff:g>@string/pref_link_prefetch_value_always</xliff:g></item>
    </string-array>
    <!-- Summary for link prefetching [CHAR LIMIT=80] -->
    <string name="pref_link_prefetch_summary">Allow browser to preload linked web pages in the background</string>
    <!-- Title of dialog for link prefetching [CHAR LIMIT=40] -->
    <string name="pref_link_prefetch_dialogtitle">Web page preloading</string>
    <!-- Title for a dialog displayed when the browser has a data connectivity
            problem -->
    <string name="browserFrameNetworkErrorLabel">Connection problem</string>
    <!-- Title for a dialog displayed when the browser runs into a file label
            error -->
    <string name="browserFrameFileErrorLabel">File problem</string>
    <!-- Dialog box title -->
    <string name="browserFrameFormResubmitLabel"></string>
    <!-- Dialog box message -->
    <string name="browserFrameFormResubmitMessage">The page you\'re trying to view contains data that has already been submitted (\"POSTDATA\"). If you resend the data, any action the form on the page carried out (such as a search or online purchase) will be repeated.</string>
    <!-- Dialog box title -->
    <string name="loadSuspendedTitle">No connection</string>
    <!-- Dialog box message -->
    <string name="loadSuspended">The browser can\'t load this page because there\'s
      no Internet connection.</string>
    <!-- Menu item -->
    <string name="clear_history">Clear history</string>
    <!-- History screen title; appears in title bar -->
    <string name="browser_history">Recently-visited pages</string>
    <!-- Appears on History screen if no history is found -->
    <string name="empty_history">No browser history.</string>
    <!-- Menu option to load the user's home page [CHAR LIMIT=30] -->
    <string name="go_home">Homepage</string>
    <!-- Displayed at the top of the bookmarks page.  When clicked, it bookmarks the page the browser is currently showing -->
    <string name="add_new_bookmark">Add bookmark</string>
    <!-- Verb placed in front of a screenshot of a web page that, when clicked,
            will add that page to bookmarks -->
    <string name="add_bookmark_short">Add</string>

    <!-- This string is for the browser "Go To" UI. -->
    <!-- Do not translate.  This string is not displayed in UI (no badge is selected for go to). -->
    <string name="search_label" translatable="false">Browser</string>
    <!-- This string is for the browser "Go To" UI. -->
    <!-- This is the hint text shown in the Go To widget, before text is entered. -->
    <string name="search_hint">Search or type URL</string>
    <!-- This string is for the browser "Go To" UI. -->
    <!-- This is the button label in the "Go To" UI. -->
    <string name="search_button_text">Go</string>
    <!-- The string used to describe the browser as a searchable item within system search settings. -->
    <string name="search_settings_description">Bookmarks and web history</string>

    <!-- Pop-up window dialog -->
    <!-- Message for a dialog informing the user that the site is attempting to
            display a popup window -->
    <string name="popup_window_attempt">Allow this site to open a
      pop-up window?</string>
    <!-- Label for a button to allow a particular popup window to open -->
    <string name="allow">Allow</string>
    <!-- Label for a button to disallow a particular popup from opening -->
    <string name="block">Block</string>

    <!-- Title for a dialog informing the user that they cannot open any more
            windows because the limit has been reached. -->
    <string name="too_many_windows_dialog_title">Tab limit reached</string>
    <!-- Message in a dialog telling the user that they cannot open any more
            windows because the limit has been reached. -->
    <string name="too_many_windows_dialog_message">Can\'t open a new tab until you close one.</string>
    <!-- Title for a dialog informing the user that they cannot open a subwindow
            because only one can be open at a time. -->
    <string name="too_many_subwindows_dialog_title">Pop-up already open</string>
    <!-- Message for a dialog informing the user that they cannot open a
            subwindow because only one can be open at a time. -->
    <string name="too_many_subwindows_dialog_message">Only one pop-up can be open
      at a time.</string>

    <!-- Download History UI strings -->
    <!-- Dialog title [CHAR LIMIT=25] -->
    <string name="download_no_sdcard_dlg_title" product="nosdcard">USB storage unavailable</string>
    <!-- Dialog title -->
    <string name="download_no_sdcard_dlg_title" product="default">No SD card</string>
    <!-- Dialog message [CHAR LIMIT=NONE] -->
    <string name="download_no_sdcard_dlg_msg" product="nosdcard">USB storage is required to download <xliff:g id="filename">%s</xliff:g>.</string>
    <!-- Dialog message -->
    <string name="download_no_sdcard_dlg_msg" product="default">An SD card is required to download <xliff:g id="filename">%s</xliff:g>.</string>
    <!-- Title for a dialog informing the user that the SD card used for
            external storage is busy so they cannot download anything [CHAR LIMIT=25] -->
    <string name="download_sdcard_busy_dlg_title" product="nosdcard">USB storage unavailable</string>
    <!-- Title for a dialog informing the user that the SD card used for
            external storage is busy so they cannot download anything -->
    <string name="download_sdcard_busy_dlg_title" product="default">SD card unavailable</string>
    <!-- Message for a dialog informing the user that the SD card used for
            external storage is busy so they cannot download anything.  Informs
            the user how to enable SD card storage [CHAR LIMIT=NONE] -->
    <string name="download_sdcard_busy_dlg_msg" product="nosdcard">The USB storage is busy. To allow downloads, touch Turn Off USB Storage in the notification.</string>
    <!-- Message for a dialog informing the user that the SD card used for
            external storage is busy so they cannot download anything.  Informs
            the user how to enable SD card storage -->
    <string name="download_sdcard_busy_dlg_msg" product="default">The SD card is busy. To allow downloads, touch Turn Off USB Storage in the notification.</string>

    <!-- Toast for a download which cannot begin because the URL is not http or https -->
    <string name="cannot_download">Can only download \"http\" or \"https\" URLs.</string>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the download has not
            yet begun -->
    <string name="download_pending">Starting download\u2026</string>

    <!-- Do not translate.  Testing only -->
    <string name="dump_nav" translatable="false">Dump navigation cache</string>

    <!-- The default homepage. -->
    <string name="homepage_base" translatable="false">
        https://www.google.com/webhp?client={CID}&amp;source=android-home</string>

    <!-- Bookmarks -->
    <string-array name="bookmarks" translatable="false">
        <item>Google</item>
        <item>http://www.google.com/</item>
        <item>Picasa</item>
        <item>http://picasaweb.google.com/</item>
        <item>Yahoo!</item>
        <item>http://www.yahoo.com/</item>
        <item>MSN</item>
        <item>http://www.msn.com/</item>
        <item>Twitter</item>
        <item>http://twitter.com/</item>
        <item>Facebook</item>
        <item>http://www.facebook.com/</item>
        <item>Wikipedia</item>
        <item>http://www.wikipedia.org/</item>
        <item>eBay</item>
        <item>http://www.ebay.com/</item>
        <item>CNN</item>
        <item>http://www.cnn.com/</item>
        <item>NY Times</item>
        <item>http://www.nytimes.com/</item>
        <item>ESPN</item>
        <item>http://espn.com/</item>
        <item>Amazon</item>
        <item>http://www.amazon.com/</item>
        <item>Weather Channel</item>
        <item>http://www.weather.com/</item>
        <item>BBC</item>
        <item>http://www.bbc.co.uk/</item>
    </string-array>

    <!-- Bookmark name for Picasa website -->
    <string name="picasa" translatable="false">Picasa</string>

    <!-- The description of the suggestion that lets the user search the web for the query currently
         in the text field. -->
    <string name="search_the_web">Search the web</string>

    <!-- HTML5 dialogs -->
    <!-- Used as a status bar notification when the browser is running out of space trying to allocate or increase the database quota for an HTML5 databae or application cache. -->
    <string name="webstorage_outofspace_notification_title">Browser storage full</string>
    <string name="webstorage_outofspace_notification_text">Touch to free up space.</string>
    <!-- Used in the Browser Settings -->
    <string name="webstorage_clear_data_title">Clear stored data</string>

    <!-- Confirmation dialog when the user ask to clear all data for an origin -->
    <string name="webstorage_clear_data_dialog_message">Delete all data stored by this website?</string>
    <string name="webstorage_clear_data_dialog_ok_button">OK</string>
    <string name="webstorage_clear_data_dialog_cancel_button">Cancel</string>
    <!-- Strings used in the summary of origins -->
    <string name="webstorage_origin_summary_mb_stored">MB stored on your phone</string>
        <!-- String shown in a progress view while a video is loading, before it starts playing -->
    <string name="loading_video">Loading video\u2026</string>

    <!-- Geolocation -->
    <!-- Permissions prompt -->
    <string name="permissions_prompt_message"><xliff:g id="website origin" example="maps.google.com">%s</xliff:g> wants to use your <xliff:g id="resources" example="camera, microphone">%s</xliff:g>.</string>
    <string name="permissions_prompt_allow">Allow</string>
    <string name="permissions_prompt_deny">Deny</string>
    <string name="permissions_prompt_remember">Remember preference</string>
    <string name="resource_protected_media_id">protected media ID</string>
    <string name="resource_video_capture">camera</string>
    <string name="resource_audio_capture">microphone</string>
    <string name="geolocation_permissions_prompt_message"><xliff:g id="website origin" example="maps.google.com">%s</xliff:g> wants to know your location</string>
    <string name="geolocation_permissions_prompt_share">Share location</string>
    <string name="geolocation_permissions_prompt_dont_share">Decline</string>
    <string name="geolocation_permissions_prompt_remember">Remember preference</string>
    <!-- Permissions prompt toast -->
    <string name="geolocation_permissions_prompt_toast_allowed">This site can access your location. Change this on the Settings &gt; Advanced &gt; Website screen.</string>
    <string name="geolocation_permissions_prompt_toast_disallowed">This site cannot access your location. Change this on the Settings &gt; Advanced &gt; Website screen.</string>
    <!-- Settings -> Advanced -> Website settings -> <origin> -->
    <string name="geolocation_settings_page_title">Clear location access</string>
    <string name="geolocation_settings_page_summary_allowed">This site can currently access your location</string>
    <string name="geolocation_settings_page_summary_not_allowed">This site can\'t currently access your location</string>
    <!-- Settings page dialog -->
    <string name="geolocation_settings_page_dialog_message">Clear location access for this website?</string>
    <string name="geolocation_settings_page_dialog_ok_button">OK</string>
    <string name="geolocation_settings_page_dialog_cancel_button">Cancel</string>
    <!-- Label for the menu item in the website settings activity used to clear data stored by all websites -->
    <string name="website_settings_clear_all">Clear all</string>
    <string name="website_settings_clear_all_dialog_message">Delete all website data and location permissions?</string>
    <string name="website_settings_clear_all_dialog_ok_button">OK</string>
    <string name="website_settings_clear_all_dialog_cancel_button">Cancel</string>

    <!-- Text in the progress dialog when we are setting an image as the home screen wallpaper. -->
    <string name="progress_dialog_setting_wallpaper">Setting wallpaper\u2026</string>

    <string name="error_console_header_text_minimized" translatable="false">Show JavaScript console</string>
    <string name="error_console_header_text_maximized" translatable="false">JavaScript console</string>
    <string name="error_console_eval_text_hint" translatable="false">Evaluate JavaScript</string>
    <string name="error_console_eval_button_text" translatable="false">Evaluate</string>

    <!-- The default state to the "up to parent folder" button in the bookmarks UI. This
         is displayed when the user is at the highest level and cannot go up [CHAR LIMIT=16] -->
    <string name="defaultBookmarksUpButton">Bookmarks</string>

    <!-- The string that is displayed when there are no bookmarks to display.
         This is centered in the middle of the screen [CHAR LIMIT=NONE] -->
    <string name="empty_bookmarks_folder">No bookmarks.</string>

    <!-- The folder name for the special "Other Bookmarks" folder created by Chrome [CHAR LIMIT=24] -->
    <string name="other_bookmarks">Other Bookmarks</string>

    <!-- Access point for RLZ tracking. -->
    <string name="rlz_access_point">Y1</string>

    <!-- Title for a dialog asking the user which account to sync their bookmarks to [CHAR LIMIT=32] -->
    <string name="account_chooser_dialog_title" msgid="4833571985009544332">Choose account</string>

    <!-- Title for a dialog asking the user what they want to do with their bookmarks when adding a sync account [CHAR-LIMIT=32] -->
    <string name="import_bookmarks_dialog_title">Sync with Google account</string>

    <!-- Description for a dialog asking the user what they want to do with their bookmarks when adding a sync account [CHAR-LIMIT=none] -->
    <string name="import_bookmarks_dialog_description">Bookmarks on this device are not yet associated with a Google account. Save these bookmarks by adding them to an account. Delete these bookmarks if you don\'t want to sync them.</string>

    <!-- Description for selecting the account to add bookmarks to and begin syncing with [CHAR-LIMIT=none] -->
    <string name="import_bookmarks_dialog_select_add_account">Add bookmarks currently on this device and begin syncing with Google account</string>

    <!-- Description for selecting the account to sync with and delete local bookmarks [CHAR-LIMIT=none] -->
    <string name="import_bookmarks_dialog_delete_select_account">Delete bookmarks currently on this device and begin syncing with Google account</string>

    <!-- Description confirming user's choice to delete bookmarks [CHAR-LIMIT=none] -->
    <string name="import_bookmarks_dialog_confirm_delete">Delete bookmarks currently on this device and begin syncing bookmarks with <xliff:g id="Google account" example="account@example.com">%s</xliff:g>?</string>

    <!-- Description confirming user's choice to add bookmarks to an account [CHAR-LIMIT=none] -->
    <string name="import_bookmarks_dialog_confirm_add">Add bookmarks currently on this device and begin syncing bookmarks with <xliff:g id="Google account" example="account@example.com">%s</xliff:g>?</string>

    <!-- Button allowing users to remove all of their existing bookmarks when setting up syncing with their bookmarks stored in Google Chrome [CHAR-LIMIT=64] -->
    <string name="import_bookmarks_dialog_remove">Delete bookmarks</string>

    <!-- Sync bookmarks wizard option to go to the next screen [CHAR-LIMIT=30] -->
    <string name="import_bookmarks_wizard_next">Next</string>

    <!-- Sync bookmarks wizard option to go to the previous screen [CHAR-LIMIT=30] -->
    <string name="import_bookmarks_wizard_previous">Previous</string>

    <!-- Sync bookmarks wizard option to cancel sync setup [CHAR-LIMIT=30] -->
    <string name="import_bookmarks_wizard_cancel">Cancel</string>

    <!-- Sync bookmarks wizard option to finish sync setup [CHAR-LIMIT=30] -->
    <string name="import_bookmarks_wizard_done">Done</string>

    <!-- Button allowing users to import all of their existing bookmarks into an account when setting up syncing with their bookmarks stored in Google Chrome [CHAR-LIMIT=64] -->
    <string name="import_bookmarks_dialog_add">Add bookmarks to Google account</string>

    <!-- Button allowing users to import all of their existing bookmarks into an account when setting up syncing with their bookmarks stored in Google Chrome [CHAR-LIMIT=64] -->
    <string name="import_bookmarks_dialog_import">Add your Android bookmarks to bookmarks for <xliff:g id="Google account" example="account@example.com">%s</xliff:g></string>

    <!-- Url Selection Action Mode -->

    <!-- Menu item to share URL selection [CHAR LIMIT=30] -->
    <string name="menu_share_url">Share</string>

    <!-- Toast to inform the user that the maximum number of tabs has been
         reached. [CHAR LIMIT=50] -->
    <string name="max_tabs_warning">No more tabs available</string>

    <!-- The label used by the instant search labs feature when shown in
         the search engines list (Preferences->Advanced->Set search engine
         [CHAR LIMIT=80] -->
    <string name="instant_search_label">Google with Instant (Labs)</string>
    <!-- Font size preview label in settings [CHAR LIMIT=30] -->
    <string name="preview">Preview</string>
    <!-- Name for the user's unsynced, local bookmarks [CHAR LIMIT=50] -->
    <string name="local_bookmarks">Local</string>
    <!-- Popup menu checkbox that allows the user to request the desktop version of a webpage [CHAR LIMIT=50] -->
    <string name="ua_switcher_desktop">Request desktop site</string>
    <!-- Preload permission label [CHAR LIMIT=40] -->
    <string name="permission_preload_label">Preload results</string>
    <!-- Empty text for the "saved pages" tab that is shown when no saved pages exist. [CHAR LIMIT=None] -->
    <string name="empty_snapshots_folder">No saved pages.</string>
    <!-- Menu option to delete the currently selected saved page [CHAR LIMIT=50] -->
    <string name="remove_snapshot">Delete saved page</string>
    <!-- Popup menu option to load the live version of a saved page [CHAR LIMIT=20] -->
    <string name="snapshot_go_live">Go live</string>

    <!--  Accessibility content descriptions -->

    <!-- Content description for back button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_back">Go back</string>
    <!-- Content description for forward button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_forward">Go forward</string>
    <!-- Content description for refresh button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_refresh">Refresh page</string>
    <!-- Content description for stop button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_stop">Stop page load</string>
    <!-- Content description for add bookmark button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_addbookmark">Bookmark page</string>
    <!-- Content description for search button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_search">Search</string>
    <!-- Content description for voice search button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_voice">Start voice search</string>
    <!-- Content description for bookmarks button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_bookmarks">Bookmarks</string>
    <!-- Content description for close tab button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_closetab">Close tab</string>
    <!-- Content description for new tab button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_newtab">Open new tab</string>
    <!-- Content description for new incognito tab button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_newincognitotab">Open new incognito tab</string>
    <!-- Content description for clear button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_clear">Clear input</string>
    <!-- Content description for user agent switcher [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_uaswitch">Switch user agent</string>
    <!-- Content description for go button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_go">Go</string>

    <!-- Content description for tab switcher button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_navscreen">Page manager</string>
    <!-- Content description for overflow menu button [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_more">More options</string>

    <!-- Content description for incognito state [CHAR LIMIT=NONE] -->
    <string name="accessibility_state_incognito">Incognito page</string>
    <!-- Content description for frozen state [CHAR LIMIT=NONE] -->
    <string name="accessibility_state_frozen">Saved page</string>

    <!-- Content description for tab switcher transition [CHAR LIMIT=NONE] -->
    <string name="accessibility_transition_navscreen">Tab management</string>
    <!-- Content description for navigating up in the bookmark folder hierarchy [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_bookmarks_folder_up">Previous folder</string>

    <!-- Permission check -->
    <string name="permission_not_granted_dialog_title">Permission not granted</string>
    <string name="permission_not_granted_dialog_message">The permission to write to external storage was not granted. Cannot download.</string>
    <string name="browser_error_title">Browser error</string>
    <string name="dialog_dismiss">Dismiss</string>
    <string name="error_permissions">The app does not have critical permissions needed to run. Please check your permissions settings.</string>

</resources>
