diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 4f28ef0..e58231a 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -127,10 +127,17 @@
             </intent-filter>
         </activity>
 
+        <activity android:name="CombinedBookmarkHistoryActivity" android:label=""
+                  android:launchMode="singleTop" android:configChanges="orientation|keyboardHidden">
+        </activity>
+
         <activity android:name="BrowserBookmarksPage" android:label="@string/bookmarks"
                   android:launchMode="singleTop" android:configChanges="orientation|keyboardHidden">
         </activity>
 
+        <activity android:name="MostVisitedActivity" android:label=""
+                android:launchMode="singleTop" android:configChanges="orientation|keyboardHidden"/>
+
         <activity-alias android:name="ShortcutBookmarksPage"
             android:targetActivity="BrowserBookmarksPage"
             android:label="@string/shortcut_bookmark">
@@ -146,7 +153,7 @@
                   android:configChanges="orientation|keyboardHidden">
         </activity>
 
-        <activity android:name="BrowserPreferencesPage" android:label=""
+        <activity android:name="BrowserPreferencesPage" android:label="@string/menu_preferences"
                   android:configChanges="orientation|keyboardHidden">
         </activity>
 
@@ -177,7 +184,7 @@
         </service>
 
         <activity android:name="AddBookmarkPage" android:label="Save bookmark" android:theme="@android:style/Theme.Dialog"
-                  android:configChanges="orientation|keyboardHidden">
+                  android:configChanges="orientation|keyboardHidden" android:windowSoftInputMode="stateHidden">
             <intent-filter>
                 <action android:name="android.intent.action.INSERT" />
                 <category android:name="android.intent.category.DEFAULT" />
diff --git a/assets/html/plugin.html b/assets/html/plugin.html
deleted file mode 100755
index f112a4b..0000000
--- a/assets/html/plugin.html
+++ /dev/null
@@ -1,43 +0,0 @@
-<html>
-<head>
-<title>Plugin test</title>
-</head>
-<body>
-<h1>Plugin test page</h1>
-This is text above the plugin
-<a href="http://www.google.com">Google</a>
-<br>
-lhs
-<object type="application/x-testplugin" height=40 width=64>
-    <param name="DrawingModel" value="Bitmap" />
-</object>
-<object type="application/x-testplugin" height=40 width=64>
-    <param name="DrawingModel" value="Canvas" />
-</object>
-rhs
-<br>
-
-This is some the text and more text and more text and more text and more text and more text and more text and more text and more text and more text and more text
-<ol>
-<li><a href="http://www.google.com">Google</a></li>
-<li><a href="http://www.gmail.com">Gmail</a></li>
-<li><a href="http://maps.google.com/">Google Maps</a></li>
-<li><a href="http://news.google.com">Google News</a></li>
-<li><a href="http://www.yahoo.com">Yahoo!</a></li>
-<li><a href="http://www.yahoomail.com">Yahoo! Mail</a></li>
-<li><a href="http://www.msn.com">MSN</a></li>
-<li><a href="http://www.hotmail.com">Hotmail</a></li>
-<li><a href="http://www.aol.com">AOL</a></li>
-<li><a href="http://mail.aol.com">AOL Mail</a></li>
-<li><a href="http://www.ebay.com">eBay</a></li>
-<li><a href="http://www.ask.com">Ask.com</a></li>
-<li><a href="http://www.amazon.com">Amazon</a></li>
-<li><a href="http://www.myspace.com">MySpace</a></li>
-<li><a href="http://www.nytimes.com">New York Times</a></li>
-<li><a href="http://www.weather.com">Weather Channel</a></li>
-<li><a href="http://www.wikipedia.org/">Wikipedia</a></li>
-<li><a href="http://www.cnet.com">CNET</a></li>
-<li><a href="http://www.apple.com">Apple</a></li>
-</ol>
-</body>
-</html>
diff --git a/assets/plugins/gears-0.5.7.0/dummy b/assets/plugins/gears-0.5.11.0/dummy
similarity index 100%
rename from assets/plugins/gears-0.5.7.0/dummy
rename to assets/plugins/gears-0.5.11.0/dummy
diff --git a/assets/plugins/gears.so b/assets/plugins/gears.so
index 9ae2a87..6cc5b75 100644
--- a/assets/plugins/gears.so
+++ b/assets/plugins/gears.so
Binary files differ
diff --git a/res/drawable/browser_bookmark_tab.xml b/res/drawable/browser_bookmark_tab.xml
new file mode 100644
index 0000000..76684cb
--- /dev/null
+++ b/res/drawable/browser_bookmark_tab.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 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.
+-->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_selected="true" android:drawable="@drawable/ic_tab_browser_bookmark_selected"/>
+    <item android:state_selected="false" android:drawable="@drawable/ic_tab_browser_bookmark_unselected"/>
+</selector>
+    
diff --git a/res/drawable/browser_history_tab.xml b/res/drawable/browser_history_tab.xml
new file mode 100644
index 0000000..b5329ea
--- /dev/null
+++ b/res/drawable/browser_history_tab.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 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.
+-->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_selected="true" android:drawable="@drawable/ic_tab_browser_history_selected"/>
+    <item android:state_selected="false" android:drawable="@drawable/ic_tab_browser_history_unselected"/>
+</selector>
+
diff --git a/res/drawable/browser_visited_tab.xml b/res/drawable/browser_visited_tab.xml
new file mode 100644
index 0000000..d1b4404
--- /dev/null
+++ b/res/drawable/browser_visited_tab.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 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.
+-->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:state_selected="true" android:drawable="@drawable/ic_tab_browser_visited_selected"/>
+    <item android:state_selected="false" android:drawable="@drawable/ic_tab_browser_visited_unselected"/>
+</selector>
+
diff --git a/res/drawable/ic_search_category_bookmark.png b/res/drawable/ic_search_category_bookmark.png
new file mode 100755
index 0000000..08b5e74
--- /dev/null
+++ b/res/drawable/ic_search_category_bookmark.png
Binary files differ
diff --git a/res/drawable/ic_search_category_history.png b/res/drawable/ic_search_category_history.png
new file mode 100755
index 0000000..894c254
--- /dev/null
+++ b/res/drawable/ic_search_category_history.png
Binary files differ
diff --git a/res/drawable/ic_search_category_suggest.png b/res/drawable/ic_search_category_suggest.png
new file mode 100755
index 0000000..ada07e6
--- /dev/null
+++ b/res/drawable/ic_search_category_suggest.png
Binary files differ
diff --git a/res/drawable/ic_tab_browser_bookmark_selected.png b/res/drawable/ic_tab_browser_bookmark_selected.png
new file mode 100644
index 0000000..184885e
--- /dev/null
+++ b/res/drawable/ic_tab_browser_bookmark_selected.png
Binary files differ
diff --git a/res/drawable/ic_tab_browser_bookmark_unselected.png b/res/drawable/ic_tab_browser_bookmark_unselected.png
new file mode 100644
index 0000000..25ddf18
--- /dev/null
+++ b/res/drawable/ic_tab_browser_bookmark_unselected.png
Binary files differ
diff --git a/res/drawable/ic_tab_browser_history_selected.png b/res/drawable/ic_tab_browser_history_selected.png
new file mode 100644
index 0000000..b39c21a
--- /dev/null
+++ b/res/drawable/ic_tab_browser_history_selected.png
Binary files differ
diff --git a/res/drawable/ic_tab_browser_history_unselected.png b/res/drawable/ic_tab_browser_history_unselected.png
new file mode 100644
index 0000000..c0847d0
--- /dev/null
+++ b/res/drawable/ic_tab_browser_history_unselected.png
Binary files differ
diff --git a/res/drawable/ic_tab_browser_visited_selected.png b/res/drawable/ic_tab_browser_visited_selected.png
new file mode 100644
index 0000000..f2cc55c
--- /dev/null
+++ b/res/drawable/ic_tab_browser_visited_selected.png
Binary files differ
diff --git a/res/drawable/ic_tab_browser_visited_unselected.png b/res/drawable/ic_tab_browser_visited_unselected.png
new file mode 100644
index 0000000..b808fbd
--- /dev/null
+++ b/res/drawable/ic_tab_browser_visited_unselected.png
Binary files differ
diff --git a/res/layout/add_new_bookmark.xml b/res/layout/add_new_bookmark.xml
index c8eb220..0335574 100644
--- a/res/layout/add_new_bookmark.xml
+++ b/res/layout/add_new_bookmark.xml
@@ -17,14 +17,19 @@
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
         android:layout_width="fill_parent" 
         android:layout_height="wrap_content"
+        android:minHeight="?android:attr/listPreferredItemHeight"
         android:orientation="horizontal"
-        android:paddingTop="0dip"
-        android:paddingBottom="0dip"
+        android:paddingRight="6dip"
+        android:paddingLeft="6dip"
+        android:paddingTop="5dip"
+        android:paddingBottom="5dip"
+        android:gravity="center_vertical"
         >
     <ImageView android:id="@+id/favicon"
             android:layout_width="48dip"
             android:layout_height="48dip"
-            android:layout_marginRight="6dip"
+            android:layout_marginLeft="5dip"
+            android:layout_marginRight="11dip"
             android:focusable="false"
             android:src="@android:drawable/ic_menu_add"
             android:scaleType="fitCenter"
@@ -33,20 +38,22 @@
             android:layout_width="fill_parent"
             android:layout_height="wrap_content"
             android:orientation="vertical"
-            android:gravity="center_vertical"
             >
         <TextView android:id="@+id/title" 
                 android:text="@string/add_new_bookmark"
-                android:textAppearance="?android:attr/textAppearanceLarge" 
+                android:textAppearance="?android:attr/textAppearanceMedium"
+                android:textStyle="bold" 
                 android:layout_width="wrap_content" 
                 android:layout_height="wrap_content"
+                android:layout_marginBottom="2dip"
                 />
         <TextView android:id="@+id/url" 
                 android:textAppearance="?android:attr/textAppearanceSmall"
                 android:maxLines="1"
-                android:scrollHorizontally="true"
                 android:layout_width="wrap_content" 
                 android:layout_height="wrap_content"
+                android:singleLine="true"
+                android:ellipsize="end"
                 />
     </LinearLayout>
 </LinearLayout>
diff --git a/res/layout/bookmark_item.xml b/res/layout/bookmark_item.xml
deleted file mode 100644
index 7d54447..0000000
--- a/res/layout/bookmark_item.xml
+++ /dev/null
@@ -1,57 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2008 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.
--->
-
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 
-        android:layout_width="fill_parent" 
-        android:layout_height="wrap_content"
-        android:paddingLeft="10dip"
-        android:paddingTop="5dip"
-        android:paddingBottom="5dip"
-        >
-
-    <!-- note: to center icon vertically, replace the alignParentTop
-         below with android:layout_centerVertical="true" -->
-
-    <ImageView android:id="@+id/favicon"
-            android:layout_width="20dip"
-            android:layout_height="20dip"
-            android:focusable="false"
-            android:padding="2dip"
-            android:layout_marginTop="4dip"
-            android:layout_marginRight="6dip"
-            android:layout_alignParentTop="true"
-            android:background="@drawable/fav_icn_background"
-            android:src="@drawable/app_web_browser_sm"
-            android:layout_alignParentLeft="true"
-            />
-    <TextView android:id="@+id/title" 
-            android:textAppearance="?android:attr/textAppearanceMedium"
-            android:maxLines="1"
-            android:layout_width="wrap_content" 
-            android:layout_height="wrap_content"
-            android:layout_toRightOf="@+id/favicon"
-            android:ellipsize="end"
-            />
-    <TextView android:id="@+id/url" 
-            android:textAppearance="?android:attr/textAppearanceSmall"
-            android:maxLines="1"
-            android:layout_width="wrap_content" 
-            android:layout_height="wrap_content"
-            android:layout_below="@+id/title"
-            android:layout_toRightOf="@+id/favicon"
-            android:ellipsize="end"
-            />
-</RelativeLayout>
diff --git a/res/layout/browser_add_bookmark.xml b/res/layout/browser_add_bookmark.xml
index 92ae627..ca84f30 100644
--- a/res/layout/browser_add_bookmark.xml
+++ b/res/layout/browser_add_bookmark.xml
@@ -42,10 +42,8 @@
             android:id="@+id/title"
             android:layout_height="wrap_content"
             android:layout_width="250dip"
-            android:singleLine="true"
-            android:autoText="false"
-            android:capitalize="sentences"
             android:gravity="fill_horizontal"
+            android:inputType="textCapSentences"
             android:selectAllOnFocus="true"
             android:textAppearance="?android:attr/textAppearanceMedium" />
                 
@@ -63,11 +61,9 @@
             android:id="@+id/address"
             android:layout_height="wrap_content"
             android:layout_width="250dip"
-            android:singleLine="true"
-            android:autoText="false"
-            android:capitalize="none"
             android:hint="@string/http"
             android:gravity="fill_horizontal"
+            android:inputType="textUri"
             android:selectAllOnFocus="true"
             android:textAppearance="?android:attr/textAppearanceMedium" />
     </LinearLayout>
diff --git a/res/layout/browser_find.xml b/res/layout/browser_find.xml
index 7e587c1..000799f 100644
--- a/res/layout/browser_find.xml
+++ b/res/layout/browser_find.xml
@@ -18,9 +18,11 @@
     android:id="@+id/findControls"
     android:layout_width="fill_parent"
     android:layout_height="wrap_content"
-    android:background="@android:drawable/bottom_bar"
-    android:paddingTop="12dip"
-    >
+    android:paddingTop="5dip"
+    android:paddingLeft="4dip"
+    android:paddingRight="4dip"
+    android:paddingBottom="1dip"
+    android:background="@android:drawable/bottom_bar">
     <ImageButton 
         android:src="@drawable/ic_btn_find_prev"
         android:id="@+id/previous"
@@ -46,8 +48,7 @@
             android:layout_width="fill_parent"
             android:layout_height="wrap_content"
             android:scrollHorizontally="true"
-            android:autoText="false"
-            android:capitalize="none"
+            android:inputType="text"
             android:hint="@string/find_dot"
             />
         <LinearLayout android:id="@+id/matches_view"
diff --git a/res/layout/history_header.xml b/res/layout/history_header.xml
new file mode 100644
index 0000000..a390c37
--- /dev/null
+++ b/res/layout/history_header.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 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.
+-->
+
+<TextView xmlns:android="http://schemas.android.com/apk/res/android" 
+        android:layout_width="fill_parent" 
+        android:layout_height="wrap_content"
+        android:minHeight="?android:attr/listPreferredItemHeight"
+        android:textAppearance="?android:attr/textAppearanceMedium"
+        android:paddingLeft="35dip"
+        android:gravity="center_vertical"
+        />
\ No newline at end of file
diff --git a/res/layout/history_item.xml b/res/layout/history_item.xml
index 1d51ad1..50903a4 100644
--- a/res/layout/history_item.xml
+++ b/res/layout/history_item.xml
@@ -16,27 +16,50 @@
 
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
         android:layout_width="fill_parent" 
-        android:layout_height="64dip"
-        android:orientation="vertical"
+        android:layout_height="wrap_content"
+        android:minHeight="?android:attr/listPreferredItemHeight"
+        android:orientation="horizontal"
         android:paddingRight="6dip"
-        android:paddingTop="8dip"
-        android:paddingLeft="4dip"
-        android:background="@color/translucent_white"
+        android:paddingLeft="6dip"
+        android:paddingTop="5dip"
+        android:paddingBottom="5dip"
+        android:gravity="center_vertical"
         >
-    <TextView android:id="@+id/title"
-            android:textAppearance="?android:attr/textAppearanceLarge"
-            android:maxLines="1"
-            android:layout_width="wrap_content" 
+    <ImageView android:id="@+id/favicon"
+        android:layout_width="20dip"
+        android:layout_height="20dip"
+        android:layout_marginLeft="5dip"
+        android:layout_marginRight="11dip"
+        android:padding="2dip"
+        android:background="@drawable/fav_icn_background"
+        android:src="@drawable/app_web_browser_sm"
+        />
+    <LinearLayout android:layout_width="0dip"
+            android:layout_weight="1"
             android:layout_height="wrap_content"
-            android:ellipsize="end"
-            android:drawablePadding="4dip"
-            />
-    <TextView android:id="@+id/url" 
-            android:textAppearance="?android:attr/textAppearanceSmall"
-            android:maxLines="1"
-            android:layout_width="wrap_content" 
+            android:orientation="vertical"
+            >
+        <TextView android:id="@+id/title"
+                android:textAppearance="?android:attr/textAppearanceMedium"
+                android:maxLines="1"
+                android:layout_width="wrap_content" 
+                android:layout_height="wrap_content"
+                android:singleLine="true"
+                android:ellipsize="end"
+                />
+        <TextView android:id="@+id/url" 
+                android:textAppearance="?android:attr/textAppearanceSmall"
+                android:maxLines="1"
+                android:layout_width="wrap_content" 
+                android:layout_height="wrap_content"
+                android:singleLine="true"
+                android:ellipsize="end"
+                />
+    </LinearLayout>
+    <CheckBox android:id="@+id/star"
+            android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_marginLeft="24dip"
-            android:ellipsize="end"
+            android:focusable="false"
+            android:button="@android:drawable/btn_star"
             />
 </LinearLayout>
diff --git a/res/layout/http_authentication.xml b/res/layout/http_authentication.xml
index 125095e..01cd3af 100644
--- a/res/layout/http_authentication.xml
+++ b/res/layout/http_authentication.xml
@@ -37,8 +37,7 @@
         android:textSize="18sp"
         android:textColor="@color/username_edit"
         android:scrollHorizontally="true"
-        android:autoText="false"
-        android:capitalize="none"
+        android:inputType="text"
         android:gravity="fill_horizontal"
         android:layout_weight="1"
         android:layout_marginLeft="20dip"
@@ -61,12 +60,10 @@
         android:textSize="18sp"
         android:textColor="@color/password_edit"
         android:scrollHorizontally="true"
-        android:autoText="false"
-        android:capitalize="none"
+        android:inputType="textPassword"
         android:gravity="fill_horizontal"
         android:layout_weight="1"
         android:layout_marginLeft="20dip"
         android:layout_marginRight="20dip"
-        android:layout_marginBottom="12dip" 
-        android:password="true" />
+        android:layout_marginBottom="12dip" />
 </TableLayout>
diff --git a/res/layout/search_bar.xml b/res/layout/search_bar.xml
deleted file mode 100644
index fe5647e..0000000
--- a/res/layout/search_bar.xml
+++ /dev/null
@@ -1,73 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/* apps/common/res/layout/SearchBar.xml
-**
-** Copyright 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.
-*/
--->
-    <!-- Outer layout defines the entire search bar at the top of the screen -->
-    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-        android:id="@+id/search_bar"
-        android:layout_width="fill_parent"
-        android:layout_height="wrap_content"
-        android:orientation="vertical"
-        android:paddingLeft="15dip"
-        android:paddingRight="15dip"
-        android:paddingTop="10dip"
-        android:paddingBottom="20dip"
-        android:baselineAligned="false"
-        android:background="@android:drawable/alert_dark_frame" >
-
-        <!-- TextView or ImageView at top shows searched application -->
-        <!-- Code will display one-or-the-other (or neither) -->
-        <FrameLayout 
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_marginBottom="3dip">
-
-            <TextView 
-                android:id="@+id/search_badge_label"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:textAppearance="?android:attr/textAppearanceSmall" />
-        </FrameLayout>
-
-        <!-- Inner layout contains the button(s) and EditText -->
-        <LinearLayout
-            android:id="@+id/search_edit_frame"
-            android:layout_width="fill_parent"
-            android:layout_height="wrap_content"
-            android:orientation="horizontal"
-            android:gravity="center_vertical"
-            android:baselineAligned="false" >
-
-            <EditText
-                android:id="@+id/search_src_text"
-                android:layout_height="wrap_content"
-                android:layout_width="0dip"
-                android:layout_weight="1.0"
-                android:paddingLeft="6dip"
-                android:paddingRight="6dip"
-                android:singleLine="true"
-                android:textSize="14sp" />
-                
-            <Button
-                android:id="@+id/search_go_btn"
-                android:text="@android:string/search_go"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content" />
-        </LinearLayout>
-        
-    </LinearLayout>
diff --git a/res/layout/tabs.xml b/res/layout/tabs.xml
new file mode 100644
index 0000000..7cf5b5d
--- /dev/null
+++ b/res/layout/tabs.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 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.
+-->
+
+<TabHost xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@android:id/tabhost"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent">
+
+    <LinearLayout
+        android:orientation="vertical"
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent">
+
+        <TabWidget android:id="@android:id/tabs"
+            android:layout_width="fill_parent"
+            android:layout_height="68dip"
+            android:paddingLeft="1dip"
+            android:paddingRight="1dip"
+            android:paddingTop="4dip"
+        />
+
+        <FrameLayout android:id="@android:id/tabcontent"
+            android:layout_width="fill_parent"
+            android:layout_height="0dip"
+            android:layout_weight="1"
+        />
+    </LinearLayout>
+</TabHost>
\ No newline at end of file
diff --git a/res/menu/browser.xml b/res/menu/browser.xml
index 21049d9..088fb6e 100644
--- a/res/menu/browser.xml
+++ b/res/menu/browser.xml
@@ -19,9 +19,6 @@
         <item android:id="@+id/goto_menu_id"
             android:title="@string/goto_dot" 
             android:alphabeticShortcut="l" 
-            android:icon="@*android:drawable/ic_menu_goto" />
-        <item android:id="@+id/search_menu_id"
-            android:title="@string/search"
             android:icon="@android:drawable/ic_menu_search"/>
         <item android:id="@+id/bookmarks_menu_id"
             android:title="@string/bookmarks" 
@@ -34,44 +31,40 @@
             android:icon="@drawable/ic_menu_windows" />
         <item android:id="@+id/stop_reload_menu_id"
             android:alphabeticShortcut="r" />
-        <item android:id="@+id/back_menu_id"
-            android:title="@string/back" 
-            android:alphabeticShortcut="j" 
-            android:icon="@*android:drawable/ic_menu_back" />
-        <item android:id="@+id/close_menu_id"
-            android:title="@string/close" 
-            android:alphabeticShortcut="w" 
-            android:icon="@android:drawable/ic_menu_close_clear_cancel" />
         <item android:id="@+id/forward_menu_id"
             android:title="@string/forward" 
-            android:alphabeticShortcut="k" />
-        <item android:id="@+id/homepage_menu_id"
-            android:title="@string/homepage" 
-            android:alphabeticShortcut="&#32;" 
-            android:icon="@*android:drawable/ic_menu_home" />
-        <item android:id="@+id/classic_history_menu_id"
-            android:icon="@android:drawable/ic_menu_recent_history" 
-            android:alphabeticShortcut="h" 
-            android:title="@string/history" />
-        <item android:id="@+id/view_downloads_menu_id"
-            android:title="@string/menu_view_download" /> 
+            android:alphabeticShortcut="k"
+            android:icon="@*android:drawable/ic_menu_forward" />
         <item android:id="@+id/find_menu_id"
             android:title="@string/find_dot" 
             android:alphabeticShortcut="f" />
         <item android:id="@+id/select_text_id"
             android:title="@string/select_dot" />
         <item android:id="@+id/page_info_menu_id"
-            android:title="@string/page_info" />
-        <item android:id="@+id/bookmark_page_menu_id"
-            android:title="@string/menu_bookmark_page"/>
+            android:title="@string/page_info"
+            android:alphabeticShortcut="g" />
         <item android:id="@+id/share_page_menu_id"
             android:title="@string/share_page"/>
-        <item android:id="@+id/flip_orientation_menu_id"
-            android:title="@string/menu_flip_orientation" /> 
-        <item android:id="@+id/zoom_menu_id"
-            android:title="@string/menu_zoom" />
+        <item android:id="@+id/view_downloads_menu_id"
+            android:title="@string/menu_view_download"
+            android:alphabeticShortcut="d" />
         <item android:id="@+id/preferences_menu_id"
-            android:title="@string/menu_preferences" />
+            android:title="@string/menu_preferences"
+            android:alphabeticShortcut="p" />
+        <!-- followings are debug only -->
+        <item android:id="@+id/dump_nav_menu_id"
+            android:title="@string/dump_nav"
+            android:visible="false" />
+    </group>
+    <group android:id="@+id/MAIN_SHORTCUT_MENU" android:visible="false">
+        <item android:id="@+id/back_menu_id"
+            android:alphabeticShortcut="j" />
+        <item android:id="@+id/close_menu_id"
+            android:alphabeticShortcut="w" />
+        <item android:id="@+id/homepage_menu_id"
+            android:alphabeticShortcut="&#32;" />
+        <item android:id="@+id/classic_history_menu_id"
+            android:alphabeticShortcut="h" />
         <item android:id="@+id/zoom_in_menu_id"
             android:alphabeticShortcut="i" />
         <item android:id="@+id/zoom_out_menu_id"
