Bug 578262: Clean up style in and remove build warnings from new-ishly merged e10s code. r=bsmedberg
authorChris Jones <jones.chris.g@gmail.com>
Mon, 19 Jul 2010 13:33:33 -0500
changeset 47933 62d0fbc0e2ba2a6c64917bc2e8b121107205f7e2
parent 47932 42b67d331734261570f95b4d1908f0d4716790c8
child 47934 bfba1780141db46360e119075bd52ea55a0ab8ee
push id14487
push usercjones@mozilla.com
push dateMon, 19 Jul 2010 18:33:48 +0000
treeherdermozilla-central@bfba1780141d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbsmedberg
bugs578262
milestone2.0b2pre
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 578262: Clean up style in and remove build warnings from new-ishly merged e10s code. r=bsmedberg
chrome/src/nsChromeRegistryChrome.cpp
chrome/src/nsChromeRegistryChrome.h
content/base/src/nsFrameLoader.cpp
content/base/src/nsFrameLoader.h
content/canvas/src/nsCanvasRenderingContext2D.cpp
dom/ipc/ContentChild.cpp
dom/ipc/ContentChild.h
dom/ipc/ContentParent.cpp
dom/ipc/ContentParent.h
dom/ipc/ContentProcess.cpp
dom/ipc/ContentProcess.h
dom/ipc/ContentProcessChild.cpp
dom/ipc/ContentProcessChild.h
dom/ipc/ContentProcessParent.cpp
dom/ipc/ContentProcessParent.h
dom/ipc/ContentProcessProcess.cpp
dom/ipc/ContentProcessProcess.h
dom/ipc/Makefile.in
dom/ipc/PBrowser.ipdl
dom/ipc/PContent.ipdl
dom/ipc/PContentDialog.ipdl
dom/ipc/PContentProcess.ipdl
dom/ipc/PDocumentRenderer.ipdl
dom/ipc/PDocumentRendererNativeID.ipdl
dom/ipc/PDocumentRendererShmem.ipdl
dom/ipc/PIFrameEmbedding.ipdl
dom/ipc/TabChild.cpp
dom/ipc/TabChild.h
dom/ipc/TabParent.cpp
dom/ipc/TabParent.h
dom/ipc/ipdl.mk
dom/src/geolocation/PGeolocationRequest.ipdl
dom/src/geolocation/nsGeolocation.cpp
extensions/cookie/nsPermissionManager.cpp
ipc/testshell/PTestShell.ipdl
ipc/testshell/TestShellParent.cpp
js/ipc/ContextWrapperParent.h
js/ipc/ObjectWrapperChild.cpp
js/ipc/ObjectWrapperParent.cpp
modules/libpref/src/nsPrefBranch.cpp
netwerk/ipc/NeckoChild.cpp
netwerk/ipc/NeckoChild.h
netwerk/ipc/NeckoParent.cpp
netwerk/ipc/NeckoParent.h
netwerk/ipc/PNecko.ipdl
netwerk/protocol/http/HttpChannelParent.cpp
netwerk/protocol/http/HttpChannelParent.h
toolkit/xre/nsEmbedFunctions.cpp
--- a/chrome/src/nsChromeRegistryChrome.cpp
+++ b/chrome/src/nsChromeRegistryChrome.cpp
@@ -32,17 +32,17 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifdef MOZ_IPC
-#include "mozilla/dom/PContentProcessParent.h"
+#include "mozilla/dom/PContentParent.h"
 #include "RegistryMessageUtils.h"
 #include "nsResProtocolHandler.h"
 #endif
 
 #include "nsChromeRegistryChrome.h"
 
 #if defined(XP_WIN)
 #include <windows.h>
