--- a/dom/ipc/ContentProcessChild.cpp
+++ b/dom/ipc/ContentProcessChild.cpp
@@ -68,47 +68,47 @@ ContentProcessChild::Init(MessageLoop* a
NS_ASSERTION(!sSingleton, "only one ContentProcessChild per child");
Open(aChannel, aIOLoop);
sSingleton = this;
return true;
}
-PIFrameEmbeddingProtocolChild*
+PIFrameEmbeddingChild*
ContentProcessChild::PIFrameEmbeddingConstructor(const MagicWindowHandle& hwnd)
{
- PIFrameEmbeddingProtocolChild* iframe = new TabChild(hwnd);
+ PIFrameEmbeddingChild* iframe = new TabChild(hwnd);
if (iframe && mIFrames.AppendElement(iframe)) {
return iframe;
}
delete iframe;
return nsnull;
}
nsresult
-ContentProcessChild::PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolChild* iframe)
+ContentProcessChild::PIFrameEmbeddingDestructor(PIFrameEmbeddingChild* iframe)
{
mIFrames.RemoveElement(iframe);
return NS_OK;
}
-PTestShellProtocolChild*
+PTestShellChild*
ContentProcessChild::PTestShellConstructor()
{
- PTestShellProtocolChild* testshell = new TestShellChild();
+ PTestShellChild* testshell = new TestShellChild();
if (testshell && mTestShells.AppendElement(testshell)) {
return testshell;
}
delete testshell;
return nsnull;
}
nsresult
-ContentProcessChild::PTestShellDestructor(PTestShellProtocolChild* shell)
+ContentProcessChild::PTestShellDestructor(PTestShellChild* shell)
{
mTestShells.RemoveElement(shell);
return NS_OK;
}
void
ContentProcessChild::Quit()
{
--- a/dom/ipc/ContentProcessChild.h
+++ b/dom/ipc/ContentProcessChild.h
@@ -34,52 +34,51 @@
* 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
-#include "mozilla/dom/PContentProcessProtocolChild.h"
+#include "mozilla/dom/PContentProcessChild.h"
#include "nsTArray.h"
#include "nsAutoPtr.h"
namespace mozilla {
namespace dom {
-class ContentProcessChild
- : public PContentProcessProtocolChild
+class ContentProcessChild : public PContentProcessChild
{
public:
ContentProcessChild();
virtual ~ContentProcessChild();
bool Init(MessageLoop* aIOLoop, IPC::Channel* aChannel);
static ContentProcessChild* GetSingleton() {
NS_ASSERTION(sSingleton, "not initialized");
return sSingleton;
}
- virtual PIFrameEmbeddingProtocolChild* PIFrameEmbeddingConstructor(const MagicWindowHandle& hwnd);
- virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolChild*);
+ virtual PIFrameEmbeddingChild* PIFrameEmbeddingConstructor(const MagicWindowHandle& hwnd);
+ virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingChild*);
- virtual PTestShellProtocolChild* PTestShellConstructor();
- virtual nsresult PTestShellDestructor(PTestShellProtocolChild*);
+ virtual PTestShellChild* PTestShellConstructor();
+ virtual nsresult PTestShellDestructor(PTestShellChild*);
void Quit();
virtual nsresult RecvQuit();
private:
static ContentProcessChild* sSingleton;
- nsTArray<nsAutoPtr<PIFrameEmbeddingProtocolChild> > mIFrames;
- nsTArray<nsAutoPtr<PTestShellProtocolChild> > mTestShells;
+ nsTArray<nsAutoPtr<PIFrameEmbeddingChild> > mIFrames;
+ nsTArray<nsAutoPtr<PTestShellChild> > mTestShells;
PRBool mQuit;
DISALLOW_EVIL_CONSTRUCTORS(ContentProcessChild);
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/ContentProcessParent.cpp
+++ b/dom/ipc/ContentProcessParent.cpp
@@ -135,36 +135,36 @@ ContentProcessParent::OnWaitableEventSig
{
// The child process has died! Sadly we're on the wrong thread to do much.
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
MonitorAutoEnter mon(mMonitor);
mSubprocess = nsnull;
mon.Notify();
}
-PIFrameEmbeddingProtocolParent*
+PIFrameEmbeddingParent*
ContentProcessParent::PIFrameEmbeddingConstructor(const MagicWindowHandle& parentWidget)
{
return new TabParent();
}
nsresult
-ContentProcessParent::PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolParent* frame)
+ContentProcessParent::PIFrameEmbeddingDestructor(PIFrameEmbeddingParent* frame)
{
delete frame;
return NS_OK;
}
-PTestShellProtocolParent*
+PTestShellParent*
ContentProcessParent::PTestShellConstructor()
{
return new TestShellParent();
}
nsresult
-ContentProcessParent::PTestShellDestructor(PTestShellProtocolParent* shell)
+ContentProcessParent::PTestShellDestructor(PTestShellParent* shell)
{
delete shell;
return NS_OK;
}
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/ContentProcessParent.h
+++ b/dom/ipc/ContentProcessParent.h
@@ -36,36 +36,35 @@
*
* ***** END LICENSE BLOCK ***** */
#ifndef mozilla_dom_ContentProcessParent_h
#define mozilla_dom_ContentProcessParent_h
#include "base/waitable_event_watcher.h"
-#include "mozilla/dom/PContentProcessProtocolParent.h"
+#include "mozilla/dom/PContentProcessParent.h"
#include "mozilla/ipc/GeckoChildProcessHost.h"
#include "nsIObserver.h"
#include "mozilla/Monitor.h"
namespace mozilla {
namespace ipc {
class TestShellParent;
}
namespace dom {
class TabParent;
-class ContentProcessParent
- : private PContentProcessProtocolParent,
- public base::WaitableEventWatcher::Delegate,
- public nsIObserver
+class ContentProcessParent : private PContentProcessParent,
+ public base::WaitableEventWatcher::Delegate,
+ public nsIObserver
{
private:
typedef mozilla::ipc::GeckoChildProcessHost GeckoChildProcessHost;
public:
static ContentProcessParent* GetSingleton();
#if 0
@@ -81,27 +80,27 @@ public:
TabParent* CreateTab(const MagicWindowHandle& hwnd);
mozilla::ipc::TestShellParent* CreateTestShell();
private:
static ContentProcessParent* gSingleton;
// Hide the raw constructor methods since we don't want client code
// using them.
- using PContentProcessProtocolParent::SendPIFrameEmbeddingConstructor;
- using PContentProcessProtocolParent::SendPTestShellConstructor;
+ using PContentProcessParent::SendPIFrameEmbeddingConstructor;
+ using PContentProcessParent::SendPTestShellConstructor;
ContentProcessParent();
virtual ~ContentProcessParent();
- virtual PIFrameEmbeddingProtocolParent* PIFrameEmbeddingConstructor(const MagicWindowHandle& parentWidget);
- virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingProtocolParent* frame);
+ virtual PIFrameEmbeddingParent* PIFrameEmbeddingConstructor(const MagicWindowHandle& parentWidget);
+ virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingParent* frame);
- virtual PTestShellProtocolParent* PTestShellConstructor();
- virtual nsresult PTestShellDestructor(PTestShellProtocolParent* shell);
+ virtual PTestShellParent* PTestShellConstructor();
+ virtual nsresult PTestShellDestructor(PTestShellParent* shell);
mozilla::Monitor mMonitor;
GeckoChildProcessHost* mSubprocess;
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -33,25 +33,24 @@
* 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_TabChild_h
#define mozilla_tabs_TabChild_h
-#include "mozilla/dom/PIFrameEmbeddingProtocolChild.h"
+#include "mozilla/dom/PIFrameEmbeddingChild.h"
#include "nsIWebNavigation.h"
#include "nsCOMPtr.h"
namespace mozilla {
namespace dom {
-class TabChild
- : public PIFrameEmbeddingProtocolChild
+class TabChild : public PIFrameEmbeddingChild
{
public:
TabChild(const MagicWindowHandle& parentWidget);
virtual ~TabChild();
virtual nsresult RecvloadURL(const nsCString& uri);
virtual nsresult Recvmove(const PRUint32& x,
const PRUint32& y,
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -34,27 +34,26 @@
* 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/PIFrameEmbeddingProtocolParent.h"
+#include "mozilla/dom/PIFrameEmbeddingParent.h"
#include "mozilla/ipc/GeckoChildProcessHost.h"
class nsIURI;
namespace mozilla {
namespace dom {
-class TabParent
- : public PIFrameEmbeddingProtocolParent
+class TabParent : public PIFrameEmbeddingParent
{
public:
TabParent();
virtual ~TabParent();
void LoadURL(nsIURI* aURI);
void Move(PRUint32 x, PRUint32 y, PRUint32 width, PRUint32 height);
};
--- a/dom/plugins/BrowserStreamChild.h
+++ b/dom/plugins/BrowserStreamChild.h
@@ -33,24 +33,24 @@
* 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_plugins_BrowserStreamChild_h
#define mozilla_plugins_BrowserStreamChild_h 1
-#include "mozilla/plugins/PBrowserStreamProtocolChild.h"
+#include "mozilla/plugins/PBrowserStreamChild.h"
namespace mozilla {
namespace plugins {
class PluginInstanceChild;
-class BrowserStreamChild : public PBrowserStreamProtocolChild
+class BrowserStreamChild : public PBrowserStreamChild
{
public:
BrowserStreamChild(PluginInstanceChild* instance,
const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const nsCString& headers,
const nsCString& mimeType,
--- a/dom/plugins/BrowserStreamParent.h
+++ b/dom/plugins/BrowserStreamParent.h
@@ -1,21 +1,21 @@
/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
#ifndef mozilla_plugins_BrowserStreamParent_h
#define mozilla_plugins_BrowserStreamParent_h
-#include "mozilla/plugins/PBrowserStreamProtocolParent.h"
+#include "mozilla/plugins/PBrowserStreamParent.h"
namespace mozilla {
namespace plugins {
class PluginInstanceParent;
-class BrowserStreamParent : public PBrowserStreamProtocolParent
+class BrowserStreamParent : public PBrowserStreamParent
{
friend class PluginModuleParent;
friend class PluginInstanceParent;
public:
BrowserStreamParent(PluginInstanceParent* npp,
NPStream* stream);
virtual ~BrowserStreamParent() { }
--- a/dom/plugins/PluginInstanceChild.cpp
+++ b/dom/plugins/PluginInstanceChild.cpp
@@ -357,47 +357,47 @@ PluginInstanceChild::PluginWindowProc(HW
if (message == WM_NCDESTROY)
RemoveProp(hWnd, kPluginInstanceChildProperty);
return res;
}
#endif // OS_WIN
-PPluginScriptableObjectProtocolChild*
+PPluginScriptableObjectChild*
PluginInstanceChild::PPluginScriptableObjectConstructor(NPError* _retval)
{
NS_NOTYETIMPLEMENTED("PluginInstanceChild::NPObjectConstructor");
return nsnull;
}
nsresult
-PluginInstanceChild::PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolChild* aObject,
+PluginInstanceChild::PPluginScriptableObjectDestructor(PPluginScriptableObjectChild* aObject,
NPError* _retval)
{
NS_NOTYETIMPLEMENTED("PluginInstanceChild::NPObjectDestructor");
return NS_ERROR_NOT_IMPLEMENTED;
}
-PBrowserStreamProtocolChild*
+PBrowserStreamChild*
PluginInstanceChild::PBrowserStreamConstructor(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const nsCString& headers,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t *stype)
{
return new BrowserStreamChild(this, url, length, lastmodified, headers,
mimeType, seekable, rv, stype);
}
nsresult
-PluginInstanceChild::PBrowserStreamDestructor(PBrowserStreamProtocolChild* stream,
+PluginInstanceChild::PBrowserStreamDestructor(PBrowserStreamChild* stream,
const NPError& reason,
const bool& artificial)
{
delete stream;
return NS_OK;
}
} // namespace plugins
--- a/dom/plugins/PluginInstanceChild.h
+++ b/dom/plugins/PluginInstanceChild.h
@@ -34,65 +34,66 @@
* 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_plugins_PluginInstanceChild_h
#define dom_plugins_PluginInstanceChild_h 1
-#include "mozilla/plugins/PPluginInstanceProtocolChild.h"
+#include "mozilla/plugins/PPluginInstanceChild.h"
#include "mozilla/plugins/PluginScriptableObjectChild.h"
#include "npfunctions.h"
#undef _MOZ_LOG
#define _MOZ_LOG(s) printf("[PluginInstanceChild] %s\n", s)
namespace mozilla {
namespace plugins {
-class PBrowserStreamProtocolChild;
+class PBrowserStreamChild;
+class BrowserStreamChild;
-class PluginInstanceChild : public PPluginInstanceProtocolChild
+class PluginInstanceChild : public PPluginInstanceChild
{
#ifdef OS_WIN
friend LRESULT CALLBACK PluginWindowProc(HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam);
#endif
protected:
friend class BrowserStreamChild;
virtual nsresult AnswerNPP_SetWindow(const NPWindow& window, NPError* rv);
virtual nsresult AnswerNPP_GetValue(const nsString& key, nsString* value);
- virtual PPluginScriptableObjectProtocolChild*
+ virtual PPluginScriptableObjectChild*
PPluginScriptableObjectConstructor(NPError* _retval);
virtual nsresult
- PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolChild* aObject,
+ PPluginScriptableObjectDestructor(PPluginScriptableObjectChild* aObject,
NPError* _retval);
- virtual PBrowserStreamProtocolChild*
+ virtual PBrowserStreamChild*
PBrowserStreamConstructor(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const nsCString& headers,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t *stype);
virtual nsresult
- PBrowserStreamDestructor(PBrowserStreamProtocolChild* stream,
+ PBrowserStreamDestructor(PBrowserStreamChild* stream,
const NPError& reason,
const bool& artificial);
public:
PluginInstanceChild(const NPPluginFuncs* aPluginIface) :
mPluginIface(aPluginIface)
#if defined(OS_LINUX)
, mPlug(0)
--- a/dom/plugins/PluginInstanceParent.cpp
+++ b/dom/plugins/PluginInstanceParent.cpp
@@ -37,43 +37,43 @@
* ***** END LICENSE BLOCK ***** */
#include "PluginInstanceParent.h"
#include "BrowserStreamParent.h"
namespace mozilla {
namespace plugins {
-PBrowserStreamProtocolParent*
+PBrowserStreamParent*
PluginInstanceParent::PBrowserStreamConstructor(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const nsCString& headers,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t *stype)
{
NS_RUNTIMEABORT("Not reachable");
return NULL;
}
nsresult
-PluginInstanceParent::AnswerPBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+PluginInstanceParent::AnswerPBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial)
{
if (!artificial) {
static_cast<BrowserStreamParent*>(stream)->NPN_DestroyStream(reason);
}
return NS_OK;
}
nsresult
-PluginInstanceParent::PBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+PluginInstanceParent::PBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial)
{
delete stream;
return NS_OK;
}
NPError
@@ -131,25 +131,25 @@ PluginInstanceParent::NPP_DestroyStream(
BrowserStreamParent* sp =
static_cast<BrowserStreamParent*>(stream->pdata);
if (sp->mNPP != this)
NS_RUNTIMEABORT("Mismatched plugin data");
return CallPBrowserStreamDestructor(sp, reason, false);
}
-PPluginScriptableObjectProtocolParent*
+PPluginScriptableObjectParent*
PluginInstanceParent::PPluginScriptableObjectConstructor(NPError* _retval)
{
NS_NOTYETIMPLEMENTED("PluginInstanceParent::PPluginScriptableObjectConstructor");
return nsnull;
}
nsresult
-PluginInstanceParent::PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolParent* aObject,
+PluginInstanceParent::PPluginScriptableObjectDestructor(PPluginScriptableObjectParent* aObject,
NPError* _retval)
{
NS_NOTYETIMPLEMENTED("PluginInstanceParent::PPluginScriptableObjectDestructor");
return NS_ERROR_NOT_IMPLEMENTED;
}
} // namespace plugins
} // namespace mozilla
--- a/dom/plugins/PluginInstanceParent.h
+++ b/dom/plugins/PluginInstanceParent.h
@@ -34,30 +34,31 @@
* 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_plugins_PluginInstanceParent_h
#define dom_plugins_PluginInstanceParent_h 1
-#include "mozilla/plugins/PPluginInstanceProtocolParent.h"
+#include "mozilla/plugins/PPluginInstanceParent.h"
#include "mozilla/plugins/PluginScriptableObjectParent.h"
#include "npfunctions.h"
#undef _MOZ_LOG
#define _MOZ_LOG(s) printf("[PluginInstanceParent] %s\n", s)
namespace mozilla {
namespace plugins {
+class PBrowserStreamParent;
class BrowserStreamParent;
-class PluginInstanceParent : public PPluginInstanceProtocolParent
+class PluginInstanceParent : public PPluginInstanceParent
{
friend class PluginModuleParent;
friend class BrowserStreamParent;
public:
PluginInstanceParent(NPP npp, const NPNetscapeFuncs* npniface)
: mNPP(npp)
, mNPNIface(npniface)
@@ -68,40 +69,40 @@ public:
{
}
virtual nsresult AnswerNPN_GetValue(const nsString& in, nsString* out)
{
return NS_OK;
}
- virtual PPluginScriptableObjectProtocolParent*
+ virtual PPluginScriptableObjectParent*
PPluginScriptableObjectConstructor(NPError* _retval);
virtual nsresult
- PPluginScriptableObjectDestructor(PPluginScriptableObjectProtocolParent* aObject,
+ PPluginScriptableObjectDestructor(PPluginScriptableObjectParent* aObject,
NPError* _retval);
- virtual PBrowserStreamProtocolParent*
+ virtual PBrowserStreamParent*
PBrowserStreamConstructor(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const nsCString& headers,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t *stype);
virtual nsresult
- AnswerPBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+ AnswerPBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial);
virtual nsresult
- PBrowserStreamDestructor(PBrowserStreamProtocolParent* stream,
+ PBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial);
NPError NPP_SetWindow(NPWindow* aWindow);
NPError NPP_GetValue(NPPVariable variable, void *ret_value);
NPError NPP_SetValue(NPNVariable variable, void *value)
{
--- a/dom/plugins/PluginModuleChild.cpp
+++ b/dom/plugins/PluginModuleChild.cpp
@@ -907,17 +907,17 @@ PluginModuleChild::AnswerNP_Initialize(N
*_retval = mInitializeFunc(&sBrowserFuncs);
return NS_OK;
#else
# error Please implement me for your platform
#endif
}
-PPluginInstanceProtocolChild*
+PPluginInstanceChild*
PluginModuleChild::PPluginInstanceConstructor(const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv)
{
_MOZ_LOG(__FUNCTION__);
@@ -961,17 +961,17 @@ PluginModuleChild::PPluginInstanceConstr
return nsnull;
}
printf ("[PluginModuleChild] %s: returning %hd\n", __FUNCTION__, *rv);
return childInstance.forget();
}
nsresult
-PluginModuleChild::PPluginInstanceDestructor(PPluginInstanceProtocolChild* actor,
+PluginModuleChild::PPluginInstanceDestructor(PPluginInstanceChild* actor,
NPError* rv)
{
_MOZ_LOG(__FUNCTION__);
PluginInstanceChild* inst = static_cast<PluginInstanceChild*>(actor);
*rv = mFunctions.destroy(inst->GetNPP(), 0);
delete actor;
inst->GetNPP()->ndata = 0;
--- a/dom/plugins/PluginModuleChild.h
+++ b/dom/plugins/PluginModuleChild.h
@@ -48,17 +48,17 @@
#include "prlink.h"
#include "npapi.h"
#include "npfunctions.h"
#include "nsplugindefs.h"
#include "nsAutoPtr.h"
-#include "mozilla/plugins/PPluginModuleProtocolChild.h"
+#include "mozilla/plugins/PPluginModuleChild.h"
#include "mozilla/plugins/PluginInstanceChild.h"
// NOTE: stolen from nsNPAPIPlugin.h
/*
* Use this macro before each exported function
* (between the return address and the function
* itself), to ensure that the function has the
@@ -88,31 +88,31 @@ typedef NS_NPAPIPLUGIN_CALLBACK(NPError,
#undef _MOZ_LOG
#define _MOZ_LOG(s) printf("[NPAPIPluginChild] %s\n", s)
namespace mozilla {
namespace plugins {
//-----------------------------------------------------------------------------
-class PluginModuleChild : public PPluginModuleProtocolChild
+class PluginModuleChild : public PPluginModuleChild
{
protected:
- // Implement the PPluginModuleProtocolChild interface
+ // Implement the PPluginModuleChild interface
virtual nsresult AnswerNP_Initialize(NPError* rv);
- virtual PPluginInstanceProtocolChild*
+ virtual PPluginInstanceChild*
PPluginInstanceConstructor(const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv);
virtual nsresult
- PPluginInstanceDestructor(PPluginInstanceProtocolChild* actor,
+ PPluginInstanceDestructor(PPluginInstanceChild* actor,
NPError* rv);
public:
PluginModuleChild();
virtual ~PluginModuleChild();
bool Init(const std::string& aPluginFilename,
MessageLoop* aIOLoop,
--- a/dom/plugins/PluginModuleParent.cpp
+++ b/dom/plugins/PluginModuleParent.cpp
@@ -70,29 +70,29 @@ PluginModuleParent::PluginModuleParent(c
}
PluginModuleParent::~PluginModuleParent()
{
_MOZ_LOG(" (closing Shim ...)");
delete mShim;
}
-PPluginInstanceProtocolParent*
+PPluginInstanceParent*
PluginModuleParent::PPluginInstanceConstructor(const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv)
{
NS_ERROR("Not reachable!");
return NULL;
}
nsresult
-PluginModuleParent::PPluginInstanceDestructor(PPluginInstanceProtocolParent* aActor,
+PluginModuleParent::PPluginInstanceDestructor(PPluginInstanceParent* aActor,
NPError* _retval)
{
_MOZ_LOG(__FUNCTION__);
delete aActor;
return NS_OK;
}
void
--- a/dom/plugins/PluginModuleParent.h
+++ b/dom/plugins/PluginModuleParent.h
@@ -47,17 +47,17 @@
#include "npapi.h"
#include "npfunctions.h"
#include "nsplugindefs.h"
#include "base/string_util.h"
#include "mozilla/SharedLibrary.h"
-#include "mozilla/plugins/PPluginModuleProtocolParent.h"
+#include "mozilla/plugins/PPluginModuleParent.h"
#include "mozilla/plugins/PluginInstanceParent.h"
#include "mozilla/plugins/PluginProcessParent.h"
#include "nsAutoPtr.h"
#undef _MOZ_LOG
#define _MOZ_LOG(s) printf("[PluginModuleParent] %s\n", s)
@@ -71,31 +71,31 @@ namespace plugins {
* This class implements the NPP API from the perspective of the rest
* of Gecko, forwarding NPP calls along to the child process that is
* actually running the plugin.
*
* This class /also/ implements a version of the NPN API, because the
* child process needs to make these calls back into Gecko proper.
* This class is responsible for "actually" making those function calls.
*/
-class PluginModuleParent : public PPluginModuleProtocolParent
+class PluginModuleParent : public PPluginModuleParent
{
private:
typedef mozilla::SharedLibrary SharedLibrary;
protected:
- PPluginInstanceProtocolParent*
+ PPluginInstanceParent*
PPluginInstanceConstructor(const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv);
virtual nsresult
- PPluginInstanceDestructor(PPluginInstanceProtocolParent* aActor,
+ PPluginInstanceDestructor(PPluginInstanceParent* aActor,
NPError* _retval);
public:
PluginModuleParent(const char* aFilePath);
virtual ~PluginModuleParent();
/**
--- a/dom/plugins/PluginScriptableObjectChild.h
+++ b/dom/plugins/PluginScriptableObjectChild.h
@@ -34,22 +34,22 @@
* 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_plugins_PluginScriptableObjectChild_h
#define dom_plugins_PluginScriptableObjectChild_h 1
-#include "mozilla/plugins/PPluginScriptableObjectProtocolChild.h"
+#include "mozilla/plugins/PPluginScriptableObjectChild.h"
namespace mozilla {
namespace plugins {
-class PluginScriptableObjectChild : public PPluginScriptableObjectProtocolChild
+class PluginScriptableObjectChild : public PPluginScriptableObjectChild
{
public:
PluginScriptableObjectChild();
virtual ~PluginScriptableObjectChild();
virtual nsresult
AnswerInvalidate();
--- a/dom/plugins/PluginScriptableObjectParent.h
+++ b/dom/plugins/PluginScriptableObjectParent.h
@@ -34,22 +34,22 @@
* 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_plugins_PluginScriptableObjectParent_h
#define dom_plugins_PluginScriptableObjectParent_h 1
-#include "mozilla/plugins/PPluginScriptableObjectProtocolParent.h"
+#include "mozilla/plugins/PPluginScriptableObjectParent.h"
namespace mozilla {
namespace plugins {
-class PluginScriptableObjectParent : public PPluginScriptableObjectProtocolParent
+class PluginScriptableObjectParent : public PPluginScriptableObjectParent
{
public:
PluginScriptableObjectParent();
virtual ~PluginScriptableObjectParent();
};
} /* namespace plugins */
} /* namespace mozilla */
--- a/ipc/ipdl/ipdl.py
+++ b/ipc/ipdl/ipdl.py
@@ -76,17 +76,17 @@ for f in files:
specstring = fd.read()
fd.close()
ast = ipdl.parse(specstring, filename, includedirs=includedirs)
if ast is None:
print >>sys.stderr, 'Specification could not be parsed.'
sys.exit(1)
- allprotocols.append('%sProtocolMsgStart' % ast.protocol.name)
+ allprotocols.append('%sMsgStart' % ast.protocol.name)
log(2, 'checking types')
if not ipdl.typecheck(ast):
print >>sys.stderr, 'Specification is not well typed.'
sys.exit(1)
if _verbosity > 2:
log(3, ' pretty printed code:')
--- a/ipc/ipdl/ipdl/lower.py
+++ b/ipc/ipdl/ipdl/lower.py
@@ -43,21 +43,21 @@ def _joinProtocolNamespacesName(sep, p,
def _protocolIncludeGuard(p, pname):
return _joinProtocolNamespacesName('_', p, pname) +'_h'
def _protocolHeaderFilename(p, pname):
return _joinProtocolNamespacesName('/', p, pname)+ '.h'
def _protocolHeaderName(pname):
- return pname +'Protocol'
+ return pname
def _actorName(pname, side):
"""|pname| is the protocol name. |side| is 'Parent' or 'Child'."""
- return pname +'Protocol'+ side
+ return pname + side
def _makeForwardDecl(p, side):
clsname = _actorName(p.decl.type.qname.baseid, side)
fd = cxx.ForwardDecl(clsname, cls=1)
if 0 == len(p.namespaces):
return fd
--- a/ipc/test-harness/TestChild.h
+++ b/ipc/test-harness/TestChild.h
@@ -33,24 +33,23 @@
* 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 ipc_test_harness_TestChild_h
#define ipc_test_harness_TestChild_h 1
-#include "mozilla/test/PTestProtocolChild.h"
+#include "mozilla/test/PTestChild.h"
namespace mozilla {
namespace test {
// Header file contents
-class TestChild :
- public PTestProtocolChild
+class TestChild : public PTestChild
{
protected:
#if 1
//-----------------------------------------------------------------------------
// "Hello world" example
virtual nsresult RecvHello();
--- a/ipc/test-harness/TestParent.h
+++ b/ipc/test-harness/TestParent.h
@@ -33,24 +33,23 @@
* 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 ipc_test_harness_TestParent_h
#define ipc_test_harness_TestParent_h 1
-#include "mozilla/test/PTestProtocolParent.h"
+#include "mozilla/test/PTestParent.h"
namespace mozilla {
namespace test {
// Header file contents
-class TestParent :
- public PTestProtocolParent
+class TestParent : public PTestParent
{
protected:
#if 1
//-----------------------------------------------------------------------------
// "Hello world" example
virtual nsresult RecvWorld();
--- a/ipc/testshell/TestShellChild.cpp
+++ b/ipc/testshell/TestShellChild.cpp
@@ -32,17 +32,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 "TestShellChild.h"
using mozilla::ipc::TestShellChild;
-using mozilla::ipc::PTestShellCommandProtocolChild;
+using mozilla::ipc::PTestShellCommandChild;
using mozilla::ipc::XPCShellEnvironment;
TestShellChild::TestShellChild()
: mXPCShell(XPCShellEnvironment::CreateEnvironment())
{
}
nsresult
@@ -51,33 +51,33 @@ TestShellChild::RecvExecuteCommand(const
if (mXPCShell->IsQuitting()) {
NS_WARNING("Commands sent after quit command issued!");
return NS_ERROR_UNEXPECTED;
}
return mXPCShell->EvaluateString(aCommand) ? NS_OK : NS_ERROR_FAILURE;
}
-PTestShellCommandProtocolChild*
+PTestShellCommandChild*
TestShellChild::PTestShellCommandConstructor(const nsString& aCommand)
{
- return new PTestShellCommandProtocolChild();
+ return new PTestShellCommandChild();
}
nsresult
-TestShellChild::PTestShellCommandDestructor(PTestShellCommandProtocolChild* aCommand,
+TestShellChild::PTestShellCommandDestructor(PTestShellCommandChild* aCommand,
const nsString& aResponse)
{
NS_ENSURE_ARG_POINTER(aCommand);
delete aCommand;
return NS_OK;
}
nsresult
-TestShellChild::RecvPTestShellCommandConstructor(PTestShellCommandProtocolChild* aActor,
+TestShellChild::RecvPTestShellCommandConstructor(PTestShellCommandChild* aActor,
const nsString& aCommand)
{
NS_ASSERTION(aActor, "Shouldn't be null!");
if (mXPCShell->IsQuitting()) {
NS_WARNING("Commands sent after quit command issued!");
return NS_ERROR_UNEXPECTED;
}
--- a/ipc/testshell/TestShellChild.h
+++ b/ipc/testshell/TestShellChild.h
@@ -32,44 +32,44 @@
* 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 ipc_testshell_TestShellChild_h
#define ipc_testshell_TestShellChild_h 1
-#include "mozilla/ipc/PTestShellProtocolChild.h"
-#include "mozilla/ipc/PTestShellCommandProtocolChild.h"
+#include "mozilla/ipc/PTestShellChild.h"
+#include "mozilla/ipc/PTestShellCommandChild.h"
#include "mozilla/ipc/XPCShellEnvironment.h"
#include "nsAutoPtr.h"
namespace mozilla {
namespace ipc {
class XPCShellEnvironment;
-class TestShellChild : public PTestShellProtocolChild
+class TestShellChild : public PTestShellChild
{
public:
TestShellChild();
nsresult
RecvExecuteCommand(const nsString& aCommand);
- PTestShellCommandProtocolChild*
+ PTestShellCommandChild*
PTestShellCommandConstructor(const nsString& aCommand);
nsresult
- RecvPTestShellCommandConstructor(PTestShellCommandProtocolChild* aActor,
+ RecvPTestShellCommandConstructor(PTestShellCommandChild* aActor,
const nsString& aCommand);
nsresult
- PTestShellCommandDestructor(PTestShellCommandProtocolChild* aCommand,
+ PTestShellCommandDestructor(PTestShellCommandChild* aCommand,
const nsString& aResponse);
void SetXPCShell(XPCShellEnvironment* aXPCShell) {
mXPCShell = aXPCShell;
}
private:
nsAutoPtr<XPCShellEnvironment> mXPCShell;
--- a/ipc/testshell/TestShellParent.cpp
+++ b/ipc/testshell/TestShellParent.cpp
@@ -35,35 +35,35 @@
* ***** END LICENSE BLOCK ***** */
#include "TestShellParent.h"
#include "nsAutoPtr.h"
using mozilla::ipc::TestShellParent;
using mozilla::ipc::TestShellCommandParent;
-using mozilla::ipc::PTestShellCommandProtocolParent;
+using mozilla::ipc::PTestShellCommandParent;
-PTestShellCommandProtocolParent*
+PTestShellCommandParent*
TestShellParent::PTestShellCommandConstructor(const nsString& aCommand)
{
return new TestShellCommandParent();
}
nsresult
-TestShellParent::PTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+TestShellParent::PTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse)
{
NS_ENSURE_ARG_POINTER(aActor);
delete aActor;
return NS_OK;
}
nsresult
-TestShellParent::RecvPTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+TestShellParent::RecvPTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse)
{
NS_ENSURE_ARG_POINTER(aActor);
TestShellCommandParent* command =
reinterpret_cast<TestShellCommandParent*>(aActor);
JSBool ok = command->RunCallback(aResponse);
--- a/ipc/testshell/TestShellParent.h
+++ b/ipc/testshell/TestShellParent.h
@@ -32,54 +32,54 @@
* 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 ipc_testshell_TestShellParent_h
#define ipc_testshell_TestShellParent_h 1
-#include "mozilla/ipc/PTestShellProtocolParent.h"
-#include "mozilla/ipc/PTestShellCommandProtocolParent.h"
+#include "mozilla/ipc/PTestShellParent.h"
+#include "mozilla/ipc/PTestShellCommandParent.h"
#include "jsapi.h"
#include "nsAutoJSValHolder.h"
#include "nsStringGlue.h"
namespace mozilla {
namespace ipc {
-class TestShellCommandParent : public PTestShellCommandProtocolParent
+class TestShellCommandParent : public PTestShellCommandParent
{
public:
TestShellCommandParent() : mCx(NULL) { }
JSBool SetCallback(JSContext* aCx,
jsval aCallback);
JSBool RunCallback(const nsString& aResponse);
void ReleaseCallback();
private:
JSContext* mCx;
nsAutoJSValHolder mCallback;
};
-class TestShellParent : public PTestShellProtocolParent
+class TestShellParent : public PTestShellParent
{
public:
- PTestShellCommandProtocolParent*
+ PTestShellCommandParent*
PTestShellCommandConstructor(const nsString& aCommand);
nsresult
- PTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+ PTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse);
nsresult
- RecvPTestShellCommandDestructor(PTestShellCommandProtocolParent* aActor,
+ RecvPTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse);
};
} /* namespace ipc */
} /* namespace mozilla */
#endif /* ipc_testshell_TestShellParent_h */