@@ -92,9 +85,6 @@
             android:alphabeticShortcut="7" />
         <item android:id="@+id/window_eight_menu_id"
             android:alphabeticShortcut="8" />
-        <item android:id="@+id/dump_nav_menu_id"
-            android:title="@string/dump_nav"
-            android:visible="false" />
     </group>
     <group android:id="@+id/TAB_MENU">
         <item android:id="@+id/new_tab_menu_id"
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 334d148..05ed190 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Přihlásit se: <xliff:g id="HOSTNAME">%s1</xliff:g> <xliff:g id="REALM">%s2</xliff:g>"</string>
     <string name="username">"Název"</string>
     <string name="password">"Heslo"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Zastavuji..."</string>
     <string name="stop">"Zastavit"</string>
     <string name="reload">"Obnovit"</string>
-    <string name="back">"Zpět"</string>
     <string name="forward">"Předat dál"</string>
     <string name="save">"OK"</string>
     <string name="do_not_save">"Zrušit"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"Adresa URL není platná."</string>
     <string name="delete_bookmark">"Smazat"</string>
     <string name="bookmark_page">"Přidat poslední zobrazenou stránku do záložek"</string>
-    <string name="current_page">"Aktuální stránka:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Záložka <xliff:g id="BOOKMARK">%s</xliff:g> bude smazána."</string>
     <string name="open_in_new_window">"Otevřít v novém okně"</string>
     <string name="new_window">"Nové okno"</string>
-    <string name="goto_dot">"Přejít na adresu URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Vyhledat na stránce"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Plocha"</string>
     <string name="view_tabs">"Přehled okna"</string>
     <string name="view_tabs_condensed">"Windows"</string>
     <string name="tab_picker_title">"Aktuální okna"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"Přidat do záložek"</string>
     <string name="history">"Historie"</string>
     <string name="menu_view_download">"Stahování"</string>
-    <string name="menu_bookmark_page">"Stránka Záložky"</string>
     <string name="share_page">"Sdílet stránku"</string>
-    <string name="menu_zoom">"Přiblížení"</string>
-    <string name="menu_flip_orientation">"Změnit orientaci"</string>
     <string name="contextmenu_openlink">"Otevřít"</string>
     <string name="contextmenu_openlink_newwindow">"Otevřít v novém okně"</string>
     <string name="contextmenu_bookmark_thislink">"Přidat odkaz do záložek"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Vymazat historii"</string>
     <string name="browser_history">"Nedávno navštívené stránky"</string>
     <string name="empty_history">"Historie prohlížeče je prázdná."</string>
-    <string name="add_new_bookmark">"Nová záložka"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"Databáze neexistuje."</string>
     <string name="search_hint">"Zadejte webovou adresu"</string>
-    <string name="search">"Hledat"</string>
     <string name="search_button_text">"Přejít"</string>
     <string name="attention">"Upozornění"</string>
     <string name="popup_window_attempt">"Tato stránka se pokouší otevřít vyskakovací okno."</string>
@@ -254,6 +261,8 @@
     <string name="download_length_required">"Nelze stáhnout. Velikost položky nelze určit."</string>
     <string name="download_precondition_failed">"Stahování bylo přerušeno a nelze v něm pokračovat."</string>
     <string name="activity_instrumentation_test_runner">"Testovací verze prohlížeče"</string>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"čtení historie a záložek prohlížeče"</string>
     <string name="permdesc_readHistoryBookmarks">"Umožňuje aplikaci číst všechny navštívené adresy URL a záložky prohlížeče."</string>
     <string name="permlab_writeHistoryBookmarks">"zápis historie a záložek prohlížeče"</string>
@@ -263,7 +272,6 @@
     <string name="shortcut_message">"Tento web se na vašem počítači pokouší vytvořit zástupce. Chcete to povolit?"</string>
     <string name="settings_message">"Níže uvedená tabulka zobrazuje oprávnění, která jste udělili jednotlivým webům, které se pokusily použít službu Gears."</string>
     <string name="filepicker_message">"Vybírání souborů služby Gears"</string>
-    <string name="image_message">"Vybraný obrázek"</string>
     <string name="settings_title">"Nastavení služby Gears"</string>
     <string name="privacy_policy">"Chcete-li zjistit, jak bude vaše poloha využita, přečtěte si zásady ochrany osobních údajů těchto stránek."</string>
     <string name="permission_button_alwaysdeny">"Nikdy nepovolit tento web"</string>
@@ -286,4 +294,6 @@
     <string name="denied">"Odepřeno"</string>
     <string name="unrecognized_dialog_message">"Nerozpoznaný typ dialogu"</string>
     <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 6f17c99..b57af1f 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Bei <xliff:g id="HOSTNAME">%s1</xliff:g> \"<xliff:g id="REALM">%s2</xliff:g>\" anmelden"</string>
     <string name="username">"Name"</string>
     <string name="password">"Passwort"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Wird angehalten..."</string>
     <string name="stop">"Anhalten"</string>
     <string name="reload">"Aktualisieren"</string>
-    <string name="back">"Zurück"</string>
     <string name="forward">"Weiter"</string>
     <string name="save">"OK"</string>
     <string name="do_not_save">"Abbrechen"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"URL ist nicht gültig."</string>
     <string name="delete_bookmark">"Löschen"</string>
     <string name="bookmark_page">"Lesezeichen für zuletzt besuchte Seite"</string>
-    <string name="current_page">"Aktuelle Seite:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Lesezeichen \"<xliff:g id="BOOKMARK">%s</xliff:g>\" wird gelöscht."</string>
     <string name="open_in_new_window">"In neuem Fenster öffnen"</string>
     <string name="new_window">"Neues Fenster"</string>
-    <string name="goto_dot">"Gehe zu URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Auf Seite suchen"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Startseite"</string>
     <string name="view_tabs">"Fensterübersicht"</string>
     <string name="view_tabs_condensed">"Windows"</string>
     <string name="tab_picker_title">"Aktuelle Fenster"</string>
@@ -91,12 +101,9 @@
     <string name="tab_picker_send_url">"Link weiterleiten"</string>
     <string name="bookmarks">"Lesezeichen"</string>
     <string name="shortcut_bookmark">"Lesezeichen"</string>
-    <string name="history">"Suchverlauf"</string>
+    <string name="history">"Verlauf"</string>
     <string name="menu_view_download">"Downloads"</string>
-    <string name="menu_bookmark_page">"Lesezeichen-Seite"</string>
     <string name="share_page">"Seitenlink weiterleiten"</string>
-    <string name="menu_zoom">"Zoom"</string>
-    <string name="menu_flip_orientation">"Ausrichtung drehen"</string>
     <string name="contextmenu_openlink">"Öffnen"</string>
     <string name="contextmenu_openlink_newwindow">"In neuem Fenster öffnen"</string>
     <string name="contextmenu_bookmark_thislink">"Lesezeichen-Link"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Verlauf löschen"</string>
     <string name="browser_history">"Zuletzt besuchte Seiten"</string>
     <string name="empty_history">"Browserverlauf ist leer."</string>
-    <string name="add_new_bookmark">"Neues Lesezeichen"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"Keine Datenbank!"</string>
     <string name="search_hint">"Webadresse eingeben"</string>
-    <string name="search">"Suche"</string>
     <string name="search_button_text">"Los"</string>
     <string name="attention">"Achtung"</string>
     <string name="popup_window_attempt">"Diese Website versucht, ein Pop-up-Fenster zu öffnen."</string>
@@ -254,6 +261,8 @@
     <string name="download_length_required">"Download kann nicht gestartet werden, da die Größe des Elements nicht bestimmt werden kann."</string>
     <string name="download_precondition_failed">"Download wurde unterbrochen und kann nicht fortgesetzt werden."</string>
     <string name="activity_instrumentation_test_runner">"Browser Test Runner"</string>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"Browserverlauf und Lesezeichen lesen"</string>
     <string name="permdesc_readHistoryBookmarks">"Ermöglicht der Anwendung, alle URLs, die mit dem Browser besucht wurden, sowie alle Lesezeichen des Browsers zu lesen."</string>
     <string name="permlab_writeHistoryBookmarks">"Browserverlauf und Lesezeichen schreiben"</string>
@@ -263,7 +272,6 @@
     <string name="shortcut_message">"Diese Website möchte einen Shortcut auf Ihrem Computer erstellen. Sind Sie damit einverstanden?"</string>
     <string name="settings_message">"Die folgende Tabelle zeigt die Berechtigungen, die Sie jeder Website erteilt haben, die versucht hat, Gears zu verwenden."</string>
     <string name="filepicker_message">"Gears File Picker"</string>
-    <string name="image_message">"Ausgewähltes Bild"</string>
     <string name="settings_title">"Gears-Einstellungen"</string>
     <string name="privacy_policy">"Lesen Sie die Datenschutzbestimmungen dieser Website, um herauszufinden, wie Ihr Ort verwendet wird."</string>
     <string name="permission_button_alwaysdeny">"Diese Website niemals zulassen"</string>
@@ -286,4 +294,6 @@
     <string name="denied">"Abgelehnt"</string>
     <string name="unrecognized_dialog_message">"Unbekannter Dialogtyp"</string>
     <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index c729504..4cf4ce2 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Acceder a <xliff:g id="HOSTNAME">%s1</xliff:g> \"<xliff:g id="REALM">%s2</xliff:g>\""</string>
     <string name="username">"Nombre"</string>
     <string name="password">"Contraseña"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Deteniendo..."</string>
     <string name="stop">"Detener"</string>
     <string name="reload">"Actualizar"</string>
-    <string name="back">"Anterior"</string>
     <string name="forward">"Siguiente"</string>
     <string name="save">"Aceptar"</string>
     <string name="do_not_save">"Cancelar"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"La URL no es válida."</string>
     <string name="delete_bookmark">"Suprimir"</string>
     <string name="bookmark_page">"Marcar como última página vista"</string>
-    <string name="current_page">"Página actual:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Se eliminará el marcador \"<xliff:g id="BOOKMARK">%s</xliff:g>\"."</string>
     <string name="open_in_new_window">"Abrir en ventana nueva"</string>
     <string name="new_window">"Nueva ventana"</string>
-    <string name="goto_dot">"Ir a URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Buscar en la página"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Página principal"</string>
     <string name="view_tabs">"Visión general de ventanas"</string>
     <string name="view_tabs_condensed">"Windows"</string>
     <string name="tab_picker_title">"Ventanas actuales"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"Marcar"</string>
     <string name="history">"Historial"</string>
     <string name="menu_view_download">"Descargas"</string>
-    <string name="menu_bookmark_page">"Marcar página"</string>
     <string name="share_page">"Compartir página"</string>
-    <string name="menu_zoom">"Zoom"</string>
-    <string name="menu_flip_orientation">"Cambiar orientación"</string>
     <string name="contextmenu_openlink">"Abrir"</string>
     <string name="contextmenu_openlink_newwindow">"Abrir en ventana nueva"</string>
     <string name="contextmenu_bookmark_thislink">"Marcar enlace"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Borrar historial"</string>
     <string name="browser_history">"Páginas visitadas recientemente"</string>
     <string name="empty_history">"El historial del navegador está vacío."</string>
-    <string name="add_new_bookmark">"Marcador nuevo"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"No hay ninguna base de datos."</string>
     <string name="search_hint">"Introduce la dirección web."</string>
-    <string name="search">"Buscar"</string>
     <string name="search_button_text">"Ir"</string>
     <string name="attention">"Atención"</string>
     <string name="popup_window_attempt">"Este sitio está intentando mostrar una ventana emergente."</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"No se puede realizar la descarga, porque no es posible determinar el tamaño del elemento."</string>
     <string name="download_precondition_failed">"La descarga se ha interrumpido y no se puede reanudar."</string>
     <string name="activity_instrumentation_test_runner">"Realizador de pruebas del navegador"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.com/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.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>"New York Times"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.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>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"leer información de marcadores y del historial del navegador"</string>
     <string name="permdesc_readHistoryBookmarks">"Permite que la aplicación lea todas las URL que ha visitado el navegador y todos sus marcadores."</string>
     <string name="permlab_writeHistoryBookmarks">"escribir en marcadores y en el historial del navegador"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"¿Quieres permitir que este sitio web cree un acceso directo en tu equipo?"</string>
     <string name="settings_message">"En la tabla que aparece a continuación se muestran los permisos que has concedido a los distintos sitios web que han intentado utilizar Gears."</string>
     <string name="filepicker_message">"Selector de archivos de Gears"</string>
-    <string name="image_message">"Imagen seleccionada"</string>
     <string name="settings_title">"Configuración de Gears"</string>
     <string name="privacy_policy">"Lee la política de privacidad del sitio para saber cómo se utilizará tu ubicación."</string>
     <string name="permission_button_alwaysdeny">"No permitir nunca este sitio"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"Denegado"</string>
     <string name="unrecognized_dialog_message">"Tipo de cuadro de diálogo no reconocido"</string>
     <string name="default_button">"Aceptar"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index 2a05c4a..e26e86d 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Connectez-vous à <xliff:g id="HOSTNAME">%s1</xliff:g> \"<xliff:g id="REALM">%s2</xliff:g>\""</string>
     <string name="username">"Nom"</string>
     <string name="password">"Mot de passe"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Arrêt..."</string>
     <string name="stop">"Interrompre"</string>
     <string name="reload">"Actualiser"</string>
-    <string name="back">"Précédent"</string>
     <string name="forward">"Suivant"</string>
     <string name="save">"OK"</string>
     <string name="do_not_save">"Annuler"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"L\'URL est incorrecte."</string>
     <string name="delete_bookmark">"Supprimer"</string>
     <string name="bookmark_page">"Dernière page de favori consultée"</string>
-    <string name="current_page">"Page actuelle :"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Le favori \"<xliff:g id="BOOKMARK">%s</xliff:g>\" sera supprimé."</string>
     <string name="open_in_new_window">"Ouvrir dans une nouvelle fenêtre"</string>
     <string name="new_window">"Nouvelle fenêtre"</string>
-    <string name="goto_dot">"Accéder à l\'URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Rechercher sur la page"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Page d\'accueil"</string>
     <string name="view_tabs">"Vue d\'ensemble des fenêtres"</string>
     <string name="view_tabs_condensed">"Windows"</string>
     <string name="tab_picker_title">"Fenêtres actuelles"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"Favori"</string>
     <string name="history">"Historique"</string>
     <string name="menu_view_download">"Téléchargements"</string>
-    <string name="menu_bookmark_page">"Page de favori"</string>
     <string name="share_page">"Partager la page"</string>
-    <string name="menu_zoom">"Zoom"</string>
-    <string name="menu_flip_orientation">"Changer l\'orientation"</string>
     <string name="contextmenu_openlink">"Ouvrir"</string>
     <string name="contextmenu_openlink_newwindow">"Ouvrir une nouvelle fenêtre"</string>
     <string name="contextmenu_bookmark_thislink">"Lien du favori"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Effacer l\'historique"</string>
     <string name="browser_history">"Dernières pages consultées"</string>
     <string name="empty_history">"L\'historique du navigateur est vide."</string>
-    <string name="add_new_bookmark">"Nouveau favori"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"Aucune base de données !"</string>
     <string name="search_hint">"Saisir l\'adresse Web"</string>
-    <string name="search">"Rechercher"</string>
     <string name="search_button_text">"Aller"</string>
     <string name="attention">"Attention"</string>
     <string name="popup_window_attempt">"Le site tente d\'ouvrir une fenêtre contextuelle."</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"Téléchargement impossible. La taille de l\'élément n\'a pas pu être déterminée."</string>
     <string name="download_precondition_failed">"Téléchargement interrompu. Impossible de reprendre le téléchargement."</string>
     <string name="activity_instrumentation_test_runner">"Testeur de navigateur"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.com/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.com/"</item>
-    <item>"Facebook"</item>
-    <item>"http://www.facebook.com/"</item>
-    <item>"Wikipédia"</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>"New York Times"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.com/"</item>
-    <item>"Amazon"</item>
-    <item>"http://www.amazon.com/"</item>
-    <item>"Météo"</item>
-    <item>"http://www.weather.com/"</item>
-    <item>"BBC"</item>
-    <item>"http://www.bbc.co.uk/"</item>
-  </string-array>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"lire l\'historique du navigateur et les favoris"</string>
     <string name="permdesc_readHistoryBookmarks">"Permet à l\'application de lire toutes les URL visitées par le navigateur et tous les favoris."</string>
     <string name="permlab_writeHistoryBookmarks">"écrire l\'historique du navigateur et les favoris"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"Voulez-vous autoriser ce site Web à créer un raccourci sur votre ordinateur ?"</string>
     <string name="settings_message">"Le tableau ci-dessous indique les fonctions que vous avez autorisées pour chaque site ayant tenté d\'utiliser Google Gears."</string>
     <string name="filepicker_message">"Sélecteur de fichiers Google Gears"</string>
-    <string name="image_message">"Image sélectionnée"</string>
     <string name="settings_title">"Paramètres Google Gears"</string>
     <string name="privacy_policy">"Lisez la politique de confidentialité du site pour voir comment votre emplacement sera utilisé."</string>
     <string name="permission_button_alwaysdeny">"Ne jamais autoriser ce site"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"Refusé"</string>
     <string name="unrecognized_dialog_message">"Type de boîte de dialogue inconnu"</string>
     <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 61f00e3..1f58874 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Accedi a <xliff:g id="HOSTNAME">%s1</xliff:g> \"<xliff:g id="REALM">%s2</xliff:g>\""</string>
     <string name="username">"Nome"</string>
     <string name="password">"Password"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Interruzione..."</string>
     <string name="stop">"Interrompi"</string>
     <string name="reload">"Aggiorna"</string>
-    <string name="back">"Indietro"</string>
     <string name="forward">"Avanti"</string>
     <string name="save">"OK"</string>
     <string name="do_not_save">"Annulla"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"URL non valido."</string>
     <string name="delete_bookmark">"Elimina"</string>
     <string name="bookmark_page">"Aggiungi ultima pagina visualizzata in segnalibri"</string>
-    <string name="current_page">"Pagina corrente:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Il segnalibro \"<xliff:g id="BOOKMARK">%s</xliff:g>\" verrà eliminato."</string>
     <string name="open_in_new_window">"Apri in nuova finestra"</string>
     <string name="new_window">"Nuova finestra"</string>
-    <string name="goto_dot">"Vai a URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Trova nella pagina"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Home page"</string>
     <string name="view_tabs">"Anteprima finestre"</string>
     <string name="view_tabs_condensed">"Finestre"</string>
     <string name="tab_picker_title">"Finestre correnti"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"Segnalibro"</string>
     <string name="history">"Cronologia"</string>
     <string name="menu_view_download">"Download"</string>
-    <string name="menu_bookmark_page">"Pagina segnalibri"</string>
     <string name="share_page">"Condividi pagina"</string>
-    <string name="menu_zoom">"Zoom"</string>
-    <string name="menu_flip_orientation">"Capovolgi orientamento"</string>
     <string name="contextmenu_openlink">"Apri"</string>
     <string name="contextmenu_openlink_newwindow">"Apri in nuova finestra"</string>
     <string name="contextmenu_bookmark_thislink">"Aggiungi link in segnalibri"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Cancella cronologia"</string>
     <string name="browser_history">"Pagine visitate di recente"</string>
     <string name="empty_history">"La cronologia del browser è vuota."</string>
-    <string name="add_new_bookmark">"Nuovo segnalibro"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"Nessun database"</string>
     <string name="search_hint">"Digita l\'indirizzo web"</string>
-    <string name="search">"Cerca"</string>
     <string name="search_button_text">"Vai"</string>
     <string name="attention">"Attenzione"</string>
     <string name="popup_window_attempt">"Il sito sta tentando di aprire una finestra pop-up."</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"Impossibile effettuare il download. Impossibile determinare le dimensioni dell\'elemento."</string>
     <string name="download_precondition_failed">"Download interrotto. Impossibile ripristinarlo."</string>
     <string name="activity_instrumentation_test_runner">"Browser Test Runner"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.com/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.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>"New York Times"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.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>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"leggere cronologia e segnalibri del browser"</string>
     <string name="permdesc_readHistoryBookmarks">"Consente all\'applicazione di leggere tutti gli URL visitati e tutti i segnalibri del browser."</string>
     <string name="permlab_writeHistoryBookmarks">"creare cronologia e segnalibri del browser"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"Il sito web desidera creare un collegamento sul computer. Consenti questa operazione?"</string>
     <string name="settings_message">"Nella tabella che segue vengono riportate le autorizzazioni concesse a ogni sito che ha provato a usare Gears."</string>
     <string name="filepicker_message">"Selettore file Gears"</string>
-    <string name="image_message">"Immagine selezionata"</string>
     <string name="settings_title">"Impostazioni Gears"</string>
     <string name="privacy_policy">"Per conoscere la modalità di utilizzo della tua posizione, leggi le norme sulla privacy del sito."</string>
     <string name="permission_button_alwaysdeny">"Non consentire mai il sito"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"Negato"</string>
     <string name="unrecognized_dialog_message">"Tipo di finestra non riconosciuto"</string>
     <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 01274d9..1fc66d2 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"<xliff:g id="HOSTNAME">%s1</xliff:g>に「<xliff:g id="REALM">%s2</xliff:g>」でログイン"</string>
     <string name="username">"名前"</string>
     <string name="password">"パスワード"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"停止中..."</string>
     <string name="stop">"停止"</string>
     <string name="reload">"リフレッシュ"</string>
-    <string name="back">"戻る"</string>
     <string name="forward">"進む"</string>
     <string name="save">"OK"</string>
     <string name="do_not_save">"キャンセル"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"無効なURLです。"</string>
     <string name="delete_bookmark">"削除"</string>
     <string name="bookmark_page">"最後に表示したページをブックマークする"</string>
-    <string name="current_page">"現在のページ:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"ブックマーク「<xliff:g id="BOOKMARK">%s</xliff:g>」を削除します。"</string>
     <string name="open_in_new_window">"新しいウィンドウで開く"</string>
     <string name="new_window">"新しいウィンドウ"</string>
-    <string name="goto_dot">"URLに移動"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"このページの検索"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"ホームページ"</string>
     <string name="view_tabs">"ウィンドウリスト"</string>
     <string name="view_tabs_condensed">"ウィンドウ"</string>
     <string name="tab_picker_title">"現在のウィンドウ"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"ブックマーク"</string>
     <string name="history">"履歴"</string>
     <string name="menu_view_download">"ダウンロード"</string>
-    <string name="menu_bookmark_page">"ページをブックマーク"</string>
     <string name="share_page">"ページを共有"</string>
-    <string name="menu_zoom">"ズーム"</string>
-    <string name="menu_flip_orientation">"画面の向きを変更"</string>
     <string name="contextmenu_openlink">"開く"</string>
     <string name="contextmenu_openlink_newwindow">"新しいウィンドウで開く"</string>
     <string name="contextmenu_bookmark_thislink">"リンクをブックマーク"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"履歴をクリア"</string>
     <string name="browser_history">"最近閲覧したページ"</string>
     <string name="empty_history">"ブラウザ履歴はありません。"</string>
-    <string name="add_new_bookmark">"新しいブックマーク"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"データベースがありません。"</string>
     <string name="search_hint">"ウェブアドレスを入力してください"</string>
-    <string name="search">"検索"</string>
     <string name="search_button_text">"移動"</string>
     <string name="attention">"注意"</string>
     <string name="popup_window_attempt">"このサイトはポップアップウィンドウを開こうとしています。"</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"項目のサイズを特定できないため、ダウンロードできません。"</string>
     <string name="download_precondition_failed">"ダウンロードが中断されました。再開できません。"</string>
     <string name="activity_instrumentation_test_runner">"Browser Test Runner"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.com/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.com/"</item>
-    <item>"Facebook"</item>
-    <item>"http://www.facebook.com/"</item>
-    <item>"ウィキペディア"</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>"New York Times"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.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>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"ブラウザの履歴とブックマークの読み取り"</string>
     <string name="permdesc_readHistoryBookmarks">"ブラウザでアクセスしたすべてのURLとブックマークの読み取りをアプリケーションに許可します。"</string>
     <string name="permlab_writeHistoryBookmarks">"ブラウザの履歴とブックマークの書き込み"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"このウェブサイトはコンピュータ上にショートカットを作成しようとしています。作成を許可しますか？"</string>
     <string name="settings_message">"Gearsを使用しようとしたサイトに許可した権限は、以下の表のとおりです。"</string>
     <string name="filepicker_message">"Gears File Picker"</string>
