diff --git a/core/java/android/app/SearchManager.java b/core/java/android/app/SearchManager.java
index 3265ac4..7f5a1e7 100644
--- a/core/java/android/app/SearchManager.java
+++ b/core/java/android/app/SearchManager.java
@@ -330,8 +330,8 @@
  * you'll need to update your searchable activity (or other activities) to receive the intents
  * as you've defined them.</li>
  * <li>Implement a Content Provider that provides suggestions.  If you already have one, and it 
- * has access to your suggestions data.  If not, you'll have to create one.
- * You'll also provide information about your Content Provider in your 
+ * has access to your suggestions data, you can use that provider. If not, you'll have to create 
+ * one. You'll also provide information about your Content Provider in your 
  * package's <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">manifest</a>.</li>
  * <li>Update your searchable activity's XML configuration file.  There are two categories of
  * information used for suggestions:
@@ -1181,7 +1181,7 @@
  *     Bundle appData = new Bundle();
  *     appData.put...();
  *     appData.put...();
- *     startSearch(null, false, appData);
+ *     startSearch(null, false, appData, false);
  *     return true;
  * }</pre> 
  *
diff --git a/core/java/android/util/AttributeSet.java b/core/java/android/util/AttributeSet.java
index 01a7ad4..82592b9 100644
--- a/core/java/android/util/AttributeSet.java
+++ b/core/java/android/util/AttributeSet.java
@@ -34,13 +34,13 @@
  * <p>This interface provides an efficient mechanism for retrieving
  * data from compiled XML files, which can be retrieved for a particular
  * XmlPullParser through {@link Xml#asAttributeSet
- * Xml.getAttributeSet()}.  Normally this will return an implementation
+ * Xml.asAttributeSet()}.  Normally this will return an implementation
  * of the interface that works on top of a generic XmlPullParser, however it
  * is more useful in conjunction with compiled XML resources:
  * 
  * <pre>
  * XmlPullParser parser = resources.getXml(myResouce);
- * AttributeSet attributes = Xml.getAttributeSet(parser);</pre>
+ * AttributeSet attributes = Xml.asAttributeSet(parser);</pre>
  * 
  * <p>The implementation returned here, unlike using
  * the implementation on top of a generic XmlPullParser,
diff --git a/core/java/android/util/DisplayMetrics.java b/core/java/android/util/DisplayMetrics.java
index 74f01cc..2628eb4 100644
--- a/core/java/android/util/DisplayMetrics.java
+++ b/core/java/android/util/DisplayMetrics.java
@@ -69,7 +69,7 @@
      * Density Independent Pixel unit, where one DIP is one pixel on an
      * approximately 160 dpi screen (for example a 240x320, 1.5"x2" screen), 
      * providing the baseline of the system's display. Thus on a 160dpi screen 
