diff --git a/res/values/strings.xml b/res/values/strings.xml
index 47f217b..d215724 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -33,11 +33,11 @@
     <!-- 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>
+    <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>
+    <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>
+    <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 -->
@@ -83,13 +83,13 @@
     <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>
+    <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 does not match the name on the certificate.</string>
+    <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 is not valid yet.</string>
+    <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 -->
@@ -126,19 +126,19 @@
     <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>
+    <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>
+    <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">Add to Bookmarks</string>
+    <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] -->
@@ -160,7 +160,7 @@
     <!-- 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>
+    <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 -->
@@ -168,9 +168,9 @@
         <!-- 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>
+    <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 cannot be bookmarked.</string>
+    <string name="bookmark_cannot_save_url">This URL can\'t 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
@@ -192,7 +192,7 @@
     <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>
+    <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-->
@@ -205,14 +205,14 @@
     <!-- 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>
+    <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>
+    <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] -->
@@ -283,7 +283,7 @@
     <!-- 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>
+    <string name="pref_content_title">Page content</string>
     <!-- Settings label -->
     <string name="pref_content_load_images">Load images</string>
     <!-- Settings label -->
@@ -308,15 +308,15 @@
         <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>
+    <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">Select a search engine</string>
+    <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\u2026</string>
+    <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>
@@ -327,7 +327,7 @@
         <!-- 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>
+        <item>Other</item>
     </string-array>
     <string-array name="pref_homepage_values" translatable="false">
         <item>current</item>
@@ -339,7 +339,7 @@
     <!-- 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>
+    <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] -->
@@ -352,14 +352,14 @@
     <!-- 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>
+    <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 data</string>
+    <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">Enter and save data for auto-filling web form fields</string>
+    <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 sign-in</string>
+    <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] -->
@@ -372,7 +372,7 @@
     <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 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] -->
@@ -386,11 +386,11 @@
     <!-- 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 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 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 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] -->
@@ -398,24 +398,24 @@
     <!-- 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>
+    <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>
+    <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">Profile saved</string>
+    <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">Profile deleted</string>
+    <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 profile</string>
+    <string name="autofill_profile_editor_delete_profile">Delete</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>
+    <string name="autofill_setup_dialog_title">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>
+    <string name="autofill_setup_dialog_message">The browser can automatically complete web forms like this one. Would you like 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">Auto-fill can always be configured through Browser Settings.</string>
+    <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>
@@ -427,7 +427,7 @@
     <!-- 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>
+    <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 -->
@@ -435,27 +435,27 @@
     <!-- 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>
+    <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">The browser navigation history will be deleted.</string>
+    <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 the saved form data</string>
+    <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">All saved form data will be deleted.</string>
+    <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">All saved passwords will be deleted.</string>
+    <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 -->
@@ -467,7 +467,7 @@
     <!-- 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>
+    <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 -->
@@ -481,11 +481,11 @@
     <!-- 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>
+    <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>
+    <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>
@@ -503,13 +503,13 @@
     <!-- 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>
+    <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>
+    <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>
+    <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>
+    <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 -->
@@ -531,7 +531,7 @@
     <!-- 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>
+    <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 -->
@@ -545,7 +545,7 @@
     <!-- 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>
+    <string name="pref_extras_reset_default_dlg">Revert settings 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 -->
@@ -632,7 +632,7 @@
     <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>
+        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] -->
@@ -643,15 +643,15 @@
     <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>
+      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>
+    <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>Only on WiFi</item>
         <item>Always</item>
     </string-array>
     <!-- Do not translate -->
@@ -665,34 +665,34 @@
         <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 the browser to preload high confidence search results in the background</string>
+    <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 a dialog displayed when the browser has a data connectivity
             problem -->
-    <string name="browserFrameNetworkErrorLabel">Data connectivity problem</string>
+    <string name="browserFrameNetworkErrorLabel">Connection problem</string>
     <!-- Title for a dialog displayed when the browser runs into a file label
             error -->