-    <string name="image_message">"選択した画像"</string>
     <string name="settings_title">"Gears設定"</string>
     <string name="privacy_policy">"サイトのプライバシーポリシーを読んで、現在地の情報がどのように使用されるのか確認してください。"</string>
     <string name="permission_button_alwaysdeny">"このサイトを常に拒否する"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"拒否されました"</string>
     <string name="unrecognized_dialog_message">"不明な種類のダイアログです"</string>
     <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
new file mode 100644
index 0000000..05aba8a
--- /dev/null
+++ b/res/values-ko/strings.xml
@@ -0,0 +1,299 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2009 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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for application_name (1935869255545976415) -->
+    <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
+    <string name="sign_in_to">"<xliff:g id="HOSTNAME">%s1</xliff:g> \'<xliff:g id="REALM">%s2</xliff:g>\'에 로그인"</string>
+    <string name="username">"이름"</string>
+    <string name="password">"비밀번호"</string>
+    <string name="action">"로그인"</string>
+    <string name="cancel">"취소"</string>
+    <string name="ok">"확인"</string>
+    <string name="matches_found">"개 일치"</string>
+    <string name="zero">"없음"</string>
+    <string name="page_info">"페이지 정보"</string>
+    <string name="page_info_view">"페이지 정보 보기"</string>
+    <string name="page_info_address">"주소:"</string>
+    <string name="ssl_warnings_header">"사이트의 보안 인증서에 문제가 있습니다."</string>
+    <string name="ssl_continue">"계속"</string>
+    <string name="security_warning">"보안 경고"</string>
+    <string name="view_certificate">"인증서 보기"</string>
+    <string name="ssl_untrusted">"신뢰된 인증기관에서 발급된 인증서가 아닙니다."</string>
+    <string name="ssl_mismatch">"사이트의 이름이 인증서에 있는 이름과 일치하지 않습니다."</string>
+    <string name="ssl_expired">"만료된 인증서입니다."</string>
+    <string name="ssl_not_yet_valid">"아직 유효하지 않은 인증서입니다."</string>
+    <string name="ssl_certificate">"보안 인증서"</string>
+    <string name="ssl_certificate_is_valid">"유효한 인증서입니다."</string>
+    <string name="issued_to">"발급 대상:"</string>
+    <string name="common_name">"일반 이름:"</string>
+    <string name="org_name">"조직:"</string>
+    <string name="org_unit">"조직 구성 단위:"</string>
+    <string name="issued_by">"발급자:"</string>
+    <string name="validity_period">"유효성:"</string>
+    <string name="issued_on">"발급일:"</string>
+    <string name="expires_on">"만료일:"</string>
+    <string name="retrieving_creds_dlg_msg">"로그인 세부정보를 가져오는 중..."</string>
+    <string name="close">"닫기"</string>
+    <string name="close_window">"창이 닫힙니다."</string>
+    <string name="stopping">"중지하는 중..."</string>
+    <string name="stop">"중지"</string>
+    <string name="reload">"새로고침"</string>
+    <string name="forward">"앞으로"</string>
+    <string name="save">"확인"</string>
+    <string name="do_not_save">"취소"</string>
+    <string name="location">"위치"</string>
+    <string name="name">"이름"</string>
+    <string name="http">"http://"</string>
+    <string name="save_to_bookmarks">"북마크"</string>
+    <string name="edit_bookmark">"북마크 수정"</string>
+    <string name="create_shortcut_bookmark">"홈에 바로가기 추가"</string>
+    <string name="open_bookmark">"열기"</string>
+    <string name="remove_bookmark">"북마크 삭제"</string>
+    <string name="remove_history_item">"기록에서 제거"</string>
+    <string name="bookmark_saved">"북마크에 저장되었습니다."</string>
+    <string name="bookmark_needs_title">"북마크에는 이름이 있어야 합니다."</string>
+    <string name="bookmark_needs_url">"북마크에는 위치가 있어야 합니다."</string>
+    <string name="empty_bookmark">"빈 북마크는 만들 수 없습니다."</string>
+    <string name="bookmark_url_not_valid">"URL이 올바르지 않습니다."</string>
+    <string name="delete_bookmark">"삭제"</string>
+    <string name="bookmark_page">"마지막으로 본 페이지를 북마크 설정"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
+    <string name="delete_bookmark_warning">"\'<xliff:g id="BOOKMARK">%s</xliff:g>\' 북마크가 삭제됩니다."</string>
+    <string name="open_in_new_window">"새 창에서 열기"</string>
+    <string name="new_window">"새 창"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
+    <string name="find_dot">"검색 페이지"</string>
+    <!-- no translation found for select_dot (6299170761900561967) -->
+    <skip />
+    <string name="view_tabs">"창 세부정보"</string>
+    <string name="view_tabs_condensed">"Windows"</string>
+    <string name="tab_picker_title">"현재 창"</string>
+    <string name="tab_picker_view_tab">"보기"</string>
+    <string name="tab_picker_new_tab">"새 창"</string>
+    <string name="tab_picker_remove_tab">"닫기"</string>
+    <string name="tab_picker_bookmark">"북마크"</string>
+    <string name="tab_picker_send_url">"링크 공유"</string>
+    <string name="bookmarks">"북마크"</string>
+    <string name="shortcut_bookmark">"북마크"</string>
+    <string name="history">"기록"</string>
+    <string name="menu_view_download">"다운로드"</string>
+    <string name="share_page">"페이지 공유"</string>
+    <string name="contextmenu_openlink">"열기"</string>
+    <string name="contextmenu_openlink_newwindow">"새 창에서 열기"</string>
+    <string name="contextmenu_bookmark_thislink">"북마크 링크"</string>
+    <string name="contextmenu_savelink">"링크 저장"</string>
+    <string name="contextmenu_sharelink">"링크 공유"</string>
+    <string name="contextmenu_copy">"복사"</string>
+    <string name="contextmenu_copylink">"링크 URL 복사"</string>
+    <string name="contextmenu_download_image">"이미지 저장"</string>
+    <string name="contextmenu_view_image">"이미지 보기"</string>
+    <string name="contextmenu_dial_dot">"전화 걸기..."</string>
+    <string name="contextmenu_add_contact">"연락처 추가"</string>
+    <string name="contextmenu_send_mail">"이메일 보내기"</string>
+    <string name="contextmenu_map">"지도"</string>
+    <string name="clear">"지우기"</string>
+    <string name="replace">"기존 URL"</string>
+    <string name="browser_bookmarks_page_bookmarks_text">"북마크"</string>
+    <string name="menu_preferences">"설정"</string>
+    <string name="pref_content_title">"페이지 내용 설정"</string>
+    <string name="pref_content_load_images">"이미지 로드"</string>
+    <string name="pref_content_load_images_summary">"웹페이지에 이미지 표시"</string>
+    <string name="pref_content_block_popups">"팝업 창 차단"</string>
+    <string name="pref_content_javascript">"자바스크립트 활성화"</string>
+    <string name="pref_content_open_in_background">"배경에서 열기"</string>
+    <string name="pref_content_open_in_background_summary">"새 창이 현재 창 뒤쪽에 열립니다."</string>
+    <string name="pref_content_homepage">"홈페이지 설정"</string>
+    <string name="pref_content_autofit">"페이지 자동 맞춤"</string>
+    <string name="pref_content_autofit_summary">"화면에 맞게 웹페이지의 형식 조정"</string>
+    <string name="pref_privacy_title">"개인정보보호 설정"</string>
+    <string name="pref_privacy_clear_cache">"캐시 지우기"</string>
+    <string name="pref_privacy_clear_cache_summary">"캐시된 모든 페이지 콘텐츠 삭제"</string>
+    <string name="pref_privacy_clear_cache_dlg">"캐시가 지워집니다."</string>
+    <string name="pref_privacy_clear_cookies">"모든 쿠키 데이터 지우기"</string>
+    <string name="pref_privacy_clear_cookies_summary">"모든 브라우저 쿠키 지우기"</string>
+    <string name="pref_privacy_clear_cookies_dlg">"모든 쿠키가 지워집니다."</string>
+    <string name="pref_privacy_clear_history">"기록 지우기"</string>
+    <string name="pref_privacy_clear_history_summary">"브라우저 탐색 기록 지우기"</string>
+    <string name="pref_privacy_clear_history_dlg">"브라우저 탐색 기록이 지워집니다."</string>
+    <string name="pref_privacy_clear_form_data">"양식 데이터 지우기"</string>
+    <string name="pref_privacy_clear_form_data_summary">"저장된 양식 데이터 모두 지우기"</string>
+    <string name="pref_privacy_clear_form_data_dlg">"저장된 양식 데이터가 모두 지워집니다."</string>
+    <string name="pref_privacy_clear_passwords">"비밀번호 지우기"</string>
+    <string name="pref_privacy_clear_passwords_summary">"저장된 비밀번호 모두 지우기"</string>
+    <string name="pref_privacy_clear_passwords_dlg">"저장된 비밀번호가 모두 지워집니다."</string>
+    <string name="pref_security_title">"보안 설정"</string>
+    <string name="pref_security_remember_passwords">"비밀번호 기억"</string>
+    <string name="pref_security_remember_passwords_summary">"웹사이트의 사용자 이름과 비밀번호 저장"</string>
+    <string name="pref_security_save_form_data">"양식 데이터 기억"</string>
+    <string name="pref_security_save_form_data_summary">"나중에 사용할 수 있도록 양식에 입력한 데이터 기억"</string>
+    <string name="pref_security_show_security_warning">"보안 경고 표시"</string>
+    <string name="pref_security_show_security_warning_summary">"사이트의 보안에 문제가 있는 경우 경고 표시"</string>
+    <string name="pref_security_accept_cookies">"쿠키 허용"</string>
+    <string name="pref_security_accept_cookies_summary">"사이트에서 \'쿠키\' 데이터를 저장하고 읽을 수 있도록 허용"</string>
+    <string name="pref_text_size">"텍스트 크기 설정"</string>
+  <string-array name="pref_text_size_choices">
+    <item>"매우 작게"</item>
+    <item>"작게"</item>
+    <item>"보통"</item>
+    <item>"크게"</item>
+    <item>"매우 크게"</item>
+  </string-array>
+    <string name="pref_text_size_dialogtitle">"텍스트 크기"</string>
+    <string name="pref_extras_title">"고급 설정"</string>
+    <string name="pref_extras_gears_enable">"Gears 활성화"</string>
+    <string name="pref_extras_gears_enable_summary">"브라우저 기능을 확장하는 응용프로그램"</string>
+    <string name="pref_extras_gears_settings">"Gears 설정"</string>
+    <string name="pref_plugin_installed">"플러그인 목록"</string>
+    <string name="pref_plugin_installed_empty_list">"설치된 플러그인이 없습니다."</string>
+    <string name="pref_extras_gears_settings_summary">"브라우저 기능을 확장하는 응용프로그램"</string>
+    <string name="pref_extras_reset_default">"기본값으로 재설정"</string>
+    <string name="pref_extras_reset_default_summary">"모든 브라우저 데이터를 지우고 모든 설정을 기본값으로 재설정"</string>
+    <string name="pref_extras_reset_default_dlg">"모든 브라우저 데이터가 지워지고 설정이 기본값으로 돌아갑니다."</string>
+    <string name="pref_extras_reset_default_dlg_title">"기본값으로 재설정"</string>
+    <string name="pref_development_title">"디버그"</string>
+    <string name="pref_development_viewport">"Use wide viewport"</string>
+    <string name="pref_development_single_column_rendering">"Single column rendering"</string>
+    <string name="pref_development_normal_rendering">"Normal rendering"</string>
+    <string name="pref_development_trace">"Enable tracing"</string>
+    <string name="pref_development_nav_dump">"Enable nav cache dump"</string>
+    <string name="pref_development_search_url">"검색 URL 설정"</string>
+    <string name="pref_development_uastring">"UAString"</string>
+  <string-array name="pref_development_ua_choices">
+    <item>"Android"</item>
+    <item>"Desktop"</item>
+    <item>"iPhone"</item>
+  </string-array>
+  <string-array name="pref_development_ua_values">
+    <item>"0"</item>
+    <item>"1"</item>
+    <item>"2"</item>
+  </string-array>
+    <string name="pref_default_text_encoding">"텍스트 인코딩 설정"</string>
+  <string-array name="pref_default_text_encoding_choices">
+    <item>"라틴어-1(ISO-8859-1)"</item>
+    <item>"유니코드(UTF-8)"</item>
+    <item>"일본어(ISO-2022-JP)"</item>
+    <item>"일본어(SHIFT_JIS)"</item>
+    <item>"일본어(EUC-JP)"</item>
+  </string-array>
+    <string name="pref_default_text_encoding_dialogtitle">"텍스트 인코딩"</string>
+    <string name="pref_default_text_encoding_default">"라틴어-1"</string>
+    <string name="browserFrameRedirect">"리디렉션"</string>
+    <string name="browserFrame307Post">"웹페이지가 리디렉션됩니다. 입력한 양식 데이터를 새 위치로 다시 보내시겠습니까?"</string>
+    <string name="browserFrameNetworkErrorLabel">"데이터 연결 문제"</string>
+    <string name="browserFrameFileErrorLabel">"파일 문제 발생"</string>
+    <string name="browserFrameFormResubmitLabel">"확인"</string>
+    <string name="browserFrameFormResubmitMessage">"보려는 페이지에 이미 제출된 데이터(\'POSTDATA\')가 포함되어 있습니다. 데이터를 다시 보내면 페이지의 양식에서 수행한 작업(예: 검색 또는 온라인 구매)이 반복됩니다."</string>
+    <string name="loadSuspendedTitle">"네트워크 연결 없음"</string>
+    <string name="loadSuspended">"연결이 복원된 후에 페이지 로드가 계속됩니다."</string>
+    <string name="clear_history">"기록 지우기"</string>
+    <string name="browser_history">"최근에 방문한 페이지"</string>
+    <string name="empty_history">"브라우저 기록이 비어 있습니다."</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
+    <string name="no_database">"데이터베이스 없음"</string>
+    <string name="search_hint">"웹 주소 입력"</string>
+    <string name="search_button_text">"이동"</string>
+    <string name="attention">"주의"</string>
+    <string name="popup_window_attempt">"사이트에서 팝업 창을 열려고 합니다."</string>
+    <string name="allow">"허용"</string>
+    <string name="block">"차단"</string>
+    <string name="too_many_windows_dialog_title">"창 개수 제한에 도달했습니다."</string>
+    <string name="too_many_windows_dialog_message">"이미 최대 개수의 창을 열었기 때문에 새 창을 열 수 없습니다."</string>
+    <string name="too_many_subwindows_dialog_title">"팝업이 이미 열려 있습니다."</string>
+    <string name="too_many_subwindows_dialog_message">"팝업 창은 하나만 열 수 있기 때문에 새 팝업 창을 열 수 없습니다."</string>
+    <string name="download_title">"다운로드 기록"</string>
+    <string name="download_unknown_filename">"&lt;알 수 없음&gt;"</string>
+    <string name="download_menu_open">"열기"</string>
+    <string name="download_menu_clear">"목록에서 지우기"</string>
+    <string name="download_menu_cancel">"다운로드 취소"</string>
+    <string name="download_menu_cancel_all">"모든 다운로드 취소"</string>
+    <string name="download_menu_clear_all">"목록 지우기"</string>
+    <string name="download_clear_dlg_title">"지우기"</string>
+    <string name="download_clear_dlg_msg">"목록에서 모든 항목이 지워지고 브라우저 캐시에서 제거됩니다."</string>
+    <string name="download_cancel_dlg_title">"다운로드 취소"</string>
+    <string name="download_cancel_dlg_msg">"<xliff:g id="DOWNLOAD_COUNT">%d</xliff:g>개의 다운로드가 모두 취소되고 다운로드 기록에서 지워집니다."</string>
+    <string name="download_file_error_dlg_title">"공간 부족"</string>
+    <string name="download_file_error_dlg_msg">"<xliff:g id="FILENAME">%s</xliff:g>을(를) 다운로드하지 못했습니다."\n"전화기에서 여유 공간을 늘린 후에 다시 시도하세요."</string>
+    <string name="download_failed_generic_dlg_title">"다운로드 실패"</string>
+    <string name="download_no_sdcard_dlg_title">"SD 카드 없음"</string>
+    <string name="download_no_sdcard_dlg_msg">"<xliff:g id="FILENAME">%s</xliff:g>을(를) 다운로드하려면 SD 카드가 필요합니다."</string>
+    <string name="download_sdcard_busy_dlg_title">"SD 카드를 사용할 수 없음"</string>
+    <string name="download_sdcard_busy_dlg_msg">"SD 카드가 사용 중입니다. 다운로드를 허용하려면 홈 &gt; 설정 &gt; SD 카드 및 전화기 저장공간으로 이동하여 \'USB 저장에 사용\' 확인란을 선택취소하세요."</string>
+    <string name="download_no_application">"파일을 열 수 있는 응용프로그램이 없습니다."</string>
+    <string name="retry">"다시 시도"</string>
+    <string name="no_downloads">"다운로드 기록이 비어 있습니다."</string>
+    <string name="download_error">"다운로드 실패"</string>
+    <string name="download_success">"<xliff:g id="FILE">%s</xliff:g> 다운로드 완료"</string>
+    <string name="download_running">"다운로드 중..."</string>
+    <string name="download_pending">"다운로드 시작 중..."</string>
+    <string name="download_pending_network">"데이터 연결을 기다리는 중..."</string>
+    <string name="download_running_paused">"데이터 연결을 기다리는 중..."</string>
+    <string name="download_canceled">"다운로드가 취소되었습니다."</string>
+    <string name="download_not_acceptable">"다운로드할 수 없습니다. 전화기에서 지원하지 않는 콘텐츠입니다."</string>
+    <string name="download_file_error">"공간이 부족하여 다운로드를 완료할 수 없습니다."</string>
+    <string name="download_length_required">"항목의 크기를 확인할 수 없으므로 다운로드할 수 없습니다."</string>
+    <string name="download_precondition_failed">"다운로드 중단됨. 다시 시작할 수 없습니다."</string>
+    <string name="activity_instrumentation_test_runner">"브라우저 테스트 실행기"</string>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
+    <string name="permlab_readHistoryBookmarks">"브라우저의 기록 및 북마크 읽기"</string>
+    <string name="permdesc_readHistoryBookmarks">"응용프로그램이 브라우저에서 방문한 모든 URL과 브라우저의 북마크를 모두 읽을 수 있습니다."</string>
+    <string name="permlab_writeHistoryBookmarks">"브라우저의 기록 및 북마크 쓰기"</string>
+    <string name="permdesc_writeHistoryBookmarks">"응용프로그램이 전화기에 저장된 브라우저의 기록 또는 북마크를 수정할 수 있습니다. 악성 응용프로그램은 이 기능을 이용하여 브라우저의 데이터를 지우거나 수정할 수 있습니다."</string>
+    <string name="query_data_message">"아래 웹사이트가 Gears를 사용하여 컴퓨터에 정보를 저장하려고 합니다."</string>
+    <string name="location_message">"아래 웹사이트가 Gears를 사용하여 사용자 위치에 대한 정보에 액세스하려고 합니다."</string>
+    <string name="shortcut_message">"웹사이트가 컴퓨터에 바로가기를 만들려고 합니다. 허용하시겠습니까?"</string>
+    <string name="settings_message">"아래 표는 Gears를 사용하려고 시도한 각 사이트에 부여한 권한을 보여줍니다."</string>
+    <string name="filepicker_message">"Gears 파일 선택기"</string>
+    <string name="settings_title">"Gears 설정"</string>
+    <string name="privacy_policy">"위치가 어떻게 사용되는지 보려면 사이트의 개인정보 보호정책을 읽어보세요."</string>
+    <string name="permission_button_alwaysdeny">"이 사이트를 허용하지 않음"</string>
+    <string name="permission_button_allow">"허용"</string>
+    <string name="permission_button_deny">"거부"</string>
+    <string name="shortcut_button_alwaysdeny">"이 바로가기를 허용하지 않음"</string>
+    <string name="shortcut_button_allow">"확인"</string>
+    <string name="shortcut_button_deny">"취소"</string>
+    <string name="settings_button_allow">"적용"</string>
+    <string name="settings_button_deny">"취소"</string>
+    <string name="filepicker_button_allow">"확인"</string>
+    <string name="filepicker_button_deny">"취소"</string>
+    <string name="filepicker_path">"경로:"</string>
+    <string name="filepicker_no_files_selected">"선택한 파일이 없습니다."</string>
+    <string name="filepicker_one_file_selected">"1개 파일 선택됨"</string>
+    <string name="filepicker_some_files_selected">"개 파일 선택됨"</string>
+    <string name="remove">"제거"</string>
+    <string name="local_storage">"로컬 저장공간"</string>
+    <string name="allowed">"허용됨"</string>
+    <string name="denied">"거부됨"</string>
+    <string name="unrecognized_dialog_message">"인식할 수 없는 대화상자 유형"</string>
+    <string name="default_button">"확인"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
+</resources>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
new file mode 100644
index 0000000..7ac84e6
--- /dev/null
+++ b/res/values-nb/strings.xml
@@ -0,0 +1,295 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (C) 2009 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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="application_name">"Nettleser"</string>
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
+    <string name="sign_in_to">"Logg inn på <xliff:g id="HOSTNAME">%s1</xliff:g> \\\"<xliff:g id="REALM">%s2</xliff:g>\\\""</string>
+    <string name="username">"Brukernavn"</string>
+    <string name="password">"Passord"</string>
+    <string name="action">"Logg inn"</string>
+    <string name="cancel">"Avbryt"</string>
+    <string name="ok">"OK"</string>
+    <string name="matches_found">"treff"</string>
+    <string name="zero">"Ingen"</string>
+    <string name="page_info">"Sideinformasjon"</string>
+    <string name="page_info_view">"Vis sideinformasjon"</string>
+    <string name="page_info_address">"Adresse:"</string>
+    <string name="ssl_warnings_header">"Det er problemer med sertifikatet for denne siden."</string>
+    <string name="ssl_continue">"Fortsett"</string>
+    <string name="security_warning">"Sikkerhetsadvarsel"</string>
+    <string name="view_certificate">"Se på sertifikat"</string>
+    <string name="ssl_untrusted">"Dette sertifikatet er ikke fra en autoritet du stoler på."</string>
+    <string name="ssl_mismatch">"Navnet på siden stemmer ikke med navnet på sertifikatet."</string>
+    <string name="ssl_expired">"Sertifikatet har gått ut."</string>
+    <string name="ssl_not_yet_valid">"Sertifikatet er ikke gyldig ennå."</string>
+    <string name="ssl_certificate">"Sikkerhetssertifikat"</string>
+    <string name="ssl_certificate_is_valid">"Sertifikatet er gyldig."</string>
+    <string name="issued_to">"Utstedt til:"</string>
+    <string name="common_name">"Navn:"</string>
+    <string name="org_name">"Organisasjon:"</string>
+    <string name="org_unit">"Organisasjonsenhet:"</string>
+    <string name="issued_by">"Utstedt av:"</string>
+    <string name="validity_period">"Gyldighet:"</string>
+    <string name="issued_on">"Utstedt:"</string>
+    <string name="expires_on">"Går ut:"</string>
+    <string name="retrieving_creds_dlg_msg">"Henter innloggingsinformasjon…"</string>
+    <string name="close">"Lukk"</string>
+    <string name="close_window">"Dette vinduet vil bli lukket."</string>
+    <string name="stopping">"Avbryter…"</string>
+    <string name="stop">"Avbryt"</string>
+    <string name="reload">"Last på nytt"</string>
+    <string name="forward">"Forover"</string>
+    <string name="save">"OK"</string>
+    <string name="do_not_save">"Avbryt"</string>
+    <string name="location">"Adresse"</string>
+    <string name="name">"Navn"</string>
+    <string name="http">"http://"</string>
+    <string name="save_to_bookmarks">"Bokmerke"</string>
+    <string name="edit_bookmark">"Rediger bokmerke"</string>
+    <string name="create_shortcut_bookmark">"Lag snarvei på skrivebordet"</string>
+    <string name="open_bookmark">"Åpne"</string>
+    <string name="remove_bookmark">"Slett bokmerke"</string>
+    <string name="remove_history_item">"Fjern fra loggen"</string>
+    <string name="bookmark_saved">"Bokmerke lagret."</string>
+    <string name="bookmark_needs_title">"Bokmerket må ha et navn."</string>
+    <string name="bookmark_needs_url">"Bokmerket må ha en adresse."</string>
+    <string name="empty_bookmark">"Kan ikke lage tomt bokmerke."</string>
+    <string name="bookmark_url_not_valid">"Adressen er ikke gyldig."</string>
+    <string name="delete_bookmark">"Slett"</string>
+    <string name="bookmark_page">"Legg til bokmerke for sist sette side"</string>
+    <string name="current_page">"Gjeldende side:"</string>
+    <string name="delete_bookmark_warning">"Bokmerket \\\"<xliff:g id="BOOKMARK">%s</xliff:g>\\\" vil bli slettet."</string>
+    <string name="open_in_new_window">"Åpne i nytt vindu"</string>
+    <string name="new_window">"Nytt vindu"</string>
+    <string name="goto_dot">"Gå til URL"</string>
+    <string name="find_dot">"Finn på siden"</string>
+    <!-- no translation found for select_dot (6299170761900561967) -->
+    <skip />
+    <string name="view_tabs">"Vindusoversikt"</string>
+    <string name="view_tabs_condensed">"Vinduer"</string>
+    <string name="tab_picker_title">"Gjeldende vinduer"</string>
+    <string name="tab_picker_view_tab">"Vis"</string>
+    <string name="tab_picker_new_tab">"Nytt vindu"</string>
+    <string name="tab_picker_remove_tab">"Lukk"</string>
+    <string name="tab_picker_bookmark">"Legg til bokmerke"</string>
+    <string name="tab_picker_send_url">"Del lenke"</string>
+    <string name="bookmarks">"Bokmerker"</string>
+    <string name="shortcut_bookmark">"Bokmerker"</string>
+    <string name="history">"Logg"</string>
+    <string name="menu_view_download">"Nedlastinger"</string>
+    <string name="share_page">"Del side"</string>
+    <string name="contextmenu_openlink">"Åpne"</string>
+    <string name="contextmenu_openlink_newwindow">"Åpne i nytt vindu"</string>
+    <string name="contextmenu_bookmark_thislink">"Legg til lenke i bokmerker"</string>
+    <string name="contextmenu_savelink">"Lagre lenke"</string>
+    <string name="contextmenu_sharelink">"Del lenke"</string>
+    <string name="contextmenu_copy">"Kopier"</string>
+    <string name="contextmenu_copylink">"Kopier lenke-URL"</string>
+    <string name="contextmenu_download_image">"Lagre bilde"</string>
+    <string name="contextmenu_view_image">"Vis bilde"</string>
+    <string name="contextmenu_dial_dot">"Ring…"</string>
+    <string name="contextmenu_add_contact">"Legg til kontakt"</string>
+    <string name="contextmenu_send_mail">"Send e-post"</string>
+    <string name="contextmenu_map">"Kart"</string>
+    <string name="clear">"Nullstill"</string>
+    <string name="replace">"Erstatt"</string>
+    <string name="browser_bookmarks_page_bookmarks_text">"Bokmerker"</string>
+    <string name="menu_preferences">"Innstillinger"</string>
+    <string name="pref_content_title">"Sideinnhold"</string>
+    <string name="pref_content_load_images">"Last bilder"</string>
+    <string name="pref_content_load_images_summary">"Vis bilder på nettsider"</string>
+    <string name="pref_content_block_popups">"Blokker sprettoppvinduer"</string>
+    <string name="pref_content_javascript">"Slå på JavaScript"</string>
+    <string name="pref_content_open_in_background">"Åpne i bakgrunnen"</string>
+    <string name="pref_content_open_in_background_summary">"La vinduer åpnes bak dette"</string>
+    <string name="pref_content_homepage">"Sett hjemmeside"</string>
+    <string name="pref_content_autofit">"Tilpass sider"</string>
+    <string name="pref_content_autofit_summary">"Tilpass nettsider så de passer på skjermen"</string>
+    <string name="pref_privacy_title">"Personvernsinnstillinger"</string>
+    <string name="pref_privacy_clear_cache">"Nullstill hurtiglager"</string>
+    <string name="pref_privacy_clear_cache_summary">"Slett alt hurtiglagret nettinnhold"</string>
+    <string name="pref_privacy_clear_cache_dlg">"Hurtiglageret vil nullstilles."</string>
+    <string name="pref_privacy_clear_cookies">"Fjern alle informasjonskapsler"</string>
+    <string name="pref_privacy_clear_cookies_summary">"Fjern alle informasjonskapsler lagret i nettleseren"</string>
+    <string name="pref_privacy_clear_cookies_dlg">"Alle informasjonskapsler vil bli slettet."</string>
+    <string name="pref_privacy_clear_history">"Slett loggen"</string>
+    <string name="pref_privacy_clear_history_summary">"Slett navigeringsloggen"</string>
+    <string name="pref_privacy_clear_history_dlg">"Nettleserens navigeringslogg vil bli slettet."</string>
+    <string name="pref_privacy_clear_form_data">"Slett skjemadata"</string>
+    <string name="pref_privacy_clear_form_data_summary">"Slett alt lagret skjemadata"</string>
+    <string name="pref_privacy_clear_form_data_dlg">"Alt lagret skjemadata vil bli slettet."</string>
+    <string name="pref_privacy_clear_passwords">"Slett passord"</string>
+    <string name="pref_privacy_clear_passwords_summary">"Slett alle lagrede passord"</string>
+    <string name="pref_privacy_clear_passwords_dlg">"Alle lagrede passord vil bli slettet."</string>
+    <string name="pref_security_title">"Sikkerhetsinnstillinger"</string>
+    <string name="pref_security_remember_passwords">"Husk passord"</string>
+    <string name="pref_security_remember_passwords_summary">"Lagre brukernavn og passord for nettsider"</string>
+    <string name="pref_security_save_form_data">"Husk skjemadata"</string>
+    <string name="pref_security_save_form_data_summary">"Husk data skrevet inn i skjemaer til senere"</string>
+    <string name="pref_security_show_security_warning">"Vis sikkerhetsadvarsler"</string>
+    <string name="pref_security_show_security_warning_summary">"Vis advarsel hvis det er et problem med sikkerheten på en side"</string>
+    <string name="pref_security_accept_cookies">"Godta informasjonskapsler"</string>
+    <string name="pref_security_accept_cookies_summary">"Tillat nettsteder å lagre og lese informasjonskapsler"</string>
+    <string name="pref_text_size">"Sett tekststørrelse"</string>
+  <string-array name="pref_text_size_choices">
+    <item>"Bitteliten"</item>
+    <item>"Liten"</item>
+    <item>"Vanlig"</item>
+    <item>"Stor"</item>
+    <item>"Kjempestor"</item>
+  </string-array>
+    <string name="pref_text_size_dialogtitle">"Tekststørrelse"</string>
+    <string name="pref_extras_title">"Avanserte innstillinger"</string>
+    <string name="pref_extras_gears_enable">"Aktiver Gears"</string>
+    <string name="pref_extras_gears_enable_summary">"Applikasjoner som utvider nettleserfunksjonaliteten"</string>
+    <string name="pref_extras_gears_settings">"Gears-innstillinger"</string>
+    <string name="pref_plugin_installed">"Liste over utvidelser"</string>
+    <string name="pref_plugin_installed_empty_list">"Ingen installerte utvidelser."</string>
+    <string name="pref_extras_gears_settings_summary">"Applikasjoner som utvider nettleserfunksjonaliteten"</string>
+    <string name="pref_extras_reset_default">"Nullstill"</string>
+    <string name="pref_extras_reset_default_summary">"Fjern alle data fra nettleseren og nullstill alle innstillinger"</string>
+    <string name="pref_extras_reset_default_dlg">"Alle data vil bli fjernet fra nettleseren, og alle innstillinger vil bli nullstilt."</string>
+    <string name="pref_extras_reset_default_dlg_title">"Nullstill"</string>
+    <string name="pref_development_title">"Avlusing"</string>
+    <string name="pref_development_viewport">"Use wide viewport"</string>
+    <string name="pref_development_single_column_rendering">"Single column rendering"</string>
+    <string name="pref_development_normal_rendering">"Normal rendering"</string>
+    <string name="pref_development_trace">"Enable tracing"</string>
+    <string name="pref_development_nav_dump">"Enable nav cache dump"</string>
+    <string name="pref_development_search_url">"Set search URL"</string>
+    <string name="pref_development_uastring">"UAString"</string>
+  <string-array name="pref_development_ua_choices">
+    <item>"Android"</item>
+    <item>"Desktop"</item>
+    <item>"iPhone"</item>
+  </string-array>
+  <string-array name="pref_development_ua_values">
+    <item>"0"</item>
+    <item>"1"</item>
+    <item>"2"</item>
+  </string-array>
+    <string name="pref_default_text_encoding">"Velg tekstkoding"</string>
+  <string-array name="pref_default_text_encoding_choices">
+    <item>"Latin-1 (ISO-8859-1)"</item>
+    <item>"Unicode (UTF-8)"</item>
+    <item>"Japansk (ISO-2022-JP)"</item>
+    <item>"Japansk (SHIFT_JIS)"</item>
+    <item>"Japansk (EUC-JP)"</item>
+  </string-array>
+    <string name="pref_default_text_encoding_dialogtitle">"Tekstkoding"</string>
+    <string name="pref_default_text_encoding_default">"Latin-1"</string>
+    <string name="browserFrameRedirect">"Videresending"</string>
+    <string name="browserFrame307Post">"Denne nettsiden blir videresendt. Send skjemadataene videre til den nye siden?"</string>
+    <string name="browserFrameNetworkErrorLabel">"Tilkoblingsproblem"</string>
+    <string name="browserFrameFileErrorLabel">"Problem med fil"</string>
+    <string name="browserFrameFormResubmitLabel">"Bekreft"</string>
+    <string name="browserFrameFormResubmitMessage">"Siden du prøver å se, inneholder data som allerede er blitt sendt inn (\\\"POSTDATA\\\"). Hvis du sender dataene på nytt, kan det skjemaet på siden gjorde bli gjort på nytt."</string>
+    <string name="loadSuspendedTitle">"Ingen nettverkstilkobling"</string>
+    <string name="loadSuspended">"Siden vil fortsette å laste etter at tilkoblingen er blitt gjenopprettet."</string>
+    <string name="clear_history">"Slett logg"</string>
+    <string name="browser_history">"Nylig besøkte sider"</string>
+    <string name="empty_history">"Nettleserens logg er tom."</string>
+    <string name="add_new_bookmark">"Nytt bokmerke"</string>
+    <string name="no_database">"Ingen database!"</string>
+    <string name="search_hint">"Skriv inn nettadresse"</string>
+    <string name="search_button_text">"Gå"</string>
+    <string name="attention">"Obs"</string>
+    <string name="popup_window_attempt">"Denne siden prøver å åpne et sprettoppvindu."</string>
+    <string name="allow">"Tillat"</string>
+    <string name="block">"Blokker"</string>
+    <string name="too_many_windows_dialog_title">"Vindusgrense nådd"</string>
+    <string name="too_many_windows_dialog_message">"Kunne ikke åpne et nytt vindu fordi du allerede har maksialt antall åpnet."</string>
+    <string name="too_many_subwindows_dialog_title">"Sprettoppvindu allerede åpnet"</string>
+    <string name="too_many_subwindows_dialog_message">"Kunne ikke åpne et nytt sprettoppvindu, fordi det bare kan være ett åpent av gangen."</string>
+    <string name="download_title">"Nedlastingslogg"</string>
+    <string name="download_unknown_filename">"&lt;Ukjent&gt;"</string>
+    <string name="download_menu_open">"Åpne"</string>
+    <string name="download_menu_clear">"Fjern fra listen"</string>
+    <string name="download_menu_cancel">"Avbryt nedlasting"</string>
+    <string name="download_menu_cancel_all">"Avbryt alle nedlastinger"</string>
+    <string name="download_menu_clear_all">"Tøm listen"</string>
+    <string name="download_clear_dlg_title">"Tøm"</string>
+    <string name="download_clear_dlg_msg">"Alle nedlastinger vil bli fjernet fra listen samt fjernet fra nettleserens hurtiglager."</string>
+    <string name="download_cancel_dlg_title">"Avbryt nedlastinger"</string>
+    <string name="download_cancel_dlg_msg">"Alle <xliff:g id="DOWNLOAD_COUNT">%d</xliff:g> nedlastinger vil bli avbrutt og fjernet fra nedlastingsloggen."</string>
+    <string name="download_file_error_dlg_title">"Tom for plass"</string>
+    <string name="download_file_error_dlg_msg">"Kunne ikke laste ned <xliff:g id="FILENAME">%s</xliff:g>."\n"Frigjør plass på telefonen og prøv igjen."</string>
+    <string name="download_failed_generic_dlg_title">"Feil ved nedlasting"</string>
+    <string name="download_no_sdcard_dlg_title">"Mangler minnekort"</string>
+    <string name="download_no_sdcard_dlg_msg">"Du trenger et minnekort for å laste ned <xliff:g id="FILENAME">%s</xliff:g>."</string>
+    <string name="download_sdcard_busy_dlg_title">"Minnekort utilgjengelig"</string>
+    <string name="download_sdcard_busy_dlg_msg">"Minnekortet er opptatt. For å tillatte nedlastinger, gå til Hjem &gt; Innstillinger &gt; Minnekort og telefonlagring, og fjern haken ved \\\"Bruk for USB-lagring\\\"-boksen."</string>
+    <string name="download_no_application">"Fant ingen applikasjon som kunne åpne denne filen."</string>
+    <string name="retry">"Prøv igjen"</string>
+    <string name="no_downloads">"Nedlastingsloggen er tom."</string>
+    <string name="download_error">"Feil ved nedlasting."</string>
+    <string name="download_success">"<xliff:g id="FILE">%s</xliff:g> Nedlasting ferdig."</string>
+    <string name="download_running">"Laster ned…"</string>
+    <string name="download_pending">"Starter nedlasting…"</string>
+    <string name="download_pending_network">"Venter på datatilkobling…"</string>
+    <string name="download_running_paused">"Venter på datatilkobling…"</string>
+    <string name="download_canceled">"Nedlastingen ble avbrutt."</string>
+    <string name="download_not_acceptable">"Kan ikke laste ned. Innholdet er ikke støttet av telefonen."</string>
+    <string name="download_file_error">"Kan ikke fullføre nedlastingen. Det er ikke nok plass."</string>
+    <string name="download_length_required">"Kan ikke laste ned. Klarte ikke bestemme størrelsen på filen."</string>
+    <string name="download_precondition_failed">"Nedlastingen ble avbrutt. Den kan ikke fortsettes."</string>
+    <string name="activity_instrumentation_test_runner">"Browser Test Runner"</string>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
+    <string name="permlab_readHistoryBookmarks">"read Browser\\\'s history and bookmarks"</string>
+    <string name="permdesc_readHistoryBookmarks">"Allows the application to read all the URLs that the Browser has visited, and all of the Browser\\\'s bookmarks."</string>
+    <string name="permlab_writeHistoryBookmarks">"write Browser\\\'s history and bookmarks"</string>
+    <string name="permdesc_writeHistoryBookmarks">"Allows an application to modify the Browser\\\'s history or bookmarks stored on your phone. Malicious applications can use this to erase or modify your Browser\\\'s data."</string>
+    <string name="query_data_message">"Nettsiden under ønsker å lagre informasjon på datamaskinen ved hjelp av Gears."</string>
+    <string name="location_message">"Nettsiden under ønsker å finne ut hvor du er ved hjelp av Gears."</string>
+    <string name="shortcut_message">"Denne nettsiden ønsker å lage en snarvei på datamaskinen. Ønsker du å tillate dette?"</string>
+    <string name="settings_message">"Tabellen under viser rettighetent du har gitt til hver side som har prøvd å bruke Gears."</string>
+    <string name="filepicker_message">"Gears filplukker"</string>
+    <string name="settings_title">"Gears-innstillinger"</string>
+    <string name="privacy_policy">"Les sidens personvernspolicy for å se hvordan informasjonen vil bli brukt."</string>
+    <string name="permission_button_alwaysdeny">"Aldri tillat for denne siden"</string>
+    <string name="permission_button_allow">"Tillat"</string>
+    <string name="permission_button_deny">"Nekt"</string>
+    <string name="shortcut_button_alwaysdeny">"Aldri tillat denne snarveien"</string>
+    <string name="shortcut_button_allow">"OK"</string>
+    <string name="shortcut_button_deny">"Avbryt"</string>
+    <string name="settings_button_allow">"Bruk"</string>
+    <string name="settings_button_deny">"Avbryt"</string>
+    <string name="filepicker_button_allow">"OK"</string>
+    <string name="filepicker_button_deny">"Avbryt"</string>
+    <string name="filepicker_path">"sti:"</string>
+    <string name="filepicker_no_files_selected">"Ingen fil valgt"</string>
+    <string name="filepicker_one_file_selected">"En fil valgt"</string>
+    <string name="filepicker_some_files_selected">"filer valgt"</string>
+    <string name="remove">"Fjern"</string>
+    <string name="local_storage">"Lokal lagring"</string>
+    <string name="allowed">"Tillatt"</string>
+    <string name="denied">"Nektet"</string>
+    <string name="unrecognized_dialog_message">"Ukjent meldingstype"</string>
+    <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
+</resources>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 38a4258..ebb9f24 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Aanmelden bij <xliff:g id="HOSTNAME">%s1</xliff:g> \'<xliff:g id="REALM">%s2</xliff:g>\'"</string>
     <string name="username">"Naam"</string>
     <string name="password">"Wachtwoord"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Stoppen..."</string>
     <string name="stop">"Stoppen"</string>
     <string name="reload">"Vernieuwen"</string>