-     * this density value will be 1; on a 106 dpi screen it would be .75; etc.
+     * this density value will be 1; on a 120 dpi screen it would be .75; etc.
      *  
      * <p>This value does not exactly follow the real screen size (as given by 
      * {@link #xdpi} and {@link #ydpi}, but rather is used to scale the size of
diff --git a/docs/html/guide/appendix/api-levels.jd b/docs/html/guide/appendix/api-levels.jd
index 0830032..cebd2d4 100644
--- a/docs/html/guide/appendix/api-levels.jd
+++ b/docs/html/guide/appendix/api-levels.jd
@@ -18,7 +18,7 @@
     </ol>
   </li>
   <li><a href="#provisional">Using a Provisional API Level</a></li>
-  <li><a href="#filtering">Filtering the Reference Documentation by API Level</a></li>
+  <li><a href="#filtering">Filtering the Documentation</a></li>
 </ol>
 
   <h2>See also</h2>
diff --git a/docs/html/guide/practices/design/responsiveness.jd b/docs/html/guide/practices/design/responsiveness.jd
index ecd743d..1d5a235 100644
--- a/docs/html/guide/practices/design/responsiveness.jd
+++ b/docs/html/guide/practices/design/responsiveness.jd
@@ -80,7 +80,7 @@
 event timeout. These same practices should be followed for any other threads
 that display UI, as they are also subject to the same timeouts.</p>
 
-<p>The specific constraint on IntentReciever execution time emphasizes what
+<p>The specific constraint on IntentReceiver execution time emphasizes what
 they were meant to do: small, discrete amounts of work in the background such
 as saving a setting or registering a Notification. So as with other methods
 called in the main thread, applications should avoid potentially long-running
diff --git a/docs/html/guide/practices/ui_guidelines/icon_design.jd b/docs/html/guide/practices/ui_guidelines/icon_design.jd
index 5f0a278..e5a1b5e2 100644
--- a/docs/html/guide/practices/ui_guidelines/icon_design.jd
+++ b/docs/html/guide/practices/ui_guidelines/icon_design.jd
@@ -847,118 +847,118 @@
 <tr>
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_alarmclock.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_alarmclock.png" alt="Android asset" />
   <div class="caption">Alarm Clock</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_browser.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_browser.png" alt="Android asset" />
   <div class="caption">Browser</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_calculator.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_calculator.png" alt="Android asset" />
   <div class="caption">Calculator</div></td>
 	
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_calendar.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_calendar.png" alt="Android asset" />
   <div class="caption">Calendar</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_video_camera.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_video_camera.png" alt="Android asset" />
   <div class="caption">Camcorder</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_camera.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_camera.png" alt="Android asset" />
   <div class="caption">Camera</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_contacts.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_contacts.png" alt="Android asset" />
   <div class="caption">Contacts</div></td>
 
 </tr>
 <tr>
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_phone_dialer.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_phone_dialer.png" alt="Android asset" />
   <div class="caption">Dialer</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_email_generic.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_email_generic.png" alt="Android asset" />
   <div class="caption">Email</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_gallery.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_gallery.png" alt="Android asset" />
   <div class="caption">Gallery</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_generic_application.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_generic_application.png" alt="Android asset" />
   <div class="caption">Generic application</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_email.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_email.png" alt="Android asset" />
   <div class="caption">Gmail</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_google_talk.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_google_talk.png" alt="Android asset" />
   <div class="caption">Google Talk</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_IM.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_IM.png" alt="Android asset" />
   <div class="caption">IM</div></td>
 
 </tr>
 <tr>
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_maps.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_maps.png" alt="Android asset" />
   <div class="caption">Maps</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_marketplace.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_marketplace.png" alt="Android asset" />
   <div class="caption">Market </div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_sms_mms.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_sms_mms.png" alt="Android asset" />
   <div class="caption">Messaging </div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_musicplayer_2.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_musicplayer_2.png" alt="Android asset" />
   <div class="caption">Music</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_settings.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_settings.png" alt="Android asset" />
   <div class="caption">Settings</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_voicedial.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_voicedial.png" alt="Android asset" />
   <div class="caption">Voice Dialer</div></td>
 
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_voicesearch.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_voicesearch.png" alt="Android asset" />
   <div class="caption">Voice Search</div></td>
 
 </tr>
 <tr>
 
 <td class="image-caption-i image-list">
-  <img src="/images/icon_design/ic_launcher_youtube.png" alt="Android asset" />
+  <img src="{@docRoot}images/icon_design/ic_launcher_youtube.png" alt="Android asset" />
   <div class="caption">YouTube</div></td>
 </tr>
 </table>
diff --git a/docs/html/guide/publishing/versioning.jd b/docs/html/guide/publishing/versioning.jd
index 8d8b304..0bec658 100644
--- a/docs/html/guide/publishing/versioning.jd
+++ b/docs/html/guide/publishing/versioning.jd
@@ -165,4 +165,4 @@
 <p>For more information, see the <a
 href="{@docRoot}guide/developing/manifest/uses-sdk-element.html"><code>&lt;uses-
 sdk&gt;</code></a> manifest element documentation and the <a
-href="{@docRoot}guide/appendix/api-levels.htmll">API Levels</a> document.</p>
+href="{@docRoot}guide/appendix/api-levels.html">API Levels</a> document.</p>
diff --git a/docs/html/sdk/1.5_r3/upgrading.jd b/docs/html/sdk/1.5_r3/upgrading.jd
index c79b656..f853d25 100644
--- a/docs/html/sdk/1.5_r3/upgrading.jd
+++ b/docs/html/sdk/1.5_r3/upgrading.jd
@@ -187,7 +187,7 @@
 
 <p>If you encounter problems, ensure your ADT is fully uninstalled and then
 follow the guide to 
-<a href="installingplugin">Installing the ADT Plugin
+<a href="installing.html#installingplugin">Installing the ADT Plugin
 for Eclipse</a>.</p>
 
 <h3 id="updateEclipsePrefs">Update your Eclipse SDK Preferences</h3>
diff --git a/docs/html/sdk/installing.jd b/docs/html/sdk/installing.jd
index 66c6bdc..edc77e8 100644
--- a/docs/html/sdk/installing.jd
+++ b/docs/html/sdk/installing.jd
@@ -360,7 +360,7 @@
 </ul>
 
 
-<h2 id="troubleshooting">Installation Troubleshooting</h2>
+<h2 id="troubleshooting">Troubleshooting</h2>
 
 <h3>Ubuntu Linux Notes</h3>
 
diff --git a/docs/html/search.jd b/docs/html/search.jd
index 8032b22..d0e7478 100644
--- a/docs/html/search.jd
+++ b/docs/html/search.jd
@@ -70,8 +70,8 @@
         searchControl.setSearchStartingCallback(this, function(control, searcher, query) {
             // save the tab index from the hash
             tabIndex = location.hash.split("&t=")[1];
-        
-            $("#searchTitle").html("search results for <em>" + query + "</em>");
+
+            $("#searchTitle").html("search results for <em>" + escapeHTML(query) + "</em>");
             $.history.add('q=' + query + '&t=' + tabIndex);
             openTab();
         });
@@ -96,7 +96,8 @@
       $(window).history(function(e, hash) {
         var query = decodeURI(getQuery(hash));
         searchControl.execute(query);
-        $("#searchTitle").html("search results for <em>" + query + "</em>");
+
+        $("#searchTitle").html("search results for <em>" + escapeHTML(query) + "</em>");
       });
 
       // forcefully regain key-up event control (previously jacked by search api)
@@ -131,6 +132,13 @@
         return queryParts[1];
       }
 
+      /* returns the given string with all HTML brackets converted to entities
+         TODO: move this to the site's JS library */
+      function escapeHTML(string) {
+        return string.replace(/</g,"&lt;")
+                     .replace(/>/g,"&gt;");
+      }
+
 </script>
 
   <div id="mainBodyFixed" style="width:auto; margin:20px">
diff --git a/docs/html/videos/index.jd b/docs/html/videos/index.jd
index ddb9f86..4e53aac 100644
--- a/docs/html/videos/index.jd
+++ b/docs/html/videos/index.jd
@@ -37,12 +37,10 @@
  * Each playlist ID is paired with a custom video description.
  */
 var featured = {
-// Android 1.6 Release
-  'MBRFkLKRwFw' : "The Android 1.6 release includes new features and improvements to the Android platform. Here's an introduction to what's new in Android 1.6.",
+// Android 2.0 Release
+  'opZ69P-0Jbc' : "The Android 2.0 platform adds exciting new user features and developer APIs. Here's an introduction to what's new.",
 // How to Make your Android UI Fast..
   'N6YdwzAvwOA' : "Make your user interface fast, with more efficient AdapterViews, better bitmap scaling, faster redrawing, ViewStub layouts, fewer Views, and more.", 
-// Coding for Life: Battery Life
-//  'OUemfrKe65c' : "Learn what kinds of operations consume the most battery and how you can reduce your usage, with tips for parsing and zipping data, using wakelocks, and running a Service.",
 // How Do I Code Thee?
   'GARMe7Km_gk' : "If you'd like to augment your Android applications with pieces written in JavaScript or native code, watch this video."
 };
