diff --git a/docs/html/guide/index.jd b/docs/html/guide/index.jd
index 38f71c0..8378472 100644
--- a/docs/html/guide/index.jd
+++ b/docs/html/guide/index.jd
@@ -34,9 +34,9 @@
 designing a user interface and setting up resources to storing 
 data and using permissions &mdash; as needed.</dd>
 
-<dt><b>Android Market Topics</b></dt>
-<dd>Documentation for topics that concern publishing and monetizing applications on Android
-Market, such as how to enforce licensing policies and implement in-app billing.</dd>
+<dt><b>Google Play Topics</b></dt>
+<dd>Documentation for topics that concern publishing and monetizing applications on Google Play,
+such as how to enforce licensing policies and implement in-app billing.</dd>
 
 <dt><b>Developing</b></dt>
 <dd>Directions for using Android's development and debugging tools, 
diff --git a/docs/html/guide/market/billing/billing_integrate.jd b/docs/html/guide/market/billing/billing_integrate.jd
index 57f685b..b49dc25 100755
--- a/docs/html/guide/market/billing/billing_integrate.jd
+++ b/docs/html/guide/market/billing/billing_integrate.jd
@@ -91,8 +91,8 @@
 
 <tr>
 <td>IMarketBillingService.aidl</td>
-<td>Android Interface Definition Library (AIDL) file that defines the IPC interface to Android
-Market's in-app billing service (<code>MarketBillingService</code>).</td>
+<td>Android Interface Definition Library (AIDL) file that defines the IPC interface to Google
+Play's in-app billing service (<code>MarketBillingService</code>).</td>
 </tr>
 
 <tr>
diff --git a/docs/html/guide/market/expansion-files.jd b/docs/html/guide/market/expansion-files.jd
index 26e63ec..01acb33 100644
--- a/docs/html/guide/market/expansion-files.jd
+++ b/docs/html/guide/market/expansion-files.jd
@@ -408,8 +408,8 @@
 download your expansion files. The information in the following sections explain how to integrate
 the library into your application.</p>
 
-<p>If you'd rather develop your own solution to download the expansion files using the Android
-Market URLs, you must follow the <a href="{@docRoot}guide/market/licensing/index.html">Application
+<p>If you'd rather develop your own solution to download the expansion files using the Google
+Play URLs, you must follow the <a href="{@docRoot}guide/market/licensing/index.html">Application
 Licensing</a> documentation to perform a license request, then retrieve the expansion file names,
 sizes, and URLs from the response extras. You should use the <a href="#ExpansionPolicy">{@code
 APKExpansionPolicy}</a> class (included in the License Verification Library) as your licensing
diff --git a/docs/html/guide/market/licensing/index.jd b/docs/html/guide/market/licensing/index.jd
index b9a7154..1f15303 100644
--- a/docs/html/guide/market/licensing/index.jd
+++ b/docs/html/guide/market/licensing/index.jd
@@ -9,8 +9,8 @@
 
 <p>Using the service, you can apply a flexible licensing policy on an application-by-application
 basis&mdash;each application can enforce licensing in the way most appropriate for it. If necessary,
-an application can apply custom constraints based on the licensing status obtained from Android
-Market. For example, an application can check the licensing status and then apply custom constraints
+an application can apply custom constraints based on the licensing status obtained from Google Play.
+For example, an application can check the licensing status and then apply custom constraints
 that allow the user to run it unlicensed for a specific validity period. An application can also
 restrict use of the application to a specific device, in addition to any other constraints. </p>
 
diff --git a/docs/html/sdk/oem-usb.jd b/docs/html/sdk/oem-usb.jd
index addcc5e..818a0af 100644
--- a/docs/html/sdk/oem-usb.jd
+++ b/docs/html/sdk/oem-usb.jd
@@ -34,7 +34,7 @@
 href="{@docRoot}guide/developing/device.html">Using Hardware Devices</a>.</p>
 
 <p class="note"><strong>Note:</strong> If your device is one of the Android Developer Phones
-(purchased from the Android Market publisher site), a Nexus One, or a Nexus S, then you need
+(ADP), a Nexus One, or a Nexus S, then you need
 the <a href="{@docRoot}sdk/win-usb.html">Google USB Driver</a>, instead of an OEM driver. The Galaxy
 Nexus driver, however, is distributed by <a
 href="http://www.samsung.com/us/support/downloads/verizon-wireless/SCH-I515MSAVZW">Samsung</a>