-    <string name="back">"Terug"</string>
     <string name="forward">"Volgende"</string>
     <string name="save">"OK"</string>
     <string name="do_not_save">"Annuleren"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"URL is ongeldig."</string>
     <string name="delete_bookmark">"Verwijderen"</string>
     <string name="bookmark_page">"Bladwijzer maken voor de laatst weergegeven pagina"</string>
-    <string name="current_page">"Huidige pagina:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Bladwijzer \'<xliff:g id="BOOKMARK">%s</xliff:g>\' wordt verwijderd."</string>
     <string name="open_in_new_window">"Openen in een nieuw venster"</string>
     <string name="new_window">"Nieuw venster"</string>
-    <string name="goto_dot">"Ga naar URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Zoeken op pagina"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Startpagina"</string>
     <string name="view_tabs">"Vensteroverzicht"</string>
     <string name="view_tabs_condensed">"Windows"</string>
     <string name="tab_picker_title">"Huidige vensters"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"Bladwijzer"</string>
     <string name="history">"Geschiedenis"</string>
     <string name="menu_view_download">"Downloads"</string>
-    <string name="menu_bookmark_page">"Bladwijzerpagina"</string>
     <string name="share_page">"Pagina delen"</string>
-    <string name="menu_zoom">"Zoomen"</string>
-    <string name="menu_flip_orientation">"Stand draaien"</string>
     <string name="contextmenu_openlink">"Openen"</string>
     <string name="contextmenu_openlink_newwindow">"Openen in een nieuw venster"</string>
     <string name="contextmenu_bookmark_thislink">"Bladwijzer maken van link"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Geschiedenis wissen"</string>
     <string name="browser_history">"Onlangs bezochte pagina\'s"</string>
     <string name="empty_history">"Browsergeschiedenis is leeg."</string>
-    <string name="add_new_bookmark">"Nieuwe bladwijzer"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"Geen database."</string>
     <string name="search_hint">"Typ het webadres"</string>
-    <string name="search">"Zoeken"</string>
     <string name="search_button_text">"Ga"</string>
     <string name="attention">"Opgelet"</string>
     <string name="popup_window_attempt">"Deze site probeert een pop-upvenster te openen."</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"Kan niet downloaden. De grootte van het item kan niet worden vastgesteld."</string>
     <string name="download_precondition_failed">"Download is onderbroken. Deze kan niet worden voortgezet."</string>
     <string name="activity_instrumentation_test_runner">"Browser Test Runner"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.com/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.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>"New York Times"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.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>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"browsergeschiedenis en bladwijzers lezen"</string>
     <string name="permdesc_readHistoryBookmarks">"Hiermee kan een toepassing de URL\'s lezen die u via de browser heeft bezocht, evenals alle bladwijzers van de browser."</string>
     <string name="permlab_writeHistoryBookmarks">"browsergeschiedenis en bladwijzers schrijven"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"Deze website probeert een snelkoppeling te maken op uw computer. Wilt u dit toestaan?"</string>
     <string name="settings_message">"De onderstaande tabel geeft de toestemming weer die u heeft verleend aan elke site die Gears heeft geprobeerd te gebruiken."</string>
     <string name="filepicker_message">"Bestandenkiezer van Google Gears"</string>
-    <string name="image_message">"Geselecteerde foto"</string>
     <string name="settings_title">"Instellingen van Gears"</string>
     <string name="privacy_policy">"U kunt het privacybeleid van de site raadplegen voor meer informatie over hoe uw locatie wordt gebruikt."</string>
     <string name="permission_button_alwaysdeny">"Deze site nooit toestaan"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"Geweigerd"</string>
     <string name="unrecognized_dialog_message">"Dialoogtype wordt niet herkend"</string>
     <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index 496f2a0..bf62311 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Zaloguj się w witrynie <xliff:g id="HOSTNAME">%s1</xliff:g> „<xliff:g id="REALM">%s2</xliff:g>”"</string>
     <string name="username">"Nazwa"</string>
     <string name="password">"Hasło"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Trwa zatrzymywanie…"</string>
     <string name="stop">"Zatrzymaj"</string>
     <string name="reload">"Odśwież"</string>
-    <string name="back">"Wstecz"</string>
     <string name="forward">"Dalej"</string>
     <string name="save">"OK"</string>
     <string name="do_not_save">"Anuluj"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"Adres URL jest nieprawidłowy."</string>
     <string name="delete_bookmark">"Usuń"</string>
     <string name="bookmark_page">"Dodaj do zakładek ostatnio wyświetlaną stronę"</string>
-    <string name="current_page">"Bieżąca strona:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Zakładka „<xliff:g id="BOOKMARK">%s</xliff:g>” zostanie usunięta."</string>
     <string name="open_in_new_window">"Otwórz w nowym oknie"</string>
     <string name="new_window">"Nowe okno"</string>
-    <string name="goto_dot">"Przejdź pod adres URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Znajdź na stronie"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Strona główna"</string>
     <string name="view_tabs">"Przegląd okien"</string>
     <string name="view_tabs_condensed">"Windows"</string>
     <string name="tab_picker_title">"Bieżące okna"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"Utwórz zakładkę"</string>
     <string name="history">"Historia"</string>
     <string name="menu_view_download">"Pobrane pliki"</string>
-    <string name="menu_bookmark_page">"Strona zakładek"</string>
     <string name="share_page">"Udostępnij stronę"</string>
-    <string name="menu_zoom">"Powiększenie"</string>
-    <string name="menu_flip_orientation">"Zmień orientację"</string>
     <string name="contextmenu_openlink">"Otwórz"</string>
     <string name="contextmenu_openlink_newwindow">"Otwórz w nowym oknie"</string>
     <string name="contextmenu_bookmark_thislink">"Dodaj link do zakładek"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Wyczyść historię"</string>
     <string name="browser_history">"Ostatnio odwiedzane strony"</string>
     <string name="empty_history">"Historia przeglądarki jest pusta."</string>
-    <string name="add_new_bookmark">"Nowa zakładka"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"Brak bazy danych!"</string>
     <string name="search_hint">"Wpisz adres WWW"</string>
-    <string name="search">"Szukaj"</string>
     <string name="search_button_text">"Idź"</string>
     <string name="attention">"Uwaga"</string>
     <string name="popup_window_attempt">"Ta strona próbuje otworzyć okienko wyskakujące."</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"Pobieranie niemożliwe. Nie można ustalić rozmiaru elementu."</string>
     <string name="download_precondition_failed">"Pobieranie zostało przerwane. Nie można go wznowić."</string>
     <string name="activity_instrumentation_test_runner">"Uruchamianie testów przeglądarki"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.com/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.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>"New York Times"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.com/"</item>
-    <item>"Amazon"</item>
-    <item>"http://www.amazon.com/"</item>
-    <item>"Pogoda"</item>
-    <item>"http://www.weather.com/"</item>
-    <item>"BBC"</item>
-    <item>"http://www.bbc.co.uk/"</item>
-  </string-array>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"odczytywanie historii i zakładek przeglądarki"</string>
     <string name="permdesc_readHistoryBookmarks">"Zezwala aplikacji na odczytanie wszystkich adresów URL odwiedzonych przy użyciu przeglądarki oraz wszystkich zakładek przeglądarki."</string>
     <string name="permlab_writeHistoryBookmarks">"zapisać historię i zakładki przeglądarki"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"Ta witryna chce utworzyć skrót w Twoim komputerze. Czy chcesz na to zezwolić?"</string>
     <string name="settings_message">"W poniższej tabeli przedstawiono uprawnienia udzielone każdej z witryn próbujących użyć Gears."</string>
     <string name="filepicker_message">"Gears — wybieranie pliku"</string>
