switch message handler nsresult return types to bool. appears to break test plugin, will be temporary
switch message handler nsresult return types to bool. appears to break test plugin, will be temporary
--- a/dom/ipc/ContentProcessChild.cpp
+++ b/dom/ipc/ContentProcessChild.cpp
@@ -81,75 +81,75 @@ ContentProcessChild::PIFrameEmbeddingCon
PIFrameEmbeddingChild* iframe = new TabChild(hwnd);
if (iframe && mIFrames.AppendElement(iframe)) {
return iframe;
}
delete iframe;
return nsnull;
}
-nsresult
+bool
ContentProcessChild::PIFrameEmbeddingDestructor(PIFrameEmbeddingChild* iframe)
{
mIFrames.RemoveElement(iframe);
- return NS_OK;
+ return true;
}
PTestShellChild*
ContentProcessChild::PTestShellConstructor()
{
PTestShellChild* testshell = new TestShellChild();
if (testshell && mTestShells.AppendElement(testshell)) {
return testshell;
}
delete testshell;
return nsnull;
}
-nsresult
+bool
ContentProcessChild::PTestShellDestructor(PTestShellChild* shell)
{
mTestShells.RemoveElement(shell);
- return NS_OK;
+ return true;
}
PNeckoChild*
ContentProcessChild::PNeckoConstructor()
{
return new NeckoChild();
}
-nsresult
+bool
ContentProcessChild::PNeckoDestructor(PNeckoChild* necko)
{
delete necko;
- return NS_OK;
+ return true;
}
void
ContentProcessChild::Quit()
{
NS_ASSERTION(mQuit, "Exiting uncleanly!");
mIFrames.Clear();
mTestShells.Clear();
}
static void
QuitIOLoop()
{
MessageLoop::current()->Quit();
}
-nsresult
+bool
ContentProcessChild::RecvQuit()
{
mQuit = PR_TRUE;
Quit();
XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
NewRunnableFunction(&QuitIOLoop));
- return NS_OK;
+ return true;
}
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/ContentProcessChild.h
+++ b/dom/ipc/ContentProcessChild.h
@@ -57,26 +57,26 @@ public:
static ContentProcessChild* GetSingleton() {
NS_ASSERTION(sSingleton, "not initialized");
return sSingleton;
}
virtual PIFrameEmbeddingChild* PIFrameEmbeddingConstructor(
const MagicWindowHandle& hwnd);
- virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingChild*);
+ virtual bool PIFrameEmbeddingDestructor(PIFrameEmbeddingChild*);
virtual PTestShellChild* PTestShellConstructor();
- virtual nsresult PTestShellDestructor(PTestShellChild*);
+ virtual bool PTestShellDestructor(PTestShellChild*);
virtual PNeckoChild* PNeckoConstructor();
- virtual nsresult PNeckoDestructor(PNeckoChild*);
+ virtual bool PNeckoDestructor(PNeckoChild*);
void Quit();
- virtual nsresult RecvQuit();
+ virtual bool RecvQuit();
private:
static ContentProcessChild* sSingleton;
nsTArray<nsAutoPtr<PIFrameEmbeddingChild> > mIFrames;
nsTArray<nsAutoPtr<PTestShellChild> > mTestShells;
PRBool mQuit;
--- a/dom/ipc/ContentProcessParent.cpp
+++ b/dom/ipc/ContentProcessParent.cpp
@@ -144,43 +144,43 @@ ContentProcessParent::OnWaitableEventSig
PIFrameEmbeddingParent*
ContentProcessParent::PIFrameEmbeddingConstructor(
const MagicWindowHandle& parentWidget)
{
return new TabParent();
}
-nsresult
+bool
ContentProcessParent::PIFrameEmbeddingDestructor(PIFrameEmbeddingParent* frame)
{
delete frame;
- return NS_OK;
+ return true;
}
PTestShellParent*
ContentProcessParent::PTestShellConstructor()
{
return new TestShellParent();
}
-nsresult
+bool
ContentProcessParent::PTestShellDestructor(PTestShellParent* shell)
{
delete shell;
- return NS_OK;
+ return true;
}
PNeckoParent*
ContentProcessParent::PNeckoConstructor()
{
return new NeckoParent();
}
-nsresult
+bool
ContentProcessParent::PNeckoDestructor(PNeckoParent* necko)
{
delete necko;
- return NS_OK;
+ return true;
}
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/ContentProcessParent.h
+++ b/dom/ipc/ContentProcessParent.h
@@ -88,23 +88,23 @@ private:
using PContentProcessParent::SendPIFrameEmbeddingConstructor;
using PContentProcessParent::SendPTestShellConstructor;
ContentProcessParent();
virtual ~ContentProcessParent();
virtual PIFrameEmbeddingParent* PIFrameEmbeddingConstructor(
const MagicWindowHandle& parentWidget);
- virtual nsresult PIFrameEmbeddingDestructor(PIFrameEmbeddingParent* frame);
+ virtual bool PIFrameEmbeddingDestructor(PIFrameEmbeddingParent* frame);
virtual PTestShellParent* PTestShellConstructor();
- virtual nsresult PTestShellDestructor(PTestShellParent* shell);
+ virtual bool PTestShellDestructor(PTestShellParent* shell);
virtual PNeckoParent* PNeckoConstructor();
- virtual nsresult PNeckoDestructor(PNeckoParent* necko);
+ virtual bool PNeckoDestructor(PNeckoParent* necko);
mozilla::Monitor mMonitor;
GeckoChildProcessHost* mSubprocess;
};
} // namespace dom
} // namespace mozilla
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -86,31 +86,31 @@ TabChild::TabChild(const MagicWindowHand
mWebNav = do_QueryInterface(webBrowser);
}
TabChild::~TabChild()
{
// TODObsmedberg: destroy the window!
}
-nsresult
+bool
TabChild::RecvloadURL(const nsCString& uri)
{
printf("loading %s, %d\n", uri.get(), NS_IsMainThread());
return mWebNav->LoadURI(NS_ConvertUTF8toUTF16(uri).get(),
nsIWebNavigation::LOAD_FLAGS_NONE,
NULL, NULL, NULL);
}
-nsresult
+bool
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 NS_OK;
+ return true;
}
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -47,21 +47,21 @@ namespace mozilla {
namespace dom {
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,
- const PRUint32& width,
- const PRUint32& height);
+ virtual bool RecvloadURL(const nsCString& uri);
+ virtual bool Recvmove(const PRUint32& x,
+ const PRUint32& y,
+ const PRUint32& width,
+ const PRUint32& height);
private:
nsCOMPtr<nsIWebNavigation> mWebNav;
DISALLOW_EVIL_CONSTRUCTORS(TabChild);
};
}
--- a/dom/plugins/BrowserStreamChild.cpp
+++ b/dom/plugins/BrowserStreamChild.cpp
@@ -66,55 +66,55 @@ BrowserStreamChild::BrowserStreamChild(P
*rv = mInstance->mPluginIface->newstream(&mInstance->mData,
const_cast<char*>(mimeType.get()),
&mStream, seekable, stype);
if (*rv != NPERR_NO_ERROR)
mClosed = true;
}
-nsresult
+bool
BrowserStreamChild::AnswerNPP_WriteReady(const int32_t& newlength,
int32_t *size)
{
if (mClosed) {
*size = 0;
- return NS_OK;
+ return true;
}
mStream.end = newlength;
*size = mInstance->mPluginIface->writeready(&mInstance->mData, &mStream);
- return NS_OK;
+ return true;
}
-nsresult
+bool
BrowserStreamChild::AnswerNPP_Write(const int32_t& offset,
const Buffer& data,
int32_t* consumed)
{
if (mClosed) {
*consumed = -1;
- return NS_OK;
+ return true;
}
*consumed = mInstance->mPluginIface->write(&mInstance->mData, &mStream,
offset, data.Length(),
const_cast<char*>(data.get()));
if (*consumed < 0)
mClosed = true;
- return NS_OK;
+ return true;
}
-nsresult
+bool
BrowserStreamChild::AnswerNPP_StreamAsFile(const nsCString& fname)
{
if (mClosed)
- return NS_OK;
+ return true;
mInstance->mPluginIface->asfile(&mInstance->mData, &mStream,
fname.get());
- return NS_OK;
+ return true;
}
} /* namespace plugins */
} /* namespace mozilla */
--- a/dom/plugins/BrowserStreamChild.h
+++ b/dom/plugins/BrowserStreamChild.h
@@ -54,23 +54,23 @@ public:
const uint32_t& lastmodified,
const nsCString& headers,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t* stype);
virtual ~BrowserStreamChild() { }
- virtual nsresult AnswerNPP_WriteReady(const int32_t& newlength,
+ virtual bool AnswerNPP_WriteReady(const int32_t& newlength,
int32_t *size);
- virtual nsresult AnswerNPP_Write(const int32_t& offset,
+ virtual bool AnswerNPP_Write(const int32_t& offset,
const Buffer& data,
int32_t* consumed);
- virtual nsresult AnswerNPP_StreamAsFile(const nsCString& fname);
+ virtual bool AnswerNPP_StreamAsFile(const nsCString& fname);
void EnsureCorrectInstance(PluginInstanceChild* i)
{
if (i != mInstance)
NS_RUNTIMEABORT("Incorrect stream instance");
}
private:
--- a/dom/plugins/BrowserStreamParent.cpp
+++ b/dom/plugins/BrowserStreamParent.cpp
@@ -9,37 +9,37 @@ namespace plugins {
BrowserStreamParent::BrowserStreamParent(PluginInstanceParent* npp,
NPStream* stream)
: mNPP(npp)
, mStream(stream)
{
mStream->pdata = this;
}
-nsresult
+bool
BrowserStreamParent::AnswerNPN_RequestRead(const IPCByteRanges& ranges,
NPError* result)
{
if (!mStream)
- return NS_ERROR_NOT_INITIALIZED;
+ return false;
if (ranges.size() > PR_INT32_MAX) {
// TODO: abort all processing!
return NS_ERROR_INVALID_ARG;
}
nsAutoArrayPtr<NPByteRange> rp(new NPByteRange[ranges.size()]);
for (PRUint32 i = 0; i < ranges.size(); ++i) {
rp[i].offset = ranges[i].offset;
rp[i].length = ranges[i].length;
rp[i].next = &rp[i + 1];
}
rp[ranges.size()].next = NULL;
- return mNPP->mNPNIface->requestread(mStream, rp);
+ return NPERR_NO_ERROR == mNPP->mNPNIface->requestread(mStream, rp);
}
int32_t
BrowserStreamParent::WriteReady()
{
int32_t result;
nsresult rv = CallNPP_WriteReady(mStream->end, &result);
if (NS_FAILED(rv)) {
--- a/dom/plugins/BrowserStreamParent.h
+++ b/dom/plugins/BrowserStreamParent.h
@@ -15,17 +15,17 @@ class BrowserStreamParent : public PBrow
friend class PluginModuleParent;
friend class PluginInstanceParent;
public:
BrowserStreamParent(PluginInstanceParent* npp,
NPStream* stream);
virtual ~BrowserStreamParent() { }
- virtual nsresult AnswerNPN_RequestRead(const IPCByteRanges& ranges,
+ virtual bool AnswerNPN_RequestRead(const IPCByteRanges& ranges,
NPError* result);
int32_t WriteReady();
int32_t Write(int32_t offset, int32_t len, void* buffer);
void StreamAsFile(const char* fname);
NPError NPN_DestroyStream(NPError reason);
private:
--- a/dom/plugins/PluginInstanceChild.cpp
+++ b/dom/plugins/PluginInstanceChild.cpp
@@ -153,42 +153,42 @@ PluginInstanceChild::NPN_GetValue(NPNVar
default:
printf(" unhandled var %s\n", NPNVariableToString(aVar));
return NPERR_GENERIC_ERROR;
}
}
-nsresult
+bool
PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginScriptableNPObject(
PPluginScriptableObjectChild** value,
NPError* result)
{
NPObject* object;
*result = mPluginIface->getvalue(GetNPP(), NPPVpluginScriptableNPObject,
&object);
if (*result != NPERR_NO_ERROR) {
- return NS_OK;
+ return true;
}
PluginScriptableObjectChild* actor = CreateActorForNPObject(object);
if (!actor) {
PluginModuleChild::sBrowserFuncs.releaseobject(object);
*result = NPERR_GENERIC_ERROR;
- return NS_OK;
+ return true;
}
PluginModuleChild::sBrowserFuncs.releaseobject(object);
*value = actor;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceChild::AnswerNPP_SetWindow(const NPWindow& aWindow,
NPError* rv)
{
printf("[PluginInstanceChild] NPP_SetWindow(%lx, %d, %d)\n",
reinterpret_cast<unsigned long>(aWindow.window),
aWindow.width, aWindow.height);
#if defined(OS_LINUX)
@@ -243,17 +243,17 @@ PluginInstanceChild::AnswerNPP_SetWindow
reinterpret_cast<LONG>(PluginWindowProc)));
}
}
#else
# error Implement me for your OS
#endif
- return NS_OK;
+ return true;
}
bool
PluginInstanceChild::Initialize()
{
#if defined(OS_WIN)
if (!CreatePluginWindow())
return false;
@@ -413,30 +413,30 @@ PluginInstanceChild::PPluginScriptableOb
NS_ENSURE_TRUE(object, nsnull);
*object = new PluginScriptableObjectChild();
NS_ENSURE_TRUE(*object, nsnull);
return object->get();
}
-nsresult
+bool
PluginInstanceChild::PPluginScriptableObjectDestructor(PPluginScriptableObjectChild* aObject)
{
PluginScriptableObjectChild* object =
reinterpret_cast<PluginScriptableObjectChild*>(aObject);
PRUint32 count = mScriptableObjects.Length();
for (PRUint32 index = 0; index < count; index++) {
if (mScriptableObjects[index] == object) {
mScriptableObjects.RemoveElementAt(index);
break;
}
}
- return NS_OK;
+ return true;
}
PBrowserStreamChild*
PluginInstanceChild::PBrowserStreamConstructor(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const PStreamNotifyChild* notifyData,
const nsCString& headers,
@@ -444,46 +444,46 @@ PluginInstanceChild::PBrowserStreamConst
const bool& seekable,
NPError* rv,
uint16_t *stype)
{
return new BrowserStreamChild(this, url, length, lastmodified, headers,
mimeType, seekable, rv, stype);
}
-nsresult
+bool
PluginInstanceChild::PBrowserStreamDestructor(PBrowserStreamChild* stream,
const NPError& reason,
const bool& artificial)
{
delete stream;
- return NS_OK;
+ return true;
}
PStreamNotifyChild*
PluginInstanceChild::PStreamNotifyConstructor(const nsCString& url,
const nsCString& target,
const bool& post,
const nsCString& buffer,
const bool& file,
NPError* result)
{
NS_RUNTIMEABORT("not reached");
return NULL;
}
-nsresult
+bool
PluginInstanceChild::PStreamNotifyDestructor(PStreamNotifyChild* notifyData,
const NPReason& reason)
{
StreamNotifyChild* sn = static_cast<StreamNotifyChild*>(notifyData);
mPluginIface->urlnotify(&mData, sn->mURL.get(), reason, sn->mClosure);
delete sn;
- return NS_OK;
+ return true;
}
PluginScriptableObjectChild*
PluginInstanceChild::CreateActorForNPObject(NPObject* aObject)
{
NS_ASSERTION(aObject, "Null pointer!");
PluginScriptableObjectChild* actor =
--- a/dom/plugins/PluginInstanceChild.h
+++ b/dom/plugins/PluginInstanceChild.h
@@ -62,51 +62,51 @@ class PluginInstanceChild : public PPlug
UINT message,
WPARAM wParam,
LPARAM lParam);
#endif
protected:
friend class BrowserStreamChild;
- virtual nsresult AnswerNPP_SetWindow(const NPWindow& window, NPError* rv);
+ virtual bool AnswerNPP_SetWindow(const NPWindow& window, NPError* rv);
- virtual nsresult
+ virtual bool
AnswerNPP_GetValue_NPPVpluginScriptableNPObject(PPluginScriptableObjectChild** value,
NPError* result);
virtual PPluginScriptableObjectChild*
PPluginScriptableObjectConstructor();
- virtual nsresult
+ virtual bool
PPluginScriptableObjectDestructor(PPluginScriptableObjectChild* aObject);
virtual PBrowserStreamChild*
PBrowserStreamConstructor(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const PStreamNotifyChild* notifyData,
const nsCString& headers,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t *stype);
- virtual nsresult
+ virtual bool
PBrowserStreamDestructor(PBrowserStreamChild* stream,
const NPError& reason,
const bool& artificial);
virtual PStreamNotifyChild*
PStreamNotifyConstructor(const nsCString& url, const nsCString& target,
const bool& post, const nsCString& buffer,
const bool& file,
NPError* result);
- virtual nsresult
+ virtual bool
PStreamNotifyDestructor(PStreamNotifyChild* notifyData,
const NPReason& reason);
public:
PluginInstanceChild(const NPPluginFuncs* aPluginIface) :
mPluginIface(aPluginIface)
#if defined(OS_LINUX)
, mPlug(0)
--- a/dom/plugins/PluginInstanceParent.cpp
+++ b/dom/plugins/PluginInstanceParent.cpp
@@ -53,108 +53,108 @@ PluginInstanceParent::PBrowserStreamCons
const bool& seekable,
NPError* rv,
uint16_t *stype)
{
NS_RUNTIMEABORT("Not reachable");
return NULL;
}
-nsresult
+bool
PluginInstanceParent::AnswerPBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial)
{
if (!artificial) {
static_cast<BrowserStreamParent*>(stream)->NPN_DestroyStream(reason);
}
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::PBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial)
{
delete stream;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::AnswerNPN_GetValue_NPNVjavascriptEnabledBool(
bool* value,
NPError* result)
{
NPBool v;
*result = mNPNIface->getvalue(mNPP, NPNVjavascriptEnabledBool, &v);
*value = v;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::AnswerNPN_GetValue_NPNVisOfflineBool(bool* value,
NPError* result)
{
NPBool v;
*result = mNPNIface->getvalue(mNPP, NPNVisOfflineBool, &v);
*value = v;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::AnswerNPN_GetValue_NPNVWindowNPObject(
PPluginScriptableObjectParent** value,
NPError* result)
{
// TODO NPRuntime
*value = NULL;
*result = NPERR_GENERIC_ERROR;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::AnswerNPN_GetValue_NPNVPluginElementNPObject(
PPluginScriptableObjectParent** value,
NPError* result)
{
// TODO NPRuntime
*value = NULL;
*result = NPERR_GENERIC_ERROR;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::AnswerNPN_GetValue_NPNVprivateModeBool(bool* value,
NPError* result)
{
NPBool v;
*result = mNPNIface->getvalue(mNPP, NPNVprivateModeBool, &v);
*value = v;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::AnswerNPN_GetURL(const nsCString& url,
const nsCString& target,
NPError* result)
{
*result = mNPNIface->geturl(mNPP, url.get(), target.get());
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginInstanceParent::AnswerNPN_PostURL(const nsCString& url,
const nsCString& target,
const nsCString& buffer,
const bool& file,
NPError* result)
{
*result = mNPNIface->posturl(mNPP, url.get(), target.get(),
buffer.Length(), buffer.get(), file);
- return NS_OK;
+ return true;
}
PStreamNotifyParent*
PluginInstanceParent::PStreamNotifyConstructor(const nsCString& url,
const nsCString& target,
const bool& post,
const nsCString& buffer,
const bool& file,
@@ -170,22 +170,22 @@ PluginInstanceParent::PStreamNotifyConst
*result = mNPNIface->posturlnotify(mNPP, url.get(), target.get(),
buffer.Length(), buffer.get(),
file, notifyData);
}
// TODO: what if this method fails?
return notifyData;
}
-nsresult
+bool
PluginInstanceParent::PStreamNotifyDestructor(PStreamNotifyParent* notifyData,
const NPReason& reason)
{
delete notifyData;
- return NS_OK;
+ return true;
}
NPError
PluginInstanceParent::NPP_SetWindow(NPWindow* aWindow)
{
_MOZ_LOG(__FUNCTION__);
NS_ENSURE_TRUE(aWindow, NPERR_GENERIC_ERROR);
@@ -253,17 +253,17 @@ PluginInstanceParent::NPP_DestroyStream(
}
PPluginScriptableObjectParent*
PluginInstanceParent::PPluginScriptableObjectConstructor()
{
return new PluginScriptableObjectParent();
}
-nsresult
+bool
PluginInstanceParent::PPluginScriptableObjectDestructor(PPluginScriptableObjectParent* aObject)
{
delete aObject;
- return NS_OK;
+ return true;
}
} // namespace plugins
} // namespace mozilla
--- a/dom/plugins/PluginInstanceParent.h
+++ b/dom/plugins/PluginInstanceParent.h
@@ -67,71 +67,71 @@ public:
virtual ~PluginInstanceParent()
{
}
virtual PPluginScriptableObjectParent*
PPluginScriptableObjectConstructor();
- virtual nsresult
+ virtual bool
PPluginScriptableObjectDestructor(PPluginScriptableObjectParent* aObject);
virtual PBrowserStreamParent*
PBrowserStreamConstructor(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
const PStreamNotifyParent* notifyData,
const nsCString& headers,
const nsCString& mimeType,
const bool& seekable,
NPError* rv,
uint16_t *stype);
- virtual nsresult
+ virtual bool
AnswerPBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial);
- virtual nsresult
+ virtual bool
PBrowserStreamDestructor(PBrowserStreamParent* stream,
const NPError& reason,
const bool& artificial);
- virtual nsresult
+ virtual bool
AnswerNPN_GetValue_NPNVjavascriptEnabledBool(bool* value, NPError* result);
- virtual nsresult
+ virtual bool
AnswerNPN_GetValue_NPNVisOfflineBool(bool* value, NPError* result);
- virtual nsresult
+ virtual bool
AnswerNPN_GetValue_NPNVWindowNPObject(
PPluginScriptableObjectParent** value,
NPError* result);
- virtual nsresult
+ virtual bool
AnswerNPN_GetValue_NPNVPluginElementNPObject(
PPluginScriptableObjectParent** value,
NPError* result);
- virtual nsresult
+ virtual bool
AnswerNPN_GetValue_NPNVprivateModeBool(bool* value, NPError* result);
- virtual nsresult
+ virtual bool
AnswerNPN_GetURL(const nsCString& url, const nsCString& target,
NPError *result);
- virtual nsresult
+ virtual bool
AnswerNPN_PostURL(const nsCString& url, const nsCString& target,
const nsCString& buffer, const bool& file,
NPError* result);
virtual PStreamNotifyParent*
PStreamNotifyConstructor(const nsCString& url, const nsCString& target,
const bool& post, const nsCString& buffer,
const bool& file,
NPError* result);
- virtual nsresult
+ virtual bool
PStreamNotifyDestructor(PStreamNotifyParent* notifyData,
const NPReason& reason);
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
@@ -928,34 +928,36 @@ void NP_CALLBACK
PluginThreadCallback aFunc,
void* aUserData)
{
_MOZ_LOG(__FUNCTION__);
}
#endif /* NP_VERSION_MINOR > 19 */
-nsresult
+bool
PluginModuleChild::AnswerNP_Initialize(NPError* _retval)
{
_MOZ_LOG(__FUNCTION__);
#if defined(OS_LINUX)
*_retval = mInitializeFunc(&sBrowserFuncs, &mFunctions);
- return NS_OK;
+ return true;
#elif defined(OS_WIN)
nsresult rv = mGetEntryPointsFunc(&mFunctions);
- NS_ENSURE_SUCCESS(rv, rv);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
NS_ASSERTION(HIBYTE(mFunctions.version) >= NP_VERSION_MAJOR,
"callback version is less than NP version");
*_retval = mInitializeFunc(&sBrowserFuncs);
- return NS_OK;
+ return true;
#else
# error Please implement me for your platform
#endif
}
PPluginInstanceChild*
PluginModuleChild::PPluginInstanceConstructor(const nsCString& aMimeType,
const uint16_t& aMode,
@@ -969,17 +971,17 @@ PluginModuleChild::PPluginInstanceConstr
new PluginInstanceChild(&mFunctions));
if (!childInstance->Initialize()) {
*rv = NPERR_GENERIC_ERROR;
return 0;
}
return childInstance.forget();
}
-nsresult
+bool
PluginModuleChild::AnswerPPluginInstanceConstructor(PPluginInstanceChild* aActor,
const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv)
{
_MOZ_LOG(__FUNCTION__);
@@ -1016,24 +1018,24 @@ PluginModuleChild::AnswerPPluginInstance
argn,
argv,
0);
if (NPERR_NO_ERROR != *rv) {
return NS_ERROR_FAILURE;
}
printf ("[PluginModuleChild] %s: returning %hd\n", __FUNCTION__, *rv);
- return NS_OK;;
+ return true;;
}
-nsresult
+bool
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;
- return NS_OK;
+ return true;
}
--- a/dom/plugins/PluginModuleChild.h
+++ b/dom/plugins/PluginModuleChild.h
@@ -95,30 +95,30 @@ namespace mozilla {
namespace plugins {
class PluginScriptableObjectChild;
class PluginModuleChild : public PPluginModuleChild
{
protected:
// Implement the PPluginModuleChild interface
- virtual nsresult AnswerNP_Initialize(NPError* rv);
+ virtual bool AnswerNP_Initialize(NPError* rv);
virtual PPluginInstanceChild*
PPluginInstanceConstructor(const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv);
- virtual nsresult
+ virtual bool
PPluginInstanceDestructor(PPluginInstanceChild* aActor,
NPError* rv);
- virtual nsresult
+ virtual bool
AnswerPPluginInstanceConstructor(PPluginInstanceChild* aActor,
const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv);
public:
--- a/dom/plugins/PluginModuleParent.cpp
+++ b/dom/plugins/PluginModuleParent.cpp
@@ -91,23 +91,23 @@ PluginModuleParent::PPluginInstanceConst
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv)
{
NS_ERROR("Not reachable!");
return NULL;
}
-nsresult
+bool
PluginModuleParent::PPluginInstanceDestructor(PPluginInstanceParent* aActor,
NPError* _retval)
{
_MOZ_LOG(__FUNCTION__);
delete aActor;
- return NS_OK;
+ return true;
}
void
PluginModuleParent::SetPluginFuncs(NPPluginFuncs* aFuncs)
{
aFuncs->version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
aFuncs->javaClass = nsnull;
@@ -318,83 +318,83 @@ PluginModuleParent::NPP_GetValue(NPP ins
NPError
PluginModuleParent::NPP_SetValue(NPP instance, NPNVariable variable,
void *value)
{
return InstCast(instance)->NPP_SetValue(variable, value);
}
-nsresult
+bool
PluginModuleParent::RecvNPN_GetStringIdentifier(const nsCString& aString,
NPRemoteIdentifier* aId)
{
NS_ENSURE_ARG(!aString.IsVoid());
NPIdentifier ident = _getstringidentifier(aString.BeginReading());
NS_ENSURE_STATE(ident);
nsVoidPtrHashKey* newEntry = mValidIdentifiers.PutEntry(ident);
NS_ENSURE_TRUE(newEntry, NS_ERROR_OUT_OF_MEMORY);
*aId = (NPRemoteIdentifier)ident;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginModuleParent::RecvNPN_GetIntIdentifier(const int32_t& aInt,
NPRemoteIdentifier* aId)
{
NPIdentifier ident = _getintidentifier(aInt);
NS_ENSURE_STATE(ident);
nsVoidPtrHashKey* newEntry = mValidIdentifiers.PutEntry(ident);
NS_ENSURE_TRUE(newEntry, NS_ERROR_OUT_OF_MEMORY);
*aId = (NPRemoteIdentifier)ident;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginModuleParent::RecvNPN_UTF8FromIdentifier(const NPRemoteIdentifier& aId,
nsCString* aString)
{
NPIdentifier ident = GetValidNPIdentifier(aId);
NS_ENSURE_ARG(ident);
NPUTF8* val = _utf8fromidentifier(ident);
NS_ENSURE_STATE(val);
aString->Assign(val);
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginModuleParent::RecvNPN_IntFromIdentifier(const NPRemoteIdentifier& aId,
int32_t* aInt)
{
NPIdentifier ident = GetValidNPIdentifier(aId);
NS_ENSURE_ARG(ident);
*aInt = _intfromidentifier(ident);
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginModuleParent::RecvNPN_IdentifierIsString(const NPRemoteIdentifier& aId,
bool* aIsString)
{
NPIdentifier ident = GetValidNPIdentifier(aId);
NS_ENSURE_ARG(ident);
*aIsString = _identifierisstring(ident);
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginModuleParent::RecvNPN_GetStringIdentifiers(const nsTArray<nsCString>& aNames,
nsTArray<NPRemoteIdentifier>* aIds)
{
NS_ASSERTION(aIds->IsEmpty(), "Non-empty array!");
PRUint32 count = aNames.Length();
NS_ENSURE_ARG_MIN(count, 1);
@@ -423,17 +423,17 @@ PluginModuleParent::RecvNPN_GetStringIde
if (id) {
nsVoidPtrHashKey* newEntry = mValidIdentifiers.PutEntry(id);
NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
}
aIds->AppendElement((NPRemoteIdentifier)id);
}
- return NS_OK;
+ return true;
}
PluginInstanceParent*
PluginModuleParent::InstCast(NPP instance)
{
PluginInstanceParent* ip =
static_cast<PluginInstanceParent*>(instance->pdata);
if (instance != ip->mNPP) {
--- a/dom/plugins/PluginModuleParent.h
+++ b/dom/plugins/PluginModuleParent.h
@@ -86,17 +86,17 @@ private:
protected:
PPluginInstanceParent*
PPluginInstanceConstructor(const nsCString& aMimeType,
const uint16_t& aMode,
const nsTArray<nsCString>& aNames,
const nsTArray<nsCString>& aValues,
NPError* rv);
- virtual nsresult
+ virtual bool
PPluginInstanceDestructor(PPluginInstanceParent* aActor,
NPError* _retval);
public:
PluginModuleParent(const char* aFilePath);
virtual ~PluginModuleParent();
@@ -106,32 +106,32 @@ public:
* Returns a SharedLibrary from which plugin symbols should be
* resolved. This may or may not launch a plugin child process,
* and may or may not be very expensive.
*/
static SharedLibrary* LoadModule(const char* aFilePath,
PRLibrary* aLibrary);
// NPRemoteIdentifier funcs
- virtual nsresult
+ virtual bool
RecvNPN_GetStringIdentifier(const nsCString& aString,
NPRemoteIdentifier* aId);
- virtual nsresult
+ virtual bool
RecvNPN_GetIntIdentifier(const int32_t& aInt,
NPRemoteIdentifier* aId);
- virtual nsresult
+ virtual bool
RecvNPN_UTF8FromIdentifier(const NPRemoteIdentifier& aId,
nsCString* aString);
- virtual nsresult
+ virtual bool
RecvNPN_IntFromIdentifier(const NPRemoteIdentifier& aId,
int32_t* aInt);
- virtual nsresult
+ virtual bool
RecvNPN_IdentifierIsString(const NPRemoteIdentifier& aId,
bool* aIsString);
- virtual nsresult
+ virtual bool
RecvNPN_GetStringIdentifiers(const nsTArray<nsCString>& aNames,
nsTArray<NPRemoteIdentifier>* aIds);
private:
void SetPluginFuncs(NPPluginFuncs* aFuncs);
// Implement the module-level functions from NPAPI; these are
// normally resolved directly from the DSO.
--- a/dom/plugins/PluginScriptableObjectChild.cpp
+++ b/dom/plugins/PluginScriptableObjectChild.cpp
@@ -120,16 +120,19 @@ ConvertToVariant(const NPRemoteVariant&
case NPRemoteVariant::TPPluginScriptableObjectChild: {
NPObject* object = NPObjectFromVariant(aRemoteVariant);
if (!object) {
return false;
}
OBJECT_TO_NPVARIANT(object, aVariant);
return true;
}
+
+ default:
+ break; // break to NOTREACHED
}
NS_NOTREACHED("Shouldn't get here!");
return false;
}
bool
ConvertToRemoteVariant(const NPVariant& aVariant,
@@ -203,299 +206,299 @@ PluginScriptableObjectChild::Initialize(
NPObject* aObject)
{
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!(mInstance && mObject), "Calling Initialize class twice!");
mInstance = aInstance;
mObject = PluginModuleChild::sBrowserFuncs.retainobject(aObject);
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerInvalidate()
{
NS_ENSURE_STATE(NS_IsMainThread());
if (mObject) {
PluginModuleChild::sBrowserFuncs.releaseobject(mObject);
mObject = nsnull;
- return NS_OK;
+ return true;
}
return NS_ERROR_UNEXPECTED;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerHasMethod(const NPRemoteIdentifier& aId,
bool* aHasMethod)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->hasMethod)) {
*aHasMethod = false;
- return NS_OK;
+ return true;
}
*aHasMethod = mObject->_class->hasMethod(mObject, (NPIdentifier)aId);
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerInvoke(const NPRemoteIdentifier& aId,
const nsTArray<NPRemoteVariant>& aArgs,
NPRemoteVariant* aResult,
bool* aSuccess)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->invoke)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
nsAutoTArray<NPVariant, 10> convertedArgs;
PRUint32 argCount = aArgs.Length();
if (!convertedArgs.SetLength(argCount)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
for (PRUint32 index = 0; index < argCount; index++) {
if (!ConvertToVariant(aArgs[index], convertedArgs[index])) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
}
NPVariant result;
bool success = mObject->_class->invoke(mObject, (NPIdentifier)aId,
convertedArgs.Elements(), argCount,
&result);
if (!success) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
NPRemoteVariant convertedResult;
if (!ConvertToRemoteVariant(result, convertedResult, mInstance)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
*aSuccess = true;
*aResult = convertedResult;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerInvokeDefault(const nsTArray<NPRemoteVariant>& aArgs,
NPRemoteVariant* aResult,
bool* aSuccess)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->invokeDefault)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
nsAutoTArray<NPVariant, 10> convertedArgs;
PRUint32 argCount = aArgs.Length();
if (!convertedArgs.SetLength(argCount)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
for (PRUint32 index = 0; index < argCount; index++) {
if (!ConvertToVariant(aArgs[index], convertedArgs[index])) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
}
NPVariant result;
bool success = mObject->_class->invokeDefault(mObject,
convertedArgs.Elements(),
argCount, &result);
if (!success) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
NPRemoteVariant convertedResult;
if (!ConvertToRemoteVariant(result, convertedResult, mInstance)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
*aSuccess = true;
*aResult = convertedResult;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerHasProperty(const NPRemoteIdentifier& aId,
bool* aHasProperty)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->hasProperty)) {
*aHasProperty = false;
- return NS_OK;
+ return true;
}
*aHasProperty = mObject->_class->hasProperty(mObject, (NPIdentifier)aId);
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerGetProperty(const NPRemoteIdentifier& aId,
NPRemoteVariant* aResult,
bool* aSuccess)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->getProperty)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
NPVariant result;
if (!mObject->_class->getProperty(mObject, (NPIdentifier)aId, &result)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
NPRemoteVariant converted;
if ((*aSuccess = ConvertToRemoteVariant(result, converted, mInstance))) {
*aResult = converted;
}
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerSetProperty(const NPRemoteIdentifier& aId,
const NPRemoteVariant& aValue,
bool* aSuccess)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->setProperty)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
NPVariant converted;
if (!ConvertToVariant(aValue, converted)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
*aSuccess = mObject->_class->setProperty(mObject, (NPIdentifier)aId,
&converted);
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerRemoveProperty(const NPRemoteIdentifier& aId,
bool* aSuccess)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->removeProperty)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
*aSuccess = mObject->_class->removeProperty(mObject, (NPIdentifier)aId);
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerEnumerate(nsTArray<NPRemoteIdentifier>* aProperties,
bool* aSuccess)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->enumerate)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
NPIdentifier* ids;
uint32_t idCount;
if (!mObject->_class->enumerate(mObject, &ids, &idCount)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
if (!aProperties->SetCapacity(idCount)) {
PluginModuleChild::sBrowserFuncs.memfree(ids);
*aSuccess = false;
- return NS_OK;
+ return true;
}
for (uint32_t index = 0; index < idCount; index++) {
#ifdef DEBUG
NPRemoteIdentifier* remoteId =
#endif
aProperties->AppendElement((NPRemoteIdentifier)ids[index]);
NS_ASSERTION(remoteId, "Shouldn't fail if SetCapacity above succeeded!");
}
PluginModuleChild::sBrowserFuncs.memfree(ids);
*aSuccess = true;
- return NS_OK;
+ return true;
}
-nsresult
+bool
PluginScriptableObjectChild::AnswerConstruct(const nsTArray<NPRemoteVariant>& aArgs,
NPRemoteVariant* aResult,
bool* aSuccess)
{
NS_ENSURE_STATE(NS_IsMainThread());
NS_ENSURE_STATE(mObject);
if (!(mObject->_class && mObject->_class->construct)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
nsAutoTArray<NPVariant, 10> convertedArgs;
PRUint32 argCount = aArgs.Length();
if (!convertedArgs.SetLength(argCount)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
for (PRUint32 index = 0; index < argCount; index++) {
if (!ConvertToVariant(aArgs[index], convertedArgs[index])) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
}
NPVariant result;
bool success = mObject->_class->construct(mObject, convertedArgs.Elements(),
argCount, &result);
if (!success) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
NPRemoteVariant convertedResult;
if (!ConvertToRemoteVariant(result, convertedResult, mInstance)) {
*aSuccess = false;
- return NS_OK;
+ return true;
}
*aSuccess = true;
*aResult = convertedResult;
- return NS_OK;
+ return true;
}
--- a/dom/plugins/PluginScriptableObjectChild.h
+++ b/dom/plugins/PluginScriptableObjectChild.h
@@ -49,57 +49,57 @@ namespace plugins {
class PluginInstanceChild;
class PluginScriptableObjectChild : public PPluginScriptableObjectChild
{
public:
PluginScriptableObjectChild();
virtual ~PluginScriptableObjectChild();
- virtual nsresult
+ virtual bool
AnswerInvalidate();
- virtual nsresult
+ virtual bool
AnswerHasMethod(const NPRemoteIdentifier& aId,
bool* aHasMethod);
- virtual nsresult
+ virtual bool
AnswerInvoke(const NPRemoteIdentifier& aId,
const nsTArray<NPRemoteVariant>& aArgs,
NPRemoteVariant* aResult,
bool* aSuccess);
- virtual nsresult
+ virtual bool
AnswerInvokeDefault(const nsTArray<NPRemoteVariant>& aArgs,
NPRemoteVariant* aResult,
bool* aSuccess);
- virtual nsresult
+ virtual bool
AnswerHasProperty(const NPRemoteIdentifier& aId,
bool* aHasProperty);
- virtual nsresult
+ virtual bool
AnswerGetProperty(const NPRemoteIdentifier& aId,
NPRemoteVariant* aResult,
bool* aSuccess);
- virtual nsresult
+ virtual bool
AnswerSetProperty(const NPRemoteIdentifier& aId,
const NPRemoteVariant& aValue,
bool* aSuccess);
- virtual nsresult
+ virtual bool
AnswerRemoveProperty(const NPRemoteIdentifier& aId,
bool* aSuccess);
- virtual nsresult
+ virtual bool
AnswerEnumerate(nsTArray<NPRemoteIdentifier>* aProperties,
bool* aSuccess);
- virtual nsresult
+ virtual bool
AnswerConstruct(const nsTArray<NPRemoteVariant>& aArgs,
NPRemoteVariant* aResult,
bool* aSuccess);
void
Initialize(PluginInstanceChild* aInstance,
NPObject* aObject);
--- a/ipc/app/MozillaRuntimeMain.cpp
+++ b/ipc/app/MozillaRuntimeMain.cpp
@@ -49,17 +49,17 @@
#include <windows.h>
// we want a wmain entry point
#include "nsWindowsWMain.cpp"
#endif
int
main(int argc, char* argv[])
{
-#if 1
+#if defined(XP_WIN) && defined(DEBUG_bent)
MessageBox(NULL, L"Hi", L"Hi", MB_OK);
#endif
GeckoProcessType proctype =
XRE_StringToChildProcessType(argv[argc - 1]);
nsresult rv = XRE_InitChildProcess(argc - 1, argv, proctype);
NS_ENSURE_SUCCESS(rv, 1);
--- a/ipc/ipdl/ipdl/lower.py
+++ b/ipc/ipdl/ipdl/lower.py
@@ -387,18 +387,24 @@ class GenerateProtocolHeader(Visitor):
opeq.addstmt(cxx.StmtExpr(
cxx.ExprAssn(cxx.ExprDeref(callptrmeth),
rhsvar)))
opeq.addstmt(returnthis)
opeqs.append(opeq)
opeqswitch.addstmt(caselabel)
opeqswitch.addstmt(cxx.StmtExpr(
- cxx.ExprAssn(cxx.ExprDeref(callptrmeth),
- cxx.ExprCast(rhsvar, clstyperef, const=1))))
+ cxx.ExprAssn(
+ cxx.ExprDeref(callptrmeth),
+ cxx.ExprCall(
+ cxx.ExprSelect(
+ cxx.ExprCast(rhsvar, clstyperef, const=1),
+ '.',
+ gettypen)))))
+
opeqswitch.addstmt(cxx.StmtBreak())
optype = cxx.MethodDefn(
cxx.MethodDecl('operator '+ typename +'&', typeop=1))
optype.addstmt(returngettype)
optypes.append(optype)
opconsttype = cxx.MethodDefn(
@@ -803,17 +809,17 @@ class GenerateProtocolHeader(Visitor):
md._cxx.params = [ makeCxxDecl(d) for d in md.inParams ]
md._cxx.returns = [ makeCxxDecl(d) for d in md.outParams ]
# generate C++ interface to message sending/handling
method = cxx.MethodDecl(
name=md.decl.progname,
params=[ ],
- ret=cxx.Type('nsresult'),
+ ret=cxx.Type('bool'),
virtual=1)
for param in md._cxx.params:
pcopy = deepcopy(param)
pcopy.type.const = 1
if not param.type.actor:
pcopy.type.ref = 1
method.params.append(pcopy)
for ret in md._cxx.returns:
@@ -1979,18 +1985,17 @@ class GenerateProtocolActorHeader(Visito
cxx.ExprSelect(objvar, '->', 'mManager'),
cxx.ExprLiteral.ZERO)))
calldtor = cxx.ExprCall(
cxx.ExprVar(md._cxx.method.name),
([ objvar ]
+ [ cxx.ExprVar(p.name) for p in md._cxx.params ]
+ [ cxx.ExprVar(r.name) for r in md._cxx.returns ]))
- failif = cxx.StmtIf(cxx.ExprCall(
- cxx.ExprVar('NS_FAILED'), [ calldtor ]))
+ failif = cxx.StmtIf(cxx.ExprPrefixUnop(calldtor, '!'))
failif.addifstmt(cxx.StmtReturn(valueerrcode))
impl.addstmt(failif)
impl.addstmt(cxx.StmtReturn(okcode))
self.cls.addstmt(impl)
self.cls.addstmt(cxx.Whitespace.NL)
@@ -2176,33 +2181,31 @@ class GenerateProtocolActorHeader(Visito
# call the C++ handler hook
callimpl = cxx.ExprCall(
cxx.ExprVar(pfx + md.decl.progname), [ ])
if md.decl.type.isCtor() or md.decl.type.isDtor():
callimpl.args += [ objvar ]
callimpl.args += [ cxx.ExprVar(p.name) for p in md._cxx.params ]
callimpl.args += [ cxx.ExprAddrOf(cxx.ExprVar(r.name))
for r in md._cxx.returns ]
- errhandle = cxx.StmtIf(cxx.ExprCall(
- cxx.ExprVar('NS_FAILED'), [ callimpl ]))
+ errhandle = cxx.StmtIf(cxx.ExprPrefixUnop(callimpl, '!'))
errhandle.ifb.addstmt(cxx.StmtReturn(
cxx.ExprVar('MsgValueError')))
block.addstmt(errhandle)
block.addstmt(cxx.Whitespace.NL)
if md.decl.type.isDtor():
calldtor = cxx.ExprCall(
cxx.ExprVar(md._cxx.method.name),
([ objvar ]
+ [ cxx.ExprVar(p.name) for p in md._cxx.params ]
+ [ cxx.ExprAddrOf(cxx.ExprVar(r.name)) for
r in md._cxx.returns ]))
- failif = cxx.StmtIf(cxx.ExprCall(
- cxx.ExprVar('NS_FAILED'), [ calldtor ]))
+ failif = cxx.StmtIf(cxx.ExprPrefixUnop(calldtor, '!'))
failif.ifb.addstmt(cxx.StmtReturn(cxx.ExprVar('MsgValueError')))
block.addstmt(failif)
block.addstmt(cxx.StmtExpr(
cxx.ExprCall(cxx.ExprVar('Unregister'), [ routevar ])))
block.addstmt(cxx.StmtExpr(
cxx.ExprAssn(routevar, cxx.ExprLiteral.ZERO)))
if md.decl.type.hasReply():
--- a/ipc/test-harness/TestChild.cpp
+++ b/ipc/test-harness/TestChild.cpp
@@ -46,43 +46,43 @@ TestChild::TestChild()
TestChild::~TestChild()
{
}
#if 1
//-----------------------------------------------------------------------------
// "Hello world" example
-nsresult TestChild::RecvHello()
+bool TestChild::RecvHello()
{
- puts("[TestChild] Hello, ");
- SendWorld();
- return NS_OK;
+ puts("[TestChild] Hello, ");
+ SendWorld();
+ return true;
}
#elif 0
//-----------------------------------------------------------------------------
// Example solution to exercise
-nsresult TestChild::RecvPing()
+bool TestChild::RecvPing()
{
- return SendPong(42);
+ return SendPong(42);
}
-nsresult TestChild::RecvPong(const int& status)
+bool TestChild::RecvPong(const int& status)
{
- return NS_ERROR_NOT_IMPLEMENTED;
+ return false;
}
-nsresult TestChild::RecvTellValue(
+bool TestChild::RecvTellValue(
const String& key,
const String& val)
{
- return NS_ERROR_NOT_IMPLEMENTED;
+ return false;
}
-nsresult TestChild::RecvTellValues(
+bool TestChild::RecvTellValues(
const StringArray& keys,
const StringArray& vals)
{
- return NS_ERROR_NOT_IMPLEMENTED;
+ return false;
}
#endif
--- a/ipc/test-harness/TestChild.h
+++ b/ipc/test-harness/TestChild.h
@@ -46,28 +46,28 @@ namespace test {
// Header file contents
class TestChild : public PTestChild
{
protected:
#if 1
//-----------------------------------------------------------------------------
// "Hello world" example
- virtual nsresult RecvHello();
+ virtual bool RecvHello();
#elif 0
//-----------------------------------------------------------------------------
// Example solution to exercise
- virtual nsresult RecvPing();
- virtual nsresult RecvPong(const int& status);
- virtual nsresult RecvTellValue(
+ virtual bool RecvPing();
+ virtual bool RecvPong(const int& status);
+ virtual bool RecvTellValue(
const String& key,
const String& val);
- virtual nsresult RecvTellValues(
+ virtual bool RecvTellValues(
const StringArray& keys,
const StringArray& vals);
#endif
public:
TestChild();
virtual ~TestChild();
};
--- a/ipc/test-harness/TestParent.cpp
+++ b/ipc/test-harness/TestParent.cpp
@@ -48,60 +48,60 @@ TestParent::~TestParent()
{
}
void
TestParent::DoStuff()
{
#if 1
- puts("[TestParent] in DoStuff()");
- SendHello();
+ puts("[TestParent] in DoStuff()");
+ SendHello();
#elif 0
- puts("[TestParent] pinging child ...");
- SendPing();
+ puts("[TestParent] pinging child ...");
+ SendPing();
#endif
}
#if 1
//-----------------------------------------------------------------------------
// "Hello world" exampl
-nsresult TestParent::RecvWorld()
+bool TestParent::RecvWorld()
{
- puts("[TestParent] world!");
- return NS_OK;
+ puts("[TestParent] world!");
+ return true;
}
#elif 0
//-----------------------------------------------------------------------------
// Example solution to exercise
-nsresult TestParent::RecvPing()
+bool TestParent::RecvPing()
{
- return NS_ERROR_NOT_IMPLEMENTED;
+ return false;
}
-nsresult TestParent::RecvPong(const int& status)
+bool TestParent::RecvPong(const int& status)
{
- printf("[TestParent] child replied to ping with status code %d\n", status);
- return NS_OK;
+ printf("[TestParent] child replied to ping with status code %d\n", status);
+ return true;
}
-nsresult TestParent::RecvGetValue(const String& key)
+bool TestParent::RecvGetValue(const String& key)
{
- return NS_ERROR_NOT_IMPLEMENTED;
+ return false;
}
-nsresult TestParent::RecvGetValues(const StringArray& keys)
+bool TestParent::RecvGetValues(const StringArray& keys)
{
- return NS_ERROR_NOT_IMPLEMENTED;
+ return false;
}
-nsresult TestParent::RecvSetValue(
+bool TestParent::RecvSetValue(
const String& key,
const String& val,
bool* ok)
{
- return NS_ERROR_NOT_IMPLEMENTED;
+ return false;
}
#endif
--- a/ipc/test-harness/TestParent.h
+++ b/ipc/test-harness/TestParent.h
@@ -45,27 +45,27 @@ namespace test {
// Header file contents
class TestParent : public PTestParent
{
protected:
#if 1
//-----------------------------------------------------------------------------
// "Hello world" example
- virtual nsresult RecvWorld();
+ virtual bool RecvWorld();
#elif 0
//-----------------------------------------------------------------------------
// Example solution to exercise
- virtual nsresult RecvPing();
- virtual nsresult RecvPong(const int& status);
- virtual nsresult RecvGetValue(const String& key);
- virtual nsresult RecvGetValues(const StringArray& keys);
- virtual nsresult RecvSetValue(
+ virtual bool RecvPing();
+ virtual bool RecvPong(const int& status);
+ virtual bool RecvGetValue(const String& key);
+ virtual bool RecvGetValues(const StringArray& keys);
+ virtual bool RecvSetValue(
const String& key,
const String& val,
bool* ok);
#endif
public:
TestParent();
virtual ~TestParent();
--- a/ipc/testshell/TestShellChild.cpp
+++ b/ipc/testshell/TestShellChild.cpp
@@ -40,55 +40,49 @@ using mozilla::ipc::TestShellChild;
using mozilla::ipc::PTestShellCommandChild;
using mozilla::ipc::XPCShellEnvironment;
TestShellChild::TestShellChild()
: mXPCShell(XPCShellEnvironment::CreateEnvironment())
{
}
-nsresult
+bool
TestShellChild::RecvExecuteCommand(const nsString& aCommand)
{
if (mXPCShell->IsQuitting()) {
NS_WARNING("Commands sent after quit command issued!");
- return NS_ERROR_UNEXPECTED;
+ return false;
}
- return mXPCShell->EvaluateString(aCommand) ? NS_OK : NS_ERROR_FAILURE;
+ return mXPCShell->EvaluateString(aCommand);
}
PTestShellCommandChild*
TestShellChild::PTestShellCommandConstructor(const nsString& aCommand)
{
return new PTestShellCommandChild();
}
-nsresult
+bool
TestShellChild::PTestShellCommandDestructor(PTestShellCommandChild* aCommand,
const nsString& aResponse)
{
- NS_ENSURE_ARG_POINTER(aCommand);
delete aCommand;
- return NS_OK;
+ return true;
}
-nsresult
+bool
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;
+ return false;
}
nsString response;
if (!mXPCShell->EvaluateString(aCommand, &response)) {
- return NS_ERROR_FAILURE;
+ return false;
}
- nsresult rv = SendPTestShellCommandDestructor(aActor, response);
- NS_ENSURE_SUCCESS(rv, rv);
-
- return NS_OK;
+ return SendPTestShellCommandDestructor(aActor, response);
}
--- a/ipc/testshell/TestShellChild.h
+++ b/ipc/testshell/TestShellChild.h
@@ -48,27 +48,27 @@ namespace ipc {
class XPCShellEnvironment;
class TestShellChild : public PTestShellChild
{
public:
TestShellChild();
- nsresult
+ bool
RecvExecuteCommand(const nsString& aCommand);
PTestShellCommandChild*
PTestShellCommandConstructor(const nsString& aCommand);
- nsresult
+ bool
RecvPTestShellCommandConstructor(PTestShellCommandChild* aActor,
const nsString& aCommand);
- nsresult
+ bool
PTestShellCommandDestructor(PTestShellCommandChild* aCommand,
const nsString& aResponse);
void SetXPCShell(XPCShellEnvironment* aXPCShell) {
mXPCShell = aXPCShell;
}
private:
--- a/ipc/testshell/TestShellParent.cpp
+++ b/ipc/testshell/TestShellParent.cpp
@@ -43,38 +43,35 @@ using mozilla::ipc::TestShellCommandPare
using mozilla::ipc::PTestShellCommandParent;
PTestShellCommandParent*
TestShellParent::PTestShellCommandConstructor(const nsString& aCommand)
{
return new TestShellCommandParent();
}
-nsresult
+bool
TestShellParent::PTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse)
{
- NS_ENSURE_ARG_POINTER(aActor);
delete aActor;
- return NS_OK;
+ return true;
}
-nsresult
+bool
TestShellParent::RecvPTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse)
{
- NS_ENSURE_ARG_POINTER(aActor);
-
TestShellCommandParent* command =
reinterpret_cast<TestShellCommandParent*>(aActor);
JSBool ok = command->RunCallback(aResponse);
command->ReleaseCallback();
- return NS_OK;
+ return true;
}
JSBool
TestShellCommandParent::SetCallback(JSContext* aCx,
jsval aCallback)
{
if (!mCallback.Hold(aCx)) {
return JS_FALSE;
--- a/ipc/testshell/TestShellParent.h
+++ b/ipc/testshell/TestShellParent.h
@@ -65,21 +65,21 @@ private:
};
class TestShellParent : public PTestShellParent
{
public:
PTestShellCommandParent*
PTestShellCommandConstructor(const nsString& aCommand);
- nsresult
+ bool
PTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse);
- nsresult
+ bool
RecvPTestShellCommandDestructor(PTestShellCommandParent* aActor,
const nsString& aResponse);
};
} /* namespace ipc */
} /* namespace mozilla */
#endif /* ipc_testshell_TestShellParent_h */
--- a/netwerk/ipc/NeckoChild.cpp
+++ b/netwerk/ipc/NeckoChild.cpp
@@ -68,17 +68,17 @@ void NeckoChild::InitNeckoChild()
}
PHttpChannelChild*
NeckoChild::PHttpChannelConstructor()
{
return new HttpChannelChild();
}
-nsresult
+bool
NeckoChild::PHttpChannelDestructor(PHttpChannelChild* channel)
{
delete channel;
- return NS_OK;
+ return true;
}
}} // mozilla::net
--- a/netwerk/ipc/NeckoChild.h
+++ b/netwerk/ipc/NeckoChild.h
@@ -54,17 +54,17 @@ class NeckoChild :
{
public:
NeckoChild();
virtual ~NeckoChild();
static void InitNeckoChild();
virtual PHttpChannelChild* PHttpChannelConstructor();
- virtual nsresult PHttpChannelDestructor(PHttpChannelChild*);
+ virtual bool PHttpChannelDestructor(PHttpChannelChild*);
protected:
};
/**
* Reference to the PNecko Child protocol.
* Null if this is not a content process.
*/
--- a/netwerk/ipc/NeckoParent.cpp
+++ b/netwerk/ipc/NeckoParent.cpp
@@ -54,18 +54,18 @@ NeckoParent::~NeckoParent()
}
PHttpChannelParent*
NeckoParent::PHttpChannelConstructor()
{
return new HttpChannelParent();
}
-nsresult
+bool
NeckoParent::PHttpChannelDestructor(PHttpChannelParent* channel)
{
delete channel;
- return NS_OK;
+ return true;
}
}} // mozilla::net
--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -52,15 +52,15 @@ class NeckoParent :
public PNeckoParent
{
public:
NeckoParent();
virtual ~NeckoParent();
protected:
virtual PHttpChannelParent* PHttpChannelConstructor();
- virtual nsresult PHttpChannelDestructor(PHttpChannelParent*);
+ virtual bool PHttpChannelDestructor(PHttpChannelParent*);
};
} // namespace net
} // namespace mozilla
#endif // mozilla_net_NeckoParent_h
--- a/netwerk/protocol/http/src/HttpChannelParent.cpp
+++ b/netwerk/protocol/http/src/HttpChannelParent.cpp
@@ -49,15 +49,16 @@ HttpChannelParent::HttpChannelParent()
}
HttpChannelParent::~HttpChannelParent()
{
}
//-----------------------------------------------------------------------------
//
-nsresult HttpChannelParent::RecvasyncOpen(const nsCString& uri)
+bool HttpChannelParent::RecvasyncOpen(const nsCString& uri)
{
puts("[HttpChannelParent] got asyncOpen msg");
+ return true;
}
}} // mozilla::net
--- a/netwerk/protocol/http/src/HttpChannelParent.h
+++ b/netwerk/protocol/http/src/HttpChannelParent.h
@@ -50,15 +50,15 @@ namespace net {
class HttpChannelParent :
public PHttpChannelParent
{
public:
HttpChannelParent();
virtual ~HttpChannelParent();
protected:
- virtual nsresult RecvasyncOpen(const nsCString& uri);
+ virtual bool RecvasyncOpen(const nsCString& uri);
};
} // namespace net
} // namespace mozilla
#endif // mozilla_net_HttpChannelParent_h