-    <string name="browserFrameFileErrorLabel">Problem with file</string>
+    <string name="browserFrameFileErrorLabel">File problem</string>
     <!-- Dialog box title -->
-    <string name="browserFrameFormResubmitLabel">Confirm</string>
+    <string name="browserFrameFormResubmitLabel"></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>
+    <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 network connection</string>
+    <string name="loadSuspendedTitle">No connection</string>
     <!-- Dialog box message -->
-    <string name="loadSuspended">Browser cannot load this page because there
-      is no internet connection.</string>
+    <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>
+    <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>
+    <string name="empty_history">No browser history.</string>
     <!-- Menu option to load the user's home page [CHAR LIMIT=30] -->
-    <string name="go_home">Home</string>
+    <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\u2026</string>
+    <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>
@@ -715,8 +715,8 @@
     <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>
+    <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 -->
@@ -727,14 +727,14 @@
     <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>
+    <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">Could not open a new
-      pop-up window because only one can be open at any time.</string>
+    <string name="too_many_subwindows_dialog_message">Only one pop-up can be open
+      at a time.</string>
 
     <!-- Download History UI strings -->
     <string name="download_title">Download history</string>
@@ -753,13 +753,13 @@
     <!-- 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>
+    <string name="download_cancel_dlg_msg">Cancel and clear all <xliff:g id="download_count">%d</xliff:g> downloads from the download history?</string>
     <!-- Confirmation dialog title -->
-    <string name="download_delete_file">File will be deleted</string>
+    <string name="download_delete_file">Delete</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>
+    <string name="download_file_error_dlg_msg"><xliff:g id="filename">%s</xliff:g> couldn\'t be downloaded.\nFree up some space 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] -->
@@ -779,25 +779,25 @@
     <!-- 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>
+    <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, select \"Turn off USB storage\" in the notification.</string>
+    <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>
     <!-- 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>
+    <string name="download_no_application_title">Can\'t 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>
+    <string name="no_downloads">No download history.</string>
     <!-- the following download_xxxx matches the download manager state, ie Downloads.Status -->
-    <string name="download_error">Download unsuccessful.</string>
+    <string name="download_error">Couldn\'t download.</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>
+    <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
@@ -819,19 +819,19 @@
     <!-- 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>
+    <string name="download_not_acceptable">Can\'t download because the content isn\'t 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>
+    <string name="download_file_error">Can\'t finish download because there isn\'t 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>
+    <string name="download_length_required">Can\'t download because the size of the item can\'t 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>
+    <string name="download_precondition_failed">Download interrupted and can\'t be resumed.</string>
 
     <!-- Do not translate.  Testing only -->
     <string name="dump_nav" translatable="false">Dump navigation cache</string>
@@ -889,19 +889,19 @@
     <!-- 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>
+    <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_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_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</string>
+    <string name="loading_video">Loading video\u2026</string>
 
     <!-- Geolocation -->
     <!-- Permissions prompt -->
@@ -910,26 +910,26 @@
     <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>
+    <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 cannot 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_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_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_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_title">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...</string>
+    <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>
@@ -942,7 +942,7 @@
 
     <!-- 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>
+    <string name="empty_bookmarks_folder">No bookmarks.</string>
 
     <!-- Access point for RLZ tracking. -->
     <string name="rlz_access_point">Y1</string>
@@ -954,19 +954,19 @@
     <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>
+    <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>
+    <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>
+    <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 synchronizing bookmarks with <xliff:g id="Google account" example="account@example.com">%s</xliff:g>.</string>
+    <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 synchronizing bookmarks with <xliff:g id="Google account" example="account@example.com">%s</xliff:g>.</string>
+    <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>
@@ -984,7 +984,7 @@
     <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>
+    <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>
@@ -1011,7 +1011,7 @@
     <!-- 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>
+    <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] -->