-    <string name="image_message">"Wybrany obraz"</string>
     <string name="settings_title">"Gears — ustawienia"</string>
     <string name="privacy_policy">"Przeczytaj zasady zachowania poufności informacji witryny, aby dowiedzieć się, jak będą użyte informacje o twojej lokalizacji."</string>
     <string name="permission_button_alwaysdeny">"Nigdy nie zezwalaj tej witrynie"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"Odmówiono"</string>
     <string name="unrecognized_dialog_message">"Nierozpoznany typ okna dialogowego"</string>
     <string name="default_button">"OK"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 621ef99..e82021a 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"Регистрация в <xliff:g id="HOSTNAME">%s1</xliff:g> \"<xliff:g id="REALM">%s2</xliff:g>\""</string>
     <string name="username">"Название"</string>
     <string name="password">"Пароль"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"Остановка загрузки…"</string>
     <string name="stop">"Остановить"</string>
     <string name="reload">"Обновить"</string>
-    <string name="back">"Назад"</string>
     <string name="forward">"Вперед"</string>
     <string name="save">"ОК"</string>
     <string name="do_not_save">"Отмена"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"URL недействителен."</string>
     <string name="delete_bookmark">"Удаление"</string>
     <string name="bookmark_page">"Добавить в закладки последнюю просмотренную страницу"</string>
-    <string name="current_page">"Текущая страница:"</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"Закладка \"<xliff:g id="BOOKMARK">%s</xliff:g>\" будет удалена."</string>
     <string name="open_in_new_window">"Открыть в новом окне"</string>
     <string name="new_window">"Новое окно"</string>
-    <string name="goto_dot">"Перейти к URL"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"Найти на странице"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"Главная страница"</string>
     <string name="view_tabs">"Обзор окон"</string>
     <string name="view_tabs_condensed">"Окна"</string>
     <string name="tab_picker_title">"Текущие окна"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"Закладка"</string>
     <string name="history">"История"</string>
     <string name="menu_view_download">"Загрузки"</string>
-    <string name="menu_bookmark_page">"Страница закладок"</string>
     <string name="share_page">"Отправить страницу"</string>
-    <string name="menu_zoom">"Масштаб"</string>
-    <string name="menu_flip_orientation">"Изменить ориентацию"</string>
     <string name="contextmenu_openlink">"Открыть"</string>
     <string name="contextmenu_openlink_newwindow">"Открыть в новом окне"</string>
     <string name="contextmenu_bookmark_thislink">"Добавить в закладки"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"Очистить историю"</string>
     <string name="browser_history">"Недавно посещенные страницы"</string>
     <string name="empty_history">"История бразуера пуста."</string>
-    <string name="add_new_bookmark">"Создать закладку"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"Нет базы данных!"</string>
     <string name="search_hint">"Введите веб-адрес"</string>
-    <string name="search">"Поиск"</string>
     <string name="search_button_text">"Перейти"</string>
     <string name="attention">"Внимание"</string>
     <string name="popup_window_attempt">"Этот сайт пытается открыть всплывающее окно."</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"Загрузка невозможна. Не удается определить размер элемента."</string>
     <string name="download_precondition_failed">"Загрузка прервана и не может быть продолжена."</string>
     <string name="activity_instrumentation_test_runner">"Проверка браузера"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.ru/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.com/"</item>
-    <item>"Facebook"</item>
-    <item>"http://www.facebook.com/"</item>
-    <item>"Википедия"</item>
-    <item>"http://ru.wikipedia.org/"</item>
-    <item>"eBay"</item>
-    <item>"http://www.ebay.com/"</item>
-    <item>"CNN"</item>
-    <item>"http://www.cnn.com/"</item>
-    <item>"New York Times"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.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>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"считывать историю и закладки браузера"</string>
     <string name="permdesc_readHistoryBookmarks">"Позволяет приложению считывать все URL, открытые через браузер, и все закладки браузера."</string>
     <string name="permlab_writeHistoryBookmarks">"записывать историю и закладки браузера"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"Этот веб-сайт пытается создать ярлык на вашем компьютере. Разрешить?"</string>
     <string name="settings_message">"В таблице ниже показаны разрешения, которые вы дали сайтам, пытавшимся использовать Gears."</string>
     <string name="filepicker_message">"Выбор файлов Gears"</string>
-    <string name="image_message">"Выбранное изображение"</string>
     <string name="settings_title">"Настройки Gears"</string>
     <string name="privacy_policy">"Прочитайте политику конфиденциальности сайта, чтобы узнать, как будут использованы данные о вашем местоположении."</string>
     <string name="permission_button_alwaysdeny">"Никогда для этого сайта"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"Запрещено"</string>
     <string name="unrecognized_dialog_message">"Неизвестный тип диалога"</string>
     <string name="default_button">"ОК"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index f3b8202..8a4d47b 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"登录至 <xliff:g id="HOSTNAME">%s1</xliff:g>“<xliff:g id="REALM">%s2</xliff:g>”"</string>
     <string name="username">"名称"</string>
     <string name="password">"密码"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"正在停止..."</string>
     <string name="stop">"停止"</string>
     <string name="reload">"刷新"</string>
-    <string name="back">"返回"</string>
     <string name="forward">"前进"</string>
     <string name="save">"确定"</string>
     <string name="do_not_save">"取消"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"网址无效。"</string>
     <string name="delete_bookmark">"删除"</string>
     <string name="bookmark_page">"将上次查看过的页面加为书签"</string>
-    <string name="current_page">"当前页面："</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"会删除书签“<xliff:g id="BOOKMARK">%s</xliff:g>”。"</string>
     <string name="open_in_new_window">"在新窗口中打开"</string>
     <string name="new_window">"新窗口"</string>
-    <string name="goto_dot">"转至网址"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"在页面上查找"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"主页"</string>
     <string name="view_tabs">"窗口概述"</string>
     <string name="view_tabs_condensed">"窗口"</string>
     <string name="tab_picker_title">"当前窗口"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"书签"</string>
     <string name="history">"历史记录"</string>
     <string name="menu_view_download">"下载"</string>
-    <string name="menu_bookmark_page">"书签页面"</string>
     <string name="share_page">"共享页面"</string>
-    <string name="menu_zoom">"缩放"</string>
-    <string name="menu_flip_orientation">"反转方向"</string>
     <string name="contextmenu_openlink">"打开"</string>
     <string name="contextmenu_openlink_newwindow">"在新窗口中打开"</string>
     <string name="contextmenu_bookmark_thislink">"书签链接"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"清除历史记录"</string>
     <string name="browser_history">"最近访问过的页面"</string>
     <string name="empty_history">"浏览器历史记录为空。"</string>
-    <string name="add_new_bookmark">"新建书签"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"没有数据库！"</string>
     <string name="search_hint">"键入网址"</string>
-    <string name="search">"搜索"</string>
     <string name="search_button_text">"转至"</string>
     <string name="attention">"注意"</string>
     <string name="popup_window_attempt">"该网站正试图打开一个弹出窗口。"</string>
@@ -254,34 +261,8 @@
     <string name="download_length_required">"无法下载。无法确定该项的大小。"</string>
     <string name="download_precondition_failed">"下载中断，无法重新开始。"</string>
     <string name="activity_instrumentation_test_runner">"浏览器测试运行器"</string>
-  <string-array name="bookmarks">
-    <item>"Google"</item>
-    <item>"http://www.google.cn/"</item>
-    <item>"Yahoo!"</item>
-    <item>"http://www.yahoo.com/"</item>
-    <item>"MSN"</item>
-    <item>"http://www.msn.com/"</item>
-    <item>"MySpace"</item>
-    <item>"http://www.myspace.com/"</item>
-    <item>"Facebook"</item>
-    <item>"http://www.facebook.com/"</item>
-    <item>"Wikipedia"</item>
-    <item>"http://www.wikipedia.org/"</item>
-    <item>"易趣"</item>
-    <item>"http://www.ebay.com/"</item>
-    <item>"CNN"</item>
-    <item>"http://www.cnn.com/"</item>
-    <item>"纽约时报"</item>
-    <item>"http://www.nytimes.com/"</item>
-    <item>"ESPN"</item>
-    <item>"http://espn.go.com/"</item>
-    <item>"卓越亚马逊"</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>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"读取浏览器的历史记录和书签"</string>
     <string name="permdesc_readHistoryBookmarks">"允许应用程序读取浏览器访问过的所有网址以及浏览器的所有书签。"</string>
     <string name="permlab_writeHistoryBookmarks">"写入浏览器的历史记录和书签"</string>
@@ -291,7 +272,6 @@
     <string name="shortcut_message">"该网站想要在您的计算机上创建快捷方式。是否允许创建？"</string>
     <string name="settings_message">"下表显示了您授予尝试使用 Gears 的各个网站的权限。"</string>
     <string name="filepicker_message">"Gears 文件选择器"</string>
-    <string name="image_message">"选定图片"</string>
     <string name="settings_title">"Gears 设置"</string>
     <string name="privacy_policy">"阅读网站的隐私政策，以了解会如何使用您的位置。"</string>
     <string name="permission_button_alwaysdeny">"始终拒绝该网站"</string>
@@ -314,4 +294,6 @@
     <string name="denied">"已拒绝"</string>
     <string name="unrecognized_dialog_message">"未识别的对话类型"</string>
     <string name="default_button">"确定"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index 48b6ec3..45a2321 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -17,6 +17,16 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <!-- no translation found for application_name (1935869255545976415) -->
     <skip />
+    <!-- no translation found for tab_bookmarks (2305793036003473653) -->
+    <skip />
+    <!-- no translation found for tab_most_visited (1077402532455000703) -->
+    <skip />
+    <!-- no translation found for tab_history (1979267558744613746) -->
+    <skip />
+    <!-- no translation found for added_to_bookmarks (1020224130695956728) -->
+    <skip />
+    <!-- no translation found for removed_from_bookmarks (6063705902028438800) -->
+    <skip />
     <string name="sign_in_to">"登入到 <xliff:g id="HOSTNAME">%s1</xliff:g>「<xliff:g id="REALM">%s2</xliff:g>」"</string>
     <string name="username">"名字"</string>
     <string name="password">"密碼"</string>
@@ -52,7 +62,6 @@
     <string name="stopping">"停止中…"</string>
     <string name="stop">"停止"</string>
     <string name="reload">"重新整理"</string>
-    <string name="back">"上一頁"</string>
     <string name="forward">"下一頁"</string>
     <string name="save">"確定"</string>
     <string name="do_not_save">"取消"</string>
@@ -72,15 +81,16 @@
     <string name="bookmark_url_not_valid">"網址無效。"</string>
     <string name="delete_bookmark">"刪除"</string>
     <string name="bookmark_page">"最後瀏覽的書籤頁面"</string>
-    <string name="current_page">"本頁："</string>
+    <!-- no translation found for current_page (7510129573681663135) -->
+    <skip />
     <string name="delete_bookmark_warning">"<xliff:g id="BOOKMARK">%s</xliff:g>"</string>
     <string name="open_in_new_window">"在新視窗開啟"</string>
     <string name="new_window">"新視窗"</string>
-    <string name="goto_dot">"前往網址"</string>
+    <!-- no translation found for goto_dot (3895839050522602723) -->
+    <skip />
     <string name="find_dot">"在頁面中尋找"</string>
     <!-- no translation found for select_dot (6299170761900561967) -->
     <skip />
-    <string name="homepage">"首頁"</string>
     <string name="view_tabs">"視窗總覽"</string>
     <string name="view_tabs_condensed">"視窗"</string>
     <string name="tab_picker_title">"目前視窗"</string>
@@ -93,10 +103,7 @@
     <string name="shortcut_bookmark">"書籤"</string>
     <string name="history">"紀錄"</string>
     <string name="menu_view_download">"下載"</string>
-    <string name="menu_bookmark_page">"書籤頁面"</string>
     <string name="share_page">"分享網頁"</string>
-    <string name="menu_zoom">"縮放"</string>
-    <string name="menu_flip_orientation">"旋轉方向"</string>
     <string name="contextmenu_openlink">"開啟"</string>
     <string name="contextmenu_openlink_newwindow">"在新視窗開啟"</string>
     <string name="contextmenu_bookmark_thislink">"書籤連結"</string>
@@ -208,10 +215,10 @@
     <string name="clear_history">"清除紀錄"</string>
     <string name="browser_history">"最近瀏覽的頁面"</string>
     <string name="empty_history">"瀏覽記錄是空的。"</string>
-    <string name="add_new_bookmark">"新書籤"</string>
+    <!-- no translation found for add_new_bookmark (8086367791400349049) -->
+    <skip />
     <string name="no_database">"沒有資料！"</string>
     <string name="search_hint">"輸入網頁位址"</string>
-    <string name="search">"搜尋"</string>
     <string name="search_button_text">"前往"</string>
     <string name="attention">"注意"</string>
     <string name="popup_window_attempt">"此網站試圖開啟快顯視窗。"</string>
@@ -254,6 +261,8 @@
     <string name="download_length_required">"無法下載。物件大小無法估計。"</string>
     <string name="download_precondition_failed">"下載中斷。無法續傳。"</string>
     <string name="activity_instrumentation_test_runner">"Browser Test Runner"</string>
+    <!-- no translation found for search_google (1231765426260855357) -->
+    <skip />
     <string name="permlab_readHistoryBookmarks">"讀取瀏覽器的瀏覽記錄和書籤"</string>
     <string name="permdesc_readHistoryBookmarks">"允許應用程式讀取瀏覽器造訪過的所有 URL 和瀏覽器所有的書籤。"</string>
     <string name="permlab_writeHistoryBookmarks">"寫入瀏覽器的瀏覽記錄和書籤"</string>
@@ -263,7 +272,6 @@
     <string name="shortcut_message">"此網站想要在您的電腦上建立捷徑。是否允許此動作？"</string>
     <string name="settings_message">"下表列出您為每個想要使用 Gears 之網站所授予的權限。"</string>
     <string name="filepicker_message">"Gears File Picker"</string>
-    <string name="image_message">"選取的圖片"</string>
     <string name="settings_title">"裝置設定"</string>
     <string name="privacy_policy">"讀取網站的隱私權政策，以瞭解網站將如何使用您的位置資訊。"</string>
     <string name="permission_button_alwaysdeny">"永遠不允許此網站"</string>
@@ -286,4 +294,6 @@
     <string name="denied">"遭拒"</string>
     <string name="unrecognized_dialog_message">"無法辨識的對話類型"</string>
     <string name="default_button">"確定"</string>
+    <!-- no translation found for zoom_overview_button_text (4146579940085488881) -->
+    <skip />
 </resources>
diff --git a/res/values/colors.xml b/res/values/colors.xml
index 8d02fe1..4426ec9 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -33,10 +33,7 @@
     <color name="black">#ff000000</color>
     <color name="gray">#ffbbbbbb</color>
     <color name="dark_gray">#ff777777</color>
-    <color name="blue">#ff0000ff</color>
     
-    <color name="translucent_white">#11ffffff</color>
-
     <!-- Gears Dialogs -->
     <color name="permission_border">#f1cc1d</color>
     <color name="permission_background">#faefb8</color>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 59ed396..6a24b08 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -18,6 +18,16 @@
     <!-- The name of the application. -->
     <string name="application_name">Browser</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>
+    <!-- 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 -->
@@ -106,8 +116,6 @@
     <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. -->
@@ -154,7 +162,7 @@
             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">Current page:\u0020</string>
+    <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>
@@ -163,15 +171,13 @@
     <!-- Appears in Current windows screen as label on blank + window; user 
             selects this window to open a new browser window -->
     <string name="new_window">New window</string>
-    <!-- Menu item to open a dialog which allows the user to enter a url-->
-    <string name="goto_dot">Go to URL</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 that opens up a dialog which allows the user to provide a
             string and search for it on the page. -->
     <string name="find_dot">Find on page</string>
     <!-- Menu item to switch to text selection mode for copy and paste. -->
     <string name="select_dot">Select text</string>
-    <!-- Menu item to go to the home page, as stored in settings -->
-    <string name="homepage">Home page</string>
     <!-- Menu item which opens a screen which shows all the currently open
             windows, and also allows them to create a new one. -->
     <string name="view_tabs">Window overview</string>
@@ -202,15 +208,8 @@
     <string name="history">History</string>
     <!-- Menu item for viewing downloads from the browser -->
     <string name="menu_view_download">Downloads</string>
-    <!-- Menu item to display the bookmark page.  This is a longer version shown
-            without an icon next to it -->
-    <string name="menu_bookmark_page">Bookmark page</string>
     <!-- Menu item -->
     <string name="share_page">Share page</string>
-    <!-- Menu item to bring up the zoom controls -->
-    <string name="menu_zoom">Zoom</string>
-    <!-- Menu item to flip the orientation of the screen.-->
-    <string name="menu_flip_orientation">Flip orientation</string>
     <!-- Context Menu item open the currently selected link in the current
             window.-->
     <string name="contextmenu_openlink">Open</string>
@@ -447,8 +446,8 @@
     <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 item -->
-    <string name="add_new_bookmark">New bookmark</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>
     <!-- Add bookmark dialog sets its title to this if we have no database.
             This is an error case -->
     <string name="no_database">No database!</string>
@@ -459,8 +458,6 @@
     <!-- 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">Type Web address</string>
-    <!-- Menu item -->
-    <string name="search">Search</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>
@@ -623,6 +620,9 @@
     <string name="google_search_base" translatable="false">
         http://www.google.com/m?hl=%1$s&amp;gl=%2$s&amp;</string>
 
+    <!-- Used in Goto to indicate Google search -->
+    <string name="search_google">Search Google</string>
+
     <!-- Title of an application permission, listed so the user can choose whether 
         they want to allow the application to do this. -->
     <string name="permlab_readHistoryBookmarks">read Browser\'s history and bookmarks</string>
@@ -646,7 +646,6 @@
     <string name="shortcut_message">This Web site wants to create a shortcut on your computer. Do you want to allow this?</string>
     <string name="settings_message">The table below shows the permissions you have granted to each site that has attempted to use Gears.</string>
     <string name="filepicker_message">Gears File Picker</string>
-    <string name="image_message">Selected image</string>
 
     <string name="settings_title">Gears settings</string>
     <string name="privacy_policy">Read the site\'s privacy policy to see how your location will be used.</string>
@@ -677,4 +676,7 @@
     <string name="unrecognized_dialog_message">Unrecognized dialog type</string>
     <string name="default_button">OK</string>
 
+    <!-- Zoom-related strings --><skip />
+    <!-- Caption for a button that is shown when the zoom widget is showing.  The button's action will switch to the zoom overview mode. -->
+    <string name="zoom_overview_button_text">Overview</string>
 </resources>
diff --git a/res/xml/searchable.xml b/res/xml/searchable.xml
index c94f0f3..d7ef778 100644
--- a/res/xml/searchable.xml
+++ b/res/xml/searchable.xml
@@ -23,6 +23,7 @@
     android:hint="@string/search_hint"
     android:searchButtonText="@string/search_button_text"
     android:searchMode="queryRewriteFromData"
+    android:voiceSearchMode="showVoiceSearchButton|launchWebSearch"
     android:inputType="textUri"
     
     android:searchSuggestAuthority="browser"
diff --git a/src/com/android/browser/AddBookmarkPage.java b/src/com/android/browser/AddBookmarkPage.java
index ea65a46..23c0fac 100644
--- a/src/com/android/browser/AddBookmarkPage.java
+++ b/src/com/android/browser/AddBookmarkPage.java
@@ -48,8 +48,8 @@
     private Bundle      mMap;
     
     private static final String[]   mProjection = 
-        { "_id", "url", "bookmark", "created", "title" };
-    private static final String     WHERE_CLAUSE = "url = ? AND bookmark = 0";
+        { "_id", "url", "bookmark", "created", "title", "visits" };
+    private static final String     WHERE_CLAUSE = "url = ?";
     private final String[]          SELECTION_ARGS = new String[1];
 
     private View.OnClickListener mSaveBookmark = new View.OnClickListener() {
@@ -163,25 +163,58 @@
                         WHERE_CLAUSE,
                         SELECTION_ARGS,
                         null);
-                if (c.moveToFirst()) {
-                    // This means we have been to this site, so convert the 
-                    // history item to a bookmark.
-                    ContentValues map = new ContentValues();
+                ContentValues map = new ContentValues();
+                if (c.moveToFirst() && c.getInt(c.getColumnIndexOrThrow(
+                        Browser.BookmarkColumns.BOOKMARK)) == 0) {
+                    // This means we have been to this site but not bookmarked
+                    // it, so convert the history item to a bookmark                    
                     map.put(Browser.BookmarkColumns.CREATED, creationTime);
                     map.put(Browser.BookmarkColumns.TITLE, title);
                     map.put(Browser.BookmarkColumns.BOOKMARK, 1);
                     cr.update(Browser.BOOKMARKS_URI, map, 
                             "_id = " + c.getInt(0), null);
                 } else {
-                    // Adding a bookmark for a site the user has not been to.
-                    ContentValues map = new ContentValues();
-                    map.put(Browser.BookmarkColumns.TITLE, title);
-                    map.put(Browser.BookmarkColumns.URL, url);
-                    map.put(Browser.BookmarkColumns.CREATED, creationTime);
-                    map.put(Browser.BookmarkColumns.BOOKMARK, 1);
-                    map.put(Browser.BookmarkColumns.DATE, 0);
-                    map.put(Browser.BookmarkColumns.VISITS, 0);
-                    cr.insert(Browser.BOOKMARKS_URI, map);
+                    int count = c.getCount();
+                    boolean matchedTitle = false;
+                    for (int i = 0; i < count; i++) {
+                        // One or more bookmarks already exist for this site.
+                        // Check the names of each
+                        c.moveToPosition(i);
+                        if (c.getString(c.getColumnIndexOrThrow(
+                                Browser.BookmarkColumns.TITLE)).equals(title)) {
+                            // The old bookmark has the same name.
+                            // Update its creation time.
+                            map.put(Browser.BookmarkColumns.CREATED,
+                                    creationTime);
+                            cr.update(Browser.BOOKMARKS_URI, map, 
+                                    "_id = " + c.getInt(0), null);
+                            matchedTitle = true;
+                        }
+                    }
+                    if (!matchedTitle) {
+                        // Adding a bookmark for a site the user has visited,
+                        // or a new bookmark (with a different name) for a site
+                        // the user has visited
+                        map.put(Browser.BookmarkColumns.TITLE, title);
+                        map.put(Browser.BookmarkColumns.URL, url);
+                        map.put(Browser.BookmarkColumns.CREATED, creationTime);
+                        map.put(Browser.BookmarkColumns.BOOKMARK, 1);
+                        map.put(Browser.BookmarkColumns.DATE, 0);
+                        int visits = 0;
+                        if (count > 0) {
+                            // The user has already bookmarked, and possibly
+                            // visited this site.  However, they are creating
+                            // a new bookmark with the same url but a different
+                            // name.  The new bookmark should have the same
+                            // number of visits as the already created bookmark.
+                            visits = c.getInt(c.getColumnIndexOrThrow(
+                                    Browser.BookmarkColumns.VISITS));
+                        }
+                        // Bookmark starts with 3 extra visits so that it will
+                        // bubble up in the most visited and goto search box
+                        map.put(Browser.BookmarkColumns.VISITS, visits + 3);
+                        cr.insert(Browser.BOOKMARKS_URI, map);
+                    }
                 }
                 WebIconDatabase.getInstance().retainIconForPageUrl(url);
                 c.deactivate();
diff --git a/src/com/android/browser/AddNewBookmark.java b/src/com/android/browser/AddNewBookmark.java
index 748c9c2..a75d002 100644
--- a/src/com/android/browser/AddNewBookmark.java
+++ b/src/com/android/browser/AddNewBookmark.java
@@ -63,10 +63,6 @@
      *  @param url  The new url for the bookmark item.
      */
     /* package */ void setUrl(String url) {
-        if (url.length() > BrowserSettings.MAX_TEXTVIEW_LEN) {
-            mUrlText.setText(url.substring(0, BrowserSettings.MAX_TEXTVIEW_LEN));
-        } else {
-            mUrlText.setText(url);
-        }
+        mUrlText.setText(url);
     }
 }
