2004-04-11 05:33:17 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2001-09-28 20:14:13 +00:00
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 22:01:16 +00:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1999-07-07 20:18:27 +00:00
|
|
|
*
|
2004-04-18 22:01:16 +00:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
1999-07-07 20:18:27 +00:00
|
|
|
*
|
2001-09-28 20:14:13 +00:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
1999-07-07 20:18:27 +00:00
|
|
|
*
|
1999-11-06 03:43:54 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 22:01:16 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-28 20:14:13 +00:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 03:43:54 +00:00
|
|
|
*
|
2001-09-28 20:14:13 +00:00
|
|
|
* Contributor(s):
|
2001-12-10 01:22:29 +00:00
|
|
|
* Tim Copperfield <timecop@network.email.ne.jp>
|
|
|
|
* Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
|
2001-09-28 20:14:13 +00:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 22:01:16 +00:00
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
2001-09-28 20:14:13 +00:00
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-18 22:01:16 +00:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-28 20:14:13 +00:00
|
|
|
* 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
|
2004-04-18 22:01:16 +00:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-28 20:14:13 +00:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1999-07-07 20:18:27 +00:00
|
|
|
|
|
|
|
#include "prlog.h"
|
|
|
|
#include "prmem.h"
|
|
|
|
#include "nscore.h"
|
2002-06-25 01:29:59 +00:00
|
|
|
#include "prenv.h"
|
2001-12-10 01:22:29 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
#include "ns4xPluginInstance.h"
|
2004-07-16 19:05:54 +00:00
|
|
|
#include "ns4xPlugin.h"
|
2001-08-16 02:59:03 +00:00
|
|
|
#include "ns4xPluginStreamListener.h"
|
|
|
|
#include "nsPluginHostImpl.h"
|
|
|
|
#include "nsPluginSafety.h"
|
|
|
|
#include "nsPluginLogging.h"
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2005-06-18 06:06:45 +00:00
|
|
|
#include "nsPIPluginInstancePeer.h"
|
|
|
|
#include "nsPIDOMWindow.h"
|
|
|
|
#include "nsIDocument.h"
|
|
|
|
|
2004-07-12 15:53:22 +00:00
|
|
|
#include "nsJSNPRuntime.h"
|
|
|
|
|
2003-10-21 22:11:20 +00:00
|
|
|
#ifdef XP_OS2
|
|
|
|
#include "nsILegacyPluginWrapperOS2.h"
|
|
|
|
#endif
|
|
|
|
|
2002-09-03 14:45:02 +00:00
|
|
|
#ifdef MOZ_WIDGET_GTK2
|
|
|
|
#include <gdk/gdk.h>
|
|
|
|
#include <gdk/gdkx.h>
|
|
|
|
#include "gtk2xtbin.h"
|
|
|
|
#endif
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
// CID's && IID's
|
2003-07-20 12:13:22 +00:00
|
|
|
static NS_DEFINE_IID(kCPluginManagerCID, NS_PLUGINMANAGER_CID); // needed for NS_TRY_SAFE_CALL
|
2001-08-16 02:59:03 +00:00
|
|
|
static NS_DEFINE_IID(kIPluginStreamListenerIID, NS_IPLUGINSTREAMLISTENER_IID);
|
2000-09-14 06:13:56 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
// ns4xPluginStreamListener Methods
|
|
|
|
|
2007-03-16 23:53:16 +00:00
|
|
|
NS_IMPL_ISUPPORTS3(ns4xPluginStreamListener, nsIPluginStreamListener,
|
|
|
|
nsITimerCallback, nsIHTTPHeaderListener)
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
ns4xPluginStreamListener::ns4xPluginStreamListener(nsIPluginInstance* inst,
|
2002-04-04 15:23:35 +00:00
|
|
|
void* notifyData,
|
|
|
|
const char* aURL)
|
2004-04-11 05:33:17 +00:00
|
|
|
: mNotifyData(notifyData),
|
|
|
|
mStreamBuffer(nsnull),
|
|
|
|
mNotifyURL(aURL ? PL_strdup(aURL) : nsnull),
|
|
|
|
mInst((ns4xPluginInstance *)inst),
|
|
|
|
mStreamBufferSize(0),
|
|
|
|
mStreamBufferByteCount(0),
|
|
|
|
mStreamType(nsPluginStreamType_Normal),
|
|
|
|
mStreamStarted(PR_FALSE),
|
|
|
|
mStreamCleanedUp(PR_FALSE),
|
|
|
|
mCallNotify(PR_FALSE),
|
2007-03-16 23:53:16 +00:00
|
|
|
mIsSuspended(PR_FALSE),
|
|
|
|
mResponseHeaderBuf(nsnull)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2001-07-21 02:31:29 +00:00
|
|
|
// Initialize the 4.x interface structure
|
|
|
|
memset(&mNPStream, 0, sizeof(mNPStream));
|
|
|
|
|
|
|
|
NS_IF_ADDREF(mInst);
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
ns4xPluginStreamListener::~ns4xPluginStreamListener(void)
|
|
|
|
{
|
2001-07-24 20:48:36 +00:00
|
|
|
// remove itself from the instance stream list
|
2002-03-13 04:24:45 +00:00
|
|
|
ns4xPluginInstance *inst = mInst;
|
|
|
|
if(inst) {
|
2001-07-24 20:48:36 +00:00
|
|
|
nsInstanceStream * prev = nsnull;
|
2002-03-13 04:24:45 +00:00
|
|
|
for(nsInstanceStream *is = inst->mStreams; is != nsnull; is = is->mNext) {
|
2001-07-24 20:48:36 +00:00
|
|
|
if(is->mPluginStreamListener == this) {
|
|
|
|
if(prev == nsnull)
|
2002-03-13 04:24:45 +00:00
|
|
|
inst->mStreams = is->mNext;
|
2001-07-24 20:48:36 +00:00
|
|
|
else
|
|
|
|
prev->mNext = is->mNext;
|
|
|
|
|
|
|
|
delete is;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
prev = is;
|
|
|
|
}
|
|
|
|
}
|
2002-03-13 04:24:45 +00:00
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
// For those cases when NewStream is never called, we still may need
|
|
|
|
// to fire a notification callback. Return network error as fallback
|
|
|
|
// reason because for other cases, notify should have already been
|
|
|
|
// called for other reasons elsewhere.
|
2002-03-13 04:24:45 +00:00
|
|
|
CallURLNotify(NPRES_NETWORK_ERR);
|
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
// lets get rid of the buffer
|
|
|
|
if (mStreamBuffer)
|
|
|
|
{
|
|
|
|
PR_Free(mStreamBuffer);
|
|
|
|
mStreamBuffer=nsnull;
|
|
|
|
}
|
|
|
|
|
2002-03-13 04:24:45 +00:00
|
|
|
NS_IF_RELEASE(inst);
|
2002-04-04 15:23:35 +00:00
|
|
|
|
|
|
|
if (mNotifyURL)
|
|
|
|
PL_strfree(mNotifyURL);
|
2007-03-16 23:53:16 +00:00
|
|
|
|
|
|
|
if (mResponseHeaderBuf)
|
|
|
|
PL_strfree(mResponseHeaderBuf);
|
2001-07-21 02:31:29 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2001-12-19 05:48:38 +00:00
|
|
|
nsresult ns4xPluginStreamListener::CleanUpStream(NPReason reason)
|
2001-07-21 02:31:29 +00:00
|
|
|
{
|
2002-02-16 01:23:16 +00:00
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
if(mStreamCleanedUp)
|
2001-07-21 02:31:29 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
2001-07-24 20:48:36 +00:00
|
|
|
if(!mInst || !mInst->IsStarted())
|
2002-02-16 01:23:16 +00:00
|
|
|
return rv;
|
2001-07-21 02:31:29 +00:00
|
|
|
|
|
|
|
const NPPluginFuncs *callbacks = nsnull;
|
|
|
|
mInst->GetCallbacks(&callbacks);
|
|
|
|
if(!callbacks)
|
2002-02-16 01:23:16 +00:00
|
|
|
return rv;
|
2001-07-21 02:31:29 +00:00
|
|
|
|
2002-02-16 01:23:16 +00:00
|
|
|
NPP npp;
|
|
|
|
mInst->GetNPP(&npp);
|
2001-07-21 02:31:29 +00:00
|
|
|
|
2002-02-16 01:23:16 +00:00
|
|
|
if (mStreamStarted && callbacks->destroystream != NULL)
|
2001-07-21 02:31:29 +00:00
|
|
|
{
|
|
|
|
PRLibrary* lib = nsnull;
|
|
|
|
lib = mInst->fLibrary;
|
2002-02-16 01:23:16 +00:00
|
|
|
NPError error;
|
2001-07-21 02:31:29 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(error, CallNPP_DestroyStreamProc(callbacks->destroystream,
|
|
|
|
npp,
|
|
|
|
&mNPStream,
|
2002-06-01 00:56:38 +00:00
|
|
|
reason), lib, mInst);
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
2001-12-19 05:48:38 +00:00
|
|
|
("NPP DestroyStream called: this=%p, npp=%p, reason=%d, return=%d, url=%s\n",
|
|
|
|
this, npp, reason, error, mNPStream.url));
|
2001-08-16 02:59:03 +00:00
|
|
|
|
2002-02-16 01:23:16 +00:00
|
|
|
if(error == NPERR_NO_ERROR)
|
|
|
|
rv = NS_OK;
|
2001-07-21 02:31:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mStreamCleanedUp = PR_TRUE;
|
|
|
|
mStreamStarted = PR_FALSE;
|
2002-03-13 04:24:45 +00:00
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
StopDataPump();
|
|
|
|
|
2002-03-13 04:24:45 +00:00
|
|
|
// fire notification back to plugin, just like before
|
|
|
|
CallURLNotify(reason);
|
|
|
|
|
2002-02-16 01:23:16 +00:00
|
|
|
return rv;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-03-13 04:24:45 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void ns4xPluginStreamListener::CallURLNotify(NPReason reason)
|
|
|
|
{
|
|
|
|
if(!mCallNotify || !mInst || !mInst->IsStarted())
|
|
|
|
return;
|
|
|
|
|
|
|
|
mCallNotify = PR_FALSE; // only do this ONCE and prevent recursion
|
|
|
|
|
|
|
|
const NPPluginFuncs *callbacks = nsnull;
|
|
|
|
mInst->GetCallbacks(&callbacks);
|
|
|
|
if(!callbacks)
|
|
|
|
return;
|
2002-04-04 15:23:35 +00:00
|
|
|
|
2002-03-13 04:24:45 +00:00
|
|
|
if (callbacks->urlnotify) {
|
2002-04-04 15:23:35 +00:00
|
|
|
|
|
|
|
NPP npp;
|
|
|
|
mInst->GetNPP(&npp);
|
2002-03-13 04:24:45 +00:00
|
|
|
|
|
|
|
NS_TRY_SAFE_CALL_VOID(CallNPP_URLNotifyProc(callbacks->urlnotify,
|
|
|
|
npp,
|
2002-04-04 15:23:35 +00:00
|
|
|
mNotifyURL,
|
2002-03-13 04:24:45 +00:00
|
|
|
reason,
|
2002-06-01 00:56:38 +00:00
|
|
|
mNotifyData), mInst->fLibrary, mInst);
|
2002-03-13 04:24:45 +00:00
|
|
|
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
|
|
|
("NPP URLNotify called: this=%p, npp=%p, notify=%p, reason=%d, url=%s\n",
|
2002-04-04 15:23:35 +00:00
|
|
|
this, npp, mNotifyData, reason, mNotifyURL));
|
2002-03-13 04:24:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
ns4xPluginStreamListener::OnStartBinding(nsIPluginStreamInfo* pluginInfo)
|
|
|
|
{
|
2001-03-02 00:29:33 +00:00
|
|
|
if(!mInst)
|
|
|
|
return NS_ERROR_FAILURE;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
NPP npp;
|
|
|
|
const NPPluginFuncs *callbacks = nsnull;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
mInst->GetCallbacks(&callbacks);
|
|
|
|
mInst->GetNPP(&npp);
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-07-20 19:36:37 +00:00
|
|
|
if(!callbacks || !mInst->IsStarted())
|
2001-03-02 00:29:33 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2000-09-14 06:13:56 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
PRBool seekable;
|
|
|
|
nsMIMEType contentType;
|
|
|
|
PRUint16 streamType = NP_NORMAL;
|
|
|
|
NPError error;
|
2000-12-11 22:54:54 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
mNPStream.ndata = (void*) this;
|
|
|
|
pluginInfo->GetURL(&mNPStream.url);
|
|
|
|
mNPStream.notifyData = mNotifyData;
|
2001-02-13 21:48:26 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
pluginInfo->GetLength((PRUint32*)&(mNPStream.end));
|
|
|
|
pluginInfo->GetLastModified((PRUint32*)&(mNPStream.lastmodified));
|
|
|
|
pluginInfo->IsSeekable(&seekable);
|
|
|
|
pluginInfo->GetContentType(&contentType);
|
2007-03-16 23:53:16 +00:00
|
|
|
|
|
|
|
if (!mResponseHeaders.IsEmpty()) {
|
|
|
|
mResponseHeaderBuf = PL_strdup(mResponseHeaders.get());
|
|
|
|
mNPStream.headers = mResponseHeaderBuf;
|
|
|
|
}
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-05-22 22:32:45 +00:00
|
|
|
mStreamInfo = pluginInfo;
|
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(error, CallNPP_NewStreamProc(callbacks->newstream,
|
|
|
|
npp,
|
|
|
|
(char *)contentType,
|
|
|
|
&mNPStream,
|
|
|
|
seekable,
|
2002-06-01 00:56:38 +00:00
|
|
|
&streamType), mInst->fLibrary, mInst);
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
|
|
|
("NPP NewStream called: this=%p, npp=%p, mime=%s, seek=%d, type=%d, return=%d, url=%s\n",
|
|
|
|
this, npp, (char *)contentType, seekable, streamType, error, mNPStream.url));
|
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
if(error != NPERR_NO_ERROR)
|
|
|
|
return NS_ERROR_FAILURE;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
// translate the old 4x style stream type to the new one
|
|
|
|
switch(streamType)
|
|
|
|
{
|
|
|
|
case NP_NORMAL:
|
|
|
|
mStreamType = nsPluginStreamType_Normal;
|
|
|
|
break;
|
|
|
|
case NP_ASFILEONLY:
|
|
|
|
mStreamType = nsPluginStreamType_AsFileOnly;
|
|
|
|
break;
|
|
|
|
case NP_ASFILE:
|
|
|
|
mStreamType = nsPluginStreamType_AsFile;
|
|
|
|
break;
|
|
|
|
case NP_SEEK:
|
|
|
|
mStreamType = nsPluginStreamType_Seek;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-07-21 02:31:29 +00:00
|
|
|
mStreamStarted = PR_TRUE;
|
2001-03-02 00:29:33 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
nsresult
|
|
|
|
ns4xPluginStreamListener::SuspendRequest()
|
|
|
|
{
|
|
|
|
NS_ASSERTION(!mIsSuspended,
|
|
|
|
"Suspending a request that's already suspended!");
|
|
|
|
|
|
|
|
nsCOMPtr<nsI4xPluginStreamInfo> pluginInfo4x =
|
|
|
|
do_QueryInterface(mStreamInfo);
|
|
|
|
nsIRequest *request;
|
|
|
|
|
|
|
|
if (!pluginInfo4x || !(request = pluginInfo4x->GetRequest())) {
|
|
|
|
NS_ERROR("Trying to suspend a non-suspendable stream!");
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult rv = StartDataPump();
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
mIsSuspended = PR_TRUE;
|
|
|
|
|
|
|
|
return request->Suspend();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ns4xPluginStreamListener::ResumeRequest()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsI4xPluginStreamInfo> pluginInfo4x =
|
|
|
|
do_QueryInterface(mStreamInfo);
|
|
|
|
|
|
|
|
nsIRequest *request = pluginInfo4x->GetRequest();
|
|
|
|
|
|
|
|
// request can be null if the network stream is done.
|
|
|
|
if (request) {
|
|
|
|
request->Resume();
|
|
|
|
}
|
|
|
|
|
|
|
|
mIsSuspended = PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
ns4xPluginStreamListener::StartDataPump()
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
mDataPumpTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// Start pumping data to the plugin every 100ms until it obeys and
|
|
|
|
// eats the data.
|
|
|
|
return mDataPumpTimer->InitWithCallback(this, 100,
|
|
|
|
nsITimer::TYPE_REPEATING_SLACK);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ns4xPluginStreamListener::StopDataPump()
|
|
|
|
{
|
|
|
|
if (mDataPumpTimer) {
|
|
|
|
mDataPumpTimer->Cancel();
|
|
|
|
|
|
|
|
mDataPumpTimer = nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2004-04-11 05:33:17 +00:00
|
|
|
|
|
|
|
// This method is called when there's more data available off the
|
|
|
|
// network, but it's also called from our data pump when we're feeding
|
|
|
|
// the plugin data that we already got off the network, but the plugin
|
|
|
|
// was unable to consume it at the point it arrived. In the case when
|
|
|
|
// the plugin pump calls this method, the input argument will be null,
|
|
|
|
// and the length will be the number of bytes available in our
|
|
|
|
// internal buffer.
|
2001-05-31 01:21:05 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo,
|
|
|
|
nsIInputStream* input,
|
|
|
|
PRUint32 length)
|
|
|
|
{
|
|
|
|
if (!mInst || !mInst->IsStarted())
|
2004-04-11 05:33:17 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
// Just in case the caller switches plugin info on us.
|
|
|
|
mStreamInfo = pluginInfo;
|
2001-05-31 01:21:05 +00:00
|
|
|
|
|
|
|
const NPPluginFuncs *callbacks = nsnull;
|
|
|
|
mInst->GetCallbacks(&callbacks);
|
2002-03-27 03:41:43 +00:00
|
|
|
// check out if plugin implements NPP_Write call
|
|
|
|
if(!callbacks || !callbacks->write || !length)
|
2004-04-11 05:33:17 +00:00
|
|
|
return NS_ERROR_FAILURE; // it'll cancel necko transaction
|
2002-03-27 03:41:43 +00:00
|
|
|
|
|
|
|
if (!mStreamBuffer)
|
2001-05-31 01:21:05 +00:00
|
|
|
{
|
2004-04-11 05:33:17 +00:00
|
|
|
// To optimize the mem usage & performance we have to allocate
|
|
|
|
// mStreamBuffer here in first ODA when length of data available
|
|
|
|
// in input stream is known. mStreamBuffer will be freed in DTOR.
|
|
|
|
// we also have to remember the size of that buff to make safe
|
|
|
|
// consecutive Read() calls form input stream into our buff.
|
|
|
|
|
|
|
|
PRUint32 contentLength;
|
|
|
|
pluginInfo->GetLength(&contentLength);
|
|
|
|
|
|
|
|
mStreamBufferSize = PR_MAX(length, contentLength);
|
|
|
|
|
|
|
|
// Limit the size of the initial buffer to MAX_PLUGIN_NECKO_BUFFER
|
|
|
|
// (16k). This buffer will grow if needed, as in the case where
|
|
|
|
// we're getting data faster than the plugin can process it.
|
|
|
|
mStreamBufferSize = PR_MIN(mStreamBufferSize, MAX_PLUGIN_NECKO_BUFFER);
|
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
mStreamBuffer = (char*) PR_Malloc(mStreamBufferSize);
|
|
|
|
if (!mStreamBuffer)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
2001-05-31 01:21:05 +00:00
|
|
|
}
|
2002-03-27 03:41:43 +00:00
|
|
|
|
|
|
|
// prepare NPP_ calls params
|
2004-04-11 05:33:17 +00:00
|
|
|
NPP npp;
|
2001-03-02 00:29:33 +00:00
|
|
|
mInst->GetNPP(&npp);
|
2004-04-11 05:33:17 +00:00
|
|
|
|
|
|
|
PRInt32 streamPosition;
|
|
|
|
pluginInfo->GetStreamOffset(&streamPosition);
|
|
|
|
PRInt32 streamOffset = streamPosition;
|
|
|
|
|
|
|
|
if (input) {
|
|
|
|
streamOffset += length;
|
|
|
|
|
|
|
|
// Set new stream offset for the next ODA call regardless of how
|
|
|
|
// following NPP_Write call will behave we pretend to consume all
|
|
|
|
// data from the input stream. It's possible that current steam
|
|
|
|
// position will be overwritten from NPP_RangeRequest call made
|
|
|
|
// from NPP_Write, so we cannot call SetStreamOffset after
|
|
|
|
// NPP_Write.
|
|
|
|
//
|
|
|
|
// Note: there is a special case when data flow should be
|
|
|
|
// temporarily stopped if NPP_WriteReady returns 0 (bug #89270)
|
|
|
|
pluginInfo->SetStreamOffset(streamOffset);
|
|
|
|
|
|
|
|
// set new end in case the content is compressed
|
|
|
|
// initial end is less than end of decompressed stream
|
|
|
|
// and some plugins (e.g. acrobat) can fail.
|
|
|
|
if ((PRInt32)mNPStream.end < streamOffset)
|
|
|
|
mNPStream.end = streamOffset;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
while (NS_SUCCEEDED(rv) && length > 0) {
|
|
|
|
if (input && length) {
|
|
|
|
if (mStreamBufferSize < mStreamBufferByteCount + length &&
|
|
|
|
mIsSuspended) {
|
|
|
|
// We're in the ::OnDataAvailable() call that we might get
|
|
|
|
// after suspending a request, or we suspended the request
|
|
|
|
// from within this ::OnDataAvailable() call while there's
|
|
|
|
// still data in the input, and we don't have enough space to
|
|
|
|
// store what we got off the network. Reallocate our internal
|
|
|
|
// buffer.
|
|
|
|
mStreamBufferSize = mStreamBufferByteCount + length;
|
|
|
|
char *buf = (char *)PR_Realloc(mStreamBuffer, mStreamBufferSize);
|
|
|
|
if (!buf)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
mStreamBuffer = buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint32 bytesToRead =
|
|
|
|
PR_MIN(length, mStreamBufferSize - mStreamBufferByteCount);
|
|
|
|
|
|
|
|
PRUint32 amountRead = 0;
|
|
|
|
rv = input->Read(mStreamBuffer + mStreamBufferByteCount, bytesToRead,
|
|
|
|
&amountRead);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
if (amountRead == 0) {
|
|
|
|
NS_NOTREACHED("input->Read() returns no data, it's almost impossible "
|
|
|
|
"to get here");
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
mStreamBufferByteCount += amountRead;
|
|
|
|
length -= amountRead;
|
|
|
|
} else {
|
|
|
|
// No input, nothing to read. Set length to 0 so that we don't
|
|
|
|
// keep iterating through this outer loop any more.
|
|
|
|
|
|
|
|
length = 0;
|
2002-03-27 03:41:43 +00:00
|
|
|
}
|
2001-08-16 02:59:03 +00:00
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
// Temporary pointer to the beginning of the data we're writing as
|
|
|
|
// we loop and feed the plugin data.
|
|
|
|
char *ptrStreamBuffer = mStreamBuffer;
|
2002-03-27 03:41:43 +00:00
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
// it is possible plugin's NPP_Write() returns 0 byte consumed. We
|
|
|
|
// use zeroBytesWriteCount to count situation like this and break
|
|
|
|
// the loop
|
2002-03-27 03:41:43 +00:00
|
|
|
PRInt32 zeroBytesWriteCount = 0;
|
2004-04-11 05:33:17 +00:00
|
|
|
|
|
|
|
// mStreamBufferByteCount tells us how many bytes there are in the
|
|
|
|
// buffer. WriteReady returns to us how many bytes the plugin is
|
|
|
|
// ready to handle.
|
|
|
|
while (mStreamBufferByteCount > 0) {
|
|
|
|
PRInt32 numtowrite;
|
|
|
|
if (callbacks->writeready) {
|
2002-03-27 03:41:43 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(numtowrite,
|
2004-04-11 05:33:17 +00:00
|
|
|
CallNPP_WriteReadyProc(callbacks->writeready,
|
|
|
|
npp, &mNPStream),
|
|
|
|
mInst->fLibrary, mInst);
|
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY,
|
2004-04-11 05:33:17 +00:00
|
|
|
("NPP WriteReady called: this=%p, npp=%p, "
|
|
|
|
"return(towrite)=%d, url=%s\n",
|
|
|
|
this, npp, numtowrite, mNPStream.url));
|
|
|
|
|
2004-05-02 16:46:52 +00:00
|
|
|
if (!mStreamStarted) {
|
|
|
|
// The plugin called NPN_DestroyStream() from within
|
|
|
|
// NPP_WriteReady(), kill the stream.
|
|
|
|
|
|
|
|
return NS_BINDING_ABORTED;
|
|
|
|
}
|
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
// if WriteReady returned 0, the plugin is not ready to handle
|
|
|
|
// the data, suspend the stream (if it isn't already
|
|
|
|
// suspended).
|
2002-03-27 03:41:43 +00:00
|
|
|
if (numtowrite <= 0) {
|
2004-04-11 05:33:17 +00:00
|
|
|
if (!mIsSuspended) {
|
|
|
|
rv = SuspendRequest();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Break out of the inner loop, but keep going through the
|
|
|
|
// outer loop in case there's more data to read from the
|
|
|
|
// input stream.
|
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2004-04-11 05:33:17 +00:00
|
|
|
|
|
|
|
numtowrite = PR_MIN(numtowrite, mStreamBufferByteCount);
|
|
|
|
} else {
|
|
|
|
// if WriteReady is not supported by the plugin, just write
|
|
|
|
// the whole buffer
|
|
|
|
numtowrite = mStreamBufferByteCount;
|
2001-03-17 00:38:23 +00:00
|
|
|
}
|
2004-04-11 05:33:17 +00:00
|
|
|
|
|
|
|
PRInt32 writeCount = 0; // bytes consumed by plugin instance
|
2002-03-27 03:41:43 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(writeCount,
|
2004-04-11 05:33:17 +00:00
|
|
|
CallNPP_WriteProc(callbacks->write, npp,
|
|
|
|
&mNPStream, streamPosition,
|
|
|
|
numtowrite,
|
|
|
|
ptrStreamBuffer),
|
|
|
|
mInst->fLibrary, mInst);
|
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY,
|
2004-04-11 05:33:17 +00:00
|
|
|
("NPP Write called: this=%p, npp=%p, pos=%d, len=%d, "
|
|
|
|
"buf=%s, return(written)=%d, url=%s\n",
|
|
|
|
this, npp, streamPosition, numtowrite,
|
|
|
|
ptrStreamBuffer, writeCount, mNPStream.url));
|
|
|
|
|
2004-05-02 16:46:52 +00:00
|
|
|
if (!mStreamStarted) {
|
|
|
|
// The plugin called NPN_DestroyStream() from within
|
2004-05-03 21:57:11 +00:00
|
|
|
// NPP_Write(), kill the stream.
|
2004-05-02 16:46:52 +00:00
|
|
|
|
|
|
|
return NS_BINDING_ABORTED;
|
|
|
|
}
|
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
if (writeCount > 0) {
|
|
|
|
NS_ASSERTION(writeCount <= mStreamBufferByteCount,
|
|
|
|
"Plugin read past the end of the available data!");
|
|
|
|
|
|
|
|
writeCount = PR_MIN(writeCount, mStreamBufferByteCount);
|
|
|
|
mStreamBufferByteCount -= writeCount;
|
|
|
|
|
|
|
|
streamPosition += writeCount;
|
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
zeroBytesWriteCount = 0;
|
2004-04-11 05:33:17 +00:00
|
|
|
|
|
|
|
if (mStreamBufferByteCount > 0) {
|
|
|
|
// This alignment code is most likely bogus, but we'll leave
|
|
|
|
// it in for now in case it matters for some plugins on some
|
|
|
|
// architectures. Who knows...
|
|
|
|
if (writeCount % sizeof(PRWord)) {
|
|
|
|
// memmove will take care about alignment
|
|
|
|
memmove(mStreamBuffer, ptrStreamBuffer + writeCount,
|
|
|
|
mStreamBufferByteCount);
|
|
|
|
ptrStreamBuffer = mStreamBuffer;
|
|
|
|
} else {
|
|
|
|
// if aligned we can use ptrStreamBuffer += to eliminate
|
|
|
|
// memmove()
|
|
|
|
ptrStreamBuffer += writeCount;
|
|
|
|
}
|
2002-03-27 03:41:43 +00:00
|
|
|
}
|
2004-04-11 05:33:17 +00:00
|
|
|
} else if (writeCount == 0) {
|
|
|
|
// if NPP_Write() returns writeCount == 0 lets say 3 times in
|
|
|
|
// a row, suspend the request and continue feeding the plugin
|
|
|
|
// the data we got so far. Once that data is consumed, we'll
|
|
|
|
// resume the request.
|
|
|
|
if (mIsSuspended || ++zeroBytesWriteCount == 3) {
|
|
|
|
if (!mIsSuspended) {
|
|
|
|
rv = SuspendRequest();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Break out of the for loop, but keep going through the
|
|
|
|
// while loop in case there's more data to read from the
|
|
|
|
// input stream.
|
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2004-04-11 05:33:17 +00:00
|
|
|
} else {
|
|
|
|
// Something's really wrong, kill the stream.
|
2002-03-27 03:41:43 +00:00
|
|
|
rv = NS_ERROR_FAILURE;
|
2004-04-11 05:33:17 +00:00
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
break;
|
|
|
|
}
|
2004-04-11 05:33:17 +00:00
|
|
|
} // end of inner while loop
|
2001-05-17 08:27:38 +00:00
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
if (mStreamBufferByteCount && mStreamBuffer != ptrStreamBuffer) {
|
|
|
|
memmove(mStreamBuffer, ptrStreamBuffer, mStreamBufferByteCount);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (streamPosition != streamOffset) {
|
|
|
|
// The plugin didn't consume all available data, or consumed some
|
|
|
|
// of our cached data while we're pumping cached data. Adjust the
|
|
|
|
// plugin info's stream offset to match reality, except if the
|
|
|
|
// plugin info's stream offset was set by a re-entering
|
|
|
|
// NPN_RequestRead() call.
|
|
|
|
|
|
|
|
PRInt32 postWriteStreamPosition;
|
|
|
|
pluginInfo->GetStreamOffset(&postWriteStreamPosition);
|
|
|
|
|
|
|
|
if (postWriteStreamPosition == streamOffset) {
|
|
|
|
pluginInfo->SetStreamOffset(streamPosition);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP
|
2000-04-22 20:50:22 +00:00
|
|
|
ns4xPluginStreamListener::OnFileAvailable(nsIPluginStreamInfo* pluginInfo,
|
|
|
|
const char* fileName)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2001-04-28 02:24:29 +00:00
|
|
|
if(!mInst || !mInst->IsStarted())
|
2001-03-02 00:29:33 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
const NPPluginFuncs *callbacks = nsnull;
|
|
|
|
mInst->GetCallbacks(&callbacks);
|
2006-04-14 19:23:39 +00:00
|
|
|
if(!callbacks || !callbacks->asfile)
|
2001-03-02 00:29:33 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2002-09-12 19:12:56 +00:00
|
|
|
|
|
|
|
NPP npp;
|
|
|
|
mInst->GetNPP(&npp);
|
2001-03-02 00:29:33 +00:00
|
|
|
|
|
|
|
PRLibrary* lib = nsnull;
|
2001-04-28 02:24:29 +00:00
|
|
|
lib = mInst->fLibrary;
|
2001-03-02 00:29:33 +00:00
|
|
|
|
2001-04-28 02:24:29 +00:00
|
|
|
NS_TRY_SAFE_CALL_VOID(CallNPP_StreamAsFileProc(callbacks->asfile,
|
2001-03-02 00:29:33 +00:00
|
|
|
npp,
|
|
|
|
&mNPStream,
|
2002-06-01 00:56:38 +00:00
|
|
|
fileName), lib, mInst);
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
|
|
|
("NPP StreamAsFile called: this=%p, npp=%p, url=%s, file=%s\n",
|
|
|
|
this, npp, mNPStream.url, fileName));
|
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP
|
2000-04-22 20:50:22 +00:00
|
|
|
ns4xPluginStreamListener::OnStopBinding(nsIPluginStreamInfo* pluginInfo,
|
|
|
|
nsresult status)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2004-04-11 05:33:17 +00:00
|
|
|
StopDataPump();
|
|
|
|
|
2004-05-02 16:46:52 +00:00
|
|
|
if (NS_FAILED(status)) {
|
|
|
|
// The stream was destroyed, or died for some reason. Make sure we
|
|
|
|
// cancel the underlying request.
|
2004-04-11 05:33:17 +00:00
|
|
|
nsCOMPtr<nsI4xPluginStreamInfo> pluginInfo4x =
|
|
|
|
do_QueryInterface(mStreamInfo);
|
|
|
|
|
|
|
|
nsIRequest *request;
|
|
|
|
if (pluginInfo4x && (request = pluginInfo4x->GetRequest())) {
|
|
|
|
request->Cancel(status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-07-21 02:31:29 +00:00
|
|
|
if(!mInst || !mInst->IsStarted())
|
2001-03-02 00:29:33 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2001-07-24 20:48:36 +00:00
|
|
|
// check if the stream is of seekable type and later its destruction
|
2001-07-21 02:31:29 +00:00
|
|
|
// see bug 91140
|
|
|
|
nsresult rv = NS_OK;
|
2002-03-18 00:09:48 +00:00
|
|
|
if(mStreamType != nsPluginStreamType_Seek) {
|
|
|
|
NPReason reason = NPRES_DONE;
|
|
|
|
|
|
|
|
if (NS_FAILED(status))
|
|
|
|
reason = NPRES_NETWORK_ERR; // since the stream failed, we need to tell the plugin that
|
|
|
|
|
|
|
|
rv = CleanUpStream(reason);
|
|
|
|
}
|
2004-04-11 05:33:17 +00:00
|
|
|
|
2001-07-21 02:31:29 +00:00
|
|
|
if(rv != NPERR_NO_ERROR)
|
|
|
|
return NS_ERROR_FAILURE;
|
2001-05-17 08:27:38 +00:00
|
|
|
|
2001-03-02 00:29:33 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ns4xPluginStreamListener::GetStreamType(nsPluginStreamType *result)
|
|
|
|
{
|
|
|
|
*result = mStreamType;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
ns4xPluginStreamListener::Notify(nsITimer *aTimer)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aTimer == mDataPumpTimer, "Uh, wrong timer?");
|
|
|
|
|
|
|
|
PRInt32 oldStreamBufferByteCount = mStreamBufferByteCount;
|
|
|
|
|
|
|
|
nsresult rv = OnDataAvailable(mStreamInfo, nsnull, mStreamBufferByteCount);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
// We ran into an error, no need to keep firing this timer then.
|
|
|
|
|
|
|
|
aTimer->Cancel();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mStreamBufferByteCount != oldStreamBufferByteCount &&
|
|
|
|
((mStreamStarted && mStreamBufferByteCount < 1024) ||
|
|
|
|
mStreamBufferByteCount == 0)) {
|
|
|
|
// The plugin read some data and we've got less than 1024 bytes in
|
|
|
|
// our buffer (or its empty and the stream is already
|
|
|
|
// done). Resume the request so that we get more data off the
|
|
|
|
// network.
|
|
|
|
|
|
|
|
ResumeRequest();
|
|
|
|
|
|
|
|
// Necko will pump data now that we've resumed the request.
|
|
|
|
StopDataPump();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-07-24 20:48:36 +00:00
|
|
|
|
2007-03-16 23:53:16 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ns4xPluginStreamListener::StatusLine(const char* line)
|
|
|
|
{
|
|
|
|
mResponseHeaders.Append(line);
|
|
|
|
mResponseHeaders.Append('\n');
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
NS_IMETHODIMP
|
|
|
|
ns4xPluginStreamListener::NewResponseHeader(const char* headerName,
|
|
|
|
const char* headerValue)
|
|
|
|
{
|
|
|
|
mResponseHeaders.Append(headerName);
|
|
|
|
mResponseHeaders.Append(": ");
|
|
|
|
mResponseHeaders.Append(headerValue);
|
|
|
|
mResponseHeaders.Append('\n');
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2001-07-24 20:48:36 +00:00
|
|
|
nsInstanceStream::nsInstanceStream()
|
|
|
|
{
|
|
|
|
mNext = nsnull;
|
|
|
|
mPluginStreamListener = nsnull;
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2001-07-24 20:48:36 +00:00
|
|
|
nsInstanceStream::~nsInstanceStream()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2004-07-12 15:53:22 +00:00
|
|
|
NS_IMPL_ISUPPORTS3(ns4xPluginInstance, nsIPluginInstance, nsIScriptablePlugin,
|
2005-03-09 17:01:22 +00:00
|
|
|
nsIPluginInstanceInternal)
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2004-04-11 05:33:17 +00:00
|
|
|
ns4xPluginInstance::ns4xPluginInstance(NPPluginFuncs* callbacks,
|
|
|
|
PRLibrary* aLibrary)
|
2001-08-16 02:59:03 +00:00
|
|
|
: fCallbacks(callbacks)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2001-08-16 02:59:03 +00:00
|
|
|
NS_ASSERTION(fCallbacks != NULL, "null callbacks");
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
// Initialize the NPP structure.
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
fNPP.pdata = NULL;
|
|
|
|
fNPP.ndata = this;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
fLibrary = aLibrary;
|
|
|
|
mWindowless = PR_FALSE;
|
|
|
|
mTransparent = PR_FALSE;
|
|
|
|
mStarted = PR_FALSE;
|
|
|
|
mStreams = nsnull;
|
2002-03-25 23:42:32 +00:00
|
|
|
mCached = PR_FALSE;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2007-03-27 01:07:57 +00:00
|
|
|
#ifdef XP_MACOSX
|
|
|
|
#ifdef NP_NO_QUICKDRAW
|
|
|
|
mDrawingModel = NPDrawingModelCoreGraphics;
|
|
|
|
#else
|
|
|
|
mDrawingModel = NPDrawingModelQuickDraw;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
PLUGIN_LOG(PLUGIN_LOG_BASIC, ("ns4xPluginInstance ctor: this=%p\n",this));
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2004-04-11 05:33:17 +00:00
|
|
|
ns4xPluginInstance::~ns4xPluginInstance(void)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2001-08-16 02:59:03 +00:00
|
|
|
PLUGIN_LOG(PLUGIN_LOG_BASIC, ("ns4xPluginInstance dtor: this=%p\n",this));
|
|
|
|
|
2007-04-30 23:52:44 +00:00
|
|
|
#if defined (MOZ_WIDGET_GTK2)
|
2000-07-11 21:44:39 +00:00
|
|
|
if (mXtBin)
|
|
|
|
gtk_widget_destroy(mXtBin);
|
|
|
|
#endif
|
2001-07-24 20:48:36 +00:00
|
|
|
|
|
|
|
// clean the stream list if any
|
|
|
|
for(nsInstanceStream *is = mStreams; is != nsnull;) {
|
|
|
|
nsInstanceStream * next = is->mNext;
|
|
|
|
delete is;
|
|
|
|
is = next;
|
|
|
|
}
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2000-10-27 22:05:07 +00:00
|
|
|
PRBool
|
2004-04-11 05:33:17 +00:00
|
|
|
ns4xPluginInstance::IsStarted(void)
|
2000-10-27 22:05:07 +00:00
|
|
|
{
|
2001-08-16 02:59:03 +00:00
|
|
|
return mStarted;
|
2000-10-27 22:05:07 +00:00
|
|
|
}
|
1999-07-07 20:18:27 +00:00
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2000-04-22 20:50:22 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::Initialize(nsIPluginInstancePeer* peer)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2001-08-16 02:59:03 +00:00
|
|
|
PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Initialize this=%p\n",this));
|
|
|
|
|
2007-04-30 23:52:44 +00:00
|
|
|
#if defined (MOZ_WIDGET_GTK2)
|
2000-07-11 21:44:39 +00:00
|
|
|
mXtBin = nsnull;
|
2000-04-22 21:47:01 +00:00
|
|
|
#endif
|
1999-07-07 20:18:27 +00:00
|
|
|
return InitializePlugin(peer);
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
2000-04-22 20:50:22 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::GetPeer(nsIPluginInstancePeer* *resultingPeer)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2000-07-11 21:44:39 +00:00
|
|
|
*resultingPeer = mPeer;
|
|
|
|
NS_IF_ADDREF(*resultingPeer);
|
2000-04-22 20:50:22 +00:00
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::Start(void)
|
|
|
|
{
|
2001-08-16 02:59:03 +00:00
|
|
|
PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Start this=%p\n",this));
|
2000-04-22 20:50:22 +00:00
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
if(mStarted)
|
|
|
|
return NS_OK;
|
|
|
|
else
|
2000-07-11 21:44:39 +00:00
|
|
|
return InitializePlugin(mPeer);
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::Stop(void)
|
|
|
|
{
|
2001-08-16 02:59:03 +00:00
|
|
|
PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Stop this=%p\n",this));
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
NPError error;
|
2000-07-11 21:44:39 +00:00
|
|
|
|
2005-06-18 06:06:45 +00:00
|
|
|
// Make sure the plugin didn't leave popups enabled.
|
|
|
|
if (mPopupStates.Count() > 0) {
|
2005-11-28 23:56:44 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = GetDOMWindow();
|
2005-06-18 06:06:45 +00:00
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
if (window) {
|
|
|
|
window->PopPopupControlState(openAbused);
|
2005-06-18 06:06:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-30 23:52:44 +00:00
|
|
|
#if defined (MOZ_WIDGET_GTK2)
|
2002-04-11 03:27:00 +00:00
|
|
|
if (mXtBin) {
|
2000-07-11 21:44:39 +00:00
|
|
|
gtk_widget_destroy(mXtBin);
|
2002-04-11 03:27:00 +00:00
|
|
|
mXtBin = 0;
|
|
|
|
}
|
2000-07-11 21:44:39 +00:00
|
|
|
#endif
|
|
|
|
|
2001-02-02 23:48:17 +00:00
|
|
|
if(!mStarted)
|
|
|
|
return NS_OK;
|
2000-07-11 21:44:39 +00:00
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
if (fCallbacks->destroy == NULL)
|
2000-04-22 20:50:22 +00:00
|
|
|
return NS_ERROR_FAILURE; // XXX right error?
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2002-03-27 03:41:43 +00:00
|
|
|
NPSavedData *sdata = 0;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-07-24 20:48:36 +00:00
|
|
|
// clean up open streams
|
|
|
|
for(nsInstanceStream *is = mStreams; is != nsnull;) {
|
2002-03-13 04:24:45 +00:00
|
|
|
ns4xPluginStreamListener * listener = is->mPluginStreamListener;
|
2001-07-24 20:48:36 +00:00
|
|
|
|
|
|
|
nsInstanceStream *next = is->mNext;
|
|
|
|
delete is;
|
|
|
|
is = next;
|
|
|
|
mStreams = is;
|
2002-03-13 04:24:45 +00:00
|
|
|
|
|
|
|
// Clean up our stream after removing it from the list because
|
|
|
|
// it may be released and destroyed at this point.
|
|
|
|
if(listener)
|
|
|
|
listener->CleanUpStream(NPRES_USER_BREAK);
|
2001-07-24 20:48:36 +00:00
|
|
|
}
|
|
|
|
|
2002-06-01 00:56:38 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(error, CallNPP_DestroyProc(fCallbacks->destroy, &fNPP, &sdata), fLibrary, this);
|
2000-09-29 00:46:18 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
2001-11-20 02:17:53 +00:00
|
|
|
("NPP Destroy called: this=%p, npp=%p, return=%d\n", this, &fNPP, error));
|
2001-08-16 02:59:03 +00:00
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
mStarted = PR_FALSE;
|
2001-12-10 01:22:29 +00:00
|
|
|
|
2004-07-12 15:53:22 +00:00
|
|
|
nsJSNPRuntime::OnPluginDestroy(&fNPP);
|
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
if(error != NPERR_NO_ERROR)
|
2000-04-22 20:50:22 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
1999-07-07 20:18:27 +00:00
|
|
|
else
|
2000-04-22 20:50:22 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
already_AddRefed<nsPIDOMWindow>
|
2005-06-18 06:06:45 +00:00
|
|
|
ns4xPluginInstance::GetDOMWindow()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsPIPluginInstancePeer> pp (do_QueryInterface(mPeer));
|
|
|
|
if (!pp) {
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIPluginInstanceOwner> owner;
|
|
|
|
pp->GetOwner(getter_AddRefs(owner));
|
|
|
|
|
|
|
|
if (!owner) {
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
owner->GetDocument(getter_AddRefs(doc));
|
|
|
|
|
|
|
|
if (!doc) {
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
2005-12-02 00:50:19 +00:00
|
|
|
nsPIDOMWindow *window = doc->GetWindow();
|
|
|
|
NS_IF_ADDREF(window);
|
|
|
|
|
|
|
|
return window;
|
2005-06-18 06:06:45 +00:00
|
|
|
}
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
nsresult ns4xPluginInstance::InitializePlugin(nsIPluginInstancePeer* peer)
|
|
|
|
{
|
2001-12-11 15:53:07 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(peer);
|
|
|
|
|
2002-06-14 20:45:29 +00:00
|
|
|
nsCOMPtr<nsIPluginTagInfo2> taginfo = do_QueryInterface(peer);
|
2001-12-11 15:53:07 +00:00
|
|
|
NS_ENSURE_TRUE(taginfo, NS_ERROR_NO_INTERFACE);
|
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
PRUint16 count = 0;
|
|
|
|
const char* const* names = nsnull;
|
|
|
|
const char* const* values = nsnull;
|
2001-12-12 18:50:16 +00:00
|
|
|
nsPluginTagType tagtype;
|
|
|
|
nsresult rv = taginfo->GetTagType(&tagtype);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
// Note: If we failed to get the tag type, we may be a full page plugin, so no arguments
|
|
|
|
rv = taginfo->GetAttributes(count, names, values);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// nsPluginTagType_Object or Applet may also have PARAM tags
|
|
|
|
// Note: The arrays handed back by GetParameters() are
|
2005-11-25 21:57:13 +00:00
|
|
|
// crafted specially to be directly behind the arrays from GetAttributes()
|
2003-03-24 04:15:34 +00:00
|
|
|
// with a null entry as a separator. This is for 4.x backwards compatibility!
|
2001-12-12 18:50:16 +00:00
|
|
|
// see bug 111008 for details
|
|
|
|
if (tagtype != nsPluginTagType_Embed) {
|
|
|
|
PRUint16 pcount = 0;
|
|
|
|
const char* const* pnames = nsnull;
|
|
|
|
const char* const* pvalues = nsnull;
|
|
|
|
if (NS_SUCCEEDED(taginfo->GetParameters(pcount, pnames, pvalues))) {
|
|
|
|
NS_ASSERTION(nsnull == values[count], "attribute/parameter array not setup correctly for 4.x plugins");
|
2001-12-14 03:52:12 +00:00
|
|
|
if (pcount)
|
|
|
|
count += ++pcount; //if it's all setup correctly, then all we need is to change the count (attrs + PARAM/blank + params)
|
2001-12-12 18:50:16 +00:00
|
|
|
}
|
2001-12-11 15:53:07 +00:00
|
|
|
}
|
2001-09-24 04:35:02 +00:00
|
|
|
}
|
2001-12-11 15:53:07 +00:00
|
|
|
|
|
|
|
NS_ENSURE_TRUE(fCallbacks->newp, NS_ERROR_FAILURE);
|
2000-04-22 20:50:22 +00:00
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
// XXX Note that the NPPluginType_* enums were crafted to be
|
|
|
|
// backward compatible...
|
2000-04-22 20:50:22 +00:00
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
nsPluginMode mode;
|
|
|
|
nsMIMEType mimetype;
|
2001-12-11 15:53:07 +00:00
|
|
|
NPError error;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2002-06-14 20:45:29 +00:00
|
|
|
peer->GetMode(&mode);
|
|
|
|
peer->GetMIMEType(&mimetype);
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2003-01-31 19:37:32 +00:00
|
|
|
// Some older versions of Flash have a bug in them
|
|
|
|
// that causes the stack to become currupt if we
|
|
|
|
// pass swliveconect=1 in the NPP_NewProc arrays.
|
|
|
|
// See bug 149336 (UNIX), bug 186287 (Mac)
|
|
|
|
//
|
|
|
|
// The code below disables the attribute unless
|
|
|
|
// the environment variable:
|
|
|
|
// MOZILLA_PLUGIN_DISABLE_FLASH_SWLIVECONNECT_HACK
|
|
|
|
// is set.
|
|
|
|
//
|
|
|
|
// It is okay to disable this attribute because
|
|
|
|
// back in 4.x, scripting required liveconnect to
|
|
|
|
// start Java which was slow. Scripting no longer
|
|
|
|
// requires starting Java and is quick plus controled
|
|
|
|
// from the browser, so Flash now ignores this attribute.
|
|
|
|
//
|
|
|
|
// This code can not be put at the time of creating
|
|
|
|
// the array because we may need to examine the
|
|
|
|
// stream header to determine we want Flash.
|
|
|
|
|
2002-06-25 01:29:59 +00:00
|
|
|
static const char flashMimeType[] = "application/x-shockwave-flash";
|
|
|
|
static const char blockedParam[] = "swliveconnect";
|
|
|
|
if (count && !PL_strcasecmp(mimetype, flashMimeType)) {
|
|
|
|
static int cachedDisableHack = 0;
|
|
|
|
if (!cachedDisableHack) {
|
|
|
|
if (PR_GetEnv("MOZILLA_PLUGIN_DISABLE_FLASH_SWLIVECONNECT_HACK"))
|
|
|
|
cachedDisableHack = -1;
|
|
|
|
else
|
|
|
|
cachedDisableHack = 1;
|
|
|
|
}
|
|
|
|
if (cachedDisableHack > 0) {
|
|
|
|
for (PRUint16 i=0; i<count; i++) {
|
|
|
|
if (!PL_strcasecmp(names[i], blockedParam)) {
|
|
|
|
// BIG FAT WARNIG:
|
|
|
|
// I'm ugly casting |const char*| to |char*| and altering it
|
|
|
|
// because I know we do malloc it values in
|
|
|
|
// http://bonsai.mozilla.org/cvsblame.cgi?file=mozilla/layout/html/base/src/nsObjectFrame.cpp&rev=1.349&root=/cvsroot#3020
|
|
|
|
// and free it at line #2096, so it couldn't be a const ptr to string literal
|
|
|
|
char *val = (char*) values[i];
|
|
|
|
if (val && *val) {
|
2005-11-25 08:16:51 +00:00
|
|
|
// we cannot just *val=0, it won't be free properly in such case
|
2002-06-25 01:29:59 +00:00
|
|
|
val[0] = '0';
|
|
|
|
val[1] = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-20 00:17:28 +00:00
|
|
|
// Assign mPeer now and mark this instance as started before calling NPP_New
|
|
|
|
// because the plugin may call other NPAPI functions, like NPN_GetURLNotify,
|
|
|
|
// that assume these are set before returning. If the plugin returns failure,
|
|
|
|
// we'll clear them out below.
|
|
|
|
mPeer = peer;
|
|
|
|
mStarted = PR_TRUE;
|
|
|
|
|
2000-09-14 06:13:56 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(error, CallNPP_NewProc(fCallbacks->newp,
|
|
|
|
(char *)mimetype,
|
|
|
|
&fNPP,
|
|
|
|
(PRUint16)mode,
|
|
|
|
count,
|
|
|
|
(char**)names,
|
|
|
|
(char**)values,
|
2002-06-01 00:56:38 +00:00
|
|
|
NULL), fLibrary,this);
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
|
|
|
("NPP New called: this=%p, npp=%p, mime=%s, mode=%d, argc=%d, return=%d\n",
|
2001-11-20 02:17:53 +00:00
|
|
|
this, &fNPP, mimetype, mode, count, error));
|
2001-08-16 02:59:03 +00:00
|
|
|
|
2002-09-20 00:17:28 +00:00
|
|
|
if(error != NPERR_NO_ERROR) {
|
|
|
|
// since the plugin returned failure, these should not be set
|
|
|
|
mPeer = nsnull;
|
|
|
|
mStarted = PR_FALSE;
|
|
|
|
|
2002-06-14 20:45:29 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2002-09-20 00:17:28 +00:00
|
|
|
}
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2002-06-14 20:45:29 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::Destroy(void)
|
|
|
|
{
|
2001-08-16 02:59:03 +00:00
|
|
|
PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Destroy this=%p\n",this));
|
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
// destruction is handled in the Stop call
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::SetWindow(nsPluginWindow* window)
|
|
|
|
{
|
2000-04-22 20:50:22 +00:00
|
|
|
// XXX 4.x plugins don't want a SetWindow(NULL).
|
2000-07-11 21:44:39 +00:00
|
|
|
if (!window || !mStarted)
|
2000-04-22 20:50:22 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
NPError error;
|
2002-01-16 23:57:10 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
// It would be nice if this was all moved to
|
|
|
|
// nsPluginNativeWindowGtk2::CallSetWindow or nsWindow or somewhere else?
|
|
|
|
#if defined (MOZ_WIDGET_GTK2)
|
|
|
|
if (window->type == nsPluginWindowType_Window) {
|
|
|
|
PRBool isXembed = PR_FALSE;
|
|
|
|
// bug 108337, flash plugin on linux doesn't like window->width <= 0
|
|
|
|
if ((PRInt32) window->width <= 0 || (PRInt32) window->height <= 0)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
// We need to test if this is an xembed window before doing checks
|
|
|
|
// below, as they might be used on the first pass or on later passes
|
|
|
|
// when we resize the plugin window.
|
|
|
|
GdkWindow *win = gdk_window_lookup((XID)window->window);
|
|
|
|
if (!win)
|
|
|
|
return NS_ERROR_FAILURE;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
gpointer user_data = nsnull;
|
|
|
|
gdk_window_get_user_data(win, &user_data);
|
|
|
|
if (user_data && GTK_IS_WIDGET(user_data)) {
|
|
|
|
GtkWidget* widget = GTK_WIDGET(user_data);
|
2000-07-11 21:44:39 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
if (GTK_IS_SOCKET(widget))
|
|
|
|
isXembed = PR_TRUE;
|
2006-02-14 08:13:51 +00:00
|
|
|
}
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
// Fill out the ws_info data.
|
|
|
|
// (ws_info should be non-null but check just in case.)
|
|
|
|
if (!mXtBin && window->ws_info) {
|
|
|
|
|
|
|
|
NPSetWindowCallbackStruct* ws =
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<NPSetWindowCallbackStruct*>(window->ws_info);
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
if (!isXembed) {
|
2000-10-28 22:17:53 +00:00
|
|
|
#ifdef NS_DEBUG
|
2007-07-03 03:29:47 +00:00
|
|
|
printf("About to create new xtbin of %i X %i from %p...\n",
|
|
|
|
window->width, window->height, (void*)win);
|
2000-10-28 22:17:53 +00:00
|
|
|
#endif
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2002-04-11 03:27:00 +00:00
|
|
|
#if 0
|
2007-07-03 03:29:47 +00:00
|
|
|
// if we destroyed the plugin when we left the page, we could remove this
|
|
|
|
// code (i believe) the problem here is that the window gets destroyed when
|
|
|
|
// its parent, etc does by changing a page the plugin instance is being
|
|
|
|
// held on to, so when we return to the page, we have a mXtBin, but it is
|
|
|
|
// in a not-so-good state.
|
|
|
|
// --
|
|
|
|
// this is lame. we shouldn't be destroying this everytime, but I can't find
|
|
|
|
// a good way to tell if we need to destroy/recreate the xtbin or not
|
|
|
|
// what if the plugin wants to change the window and not just resize it??
|
|
|
|
// (pav)
|
|
|
|
|
|
|
|
if (mXtBin) {
|
|
|
|
gtk_widget_destroy(mXtBin);
|
|
|
|
mXtBin = NULL;
|
|
|
|
}
|
2000-07-11 21:44:39 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
if (!mXtBin) {
|
|
|
|
mXtBin = gtk_xtbin_new(win, 0);
|
|
|
|
// Check to see if creating mXtBin failed for some reason.
|
|
|
|
// if it did, we can't go any further.
|
|
|
|
if (!mXtBin)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2000-07-11 21:44:39 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
gtk_widget_set_usize(mXtBin, window->width, window->height);
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2000-07-11 21:44:39 +00:00
|
|
|
#ifdef NS_DEBUG
|
2007-07-03 03:29:47 +00:00
|
|
|
printf("About to show xtbin(%p)...\n", (void*)mXtBin); fflush(NULL);
|
2000-07-11 21:44:39 +00:00
|
|
|
#endif
|
2007-07-03 03:29:47 +00:00
|
|
|
gtk_widget_show(mXtBin);
|
2000-07-11 21:44:39 +00:00
|
|
|
#ifdef NS_DEBUG
|
2007-07-03 03:29:47 +00:00
|
|
|
printf("completed gtk_widget_show(%p)\n", (void*)mXtBin); fflush(NULL);
|
2000-07-11 21:44:39 +00:00
|
|
|
#endif
|
2007-07-03 03:29:47 +00:00
|
|
|
}
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
// fill in window info structure
|
|
|
|
ws->type = 0; // OK, that was a guess!!
|
2003-03-04 03:58:43 +00:00
|
|
|
#ifdef MOZ_X11
|
2007-07-03 03:29:47 +00:00
|
|
|
ws->depth = gdk_window_get_visual(win)->depth;
|
|
|
|
if (!isXembed)
|
|
|
|
ws->display = GTK_XTBIN(mXtBin)->xtdisplay;
|
|
|
|
else
|
|
|
|
ws->display = GDK_WINDOW_XDISPLAY(win);
|
|
|
|
ws->visual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(win));
|
|
|
|
ws->colormap = GDK_COLORMAP_XCOLORMAP(gdk_window_get_colormap(win));
|
|
|
|
|
|
|
|
XFlush(ws->display);
|
2003-02-28 02:34:09 +00:00
|
|
|
#endif
|
2007-07-03 03:29:47 +00:00
|
|
|
} // !mXtBin
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
if (!mXtBin && !isXembed)
|
|
|
|
return NS_ERROR_FAILURE;
|
2001-09-28 01:51:06 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
if (!isXembed) {
|
|
|
|
// And now point the NPWindow structures window
|
|
|
|
// to the actual X window
|
|
|
|
window->window = (nsPluginPort *)GTK_XTBIN(mXtBin)->xtwindow;
|
2003-09-16 01:44:41 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
gtk_xtbin_resize(mXtBin, window->width, window->height);
|
|
|
|
}
|
2003-09-16 01:44:41 +00:00
|
|
|
}
|
2001-12-10 01:22:29 +00:00
|
|
|
|
|
|
|
#endif // MOZ_WIDGET
|
2000-04-22 20:50:22 +00:00
|
|
|
|
|
|
|
if (fCallbacks->setwindow) {
|
|
|
|
// XXX Turns out that NPPluginWindow and NPWindow are structurally
|
|
|
|
// identical (on purpose!), so there's no need to make a copy.
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::SetWindow (about to call it) this=%p\n",this));
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2000-09-14 06:13:56 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(error, CallNPP_SetWindowProc(fCallbacks->setwindow,
|
2000-04-22 20:50:22 +00:00
|
|
|
&fNPP,
|
2002-06-01 00:56:38 +00:00
|
|
|
(NPWindow*) window), fLibrary, this);
|
|
|
|
|
2000-09-29 00:46:18 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
|
|
|
("NPP SetWindow called: this=%p, [x=%d,y=%d,w=%d,h=%d], clip[t=%d,b=%d,l=%d,r=%d], return=%d\n",
|
2002-03-13 04:24:45 +00:00
|
|
|
this, window->x, window->y, window->width, window->height,
|
2001-08-16 02:59:03 +00:00
|
|
|
window->clipRect.top, window->clipRect.bottom, window->clipRect.left, window->clipRect.right, error));
|
2000-04-22 20:50:22 +00:00
|
|
|
|
|
|
|
// XXX In the old code, we'd just ignore any errors coming
|
|
|
|
// back from the plugin's SetWindow(). Is this the correct
|
|
|
|
// behavior?!?
|
2002-11-06 01:24:57 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/* NOTE: the caller must free the stream listener */
|
2002-03-13 04:24:45 +00:00
|
|
|
// Create a normal stream, one without a urlnotify callback
|
1999-07-07 20:18:27 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::NewStream(nsIPluginStreamListener** listener)
|
|
|
|
{
|
2002-04-04 15:23:35 +00:00
|
|
|
return NewNotifyStream(listener, nsnull, PR_FALSE, nsnull);
|
2001-07-24 20:48:36 +00:00
|
|
|
}
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2002-03-13 04:24:45 +00:00
|
|
|
// Create a stream that will notify when complete
|
|
|
|
nsresult ns4xPluginInstance::NewNotifyStream(nsIPluginStreamListener** listener,
|
|
|
|
void* notifyData,
|
2002-04-04 15:23:35 +00:00
|
|
|
PRBool aCallNotify,
|
|
|
|
const char* aURL)
|
2001-07-24 20:48:36 +00:00
|
|
|
{
|
2002-04-04 15:23:35 +00:00
|
|
|
ns4xPluginStreamListener* stream = new ns4xPluginStreamListener(this, notifyData, aURL);
|
2002-03-13 04:24:45 +00:00
|
|
|
NS_ENSURE_TRUE(stream, NS_ERROR_OUT_OF_MEMORY);
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-07-24 20:48:36 +00:00
|
|
|
// add it to the list
|
|
|
|
nsInstanceStream * is = new nsInstanceStream();
|
2002-03-13 04:24:45 +00:00
|
|
|
NS_ENSURE_TRUE(is, NS_ERROR_OUT_OF_MEMORY);
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-07-24 20:48:36 +00:00
|
|
|
is->mNext = mStreams;
|
|
|
|
is->mPluginStreamListener = stream;
|
|
|
|
mStreams = is;
|
2002-03-13 04:24:45 +00:00
|
|
|
stream->SetCallNotify(aCallNotify); // set flag in stream to call URLNotify
|
2001-07-24 20:48:36 +00:00
|
|
|
|
|
|
|
NS_ADDREF(stream); // Stabilize
|
|
|
|
|
|
|
|
nsresult res = stream->QueryInterface(kIPluginStreamListenerIID, (void**)listener);
|
|
|
|
|
|
|
|
// Destabilize and avoid leaks. Avoid calling delete <interface pointer>
|
|
|
|
NS_RELEASE(stream);
|
|
|
|
|
|
|
|
return res;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP ns4xPluginInstance::Print(nsPluginPrint* platformPrint)
|
|
|
|
{
|
2001-09-18 02:11:09 +00:00
|
|
|
NS_ENSURE_TRUE(platformPrint, NS_ERROR_NULL_POINTER);
|
|
|
|
|
|
|
|
NPPrint* thePrint = (NPPrint *)platformPrint;
|
|
|
|
|
2001-12-08 01:13:05 +00:00
|
|
|
// to be compatible with the older SDK versions and to match what
|
|
|
|
// 4.x and other browsers do, overwrite |window.type| field with one
|
|
|
|
// more copy of |platformPrint|. See bug 113264
|
|
|
|
if(fCallbacks) {
|
|
|
|
PRUint16 sdkmajorversion = (fCallbacks->version & 0xff00)>>8;
|
|
|
|
PRUint16 sdkminorversion = fCallbacks->version & 0x00ff;
|
|
|
|
if((sdkmajorversion == 0) && (sdkminorversion < 11)) {
|
|
|
|
// Let's copy platformPrint bytes over to where it was supposed to be
|
|
|
|
// in older versions -- four bytes towards the beginning of the struct
|
|
|
|
// but we should be careful about possible misalignments
|
|
|
|
if(sizeof(NPWindowType) >= sizeof(void *)) {
|
|
|
|
void* source = thePrint->print.embedPrint.platformPrint;
|
|
|
|
void** destination = (void **)&(thePrint->print.embedPrint.window.type);
|
|
|
|
*destination = source;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
NS_ASSERTION(PR_FALSE, "Incompatible OS for assignment");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-06 14:51:52 +00:00
|
|
|
if(fCallbacks->print) {
|
|
|
|
NS_TRY_SAFE_CALL_VOID(CallNPP_PrintProc(fCallbacks->print,
|
|
|
|
&fNPP,
|
|
|
|
thePrint), fLibrary, this);
|
|
|
|
}
|
2001-09-18 02:11:09 +00:00
|
|
|
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
|
|
|
("NPP PrintProc called: this=%p, pDC=%p, [x=%d,y=%d,w=%d,h=%d], clip[t=%d,b=%d,l=%d,r=%d]\n",
|
|
|
|
this,
|
|
|
|
platformPrint->print.embedPrint.platformPrint,
|
|
|
|
platformPrint->print.embedPrint.window.x,
|
|
|
|
platformPrint->print.embedPrint.window.y,
|
|
|
|
platformPrint->print.embedPrint.window.width,
|
|
|
|
platformPrint->print.embedPrint.window.height,
|
|
|
|
platformPrint->print.embedPrint.window.clipRect.top,
|
|
|
|
platformPrint->print.embedPrint.window.clipRect.bottom,
|
|
|
|
platformPrint->print.embedPrint.window.clipRect.left,
|
|
|
|
platformPrint->print.embedPrint.window.clipRect.right));
|
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP ns4xPluginInstance::HandleEvent(nsPluginEvent* event, PRBool* handled)
|
|
|
|
{
|
2001-03-12 02:07:15 +00:00
|
|
|
if(!mStarted)
|
|
|
|
return NS_OK;
|
|
|
|
|
2001-07-20 19:36:37 +00:00
|
|
|
if (event == nsnull)
|
2001-02-02 23:48:17 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2002-01-15 22:45:56 +00:00
|
|
|
PRInt16 result = 0;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2002-11-06 01:24:57 +00:00
|
|
|
if (fCallbacks->event) {
|
2005-11-10 17:45:59 +00:00
|
|
|
#ifdef XP_MACOSX
|
2002-11-06 01:24:57 +00:00
|
|
|
result = CallNPP_HandleEventProc(fCallbacks->event,
|
|
|
|
&fNPP,
|
|
|
|
(void*) event->event);
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2007-07-03 03:29:47 +00:00
|
|
|
#elif defined(XP_WIN) || defined(XP_OS2)
|
2000-04-22 20:50:22 +00:00
|
|
|
NPEvent npEvent;
|
|
|
|
npEvent.event = event->event;
|
|
|
|
npEvent.wParam = event->wParam;
|
|
|
|
npEvent.lParam = event->lParam;
|
2000-09-14 06:13:56 +00:00
|
|
|
|
2002-01-15 22:45:56 +00:00
|
|
|
NS_TRY_SAFE_CALL_RETURN(result, CallNPP_HandleEventProc(fCallbacks->event,
|
2000-04-22 20:50:22 +00:00
|
|
|
&fNPP,
|
2002-06-01 00:56:38 +00:00
|
|
|
(void*)&npEvent), fLibrary, this);
|
2007-07-03 03:29:47 +00:00
|
|
|
|
|
|
|
#else // MOZ_X11 or other
|
|
|
|
result = CallNPP_HandleEventProc(fCallbacks->event,
|
|
|
|
&fNPP,
|
|
|
|
(void*)&event->event);
|
1999-07-07 20:18:27 +00:00
|
|
|
#endif
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY,
|
|
|
|
("NPP HandleEvent called: this=%p, npp=%p, event=%d, return=%d\n",
|
2002-01-15 22:45:56 +00:00
|
|
|
this, &fNPP, event->event, result));
|
2001-08-16 02:59:03 +00:00
|
|
|
|
2002-01-15 22:45:56 +00:00
|
|
|
*handled = result;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2003-02-27 01:47:53 +00:00
|
|
|
nsresult ns4xPluginInstance::GetValueInternal(NPPVariable variable, void* value)
|
|
|
|
{
|
|
|
|
nsresult res = NS_OK;
|
|
|
|
if(fCallbacks->getvalue && mStarted) {
|
|
|
|
|
|
|
|
NS_TRY_SAFE_CALL_RETURN(res,
|
|
|
|
CallNPP_GetValueProc(fCallbacks->getvalue,
|
|
|
|
&fNPP,
|
|
|
|
variable,
|
|
|
|
value),
|
|
|
|
fLibrary, this);
|
|
|
|
NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
|
|
|
|
("NPP GetValue called: this=%p, npp=%p, var=%d, value=%d, return=%d\n",
|
|
|
|
this, &fNPP, variable, value, res));
|
2003-10-21 22:11:20 +00:00
|
|
|
|
|
|
|
#ifdef XP_OS2
|
|
|
|
/* Query interface for legacy Flash plugin */
|
|
|
|
if (res == NS_OK && variable == NPPVpluginScriptableInstance)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsILegacyPluginWrapperOS2> wrapper =
|
|
|
|
do_GetService(NS_LEGACY_PLUGIN_WRAPPER_CONTRACTID, &res);
|
|
|
|
if (res == NS_OK)
|
|
|
|
{
|
|
|
|
nsIID *iid = nsnull;
|
|
|
|
res = CallNPP_GetValueProc(fCallbacks->getvalue, &fNPP,
|
|
|
|
NPPVpluginScriptableIID, (void *)&iid);
|
|
|
|
if (res == NS_OK)
|
|
|
|
res = wrapper->MaybeWrap(*iid, *(nsISupports**)value,
|
|
|
|
(nsISupports**)value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2003-02-27 01:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2004-04-11 05:33:17 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::GetValue(nsPluginInstanceVariable variable,
|
|
|
|
void *value)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
2001-04-03 22:49:38 +00:00
|
|
|
nsresult res = NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2002-03-25 23:42:32 +00:00
|
|
|
switch (variable) {
|
1999-07-07 20:18:27 +00:00
|
|
|
case nsPluginInstanceVariable_WindowlessBool:
|
|
|
|
*(PRBool *)value = mWindowless;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case nsPluginInstanceVariable_TransparentBool:
|
|
|
|
*(PRBool *)value = mTransparent;
|
|
|
|
break;
|
|
|
|
|
2002-03-25 23:42:32 +00:00
|
|
|
case nsPluginInstanceVariable_DoCacheBool:
|
|
|
|
*(PRBool *)value = mCached;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case nsPluginInstanceVariable_CallSetWindowAfterDestroyBool:
|
|
|
|
*(PRBool *)value = 0; // not supported for 4.x plugins
|
|
|
|
break;
|
|
|
|
|
2007-03-27 01:07:57 +00:00
|
|
|
#ifdef XP_MACOSX
|
|
|
|
case nsPluginInstanceVariable_DrawingModel:
|
|
|
|
*(NPDrawingModel*)value = mDrawingModel;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
1999-07-07 20:18:27 +00:00
|
|
|
default:
|
2003-02-27 01:47:53 +00:00
|
|
|
res = GetValueInternal((NPPVariable)variable, value);
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-04-03 22:49:38 +00:00
|
|
|
return res;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
nsresult ns4xPluginInstance::GetNPP(NPP* aNPP)
|
|
|
|
{
|
2001-04-03 22:49:38 +00:00
|
|
|
if(aNPP != nsnull)
|
|
|
|
*aNPP = &fNPP;
|
|
|
|
else
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-04-03 22:49:38 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
1999-07-07 20:18:27 +00:00
|
|
|
nsresult ns4xPluginInstance::GetCallbacks(const NPPluginFuncs ** aCallbacks)
|
|
|
|
{
|
2001-04-03 22:49:38 +00:00
|
|
|
if(aCallbacks != nsnull)
|
|
|
|
*aCallbacks = fCallbacks;
|
|
|
|
else
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
1999-07-07 20:18:27 +00:00
|
|
|
|
2001-04-03 22:49:38 +00:00
|
|
|
return NS_OK;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2007-03-20 02:35:56 +00:00
|
|
|
NPError ns4xPluginInstance::SetWindowless(PRBool aWindowless)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
|
|
|
mWindowless = aWindowless;
|
2007-03-20 02:35:56 +00:00
|
|
|
return NPERR_NO_ERROR;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
2007-03-20 02:35:56 +00:00
|
|
|
NPError ns4xPluginInstance::SetTransparent(PRBool aTransparent)
|
1999-07-07 20:18:27 +00:00
|
|
|
{
|
|
|
|
mTransparent = aTransparent;
|
2007-03-20 02:35:56 +00:00
|
|
|
return NPERR_NO_ERROR;
|
1999-07-07 20:18:27 +00:00
|
|
|
}
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2007-03-27 01:07:57 +00:00
|
|
|
#ifdef XP_MACOSX
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
void ns4xPluginInstance::SetDrawingModel(NPDrawingModel aModel)
|
|
|
|
{
|
|
|
|
mDrawingModel = aModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
NPDrawingModel ns4xPluginInstance::GetDrawingModel()
|
|
|
|
{
|
|
|
|
return mDrawingModel;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
2001-04-03 22:49:38 +00:00
|
|
|
/* readonly attribute nsQIResult scriptablePeer; */
|
2004-04-11 05:33:17 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::GetScriptablePeer(void * *aScriptablePeer)
|
2001-04-03 22:49:38 +00:00
|
|
|
{
|
|
|
|
if (!aScriptablePeer)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
*aScriptablePeer = nsnull;
|
2003-02-27 01:47:53 +00:00
|
|
|
return GetValueInternal(NPPVpluginScriptableInstance, aScriptablePeer);
|
2001-04-03 22:49:38 +00:00
|
|
|
}
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2001-08-16 02:59:03 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////
|
2001-04-03 22:49:38 +00:00
|
|
|
/* readonly attribute nsIIDPtr scriptableInterface; */
|
2004-04-11 05:33:17 +00:00
|
|
|
NS_IMETHODIMP ns4xPluginInstance::GetScriptableInterface(nsIID * *aScriptableInterface)
|
2001-04-03 22:49:38 +00:00
|
|
|
{
|
|
|
|
if (!aScriptableInterface)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2001-04-03 22:49:38 +00:00
|
|
|
*aScriptableInterface = nsnull;
|
2003-02-27 01:47:53 +00:00
|
|
|
return GetValueInternal(NPPVpluginScriptableIID, (void*)aScriptableInterface);
|
2001-04-03 22:49:38 +00:00
|
|
|
}
|
2004-07-12 15:53:22 +00:00
|
|
|
|
|
|
|
JSObject *
|
|
|
|
ns4xPluginInstance::GetJSObject(JSContext *cx)
|
|
|
|
{
|
|
|
|
JSObject *obj = nsnull;
|
|
|
|
NPObject *npobj = nsnull;
|
|
|
|
|
|
|
|
nsresult rv = GetValueInternal(NPPVpluginScriptableNPObject, &npobj);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && npobj) {
|
|
|
|
obj = nsNPObjWrapper::GetNewOrUsed(&fNPP, cx, npobj);
|
|
|
|
|
|
|
|
_releaseobject(npobj);
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
2005-03-09 17:01:22 +00:00
|
|
|
|
|
|
|
nsresult
|
|
|
|
ns4xPluginInstance::GetFormValue(nsAString& aValue)
|
|
|
|
{
|
|
|
|
aValue.Truncate();
|
|
|
|
|
|
|
|
char *value = nsnull;
|
|
|
|
nsresult rv = GetValueInternal(NPPVformValue, &value);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && value) {
|
|
|
|
CopyUTF8toUTF16(value, aValue);
|
|
|
|
|
|
|
|
// NPPVformValue allocates with NPN_MemAlloc(), which uses
|
|
|
|
// nsMemory.
|
|
|
|
nsMemory::Free(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2005-06-18 06:06:45 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
ns4xPluginInstance::PushPopupsEnabledState(PRBool aEnabled)
|
|
|
|
{
|
2005-11-28 23:56:44 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = GetDOMWindow();
|
|
|
|
if (!window)
|
2005-06-18 06:06:45 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
PopupControlState oldState =
|
2005-11-28 23:56:44 +00:00
|
|
|
window->PushPopupControlState(aEnabled ? openAllowed : openAbused,
|
|
|
|
PR_TRUE);
|
2005-06-18 06:06:45 +00:00
|
|
|
|
|
|
|
if (!mPopupStates.AppendElement(NS_INT32_TO_PTR(oldState))) {
|
|
|
|
// Appending to our state stack failed, push what we just popped.
|
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
window->PopPopupControlState(oldState);
|
2005-06-18 06:06:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ns4xPluginInstance::PopPopupsEnabledState()
|
|
|
|
{
|
|
|
|
PRInt32 last = mPopupStates.Count() - 1;
|
|
|
|
|
|
|
|
if (last < 0) {
|
|
|
|
// Nothing to pop.
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = GetDOMWindow();
|
|
|
|
if (!window)
|
2005-06-18 06:06:45 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
PopupControlState oldState =
|
|
|
|
(PopupControlState)NS_PTR_TO_INT32(mPopupStates[last]);
|
|
|
|
|
2005-11-28 23:56:44 +00:00
|
|
|
window->PopPopupControlState(oldState);
|
2005-06-18 06:06:45 +00:00
|
|
|
|
|
|
|
mPopupStates.RemoveElementAt(last);
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint16
|
|
|
|
ns4xPluginInstance::GetPluginAPIVersion()
|
|
|
|
{
|
|
|
|
return fCallbacks->version;
|
|
|
|
}
|