<?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 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 is not from a trusted authority.</string>
    <!-- Message in an SSL Error dialog -->
    <string name="ssl_mismatch">The name of the site does not 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 is not 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\u2026</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">Add 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">Unable to 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">URL is not 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 cannot be bookmarked.</string>
        <!-- Title of a confirmation dialog when the user deletes a bookmark-->
    <string name="delete_bookmark">Delete</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">Bookmark \"<xliff:g id="bookmark">%s</xliff:g>\" will be deleted.</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 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">Pick 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>
    <!-- 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 settings</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 one</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">Select 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\u2026</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\u2026</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 web pages 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 in a single click</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 data</string>
    <!-- Summary for the AutoFill Settings preference [CHAR-LIMIT=none] -->
    <string name="pref_autofill_profile_editor_summary">Enter and save data for auto-filling web form fields</string>

    <!-- Auto login preference title [CHAR-LIMIT=32] -->
    <string name="pref_autologin_title">Automatic Google sign-in</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">Enter the data you want to auto-fill in web fields when you touch them.</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 profile</string>
    <!-- Toast message displayed when the profile has been successfully saved [CHAR-LIMIT=none] -->
    <string name="autofill_profile_successful_save">Profile saved</string>
    <!-- Toast message displayed when the profile has been successfully deleted [CHAR-LIMIT=none] -->
    <string name="autofill_profile_successful_delete">Profile deleted</string>
    <!-- Button text to delete all the AutoFill profile data [CHAR-LIMIT=20] -->
    <string name="autofill_profile_editor_delete_profile">Delete profile</string>

    <!-- Title on a dialog shown to the user when they are prompted to set up the autofill feature [CHAR-LIMIT=32] -->
    <string name="autofill_setup_dialog_title">Setup auto-fill?</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">Browser can automatically complete web forms like this one. Would you like to set up your profile?</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">Auto-fill can always be configured through Browser Settings.</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">Locally cached content and databases will be deleted.</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">All cookies will be deleted.</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">The browser navigation history will be deleted.</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 the saved form data</string>
    <!-- Confirmation dialog message -->
    <string name="pref_privacy_clear_form_data_dlg">All saved form data will be deleted.</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">All saved passwords will be deleted.</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 location access for all websites</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 is 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 zoom (percent) [CHAR LIMIT=30] -->
    <string name="pref_text_zoom">Text zoom</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">Whether or not to 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">Enable inverted rendering. Black will become 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">Settings will revert to default values.</string>
    <!-- Confirmation dialog title -->
    <string name="pref_extras_reset_default_dlg_title">Reset to default</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="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">Font 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=80] -->
    <string name="pref_lab_quick_controls_summary">
        Swipe thumb from left or right edge to access quick controls and hide Application 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>
    <!-- Summary for search preloading [CHAR LIMIT=80] -->
    <string name="pref_data_preload_summary">Allow the browser to preload high confidence search results in the background</string>
    <!-- Title for a dialog displayed when the browser has a data connectivity
            problem -->
    <string name="browserFrameNetworkErrorLabel">Data connectivity problem</string>
    <!-- Title for a dialog displayed when the browser runs into a file label
            error -->
    <string name="browserFrameFileErrorLabel">Problem with file</string>
    <!-- Dialog box title -->
    <string name="browserFrameFormResubmitLabel">Confirm</string>
    <!-- Dialog box message -->
    <string name="browserFrameFormResubmitMessage">The page you are 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 network connection</string>
    <!-- Dialog box message -->
    <string name="loadSuspended">Browser cannot load this page because there
      is 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">Browser history is empty.</string>
    <!-- Menu option to load the user's home page [CHAR LIMIT=30] -->
    <string name="go_home">Home</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\u2026</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 -->
    <!-- Title for a dialog informing the user that the site is attempting to
            display a popup window -->
    <string name="attention">Attention</string>
    <!-- Message for a dialog informing the user that the site is attempting to
            display a popup window -->
    <string name="popup_window_attempt">This site is attempting 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">Could not open a new tab because you have already opened the maximum number.</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">Could not open a new
      pop-up window because only one can be open at any time.</string>

    <!-- Download History UI strings -->
    <string name="download_title">Download history</string>
    <!-- Download history screen string-->
    <string name="download_unknown_filename">&lt;Unknown&gt;</string>
    <!-- Context menu item on Download history screen -->
    <string name="download_menu_open">Open</string>
    <!-- Context menu item on Download history screen -->
    <string name="download_menu_clear">Clear from list</string>
    <!-- Context menu item in Download history screen -->
    <string name="download_menu_delete">Delete</string>
    <!-- Context menu item in Download history screen -->
    <string name="download_menu_cancel">Cancel download</string>
    <!-- Menu item -->
    <string name="download_menu_cancel_all">Cancel all downloads</string>
    <!-- Confirmation dialog title -->
    <string name="download_cancel_dlg_title">Cancel downloads</string>
    <!-- Confirmation dialog message -->
    <string name="download_cancel_dlg_msg">All <xliff:g id="download_count">%d</xliff:g> downloads will be canceled and cleared from the download history.</string>
    <!-- Confirmation dialog title -->
    <string name="download_delete_file">File will be deleted</string>
    <!-- Dialog title -->
    <string name="download_file_error_dlg_title">Out of space</string>
    <!-- Dialog message -->
    <string name="download_file_error_dlg_msg"><xliff:g id="filename">%s</xliff:g> could not be downloaded.\nFree up some space on your phone and try again.</string>
    <!-- Title for a dialog informing the user that the download has failed -->
    <string name="download_failed_generic_dlg_title">Download unsuccessful</string>
    <!-- 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, select \"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, select \"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>
    <!-- Title for a dialog informing the user that there is no application on
            the phone that can open the file that was downloaded -->
    <string name="download_no_application_title">Cannot open file</string>
    <!-- Label for a button to re-attempt downloading a file -->
    <string name="retry">Retry</string>
    <!-- Appears in Download history screen if there is no history -->
    <string name="no_downloads">Download history is empty.</string>
    <!-- the following download_xxxx matches the download manager state, ie Downloads.Status -->
    <string name="download_error">Download unsuccessful.</string>
    <!-- Appears in Download history screen after an item has downloaded, included item size -->
    <string name="download_success"><xliff:g id="file">%s</xliff:g> Download complete.</string>
    <!-- Appears in Download history screen while an item is being downloaded -->
    <string name="download_running">Downloading\u2026</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>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the download is
            waiting for a network connection to continue -->
    <string name="download_pending_network">Waiting for data connection\u2026</string>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the download has
            paused to wait for a network connection -->
    <string name="download_running_paused">Waiting for data connection\u2026</string>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the download has
            been canceled -->
    <string name="download_canceled">Download canceled.</string>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the download will
            not happen because the content is not supported by the phone -->
    <string name="download_not_acceptable">Cannot download. The content is not supported on this phone.</string>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the download did not
            finish because there is not enough storage for the file -->
    <string name="download_file_error">Cannot finish download. There is not enough space.</string>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the item cannot be
            downloaded because it cannot determine the length of the item -->
    <string name="download_length_required">Cannot download. The size of the item cannot be determined.</string>
    <!-- Message in the list of items which have received download requests
            telling their status.  This message states that the download was
            interrupted and cannot be resumed -->
    <string name="download_precondition_failed">Download interrupted. It cannot be resumed.</string>

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

    <!-- The default homepage. If it starts with "http://www.google" and the
            user signs up the device with a Google sites account, the site's
            domain will be appended. -->
    <string name="homepage_base" translatable="false">
        http://www.google.com/webhp?client={CID}&amp;source=android-home</string>
    <!-- The default url for the instant_base_page. -->
    <string name="instant_base" translatable="false">
        http://www.google.com/webhp?client={CID}&amp;source=android-instant&amp;ion=1</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">Click 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_title">Clear stored data</string>
    <string name="webstorage_clear_data_dialog_message">All data stored by this website will be deleted</string>
    <string name="webstorage_clear_data_dialog_ok_button">Clear all</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</string>

    <!-- Geolocation -->
    <!-- Permissions prompt -->
    <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 in Settings -&gt; Advanced -&gt; Website settings</string>
    <string name="geolocation_permissions_prompt_toast_disallowed">This site cannot access your location. Change this in Settings -&gt; Advanced -&gt; Website settings</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 cannot currently access your location</string>
    <!-- Settings page dialog -->
    <string name="geolocation_settings_page_dialog_title">Clear location access</string>
    <string name="geolocation_settings_page_dialog_message">Location access for this website will be cleared</string>
    <string name="geolocation_settings_page_dialog_ok_button">Clear access</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_title">Clear all website settings?</string>
    <string name="website_settings_clear_all_dialog_message">All website data and location permissions will be deleted.</string>
    <string name="website_settings_clear_all_dialog_ok_button">Delete all data</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...</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">There are no 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 do not 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 synchronizing 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 synchronizing 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 synchronizing 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">There are 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>

</resources>