diff --git a/src/com/android/browser/BookmarkItem.java b/src/com/android/browser/BookmarkItem.java
index 0015eaf..a70dd4f 100644
--- a/src/com/android/browser/BookmarkItem.java
+++ b/src/com/android/browser/BookmarkItem.java
@@ -19,19 +19,20 @@
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.view.LayoutInflater;
+import android.view.View;
 import android.widget.ImageView;
-import android.widget.RelativeLayout;
+import android.widget.LinearLayout;
 import android.widget.TextView;
 
 /**
  *  Custom layout for an item representing a bookmark in the browser.
  */
-class BookmarkItem extends RelativeLayout {
+class BookmarkItem extends LinearLayout {
 
-    private TextView    mTextView;
-    private TextView    mUrlText;
-    private ImageView   mImageView;
-    private LayoutInflater mFactory;
+    protected TextView    mTextView;
+    protected TextView    mUrlText;
+    protected ImageView   mImageView;
+    protected String      mUrl;
 
     /**
      *  Instantiate a bookmark item, including a default favicon.
@@ -41,11 +42,13 @@
     BookmarkItem(Context context) {
         super(context);
 
-        mFactory = LayoutInflater.from(context);
-        mFactory.inflate(R.layout.bookmark_item, this);
+        LayoutInflater factory = LayoutInflater.from(context);
+        factory.inflate(R.layout.history_item, this);
         mTextView = (TextView) findViewById(R.id.title);
         mUrlText = (TextView) findViewById(R.id.url);
         mImageView = (ImageView) findViewById(R.id.favicon);
+        View star = findViewById(R.id.star);
+        star.setVisibility(View.GONE);
     }
 
     /**
@@ -61,8 +64,8 @@
     /**
      * Return the name assigned to this bookmark item.
      */
-    /* package */ CharSequence getName() {
-        return mTextView.getText();
+    /* package */ String getName() {
+        return mTextView.getText().toString();
     }
 
     /**
@@ -72,6 +75,10 @@
         return mTextView;
     }
 
+    /* package */ String getUrl() {
+        return mUrl;
+    }
+
     /**
      *  Set the favicon for this item.
      *
@@ -101,5 +108,6 @@
      */
     /* package */ void setUrl(String url) {
         mUrlText.setText(url);
+        mUrl = url;
     }
 }
diff --git a/src/com/android/browser/BrowserActivity.java b/src/com/android/browser/BrowserActivity.java
index 170083d..b6942d2 100644
--- a/src/com/android/browser/BrowserActivity.java
+++ b/src/com/android/browser/BrowserActivity.java
@@ -54,10 +54,10 @@
 import android.graphics.drawable.PaintDrawable;
 import android.hardware.SensorListener;
 import android.hardware.SensorManager;
+import android.net.ConnectivityManager;
 import android.net.Uri;
 import android.net.WebAddress;
 import android.net.http.EventHandler;
-import android.net.http.RequestQueue;
 import android.net.http.SslCertificate;
 import android.net.http.SslError;
 import android.os.AsyncTask;
@@ -97,6 +97,7 @@
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.Window;
+import android.view.WindowManager;
 import android.view.animation.AlphaAnimation;
 import android.view.animation.Animation;
 import android.view.animation.AnimationSet;
@@ -730,19 +731,18 @@
            http stack */
         mNetworkStateChangedFilter = new IntentFilter();
         mNetworkStateChangedFilter.addAction(
-                RequestQueue.HTTP_NETWORK_STATE_CHANGED_INTENT);
+                ConnectivityManager.CONNECTIVITY_ACTION);
         mNetworkStateIntentReceiver = new BroadcastReceiver() {
                 @Override
                 public void onReceive(Context context, Intent intent) {
                     if (intent.getAction().equals(
-                            RequestQueue.HTTP_NETWORK_STATE_CHANGED_INTENT)) {
-                        Boolean up = (Boolean)intent.getExtra(
-                                RequestQueue.HTTP_NETWORK_STATE_UP);
-                        onNetworkToggle(up);
+                            ConnectivityManager.CONNECTIVITY_ACTION)) {
+                        boolean down = intent.getBooleanExtra(
+                                ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
+                        onNetworkToggle(!down);
                     }
                 }
             };
-        setRequestedOrientation(mSettings.getOrientation());
     }
 
     @Override
@@ -1324,14 +1324,8 @@
                 }
                 break;
 
-            case R.id.search_menu_id:
-                // launch using "global" search, which will bring up the Google search box
-                startSearch(null, false,
-                        createGoogleSearchSourceBundle(GOOGLE_SEARCH_SOURCE_SEARCHMENU), true);
-                break;
-
             case R.id.bookmarks_menu_id:
-                bookmarksPicker();
+                bookmarksOrHistoryPicker(false);
                 break;
 
             case R.id.windows_menu_id:
@@ -1412,12 +1406,7 @@
                 break;
 
             case R.id.classic_history_menu_id:
-                loadHistory();
-                break;
-
-            case R.id.bookmark_page_menu_id:
-                Browser.saveBookmark(this, getTopWindow().getTitle(),
-                        getTopWindow().getUrl());
+                bookmarksOrHistoryPicker(true);
                 break;
 
             case R.id.share_page_menu_id:
@@ -1428,12 +1417,6 @@
                 getTopWindow().debugDump();
                 break;
 
-            case R.id.zoom_menu_id:
-                // FIXME: Can we move this out of WebView? How does this work
-                // for a subwindow?
-                getTopWindow().invokeZoomPicker();
-                break;
-
             case R.id.zoom_in_menu_id:
                 getTopWindow().zoomIn();
                 break;
@@ -1446,18 +1429,6 @@
                 viewDownloads(null);
                 break;
 
-            case R.id.flip_orientation_menu_id:
-                if (mSettings.getOrientation() !=
-                        ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
-                    mSettings.setOrientation(this,
-                            ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-                } else {
-                    mSettings.setOrientation(this,
-                            ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
-                }
-                setRequestedOrientation(mSettings.getOrientation());
-                break;
-
             // -- Tab menu
             case R.id.view_tab_menu_id:
                 if (mTabListener != null && mTabOverview != null) {
@@ -1499,17 +1470,12 @@
                 }
                 break;
 
-            case R.id.history_tab_menu_id: {
-                    Intent i = new Intent(this, BrowserHistoryPage.class);
-                    i.putExtra("maxTabsOpen",
-                            mTabControl.getTabCount() >=
-                            TabControl.MAX_TABS);
-                    startActivityForResult(i, CLASSIC_HISTORY_PAGE);
-                }
+            case R.id.history_tab_menu_id:
+                bookmarksOrHistoryPicker(true);
                 break;
 
             case R.id.bookmarks_tab_menu_id:
-                bookmarksPicker();
+                bookmarksOrHistoryPicker(false);
                 break;
 
             case R.id.properties_tab_menu_id:
@@ -1570,6 +1536,7 @@
                 if (mCurrentMenuState != mMenuState) {
                     menu.setGroupVisible(R.id.MAIN_MENU, false);
                     menu.setGroupEnabled(R.id.MAIN_MENU, false);
+                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
                     menu.setGroupVisible(R.id.TAB_MENU, true);
                     menu.setGroupEnabled(R.id.TAB_MENU, true);
                 }
@@ -1582,6 +1549,7 @@
                 if (mCurrentMenuState != mMenuState) {
                     menu.setGroupVisible(R.id.MAIN_MENU, false);
                     menu.setGroupEnabled(R.id.MAIN_MENU, false);
+                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
                     menu.setGroupVisible(R.id.TAB_MENU, false);
                     menu.setGroupEnabled(R.id.TAB_MENU, false);
                 }
@@ -1590,31 +1558,27 @@
                 if (mCurrentMenuState != mMenuState) {
                     menu.setGroupVisible(R.id.MAIN_MENU, true);
                     menu.setGroupEnabled(R.id.MAIN_MENU, true);
+                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, true);
                     menu.setGroupVisible(R.id.TAB_MENU, false);
                     menu.setGroupEnabled(R.id.TAB_MENU, false);
                 }
                 final WebView w = getTopWindow();
-                boolean canGoBack = w.canGoBack();
+                boolean canGoBack = false;
+                boolean canGoForward = false;
+                boolean isHome = false;
+                if (w != null) {
+                    canGoBack = w.canGoBack();
+                    canGoForward = w.canGoForward();
+                    isHome = mSettings.getHomePage().equals(w.getUrl());
+                }
                 final MenuItem back = menu.findItem(R.id.back_menu_id);
-                back.setVisible(canGoBack);
                 back.setEnabled(canGoBack);
-                final MenuItem flip =
-                        menu.findItem(R.id.flip_orientation_menu_id);
-                boolean keyboardClosed =
-                        getResources().getConfiguration().hardKeyboardHidden ==
-                        Configuration.HARDKEYBOARDHIDDEN_YES;
-                flip.setEnabled(keyboardClosed);
 
-                boolean isHome = mSettings.getHomePage().equals(w.getUrl());
                 final MenuItem home = menu.findItem(R.id.homepage_menu_id);
-                home.setVisible(!isHome);
                 home.setEnabled(!isHome);
 
                 menu.findItem(R.id.forward_menu_id)
-                        .setEnabled(w.canGoForward());
-
-                menu.findItem(R.id.zoom_in_menu_id).setVisible(false);
-                menu.findItem(R.id.zoom_out_menu_id).setVisible(false);
+                        .setEnabled(canGoForward);
 
                 // decide whether to show the share link option
                 PackageManager pm = getPackageManager();
@@ -1625,13 +1589,6 @@
                 menu.findItem(R.id.share_page_menu_id).setVisible(
                         list.size() > 0);
 
-                // Hide the menu+<window number> items
-                // Can't set visibility in menu xml file b/c when a
-                // group is set visible, all items are set visible.
-                for (int i = 0; i < WINDOW_SHORTCUT_ID_ARRAY.length; i++) {
-                    menu.findItem(WINDOW_SHORTCUT_ID_ARRAY[i]).setVisible(false);
-                }
-
                 // If there is only 1 window, the text will be "New window"
                 final MenuItem windows = menu.findItem(R.id.windows_menu_id);
                 windows.setTitleCondensed(mTabControl.getTabCount() > 1 ?
@@ -1741,10 +1698,14 @@
                         PackageManager.MATCH_DEFAULT_ONLY);
                 menu.findItem(R.id.share_link_context_menu_id).setVisible(
                         list.size() > 0);
-                break;
-
+                if (type == WebView.HitTestResult.SRC_ANCHOR_TYPE) {
+                    break;
+                }
+                // otherwise fall through to handle image part
             case WebView.HitTestResult.IMAGE_TYPE:
-                menu.setHeaderTitle(extra);
+                if (type == WebView.HitTestResult.IMAGE_TYPE) {
+                    menu.setHeaderTitle(extra);
+                }
                 menu.findItem(R.id.view_image_context_menu_id).setIntent(
                         new Intent(Intent.ACTION_VIEW, Uri.parse(extra)));
                 menu.findItem(R.id.download_context_menu_id).
@@ -1838,7 +1799,13 @@
         // Send the animate message.
         final HashMap map = new HashMap();
         map.put("view", view);
-        map.put("url", url);
+        // Load the url after the AnimatingView has captured the picture. This
+        // prevents any bad layout or bad scale from being used during
+        // animation.
+        if (url != null) {
+            dismissSubWindow(tab);
+            tab.getWebView().loadUrl(url);
+        }
         map.put("msg", msg);
         mHandler.sendMessageDelayed(mHandler.obtainMessage(
                 ANIMATE_FROM_OVERVIEW, newTab ? 1 : 0, 0, map), delay);
@@ -2041,7 +2008,7 @@
     // Animate from the tab picker. The index supplied is the index to animate
     // from.
     private void animateFromTabOverview(final AnimatingView view,
-            final boolean newTab, final String url, final Message msg) {
+            final boolean newTab, final Message msg) {
         // firstVisible is the first visible tab on the screen.  This helps
         // to know which corner of the screen the selected tab is.
         int firstVisible = mTabOverview.getFirstVisiblePosition();
@@ -2063,7 +2030,7 @@
         // Find the view at this location.
         final View v = mTabOverview.getChildAt(location);
 
-        // Wait until the animation completes to load the url.
+        // Wait until the animation completes to replace the AnimatingView.
         final Animation.AnimationListener l =
                 new Animation.AnimationListener() {
                     public void onAnimationStart(Animation a) {}
@@ -2078,15 +2045,9 @@
                                 dismissTabOverview(v == null);
                                 TabControl.Tab t =
                                         mTabControl.getCurrentTab();
-                                WebView w = t.getWebView();
-                                if (url != null) {
-                                    // Dismiss the subwindow if one exists.
-                                    dismissSubWindow(t);
-                                    w.loadUrl(url);
-                                }
                                 mMenuState = R.id.MAIN_MENU;
                                 // Resume regular updates.
-                                w.resumeTimers();
+                                t.getWebView().resumeTimers();
                                 // Dispatch the message after the animation
                                 // completes.
                                 if (msg != null) {
@@ -2111,7 +2072,7 @@
             // Make the view VISIBLE during the animation.
             view.setVisibility(View.VISIBLE);
         } else {
-            // Go ahead and load the url.
+            // Go ahead and do all the cleanup.
             l.onAnimationEnd(null);
         }
     }
@@ -2450,7 +2411,7 @@
                 return KeyTracker.State.DONE_TRACKING;
             }
             if (stage == KeyTracker.Stage.LONG_REPEAT) {
-                loadHistory();
+                bookmarksOrHistoryPicker(true);
                 return KeyTracker.State.DONE_TRACKING;
             } else if (stage == KeyTracker.Stage.UP) {
                 // FIXME: Currently, we do not have a notion of the
@@ -2522,13 +2483,6 @@
         }
     }
 
-    private void loadHistory() {
-        Intent intent = new Intent(this, BrowserHistoryPage.class);
-        intent.putExtra("maxTabsOpen",
-                mTabControl.getTabCount() >= TabControl.MAX_TABS);
-        startActivityForResult(intent, CLASSIC_HISTORY_PAGE);
-    }
-
     // called by a non-UI thread to post the message
     public void postMessage(int what, int arg1, int arg2, Object obj) {
         mHandler.sendMessage(mHandler.obtainMessage(what, arg1, arg2, obj));
@@ -2555,8 +2509,7 @@
                 case ANIMATE_FROM_OVERVIEW:
                     final HashMap map = (HashMap) msg.obj;
                     animateFromTabOverview((AnimatingView) map.get("view"),
-                            msg.arg1 == 1, (String) map.get("url"),
-                            (Message) map.get("msg"));
+                            msg.arg1 == 1, (Message) map.get("msg"));
                     break;
 
                 case ANIMATE_TO_OVERVIEW:
@@ -2723,6 +2676,18 @@
 
             mInLoad = true;
             updateInLoadMenuItems();
+            if (!mIsNetworkUp) {
+                if ( mAlertDialog == null) {
+                    mAlertDialog = new AlertDialog.Builder(BrowserActivity.this)
+                        .setTitle(R.string.loadSuspendedTitle)
+                        .setMessage(R.string.loadSuspended)
+                        .setPositiveButton(R.string.ok, null)
+                        .show();
+                }
+                if (view != null) {
+                    view.setNetworkAvailable(false);
+                }
+            }
 
             // schedule to check memory condition
             mHandler.sendMessageDelayed(mHandler.obtainMessage(CHECK_MEMORY),
@@ -3884,7 +3849,7 @@
         }
 
         mHttpAuthHandler = handler;
-        mHttpAuthenticationDialog = new AlertDialog.Builder(this)
+        AlertDialog dialog = new AlertDialog.Builder(this)
                 .setTitle(titleText)
                 .setIcon(android.R.drawable.ic_dialog_alert)
                 .setView(v)
@@ -3920,12 +3885,17 @@
                             mHttpAuthenticationDialog = null;
                             mHttpAuthHandler = null;
                         }})