@@ -461,17 +461,17 @@ struct EnumerationArgs
 {
   nsTArray<ChromePackage>& packages;
   const nsCString& selectedLocale;
   const nsCString& selectedSkin;
 };
 
 void
 nsChromeRegistryChrome::SendRegisteredChrome(
-    mozilla::dom::PContentProcessParent* aParent)
+    mozilla::dom::PContentParent* aParent)
 {
   nsTArray<ChromePackage> packages;
   nsTArray<ResourceMapping> resources;
   nsTArray<OverrideMapping> overrides;
 
   EnumerationArgs args = {
     packages, mSelectedLocale, mSelectedSkin
   };
--- a/chrome/src/nsChromeRegistryChrome.h
+++ b/chrome/src/nsChromeRegistryChrome.h
@@ -38,17 +38,17 @@
 
 #ifndef nsChromeRegistryChrome_h
 #define nsChromeRegistryChrome_h
 
 #include "nsChromeRegistry.h"
 
 namespace mozilla {
 namespace dom {
-class PContentProcessParent;
+class PContentParent;
 }
 }
 
 class nsIPrefBranch;
 
 class nsChromeRegistryChrome : public nsChromeRegistry
 {
  public:
@@ -71,17 +71,17 @@ class nsChromeRegistryChrome : public ns
 #ifdef MOZ_XUL
   NS_OVERRIDE NS_IMETHOD GetXULOverlays(nsIURI *aURI,
                                         nsISimpleEnumerator **_retval);
   NS_OVERRIDE NS_IMETHOD GetStyleOverlays(nsIURI *aURI,
                                           nsISimpleEnumerator **_retval);
 #endif
   
 #ifdef MOZ_IPC
-  void SendRegisteredChrome(mozilla::dom::PContentProcessParent* aChild);
+  void SendRegisteredChrome(mozilla::dom::PContentParent* aChild);
 #endif
 
  private:
 #ifdef MOZ_IPC
   static PLDHashOperator CollectPackages(PLDHashTable *table,
                                          PLDHashEntryHdr *entry,
                                          PRUint32 number, void *arg);
 #endif
--- a/content/base/src/nsFrameLoader.cpp
+++ b/content/base/src/nsFrameLoader.cpp
@@ -105,26 +105,27 @@
 
 #include "nsThreadUtils.h"
 #include "nsIContentViewer.h"
 #include "nsIView.h"
 
 #include "nsIDOMChromeWindow.h"
 #include "nsInProcessTabChildGlobal.h"
 #include "mozilla/AutoRestore.h"
+#include "mozilla/unused.h"
 
 #ifdef MOZ_WIDGET_GTK2
 #include "mozcontainer.h"
 
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 #endif
 
 #ifdef MOZ_IPC
-#include "ContentProcessParent.h"
+#include "ContentParent.h"
 #include "TabParent.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 #endif
 
 #include "jsapi.h"
 
@@ -297,27 +298,27 @@ nsFrameLoader::ReallyStartLoadingInterna
 
   nsresult rv = MaybeCreateDocShell();
   if (NS_FAILED(rv)) {
     return rv;
   }
 
 #ifdef MOZ_IPC
   if (mRemoteFrame) {
-    if (!mChildProcess) {
+    if (!mRemoteBrowser) {
       TryNewProcess();
     }
 
-    if (!mChildProcess) {
+    if (!mRemoteBrowser) {
       NS_WARNING("Couldn't create child process for iframe.");
       return NS_ERROR_FAILURE;
     }
 
     // FIXME get error codes from child
-    mChildProcess->LoadURL(mURIToLoad);
+    mRemoteBrowser->LoadURL(mURIToLoad);
     return NS_OK;
   }
 #endif
 
   NS_ASSERTION(mDocShell,
                "MaybeCreateDocShell succeeded with a null mDocShell");
 
   // Just to be safe, recheck uri.
@@ -424,23 +425,23 @@ nsFrameLoader::GetDocShell(nsIDocShell *
 
 NS_IMETHODIMP
 nsFrameLoader::GetWebProgress(nsIWebProgress **aWebProgress)
 {
   nsresult rv;
   *aWebProgress = nsnull;
 #ifdef MOZ_IPC
   if (mRemoteFrame) {
-    if (!mChildProcess) {
+    if (!mRemoteBrowser) {
       TryNewProcess();
     }
-    if (!mChildProcess) {
+    if (!mRemoteBrowser) {
       return NS_ERROR_UNEXPECTED;
     }
-    *aWebProgress = mChildProcess;
+    *aWebProgress = mRemoteBrowser;
     NS_ADDREF(*aWebProgress);
     return NS_OK;
   }
 #endif
 
   nsCOMPtr<nsIDocShell> shell;
   rv = GetDocShell(getter_AddRefs(shell));
   if (NS_SUCCEEDED(rv)) {
@@ -750,38 +751,39 @@ nsFrameLoader::Show(PRInt32 marginWidth,
 }
 
 #ifdef MOZ_IPC
 bool
 nsFrameLoader::ShowRemoteFrame(nsIFrameFrame* frame, nsIView* view)
 {
   NS_ASSERTION(mRemoteFrame, "ShowRemote only makes sense on remote frames.");
 
-  if (!mChildProcess) {
+  if (!mRemoteBrowser) {
     TryNewProcess();
   }
 
-  if (!mChildProcess) {
+  if (!mRemoteBrowser) {
     NS_ERROR("Couldn't create child process.");
     return false;
   }
 
   nsIWidget* w = view->GetWidget();
   if (!w) {
     NS_ERROR("Our view doesn't have a widget. Totally stuffed!");
     return false;
   }
 
   nsIntSize size = GetSubDocumentSize(frame->GetFrame());
 
 #ifdef XP_WIN
   HWND parentwin =
     static_cast<HWND>(w->GetNativeData(NS_NATIVE_WINDOW));
 
-  mChildProcess->SendcreateWidget(parentwin);
+  if (!mRemoteBrowser->SendCreateWidget(parentwin))
+    return false;
 #elif defined(MOZ_WIDGET_GTK2)
   GdkWindow* parent_win =
     static_cast<GdkWindow*>(w->GetNativeData(NS_NATIVE_WINDOW));
 
   gpointer user_data = nsnull;
   gdk_window_get_user_data(parent_win, &user_data);
 
   MozContainer* parentMozContainer = MOZ_CONTAINER(user_data);
@@ -794,46 +796,51 @@ nsFrameLoader::ShowRemoteFrame(nsIFrameF
   gtk_widget_realize(mRemoteSocket);
 
   // set the child window's size and position
   GtkAllocation alloc = { 0, 0, size.width, size.height };
   gtk_widget_size_allocate(mRemoteSocket, &alloc);
 
   gtk_widget_show(mRemoteSocket);
   GdkNativeWindow id = gtk_socket_get_id(GTK_SOCKET(mRemoteSocket));
-  mChildProcess->SendcreateWidget(id);
+  if (!mRemoteBrowser->SendCreateWidget(id))
+    return false;
+
 #elif defined(MOZ_WIDGET_QT)
   if (getenv("USE_XEMBED_PROXY")) {
     // Very bad idea to use Xembedding for IPC, but test-ipc.xul still rendering with XEmbed
     QGraphicsWidget *widget = static_cast<QGraphicsWidget*>(w->GetNativeData(NS_NATIVE_WINDOW));
     NS_ENSURE_TRUE(widget, false);
     QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget(widget);
     NS_ENSURE_TRUE(proxy, false);
     mRemoteSocket = new QX11EmbedContainer();
     NS_ENSURE_TRUE(mRemoteSocket, false);
     proxy->setWidget(mRemoteSocket);
     mRemoteSocket->show();
     mRemoteSocket->resize(size.width, size.height);
-    mChildProcess->SendcreateWidget(0);
+    if (!mRemoteBrowser->SendCreateWidget(0))
+      return false;
   } else {
     // Don't create any parent/child XEmbed, because we are painting with shared memory
-    mChildProcess->SendcreateWidget(0);
+    if (!mRemoteBrowser->SendCreateWidget(0))
+      return false;
   }
 #elif defined(ANDROID)
   // Painting with shared memory
 
-  mChildProcess->SendcreateWidget(0);
+  if (!mRemoteBrowser->SendCreateWidget(0))
+    return false;
 #elif defined(XP_MACOSX)
 #  warning IMPLEMENT ME
 
 #else
 #error TODO for this platform
 #endif
 
-  mChildProcess->Move(0, 0, size.width, size.height);
+  mRemoteBrowser->Move(0, 0, size.width, size.height);
   mRemoteWidgetCreated = PR_TRUE;
   nsCOMPtr<nsIChromeFrameMessageManager> dummy;
   GetMessageManager(getter_AddRefs(dummy)); // Initialize message manager.
 
   return true;
 }
 #endif
 
@@ -1156,20 +1163,20 @@ nsFrameLoader::SwapWithOtherLoader(nsFra
   mInSwap = aOther->mInSwap = PR_FALSE;
   return NS_OK;
 }
 
 void
 nsFrameLoader::DestroyChild()
 {
 #ifdef MOZ_IPC
-  if (mChildProcess) {
-    mChildProcess->SetOwnerElement(nsnull);
-    PIFrameEmbeddingParent::Send__delete__(mChildProcess);
-    mChildProcess = nsnull;
+  if (mRemoteBrowser) {
+    mRemoteBrowser->SetOwnerElement(nsnull);
+    unused << PBrowserParent::Send__delete__(mRemoteBrowser);
+    mRemoteBrowser = nsnull;
   }
 #endif
 }
 
 NS_IMETHODIMP
 nsFrameLoader::Destroy()
 {
   if (mDestroyCalled) {
@@ -1528,30 +1535,30 @@ nsFrameLoader::CheckForRecursiveLoad(nsI
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::UpdatePositionAndSize(nsIFrame *aIFrame)
 {
 #ifdef MOZ_IPC
   if (mRemoteFrame) {
-    if (mChildProcess) {
+    if (mRemoteBrowser) {
       nsIntSize size = GetSubDocumentSize(aIFrame);
 
 #ifdef MOZ_WIDGET_GTK2
       if (mRemoteSocket) {
         GtkAllocation alloc = {0, 0, size.width, size.height };
         gtk_widget_size_allocate(mRemoteSocket, &alloc);
       }
 #elif defined(MOZ_WIDGET_QT)
       if (mRemoteSocket)
         mRemoteSocket->resize(size.width, size.height);
 #endif
 
-      mChildProcess->Move(0, 0, size.width, size.height);
+      mRemoteBrowser->Move(0, 0, size.width, size.height);
     }
     return NS_OK;
   }
 #endif
   return UpdateBaseWindowPositionAndSize(aIFrame);
 }
 
 nsresult
@@ -1598,17 +1605,17 @@ nsFrameLoader::GetSubDocumentSize(const 
   return nsIntSize(presContext->AppUnitsToDevPixels(docSizeAppUnits.width),
                    presContext->AppUnitsToDevPixels(docSizeAppUnits.height));
 }
 
 #ifdef MOZ_IPC
 bool
 nsFrameLoader::TryNewProcess()
 {
-  NS_ASSERTION(!mChildProcess, "TryNewProcess called with a process already?");
+  NS_ASSERTION(!mRemoteBrowser, "TryNewProcess called with a process already?");
 
   nsIDocument* doc = mOwnerContent->GetDocument();
   if (!doc) {
     return false;
   }
 
   if (doc->GetDisplayDocument()) {
     // Don't allow subframe loads in external reference documents
@@ -1639,103 +1646,101 @@ nsFrameLoader::TryNewProcess()
   mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::type, value);
 
   if (!value.LowerCaseEqualsLiteral("content") &&
       !StringBeginsWith(value, NS_LITERAL_STRING("content-"),
                         nsCaseInsensitiveStringComparator())) {
     return false;
   }
 
-  ContentProcessParent* parent = ContentProcessParent::GetSingleton();
+  ContentParent* parent = ContentParent::GetSingleton();
   NS_ASSERTION(parent->IsAlive(), "Process parent should be alive; something is very wrong!");
-  mChildProcess = parent->CreateTab();
-  if (mChildProcess) {
+  mRemoteBrowser = parent->CreateTab();
+  if (mRemoteBrowser) {
     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mOwnerContent);
-    mChildProcess->SetOwnerElement(element);
+    mRemoteBrowser->SetOwnerElement(element);
 
     nsCOMPtr<nsIDocShellTreeItem> rootItem;
     parentAsItem->GetRootTreeItem(getter_AddRefs(rootItem));
     nsCOMPtr<nsIDOMWindow> rootWin = do_GetInterface(rootItem);
     nsCOMPtr<nsIDOMChromeWindow> rootChromeWin = do_QueryInterface(rootWin);
     NS_ABORT_IF_FALSE(rootChromeWin, "How did we not get a chrome window here?");
 
     nsCOMPtr<nsIBrowserDOMWindow> browserDOMWin;
     rootChromeWin->GetBrowserDOMWindow(getter_AddRefs(browserDOMWin));
-    mChildProcess->SetBrowserDOMWindow(browserDOMWin);
+    mRemoteBrowser->SetBrowserDOMWindow(browserDOMWin);
     
     mChildHost = parent;
   }
   return true;
 }
 #endif
 
 #ifdef MOZ_IPC
-mozilla::dom::PIFrameEmbeddingParent*
-nsFrameLoader::GetChildProcess()
+mozilla::dom::PBrowserParent*
+nsFrameLoader::GetRemoteBrowser()
 {
-  return mChildProcess;
+  return mRemoteBrowser;
 }
 #endif
 
 NS_IMETHODIMP
 nsFrameLoader::ActivateRemoteFrame() {
 #ifdef MOZ_IPC
-  if (mChildProcess) {
-    mChildProcess->Activate();
+  if (mRemoteBrowser) {
+    mRemoteBrowser->Activate();
     return NS_OK;
   }
 #endif
   return NS_ERROR_UNEXPECTED;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::SendCrossProcessMouseEvent(const nsAString& aType,
                                           float aX,
                                           float aY,
                                           PRInt32 aButton,
                                           PRInt32 aClickCount,
                                           PRInt32 aModifiers,
                                           PRBool aIgnoreRootScrollFrame)
 {
 #ifdef MOZ_IPC
-  if (mChildProcess) {
-    mChildProcess->SendMouseEvent(aType, aX, aY, aButton,
+  if (mRemoteBrowser) {
+    mRemoteBrowser->SendMouseEvent(aType, aX, aY, aButton,
                                   aClickCount, aModifiers,
                                   aIgnoreRootScrollFrame);
-    return NS_OK;
   }
 #endif
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::ActivateFrameEvent(const nsAString& aType,
                                   PRBool aCapture)
 {
 #ifdef MOZ_IPC
-  if (mChildProcess) {
-    mChildProcess->SendactivateFrameEvent(nsString(aType), aCapture);
-    return NS_OK;
+  if (mRemoteBrowser) {
+    return mRemoteBrowser->SendActivateFrameEvent(nsString(aType), aCapture) ?
+      NS_OK : NS_ERROR_NOT_AVAILABLE;
   }
 #endif
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::SendCrossProcessKeyEvent(const nsAString& aType,
                                         PRInt32 aKeyCode,
                                         PRInt32 aCharCode,
                                         PRInt32 aModifiers,
                                         PRBool aPreventDefault)
 {
 #ifdef MOZ_IPC
-  if (mChildProcess) {
-    mChildProcess->SendKeyEvent(aType, aKeyCode, aCharCode, aModifiers,
+  if (mRemoteBrowser) {
+    mRemoteBrowser->SendKeyEvent(aType, aKeyCode, aCharCode, aModifiers,
                                 aPreventDefault);
-    return NS_OK;
   }
 #endif
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::GetDelayRemoteDialogs(PRBool* aRetVal)
 {
@@ -1746,19 +1751,19 @@ nsFrameLoader::GetDelayRemoteDialogs(PRB
 #endif
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::SetDelayRemoteDialogs(PRBool aDelay)
 {
 #ifdef MOZ_IPC
-  if (mChildProcess && mDelayRemoteDialogs && !aDelay) {
+  if (mRemoteBrowser && mDelayRemoteDialogs && !aDelay) {
     nsRefPtr<nsIRunnable> ev =
-      NS_NewRunnableMethod(mChildProcess,
+      NS_NewRunnableMethod(mRemoteBrowser,
                            &mozilla::dom::TabParent::HandleDelayedDialogs);
     NS_DispatchToCurrentThread(ev);
   }
   mDelayRemoteDialogs = aDelay;
 #endif
   return NS_OK;
 }
 
@@ -1785,20 +1790,20 @@ nsFrameLoader::CreateStaticClone(nsIFram
 
   viewer->SetDOMDocument(clonedDOMDoc);
   return NS_OK;
 }
 
 bool LoadScript(void* aCallbackData, const nsAString& aURL)
 {
 #ifdef MOZ_IPC
-  mozilla::dom::PIFrameEmbeddingParent* tabParent =
-    static_cast<nsFrameLoader*>(aCallbackData)->GetChildProcess();
+  mozilla::dom::PBrowserParent* tabParent =
+    static_cast<nsFrameLoader*>(aCallbackData)->GetRemoteBrowser();
   if (tabParent) {
-    return tabParent->SendloadRemoteScript(nsString(aURL));
+    return tabParent->SendLoadRemoteScript(nsString(aURL));
   }
 #endif
   nsFrameLoader* fl = static_cast<nsFrameLoader*>(aCallbackData);
   nsRefPtr<nsInProcessTabChildGlobal> tabChild =
     static_cast<nsInProcessTabChildGlobal*>(fl->GetTabChildGlobalAsEventTarget());
   if (tabChild) {
     tabChild->LoadFrameScript(aURL);
   }
@@ -1828,21 +1833,20 @@ public:
   nsString mJSON;
 };
 
 bool SendAsyncMessageToChild(void* aCallbackData,
                              const nsAString& aMessage,
                              const nsAString& aJSON)
 {
 #ifdef MOZ_IPC
-  mozilla::dom::PIFrameEmbeddingParent* tabParent =
-    static_cast<nsFrameLoader*>(aCallbackData)->GetChildProcess();
+  mozilla::dom::PBrowserParent* tabParent =
+    static_cast<nsFrameLoader*>(aCallbackData)->GetRemoteBrowser();
   if (tabParent) {
-    return tabParent->SendsendAsyncMessageToChild(nsString(aMessage),
-                                                  nsString(aJSON));
+    return tabParent->SendAsyncMessage(nsString(aMessage), nsString(aJSON));
   }
 #endif
   nsRefPtr<nsIRunnable> ev =
     new nsAsyncMessageToChild(static_cast<nsFrameLoader*>(aCallbackData),
                               aMessage, aJSON);
   NS_DispatchToCurrentThread(ev);
   return true;
 }
--- a/content/base/src/nsFrameLoader.h
+++ b/content/base/src/nsFrameLoader.h
@@ -56,49 +56,51 @@ class nsIContent;
 class nsIURI;
 class nsIFrameFrame;
 class nsIView;
 class nsIInProcessContentFrameMessageManager;
 class AutoResetInShow;
 
 #ifdef MOZ_IPC
 namespace mozilla {
-  namespace dom {
-    class TabParent;
-    class PIFrameEmbeddingParent;
-  }
+namespace dom {
+class PBrowserParent;
+class TabParent;
+}
 }
 
 #ifdef MOZ_WIDGET_GTK2
 typedef struct _GtkWidget GtkWidget;
 #endif
 #ifdef MOZ_WIDGET_QT
 class QX11EmbedContainer;
 #endif
 #endif
 
 class nsFrameLoader : public nsIFrameLoader
 {
   friend class AutoResetInShow;
+  typedef mozilla::dom::PBrowserParent PBrowserParent;
+  typedef mozilla::dom::TabParent TabParent;
 
 protected:
   nsFrameLoader(nsIContent *aOwner) :
     mOwnerContent(aOwner),
     mDepthTooGreat(PR_FALSE),
     mIsTopLevelContent(PR_FALSE),
     mDestroyCalled(PR_FALSE),
     mNeedsAsyncDestroy(PR_FALSE),
     mInSwap(PR_FALSE),
     mInShow(PR_FALSE),
     mHideCalled(PR_FALSE)
 #ifdef MOZ_IPC
     , mDelayRemoteDialogs(PR_FALSE)
     , mRemoteWidgetCreated(PR_FALSE)
     , mRemoteFrame(false)
-    , mChildProcess(nsnull)
+    , mRemoteBrowser(nsnull)
 #if defined(MOZ_WIDGET_GTK2) || defined(MOZ_WIDGET_QT)
     , mRemoteSocket(nsnull)
 #endif
 #endif
   {}
 
 public:
   ~nsFrameLoader() {
@@ -144,17 +146,17 @@ public:
   nsresult SwapWithOtherLoader(nsFrameLoader* aOther,
                                nsRefPtr<nsFrameLoader>& aFirstToSwap,
                                nsRefPtr<nsFrameLoader>& aSecondToSwap);
 
   // When IPC is enabled, destroy any associated child process.
   void DestroyChild();
 
 #ifdef MOZ_IPC
-  mozilla::dom::PIFrameEmbeddingParent* GetChildProcess();
+  PBrowserParent* GetRemoteBrowser();
 #endif
   nsFrameMessageManager* GetFrameMessageManager() { return mMessageManager; }
 
 private:
 
 #ifdef MOZ_IPC
   bool ShouldUseRemoteProcess();
 #endif
@@ -203,17 +205,17 @@ private:
   PRPackedBool mHideCalled : 1;
 
 #ifdef MOZ_IPC
   PRPackedBool mDelayRemoteDialogs : 1;
   PRPackedBool mRemoteWidgetCreated : 1;
   bool mRemoteFrame;
   // XXX leaking
   nsCOMPtr<nsIObserver> mChildHost;
-  mozilla::dom::TabParent* mChildProcess;
+  TabParent* mRemoteBrowser;
 
 #ifdef MOZ_WIDGET_GTK2
   GtkWidget* mRemoteSocket;
 #elif defined(MOZ_WIDGET_QT)
   QX11EmbedContainer* mRemoteSocket;
 #endif
 #endif
 
--- a/content/canvas/src/nsCanvasRenderingContext2D.cpp
+++ b/content/canvas/src/nsCanvasRenderingContext2D.cpp
@@ -120,21 +120,21 @@
 #include "Layers.h"
 
 #include "CanvasUtils.h"
 
 #include "nsIMemoryReporter.h"
 
 #ifdef MOZ_IPC
 #  include <algorithm>
-#  include "mozilla/dom/ContentProcessParent.h"
+#  include "mozilla/dom/ContentParent.h"
 #  include "mozilla/ipc/PDocumentRendererParent.h"
 #  include "mozilla/ipc/PDocumentRendererShmemParent.h"
 #  include "mozilla/ipc/PDocumentRendererNativeIDParent.h"
-#  include "mozilla/dom/PIFrameEmbeddingParent.h"
+#  include "mozilla/dom/PBrowserParent.h"
 #  include "mozilla/ipc/DocumentRendererParent.h"
 #  include "mozilla/ipc/DocumentRendererShmemParent.h"
 #  include "mozilla/ipc/DocumentRendererNativeIDParent.h"
 #  include "mozilla/ipc/SharedMemorySysV.h"
 
 // windows.h (included by chromium code) defines this, in its infinite wisdom
 #  undef DrawText
 
@@ -835,17 +835,17 @@ nsCanvasRenderingContext2D::nsCanvasRend
     sNumLivingContexts++;
 }
 
 nsCanvasRenderingContext2D::~nsCanvasRenderingContext2D()
 {
     Destroy();
 
 #ifdef MOZ_IPC
-    ContentProcessParent* allocator = ContentProcessParent::GetSingleton(PR_FALSE);
+    ContentParent* allocator = ContentParent::GetSingleton(PR_FALSE);
     if (allocator && gfxSharedImageSurface::IsSharedImage(mBackSurface)) {
         Shmem mem = static_cast<gfxSharedImageSurface*>(mBackSurface.get())->GetShmem();
         allocator->DeallocShmem(mem);
     }
     mBackSurface = nsnull;
 #endif
 
     sNumLivingContexts--;
@@ -856,17 +856,17 @@ nsCanvasRenderingContext2D::~nsCanvasRen
         sPremultiplyTable = nsnull;
     }
 }
 
 void
 nsCanvasRenderingContext2D::Destroy()
 {
 #ifdef MOZ_IPC
-    ContentProcessParent* allocator = ContentProcessParent::GetSingleton(PR_FALSE);
+    ContentParent* allocator = ContentParent::GetSingleton(PR_FALSE);
     if (allocator && gfxSharedImageSurface::IsSharedImage(mSurface)) {
         Shmem &mem = static_cast<gfxSharedImageSurface*>(mSurface.get())->GetShmem();
         allocator->DeallocShmem(mem);
     }
 #endif
 
     // only do this for non-docshell created contexts,
     // since those are the ones that we created a surface for
@@ -1105,17 +1105,17 @@ nsCanvasRenderingContext2D::SetDimension
 #endif
             {
                 if (surface->GetType() == gfxASurface::SurfaceTypeImage)
                     format = static_cast<gfxImageSurface*>(surface.get())->Format();
                 SharedMemory::SharedMemoryType shmtype = SharedMemory::TYPE_BASIC;
 #ifdef MOZ_HAVE_SHAREDMEMORYSYSV
                 shmtype = SharedMemory::TYPE_SYSV;
 #endif
-                ContentProcessParent* allocator = ContentProcessParent::GetSingleton();
+                ContentParent* allocator = ContentParent::GetSingleton();
                 mBackSurface = new gfxSharedImageSurface();
                 static_cast<gfxSharedImageSurface*>(mBackSurface.get())->Init(allocator, size, format, shmtype);
             }
         }
 #endif
     }
     if (surface) {
         if (gCanvasMemoryReporter == nsnull) {
@@ -1266,17 +1266,17 @@ nsCanvasRenderingContext2D::Swap(mozilla
 #ifdef MOZ_IPC
     if (!gfxSharedImageSurface::IsSharedImage(mBackSurface))
         return NS_ERROR_FAILURE;
 
     nsRefPtr<gfxSharedImageSurface> aBackImage = new gfxSharedImageSurface(aBack);
     if (aBackImage->Data() != static_cast<gfxImageSurface*>(mBackSurface.get())->Data()) {
         NS_ERROR("Incoming back surface is not equal to our back surface");
         // Delete orphaned memory and return
-        ContentProcessParent* allocator = ContentProcessParent::GetSingleton(PR_FALSE);
+        ContentParent* allocator = ContentParent::GetSingleton(PR_FALSE);
         if (allocator)
             allocator->DeallocShmem(aBack);
         return NS_ERROR_FAILURE;
     }
 
     Shmem& mem = static_cast<gfxSharedImageSurface*>(mBackSurface.get())->GetShmem();
     if (mem.IsReadable())
         NS_ERROR("Back surface readable before swap, this must not happen");
@@ -3715,17 +3715,17 @@ nsCanvasRenderingContext2D::AsyncDrawXUL
     if (!loaderOwner)
         return NS_ERROR_FAILURE;
 
     nsCOMPtr<nsFrameLoader> frameloader = loaderOwner->GetFrameLoader();
     if (!frameloader)
         return NS_ERROR_FAILURE;
 
 #ifdef MOZ_IPC
-    PIFrameEmbeddingParent *child = frameloader->GetChildProcess();
+    PBrowserParent *child = frameloader->GetRemoteBrowser();
     if (!child) {
         nsCOMPtr<nsIDOMWindow> window =
             do_GetInterface(frameloader->GetExistingDocShell());
         if (!window)
             return NS_ERROR_FAILURE;
 
         return DrawWindow(window, aX, aY, aW, aH, aBGColor, flags);
     }
rename from dom/ipc/ContentProcessChild.cpp
rename to dom/ipc/ContentChild.cpp
--- a/dom/ipc/ContentProcessChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -32,17 +32,17 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-#include "ContentProcessChild.h"
+#include "ContentChild.h"
 #include "TabChild.h"
 
 #include "mozilla/ipc/TestShellChild.h"
 #include "mozilla/net/NeckoChild.h"
 #include "mozilla/ipc/XPCShellEnvironment.h"
 #include "mozilla/jsipc/PContextWrapperChild.h"
 
 #include "nsXULAppAPI.h"
@@ -54,137 +54,137 @@
 #include "mozilla/chrome/RegistryMessageUtils.h"
 
 using namespace mozilla::ipc;
 using namespace mozilla::net;
 
 namespace mozilla {
 namespace dom {
 
-ContentProcessChild* ContentProcessChild::sSingleton;
+ContentChild* ContentChild::sSingleton;
 
-ContentProcessChild::ContentProcessChild()
+ContentChild::ContentChild()
 {
 }
 
-ContentProcessChild::~ContentProcessChild()
+ContentChild::~ContentChild()
 {
 }
 
 bool
-ContentProcessChild::Init(MessageLoop* aIOLoop,
-                          base::ProcessHandle aParentHandle,
-                          IPC::Channel* aChannel)
+ContentChild::Init(MessageLoop* aIOLoop,
+                   base::ProcessHandle aParentHandle,
+                   IPC::Channel* aChannel)
 {
-    NS_ASSERTION(!sSingleton, "only one ContentProcessChild per child");
+    NS_ASSERTION(!sSingleton, "only one ContentChild per child");
   
     Open(aChannel, aParentHandle, aIOLoop);
     sSingleton = this;
 
     return true;
 }
 
-PIFrameEmbeddingChild*
-ContentProcessChild::AllocPIFrameEmbedding()
+PBrowserChild*
+ContentChild::AllocPBrowser()
 {
   nsRefPtr<TabChild> iframe = new TabChild();
   return NS_SUCCEEDED(iframe->Init()) ? iframe.forget().get() : NULL;
 }
 
 bool
-ContentProcessChild::DeallocPIFrameEmbedding(PIFrameEmbeddingChild* iframe)
+ContentChild::DeallocPBrowser(PBrowserChild* iframe)
 {
     TabChild* child = static_cast<TabChild*>(iframe);
     NS_RELEASE(child);
     return true;
 }
 
 PTestShellChild*
-ContentProcessChild::AllocPTestShell()
+ContentChild::AllocPTestShell()
 {
     return new TestShellChild();
 }
 
 bool
-ContentProcessChild::DeallocPTestShell(PTestShellChild* shell)
+ContentChild::DeallocPTestShell(PTestShellChild* shell)
 {
     delete shell;
     return true;
 }
 
 bool
-ContentProcessChild::RecvPTestShellConstructor(PTestShellChild* actor)
+ContentChild::RecvPTestShellConstructor(PTestShellChild* actor)
 {
     actor->SendPContextWrapperConstructor()->SendPObjectWrapperConstructor(true);
     return true;
 }
 
 PNeckoChild* 
-ContentProcessChild::AllocPNecko()
+ContentChild::AllocPNecko()
 {
     return new NeckoChild();
 }
 
 bool 
-ContentProcessChild::DeallocPNecko(PNeckoChild* necko)
+ContentChild::DeallocPNecko(PNeckoChild* necko)
 {
     delete necko;
     return true;
 }
 
 bool
-ContentProcessChild::RecvRegisterChrome(const nsTArray<ChromePackage>& packages,
-                                        const nsTArray<ResourceMapping>& resources,
-                                        const nsTArray<OverrideMapping>& overrides)
+ContentChild::RecvRegisterChrome(const nsTArray<ChromePackage>& packages,
+                                 const nsTArray<ResourceMapping>& resources,
+                                 const nsTArray<OverrideMapping>& overrides)
 {
     nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
     nsChromeRegistryContent* chromeRegistry =
         static_cast<nsChromeRegistryContent*>(registrySvc.get());
     chromeRegistry->RegisterRemoteChrome(packages, resources, overrides);
     return true;
 }
 
 bool
-ContentProcessChild::RecvSetOffline(const PRBool& offline)
+ContentChild::RecvSetOffline(const PRBool& offline)
 {
   nsCOMPtr<nsIIOService> io (do_GetIOService());
   NS_ASSERTION(io, "IO Service can not be null");
 
   io->SetOffline(offline);
     
   return true;
 }
 
 void
-ContentProcessChild::ActorDestroy(ActorDestroyReason why)
+ContentChild::ActorDestroy(ActorDestroyReason why)
 {
     if (AbnormalShutdown == why)
         NS_WARNING("shutting down because of crash!");
 
     ClearPrefObservers();
     XRE_ShutdownChildProcess();
 }
 
 nsresult
-ContentProcessChild::AddRemotePrefObserver(const nsCString &aDomain, 
-                                           const nsCString &aPrefRoot, 
-                                           nsIObserver *aObserver, 
-                                           PRBool aHoldWeak)
+ContentChild::AddRemotePrefObserver(const nsCString &aDomain, 
+                                    const nsCString &aPrefRoot, 
+                                    nsIObserver *aObserver, 
+                                    PRBool aHoldWeak)
 {
     nsPrefObserverStorage* newObserver = 
         new nsPrefObserverStorage(aObserver, aDomain, aPrefRoot, aHoldWeak);
 
     mPrefObserverArray.AppendElement(newObserver);
     return NS_OK;
 }
 
 nsresult
-ContentProcessChild::RemoveRemotePrefObserver(const nsCString &aDomain, 
-                                              const nsCString &aPrefRoot, 
-                                              nsIObserver *aObserver)
+ContentChild::RemoveRemotePrefObserver(const nsCString &aDomain, 
+                                       const nsCString &aPrefRoot, 
+                                       nsIObserver *aObserver)
 {
     if (mPrefObserverArray.IsEmpty())
         return NS_OK;
 
     nsPrefObserverStorage *entry;
     for (PRUint32 i = 0; i < mPrefObserverArray.Length(); ++i) {
         entry = mPrefObserverArray[i];
         if (entry && entry->GetObserver() == aObserver &&
@@ -194,17 +194,17 @@ ContentProcessChild::RemoveRemotePrefObs
             return NS_OK;
         }
     }
     NS_WARNING("No preference Observer was matched !");
     return NS_ERROR_UNEXPECTED;
 }
 
 bool
-ContentProcessChild::RecvNotifyRemotePrefObserver(const nsCString& aDomain)
+ContentChild::RecvNotifyRemotePrefObserver(const nsCString& aDomain)
 {
     nsPrefObserverStorage *entry;
     for (PRUint32 i = 0; i < mPrefObserverArray.Length(); ) {
         entry = mPrefObserverArray[i];
         nsCAutoString prefName(entry->GetPrefRoot() + entry->GetDomain());
         // aDomain here is returned from our global pref observer from parent
         // so it's really a full pref name (i.e. root + domain)
         if (StringBeginsWith(aDomain, prefName)) {
rename from dom/ipc/ContentProcessChild.h
rename to dom/ipc/ContentChild.h
--- a/dom/ipc/ContentProcessChild.h
+++ b/dom/ipc/ContentChild.h
@@ -32,20 +32,20 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-#ifndef mozilla_dom_ContentProcessChild_h
-#define mozilla_dom_ContentProcessChild_h
+#ifndef mozilla_dom_ContentChild_h
+#define mozilla_dom_ContentChild_h
 
-#include "mozilla/dom/PContentProcessChild.h"
+#include "mozilla/dom/PContentChild.h"
 
 #include "nsIObserverService.h"
 #include "nsTObserverArray.h"
 #include "nsIObserver.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch.h"
 #include "nsServiceManagerUtils.h"
 #include "nsTArray.h"
@@ -54,21 +54,21 @@
 
 struct ChromePackage;
 struct ResourceMapping;
 struct OverrideMapping;
 
 namespace mozilla {
 namespace dom {
 
-class ContentProcessChild : public PContentProcessChild
+class ContentChild : public PContentChild
 {
 public:
-    ContentProcessChild();
-    virtual ~ContentProcessChild();
+    ContentChild();
+    virtual ~ContentChild();
 
     class nsPrefObserverStorage {
     public:
         nsPrefObserverStorage(nsIObserver *aObserver, nsCString aDomain,
                               nsCString aPrefRoot, bool aHoldWeak) {
             mDomain = aDomain;
             mPrefRoot = aPrefRoot;
             mObserver = aObserver;
@@ -120,26 +120,26 @@ public:
         nsCString mPrefRoot;
         nsCString mDomain;
     };
 
     bool Init(MessageLoop* aIOLoop,
               base::ProcessHandle aParentHandle,
               IPC::Channel* aChannel);
 
-    static ContentProcessChild* GetSingleton() {
+    static ContentChild* GetSingleton() {
         NS_ASSERTION(sSingleton, "not initialized");
         return sSingleton;
     }
 
     /* if you remove this, please talk to cjones or dougt */
     virtual bool RecvDummy(Shmem& foo) { return true; }
 
-    virtual PIFrameEmbeddingChild* AllocPIFrameEmbedding();
-    virtual bool DeallocPIFrameEmbedding(PIFrameEmbeddingChild*);
+    virtual PBrowserChild* AllocPBrowser();
+    virtual bool DeallocPBrowser(PBrowserChild*);
 
     virtual PTestShellChild* AllocPTestShell();
     virtual bool DeallocPTestShell(PTestShellChild*);
     virtual bool RecvPTestShellConstructor(PTestShellChild*);
 
     virtual PNeckoChild* AllocPNecko();
     virtual bool DeallocPNecko(PNeckoChild*);
 
@@ -163,19 +163,19 @@ public:
             const nsCString& aDomain);
     
 
 
 private:
     NS_OVERRIDE
     virtual void ActorDestroy(ActorDestroyReason why);
 
-    static ContentProcessChild* sSingleton;
+    static ContentChild* sSingleton;
 
     nsTArray< nsAutoPtr<nsPrefObserverStorage> > mPrefObserverArray;
 
-    DISALLOW_EVIL_CONSTRUCTORS(ContentProcessChild);
+    DISALLOW_EVIL_CONSTRUCTORS(ContentChild);
 };
 
 } // namespace dom
 } // namespace mozilla
 
 #endif
rename from dom/ipc/ContentProcessParent.cpp
rename to dom/ipc/ContentParent.cpp
--- a/dom/ipc/ContentProcessParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -32,17 +32,17 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-#include "ContentProcessParent.h"
+#include "ContentParent.h"
 
 #include "TabParent.h"
 #include "mozilla/ipc/TestShellParent.h"
 #include "mozilla/net/NeckoParent.h"
 #include "nsIPrefBranch.h"
 #include "nsIPrefBranch2.h"
 #include "nsIPrefLocalizedString.h"
 #include "nsIObserverService.h"
@@ -57,26 +57,26 @@ using namespace mozilla::ipc;
 using namespace mozilla::net;
 using mozilla::MonitorAutoEnter;
 
 namespace mozilla {
 namespace dom {
 
 #define NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC "ipc:network:set-offline"
 
-ContentProcessParent* ContentProcessParent::gSingleton;
+ContentParent* ContentParent::gSingleton;
 
-ContentProcessParent*
-ContentProcessParent::GetSingleton(PRBool aForceNew)
+ContentParent*
+ContentParent::GetSingleton(PRBool aForceNew)
 {
     if (gSingleton && !gSingleton->IsAlive())
         gSingleton = nsnull;
     
     if (!gSingleton && aForceNew) {
-        nsRefPtr<ContentProcessParent> parent = new ContentProcessParent();
+        nsRefPtr<ContentParent> parent = new ContentParent();
         if (parent) {
             nsCOMPtr<nsIObserverService> obs =
                 do_GetService("@mozilla.org/observer-service;1");
             if (obs) {
                 if (NS_SUCCEEDED(obs->AddObserver(parent, "xpcom-shutdown",
                                                   PR_FALSE))) {
                     gSingleton = parent;
                     nsCOMPtr<nsIPrefBranch2> prefs 
@@ -95,17 +95,17 @@ ContentProcessParent::GetSingleton(PRBoo
                 threadInt->SetObserver(parent);
             }
         }
     }
     return gSingleton;
 }
 
 void
-ContentProcessParent::ActorDestroy(ActorDestroyReason why)
+ContentParent::ActorDestroy(ActorDestroyReason why)
 {
     nsCOMPtr<nsIThreadObserver>
         kungFuDeathGrip(static_cast<nsIThreadObserver*>(this));
     nsCOMPtr<nsIObserverService>
         obs(do_GetService("@mozilla.org/observer-service;1"));
     if (obs)
         obs->RemoveObserver(static_cast<nsIObserver*>(this), "xpcom-shutdown");
     nsCOMPtr<nsIThreadInternal>
@@ -114,148 +114,148 @@ ContentProcessParent::ActorDestroy(Actor
         threadInt->SetObserver(mOldObserver);
     if (mRunToCompletionDepth)
         mRunToCompletionDepth = 0;
 
     mIsAlive = false;
 }
 
 TabParent*
-ContentProcessParent::CreateTab()
+ContentParent::CreateTab()
 {
-  return static_cast<TabParent*>(SendPIFrameEmbeddingConstructor());
+  return static_cast<TabParent*>(SendPBrowserConstructor());
 }
 
 TestShellParent*
-ContentProcessParent::CreateTestShell()
+ContentParent::CreateTestShell()
 {
   return static_cast<TestShellParent*>(SendPTestShellConstructor());
 }
 
 bool
-ContentProcessParent::DestroyTestShell(TestShellParent* aTestShell)
+ContentParent::DestroyTestShell(TestShellParent* aTestShell)
 {
     return PTestShellParent::Send__delete__(aTestShell);
 }
 
-ContentProcessParent::ContentProcessParent()
-    : mMonitor("ContentProcessParent::mMonitor")
+ContentParent::ContentParent()
+    : mMonitor("ContentParent::mMonitor")
     , mRunToCompletionDepth(0)
     , mShouldCallUnblockChild(false)
     , mIsAlive(true)
 {
     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
     mSubprocess = new GeckoChildProcessHost(GeckoProcessType_Content);
     mSubprocess->AsyncLaunch();
     Open(mSubprocess->GetChannel(), mSubprocess->GetChildProcessHandle());
 
     nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
     nsChromeRegistryChrome* chromeRegistry =
         static_cast<nsChromeRegistryChrome*>(registrySvc.get());
     chromeRegistry->SendRegisteredChrome(this);
 }
 
-ContentProcessParent::~ContentProcessParent()
+ContentParent::~ContentParent()
 {
     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
     //If the previous content process has died, a new one could have
     //been started since.
     if (gSingleton == this)
         gSingleton = nsnull;
 }
 
 bool
-ContentProcessParent::IsAlive()
+ContentParent::IsAlive()
 {
     return mIsAlive;
 }
 
 bool
-ContentProcessParent::RecvGetPrefType(const nsCString& prefName,
-                                      PRInt32* retValue, nsresult* rv)
+ContentParent::RecvGetPrefType(const nsCString& prefName,
+                               PRInt32* retValue, nsresult* rv)
 {
     *retValue = 0;
 
     EnsurePrefService();
     *rv = mPrefService->GetPrefType(prefName.get(), retValue);
     return true;
 }
 
 bool
-ContentProcessParent::RecvGetBoolPref(const nsCString& prefName,
-                                      PRBool* retValue, nsresult* rv)
+ContentParent::RecvGetBoolPref(const nsCString& prefName,
+                               PRBool* retValue, nsresult* rv)
 {
     *retValue = PR_FALSE;
 
     EnsurePrefService();
     *rv = mPrefService->GetBoolPref(prefName.get(), retValue);
     return true;
 }
 
 bool
-ContentProcessParent::RecvGetIntPref(const nsCString& prefName,
-                                     PRInt32* retValue, nsresult* rv)
+ContentParent::RecvGetIntPref(const nsCString& prefName,
+                              PRInt32* retValue, nsresult* rv)
 {
     *retValue = 0;
 
     EnsurePrefService();
     *rv = mPrefService->GetIntPref(prefName.get(), retValue);
     return true;
 }
 
 bool
-ContentProcessParent::RecvGetCharPref(const nsCString& prefName,
-                                      nsCString* retValue, nsresult* rv)
+ContentParent::RecvGetCharPref(const nsCString& prefName,
+                               nsCString* retValue, nsresult* rv)
 {
     EnsurePrefService();
     *rv = mPrefService->GetCharPref(prefName.get(), getter_Copies(*retValue));
     return true;
 }
 
 bool
-ContentProcessParent::RecvGetPrefLocalizedString(const nsCString& prefName,
-                                                 nsString* retValue, nsresult* rv)
+ContentParent::RecvGetPrefLocalizedString(const nsCString& prefName,
+                                          nsString* retValue, nsresult* rv)
 {
     EnsurePrefService();
     nsCOMPtr<nsIPrefLocalizedString> string;
     *rv = mPrefService->GetComplexValue(prefName.get(),
             NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(string));
 
     if (NS_SUCCEEDED(*rv))
       string->GetData(getter_Copies(*retValue));
 
     return true;
 }
 
 bool
-ContentProcessParent::RecvPrefHasUserValue(const nsCString& prefName,
-                                           PRBool* retValue, nsresult* rv)
+ContentParent::RecvPrefHasUserValue(const nsCString& prefName,
+                                    PRBool* retValue, nsresult* rv)
 {
     *retValue = PR_FALSE;
 
     EnsurePrefService();
     *rv = mPrefService->PrefHasUserValue(prefName.get(), retValue);
     return true;
 }
 
 bool
-ContentProcessParent::RecvPrefIsLocked(const nsCString& prefName,
-                                       PRBool* retValue, nsresult* rv)
+ContentParent::RecvPrefIsLocked(const nsCString& prefName,
+                                PRBool* retValue, nsresult* rv)
 {
     *retValue = PR_FALSE;
 
     EnsurePrefService();
     *rv = mPrefService->PrefIsLocked(prefName.get(), retValue);
         
     return true;
 }
 
 bool
-ContentProcessParent::RecvGetChildList(const nsCString& domain,
-                                       nsTArray<nsCString>* list, nsresult* rv)
+ContentParent::RecvGetChildList(const nsCString& domain,
+                                nsTArray<nsCString>* list, nsresult* rv)
 {
     EnsurePrefService();
 
     PRUint32 count;
     char **childArray;
     *rv = mPrefService->GetChildList(domain.get(), &count, &childArray);
 
     if (NS_SUCCEEDED(*rv)) {
@@ -263,71 +263,71 @@ ContentProcessParent::RecvGetChildList(c
       for (PRUint32 i = 0; i < count; ++i)
         *(list->AppendElement()) = childArray[i];
     }
         
     return true;
 }
 
 bool
-ContentProcessParent::RecvTestPermission(const IPC::URI&  aUri,
-                                         const nsCString& aType,
-                                         const PRBool&    aExact,
-                                         PRUint32*        retValue)
+ContentParent::RecvTestPermission(const IPC::URI&  aUri,
+                                   const nsCString& aType,
+                                   const PRBool&    aExact,
+                                   PRUint32*        retValue)
 {
     EnsurePermissionService();
 
     nsCOMPtr<nsIURI> uri = aUri;
     if (aExact) {
         mPermissionService->TestExactPermission(uri, aType.get(), retValue);
     } else {
         mPermissionService->TestPermission(uri, aType.get(), retValue);
     }
     return true;
 }
 
 void
-ContentProcessParent::EnsurePrefService()
+ContentParent::EnsurePrefService()
 {
     nsresult rv;
     if (!mPrefService) {
         mPrefService = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
         NS_ASSERTION(NS_SUCCEEDED(rv), 
                      "We lost prefService in the Chrome process !");
     }
 }
 
 void
-ContentProcessParent::EnsurePermissionService()
+ContentParent::EnsurePermissionService()
 {
     nsresult rv;
     if (!mPermissionService) {
         mPermissionService = do_GetService(
             NS_PERMISSIONMANAGER_CONTRACTID, &rv);
         NS_ASSERTION(NS_SUCCEEDED(rv), 
                      "We lost permissionService in the Chrome process !");
     }
 }
 
-NS_IMPL_THREADSAFE_ISUPPORTS2(ContentProcessParent,
+NS_IMPL_THREADSAFE_ISUPPORTS2(ContentParent,
                               nsIObserver,
                               nsIThreadObserver)
 
 namespace {
 void
 DeleteSubprocess(GeckoChildProcessHost* aSubprocess)
 {
     delete aSubprocess;
 }
 }
 
 NS_IMETHODIMP
-ContentProcessParent::Observe(nsISupports* aSubject,
-                              const char* aTopic,
-                              const PRUnichar* aData)
+ContentParent::Observe(nsISupports* aSubject,
+                       const char* aTopic,
+                       const PRUnichar* aData)
 {
     if (!strcmp(aTopic, "xpcom-shutdown") && mSubprocess) {
         // remove the global remote preferences observers
         nsCOMPtr<nsIPrefBranch2> prefs 
             (do_GetService(NS_PREFSERVICE_CONTRACTID));
         if (prefs) { 
             if (gSingleton) {
                 prefs->RemoveObserver("", this);
@@ -336,132 +336,134 @@ ContentProcessParent::Observe(nsISupport
 
         Close();
         XRE_GetIOMessageLoop()->PostTask(
             FROM_HERE,
             NewRunnableFunction(DeleteSubprocess, mSubprocess));
         mSubprocess = nsnull;
     }
 
+    if (!mIsAlive || !mSubprocess)
+        return NS_OK;
+
     // listening for remotePrefs...
     if (!strcmp(aTopic, "nsPref:changed")) {
         // We know prefs are ASCII here.
         NS_LossyConvertUTF16toASCII strData(aData);
-        if (mIsAlive)
-            SendNotifyRemotePrefObserver(strData);
+        if (!SendNotifyRemotePrefObserver(strData))
+            return NS_ERROR_NOT_AVAILABLE;
     }
-
-    if (!strcmp(aTopic, NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC) && mSubprocess) {
+    else if (!strcmp(aTopic, NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC)) {
       NS_ConvertUTF16toUTF8 dataStr(aData);
       const char *offline = dataStr.get();
-      if (mIsAlive)
-          SendSetOffline(!strcmp(offline, "true") ? true : false);
+      if (!SendSetOffline(!strcmp(offline, "true") ? true : false))
+          return NS_ERROR_NOT_AVAILABLE;
     }
     return NS_OK;
 }
 
-PIFrameEmbeddingParent*
-ContentProcessParent::AllocPIFrameEmbedding()
+PBrowserParent*
+ContentParent::AllocPBrowser()
 {
   TabParent* parent = new TabParent();
   if (parent){
     NS_ADDREF(parent);
   }
   return parent;
 }
 
 bool
-ContentProcessParent::DeallocPIFrameEmbedding(PIFrameEmbeddingParent* frame)
+ContentParent::DeallocPBrowser(PBrowserParent* frame)
 {
   TabParent* parent = static_cast<TabParent*>(frame);
   NS_RELEASE(parent);
   return true;
 }
 
 PTestShellParent*
-ContentProcessParent::AllocPTestShell()
+ContentParent::AllocPTestShell()
 {
   return new TestShellParent();
 }
 
 bool
-ContentProcessParent::DeallocPTestShell(PTestShellParent* shell)
+ContentParent::DeallocPTestShell(PTestShellParent* shell)
 {
   delete shell;
   return true;
 }
 
 PNeckoParent* 
-ContentProcessParent::AllocPNecko()
+ContentParent::AllocPNecko()
 {
     return new NeckoParent();
 }
 
 bool 
-ContentProcessParent::DeallocPNecko(PNeckoParent* necko)
+ContentParent::DeallocPNecko(PNeckoParent* necko)
 {
     delete necko;
     return true;
 }
 
 void
-ContentProcessParent::ReportChildAlreadyBlocked()
+ContentParent::ReportChildAlreadyBlocked()
 {
     if (!mRunToCompletionDepth) {
 #ifdef DEBUG
         printf("Running to completion...\n");
 #endif
         mRunToCompletionDepth = 1;
         mShouldCallUnblockChild = false;
     }
 }
     
 bool
-ContentProcessParent::RequestRunToCompletion()
+ContentParent::RequestRunToCompletion()
 {
     if (!mRunToCompletionDepth &&
         BlockChild()) {
 #ifdef DEBUG
         printf("Running to completion...\n");
 #endif
         mRunToCompletionDepth = 1;
         mShouldCallUnblockChild = true;
     }
     return !!mRunToCompletionDepth;
 }
 
 /* void onDispatchedEvent (in nsIThreadInternal thread); */
 NS_IMETHODIMP
-ContentProcessParent::OnDispatchedEvent(nsIThreadInternal *thread)
+ContentParent::OnDispatchedEvent(nsIThreadInternal *thread)
 {
     if (mOldObserver)
         return mOldObserver->OnDispatchedEvent(thread);
 
     return NS_OK;
 }
 
 /* void onProcessNextEvent (in nsIThreadInternal thread, in boolean mayWait, in unsigned long recursionDepth); */
 NS_IMETHODIMP
-ContentProcessParent::OnProcessNextEvent(nsIThreadInternal *thread,
-                                         PRBool mayWait,
-                                         PRUint32 recursionDepth)
+ContentParent::OnProcessNextEvent(nsIThreadInternal *thread,
+                                  PRBool mayWait,
+                                  PRUint32 recursionDepth)
 {
     if (mRunToCompletionDepth)
         ++mRunToCompletionDepth;
 
     if (mOldObserver)
         return mOldObserver->OnProcessNextEvent(thread, mayWait, recursionDepth);
 
     return NS_OK;
 }
 
 /* void afterProcessNextEvent (in nsIThreadInternal thread, in unsigned long recursionDepth); */
 NS_IMETHODIMP
-ContentProcessParent::AfterProcessNextEvent(nsIThreadInternal *thread,
-                                            PRUint32 recursionDepth)
+ContentParent::AfterProcessNextEvent(nsIThreadInternal *thread,
+                                     PRUint32 recursionDepth)
 {
     if (mRunToCompletionDepth &&
         !--mRunToCompletionDepth) {
 #ifdef DEBUG
             printf("... ran to completion.\n");
 #endif
             if (mShouldCallUnblockChild) {
                 mShouldCallUnblockChild = false;
rename from dom/ipc/ContentProcessParent.h
rename to dom/ipc/ContentParent.h
--- a/dom/ipc/ContentProcessParent.h
+++ b/dom/ipc/ContentParent.h
@@ -31,22 +31,22 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-#ifndef mozilla_dom_ContentProcessParent_h
-#define mozilla_dom_ContentProcessParent_h
+#ifndef mozilla_dom_ContentParent_h
+#define mozilla_dom_ContentParent_h
 
 #include "base/waitable_event_watcher.h"
 
-#include "mozilla/dom/PContentProcessParent.h"
+#include "mozilla/dom/PContentParent.h"
 #include "mozilla/ipc/GeckoChildProcessHost.h"
 
 #include "nsIObserver.h"
 #include "nsIThreadInternal.h"
 #include "mozilla/Monitor.h"
 #include "nsIPrefService.h"
 #include "nsIPermissionManager.h"
 
@@ -55,30 +55,30 @@ namespace mozilla {
 namespace ipc {
 class TestShellParent;
 }
 
 namespace dom {
 
 class TabParent;
 
-class ContentProcessParent : public PContentProcessParent
-                           , public nsIObserver
-                           , public nsIThreadObserver
+class ContentParent : public PContentParent
+                    , public nsIObserver
+                    , public nsIThreadObserver
 {
 private:
     typedef mozilla::ipc::GeckoChildProcessHost GeckoChildProcessHost;
     typedef mozilla::ipc::TestShellParent TestShellParent;
 
 public:
-    static ContentProcessParent* GetSingleton(PRBool aForceNew = PR_TRUE);
+    static ContentParent* GetSingleton(PRBool aForceNew = PR_TRUE);
 
 #if 0
     // TODO: implement this somewhere!
-    static ContentProcessParent* FreeSingleton();
+    static ContentParent* FreeSingleton();
 #endif
 
     NS_DECL_ISUPPORTS
     NS_DECL_NSIOBSERVER
     NS_DECL_NSITHREADOBSERVER
 
     TabParent* CreateTab();
 
@@ -89,28 +89,28 @@ public:
     bool RequestRunToCompletion();
 
     bool IsAlive();
 
 protected:
     virtual void ActorDestroy(ActorDestroyReason why);
 
 private:
-    static ContentProcessParent* gSingleton;
+    static ContentParent* gSingleton;
 
     // Hide the raw constructor methods since we don't want client code
     // using them.
-    using PContentProcessParent::SendPIFrameEmbeddingConstructor;
-    using PContentProcessParent::SendPTestShellConstructor;
+    using PContentParent::SendPBrowserConstructor;
+    using PContentParent::SendPTestShellConstructor;
 
-    ContentProcessParent();
-    virtual ~ContentProcessParent();
+    ContentParent();
+    virtual ~ContentParent();
 
-    virtual PIFrameEmbeddingParent* AllocPIFrameEmbedding();
-    virtual bool DeallocPIFrameEmbedding(PIFrameEmbeddingParent* frame);
+    virtual PBrowserParent* AllocPBrowser();
+    virtual bool DeallocPBrowser(PBrowserParent* frame);
 
     virtual PTestShellParent* AllocPTestShell();
     virtual bool DeallocPTestShell(PTestShellParent* shell);
 
     virtual PNeckoParent* AllocPNecko();
     virtual bool DeallocPNecko(PNeckoParent* necko);
 
     virtual bool RecvGetPrefType(const nsCString& prefName,
rename from dom/ipc/ContentProcessProcess.cpp
rename to dom/ipc/ContentProcess.cpp
--- a/dom/ipc/ContentProcessProcess.cpp
+++ b/dom/ipc/ContentProcess.cpp
@@ -34,34 +34,34 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "mozilla/ipc/IOThreadChild.h"
 
-#include "ContentProcessProcess.h"
+#include "ContentProcess.h"
 
 using mozilla::ipc::IOThreadChild;
 
 namespace mozilla {
 namespace dom {
 
 bool
-ContentProcessProcess::Init()
+ContentProcess::Init()
 {
-    mContentProcess.Init(IOThreadChild::message_loop(),
+    mContent.Init(IOThreadChild::message_loop(),
                          ParentHandle(),
                          IOThreadChild::channel());
     mXREEmbed.Start();
     
     return true;
 }
 
 void
-ContentProcessProcess::CleanUp()
+ContentProcess::CleanUp()
 {
     mXREEmbed.Stop();
 }
 
 } // namespace tabs
 } // namespace mozilla
rename from dom/ipc/ContentProcessProcess.h
rename to dom/ipc/ContentProcess.h
--- a/dom/ipc/ContentProcessProcess.h
+++ b/dom/ipc/ContentProcess.h
@@ -32,53 +32,53 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-#ifndef dom_tabs_ContentProcessThread_h
-#define dom_tabs_ContentProcessThread_h 1
+#ifndef dom_tabs_ContentThread_h
+#define dom_tabs_ContentThread_h 1
 
 #include "mozilla/ipc/ProcessChild.h"
 #include "mozilla/ipc/ScopedXREEmbed.h"
-#include "ContentProcessChild.h"
+#include "ContentChild.h"
 
 #undef _MOZ_LOG
-#define _MOZ_LOG(s)  printf("[ContentProcessProcess] %s", s)
+#define _MOZ_LOG(s)  printf("[ContentProcess] %s", s)
 
 namespace mozilla {
 namespace dom {
 
 /**
- * ContentProcessProcess is a singleton on the content process which represents
+ * ContentProcess is a singleton on the content process which represents
  * the main thread where tab instances live.
  */
-class ContentProcessProcess : public mozilla::ipc::ProcessChild
+class ContentProcess : public mozilla::ipc::ProcessChild
 {
     typedef mozilla::ipc::ProcessChild ProcessChild;
 
 public:
-    ContentProcessProcess(ProcessHandle mParentHandle)
+    ContentProcess(ProcessHandle mParentHandle)
         : ProcessChild(mParentHandle)
     { }
 
-    ~ContentProcessProcess()
+    ~ContentProcess()
     { }
 
     NS_OVERRIDE
     virtual bool Init();
     NS_OVERRIDE
     virtual void CleanUp();
 
 private:
-    ContentProcessChild mContentProcess;
+    ContentChild mContent;
     mozilla::ipc::ScopedXREEmbed mXREEmbed;
 
-    DISALLOW_EVIL_CONSTRUCTORS(ContentProcessProcess);
+    DISALLOW_EVIL_CONSTRUCTORS(ContentProcess);
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
-#endif  // ifndef dom_tabs_ContentProcessThread_h
+#endif  // ifndef dom_tabs_ContentThread_h
--- a/dom/ipc/Makefile.in
+++ b/dom/ipc/Makefile.in
@@ -51,27 +51,27 @@ EXPORTS = TabMessageUtils.h
 
 EXPORTS_NAMESPACES = mozilla mozilla/dom
 
 EXPORTS_mozilla = \
   TabTypes.h \
   $(NULL)
 
 EXPORTS_mozilla/dom = \
-  ContentProcessChild.h \
-  ContentProcessParent.h \
-  ContentProcessProcess.h \
+  ContentChild.h \
+  ContentParent.h \
+  ContentProcess.h \
   TabParent.h \
   TabChild.h \
   $(NULL)
 
 CPPSRCS = \
-  ContentProcessProcess.cpp \
-  ContentProcessParent.cpp \
-  ContentProcessChild.cpp \
+  ContentProcess.cpp \
+  ContentParent.cpp \
+  ContentChild.cpp \
   TabParent.cpp \
   TabChild.cpp \
   TabMessageUtils.cpp \
   $(NULL)
 
 include $(topsrcdir)/config/config.mk
 include $(topsrcdir)/ipc/chromium/chromium-config.mk
 include $(topsrcdir)/config/rules.mk
rename from dom/ipc/PIFrameEmbedding.ipdl
rename to dom/ipc/PBrowser.ipdl
--- a/dom/ipc/PIFrameEmbedding.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -32,130 +32,130 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PContentProcess;
+include protocol PContent;
+include protocol PContentDialog;
 include protocol PDocumentRenderer;
 include protocol PDocumentRendererShmem;
 include protocol PDocumentRendererNativeID;
 include protocol PGeolocationRequest;
-include protocol PContentDialog;
 
 include "mozilla/TabTypes.h";
 include "TabMessageUtils.h";
 include "gfxMatrix.h";
 include "mozilla/net/NeckoMessageUtils.h";
 
 using IPC::URI;
 using MagicWindowHandle;
 using RemoteDOMEvent;
 using gfxMatrix;
 
 namespace mozilla {
 namespace dom {
 
-rpc protocol PIFrameEmbedding
+rpc protocol PBrowser
 {
-    manager PContentProcess;
+    manager PContent;
+
+    manages PContentDialog;
     manages PDocumentRenderer;
     manages PDocumentRendererShmem;
     manages PDocumentRendererNativeID;
     manages PGeolocationRequest;
-    manages PContentDialog;
+
+both:
+    AsyncMessage(nsString aMessage, nsString aJSON);
 
 child:
     __delete__();
 
 parent:
     /**
      * When child sends this message, parent should move focus to
      * the next or previous focusable element.
      */
-    moveFocus(bool forward);
+    MoveFocus(bool forward);
 
-    sendEvent(RemoteDOMEvent aEvent);
+    Event(RemoteDOMEvent aEvent);
 
-    notifyStateChange(PRUint32 stateFlags, nsresult status);
+    NotifyStateChange(PRUint32 stateFlags, nsresult status);
 
-    notifyProgressChange(PRInt64 curSelfProgress,
+    NotifyProgressChange(PRInt64 curSelfProgress,
                          PRInt64 maxSelfProgress,
                          PRInt64 curTotalProgress,
                          PRInt64 maxTotalProgress);
 
-    notifyLocationChange(nsCString uri);
+    NotifyLocationChange(nsCString uri);
 
-    notifyStatusChange(nsresult status,
+    NotifyStatusChange(nsresult status,
                        nsString message);
 
-    notifySecurityChange(PRUint32 aState);
+    NotifySecurityChange(PRUint32 aState);
 
-    sync refreshAttempted(nsCString uri, PRInt32 millis,
+    sync RefreshAttempted(nsCString uri, PRInt32 millis,
                           bool sameURI) returns (bool retval);
 
 
-    rpc createWindow() returns (PIFrameEmbedding window);
+    rpc CreateWindow() returns (PBrowser window);
 
-    sync sendSyncMessageToParent(nsString aMessage, nsString aJSON)
+    sync SyncMessage(nsString aMessage, nsString aJSON)
       returns (nsString[] retval);
 
-    sendAsyncMessageToParent(nsString aMessage, nsString aJSON);
-
     PGeolocationRequest(URI uri);
 
     PContentDialog(PRUint32 aType, nsCString aName, nsCString aFeatures,
                    PRInt32[] aIntParams, nsString[] aStringParams);
 
 child:
-    createWidget(MagicWindowHandle parentWidget);
+    CreateWidget(MagicWindowHandle parentWidget);
 
-    loadURL(nsCString uri);
+    LoadURL(nsCString uri);
 
-    move(PRUint32 x,
+    Move(PRUint32 x,
          PRUint32 y,
          PRUint32 width,
          PRUint32 height);
 
     /**
      * Sending an activate message moves focus to the child.
      */
-    activate();
+    Activate();
 
-  /**
-   * @see nsIDOMWindowUtils sendMouseEvent.
-   */
-    sendMouseEvent(nsString aType,
-                   PRInt32 aX, //XXX should be float, but ipdl doesn't seem to support that.
-                   PRInt32 aY, //XXX - " -
-                   PRInt32 aButton,
-                   PRInt32 aClickCount,
-                   PRInt32 aModifiers,
-                   bool aIgnoreRootScrollFrame);
+    /**
+     * @see nsIDOMWindowUtils sendMouseEvent.
+     */
+    MouseEvent(nsString aType,
+               float aX,
+               float aY,
+               PRInt32 aButton,
+               PRInt32 aClickCount,
+               PRInt32 aModifiers,
+               bool aIgnoreRootScrollFrame);
 
-  /**
-   * @see nsIDOMWindowUtils sendKeyEvent.
-   */
-    sendKeyEvent(nsString aType,
-                 PRInt32 aKeyCode,
-                 PRInt32 aCharCode,
-                 PRInt32 aModifiers,
-                 bool aPreventDefault);
+    /**
+     * @see nsIDOMWindowUtils sendKeyEvent.
+     */
+    KeyEvent(nsString aType,
+             PRInt32 aKeyCode,
+             PRInt32 aCharCode,
+             PRInt32 aModifiers,
+             bool aPreventDefault);
 
     /**
      * Activate event forwarding from client to parent.
      */
-    activateFrameEvent(nsString aType, bool capture);
+    ActivateFrameEvent(nsString aType, bool capture);
 
-    loadRemoteScript(nsString aURL);
-
-    sendAsyncMessageToChild(nsString aMessage, nsString aJSON);
+    LoadRemoteScript(nsString aURL);
 
     PDocumentRenderer(PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h, nsString bgcolor, PRUint32 flags, bool flush);
 
     // @param matrix the transformation matrix the context we're going to draw into should have.
     PDocumentRendererShmem(PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h, nsString bgcolor, PRUint32 flags, bool flush,
                            gfxMatrix matrix, Shmem buf);
 
     // @param matrix the transformation matrix the context we're going to draw into should have.
rename from dom/ipc/PContentProcess.ipdl
rename to dom/ipc/PContent.ipdl
--- a/dom/ipc/PContentProcess.ipdl
+++ b/dom/ipc/PContent.ipdl
@@ -31,40 +31,40 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PIFrameEmbedding;
+include protocol PBrowser;
 include protocol PTestShell;
 include protocol PNecko;
 
 include "mozilla/TabTypes.h";
 include "mozilla/chrome/RegistryMessageUtils.h";
 include "mozilla/net/NeckoMessageUtils.h";
 
 using ChromePackage;
 using ResourceMapping;
 using OverrideMapping;
 using IPC::URI;
 
 namespace mozilla {
 namespace dom {
 
-rpc protocol PContentProcess
+rpc protocol PContent
 {
-    manages PIFrameEmbedding;
+    manages PBrowser;
     manages PTestShell;
     manages PNecko;
 
 child:
-    PIFrameEmbedding();
+    PBrowser();
 
     PTestShell();
 
     RegisterChrome(ChromePackage[] packages, ResourceMapping[] resources,
                    OverrideMapping[] overrides);
 
     async SetOffline(PRBool offline);
 
--- a/dom/ipc/PContentDialog.ipdl
+++ b/dom/ipc/PContentDialog.ipdl
@@ -30,24 +30,24 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PIFrameEmbedding;
+include protocol PBrowser;
 include "mozilla/TabTypes.h";
 
 namespace mozilla {
 namespace dom {
 
 protocol PContentDialog
 {
-  manager PIFrameEmbedding;
+  manager PBrowser;
 
 child:
     __delete__(PRInt32[] aIntParams, nsString[] aStringParams);
 };
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/ipc/PDocumentRenderer.ipdl
+++ b/dom/ipc/PDocumentRenderer.ipdl
@@ -30,24 +30,24 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PIFrameEmbedding;
+include protocol PBrowser;
 
 namespace mozilla {
 namespace ipc {
 
 protocol PDocumentRenderer
 {
-  manager PIFrameEmbedding;
+  manager PBrowser;
 
 parent:
     // Returns the width and height, in pixels, of the returned ARGB32 data.
     __delete__(PRUint32 w, PRUint32 h, nsCString data);
 };
 
 } // namespace ipc
 } // namespace mozilla
--- a/dom/ipc/PDocumentRendererNativeID.ipdl
+++ b/dom/ipc/PDocumentRendererNativeID.ipdl
@@ -30,24 +30,24 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PIFrameEmbedding;
+include protocol PBrowser;
 
 namespace mozilla {
 namespace ipc {
 
 protocol PDocumentRendererNativeID
 {
-  manager PIFrameEmbedding;
+  manager PBrowser;
 
 parent:
     // Returns the offset, width and height, in pixels, of the area in the
     // buffer that was drawn.
     __delete__(PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h, PRUint32 nativeID);
 };
 
 } // namespace ipc
--- a/dom/ipc/PDocumentRendererShmem.ipdl
+++ b/dom/ipc/PDocumentRendererShmem.ipdl
@@ -30,24 +30,24 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PIFrameEmbedding;
+include protocol PBrowser;
 
 namespace mozilla {
 namespace ipc {
 
 protocol PDocumentRendererShmem
 {
-  manager PIFrameEmbedding;
+  manager PBrowser;
 
 parent:
     // Returns the offset, width and height, in pixels, of the area in the
     // buffer that was drawn.
     __delete__(PRInt32 x, PRInt32 y, PRInt32 w, PRInt32 h, Shmem data);
 };
 
 } // namespace ipc
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -32,17 +32,17 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "TabChild.h"
-#include "mozilla/dom/PContentProcessChild.h"
+#include "mozilla/dom/PContentChild.h"
 #include "mozilla/dom/PContentDialogChild.h"
 
 #include "nsIWebBrowser.h"
 #include "nsEmbedCID.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIBaseWindow.h"
 #include "nsIDOMWindow.h"
 #include "nsIDocShellTreeItem.h"
@@ -93,17 +93,17 @@ using namespace mozilla::dom;
 NS_IMPL_ISUPPORTS1(ContentListener, nsIDOMEventListener)
 
 NS_IMETHODIMP
 ContentListener::HandleEvent(nsIDOMEvent* aEvent)
 {
   RemoteDOMEvent remoteEvent;
   remoteEvent.mEvent = do_QueryInterface(aEvent);
   NS_ENSURE_STATE(remoteEvent.mEvent);
-  mTabChild->SendsendEvent(remoteEvent);
+  mTabChild->SendEvent(remoteEvent);
   return NS_OK;
 }
 
 class ContentDialogChild : public PContentDialogChild
 {
 public:
   virtual bool Recv__delete__(const nsTArray<int>& aIntParams,
                               const nsTArray<nsString>& aStringParams);
@@ -285,24 +285,24 @@ NS_IMETHODIMP
 TabChild::Blur()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 TabChild::FocusNextElement()
 {
-  SendmoveFocus(PR_TRUE);
+  SendMoveFocus(PR_TRUE);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::FocusPrevElement()
 {
-  SendmoveFocus(PR_FALSE);
+  SendMoveFocus(PR_FALSE);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::GetInterface(const nsIID & aIID, void **aSink)
 {
     // XXXbz should we restrict the set of interfaces we hand out here?
     // See bug 537429
@@ -314,18 +314,18 @@ TabChild::ProvideWindow(nsIDOMWindow* aP
                         PRBool aCalledFromJS,
                         PRBool aPositionSpecified, PRBool aSizeSpecified,
                         nsIURI* aURI, const nsAString& aName,
                         const nsACString& aFeatures, PRBool* aWindowIsNew,
                         nsIDOMWindow** aReturn)
 {
     *aReturn = nsnull;
 
-    PIFrameEmbeddingChild* newChild;
-    if (!CallcreateWindow(&newChild)) {
+    PBrowserChild* newChild;
+    if (!CallCreateWindow(&newChild)) {
         return NS_ERROR_NOT_AVAILABLE;
     }
 
     nsCOMPtr<nsIDOMWindow> win =
         do_GetInterface(static_cast<TabChild*>(newChild)->mWebNav);
     win.forget(aReturn);
     return NS_OK;
 }
@@ -401,17 +401,17 @@ TabChild::ArraysToParams(const nsTArray<
     }
     for (PRInt32 j = 0; PRUint32(j) < aStringParams.Length(); ++j) {
       aParams->SetString(j, aStringParams[j].get());
     }
   }
 }
 
 bool
-TabChild::RecvcreateWidget(const MagicWindowHandle& parentWidget)
+TabChild::RecvCreateWidget(const MagicWindowHandle& parentWidget)
 {
     nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(mWebNav);
     if (!baseWindow) {
         NS_ERROR("mWebNav doesn't QI to nsIBaseWindow");
         return true;
     }
 
 #ifdef MOZ_WIDGET_GTK2
@@ -448,28 +448,28 @@ TabChild::RecvcreateWidget(const MagicWi
     baseWindow->Create();
     baseWindow->SetVisibility(PR_TRUE);
 #endif
 
     return InitTabChildGlobal();
 }
 
 bool
-TabChild::destroyWidget()
+TabChild::DestroyWidget()
 {
     nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(mWebNav);
     if (baseWindow)
         baseWindow->Destroy();
 
     return true;
 }
 
 TabChild::~TabChild()
 {
-    destroyWidget();
+    DestroyWidget();
     nsCOMPtr<nsIWebBrowser> webBrowser = do_QueryInterface(mWebNav);
     if (webBrowser) {
       webBrowser->SetContainerWindow(nsnull);
     }
     if (mCx) {
       nsIXPConnect* xpc = nsContentUtils::XPConnect();
       if (xpc) {
          xpc->ReleaseJSContext(mCx, PR_FALSE);
@@ -481,158 +481,158 @@ TabChild::~TabChild()
 }
 
 NS_IMETHODIMP
 TabChild::OnStateChange(nsIWebProgress *aWebProgress,
                         nsIRequest *aRequest,
                         PRUint32 aStateFlags,
                         nsresult aStatus)
 {
-  SendnotifyStateChange(aStateFlags, aStatus);
+  SendNotifyStateChange(aStateFlags, aStatus);
   return NS_OK;
 }
 
 // Only one of OnProgressChange / OnProgressChange64 will be called.
 // According to interface, it should be OnProgressChange64, but looks
 // like docLoader only sends the former.
 NS_IMETHODIMP
 TabChild::OnProgressChange(nsIWebProgress *aWebProgress,
                            nsIRequest *aRequest,
                            PRInt32 aCurSelfProgress,
                            PRInt32 aMaxSelfProgress,
                            PRInt32 aCurTotalProgress,
                            PRInt32 aMaxTotalProgress)
 {
-  SendnotifyProgressChange(aCurSelfProgress, aMaxSelfProgress,
+  SendNotifyProgressChange(aCurSelfProgress, aMaxSelfProgress,
                            aCurTotalProgress, aMaxTotalProgress);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::OnStatusChange(nsIWebProgress *aWebProgress,
                          nsIRequest *aRequest,
                          nsresult aStatus,
                          const PRUnichar* aMessage)
 {
   nsDependentString message(aMessage);
-  SendnotifyStatusChange(aStatus, message);
+  SendNotifyStatusChange(aStatus, message);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::OnSecurityChange(nsIWebProgress *aWebProgress,
                            nsIRequest *aRequest,
                            PRUint32 aState)
 {
-  SendnotifySecurityChange(aState);
+  SendNotifySecurityChange(aState);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::OnLocationChange(nsIWebProgress *aWebProgress,
                            nsIRequest *aRequest,
                            nsIURI *aLocation)
 {
   NS_ENSURE_ARG_POINTER(aLocation);
   nsCString uri;
   aLocation->GetSpec(uri);
-  SendnotifyLocationChange(uri);
+  SendNotifyLocationChange(uri);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::OnProgressChange64(nsIWebProgress *aWebProgress,
                              nsIRequest *aRequest,
                              PRInt64 aCurSelfProgress,
                              PRInt64 aMaxSelfProgress,
                              PRInt64 aCurTotalProgress,
                              PRInt64 aMaxTotalProgress)
 {
-  SendnotifyProgressChange(aCurSelfProgress, aMaxSelfProgress,
+  SendNotifyProgressChange(aCurSelfProgress, aMaxSelfProgress,
                            aCurTotalProgress, aMaxTotalProgress);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::OnRefreshAttempted(nsIWebProgress *aWebProgress,
                              nsIURI *aURI, PRInt32 aMillis,
                              PRBool aSameURL, PRBool *aRefreshAllowed)
 {
   NS_ENSURE_ARG_POINTER(aURI);
   nsCString uri;
   aURI->GetSpec(uri);
   bool sameURL = aSameURL;
   bool refreshAllowed;
-  SendrefreshAttempted(uri, aMillis, sameURL, &refreshAllowed);
+  SendRefreshAttempted(uri, aMillis, sameURL, &refreshAllowed);
   *aRefreshAllowed = refreshAllowed;
   return NS_OK;
 }
                              
                              
 
 bool
-TabChild::RecvloadURL(const nsCString& uri)
+TabChild::RecvLoadURL(const nsCString& uri)
 {
     printf("loading %s, %d\n", uri.get(), NS_IsMainThread());
 
     nsresult rv = mWebNav->LoadURI(NS_ConvertUTF8toUTF16(uri).get(),
                                    nsIWebNavigation::LOAD_FLAGS_NONE,
                                    NULL, NULL, NULL);
     if (NS_FAILED(rv)) {
         NS_WARNING("mWebNav->LoadURI failed. Eating exception, what else can I do?");
     }
 
     return true;
 }
 
 bool
-TabChild::Recvmove(const PRUint32& x,
-                     const PRUint32& y,
-                     const PRUint32& width,
-                     const PRUint32& height)
+TabChild::RecvMove(const PRUint32& x,
+                   const PRUint32& y,
+                   const PRUint32& width,
+                   const PRUint32& height)
 {
     printf("[TabChild] MOVE to (x,y)=(%ud, %ud), (w,h)= (%ud, %ud)\n",
            x, y, width, height);
 
     nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(mWebNav);
     baseWin->SetPositionAndSize(x, y, width, height, PR_TRUE);
     return true;
 }
 
 bool
-TabChild::Recvactivate()
+TabChild::RecvActivate()
 {
   nsCOMPtr<nsIWebBrowserFocus> browser = do_QueryInterface(mWebNav);
   browser->Activate();
   return true;
 }
 
 bool
-TabChild::RecvsendMouseEvent(const nsString& aType,
-                             const PRInt32&  aX,
-                             const PRInt32&  aY,
-                             const PRInt32&  aButton,
-                             const PRInt32&  aClickCount,
-                             const PRInt32&  aModifiers,
-                             const bool&     aIgnoreRootScrollFrame)
+TabChild::RecvMouseEvent(const nsString& aType,
+                         const float&    aX,
+                         const float&    aY,
+                         const PRInt32&  aButton,
+                         const PRInt32&  aClickCount,
+                         const PRInt32&  aModifiers,
+                         const bool&     aIgnoreRootScrollFrame)
 {
   nsCOMPtr<nsPIDOMWindow> window = do_GetInterface(mWebNav);
   nsCOMPtr<nsIDOMWindowUtils> utils = do_GetInterface(window);
   NS_ENSURE_TRUE(utils, true);
   utils->SendMouseEvent(aType, aX, aY, aButton, aClickCount, aModifiers,
                         aIgnoreRootScrollFrame);
   return true;
 }
 
 bool
-TabChild::RecvsendKeyEvent(const nsString& aType,
-                           const PRInt32& aKeyCode,
-                           const PRInt32& aCharCode,
-                           const PRInt32& aModifiers,
-                           const bool& aPreventDefault)
+TabChild::RecvKeyEvent(const nsString& aType,
+                       const PRInt32& aKeyCode,
+                       const PRInt32& aCharCode,
+                       const PRInt32& aModifiers,
+                       const bool& aPreventDefault)
 {
   nsCOMPtr<nsPIDOMWindow> window = do_GetInterface(mWebNav);
   nsCOMPtr<nsIDOMWindowUtils> utils = do_GetInterface(window);
   NS_ENSURE_TRUE(utils, true);
   PRBool ignored = PR_FALSE;
   utils->SendKeyEvent(aType, aKeyCode, aCharCode,
                       aModifiers, aPreventDefault, &ignored);
   return true;
@@ -841,31 +841,31 @@ TabChild::AllocPGeolocationRequest(const
 
 bool
 TabChild::DeallocPGeolocationRequest(PGeolocationRequestChild* actor)
 {
   return true;
 }
 
 bool
-TabChild::RecvactivateFrameEvent(const nsString& aType, const bool& capture)
+TabChild::RecvActivateFrameEvent(const nsString& aType, const bool& capture)
 {
   nsCOMPtr<nsPIDOMWindow> window = do_GetInterface(mWebNav);
   NS_ENSURE_TRUE(window, true);
   nsCOMPtr<nsIDOMEventTarget> chromeHandler =
     do_QueryInterface(window->GetChromeEventHandler());
   NS_ENSURE_TRUE(chromeHandler, true);
   nsRefPtr<ContentListener> listener = new ContentListener(this);
   NS_ENSURE_TRUE(listener, true);
   chromeHandler->AddEventListener(aType, listener, capture);
   return true;
 }
 
 bool
-TabChild::RecvloadRemoteScript(const nsString& aURL)
+TabChild::RecvLoadRemoteScript(const nsString& aURL)
 {
   nsCString url = NS_ConvertUTF16toUTF8(aURL);
   nsCOMPtr<nsIURI> uri;
   nsresult rv = NS_NewURI(getter_AddRefs(uri), url);
   NS_ENSURE_SUCCESS(rv, true);
   NS_NewChannel(getter_AddRefs(mChannel), uri);
   NS_ENSURE_TRUE(mChannel, true);
 
@@ -910,18 +910,18 @@ TabChild::RecvloadRemoteScript(const nsS
     JSContext *unused;
     nsContentUtils::ThreadJSContextStack()->Pop(&unused);
     NS_ENSURE_TRUE(ret, true); // This gives us a useful warning!
   }
   return true;
 }
 
 bool
-TabChild::RecvsendAsyncMessageToChild(const nsString& aMessage,
-                                      const nsString& aJSON)
+TabChild::RecvAsyncMessage(const nsString& aMessage,
+                           const nsString& aJSON)
 {
   if (mTabChildGlobal) {
     static_cast<nsFrameMessageManager*>(mTabChildGlobal->mMessageManager.get())->
       ReceiveMessage(static_cast<nsPIDOMEventTarget*>(mTabChildGlobal),
                      aMessage, PR_FALSE, aJSON, nsnull, nsnull);
   }
   return true;
 }
@@ -1005,34 +1005,34 @@ TabChild::InitTabChildGlobal()
   rv = mRootGlobal->GetJSObject(&global);
   NS_ENSURE_SUCCESS(rv, false);
 
   JS_SetGlobalObject(cx, global);
 
   return true;
 }
 
-static
-bool SendSyncMessageToParent(void* aCallbackData,
-                             const nsAString& aMessage,
-                             const nsAString& aJSON,
-                             nsTArray<nsString>* aJSONRetVal)
+static bool
+SendSyncMessageToParent(void* aCallbackData,
+                        const nsAString& aMessage,
+                        const nsAString& aJSON,
+                        nsTArray<nsString>* aJSONRetVal)
 {
   return static_cast<TabChild*>(aCallbackData)->
-    SendsendSyncMessageToParent(nsString(aMessage), nsString(aJSON),
-                                aJSONRetVal);
+    SendSyncMessage(nsString(aMessage), nsString(aJSON),
+                    aJSONRetVal);
 }
 
-static
-bool SendAsyncMessageToParent(void* aCallbackData,
-                              const nsAString& aMessage,
-                              const nsAString& aJSON)
+static bool
+SendAsyncMessageToParent(void* aCallbackData,
+                         const nsAString& aMessage,
+                         const nsAString& aJSON)
 {
   return static_cast<TabChild*>(aCallbackData)->
-    SendsendAsyncMessageToParent(nsString(aMessage), nsString(aJSON));
+    SendAsyncMessage(nsString(aMessage), nsString(aJSON));
 }
 
 TabChildGlobal::TabChildGlobal(TabChild* aTabChild)
 : mTabChild(aTabChild)
 {
   mMessageManager = new nsFrameMessageManager(PR_FALSE,
                                               SendSyncMessageToParent,
                                               SendAsyncMessageToParent,
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -35,17 +35,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_tabs_TabChild_h
 #define mozilla_tabs_TabChild_h
 
 #ifndef _IMPL_NS_LAYOUT
-#include "mozilla/dom/PIFrameEmbeddingChild.h"
+#include "mozilla/dom/PBrowserChild.h"
 #endif
 #include "nsIWebNavigation.h"
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
 #include "nsIWebBrowserChrome2.h"
 #include "nsIEmbeddingSiteWindow2.h"
 #include "nsIWebBrowserChromeFocus.h"
 #include "nsIWebProgressListener.h"
@@ -134,68 +134,68 @@ class ContentListener : public nsIDOMEve
 public:
   ContentListener(TabChild* aTabChild) : mTabChild(aTabChild) {}
   NS_DECL_ISUPPORTS
   NS_DECL_NSIDOMEVENTLISTENER
 protected:
   TabChild* mTabChild;
 };
 
-class TabChild : public PIFrameEmbeddingChild,
+class TabChild : public PBrowserChild,
                  public nsIWebProgressListener2,
                  public nsIWebBrowserChrome2,
                  public nsIEmbeddingSiteWindow2,
                  public nsIWebBrowserChromeFocus,
                  public nsIInterfaceRequestor,
                  public nsIWindowProvider,
                  public nsSupportsWeakReference,
                  public nsIDialogCreator,
                  public nsITabChild
 {
 public:
     TabChild();
     virtual ~TabChild();
-    bool destroyWidget();
+    bool DestroyWidget();
     nsresult Init();
 
     NS_DECL_ISUPPORTS
     NS_DECL_NSIWEBPROGRESSLISTENER
     NS_DECL_NSIWEBPROGRESSLISTENER2
     NS_DECL_NSIWEBBROWSERCHROME
     NS_DECL_NSIWEBBROWSERCHROME2
     NS_DECL_NSIEMBEDDINGSITEWINDOW
     NS_DECL_NSIEMBEDDINGSITEWINDOW2
     NS_DECL_NSIWEBBROWSERCHROMEFOCUS
     NS_DECL_NSIINTERFACEREQUESTOR
     NS_DECL_NSIWINDOWPROVIDER
     NS_DECL_NSIDIALOGCREATOR
 
-    virtual bool RecvcreateWidget(const MagicWindowHandle& parentWidget);
-    virtual bool RecvloadURL(const nsCString& uri);
-    virtual bool Recvmove(const PRUint32& x,
+    virtual bool RecvCreateWidget(const MagicWindowHandle& parentWidget);
+    virtual bool RecvLoadURL(const nsCString& uri);
+    virtual bool RecvMove(const PRUint32& x,
                           const PRUint32& y,
                           const PRUint32& width,
                           const PRUint32& height);
-    virtual bool Recvactivate();
-    virtual bool RecvsendMouseEvent(const nsString& aType,
-                                    const PRInt32&  aX,
-                                    const PRInt32&  aY,
-                                    const PRInt32&  aButton,
-                                    const PRInt32&  aClickCount,
-                                    const PRInt32&  aModifiers,
-                                    const bool&     aIgnoreRootScrollFrame);
-    virtual bool RecvsendKeyEvent(const nsString& aType,
-                                  const PRInt32&  aKeyCode,
-                                  const PRInt32&  aCharCode,
-                                  const PRInt32&  aModifiers,
-                                  const bool&     aPreventDefault);
-    virtual bool RecvactivateFrameEvent(const nsString& aType, const bool& capture);
-    virtual bool RecvloadRemoteScript(const nsString& aURL);
-    virtual bool RecvsendAsyncMessageToChild(const nsString& aMessage,
-                                             const nsString& aJSON);
+    virtual bool RecvActivate();
+    virtual bool RecvMouseEvent(const nsString& aType,
+                                const float&    aX,
+                                const float&    aY,
+                                const PRInt32&  aButton,
+                                const PRInt32&  aClickCount,
+                                const PRInt32&  aModifiers,
+                                const bool&     aIgnoreRootScrollFrame);
+    virtual bool RecvKeyEvent(const nsString& aType,
+                              const PRInt32&  aKeyCode,
+                              const PRInt32&  aCharCode,
+                              const PRInt32&  aModifiers,
+                              const bool&     aPreventDefault);
+    virtual bool RecvActivateFrameEvent(const nsString& aType, const bool& capture);
+    virtual bool RecvLoadRemoteScript(const nsString& aURL);
+    virtual bool RecvAsyncMessage(const nsString& aMessage,
+                                  const nsString& aJSON);
     virtual mozilla::ipc::PDocumentRendererChild* AllocPDocumentRenderer(
             const PRInt32& x,
             const PRInt32& y,
             const PRInt32& w,
             const PRInt32& h,
             const nsString& bgcolor,
             const PRUint32& flags,
             const bool& flush);
@@ -276,25 +276,20 @@ public:
     JSContext* GetJSContext() { return mCx; }
 
     nsIPrincipal* GetPrincipal() { return mPrincipal; }
 
 private:
     bool InitTabChildGlobal();
 
     nsCOMPtr<nsIWebNavigation> mWebNav;
-
     nsCOMPtr<nsIXPConnectJSObjectHolder> mRootGlobal;
-
     JSContext* mCx;
-
     nsCOMPtr<nsIChannel> mChannel;
-
     TabChildGlobal* mTabChildGlobal;
-
     nsCOMPtr<nsIPrincipal> mPrincipal;
 
     DISALLOW_EVIL_CONSTRUCTORS(TabChild);
 };
 
 }
 }
 
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -36,17 +36,17 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "TabParent.h"
 
 #include "mozilla/ipc/DocumentRendererParent.h"
 #include "mozilla/ipc/DocumentRendererShmemParent.h"
 #include "mozilla/ipc/DocumentRendererNativeIDParent.h"
-#include "mozilla/dom/ContentProcessParent.h"
+#include "mozilla/dom/ContentParent.h"
 
 #include "nsIURI.h"
 #include "nsFocusManager.h"
 #include "nsCOMPtr.h"
 #include "nsServiceManagerUtils.h"
 #include "nsIDOMElement.h"
 #include "nsEventDispatcher.h"
 #include "nsIDOMEventTarget.h"
@@ -63,20 +63,22 @@
 #include "nsContentUtils.h"
 #include "nsGeolocationOOP.h"
 #include "nsIDOMNSHTMLFrameElement.h"
 #include "nsIDialogCreator.h"
 #include "nsThreadUtils.h"
 #include "nsIPromptFactory.h"
 #include "nsIContent.h"
 
+#include "mozilla/unused.h"
+
 using mozilla::ipc::DocumentRendererParent;
 using mozilla::ipc::DocumentRendererShmemParent;
 using mozilla::ipc::DocumentRendererNativeIDParent;
-using mozilla::dom::ContentProcessParent;
+using mozilla::dom::ContentParent;
 
 // The flags passed by the webProgress notifications are 16 bits shifted
 // from the ones registered by webProgressListeners.
 #define NOTIFY_FLAG_SHIFT 16
 
 namespace mozilla {
 namespace dom {
 
@@ -98,45 +100,45 @@ TabParent::ActorDestroy(ActorDestroyReas
     nsRefPtr<nsFrameLoader> frameLoader = frameLoaderOwner->GetFrameLoader();
     if (frameLoader) {
       frameLoader->DestroyChild();
     }
   }
 }
 
 bool
-TabParent::RecvmoveFocus(const bool& aForward)
+TabParent::RecvMoveFocus(const bool& aForward)
 {
   nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
   if (fm) {
     nsCOMPtr<nsIDOMElement> dummy;
-    PRUint32 type = aForward ? nsIFocusManager::MOVEFOCUS_FORWARD
-                             : nsIFocusManager::MOVEFOCUS_BACKWARD;
+    PRUint32 type = aForward ? PRUint32(nsIFocusManager::MOVEFOCUS_FORWARD)
+                             : PRUint32(nsIFocusManager::MOVEFOCUS_BACKWARD);
     fm->MoveFocus(nsnull, mFrameElement, type, nsIFocusManager::FLAG_BYKEY, 
                   getter_AddRefs(dummy));
   }
   return true;
 }
 
 bool
-TabParent::RecvsendEvent(const RemoteDOMEvent& aEvent)
+TabParent::RecvEvent(const RemoteDOMEvent& aEvent)
 {
   nsCOMPtr<nsIDOMEvent> event = do_QueryInterface(aEvent.mEvent);
   NS_ENSURE_TRUE(event, true);
 
   nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(mFrameElement);
   NS_ENSURE_TRUE(target, true);
 
   PRBool dummy;
   target->DispatchEvent(event, &dummy);
   return true;
 }
 
 bool
-TabParent::RecvnotifyProgressChange(const PRInt64& aProgress,
+TabParent::RecvNotifyProgressChange(const PRInt64& aProgress,
                                     const PRInt64& aProgressMax,
                                     const PRInt64& aTotalProgress,
                                     const PRInt64& aMaxTotalProgress)
 {
   /*
    * First notify any listeners of the new progress info...
    *
    * Operate the elements from back to front so that if items get
@@ -170,17 +172,17 @@ TabParent::RecvnotifyProgressChange(cons
                                  PRInt32(aMaxTotalProgress));
     }
   }
 
   return true;
 }
 
 bool
-TabParent::RecvnotifyStateChange(const PRUint32& aStateFlags,
+TabParent::RecvNotifyStateChange(const PRUint32& aStateFlags,
                                  const nsresult& aStatus)
 {
   /*                                                                           
    * First notify any listeners of the new state info...
    *
    * Operate the elements from back to front so that if items get
    * get removed from the list it won't affect our iteration
    */
@@ -210,17 +212,17 @@ TabParent::RecvnotifyStateChange(const P
     
     listener->OnStateChange(this, nsnull, aStateFlags, aStatus); 
   }   
 
   return true;
  }
 
 bool
-TabParent::RecvnotifyLocationChange(const nsCString& aUri)
+TabParent::RecvNotifyLocationChange(const nsCString& aUri)
 {
   nsCOMPtr<nsIURI> uri;
   nsresult rv = NS_NewURI(getter_AddRefs(uri), aUri);
   if (NS_FAILED(rv)) {
     return false;
   }
 
   /*                                                                           
@@ -247,17 +249,17 @@ TabParent::RecvnotifyLocationChange(cons
     
     listener->OnLocationChange(this, nsnull, uri);
   }
 
   return true;
 }
 
 bool
-TabParent::RecvnotifyStatusChange(const nsresult& status,
+TabParent::RecvNotifyStatusChange(const nsresult& status,
                                   const nsString& message)
 {
   /*                                                                           
    * First notify any listeners of the new state info...
    *
    * Operate the elements from back to front so that if items get
    * get removed from the list it won't affect our iteration
    */
@@ -279,17 +281,17 @@ TabParent::RecvnotifyStatusChange(const 
 
     listener->OnStatusChange(this, nsnull, status, message.BeginReading());
   }
 
   return true;
 }
 
 bool
-TabParent::RecvnotifySecurityChange(const PRUint32& aState)
+TabParent::RecvNotifySecurityChange(const PRUint32& aState)
 {
   /*                                                                           
    * First notify any listeners of the new state info...
    *
    * Operate the elements from back to front so that if items get
    * get removed from the list it won't affect our iteration
    */
 
@@ -311,17 +313,17 @@ TabParent::RecvnotifySecurityChange(cons
 
     listener->OnSecurityChange(this, nsnull, aState);
   }
 
   return true;
 }
 
 bool
-TabParent::RecvrefreshAttempted(const nsCString& aURI, const PRInt32& aMillis, 
+TabParent::RecvRefreshAttempted(const nsCString& aURI, const PRInt32& aMillis, 
                                 const bool& aSameURI, bool* refreshAllowed)
 {
   nsCOMPtr<nsIURI> uri;
   nsresult rv = NS_NewURI(getter_AddRefs(uri), aURI);
   if (NS_FAILED(rv)) {
     return false;
   }
   /*                                                                           
@@ -360,17 +362,17 @@ TabParent::RecvrefreshAttempted(const ns
                                   aMillis, aSameURI, &allowed);
     *refreshAllowed = allowed && *refreshAllowed;
   }
 
   return true;
 }
 
 bool
-TabParent::AnswercreateWindow(PIFrameEmbeddingParent** retval)
+TabParent::AnswerCreateWindow(PBrowserParent** retval)
 {
     if (!mBrowserDOMWindow) {
         return false;
     }
 
     // Get a new rendering area from the browserDOMWin.  We don't want
     // to be starting any loads here, so get it with a null URI.
     nsCOMPtr<nsIFrameLoaderOwner> frameLoaderOwner;
@@ -382,39 +384,39 @@ TabParent::AnswercreateWindow(PIFrameEmb
         return false;
     }
 
     nsRefPtr<nsFrameLoader> frameLoader = frameLoaderOwner->GetFrameLoader();
     if (!frameLoader) {
         return false;
     }
 
-    *retval = frameLoader->GetChildProcess();
+    *retval = frameLoader->GetRemoteBrowser();
     return true;
 }
 
 void
 TabParent::LoadURL(nsIURI* aURI)
 {
     nsCString spec;
     aURI->GetSpec(spec);
 
-    SendloadURL(spec);
+    unused << SendLoadURL(spec);
 }
 
 void
 TabParent::Move(PRUint32 x, PRUint32 y, PRUint32 width, PRUint32 height)
 {
-    Sendmove(x, y, width, height);
+    unused << SendMove(x, y, width, height);
 }
 
 void
 TabParent::Activate()
 {
-    Sendactivate();
+    unused << SendActivate();
 }
 
 mozilla::ipc::PDocumentRendererParent*
 TabParent::AllocPDocumentRenderer(const PRInt32& x,
         const PRInt32& y, const PRInt32& w, const PRInt32& h, const nsString& bgcolor,
         const PRUint32& flags, const bool& flush)
 {
     return new DocumentRendererParent();
@@ -472,42 +474,43 @@ TabParent::DeallocPGeolocationRequest(PG
   return true;
 }
 
 void
 TabParent::SendMouseEvent(const nsAString& aType, float aX, float aY,
                           PRInt32 aButton, PRInt32 aClickCount,
                           PRInt32 aModifiers, PRBool aIgnoreRootScrollFrame)
 {
-  SendsendMouseEvent(nsString(aType), aX, aY, aButton, aClickCount,
-                     aModifiers, aIgnoreRootScrollFrame);
+  unused << PBrowserParent::SendMouseEvent(nsString(aType), aX, aY,
+                                           aButton, aClickCount,
+                                           aModifiers, aIgnoreRootScrollFrame);
 }
 
 void
 TabParent::SendKeyEvent(const nsAString& aType,
                         PRInt32 aKeyCode,
                         PRInt32 aCharCode,
                         PRInt32 aModifiers,
                         PRBool aPreventDefault)
 {
-    SendsendKeyEvent(nsString(aType), aKeyCode, aCharCode, aModifiers,
-                     aPreventDefault);
+  unused << PBrowserParent::SendKeyEvent(nsString(aType), aKeyCode, aCharCode,
+                                         aModifiers, aPreventDefault);
 }
 
 bool
-TabParent::RecvsendSyncMessageToParent(const nsString& aMessage,
-                                       const nsString& aJSON,
-                                       nsTArray<nsString>* aJSONRetVal)
+TabParent::RecvSyncMessage(const nsString& aMessage,
+                           const nsString& aJSON,
+                           nsTArray<nsString>* aJSONRetVal)
 {
   return ReceiveMessage(aMessage, PR_TRUE, aJSON, aJSONRetVal);
 }
 
 bool
-TabParent::RecvsendAsyncMessageToParent(const nsString& aMessage,
-                                        const nsString& aJSON)
+TabParent::RecvAsyncMessage(const nsString& aMessage,
+                            const nsString& aJSON)
 {
   return ReceiveMessage(aMessage, PR_FALSE, aJSON, nsnull);
 }
 
 bool
 TabParent::ReceiveMessage(const nsString& aMessage,
                           PRBool aSync,
                           const nsString& aJSON,
@@ -546,18 +549,16 @@ TabParent::ReceiveMessage(const nsString
   return true;
 }
 
 // nsIWebProgress
 nsresult
 TabParent::AddProgressListener(nsIWebProgressListener* aListener,
                                PRUint32 aNotifyMask)
 {
-  nsresult rv;
-
   if (GetListenerInfo(aListener)) {
     // The listener is already registered!
     return NS_ERROR_FAILURE;
   }
 
   nsWeakPtr listener = do_GetWeakReference(aListener);
   if (!listener) {
     return NS_ERROR_INVALID_ARG;
@@ -615,19 +616,16 @@ TabParent::GetIsLoadingDocument(PRBool *
 
 // nsIAuthPromptProvider
 
 // This method is largely copied from nsDocShell::GetAuthPrompt
 NS_IMETHODIMP
 TabParent::GetAuthPrompt(PRUint32 aPromptReason, const nsIID& iid,
                           void** aResult)
 {
-  // a priority prompt request will override a false mAllowAuth setting
-  PRBool priorityPrompt = (aPromptReason == PROMPT_PROXY);
-
   // we're either allowing auth, or it's a proxy request
   nsresult rv;
   nsCOMPtr<nsIPromptFactory> wwatch =
     do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDOMWindow> window;
   nsCOMPtr<nsIContent> frame = do_QueryInterface(mFrameElement);
@@ -698,17 +696,18 @@ TabParent::HandleDelayedDialogs()
       }
     }
 
     delete data;
     if (dialog) {
       nsTArray<PRInt32> intParams;
       nsTArray<nsString> stringParams;
       TabChild::ParamsToArrays(params, intParams, stringParams);
-      PContentDialogParent::Send__delete__(dialog, intParams, stringParams);
+      unused << PContentDialogParent::Send__delete__(dialog,
+                                                     intParams, stringParams);
     }
   }
   if (ShouldDelayDialogs() && mDelayedDialogs.Length()) {
     nsContentUtils::DispatchTrustedEvent(frame->GetOwnerDoc(), frame,
                                          NS_LITERAL_STRING("MozDelayedModalDialog"),
                                          PR_TRUE, PR_TRUE);
   }
 }
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -34,17 +34,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_tabs_TabParent_h
 #define mozilla_tabs_TabParent_h
 
-#include "mozilla/dom/PIFrameEmbeddingParent.h"
+#include "mozilla/dom/PBrowserParent.h"
 #include "mozilla/dom/PContentDialogParent.h"
 #include "mozilla/ipc/GeckoChildProcessHost.h"
 
 #include "jsapi.h"
 #include "nsCOMPtr.h"
 #include "nsITabParent.h"
 #include "nsIBrowserDOMWindow.h"
 #include "nsIWebProgress.h"
@@ -82,52 +82,52 @@ struct TabParentListenerInfo
 inline    
 bool operator==(const TabParentListenerInfo& lhs, const TabParentListenerInfo& rhs)
 {
   return &lhs == &rhs;
 }
 
 class ContentDialogParent : public PContentDialogParent {};
 
-class TabParent : public PIFrameEmbeddingParent 
+class TabParent : public PBrowserParent 
                 , public nsITabParent 
                 , public nsIWebProgress
                 , public nsIAuthPromptProvider
 {
 public:
     TabParent();
     virtual ~TabParent();
     void SetOwnerElement(nsIDOMElement* aElement) { mFrameElement = aElement; }
     void SetBrowserDOMWindow(nsIBrowserDOMWindow* aBrowserDOMWindow) {
         mBrowserDOMWindow = aBrowserDOMWindow;
     }
 
-    virtual bool RecvmoveFocus(const bool& aForward);
-    virtual bool RecvsendEvent(const RemoteDOMEvent& aEvent);
-    virtual bool RecvnotifyProgressChange(const PRInt64& aProgress,
+    virtual bool RecvMoveFocus(const bool& aForward);
+    virtual bool RecvEvent(const RemoteDOMEvent& aEvent);
+    virtual bool RecvNotifyProgressChange(const PRInt64& aProgress,
                                           const PRInt64& aProgressMax,
                                           const PRInt64& aTotalProgress,
                                           const PRInt64& aMaxTotalProgress);
-    virtual bool RecvnotifyStateChange(const PRUint32& aStateFlags,
+    virtual bool RecvNotifyStateChange(const PRUint32& aStateFlags,
                                        const nsresult& aStatus);
-    virtual bool RecvnotifyLocationChange(const nsCString& aUri);
-    virtual bool RecvnotifyStatusChange(const nsresult& status,
+    virtual bool RecvNotifyLocationChange(const nsCString& aUri);
+    virtual bool RecvNotifyStatusChange(const nsresult& status,
                                         const nsString& message);
-    virtual bool RecvnotifySecurityChange(const PRUint32& aState);
-    virtual bool RecvrefreshAttempted(const nsCString& aURI,
+    virtual bool RecvNotifySecurityChange(const PRUint32& aState);
+    virtual bool RecvRefreshAttempted(const nsCString& aURI,
                                       const PRInt32& aMillis,
                                       const bool& aSameURI,
                                       bool* aAllowRefresh);
 
-    virtual bool AnswercreateWindow(PIFrameEmbeddingParent** retval);
-    virtual bool RecvsendSyncMessageToParent(const nsString& aMessage,
-                                             const nsString& aJSON,
-                                             nsTArray<nsString>* aJSONRetVal);
-    virtual bool RecvsendAsyncMessageToParent(const nsString& aMessage,
-                                              const nsString& aJSON);
+    virtual bool AnswerCreateWindow(PBrowserParent** retval);
+    virtual bool RecvSyncMessage(const nsString& aMessage,
+                                 const nsString& aJSON,
+                                 nsTArray<nsString>* aJSONRetVal);
+    virtual bool RecvAsyncMessage(const nsString& aMessage,
+                                  const nsString& aJSON);
     virtual PContentDialogParent* AllocPContentDialog(const PRUint32& aType,
                                                       const nsCString& aName,
                                                       const nsCString& aFeatures,
                                                       const nsTArray<int>& aIntParams,
                                                       const nsTArray<nsString>& aStringParams);
     virtual bool DeallocPContentDialog(PContentDialogParent* aDialog)
     {
       delete aDialog;
--- a/dom/ipc/ipdl.mk
+++ b/dom/ipc/ipdl.mk
@@ -30,15 +30,15 @@
 # decision by deleting the provisions above and replace them with the notice
 # and other provisions required by the GPL or the LGPL. If you do not delete
 # the provisions above, a recipient may use your version of this file under
 # the terms of any one of the MPL, the GPL or the LGPL.
 #
 # ***** END LICENSE BLOCK *****
 
 IPDLSRCS = \
-  PContentProcess.ipdl \
-  PIFrameEmbedding.ipdl \
+  PBrowser.ipdl \
+  PContent.ipdl \
+  PContentDialog.ipdl \
   PDocumentRenderer.ipdl \
+  PDocumentRendererNativeID.ipdl \
   PDocumentRendererShmem.ipdl \
-  PDocumentRendererNativeID.ipdl \
-  PContentDialog.ipdl \
   $(NULL)
--- a/dom/src/geolocation/PGeolocationRequest.ipdl
+++ b/dom/src/geolocation/PGeolocationRequest.ipdl
@@ -30,27 +30,27 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PIFrameEmbedding;
+include protocol PBrowser;
 include "mozilla/net/NeckoMessageUtils.h";
 
 using IPC::URI;
 
 namespace mozilla {
 namespace dom {
 
 protocol PGeolocationRequest
 {
-  manager PIFrameEmbedding;
+  manager PBrowser;
 
 parent:
   prompt();
 
 child:
   __delete__(bool allow);
 };
 
--- a/dom/src/geolocation/nsGeolocation.cpp
+++ b/dom/src/geolocation/nsGeolocation.cpp
@@ -33,19 +33,19 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifdef MOZ_IPC
 #include "nsGeolocationOOP.h"
 #include "nsXULAppAPI.h"
 
-#include "mozilla/dom/PIFrameEmbeddingChild.h"
-#include "mozilla/dom/PIFrameEmbeddingParent.h"
-#include "mozilla/dom/ContentProcessChild.h"
+#include "mozilla/dom/PBrowserChild.h"
+#include "mozilla/dom/PBrowserParent.h"
+#include "mozilla/dom/ContentChild.h"
 #include "nsNetUtil.h"
 
 #include "nsFrameManager.h"
 #include "nsFrameLoader.h"
 #include "nsIFrameLoader.h"
 
 #include "nsIDocShellTreeOwner.h"
 #include "nsIDocShellTreeItem.h"
@@ -67,16 +67,17 @@
 #include "nsContentUtils.h"
 #include "nsIURI.h"
 #include "nsIPermissionManager.h"
 #include "nsIObserverService.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch2.h"
 #include "nsIJSContextStack.h"
 #include "mozilla/Services.h"
+#include "mozilla/unused.h"
 
 #include <math.h>
 
 #ifdef WINCE_WINDOWS_MOBILE
 #include "WinMobileLocationProvider.h"
 #endif
 
 #ifdef MOZ_MAEMO_LIBLOCATION
@@ -89,16 +90,18 @@
 
 #include "nsIDOMDocument.h"
 #include "nsIDocument.h"
 
 // Some limit to the number of get or watch geolocation requests
 // that a window can make.
 #define MAX_GEO_REQUESTS_PER_WINDOW  1500
 
+using mozilla::unused;          // <snicker>
+
 ////////////////////////////////////////////////////
 // nsDOMGeoPositionError
 ////////////////////////////////////////////////////
 
 class nsDOMGeoPositionError : public nsIDOMGeoPositionError
 {
 public:
   NS_DECL_ISUPPORTS
@@ -1103,25 +1106,25 @@ nsGeolocationRequestProxy::GetRequesting
   NS_ADDREF(*aRequestingElement = mParent->mElement);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsGeolocationRequestProxy::Cancel()
 {
   NS_ASSERTION(mParent, "No parent for request");
-  (void) mozilla::dom::GeolocationRequestParent::Send__delete__(mParent, false);
+  unused << mozilla::dom::GeolocationRequestParent::Send__delete__(mParent, false);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsGeolocationRequestProxy::Allow()
 {
   NS_ASSERTION(mParent, "No parent for request");
-  (void) mozilla::dom::GeolocationRequestParent::Send__delete__(mParent, true);
+  unused << mozilla::dom::GeolocationRequestParent::Send__delete__(mParent, true);
   return NS_OK;
 }
 
 namespace mozilla {
 namespace dom {
 
 GeolocationRequestParent::GeolocationRequestParent(nsIDOMElement *element, const IPC::URI& uri)
 {
--- a/extensions/cookie/nsPermissionManager.cpp
+++ b/extensions/cookie/nsPermissionManager.cpp
@@ -33,17 +33,17 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifdef MOZ_IPC
-#include "mozilla/dom/ContentProcessChild.h"
+#include "mozilla/dom/ContentChild.h"
 #endif
 #include "nsPermissionManager.h"
 #include "nsPermission.h"
 #include "nsCRT.h"
 #include "nsNetUtil.h"
 #include "nsCOMArray.h"
 #include "nsArrayEnumerator.h"
 #include "nsTArray.h"
@@ -55,32 +55,33 @@
 #include "mozIStorageService.h"
 #include "mozIStorageStatement.h"
 #include "mozIStorageConnection.h"
 #include "mozStorageHelper.h"
 #include "mozStorageCID.h"
 #include "nsXULAppAPI.h"
 
 #ifdef MOZ_IPC
+using mozilla::dom::ContentChild;
+
 static PRBool
 IsChildProcess()
 {
   return XRE_GetProcessType() == GeckoProcessType_Content;
 }
 
 /**
  * @returns The child process object, or if we are not in the child
  *          process, nsnull.
  */
-static mozilla::dom::ContentProcessChild*
+static ContentChild*
 ChildProcess()
 {
   if (IsChildProcess()) {
-    mozilla::dom::ContentProcessChild* cpc =
-      mozilla::dom::ContentProcessChild::GetSingleton();
+    ContentChild* cpc = ContentChild::GetSingleton();
     if (!cpc)
       NS_RUNTIMEABORT("Content Process is NULL!");
     return cpc;
   }
 
   return nsnull;
 }
 #endif
@@ -586,32 +587,32 @@ nsPermissionManager::RemoveAllInternal()
 }
 
 NS_IMETHODIMP
 nsPermissionManager::TestExactPermission(nsIURI     *aURI,
                                          const char *aType,
                                          PRUint32   *aPermission)
 {
 #ifdef MOZ_IPC
-  mozilla::dom::ContentProcessChild* cpc = ChildProcess();
+  ContentChild* cpc = ChildProcess();
   if (cpc) {
     return cpc->SendTestPermission(IPC::URI(aURI), nsDependentCString(aType), PR_TRUE,
       aPermission) ? NS_OK : NS_ERROR_FAILURE;
   }
 #endif
   return CommonTestPermission(aURI, aType, aPermission, PR_TRUE);
 }
 
 NS_IMETHODIMP
 nsPermissionManager::TestPermission(nsIURI     *aURI,
                                     const char *aType,
                                     PRUint32   *aPermission)
 {
 #ifdef MOZ_IPC
-  mozilla::dom::ContentProcessChild* cpc = ChildProcess();
+  ContentChild* cpc = ChildProcess();
   if (cpc) {
     return cpc->SendTestPermission(IPC::URI(aURI), nsDependentCString(aType), PR_FALSE,
       aPermission) ? NS_OK : NS_ERROR_FAILURE;
   }
 #endif
   return CommonTestPermission(aURI, aType, aPermission, PR_FALSE);
 }
 
--- a/ipc/testshell/PTestShell.ipdl
+++ b/ipc/testshell/PTestShell.ipdl
@@ -30,26 +30,26 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PContentProcess;
+include protocol PContent;
 include protocol PTestShellCommand;
 include protocol PContextWrapper;
 
 namespace mozilla {
 namespace ipc {
 
 rpc protocol PTestShell
 {
-  manager PContentProcess;
+  manager PContent;
 
   manages PTestShellCommand;
   manages PContextWrapper;
 
 child:
   __delete__();
 
   ExecuteCommand(nsString aCommand);
--- a/ipc/testshell/TestShellParent.cpp
+++ b/ipc/testshell/TestShellParent.cpp
@@ -30,25 +30,25 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "TestShellParent.h"
-#include "mozilla/dom/ContentProcessParent.h"
+#include "mozilla/dom/ContentParent.h"
 #include "mozilla/jsipc/ContextWrapperParent.h"
 
 #include "nsAutoPtr.h"
 
 using mozilla::ipc::TestShellParent;
 using mozilla::ipc::TestShellCommandParent;
 using mozilla::ipc::PTestShellCommandParent;
-using mozilla::dom::ContentProcessParent;
+using mozilla::dom::ContentParent;
 using mozilla::jsipc::PContextWrapperParent;
 using mozilla::jsipc::ContextWrapperParent;
 
 PTestShellCommandParent*
 TestShellParent::AllocPTestShellCommand(const nsString& aCommand)
 {
   return new TestShellCommandParent();
 }
@@ -69,18 +69,17 @@ TestShellParent::CommandDone(TestShellCo
   command->ReleaseCallback();
 
   return true;
 }
 
 PContextWrapperParent*
 TestShellParent::AllocPContextWrapper()
 {
-    ContentProcessParent* cpp =
-        static_cast<ContentProcessParent*>(Manager());
+    ContentParent* cpp = static_cast<ContentParent*>(Manager());
     return new ContextWrapperParent(cpp);
 }
 
 bool
 TestShellParent::DeallocPContextWrapper(PContextWrapperParent* actor)
 {
     delete actor;
     return true;
--- a/js/ipc/ContextWrapperParent.h
+++ b/js/ipc/ContextWrapperParent.h
@@ -40,55 +40,55 @@
 
 #ifndef mozilla_jsipc_ContextWrapperParent_h__
 #define mozilla_jsipc_ContextWrapperParent_h__
 
 #include "mozilla/jsipc/PContextWrapperParent.h"
 #include "mozilla/jsipc/ObjectWrapperParent.h"
 #include "mozilla/jsipc/CPOWTypes.h"
 
-#include "mozilla/dom/ContentProcessParent.h"
+#include "mozilla/dom/ContentParent.h"
 
 #include "jsapi.h"
 #include "nsAutoJSValHolder.h"
 
 namespace mozilla {
 namespace jsipc {
 
-using mozilla::dom::ContentProcessParent;
+using mozilla::dom::ContentParent;
     
 class ContextWrapperParent
     : public PContextWrapperParent
 {
 public:
 
-    ContextWrapperParent(ContentProcessParent* cpp)
-        : mContentProcess(cpp)
+    ContextWrapperParent(ContentParent* cpp)
+        : mContent(cpp)
         , mGlobal(NULL)
     {}
 
     JSBool GetGlobalJSObject(JSContext* cx, JSObject** globalp) {
         if (!mGlobal)
             return JS_FALSE;
         mGlobalHolder.Hold(cx);
         mGlobalHolder = *globalp = mGlobal->GetJSObject(cx);
         return JS_TRUE;
     }
 
     ObjectWrapperParent* GetGlobalObjectWrapper() const {
         return mGlobal;
     }
 
     bool RequestRunToCompletion() {
-        return mContentProcess->RequestRunToCompletion();
+        return mContent->RequestRunToCompletion();
     }
 
 private:
 
-    ContentProcessParent* mContentProcess;
+    ContentParent* mContent;
     ObjectWrapperParent* mGlobal;
     nsAutoJSValHolder mGlobalHolder;
 
     PObjectWrapperParent* AllocPObjectWrapper(const bool&) {
         return new ObjectWrapperParent();
     }
 
     bool RecvPObjectWrapperConstructor(PObjectWrapperParent* actor,
--- a/js/ipc/ObjectWrapperChild.cpp
+++ b/js/ipc/ObjectWrapperChild.cpp
@@ -496,17 +496,17 @@ ObjectWrapperChild::AnswerNewEnumerateNe
         return false;
 
     nsTArray<nsString>* strIds =
         static_cast<nsTArray<nsString>*>(JS_GetPrivate(cx, state));
 
     if (!strIds || !JS_GetReservedSlot(cx, state, sNextIdIndexSlot, &v))
         return false;
 
-    jsint i = JSVAL_TO_INT(v);
+    jsuint i = JSVAL_TO_INT(v);
     NS_ASSERTION(i >= 0, "Index of next jsid negative?");
     NS_ASSERTION(i <= strIds->Length(), "Index of next jsid too large?");
 
     if (jsuint(i) == strIds->Length()) {
         *status = JS_TRUE;
         return JSObject_to_JSVariant(cx, NULL, statep);
     }
 
--- a/js/ipc/ObjectWrapperParent.cpp
+++ b/js/ipc/ObjectWrapperParent.cpp
@@ -36,16 +36,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "mozilla/jsipc/ObjectWrapperParent.h"
 #include "mozilla/jsipc/ContextWrapperParent.h"
 #include "mozilla/jsipc/CPOWTypes.h"
+#include "mozilla/unused.h"
 
 #include "jsobj.h"
 #include "jsfun.h"
 #include "jsutil.h"
 
 using namespace mozilla::jsipc;
 
 namespace {
@@ -635,17 +636,17 @@ ObjectWrapperParent::CPOW_Convert(JSCont
 /*static*/ void
 ObjectWrapperParent::CPOW_Finalize(JSContext* cx, JSObject* obj)
 {
     CPOW_LOG(("Calling CPOW_Finalize..."));
     
     ObjectWrapperParent* self = Unwrap(cx, obj);
     if (self) {
         self->mObj = NULL;
-        ObjectWrapperParent::Send__delete__(self);
+        unused << ObjectWrapperParent::Send__delete__(self);
     }
 }
 
 /*static*/ JSBool
 ObjectWrapperParent::CPOW_Call(JSContext* cx, JSObject* obj, uintN argc,
                                jsval* argv, jsval* rval)
 {
     CPOW_LOG(("Calling CPOW_Call..."));
--- a/modules/libpref/src/nsPrefBranch.cpp
+++ b/modules/libpref/src/nsPrefBranch.cpp
@@ -34,17 +34,17 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifdef MOZ_IPC
-#include "mozilla/dom/ContentProcessChild.h"
+#include "mozilla/dom/ContentChild.h"
 #include "nsXULAppAPI.h"
 #endif
 
 #include "nsPrefBranch.h"
 #include "nsILocalFile.h"
 #include "nsIObserverService.h"
 #include "nsXPCOM.h"
 #include "nsISupportsPrimitives.h"
@@ -81,23 +81,23 @@ struct PrefCallbackData {
 // Prototypes
 static PLDHashOperator
   pref_enumChild(PLDHashTable *table, PLDHashEntryHdr *heh,
                  PRUint32 i, void *arg);
 static nsresult
   NotifyObserver(const char *newpref, void *data);
 
 #ifdef MOZ_IPC
-using mozilla::dom::ContentProcessChild;
+using mozilla::dom::ContentChild;
 
-static ContentProcessChild*
-GetContentProcessChild()
+static ContentChild*
+GetContentChild()
 {
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
-    ContentProcessChild* cpc = ContentProcessChild::GetSingleton();
+    ContentChild* cpc = ContentChild::GetSingleton();
     if (!cpc) {
       NS_RUNTIMEABORT("Content Protocol is NULL!  We're going to crash!");
     }
     return cpc;
   }
   return nsnull;
 }
 #endif  // MOZ_IPC
@@ -157,17 +157,17 @@ NS_IMETHODIMP nsPrefBranch::GetRoot(char
   mPrefRoot.Truncate(mPrefRootLength);
   *aRoot = ToNewCString(mPrefRoot);
   return NS_OK;
 }
 
 NS_IMETHODIMP nsPrefBranch::GetPrefType(const char *aPrefName, PRInt32 *_retval)
 {
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     nsresult rv = NS_ERROR_NOT_AVAILABLE;
     PRInt32 retval;
     cpc->SendGetPrefType(nsDependentCString(getPrefName(aPrefName)), &retval, &rv);
     if (NS_SUCCEEDED(rv))
       *_retval = retval;
     return rv;
   }
 #endif
@@ -175,47 +175,47 @@ NS_IMETHODIMP nsPrefBranch::GetPrefType(
   const char *pref = getPrefName(aPrefName);
   *_retval = PREF_GetPrefType(pref);
   return NS_OK;
 }
 
 NS_IMETHODIMP nsPrefBranch::GetBoolPref(const char *aPrefName, PRBool *_retval)
 {
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     nsresult rv = NS_ERROR_NOT_AVAILABLE;
     PRBool retval;
     cpc->SendGetBoolPref(nsDependentCString(getPrefName(aPrefName)), &retval, &rv);
     if (NS_SUCCEEDED(rv))
       *_retval = retval;
     return rv;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_GetBoolPref(pref, _retval, mIsDefault);
 }
 
 NS_IMETHODIMP nsPrefBranch::SetBoolPref(const char *aPrefName, PRInt32 aValue)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot set pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_SetBoolPref(pref, aValue, mIsDefault);
 }
 
 NS_IMETHODIMP nsPrefBranch::GetCharPref(const char *aPrefName, char **_retval)
 {
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     nsresult rv = NS_ERROR_NOT_AVAILABLE;
     nsCAutoString prefValue;
     cpc->SendGetCharPref(nsDependentCString(getPrefName(aPrefName)), 
                          &prefValue, &rv);
     if (NS_SUCCEEDED(rv)) {
       *_retval = strdup(prefValue.get());
     }
     return rv;
@@ -224,47 +224,47 @@ NS_IMETHODIMP nsPrefBranch::GetCharPref(
 
   const char *pref = getPrefName(aPrefName);
   return PREF_CopyCharPref(pref, _retval, mIsDefault);
 }
 
 NS_IMETHODIMP nsPrefBranch::SetCharPref(const char *aPrefName, const char *aValue)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot set pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_SetCharPref(pref, aValue, mIsDefault);
 }
 
 NS_IMETHODIMP nsPrefBranch::GetIntPref(const char *aPrefName, PRInt32 *_retval)
 {
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     nsresult rv = NS_ERROR_NOT_AVAILABLE;
     PRInt32 retval;
     cpc->SendGetIntPref(nsDependentCString(getPrefName(aPrefName)), &retval, &rv);
     if (NS_SUCCEEDED(rv))
       *_retval = retval;
     return rv;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_GetIntPref(pref, _retval, mIsDefault);
 }
 
 NS_IMETHODIMP nsPrefBranch::SetIntPref(const char *aPrefName, PRInt32 aValue)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot set pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_SetIntPref(pref, aValue, mIsDefault);
 }
@@ -275,17 +275,17 @@ NS_IMETHODIMP nsPrefBranch::GetComplexVa
   nsXPIDLCString utf8String;
 
   // we have to do this one first because it's different than all the rest
   if (aType.Equals(NS_GET_IID(nsIPrefLocalizedString))) {
     nsCOMPtr<nsIPrefLocalizedString> theString(do_CreateInstance(NS_PREFLOCALIZEDSTRING_CONTRACTID, &rv));
     if (NS_FAILED(rv)) return rv;
 
 #ifdef MOZ_IPC
-    if (ContentProcessChild* cpc = GetContentProcessChild()) {
+    if (ContentChild* cpc = GetContentChild()) {
       nsAutoString prefValue;
 
       rv = NS_ERROR_NOT_AVAILABLE;
       cpc->SendGetPrefLocalizedString(nsDependentCString(getPrefName(aPrefName)), 
                                       &prefValue, &rv);
       if (NS_FAILED(rv)) return rv;
 
       theString->SetData(prefValue.get());
@@ -362,17 +362,17 @@ NS_IMETHODIMP nsPrefBranch::GetComplexVa
   // if we can't get the pref, there's no point in being here
   rv = GetCharPref(aPrefName, getter_Copies(utf8String));
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   if (aType.Equals(NS_GET_IID(nsILocalFile))) {
 #ifdef MOZ_IPC
-    if (GetContentProcessChild()) {
+    if (GetContentChild()) {
       NS_ERROR("cannot get nsILocalFile pref from content process");
       return NS_ERROR_NOT_AVAILABLE;
     }
 #endif
 
     nsCOMPtr<nsILocalFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
 
     if (NS_SUCCEEDED(rv)) {
@@ -382,17 +382,17 @@ NS_IMETHODIMP nsPrefBranch::GetComplexVa
         return NS_OK;
       }
     }
     return rv;
   }
 
   if (aType.Equals(NS_GET_IID(nsIRelativeFilePref))) {
 #ifdef MOZ_IPC
-    if (GetContentProcessChild()) {
+    if (GetContentChild()) {
       NS_ERROR("cannot get nsIRelativeFilePref from content process");
       return NS_ERROR_NOT_AVAILABLE;
     }
 #endif
 
     nsACString::const_iterator keyBegin, strEnd;
     utf8String.BeginReading(keyBegin);
     utf8String.EndReading(strEnd);    
@@ -441,17 +441,17 @@ NS_IMETHODIMP nsPrefBranch::GetComplexVa
 
   NS_WARNING("nsPrefBranch::GetComplexValue - Unsupported interface type");
   return NS_NOINTERFACE;
 }
 
 NS_IMETHODIMP nsPrefBranch::SetComplexValue(const char *aPrefName, const nsIID & aType, nsISupports *aValue)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot set pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   nsresult   rv = NS_NOINTERFACE;
 
   if (aType.Equals(NS_GET_IID(nsILocalFile))) {
@@ -530,32 +530,32 @@ NS_IMETHODIMP nsPrefBranch::SetComplexVa
 
   NS_WARNING("nsPrefBranch::SetComplexValue - Unsupported interface type");
   return NS_NOINTERFACE;
 }
 
 NS_IMETHODIMP nsPrefBranch::ClearUserPref(const char *aPrefName)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot set pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_ClearUserPref(pref);
 }
 
 NS_IMETHODIMP nsPrefBranch::PrefHasUserValue(const char *aPrefName, PRBool *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
 
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     nsresult rv = NS_ERROR_NOT_AVAILABLE;
     PRBool retval;
     cpc->SendPrefHasUserValue(nsDependentCString(getPrefName(aPrefName)), &retval, &rv);
     if (NS_SUCCEEDED(rv))
       *_retval = retval;
     return rv;
   }
 #endif
@@ -563,32 +563,32 @@ NS_IMETHODIMP nsPrefBranch::PrefHasUserV
   const char *pref = getPrefName(aPrefName);
   *_retval = PREF_HasUserPref(pref);
   return NS_OK;
 }
 
 NS_IMETHODIMP nsPrefBranch::LockPref(const char *aPrefName)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot lock pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_LockPref(pref, PR_TRUE);
 }
 
 NS_IMETHODIMP nsPrefBranch::PrefIsLocked(const char *aPrefName, PRBool *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
 
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     nsresult rv = NS_ERROR_NOT_AVAILABLE;
     PRBool retval;
     cpc->SendPrefIsLocked(nsDependentCString(getPrefName(aPrefName)), &retval, &rv);
     if (NS_SUCCEEDED(rv))
       *_retval = retval;
     return rv;
   }
 #endif
@@ -596,17 +596,17 @@ NS_IMETHODIMP nsPrefBranch::PrefIsLocked
   const char *pref = getPrefName(aPrefName);
   *_retval = PREF_PrefIsLocked(pref);
   return NS_OK;
 }
 
 NS_IMETHODIMP nsPrefBranch::UnlockPref(const char *aPrefName)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot unlock pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   const char *pref = getPrefName(aPrefName);
   return PREF_LockPref(pref, PR_FALSE);
 }
@@ -615,17 +615,17 @@ NS_IMETHODIMP nsPrefBranch::UnlockPref(c
 NS_IMETHODIMP nsPrefBranch::ResetBranch(const char *aStartingAt)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP nsPrefBranch::DeleteBranch(const char *aStartingAt)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     NS_ERROR("cannot set pref from content process");
     return NS_ERROR_NOT_AVAILABLE;
   }
 #endif
 
   const char *pref = getPrefName(aStartingAt);
   return PREF_DeleteBranch(pref);
 }
@@ -641,17 +641,17 @@ NS_IMETHODIMP nsPrefBranch::GetChildList
   NS_ENSURE_ARG_POINTER(aStartingAt);
   NS_ENSURE_ARG_POINTER(aCount);
   NS_ENSURE_ARG_POINTER(aChildArray);
 
   *aChildArray = nsnull;
   *aCount = 0;
 
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     nsresult rv = NS_ERROR_NOT_AVAILABLE;
     cpc->SendGetChildList(nsDependentCString(getPrefName(aStartingAt)),
                           &prefArray, &rv);
     if (NS_FAILED(rv)) return rv;
 
   } else
 #endif
   {
@@ -704,17 +704,17 @@ NS_IMETHODIMP nsPrefBranch::AddObserver(
 {
   PrefCallbackData *pCallback;
   const char *pref;
 
   NS_ENSURE_ARG_POINTER(aDomain);
   NS_ENSURE_ARG_POINTER(aObserver);
 
 #ifdef MOZ_IPC
-  if (ContentProcessChild* cpc = GetContentProcessChild()) {
+  if (ContentChild* cpc = GetContentChild()) {
     return cpc->AddRemotePrefObserver(nsDependentCString(aDomain), mPrefRoot, aObserver, aHoldWeak);
   }
 #endif
 
   if (!mObservers) {
     mObservers = new nsAutoVoidArray();
     if (nsnull == mObservers)
       return NS_ERROR_OUT_OF_MEMORY;
@@ -766,17 +766,17 @@ NS_IMETHODIMP nsPrefBranch::AddObserver(
 NS_IMETHODIMP nsPrefBranch::RemoveObserver(const char *aDomain, nsIObserver *aObserver)
 {
   NS_ENSURE_ARG_POINTER(aDomain);
   NS_ENSURE_ARG_POINTER(aObserver);
 
 #ifdef MOZ_IPC
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     nsresult rv = NS_OK;
-    ContentProcessChild *cpc = ContentProcessChild::GetSingleton();
+    ContentChild *cpc = ContentChild::GetSingleton();
     // In case cpc doesn't exist here, we're silently returning (instead of
     // asserting), because the child process is likely to be null
     // when this is called during xpcom-shutdown.
     if (cpc)
       rv = cpc->RemoveRemotePrefObserver(nsDependentCString(aDomain), 
                                          mPrefRoot, 
                                          aObserver);
     return rv;
@@ -797,17 +797,17 @@ NS_IMETHODIMP nsPrefBranch::Observe(nsIS
     freeObserverList();
   }
   return NS_OK;
 }
 
 static nsresult NotifyObserver(const char *newpref, void *data)
 {
 #ifdef MOZ_IPC
-  if (GetContentProcessChild()) {
+  if (GetContentChild()) {
     // We shouldn't ever get here, since we never register NotifyObserver in the 
     // content process
     NS_NOTREACHED("Remote prefs observation should be done from the \
                   chrome process!");
     return NS_OK;
   }
 #endif
 
--- a/netwerk/ipc/NeckoChild.cpp
+++ b/netwerk/ipc/NeckoChild.cpp
@@ -35,17 +35,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHttp.h"
 #include "mozilla/net/NeckoChild.h"
-#include "mozilla/dom/ContentProcessChild.h"
+#include "mozilla/dom/ContentChild.h"
 #include "mozilla/net/HttpChannelChild.h"
 #include "mozilla/net/CookieServiceChild.h"
 
 namespace mozilla {
 namespace net {
 
 PNeckoChild *gNeckoChild = nsnull;
 
@@ -58,18 +58,18 @@ NeckoChild::~NeckoChild()
 {
 }
 
 void NeckoChild::InitNeckoChild()
 {
   NS_ABORT_IF_FALSE(IsNeckoChild(), "InitNeckoChild called by non-child!");
 
   if (!gNeckoChild) {
-    mozilla::dom::ContentProcessChild * cpc = 
-      mozilla::dom::ContentProcessChild::GetSingleton();
+    mozilla::dom::ContentChild * cpc = 
+      mozilla::dom::ContentChild::GetSingleton();
     NS_ASSERTION(cpc, "Content Protocol is NULL!");
     gNeckoChild = cpc->SendPNeckoConstructor(); 
     NS_ASSERTION(gNeckoChild, "PNecko Protocol init failed!");
   }
 }
 
 // Note: not actually called; has some lifespan as child process, so
 // automatically destroyed at exit.  
@@ -82,17 +82,17 @@ void NeckoChild::DestroyNeckoChild()
   if (!alreadyDestroyed) {
     Send__delete__(gNeckoChild); 
     gNeckoChild = nsnull;
     alreadyDestroyed = true;
   }
 }
 
 PHttpChannelChild* 
-NeckoChild::AllocPHttpChannel(PIFrameEmbeddingChild* iframeEmbedding)
+NeckoChild::AllocPHttpChannel(PBrowserChild* iframeEmbedding)
 {
   // We don't allocate here: see HttpChannelChild::AsyncOpen()
   NS_RUNTIMEABORT("AllocPHttpChannel should not be called");
   return nsnull;
 }
 
 bool 
 NeckoChild::DeallocPHttpChannel(PHttpChannelChild* channel)
--- a/netwerk/ipc/NeckoChild.h
+++ b/netwerk/ipc/NeckoChild.h
@@ -54,17 +54,17 @@ class NeckoChild :
 public:
   NeckoChild();
   virtual ~NeckoChild();
 
   static void InitNeckoChild();
   static void DestroyNeckoChild();
 
 protected:
-  virtual PHttpChannelChild* AllocPHttpChannel(PIFrameEmbeddingChild* iframeEmbedding);
+  virtual PHttpChannelChild* AllocPHttpChannel(PBrowserChild* iframeEmbedding);
   virtual bool DeallocPHttpChannel(PHttpChannelChild*);
   virtual PCookieServiceChild* AllocPCookieService();
   virtual bool DeallocPCookieService(PCookieServiceChild*);
 };
 
 /**
  * Reference to the PNecko Child protocol.
  * Null if this is not a content process.
--- a/netwerk/ipc/NeckoParent.cpp
+++ b/netwerk/ipc/NeckoParent.cpp
@@ -51,17 +51,17 @@ NeckoParent::NeckoParent()
 {
 }
 
 NeckoParent::~NeckoParent()
 {
 }
 
 PHttpChannelParent* 
-NeckoParent::AllocPHttpChannel(PIFrameEmbeddingParent* iframeEmbedding)
+NeckoParent::AllocPHttpChannel(PBrowserParent* iframeEmbedding)
 {
   HttpChannelParent *p = new HttpChannelParent(iframeEmbedding);
   p->AddRef();
   return p;
 }
 
 bool 
 NeckoParent::DeallocPHttpChannel(PHttpChannelParent* channel)
--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -51,17 +51,17 @@ namespace net {
 class NeckoParent :
   public PNeckoParent
 {
 public:
   NeckoParent();
   virtual ~NeckoParent();
 
 protected:
-  virtual PHttpChannelParent* AllocPHttpChannel(PIFrameEmbeddingParent* iframeEmbedding);
+  virtual PHttpChannelParent* AllocPHttpChannel(PBrowserParent* iframeEmbedding);
   virtual bool DeallocPHttpChannel(PHttpChannelParent*);
   virtual PCookieServiceParent* AllocPCookieService();
   virtual bool DeallocPCookieService(PCookieServiceParent*);
 };
 
 } // namespace net
 } // namespace mozilla
 
--- a/netwerk/ipc/PNecko.ipdl
+++ b/netwerk/ipc/PNecko.ipdl
@@ -33,34 +33,34 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-include protocol PContentProcess;
+include protocol PContent;
 include protocol PHttpChannel;
 include protocol PCookieService;
-include protocol PIFrameEmbedding;
+include protocol PBrowser;
 
 namespace mozilla {
 namespace net {
 
 
 //-------------------------------------------------------------------
 sync protocol PNecko
 {
-  manager PContentProcess;
+  manager PContent;
   manages PHttpChannel;
   manages PCookieService;
 
 parent:
   __delete__();
 
-  PHttpChannel(nullable PIFrameEmbedding iframeEmbedding);
+  PHttpChannel(nullable PBrowser iframeEmbedding);
   PCookieService();
 };
 
 
 } // namespace net
 } // namespace mozilla
--- a/netwerk/protocol/http/HttpChannelParent.cpp
+++ b/netwerk/protocol/http/HttpChannelParent.cpp
@@ -48,17 +48,17 @@
 #include "nsIDocShellTreeItem.h"
 #include "nsIBadCertListener2.h"
 #include "nsICacheEntryDescriptor.h"
 
 namespace mozilla {
 namespace net {
 
 // C++ file contents
-HttpChannelParent::HttpChannelParent(PIFrameEmbeddingParent* iframeEmbedding)
+HttpChannelParent::HttpChannelParent(PBrowserParent* iframeEmbedding)
 : mIPCClosed(false)
 {
   // Ensure gHttpHandler is initialized: we need the atom table up and running.
   nsIHttpProtocolHandler* handler;
   CallGetService(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "http", &handler);
   NS_ASSERTION(handler, "no http handler");
 
   mTabParent = do_QueryInterface(static_cast<nsITabParent*>(
--- a/netwerk/protocol/http/HttpChannelParent.h
+++ b/netwerk/protocol/http/HttpChannelParent.h
@@ -37,17 +37,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_net_HttpChannelParent_h
 #define mozilla_net_HttpChannelParent_h
 
 #include "nsHttp.h"
-#include "mozilla/dom/PIFrameEmbeddingParent.h"
+#include "mozilla/dom/PBrowserParent.h"
 #include "mozilla/net/PHttpChannelParent.h"
 #include "mozilla/net/NeckoCommon.h"
 #include "nsIStreamListener.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIProgressEventSink.h"
 #include "nsITabParent.h"
 
 using namespace mozilla::dom;
@@ -65,17 +65,17 @@ class HttpChannelParent : public PHttpCh
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIREQUESTOBSERVER
   NS_DECL_NSISTREAMLISTENER
   NS_DECL_NSIINTERFACEREQUESTOR
   NS_DECL_NSIPROGRESSEVENTSINK
 
-  HttpChannelParent(PIFrameEmbeddingParent* iframeEmbedding);
+  HttpChannelParent(PBrowserParent* iframeEmbedding);
   virtual ~HttpChannelParent();
 
 protected:
   virtual bool RecvAsyncOpen(const IPC::URI&            uri,
                              const IPC::URI&            originalUri,
                              const IPC::URI&            docUri,
                              const IPC::URI&            referrerUri,
                              const PRUint32&            loadFlags,
--- a/toolkit/xre/nsEmbedFunctions.cpp
+++ b/toolkit/xre/nsEmbedFunctions.cpp
@@ -85,19 +85,19 @@
 #include "mozilla/ipc/BrowserProcessSubThread.h"
 #include "mozilla/ipc/GeckoChildProcessHost.h"
 #include "mozilla/ipc/IOThreadChild.h"
 #include "mozilla/ipc/ProcessChild.h"
 #include "ScopedXREEmbed.h"
 
 #include "mozilla/jetpack/JetpackProcessChild.h"
 #include "mozilla/plugins/PluginProcessChild.h"
-#include "mozilla/dom/ContentProcessProcess.h"
-#include "mozilla/dom/ContentProcessParent.h"
-#include "mozilla/dom/ContentProcessChild.h"
+#include "mozilla/dom/ContentProcess.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ContentChild.h"
 
 #include "mozilla/jsipc/ContextWrapperParent.h"
 
 #include "mozilla/ipc/TestShellParent.h"
 #include "mozilla/ipc/XPCShellEnvironment.h"
 
 #ifdef MOZ_IPDL_TESTS
 #include "mozilla/_ipdltest/IPDLUnitTests.h"
@@ -109,19 +109,19 @@ using mozilla::_ipdltest::IPDLUnitTestPr
 using mozilla::ipc::BrowserProcessSubThread;
 using mozilla::ipc::GeckoChildProcessHost;
 using mozilla::ipc::IOThreadChild;
 using mozilla::ipc::ProcessChild;
 using mozilla::ipc::ScopedXREEmbed;
 
 using mozilla::jetpack::JetpackProcessChild;
 using mozilla::plugins::PluginProcessChild;
-using mozilla::dom::ContentProcessProcess;
-using mozilla::dom::ContentProcessParent;
-using mozilla::dom::ContentProcessChild;
+using mozilla::dom::ContentProcess;
+using mozilla::dom::ContentParent;
+using mozilla::dom::ContentChild;
 
 using mozilla::jsipc::PContextWrapperParent;
 using mozilla::jsipc::ContextWrapperParent;
 
 using mozilla::ipc::TestShellParent;
 using mozilla::ipc::TestShellCommandParent;
 using mozilla::ipc::XPCShellEnvironment;
 
@@ -394,17 +394,17 @@ XRE_InitChildProcess(int aArgc,
       NS_RUNTIMEABORT("This makes no sense");
       break;
 
     case GeckoProcessType_Plugin:
       process = new PluginProcessChild(parentHandle);
       break;
 
     case GeckoProcessType_Content:
-      process = new ContentProcessProcess(parentHandle);
+      process = new ContentProcess(parentHandle);
       break;
 
     case GeckoProcessType_Jetpack:
       process = new JetpackProcessChild(parentHandle);
       break;
 
     case GeckoProcessType_IPDLUnitTest:
 #ifdef MOZ_IPDL_TESTS
@@ -542,20 +542,20 @@ XRE_RunAppShell()
 {
     nsCOMPtr<nsIAppShell> appShell(do_GetService(kAppShellCID));
     NS_ENSURE_TRUE(appShell, NS_ERROR_FAILURE);
 
     return appShell->Run();
 }
 
 template<>
-struct RunnableMethodTraits<ContentProcessChild>
+struct RunnableMethodTraits<ContentChild>
 {
-    static void RetainCallee(ContentProcessChild* obj) { }
-    static void ReleaseCallee(ContentProcessChild* obj) { }
+    static void RetainCallee(ContentChild* obj) { }
+    static void ReleaseCallee(ContentChild* obj) { }
 };
 
 void
 XRE_ShutdownChildProcess()
 {
   NS_ABORT_IF_FALSE(MessageLoopForUI::current(), "Wrong thread!");
 
   MessageLoop* ioLoop = XRE_GetIOMessageLoop();
@@ -570,17 +570,17 @@ XRE_ShutdownChildProcess()
   MessageLoop::current()->Quit(); 
 }
 
 namespace {
 TestShellParent* gTestShellParent = nsnull;
 TestShellParent* GetOrCreateTestShellParent()
 {
     if (!gTestShellParent) {
-        ContentProcessParent* parent = ContentProcessParent::GetSingleton();
+        ContentParent* parent = ContentParent::GetSingleton();
         NS_ENSURE_TRUE(parent, nsnull);
         gTestShellParent = parent->CreateTestShell();
         NS_ENSURE_TRUE(gTestShellParent, nsnull);
     }
     return gTestShellParent;
 }
 }
 
@@ -615,17 +615,17 @@ XRE_GetChildGlobalObject(JSContext* aCx,
     return tsp && tsp->GetGlobalJSObject(aCx, aGlobalP);
 }
 
 bool
 XRE_ShutdownTestShell()
 {
   if (!gTestShellParent)
     return true;
-  return ContentProcessParent::GetSingleton()->DestroyTestShell(gTestShellParent);
+  return ContentParent::GetSingleton()->DestroyTestShell(gTestShellParent);
 }
 
 #ifdef MOZ_X11
 void
 XRE_InstallX11ErrorHandler()
 {
   InstallX11ErrorHandler();
 }