-                .show();
+                .create();
+        // Make the IME appear when the dialog is displayed if applicable.
+        dialog.getWindow().setSoftInputMode(
+                WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+        dialog.show();
         if (focusId != 0) {
-            mHttpAuthenticationDialog.findViewById(focusId).requestFocus();
+            dialog.findViewById(focusId).requestFocus();
         } else {
             v.findViewById(R.id.username_edit).requestFocus();
         }
+        mHttpAuthenticationDialog = dialog;
     }
 
     public int getProgress() {
@@ -3956,16 +3926,20 @@
     }
 
     /**
-     * http stack says net has come or gone... inform the user
+     * connectivity manager says net has come or gone... inform the user
      * @param up true if net has come up, false if net has gone down
      */
     public void onNetworkToggle(boolean up) {
-        if (up) {
+        if (up == mIsNetworkUp) {
+            return;
+        } else if (up) {
+            mIsNetworkUp = true;
             if (mAlertDialog != null) {
                 mAlertDialog.cancel();
                 mAlertDialog = null;
             }
         } else {
+            mIsNetworkUp = false;
             if (mInLoad && mAlertDialog == null) {
                 mAlertDialog = new AlertDialog.Builder(this)
                         .setTitle(R.string.loadSuspendedTitle)
@@ -3984,8 +3958,7 @@
     protected void onActivityResult(int requestCode, int resultCode,
                                     Intent intent) {
         switch (requestCode) {
-            case BOOKMARKS_PAGE:
-            case CLASSIC_HISTORY_PAGE:
+            case COMBO_PAGE:
                 if (resultCode == RESULT_OK && intent != null) {
                     String data = intent.getAction();
                     Bundle extras = intent.getExtras();
@@ -4202,13 +4175,13 @@
         mMenuState = EMPTY_MENU;
     }
 
-    private void bookmarksPicker() {
+    private void bookmarksOrHistoryPicker(boolean startWithHistory) {
         WebView current = mTabControl.getCurrentWebView();
         if (current == null) {
             return;
         }
         Intent intent = new Intent(this,
-                BrowserBookmarksPage.class);
+                CombinedBookmarkHistoryActivity.class);
         String title = current.getTitle();
         String url = current.getUrl();
         // Just in case the user opens bookmarks before a page finishes loading
@@ -4228,7 +4201,11 @@
         intent.putExtra("url", url);
         intent.putExtra("maxTabsOpen",
                 mTabControl.getTabCount() >= TabControl.MAX_TABS);
-        startActivityForResult(intent, BOOKMARKS_PAGE);
+        if (startWithHistory) {
+            intent.putExtra(CombinedBookmarkHistoryActivity.STARTING_TAB,
+                    CombinedBookmarkHistoryActivity.HISTORY_TAB);
+        }
+        startActivityForResult(intent, COMBO_PAGE);
     }
 
     // Called when loading from context menu or LOAD_URL message
@@ -4351,7 +4328,7 @@
         return composeSearchUrl(inUrl);
     }
 
-    /* package */static String composeSearchUrl(String search) {
+    /* package */ String composeSearchUrl(String search) {
         return URLUtil.composeSearchUrl(search, QuickSearch_G,
                 QUERY_PLACE_HOLDER);
     }
@@ -4409,6 +4386,7 @@
     boolean mCanChord;
 
     private boolean mInLoad;
+    private boolean mIsNetworkUp;
 
     private boolean mPageStarted;
     private boolean mActivityInPause = true;
@@ -4503,8 +4481,6 @@
 
     // "source" parameter for Google search through search key
     final static String GOOGLE_SEARCH_SOURCE_SEARCHKEY = "browser-key";
-    // "source" parameter for Google search through search menu
-    final static String GOOGLE_SEARCH_SOURCE_SEARCHMENU = "browser-menu";
     // "source" parameter for Google search through goto menu
     final static String GOOGLE_SEARCH_SOURCE_GOTO = "browser-goto";
     // "source" parameter for Google search through simplily type
@@ -4543,10 +4519,9 @@
     private BroadcastReceiver mNetworkStateIntentReceiver;
 
     // activity requestCode
-    final static int BOOKMARKS_PAGE         = 1;
-    final static int CLASSIC_HISTORY_PAGE   = 2;
-    final static int DOWNLOAD_PAGE          = 3;
-    final static int PREFERENCES_PAGE       = 4;
+    final static int COMBO_PAGE             = 1;
+    final static int DOWNLOAD_PAGE          = 2;
+    final static int PREFERENCES_PAGE       = 3;
 
     // the frenquency of checking whether system memory is low
     final static int CHECK_MEMORY_INTERVAL = 30000;     // 30 seconds
diff --git a/src/com/android/browser/BrowserBookmarksPage.java b/src/com/android/browser/BrowserBookmarksPage.java
index 5c509a8..7708e8b 100644
--- a/src/com/android/browser/BrowserBookmarksPage.java
+++ b/src/com/android/browser/BrowserBookmarksPage.java
@@ -162,7 +162,7 @@
         }
 
         mBookmarksAdapter = new BrowserBookmarksAdapter(this, 
-                getIntent().getStringExtra("title"), mCreateShortcut);
+                getIntent().getStringExtra("url"), mCreateShortcut);
         mMaxTabsOpen = getIntent().getBooleanExtra("maxTabsOpen", false);
 
         ListView listView = (ListView) findViewById(R.id.list);
@@ -204,7 +204,7 @@
             } else {
                 final Intent intent = createShortcutIntent(getUrl(position),
                         getBookmarkTitle(position));
-                setResult(RESULT_OK, intent);
+                setResultToParent(RESULT_OK, intent);
                 finish();
             }
         }
@@ -231,7 +231,8 @@
     }
 
     private void loadUrl(int position) {
-        setResult(RESULT_OK, (new Intent()).setAction(getUrl(position)));
+        Intent intent = (new Intent()).setAction(getUrl(position));
+        setResultToParent(RESULT_OK, intent);
         finish();
     }
 
@@ -262,7 +263,7 @@
     private void openInNewWindow(int position) {
         Bundle b = new Bundle();
         b.putBoolean("new_window", true);
-        setResult(RESULT_OK,
+        setResultToParent(RESULT_OK,
                 (new Intent()).setAction(getUrl(position)).putExtras(b));
 
         finish();
@@ -367,9 +368,18 @@
     
     public boolean dispatchKeyEvent(KeyEvent event) {    
         if (event.getKeyCode() ==  KeyEvent.KEYCODE_BACK && event.isDown()) {
-            setResult(RESULT_CANCELED);
+            setResultToParent(RESULT_CANCELED, null);
             mCanceled = true;
         }
         return super.dispatchKeyEvent(event);
     }
+
+    // This Activity is generally a sub-Activity of CombinedHistoryActivity. In
+    // that situation, we need to pass our result code up to our parent.
+    // However, if someone calls this Activity directly, then this has no
+    // parent, and it needs to set it on itself.
+    private void setResultToParent(int resultCode, Intent data) {
+        Activity a = getParent() == null ? this : getParent();
+        a.setResult(resultCode, data);
+    }
 }
diff --git a/src/com/android/browser/BrowserDownloadAdapter.java b/src/com/android/browser/BrowserDownloadAdapter.java
index 0b509ef..38b83fe 100644
--- a/src/com/android/browser/BrowserDownloadAdapter.java
+++ b/src/com/android/browser/BrowserDownloadAdapter.java
@@ -180,6 +180,7 @@
                     sb.append("/");
                     sb.append(Formatter.formatFileSize(mContext, totalBytes));
                     sb.append(")");
+                    pb.setIndeterminate(false);
                     pb.setProgress(progressAmount);
                 } else {
                     pb.setIndeterminate(true);
diff --git a/src/com/android/browser/BrowserHistoryPage.java b/src/com/android/browser/BrowserHistoryPage.java
index 3059126..f7e97c0 100644
--- a/src/com/android/browser/BrowserHistoryPage.java
+++ b/src/com/android/browser/BrowserHistoryPage.java
@@ -16,14 +16,17 @@
 
 package com.android.browser;
 
-import android.app.ListActivity;
+import android.app.Activity;
+import android.app.ExpandableListActivity;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
+import android.database.ContentObserver;
 import android.database.Cursor;
 import android.database.DataSetObserver;
 import android.graphics.Bitmap;
 import android.os.Bundle;
+import android.os.Handler;
 import android.os.ServiceManager;
 import android.provider.Browser;
 import android.text.IClipboard;
@@ -41,11 +44,11 @@
 import android.webkit.DateSorter;
 import android.webkit.WebIconDatabase.IconListener;
 import android.widget.AdapterView;
-import android.widget.ListAdapter;
-import android.widget.ListView;
+import android.widget.ExpandableListAdapter;
+import android.widget.ExpandableListView;
+import android.widget.ExpandableListView.ExpandableListContextMenuInfo;
 import android.widget.TextView;
 
-import java.util.HashMap;
 import java.util.List;
 import java.util.Vector;
 
@@ -53,22 +56,16 @@
  * Activity for displaying the browser's history, divided into
  * days of viewing.
  */
-public class BrowserHistoryPage extends ListActivity {
+public class BrowserHistoryPage extends ExpandableListActivity {
     private HistoryAdapter          mAdapter;
     private DateSorter              mDateSorter;
     private boolean                 mMaxTabsOpen;
 
     private final static String LOGTAG = "browser";
 
-    // FIXME: Make this a part of Browser so we do not have more than one
-    // copy (other copy is in BrowserBookmarksAdapter).
-    // Used to store favicons as we get them from the database
-    private final HashMap<String, Bitmap> mUrlsToIcons =
-            new HashMap<String, Bitmap>();
     // Implementation of WebIconDatabase.IconListener
     private class IconReceiver implements IconListener {
         public void onReceivedIcon(String url, Bitmap icon) {
-            mUrlsToIcons.put(url, icon);
             setListAdapter(mAdapter);
         }
     }
@@ -87,7 +84,7 @@
             b.putBoolean("new_window", true);
             intent.putExtras(b);
         }
-        setResult(RESULT_OK, intent);
+        setResultToParent(RESULT_OK, intent);
         finish();
     }
     
@@ -111,20 +108,25 @@
 
         mAdapter = new HistoryAdapter();
         setListAdapter(mAdapter);
-        ListView list = getListView();
+        final ExpandableListView list = getExpandableListView();
         list.setOnCreateContextMenuListener(this);
         LayoutInflater factory = LayoutInflater.from(this);
         View v = factory.inflate(R.layout.empty_history, null);
         addContentView(v, new LayoutParams(LayoutParams.FILL_PARENT,
                 LayoutParams.FILL_PARENT));
         list.setEmptyView(v);
-
+        list.post(new Runnable() {
+            public void run() {
+                list.expandGroup(0);
+            }
+        });
         mMaxTabsOpen = getIntent().getBooleanExtra("maxTabsOpen", false);
-        Browser.requestAllIcons(getContentResolver(), null, mIconReceiver);
+        CombinedBookmarkHistoryActivity.getIconListenerSet(getContentResolver())
+                .addListener(mIconReceiver);
         
         // initialize the result to canceled, so that if the user just presses
         // back then it will have the correct result
-        setResult(RESULT_CANCELED);
+        setResultToParent(RESULT_CANCELED, null);
     }
 
     @Override
@@ -160,9 +162,12 @@
     @Override
     public void onCreateContextMenu(ContextMenu menu, View v,
             ContextMenuInfo menuInfo) {
-        AdapterView.AdapterContextMenuInfo i = 
-            (AdapterView.AdapterContextMenuInfo)
-            menuInfo;
+        ExpandableListContextMenuInfo i = 
+            (ExpandableListContextMenuInfo) menuInfo;
+        // Do not allow a context menu to come up from the group views.
+        if (!(i.targetView instanceof HistoryItem)) {
+            return;
+        }
 
         // Inflate the menu
         MenuInflater inflater = getMenuInflater();
@@ -174,7 +179,7 @@
         // Only show open in new tab if we have not maxed out available tabs
         menu.findItem(R.id.new_window_context_menu_id).setVisible(!mMaxTabsOpen);
         
-     // decide whether to show the share link option
+        // decide whether to show the share link option
         PackageManager pm = getPackageManager();
         Intent send = new Intent(Intent.ACTION_SEND);
         send.setType("text/plain");
@@ -188,8 +193,8 @@
     
     @Override
     public boolean onContextItemSelected(MenuItem item) {
-        AdapterView.AdapterContextMenuInfo i = 
-            (AdapterView.AdapterContextMenuInfo)item.getMenuInfo();
+        ExpandableListContextMenuInfo i = 
+            (ExpandableListContextMenuInfo) item.getMenuInfo();
         String url = ((HistoryItem)i.targetView).getUrl();
         String title = ((HistoryItem)i.targetView).getName();
         switch (item.getItemId()) {
@@ -219,13 +224,41 @@
     }
     
     @Override
-    protected void onListItemClick(ListView l, View v, int position, long id) {
+    public boolean onChildClick(ExpandableListView parent, View v,
+            int groupPosition, int childPosition, long id) {
         if (v instanceof HistoryItem) {
             loadUrl(((HistoryItem) v).getUrl(), false);
+            return true;
         }
+        return false;
     }
 
-    private class HistoryAdapter implements ListAdapter {
+    // This Activity is generally a sub-Activity of CombinedHistoryActivity. In
+    // that situation, we need to pass our result code up to our parent.
+    // However, if someone calls this Activity directly, then this has no
+    // parent, and it needs to set it on itself.
+    private void setResultToParent(int resultCode, Intent data) {
+        Activity a = getParent() == null ? this : getParent();
+        a.setResult(resultCode, data);
+    }
+
+    private class ChangeObserver extends ContentObserver {
+        public ChangeObserver() {
+            super(new Handler());
+        }
+
+        @Override
+        public boolean deliverSelfNotifications() {
+            return true;
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            mAdapter.refreshData();
+        }
+    }
+    
+    private class HistoryAdapter implements ExpandableListAdapter {
         
         // Map of items. Negative values are labels, positive values
         // and zero are cursor offsets.
@@ -245,6 +278,7 @@
                     whereClause, null, orderBy);
             
             buildMap();
+            mCursor.registerContentObserver(new ChangeObserver());
         }
         
         void refreshData() {
@@ -255,107 +289,109 @@
             }
         }
         
-        public void buildMap() {
+        private void buildMap() {
             // The cursor is sorted by date
-            // Make one pass to build up the ItemMap with the inserted 
-            // section separators. 
-            int array[] = new int[mCursor.getCount() + DateSorter.DAY_COUNT];
+            // The ItemMap will store the number of items in each bin.
+            int array[] = new int[DateSorter.DAY_COUNT];
+            // Zero out the array.
+            for (int j = 0; j < DateSorter.DAY_COUNT; j++) {
+                array[j] = 0;
+            }
             int dateIndex = -1;
             if (mCursor.moveToFirst() && mCursor.getCount() > 0) {
-                int itemIndex = 0;
                 while (!mCursor.isAfterLast()) {
                     long date = mCursor.getLong(Browser.HISTORY_PROJECTION_DATE_INDEX);
                     int index = mDateSorter.getIndex(date);
                     if (index > dateIndex) {
+                        if (index == DateSorter.DAY_COUNT - 1) {
+                            // We are already in the last bin, so it will
+                            // include all the remaining items
+                            array[index] = mCursor.getCount()
+                                    - mCursor.getPosition();
+                            break;
+                        }
                         dateIndex = index;
-                        array[itemIndex] = dateIndex - DateSorter.DAY_COUNT;
-                        itemIndex++;
                     }
-                    array[itemIndex] = mCursor.getPosition();
-                    itemIndex++;
+                    array[dateIndex]++;
                     mCursor.moveToNext();
                 }
-            } else {
-                // The db is empty, just add the heading for the first item
-                dateIndex = 0;
-                array[0] = dateIndex - DateSorter.DAY_COUNT;
             }
-            // Compress the array as the trailing date sections may be
-            // empty
-            int extraEntries = DateSorter.DAY_COUNT - dateIndex - 1;
-            if (extraEntries > 0) {
-                int newArraySize = array.length - extraEntries;
-                mItemMap = new int[newArraySize];
-                System.arraycopy(array, 0, mItemMap, 0, newArraySize);
-            } else {
-                mItemMap = array;
-            }
-        }
-
-        public View getView(int position, View convertView, ViewGroup parent) {
-            if (mItemMap[position] < 0) {
-                return getHeaderView(position, convertView);
-            }
-            return getHistoryItem(position, convertView);
+            mItemMap = array;
         }
         
-        View getHistoryItem(int position, View convertView) {
+        public View getChildView(int groupPosition, int childPosition, boolean isLastChild,
+                View convertView, ViewGroup parent) {
             HistoryItem item;
             if (null == convertView || !(convertView instanceof HistoryItem)) {
                 item = new HistoryItem(BrowserHistoryPage.this);
+                // Add padding on the left so it will be indented from the
+                // arrows on the group views.
+                item.setPadding(item.getPaddingLeft() + 10,
+                        item.getPaddingTop(),
+                        item.getPaddingRight(),
+                        item.getPaddingBottom());
             } else {
                 item = (HistoryItem) convertView;
             }
-            mCursor.moveToPosition(mItemMap[position]);
+            int index = childPosition;
+            for (int i = 0; i < groupPosition; i++) {
+                index += mItemMap[i];
+            }
+            mCursor.moveToPosition(index);
             item.setName(mCursor.getString(Browser.HISTORY_PROJECTION_TITLE_INDEX));
             String url = mCursor.getString(Browser.HISTORY_PROJECTION_URL_INDEX);
             item.setUrl(url);
-            item.setFavicon((Bitmap) mUrlsToIcons.get(url));
+            item.setFavicon(CombinedBookmarkHistoryActivity.getIconListenerSet(
+                    getContentResolver()).getFavicon(url));
+            item.setIsBookmark(1 ==
+                    mCursor.getInt(Browser.HISTORY_PROJECTION_BOOKMARK_INDEX));
             return item;
         }
         
-        View getHeaderView(int position, View convertView) {
+        public View getGroupView(int groupPosition, boolean isExpanded, View convertView, ViewGroup parent) {
             TextView item;
             if (null == convertView || !(convertView instanceof TextView)) {
                 LayoutInflater factory = 
                         LayoutInflater.from(BrowserHistoryPage.this);
                 item = (TextView) 
-                        factory.inflate(android.R.layout.preference_category, null);
+                        factory.inflate(R.layout.history_header, null);
             } else {
                 item = (TextView) convertView;
             }
-            item.setText(mDateSorter.getLabel(
-                    mItemMap[position] + DateSorter.DAY_COUNT));
+            item.setText(mDateSorter.getLabel(groupPosition));
             return item;
         }
 
         public boolean areAllItemsEnabled() {
-            return false;
+            return true;
         }
 
-        public boolean isEnabled(int position) {
-            return mItemMap[position] >= 0;
+        public boolean isChildSelectable(int groupPosition, int childPosition) {
+            return true;
         }
 
-        public int getCount() {
-            return mItemMap.length;
+        public int getGroupCount() {
+            return DateSorter.DAY_COUNT;
         }
 
-        public Object getItem(int position) {
+        public int getChildrenCount(int groupPosition) {
+            return mItemMap[groupPosition];
+        }
+
+        public Object getGroup(int groupPosition) {
             return null;
         }
 
-        public long getItemId(int position) {
-            return mItemMap[position];
+        public Object getChild(int groupPosition, int childPosition) {
+            return null;
         }
 
-        // 0 for TextView, 1 for HistoryItem
-        public int getItemViewType(int position) {
-            return mItemMap[position] < 0 ? 0 : 1;
+        public long getGroupId(int groupPosition) {
+            return groupPosition;
         }
 
-        public int getViewTypeCount() {
-            return 2;
+        public long getChildId(int groupPosition, int childPosition) {
+            return (childPosition << 3) + groupPosition;
         }
 
         public boolean hasStableIds() {
@@ -370,8 +406,24 @@
             mObservers.remove(observer);
         }
 
+        public void onGroupExpanded(int groupPosition) {
+        
+        }
+
+        public void onGroupCollapsed(int groupPosition) {
+        
+        }
+
+        public long getCombinedChildId(long groupId, long childId) {
+            return childId;
+        }
+
+        public long getCombinedGroupId(long groupId) {
+            return groupId;
+        }
+
         public boolean isEmpty() {
-            return getCount() == 1;
+            return mCursor.getCount() == 0;
         }
     }
 }
diff --git a/src/com/android/browser/BrowserProvider.java b/src/com/android/browser/BrowserProvider.java
index 7aa5bb2..0c930c6 100644
--- a/src/com/android/browser/BrowserProvider.java
+++ b/src/com/android/browser/BrowserProvider.java
@@ -16,23 +16,26 @@
 
 package com.android.browser;
 
+import android.app.ISearchManager;
 import android.app.SearchManager;
+import android.content.ComponentName;
 import android.content.ContentProvider;
-import android.content.ContentResolver;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.Context;
+import android.content.Intent;
 import android.content.UriMatcher;
 import android.database.AbstractCursor;
-import android.database.ContentObserver;
 import android.database.Cursor;
-import android.database.DataSetObserver;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.database.sqlite.SQLiteDatabase;
 import android.net.Uri;
+import android.os.RemoteException;
+import android.os.ServiceManager;
 import android.os.SystemProperties;
 import android.provider.Browser;
 import android.util.Log;
+import android.server.search.SearchableInfo;
 import android.text.util.Regex;
 
 public class BrowserProvider extends ContentProvider {
@@ -40,22 +43,41 @@
     private SQLiteOpenHelper mOpenHelper;
     private static final String sDatabaseName = "browser.db";
     private static final String TAG = "BrowserProvider";
-    private static final String ORDER_BY = "date DESC";
+    private static final String ORDER_BY = "visits DESC, date DESC";
 
     private static final String[] TABLE_NAMES = new String[] {
         "bookmarks", "searches"
     };
-    private static final String[] SUGGEST_PROJECTION = new String [] {
-        "0 AS " + SearchManager.SUGGEST_COLUMN_FORMAT,
-        "url AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA,
-        "url AS " + SearchManager.SUGGEST_COLUMN_TEXT_1,
-        "title AS " + SearchManager.SUGGEST_COLUMN_TEXT_2,
-        "_id"
+    private static final String[] SUGGEST_PROJECTION = new String[] {
+            "_id", "url", "title", "bookmark"
     };
     private static final String SUGGEST_SELECTION = 
             "url LIKE ? OR url LIKE ? OR url LIKE ? OR url LIKE ?";
     private String[] SUGGEST_ARGS = new String[4];
 
+    // shared suggestion array index, make sure to match COLUMNS
+    private static final int SUGGEST_COLUMN_INTENT_ACTION_ID = 1;
+    private static final int SUGGEST_COLUMN_INTENT_DATA_ID = 2;
+    private static final int SUGGEST_COLUMN_TEXT_1_ID = 3;
+    private static final int SUGGEST_COLUMN_TEXT_2_ID = 4;
+    private static final int SUGGEST_COLUMN_ICON_1_ID = 5;
+    private static final int SUGGEST_COLUMN_ICON_2_ID = 6;
+    private static final int SUGGEST_COLUMN_QUERY_ID = 7;
+
+    // shared suggestion columns
+    private static final String[] COLUMNS = new String[] {
+            "_id",
+            SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+            SearchManager.SUGGEST_COLUMN_INTENT_DATA,
+            SearchManager.SUGGEST_COLUMN_TEXT_1,
+            SearchManager.SUGGEST_COLUMN_TEXT_2,
+            SearchManager.SUGGEST_COLUMN_ICON_1,
+            SearchManager.SUGGEST_COLUMN_ICON_2,
+            SearchManager.SUGGEST_COLUMN_QUERY};
+
+    private static final int MAX_SUGGESTION_SHORT_ENTRIES = 3;
+    private static final int MAX_SUGGESTION_LONG_ENTRIES = 6;
+
     // make sure that these match the index of TABLE_NAMES
     private static final int URI_MATCH_BOOKMARKS = 0;
     private static final int URI_MATCH_SEARCHES = 1;
@@ -206,221 +228,195 @@
     }
 
     /*
-     * Subclass AbstractCursor so we can add "Google Search"
+     * Subclass AbstractCursor so we can combine multiple Cursors and add
+     * "Google Search".
+     * Here are the rules.
+     * 1. We only have MAX_SUGGESTION_LONG_ENTRIES in the list plus 
+     *      "Google Search";
+     * 2. If bookmark/history entries are less than 
+     *      (MAX_SUGGESTION_SHORT_ENTRIES -1), we include Google suggest.
      */
     private class MySuggestionCursor extends AbstractCursor {
-        private Cursor  mCursor;
+        private Cursor  mHistoryCursor;
+        private Cursor  mSuggestCursor;
+        private int     mHistoryCount;
+        private int     mSuggestionCount;
         private boolean mBeyondCursor;
         private String  mString;
-        private Uri     mNotifyUri;
-        private ContentResolver mContentResolver;
-        private AbstractCursor.SelfContentObserver mObserver;
-        private final Object mObserverLock = new Object();
 
-        public MySuggestionCursor(Cursor c, String string) {
-            mCursor = c;
-            if (Regex.WEB_URL_PATTERN.matcher(string).matches()) {
-                mString = "";
-            } else {
-                mString = string;
+        public MySuggestionCursor(Cursor hc, Cursor sc, String string) {
+            mHistoryCursor = hc;
+            mSuggestCursor = sc;
+            mHistoryCount = hc.getCount();
+            mSuggestionCount = sc != null ? sc.getCount() : 0;
+            if (mSuggestionCount > (MAX_SUGGESTION_LONG_ENTRIES - mHistoryCount)) {
+                mSuggestionCount = MAX_SUGGESTION_LONG_ENTRIES - mHistoryCount;
             }
+            mString = string;
             mBeyondCursor = false;
         }
 
+        @Override
         public boolean onMove(int oldPosition, int newPosition) {
-            if (mCursor.getCount() == newPosition) {
-                mBeyondCursor = true;
-            } else {
-                mCursor.moveToPosition(newPosition);
+            if (mHistoryCursor == null) {
+                return false;
+            }
+            if (mHistoryCount > newPosition) {
+                mHistoryCursor.moveToPosition(newPosition);
                 mBeyondCursor = false;
+            } else if (mHistoryCount + mSuggestionCount > newPosition) {
+                mSuggestCursor.moveToPosition(newPosition - mHistoryCount);
+                mBeyondCursor = false;
+            } else {
+                mBeyondCursor = true;
             }
             return true;
         }
 
+        @Override
         public int getCount() {
             if (mString.length() > 0) {
-                return mCursor.getCount() + 1;
+                return mHistoryCount + mSuggestionCount + 1;
             } else {
-                return mCursor.getCount();
+                return mHistoryCount + mSuggestionCount;
             }
         }
 
-        public boolean deleteRow() {
-            return !mBeyondCursor && mCursor.deleteRow();
-        }
-
+        @Override
         public String[] getColumnNames() {
-            return mCursor.getColumnNames();
+            return COLUMNS;
         }
 
-        public int getColumnCount() {
-            return mCursor.getColumnCount();
-        }
-
+        @Override
         public String getString(int columnIndex) {
-            if (!mBeyondCursor) {
-                return mCursor.getString(columnIndex);
+            if ((mPos != -1 && mHistoryCursor != null)) {
+                switch(columnIndex) {
+                    case SUGGEST_COLUMN_INTENT_ACTION_ID:
+                        if (mHistoryCount > mPos) {
+                            return Intent.ACTION_VIEW;
+                        } else {
+                            return Intent.ACTION_SEARCH;
+                        }
+
+                    case SUGGEST_COLUMN_INTENT_DATA_ID:
+                        if (mHistoryCount > mPos) {
+                            return mHistoryCursor.getString(1);
+                        } else {
+                            return null;
+                        }
+
+                    case SUGGEST_COLUMN_TEXT_1_ID:
+                        if (mHistoryCount > mPos) {
+                            return mHistoryCursor.getString(1);
+                        } else if (!mBeyondCursor) {
+                            return mSuggestCursor.getString(1);
+                        } else {
+                            return mString;
+                        }
+
+                    case SUGGEST_COLUMN_TEXT_2_ID:
+                        if (mHistoryCount > mPos) {
+                            return mHistoryCursor.getString(2);
+                        } else if (!mBeyondCursor) {
+                            return mSuggestCursor.getString(2);
+                        } else {
+                            return getContext().getString(R.string.search_google);
+                        }
+
+                    case SUGGEST_COLUMN_ICON_1_ID:
+                        if (mHistoryCount > mPos) {
+                            if (mHistoryCursor.getInt(3) == 1) {
+                                return new Integer(
+                                        R.drawable.ic_search_category_bookmark)
+                                        .toString();
+                            } else {
+                                return new Integer(
+                                        R.drawable.ic_search_category_history)
+                                        .toString();
+                            }
+                        } else {
+                            return new Integer(
+                                    R.drawable.ic_search_category_suggest)
+                                    .toString();
+                        }
+
+                    case SUGGEST_COLUMN_ICON_2_ID:
+                        return new String("0");
+
+                    case SUGGEST_COLUMN_QUERY_ID:
+                        if (mHistoryCount > mPos) {
+                            return null;
+                        } else if (!mBeyondCursor) {
+                            return mSuggestCursor.getString(3);
+                        } else {
+                            return mString;
+                        }
+                }
             }
-            switch (columnIndex) {
-                case 2: // SearchManager.SUGGEST_COLUMN_TEXT_1
-                    return "Google Search for \"" + mString + "\"";
-                case 1: // SearchManager.SUGGEST_COLUMN_INTENT_DATA
-                    return BrowserActivity.composeSearchUrl(mString);
-                case 3: // SearchManager.SUGGEST_COLUMN_TEXT_2
-                default:
-                    return "";
+            return null;
+        }
+
+        @Override
+        public double getDouble(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public float getFloat(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public int getInt(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public long getLong(int column) {
+            if ((mPos != -1) && column == 0) {
+                return mPos;        // use row# as the _Id
             }
+            throw new UnsupportedOperationException();
         }
 
-        public short getShort(int columnIndex) {
-            if (!mBeyondCursor) {
-                return mCursor.getShort(columnIndex);
-            }
-            if (0 == columnIndex) {
-                return 0;
-            }
-            return -1;
+        @Override
+        public short getShort(int column) {
+            throw new UnsupportedOperationException();
         }
 
-        public int getInt(int columnIndex) {
-            if (!mBeyondCursor) {
-                return mCursor.getInt(columnIndex);
-            }
-            if (0 == columnIndex) {
-                return 0;
-            }
-            return -1;
-        }
-
-        public long getLong(int columnIndex) {
-            if (!mBeyondCursor) {
-                return mCursor.getLong(columnIndex);
-            }
-            if (0 == columnIndex) {
-                return 0;
-            }
-            return -1;
-        }
-
-        public float getFloat(int columnIndex) {
-            if (!mBeyondCursor) {
-                return mCursor.getFloat(columnIndex);
-            }
-            if (0 == columnIndex) {
-                return 0f;
-            }
-            return -1f;
-        }
-
-        public double getDouble(int columnIndex) {
-            if (!mBeyondCursor) {
-                return mCursor.getDouble(columnIndex);
-            }
-            if (0 == columnIndex) {
-                return 0.0;
-            }
-            return -1.0;
-        }
-
-        public boolean isNull(int columnIndex) {
-            return mCursor.isNull(columnIndex);
-        }
-
-        public boolean supportsUpdates() {
-            return false;
-        }
-
-        public boolean hasUpdates() {
-            return false;
-        }
-
-        public boolean updateString(int columnIndex, String value) {
-            return false;
-        }
-
-        public boolean updateShort(int columnIndex, short value) {
-            return false;
-        }
-
-        public boolean updateInt(int columnIndex, int value) {
-            return false;
-        }
-
-        public boolean updateLong(int columnIndex, long value) {
-            return false;
-        }
-
-        public boolean updateFloat(int columnIndex, float value) {
-            return false;
-        }
-
-        public boolean updateDouble(int columnIndex, double value) {
-            return false;
+        @Override
+        public boolean isNull(int column) {
+            throw new UnsupportedOperationException();
         }
 
         // TODO Temporary change, finalize after jq's changes go in
         public void deactivate() {
-            if (mCursor != null) {
-                mCursor.deactivate();
+            if (mHistoryCursor != null) {
+                mHistoryCursor.deactivate();
+            }
+            if (mSuggestCursor != null) {
+                mSuggestCursor.deactivate();
             }
             super.deactivate();
         }
 
         public boolean requery() {
-            return mCursor.requery();
+            return (mHistoryCursor != null ? mHistoryCursor.requery() : false) |
+                    (mSuggestCursor != null ? mSuggestCursor.requery() : false);
         }
 
         // TODO Temporary change, finalize after jq's changes go in
         public void close() {
             super.close();
-            if (mCursor != null) {
-                mCursor.close();
-                mCursor = null;
+            if (mHistoryCursor != null) {
+                mHistoryCursor.close();
+                mHistoryCursor = null;
             }
-        }
-
-        public void registerContentObserver(ContentObserver observer) {
-            super.registerContentObserver(observer);
-        }
-
-        public void unregisterContentObserver(ContentObserver observer) {
-            super.unregisterContentObserver(observer);
-        }
-
-        public void registerDataSetObserver(DataSetObserver observer) {
-            super.registerDataSetObserver(observer);
-        }
-
-        public void unregisterDataSetObserver(DataSetObserver observer) {
-            super.unregisterDataSetObserver(observer);
-        }
-
-        protected void onChange(boolean selfChange) {
-            synchronized (mObserverLock) {
-                super.onChange(selfChange);
-                if (mNotifyUri != null && selfChange) {
-                    mContentResolver.notifyChange(mNotifyUri, mObserver);
-                }
+            if (mSuggestCursor != null) {
+                mSuggestCursor.close();
+                mSuggestCursor = null;
             }
         }
-
-        public void setNotificationUri(ContentResolver cr, Uri uri) {
-            synchronized (mObserverLock) {
-                if (mObserver != null) {
-                    cr.unregisterContentObserver(mObserver);
-                }
-                mObserver = new AbstractCursor.SelfContentObserver(this);
-                cr.registerContentObserver(uri, true, mObserver);
-                mCursor.setNotificationUri(cr, uri);
-                super.setNotificationUri(cr, uri);
-                mContentResolver = cr;
-                mNotifyUri = uri;
-            }
-        }
-
-        public boolean getWantsAllOnMoveCalls() {
-            return mCursor.getWantsAllOnMoveCalls();
-        }
     }
 
     @Override
@@ -455,13 +451,58 @@
                     suggestSelection = SUGGEST_SELECTION;
                 }
             }
-            // Suggestions are always performed with the default sort order:
-            // date ASC.
+
             Cursor c = db.query(TABLE_NAMES[URI_MATCH_BOOKMARKS],
                     SUGGEST_PROJECTION, suggestSelection, myArgs, null, null,
-                    ORDER_BY, null);
-            c.setNotificationUri(getContext().getContentResolver(), url);
-            return new MySuggestionCursor(c, selectionArgs[0]);
+                    ORDER_BY,
+                    (new Integer(MAX_SUGGESTION_LONG_ENTRIES)).toString());
+
+            if (Regex.WEB_URL_PATTERN.matcher(selectionArgs[0]).matches()) {
+                return new MySuggestionCursor(c, null, "");
+            } else {
+                // get Google suggest if there is still space in the list
+                if (myArgs != null && myArgs.length > 1
+                        && c.getCount() < (MAX_SUGGESTION_SHORT_ENTRIES - 1)) {
+                    ISearchManager sm = ISearchManager.Stub
+                            .asInterface(ServiceManager
+                                    .getService(Context.SEARCH_SERVICE));
+                    SearchableInfo si = null;
+                    try {
+                        // use the global search to get Google suggest provider
+                        si = sm.getSearchableInfo(new ComponentName(
+                                getContext(), "com.android.browser"), true);
+
+                        // similar to the getSuggestions() in SearchDialog.java
+                        StringBuilder uriStr = new StringBuilder("content://");
+                        uriStr.append(si.getSuggestAuthority());
+                        // if content path provided, insert it now
+                        final String contentPath = si.getSuggestPath();
+                        if (contentPath != null) {
+                            uriStr.append('/');
+                            uriStr.append(contentPath);
+                        }
+                        // append standard suggestion query path 
+                        uriStr.append('/' + SearchManager.SUGGEST_URI_PATH_QUERY);
+                        // inject query, either as selection args or inline
+                        String[] selArgs = null;
+                        if (si.getSuggestSelection() != null) {
+                            selArgs = new String[] {selectionArgs[0]};
+                        } else {
+                            uriStr.append('/');
+                            uriStr.append(Uri.encode(selectionArgs[0]));
+                        }
+
+                        // finally, make the query
+                        Cursor sc = getContext().getContentResolver().query(
+                                Uri.parse(uriStr.toString()), null,
+                                si.getSuggestSelection(), selArgs, null);
+
+                        return new MySuggestionCursor(c, sc, selectionArgs[0]);
+                    } catch (RemoteException e) {
+                    }
+                }
+                return new MySuggestionCursor(c, null, selectionArgs[0]);
+            }
         }
 
         String[] projection = null;
diff --git a/src/com/android/browser/BrowserSettings.java b/src/com/android/browser/BrowserSettings.java
index 6164e38..5038a4e 100644
--- a/src/com/android/browser/BrowserSettings.java
+++ b/src/com/android/browser/BrowserSettings.java
@@ -67,7 +67,6 @@
     private String homeUrl = "http://www.google.com/m?client=ms-" + 
         SystemProperties.get("ro.com.google.clientid", "unknown");
     private boolean loginInitialized = false;
-    private int orientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
     private boolean autoFitPage = true;
     private boolean showDebugSettings = false;
     
@@ -231,7 +230,6 @@
         loginInitialized = p.getBoolean("login_initialized", loginInitialized);
         textSize = WebSettings.TextSize.valueOf(
                 p.getString(PREF_TEXT_SIZE, textSize.name()));
-        orientation = p.getInt("orientation", orientation);
         autoFitPage = p.getBoolean("autofit_pages", autoFitPage);
         useWideViewPort = true; // use wide view port for either setting
         if (autoFitPage) {
@@ -301,22 +299,7 @@
         ed.putBoolean("login_initialized", loginInitialized);
         ed.commit();
     }
-    
-    public int getOrientation() {
-        return orientation;
-    }
-    
-    public void setOrientation(Context context, int o) {
-        if (orientation == o) {
-            return;
-        }
-        orientation = o;
-        Editor ed = PreferenceManager.
-                getDefaultSharedPreferences(context).edit();      
-        ed.putInt("orientation", orientation);
-        ed.commit();
-    }
-    
+
     public WebSettings.TextSize getTextSize() {
         return textSize;
     }
diff --git a/src/com/android/browser/CombinedBookmarkHistoryActivity.java b/src/com/android/browser/CombinedBookmarkHistoryActivity.java
new file mode 100644
index 0000000..963f179
--- /dev/null
+++ b/src/com/android/browser/CombinedBookmarkHistoryActivity.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2009 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.
+ */
+
+package com.android.browser;
+
+import android.app.Activity;
+import android.app.TabActivity;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.provider.Browser;
+import android.webkit.WebIconDatabase.IconListener;
+import android.widget.TabHost;
+import android.widget.TabHost.TabSpec;
+import android.view.Window;
+
+import java.util.HashMap;
+import java.util.Vector;
+
+public class CombinedBookmarkHistoryActivity extends TabActivity
+        implements TabHost.OnTabChangeListener {
+    /* package */ static String BOOKMARKS_TAB = "bookmark";
+    /* package */ static String VISITED_TAB = "visited";
+    /* package */ static String HISTORY_TAB = "history";
+    /* package */ static String STARTING_TAB = "tab";
+
+    static class IconListenerSet implements IconListener {
+        // Used to store favicons as we get them from the database
+        // FIXME: We use a different method to get the Favicons in
+        // BrowserBookmarksAdapter. They should probably be unified.
+        private HashMap<String, Bitmap> mUrlsToIcons;
+        private Vector<IconListener> mListeners;
+
+        public IconListenerSet() {
+            mUrlsToIcons = new HashMap<String, Bitmap>();
+            mListeners = new Vector<IconListener>();
+        }
+        public void onReceivedIcon(String url, Bitmap icon) {
+            mUrlsToIcons.put(url, icon);
+            for (IconListener listener : mListeners) {
+                listener.onReceivedIcon(url, icon);
+            }
+        }
+        public void addListener(IconListener listener) {
+            mListeners.add(listener);
+        }
+        public Bitmap getFavicon(String url) {
+            return (Bitmap) mUrlsToIcons.get(url);
+        }
+    }
+    private static IconListenerSet sIconListenerSet;
+    static IconListenerSet getIconListenerSet(ContentResolver cr) {
+        if (null == sIconListenerSet) {
+            sIconListenerSet = new IconListenerSet();
+            Browser.requestAllIcons(cr, null, sIconListenerSet);
+        }
+        return sIconListenerSet;
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(R.layout.tabs);
+        TabHost tabHost = getTabHost();
+        tabHost.setOnTabChangedListener(this);
+
+        Bundle extras = getIntent().getExtras();
+        Resources resources = getResources();
+
+        getIconListenerSet(getContentResolver());
+        Intent bookmarksIntent = new Intent(this, BrowserBookmarksPage.class);
+        bookmarksIntent.putExtras(extras);
+        tabHost.addTab(tabHost.newTabSpec(BOOKMARKS_TAB)
+                .setIndicator(resources.getString(R.string.tab_bookmarks),
+                resources.getDrawable(R.drawable.browser_bookmark_tab))
+                .setContent(bookmarksIntent));
+
+        Intent visitedIntent = new Intent(this, MostVisitedActivity.class);
+        visitedIntent.putExtras(extras);
+        tabHost.addTab(tabHost.newTabSpec(VISITED_TAB)
+                .setIndicator(resources.getString(R.string.tab_most_visited),
+                resources.getDrawable(R.drawable.browser_visited_tab))
+                .setContent(visitedIntent));
+
+        Intent historyIntent = new Intent(this, BrowserHistoryPage.class);
+        historyIntent.putExtras(extras);
+        tabHost.addTab(tabHost.newTabSpec(HISTORY_TAB)
+                .setIndicator(resources.getString(R.string.tab_history),
+                resources.getDrawable(R.drawable.
+                browser_history_tab)).setContent(historyIntent));
+
+        String defaultTab = extras.getString(STARTING_TAB);
+        if (defaultTab != null) {
+            tabHost.setCurrentTab(2);
+        }
+    }
+
+    // Copied from DialTacts Activity
+    /** {@inheritDoc} */
+    public void onTabChanged(String tabId) {
+        Activity activity = getLocalActivityManager().getActivity(tabId);
+        if (activity != null) {
+            activity.onWindowFocusChanged(true);
+        }
+    }
+
+    
+}
diff --git a/src/com/android/browser/FindDialog.java b/src/com/android/browser/FindDialog.java
index 2b26784..44109ff 100644
--- a/src/com/android/browser/FindDialog.java
+++ b/src/com/android/browser/FindDialog.java
@@ -29,6 +29,7 @@
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.Window;
+import android.view.WindowManager;
 import android.webkit.WebView;
 import android.widget.EditText;
 import android.widget.TextView;
@@ -121,6 +122,8 @@
         mMatches = (TextView) findViewById(R.id.matches);
         mMatchesView = findViewById(R.id.matches_view);
         disableButtons();
+        theWindow.setSoftInputMode(
+                WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
     }
     
     public void dismiss() {
diff --git a/src/com/android/browser/HistoryItem.java b/src/com/android/browser/HistoryItem.java
index c83ced1..55e43f0 100644
--- a/src/com/android/browser/HistoryItem.java
+++ b/src/com/android/browser/HistoryItem.java
@@ -17,26 +17,31 @@
  
 package com.android.browser;
 
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
 import android.content.Context;
+import android.database.Cursor;
 import android.graphics.Bitmap;
-import android.graphics.Color;
-import android.graphics.drawable.BitmapDrawable;
-import android.graphics.drawable.Drawable;
-import android.graphics.drawable.LayerDrawable;
-import android.graphics.drawable.PaintDrawable;
-import android.view.LayoutInflater;
-import android.widget.LinearLayout;
+import android.net.Uri;
+import android.provider.Browser;
+import android.util.Log;
+import android.view.View;
+import android.webkit.WebIconDatabase;
+import android.widget.CompoundButton;
+import android.widget.ImageView;
 import android.widget.TextView;
+import android.widget.Toast;
+
+import java.util.Date;
 
 /**
  *  Layout representing a history item in the classic history viewer.
  */
-/* package */ class HistoryItem extends LinearLayout {
+/* package */ class HistoryItem extends BookmarkItem {
 
-    private TextView    mTitleView; // Truncated Title
-    private String      mUrl;       // Full Url
-    private TextView    mUrlText;   // Truncated Url
-    
+    private CompoundButton  mStar;      // Star for bookmarking
+    private CompoundButton.OnCheckedChangeListener  mListener;
     /**
      *  Create a new HistoryItem.
      *  @param context  Context for this HistoryItem.
@@ -44,83 +49,79 @@
     /* package */ HistoryItem(Context context) {
         super(context);
 
-        setWillNotDraw(false);
-        LayoutInflater factory = LayoutInflater.from(context);
-        factory.inflate(R.layout.history_item, this);
-        mTitleView = (TextView) findViewById(R.id.title);
-        mUrlText = (TextView) findViewById(R.id.url);
+        mStar = (CompoundButton) findViewById(R.id.star);
+        mStar.setVisibility(View.VISIBLE);
+        mListener = new CompoundButton.OnCheckedChangeListener() {
+            public void onCheckedChanged(CompoundButton buttonView,
+                    boolean isChecked) {
+                ContentResolver cr = mContext.getContentResolver();
+                Cursor cursor = cr.query(
+                        Browser.BOOKMARKS_URI,
+                        Browser.HISTORY_PROJECTION,
+                        "url = ?",
+                        new String[] { mUrl },
+                        null);
+                boolean first = cursor.moveToFirst();
+                // Should be in the database no matter what
+                if (!first) {
+                    throw new AssertionError("URL is not in the database!");
+                }
+                if (isChecked) {
+                    // Add to bookmarks
+                    // FIXME: Share code with AddBookmarkPage.java
+                    ContentValues map = new ContentValues();
+                    map.put(Browser.BookmarkColumns.CREATED,
+                            new Date().getTime());
+                    map.put(Browser.BookmarkColumns.TITLE, getName());
+                    map.put(Browser.BookmarkColumns.BOOKMARK, 1);
+                    try {
+                        cr.update(Browser.BOOKMARKS_URI, map, 
+                                "_id = " + cursor.getInt(0), null);
+                    } catch (IllegalStateException e) {
+                        Log.e("HistoryItem", "no database!");
+                    }
+                    WebIconDatabase.getInstance().retainIconForPageUrl(mUrl);
+                    // catch IllegalStateException?
+                    Toast.makeText(mContext, R.string.added_to_bookmarks,
+                            Toast.LENGTH_LONG).show();
+                } else {
+                    // Remove from bookmarks
+                    // FIXME: This code should be shared with
+                    // BrowserBookmarksAdapter.java
+                    WebIconDatabase.getInstance().releaseIconForPageUrl(mUrl);
+                    Uri uri = ContentUris.withAppendedId(Browser.BOOKMARKS_URI,
+                            cursor.getInt(Browser.HISTORY_PROJECTION_ID_INDEX));
+                    // It is no longer a bookmark, but it is still a visited
+                    // site.
+                    ContentValues values = new ContentValues();
+                    values.put(Browser.BookmarkColumns.BOOKMARK, 0);
+                    try {
+                        cr.update(uri, values, null, null);
+                    } catch (IllegalStateException e) {
+                        Log.e("HistoryItem", "no database!");
+                    }
+                    Toast.makeText(mContext, R.string.removed_from_bookmarks,
+                            Toast.LENGTH_LONG).show();
+                }
+                cursor.deactivate();
+            }
+        };
     }
     
     void copyTo(HistoryItem item) {
-        item.mTitleView.setText(mTitleView.getText());
+        item.mTextView.setText(mTextView.getText());
         item.mUrlText.setText(mUrlText.getText());
-    }
-    
-    /**
-     * Return the name of this HistoryItem.
-     * @return  String name of this HistoryItem.
-     /
-    /* package */ String getName() {
-        return mTitleView.getText().toString();
+        item.setIsBookmark(mStar.isChecked());
+        item.mImageView.setImageDrawable(mImageView.getDrawable());
     }
 
     /**
-     * Return the url of this HistoryItem.
-     * @return  String url of this HistoryItem.
-     /
-    /* package */ String getUrl() {
-        return mUrl;
-    }
-
-    /**
-     *  Set the favicon for this item.
-     *
-     *  @param b    The new bitmap for this item.
-     *              If it is null, will use the default.
+     *  Set whether or not this represents a bookmark, and make sure the star
+     *  behaves appropriately.
      */
-    /* package */ void setFavicon(Bitmap b) {
-        Drawable[] array = new Drawable[2];
-        PaintDrawable p = new PaintDrawable(Color.WHITE);
-        p.setCornerRadius(3f);
-        array[0] = p;
-        if (b != null) {
-            array[1] = new BitmapDrawable(b);
-        } else {
-            array[1] = new BitmapDrawable(mContext.getResources().
-                    openRawResource(R.drawable.app_web_browser_sm));
-        }
-        LayerDrawable d = new LayerDrawable(array);
-        d.setLayerInset(1, 2, 2, 2, 2);
-        d.setBounds(0, 0, 20, 20);
-        mTitleView.setCompoundDrawables(d, null, null, null);
-    }
-    
-    /**
-     *  Set the name for this HistoryItem.
-     *  If the name is longer that BrowserSettings.MAX_TEXTVIEW_LEN characters, 
-     *  the name is truncated to BrowserSettings.MAX_TEXTVIEW_LEN characters. 
-     *  The History activity does not expose a UI element that can show the 
-     *  full title.
-     *  @param  name String representing new name for this HistoryItem.
-     */
-    /* package */ void setName(String name) {
-        if (name != null && name.length() > BrowserSettings.MAX_TEXTVIEW_LEN) {
-            name = name.substring(0, BrowserSettings.MAX_TEXTVIEW_LEN);
-        }
-        mTitleView.setText(name);
-    }
-    
-    /**
-     *  Set the url for this HistoryItem.
-     *  @param  url String representing new url for this HistoryItem.
-     */
-    /* package */ void setUrl(String url) {
-        mUrl = url;
-        // Truncate the url for the screen
-        if (url.length() > BrowserSettings.MAX_TEXTVIEW_LEN) {
-            mUrlText.setText(url.substring(0, BrowserSettings.MAX_TEXTVIEW_LEN));
-        } else {
-            mUrlText.setText(url);
-        }
+    void setIsBookmark(boolean isBookmark) {
+        mStar.setOnCheckedChangeListener(null);
+        mStar.setChecked(isBookmark);
+        mStar.setOnCheckedChangeListener(mListener);
     }
 }
diff --git a/src/com/android/browser/MostVisitedActivity.java b/src/com/android/browser/MostVisitedActivity.java
new file mode 100644
index 0000000..aeaf2a6
--- /dev/null
+++ b/src/com/android/browser/MostVisitedActivity.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2009 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.
+ */
+
+package com.android.browser;
+
+import android.app.Activity;
+import android.app.ListActivity;
+import android.content.Intent;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.database.DataSetObserver;
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.os.Handler;
+import android.provider.Browser;
+import android.webkit.WebIconDatabase.IconListener;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.SimpleCursorAdapter;
+import android.widget.TextView;
+import android.view.View;
+import android.view.ViewGroup;
+
+import java.util.Vector;
+
+public class MostVisitedActivity extends ListActivity {
+
+    private MyAdapter   mAdapter;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mAdapter = new MyAdapter();
+        CombinedBookmarkHistoryActivity.getIconListenerSet(getContentResolver())
+                .addListener(new IconReceiver());
+        setListAdapter(mAdapter);
+    }
+
+    private class IconReceiver implements IconListener {
+        public void onReceivedIcon(String url, Bitmap icon) {
+            setListAdapter(mAdapter);
+        }
+    }
+
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        TextView tv = (TextView) v.findViewById(R.id.url);
+        String url = tv.getText().toString();
+        loadUrl(url, false);
+    }
+
+    private void loadUrl(String url, boolean newWindow) {
+        Intent intent = new Intent().setAction(url);
+        if (newWindow) {
+            Bundle b = new Bundle();
+            b.putBoolean("new_window", true);
+            intent.putExtras(b);
+        }
+        setResultToParent(RESULT_OK, intent);
+        finish();
+    }
+
+    private class MyAdapter implements ListAdapter {
+        private Vector<DataSetObserver> mObservers;
+        private Cursor mCursor;
+        // These correspond with projection below.
+        private final int mUrlIndex = 0;
+        private final int mTitleIndex = 1;
+        private final int mBookmarkIndex = 2;
+
+        MyAdapter() {
+            mObservers = new Vector<DataSetObserver>();
+            String[] projection = new String[] {
+                    Browser.BookmarkColumns.URL,
+                    Browser.BookmarkColumns.TITLE,
+                    Browser.BookmarkColumns.BOOKMARK };
+            String whereClause = Browser.BookmarkColumns.VISITS + " != 0";
+            String orderBy = Browser.BookmarkColumns.VISITS + " DESC";
+            mCursor = managedQuery(Browser.BOOKMARKS_URI, projection,
+                    whereClause, null, orderBy);
+            mCursor.registerContentObserver(new ChangeObserver());
+        }
+
+        private class ChangeObserver extends ContentObserver {
+            public ChangeObserver() {
+                super(new Handler());
+            }
+
+            @Override
+            public boolean deliverSelfNotifications() {
+                return true;
+            }
+
+            @Override
+            public void onChange(boolean selfChange) {
+                MyAdapter.this.refreshData();
+            }
+        }
+
+        void refreshData() {
+            mCursor.requery();
+            for (DataSetObserver o : mObservers) {
+                o.onChanged();
+            }
+        }
+
+        public View getView(int position, View convertView, ViewGroup parent) {
+            HistoryItem item;
+            if (null == convertView) {
+                item = new HistoryItem(MostVisitedActivity.this);
+            } else {
+                item = (HistoryItem) convertView;
+            }
+            mCursor.moveToPosition(position);
+            item.setName(mCursor.getString(mTitleIndex));
+            String url = mCursor.getString(mUrlIndex);
+            item.setUrl(url);
+            item.setFavicon(CombinedBookmarkHistoryActivity.getIconListenerSet(
+                    getContentResolver()).getFavicon(url));
+            item.setIsBookmark(1 == mCursor.getInt(mBookmarkIndex));
+            return item;
+        }
+
+        public boolean areAllItemsEnabled() {
+            return true;
+        }
+
+        public boolean isEnabled(int position) {
+            return true;
+        }
+
+        public int getCount() {
+            return mCursor.getCount();
+        }
+
+        public Object getItem(int position) {
+            return null;
+        }
+
+        public long getItemId(int position) {
+            return position;
+        }
+
+        // Always a HistoryItem
+        public int getItemViewType(int position) {
+            return 0;
+        }
+
+        public int getViewTypeCount() {
+            return 1;
+        }
+
+        public boolean hasStableIds() {
+            return true;
+        }
+
+        public void registerDataSetObserver(DataSetObserver observer) {
+            mObservers.add(observer);
+        }
+
+        public void unregisterDataSetObserver(DataSetObserver observer) {
+            mObservers.remove(observer);
+        }
+
+        public boolean isEmpty() {
+            return getCount() == 0;
+        }
+    }
+
+    // This Activity is generally a sub-Activity of CombinedHistoryActivity. In
+    // that situation, we need to pass our result code up to our parent.
+    // However, if someone calls this Activity directly, then this has no
+    // parent, and it needs to set it on itself.
+    private void setResultToParent(int resultCode, Intent data) {
+        Activity a = getParent() == null ? this : getParent();
+        a.setResult(resultCode, data);
+    }
+}
+
diff --git a/src/com/android/browser/TabControl.java b/src/com/android/browser/TabControl.java
index dfac185..69610bf 100644
--- a/src/com/android/browser/TabControl.java
+++ b/src/com/android/browser/TabControl.java
@@ -17,7 +17,9 @@
 package com.android.browser;
 
 import android.content.Context;
+import android.net.http.SslError;
 import android.os.Bundle;
+import android.os.Message;
 import android.util.Config;
 import android.util.Log;
 import android.view.Gravity;
@@ -25,8 +27,10 @@
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.View.OnClickListener;
+import android.webkit.HttpAuthHandler;
 import android.webkit.JsPromptResult;
 import android.webkit.JsResult;
+import android.webkit.SslErrorHandler;
 import android.webkit.WebBackForwardList;
 import android.webkit.WebChromeClient;
 import android.webkit.WebHistoryItem;
@@ -79,6 +83,26 @@
         public boolean shouldOverrideUrlLoading(WebView view, String url) {
             return mClient.shouldOverrideUrlLoading(view, url);
         }
+        @Override
+        public void onReceivedSslError(WebView view, SslErrorHandler handler,
+                SslError error) {
+            mClient.onReceivedSslError(view, handler, error);
+        }
+        @Override
+        public void onReceivedHttpAuthRequest(WebView view,
+                HttpAuthHandler handler, String host, String realm) {
+            mClient.onReceivedHttpAuthRequest(view, handler, host, realm);
+        }
+        @Override
+        public void onFormResubmission(WebView view, Message dontResend,
+                Message resend) {
+            mClient.onFormResubmission(view, dontResend, resend);
+        }
+        @Override
+        public void onReceivedError(WebView view, int errorCode,
+                String description, String failingUrl) {
+            mClient.onReceivedError(view, errorCode, description, failingUrl);
+        }
     }
     // Subclass of WebChromeClient to display javascript dialogs.
     private class SubWindowChromeClient extends WebChromeClient {
