Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-28 11:28:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
7de193d0f0
gecko-dev/silentdl/nsSilentDownload.cpp
pp%ludusdesign.com 698852a4f4 Converting usage of ::GetIID() to NS_GET_IID(). 
Bug #20232, r=scc@netscape.com
2000-01-11 20:49:15 +00:00

1358 lines
32 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape 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/NPL/
*
* 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.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is Netscape Communications
* Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
* Pierre Phaneuf <pp@ludusdesign.com>
*/
#include "nsSilentDownload.h"
#include "nsSilentDownloadPrivate.h"
#include "nscore.h"
#include "nsIFactory.h"
#include "nsISupports.h"
#include "nsIComponentManager.h"
#include "nsIScriptObjectOwner.h"
#include "nsIScriptGlobalObject.h"
#include "nsString.h"
#include "nsSpecialSystemDirectory.h"
#include "pratom.h"
#include "prmem.h"
#include "prio.h"
#include "mkutils.h"
#include "prefapi.h"
#include "nsIURL.h"
#include "nsIIOService.h"
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
#include "nsINetlibURL.h"
#include "nsINetService.h"
#include "nsIInputStream.h"
#include "nsIStreamListener.h"
#include "nsIDOMSilentDownload.h"
#include "nsIDOMSilentDownloadTask.h"
/* For Javascript Namespace Access */
#include "nsDOMCID.h"
#include "nsIServiceManager.h"
#include "nsINameSpaceManager.h"
#include "nsIScriptNameSetRegistry.h"
#include "nsIScriptNameSpaceManager.h"
#include "nsIScriptExternalNameSet.h"
#include "nsITimer.h"
#include "nsITimerCallback.h"
#include "nsIBrowserWindow.h"
#include "nsIWebShell.h"
#include "nsIServiceManager.h"
#include "nsCOMPtr.h"
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
static NS_DEFINE_IID(kIScriptObjectOwnerIID, NS_ISCRIPTOBJECTOWNER_IID);
static NS_DEFINE_IID(kIScriptNameSetRegistryIID, NS_ISCRIPTNAMESETREGISTRY_IID);
static NS_DEFINE_IID(kCScriptNameSetRegistryCID, NS_SCRIPT_NAMESET_REGISTRY_CID);
static NS_DEFINE_IID(kIScriptExternalNameSetIID, NS_ISCRIPTEXTERNALNAMESET_IID);
static NS_DEFINE_IID(kInetServiceIID, NS_INETSERVICE_IID);
static NS_DEFINE_IID(kInetServiceCID, NS_NETSERVICE_CID);
static NS_DEFINE_IID(kInetLibURLIID, NS_INETLIBURL_IID);
static NS_DEFINE_IID(kIStreamListenerIID, NS_ISTREAMLISTENER_IID);
static NS_DEFINE_IID(kBrowserWindowCID, NS_BROWSER_WINDOW_CID);
static NS_DEFINE_IID(kIBrowserWindowIID, NS_IBROWSER_WINDOW_IID);
static NS_DEFINE_IID(kISilentDownloadTaskIID, NS_IDOMSILENTDOWNLOADTASK_IID);
static NS_DEFINE_IID(kISilentDownloadIID, NS_IDOMSILENTDOWNLOAD_IID);
static NS_DEFINE_IID(kSilentDownloadCID, NS_SilentDownload_CID);
static NS_DEFINE_IID(kSilentDownloadTaskCID, NS_SilentDownloadTask_CID);
static NS_DEFINE_IID(kSilentDownloadFactoryCID, NS_SilentDownloadFactory_CID);
static NS_DEFINE_IID(kSilentDownloadTaskFactoryCID, NS_SilentDownloadTaskFactory_CID);
static PRInt32 gLockCnt = 0;
static PRInt32 gInstanceCnt = 0;
static nsITimer *gTaskTimer = nsnull;
static nsINetService *gInetService = nsnull;
static SDL_TaskList *gTasks = nsnull;
static SDL_TaskList *gNextReadyTask = nsnull;
static PRInt32 gByteRange = 0;
static PRInt32 gInterval = 0xFFFF;
/////////////////////////////////////////////////////////////////////////
// static helper meathods
/////////////////////////////////////////////////////////////////////////
static void
GetSilentDownloadDirectory(char* directory)
{
if (PREF_OK != PREF_CopyCharPref("SilentDownload.directory", (char**)directory))
{
directory = NULL;
}
}
static void
GetSilentDownloadDefaults(PRBool* enabled, PRInt32 *bytes_range, PRInt32 *interval)
{
*enabled = PR_FALSE;
*bytes_range = 0;
*interval = 0;
PREF_GetBoolPref( "SilentDownload.enabled", enabled);
//fix if (*enabled == PR_FALSE)
// return;
if (PREF_OK != PREF_GetIntPref("SilentDownload.range", bytes_range))
{
*bytes_range = 3000;
}
if (PREF_OK != PREF_GetIntPref("SilentDownload.interval", interval))
{
*interval = 10000;
}
}
nsFileSpec *
CreateOutFileLocation(const nsString& url, const nsString& directory)
{
nsSpecialSystemDirectory outFileLocation(nsSpecialSystemDirectory::OS_CurrentProcessDirectory);
PRInt32 result = url.RFindChar('/');
if (result != -1)
{
nsString fileName;
url.Right(fileName, (url.Length() - result) );
outFileLocation += fileName;
}
else
{
outFileLocation += "sdl";
}
outFileLocation.MakeUnique();
return new nsSpecialSystemDirectory(outFileLocation);
}
/////////////////////////////////////////////////////////////////////////
// nsSilentDownloadManager
/////////////////////////////////////////////////////////////////////////
nsSilentDownloadManager* nsSilentDownloadManager::mInstance = NULL;
nsSilentDownloadManager::nsSilentDownloadManager()
{
mScriptObject = nsnull;
PR_AtomicIncrement(&gInstanceCnt);
NS_INIT_REFCNT();
Startup();
}
nsSilentDownloadManager::~nsSilentDownloadManager()
{
PR_AtomicDecrement(&gInstanceCnt);
Shutdown();
}
nsSilentDownloadManager *
nsSilentDownloadManager::GetInstance()
{
if (mInstance == NULL)
{
mInstance = new nsSilentDownloadManager();
}
return mInstance;
}
nsresult
nsSilentDownloadManager::LoadAllTasks(void)
{
gNextReadyTask = gTasks;
return NS_OK;
}
nsresult
nsSilentDownloadManager::StoreAllTasks(void)
{
return NS_OK;
}
NS_IMPL_ADDREF(nsSilentDownloadManager)
NS_IMPL_RELEASE(nsSilentDownloadManager)
NS_IMETHODIMP
nsSilentDownloadManager::QueryInterface(REFNSIID aIID,void** aInstancePtr)
{
if (aInstancePtr == NULL)
{
return NS_ERROR_NULL_POINTER;
}
// Always NULL result, in case of failure
*aInstancePtr = NULL;
if ( aIID.Equals(kISilentDownloadIID) )
{
nsIDOMSilentDownload* tmp = this;
*aInstancePtr = (void*)tmp;
AddRef();
return NS_OK;
}
else if ( aIID.Equals(kIScriptObjectOwnerIID))
{
nsIScriptObjectOwner* tmp = this;
*aInstancePtr = (void*)tmp;
AddRef();
return NS_OK;
}
else if ( aIID.Equals(kISupportsIID) )
{
nsIDOMSilentDownload* tmp1 = this;
nsISupports* tmp2 = tmp1;
*aInstancePtr = (void*)tmp2;
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_IMETHODIMP
nsSilentDownloadManager::GetScriptObject(nsIScriptContext *aContext, void** aScriptObject)
{
nsresult res = NS_OK;
if (nsnull == mScriptObject)
{
nsIScriptGlobalObject *global = aContext->GetGlobalObject();
res = NS_NewScriptSilentDownload(aContext, (nsISupports *)(nsIDOMSilentDownload*)this, global, (void**)&mScriptObject);
NS_IF_RELEASE(global);
}
*aScriptObject = mScriptObject;
return res;
}
NS_IMETHODIMP
nsSilentDownloadManager::SetScriptObject(void *aScriptObject)
{
mScriptObject = aScriptObject;
return NS_OK;
}
void nsSilentDownloadManager::Notify(nsITimer * aTimer)
{
/* Fix: maybe some additional check on gNextReadyTask */
if (gTasks != NULL && gNextReadyTask != NULL)
{
if (! gInetService->AreThereActiveConnections() )
{
gNextReadyTask->task->DownloadSelf(gByteRange);
if (gNextReadyTask->next == NULL)
{
gNextReadyTask = gTasks;
}
else
{
gNextReadyTask = gNextReadyTask->next;
}
}
}
NS_RELEASE(gTaskTimer);
if (NS_OK == NS_NewTimer(&gTaskTimer))
gTaskTimer->Init(this, gInterval);
}
NS_IMETHODIMP
nsSilentDownloadManager::Startup()
{
PRBool enabled = PR_FALSE;
GetSilentDownloadDefaults(&enabled, &gByteRange, &gInterval);
//if (enabled == PR_FALSE)
// FIX ignore for now: return -1;
/***************************************/
/* Add us to the Javascript Name Space */
/***************************************/
nsIScriptNameSetRegistry *registry;
nsresult result = nsServiceManager::GetService(kCScriptNameSetRegistryCID,
kIScriptNameSetRegistryIID,
(nsISupports **)&registry);
if (NS_OK == result)
{
nsSilentDownloadNameSet* nameSet = new nsSilentDownloadNameSet();
registry->AddExternalNameSet(nameSet);
/* FIX - do we need to release this service? When we do, it get deleted,and our name is lost. */
}
/************************************************************************/
/* Create an instance of INet so that we can see if the network is busy */
/************************************************************************/
result = nsComponentManager::CreateInstance(kInetServiceCID,
nsnull,
kInetServiceIID,
(void**)&gInetService);
if (result != NS_OK)
return result;
/************************/
/* Load all saved tasks */
/************************/
result = LoadAllTasks();
if (result != NS_OK)
return result;
/************************/
/* Start Timer */
/************************/
if (NS_OK == NS_NewTimer(&gTaskTimer))
gTaskTimer->Init(this, gInterval);
return result;
}
NS_IMETHODIMP
nsSilentDownloadManager::Shutdown()
{
StoreAllTasks();
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadManager::Add(nsIDOMSilentDownloadTask* aTask)
{
if (aTask == NULL)
return NS_ERROR_FAILURE;
/* Check to see if we already have this task in our list */
SDL_TaskList *node = gTasks;
nsString nodeIDString;
nsString addIDString;
aTask->GetId(addIDString);
while (node != NULL)
{
node->task->GetId(nodeIDString);
if (nodeIDString == addIDString)
{
/*we already have this ID in our list, ignore */
return NS_OK;
}
node = node->next;
}
/* add the task to our list */
SDL_TaskList* taskNode = (SDL_TaskList*)PR_MALLOC(sizeof(SDL_TaskList));
aTask->AddRef();
taskNode->next = gTasks;
taskNode->task = aTask;
gTasks = taskNode;
/* Lets set the next task to run to this one */
gNextReadyTask = taskNode;
aTask->SetState(nsIDOMSilentDownloadTask::SDL_STARTED);
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadManager::Remove(nsIDOMSilentDownloadTask* aTask)
{
if (aTask == NULL)
return NS_ERROR_FAILURE;
/* Remove from our list */
SDL_TaskList *node = gTasks;
SDL_TaskList *lastnode = gTasks;
nsString nodeIDString;
nsString doomedIDString;
aTask->GetId(doomedIDString);
while (node != NULL)
{
node->task->GetId(nodeIDString);
if (nodeIDString == doomedIDString)
{
/* we want to delete this node */
if (node == gTasks)
{
gTasks = node->next;
}
else
{
lastnode->next = node->next;
}
node->task->Release();
PR_DELETE(node);
break;
}
lastnode = node;
node = node->next;
}
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadManager::Find(const nsString& aId, nsIDOMSilentDownloadTask** aReturn)
{
*aReturn=nsnull;
SDL_TaskList *node = gTasks;
nsString nodeIDString;
while (node != NULL)
{
node->task->GetId(nodeIDString);
if (nodeIDString == aId)
{
*aReturn = node->task;
node->task->AddRef();
break;
}
node = node->next;
}
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadManager::GetByteRange(PRInt32* aByterange)
{
*aByterange = gByteRange;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadManager::SetByteRange(PRInt32 aByterange)
{
gByteRange = aByterange;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadManager::GetInterval(PRInt32* aInterval)
{
*aInterval = gInterval;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadManager::SetInterval(PRInt32 aInterval)
{
gInterval = aInterval;
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////
// nsSilentDownloadTask
/////////////////////////////////////////////////////////////////////////
nsSilentDownloadTask::nsSilentDownloadTask()
{
mScriptObject = nsnull;
mListener = nsnull;
mWindow = nsnull;
mWebShell = nsnull;
mState = nsIDOMSilentDownloadTask::SDL_NOT_INITED;
mNextByte = 0;
mOutFile = nsnull;
PR_AtomicIncrement(&gInstanceCnt);
NS_INIT_REFCNT();
}
nsSilentDownloadTask::~nsSilentDownloadTask()
{
if (mOutFile)
delete mOutFile;
mListener->Release();
PR_AtomicDecrement(&gInstanceCnt);
}
void
nsSilentDownloadTask::LoadScript(void)
{
if (mState == nsIDOMSilentDownloadTask::SDL_NOT_ADDED ||
mState == nsIDOMSilentDownloadTask::SDL_NOT_INITED )
return;
if (mWindow == nsnull)
{
nsresult rv = nsComponentManager::CreateInstance(kBrowserWindowCID, nsnull,
kIBrowserWindowIID,
(void**) &mWindow);
if (rv == NS_OK)
{
nsRect rect(0, 0, 275, 300);
rv = mWindow->Init(nsnull, nsnull, rect, PRUint32(0), PR_FALSE);
if (rv == NS_OK)
{
rv = mWindow->GetWebShell(mWebShell);
mWebShell->LoadURL(mScript.GetUnicode());
}
else
{
mWindow->Release();
mWindow=nsnull;
mState = nsIDOMSilentDownloadTask::SDL_ERROR;
SetErrorMsg("Couldn't Open Window");
}
}
}
else
{
if (mWebShell)
{
mWebShell->LoadURL(mScript.GetUnicode());
}
else
{
mState = nsIDOMSilentDownloadTask::SDL_ERROR;
SetErrorMsg("Couldn't Open Window");
}
}
}
NS_IMPL_ADDREF(nsSilentDownloadTask)
NS_IMPL_RELEASE(nsSilentDownloadTask)
NS_IMETHODIMP
nsSilentDownloadTask::QueryInterface(REFNSIID aIID,void** aInstancePtr)
{
if (aInstancePtr == NULL)
{
return NS_ERROR_NULL_POINTER;
}
// Always NULL result, in case of failure
*aInstancePtr = NULL;
if ( aIID.Equals(kIScriptObjectOwnerIID))
{
*aInstancePtr = (void*) ((nsIScriptObjectOwner*)this);
AddRef();
return NS_OK;
}
else if ( aIID.Equals(kISilentDownloadTaskIID) )
{
*aInstancePtr = (void*) ((nsIDOMSilentDownloadTask*)this);
AddRef();
return NS_OK;
}
else if ( aIID.Equals(kISupportsIID) )
{
*aInstancePtr = (void*)(nsISupports*)(nsIScriptObjectOwner*)this;
AddRef();
return NS_OK;
}
return NS_NOINTERFACE;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetScriptObject(nsIScriptContext *aContext, void** aScriptObject)
{
NS_PRECONDITION(nsnull != aScriptObject, "null arg");
nsresult res = NS_OK;
if (nsnull == mScriptObject)
{
res = NS_NewScriptSilentDownloadTask( aContext,
(nsISupports *)(nsIDOMSilentDownloadTask*)this,
nsnull,
&mScriptObject);
}
*aScriptObject = mScriptObject;
return res;
}
NS_IMETHODIMP
nsSilentDownloadTask::SetScriptObject(void *aScriptObject)
{
mScriptObject = aScriptObject;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::Init(const nsString& aId, const nsString& aUrl, const nsString& aScript)
{
char *defaultDirectoryCString = NULL;
nsFileSpec *outFile = NULL;
GetSilentDownloadDirectory(defaultDirectoryCString);
mId = aId;
mUrl = aUrl;
mScript = aScript;
//Fix use silentdownload directory
mOutFile = CreateOutFileLocation(aUrl, nsString("/SilentDL"));
// FIx need to delete defaultDirectoryCString
if (mOutFile == NULL)
{
SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
SetErrorMsg("Couldn't access destination directory to save file");
return -1;
}
mNextByte = mOutFile->GetFileSize();
if (mNextByte < 0)
{
SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
SetErrorMsg("Negative Byte!");
return NS_OK;
}
/* Everything looks good. Mark as SDL_NOT_ADDED. */
mState = nsIDOMSilentDownloadTask::SDL_NOT_ADDED;
mListener = new nsSilentDownloadListener();
mListener->SetSilentDownloadInfo(this);
nsSilentDownloadManager* sdm = nsSilentDownloadManager::GetInstance();
sdm->Add(this);
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetId(nsString& aId)
{
aId = mId;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetUrl(nsString& aUrl)
{
aUrl = mUrl;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetScript(nsString& aScript)
{
aScript = mScript;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetState(PRInt32* aState)
{
*aState = mState;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::SetState(PRInt32 aState)
{
/* This function is so that our listener can change the state.
I would rather not expose this to Javascript if possible*/
mState = aState;
LoadScript();
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetErrorMsg(nsString& aErrorMsg)
{
/* This function is so that our listener can change the state.
I would rather not expose this to Javascript if possible*/
aErrorMsg = mErrorMsg;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::SetErrorMsg(const nsString& aErrorMsg)
{
mErrorMsg = aErrorMsg;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetNextByte(PRInt32* aNext_byte)
{
*aNext_byte = mNextByte;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::SetNextByte(PRInt32 aNextByte)
{
mNextByte = aNextByte;
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::GetOutFile(nsString& aOutFile)
{
aOutFile.SetString(nsNSPRPath(*mOutFile));
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::Remove()
{
mState = nsIDOMSilentDownloadTask::SDL_NOT_ADDED;
mWebShell->Release();
mWindow->Close();
mWindow->Release();
mWindow = nsnull;
nsSilentDownloadManager* sdm = nsSilentDownloadManager::GetInstance();
sdm->Remove(this);
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::Suspend()
{
SetState(nsIDOMSilentDownloadTask::SDL_SUSPENDED);
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::Resume()
{
SetState(nsIDOMSilentDownloadTask::SDL_STARTED);
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::DownloadNow()
{
SetState(nsIDOMSilentDownloadTask::SDL_DOWNLOADING_NOW);
DownloadSelf(0);
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadTask::DownloadSelf(PRInt32 range)
{
long result=0;
char* byteRangeString=NULL;
nsIURI *pURL;
nsILoadAttribs *loadAttr;
if (mState != nsIDOMSilentDownloadTask::SDL_STARTED &&
mState != nsIDOMSilentDownloadTask::SDL_DOWNLOADING_NOW)
{
/* We do not have to do a download here. */
return 0;
}
// Create the URL object...
pURL = NULL;
NS_WITH_SERVICE(nsIIOService, service, kIOServiceCID, &result);
if (NS_FAILED(result)) return result;
nsIURI *uri = nsnull;
char *uriStr = mUrl.ToNewCString();
if (!uriStr) return NS_ERROR_OUT_OF_MEMORY;
result = service->NewURI(uriStr, nsnull, &uri);
nsCRT::free(uriStr);
if (NS_FAILED(result)) return result;
result = uri->QueryInterface(NS_GET_IID(nsIURI), (void**)&pURL);
NS_RELEASE(uri);
if (result != NS_OK)
{
SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
SetErrorMsg("Couldn't set up download. Out of memory");
return -1;
}
pURL->GetLoadAttribs(&loadAttr);
loadAttr->SetLoadType(nsURLLoadBackground);
if (mState != nsIDOMSilentDownloadTask::SDL_DOWNLOADING_NOW)
{
/* Do Byte Range Stuff */
byteRangeString = PR_sprintf_append( byteRangeString,
"bytes=%ld-%ld",
mNextByte,
mNextByte+range);
loadAttr->SetByteRangeHeader(byteRangeString);
PR_FREEIF(byteRangeString);
}
result = NS_OpenURL(pURL, mListener);
/* If the open failed... */
if (NS_OK != result)
{
}
return result;
}
/////////////////////////////////////////////////////////////////////////
// nsSilentDownloadImplFactory
/////////////////////////////////////////////////////////////////////////
nsSilentDownloadManagerFactory::nsSilentDownloadManagerFactory(void)
{
mRefCnt=0;
PR_AtomicIncrement(&gInstanceCnt);
}
nsSilentDownloadManagerFactory::~nsSilentDownloadManagerFactory(void)
{
PR_AtomicDecrement(&gInstanceCnt);
}
NS_IMPL_ISUPPORTS(nsSilentDownloadManagerFactory,kIFactoryIID)
NS_IMETHODIMP
nsSilentDownloadManagerFactory::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
if (aResult == NULL)
{
return NS_ERROR_NULL_POINTER;
}
*aResult = NULL;
nsSilentDownloadManager *inst = nsSilentDownloadManager::GetInstance();
if (inst == NULL)
return NS_ERROR_OUT_OF_MEMORY;
nsresult result = inst->QueryInterface(aIID, aResult);
if (NS_FAILED(result))
{
*aResult = NULL;
}
NS_ADDREF(inst); // Are we sure that we need to addref???
return result;
}
NS_IMETHODIMP
nsSilentDownloadManagerFactory::LockFactory(PRBool aLock)
{
if (aLock)
PR_AtomicIncrement(&gLockCnt);
else
PR_AtomicDecrement(&gLockCnt);
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////
// nsSilentDownloadTaskFactory
/////////////////////////////////////////////////////////////////////////
nsSilentDownloadTaskFactory::nsSilentDownloadTaskFactory(void)
{
mRefCnt=0;
PR_AtomicIncrement(&gInstanceCnt);
}
nsSilentDownloadTaskFactory::~nsSilentDownloadTaskFactory(void)
{
PR_AtomicDecrement(&gInstanceCnt);
}
NS_IMPL_ISUPPORTS(nsSilentDownloadTaskFactory,kIFactoryIID)
NS_IMETHODIMP
nsSilentDownloadTaskFactory::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult)
{
if (aResult == NULL)
{
return NS_ERROR_NULL_POINTER;
}
*aResult = NULL;
/* do I have to use iSupports? */
nsSilentDownloadTask *inst = new nsSilentDownloadTask();
if (inst == NULL)
return NS_ERROR_OUT_OF_MEMORY;
nsresult result = inst->QueryInterface(aIID, aResult);
if (result != NS_OK)
delete inst;
return result;
}
NS_IMETHODIMP
nsSilentDownloadTaskFactory::LockFactory(PRBool aLock)
{
if (aLock)
PR_AtomicIncrement(&gLockCnt);
else
PR_AtomicDecrement(&gLockCnt);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsSilentDownloadNameSet
////////////////////////////////////////////////////////////////////////////////
nsSilentDownloadNameSet::nsSilentDownloadNameSet()
{
NS_INIT_REFCNT();
}
nsSilentDownloadNameSet::~nsSilentDownloadNameSet()
{
}
NS_IMPL_ISUPPORTS(nsSilentDownloadNameSet, kIScriptExternalNameSetIID);
NS_IMETHODIMP
nsSilentDownloadNameSet::InitializeClasses(nsIScriptContext* aScriptContext)
{
nsresult result = NS_OK;
result = NS_InitSilentDownloadClass(aScriptContext, nsnull);
if (NS_OK != result) return result;
result = NS_InitSilentDownloadTaskClass(aScriptContext, nsnull);
return result;
}
NS_IMETHODIMP
nsSilentDownloadNameSet::AddNameSet(nsIScriptContext* aScriptContext)
{
nsresult result = NS_OK;
nsIScriptNameSpaceManager* manager;
result = aScriptContext->GetNameSpaceManager(&manager);
if (NS_OK == result)
{
result = manager->RegisterGlobalName("SilentDownloadTask",
kSilentDownloadTaskCID,
PR_TRUE);
if (NS_OK != result) return result;
result = manager->RegisterGlobalName("SilentDownloadManager",
kSilentDownloadCID,
PR_FALSE);
NS_RELEASE(manager);
}
return result;
}
////////////////////////////////////////////////////////////////////////////////
// nsSilentDownloadListener
////////////////////////////////////////////////////////////////////////////////
nsSilentDownloadListener::nsSilentDownloadListener()
{
NS_INIT_REFCNT();
}
nsSilentDownloadListener::~nsSilentDownloadListener()
{
mSilentDownloadTask->Release();
if (mOutFileDesc != NULL)
PR_Close(mOutFileDesc);
}
NS_IMPL_ISUPPORTS( nsSilentDownloadListener, kIStreamListenerIID )
NS_IMETHODIMP
nsSilentDownloadListener::GetBindInfo(nsIURI* aURL, nsStreamBindingInfo* info)
{
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadListener::OnProgress( nsIURI* aURL,
PRUint32 Progress,
PRUint32 ProgressMax)
{
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadListener::OnStatus(nsIURI* aURL,
const PRUnichar* aMsg)
{
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadListener::OnStartRequest(nsIURI* aURL,
const char *aContentType)
{
return NS_OK;
}
NS_IMETHODIMP
nsSilentDownloadListener::OnStopRequest(nsIURI* aURL,
nsresult status,
const PRUnichar* aMsg)
{
nsresult result = NS_OK;
PRInt32 content_length = 0;
PRInt32 server_status = 0;
PRInt32 nextByte;
switch( status )
{
case NS_BINDING_SUCCEEDED:
/*
What we are going to is check to see if our nextByte that the task will
get is passed the content_length of the URL.
What happens if there is no content_length?
*/
aURL->GetServerStatus(&server_status);
if (server_status == 404)
{
mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
mSilentDownloadTask->SetErrorMsg("Server Error 400.");
return NS_OK;
}
else if (server_status == 500)
{
mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
mSilentDownloadTask->SetErrorMsg("Server Error 500.");
return NS_OK;
}
aURL->GetContentLength(&content_length);
mSilentDownloadTask->GetNextByte(&nextByte);
if (content_length <= nextByte || content_length == 0)
{
mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_COMPLETED);
PR_Close(mOutFileDesc);
mOutFileDesc=NULL;
}
break;
case NS_BINDING_FAILED:
case NS_BINDING_ABORTED:
mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
mSilentDownloadTask->SetErrorMsg("Could Not Download.");
break;
default:
result = NS_ERROR_ILLEGAL_VALUE;
}
return result;
}
NS_IMETHODIMP
nsSilentDownloadListener::OnDataAvailable(nsIURI* aURL, nsIInputStream *pIStream, PRUint32 length)
{
PRUint32 len;
PRInt32 nextByte;
PRInt32 byteCountDown = length;
nsresult err;
char buffer[4096];
do
{
err = pIStream->Read(buffer, 4096, &len);
byteCountDown -= len;
if (err == NS_OK)
{
mSilentDownloadTask->GetNextByte(&nextByte);
if ( PR_Seek(mOutFileDesc, nextByte, PR_SEEK_SET) == -1 )
{
/* Error */
mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
mSilentDownloadTask->SetErrorMsg("File Seek Error.");
return -1;
}
if( PR_Write(mOutFileDesc, buffer, len) == -1 )
{
/* Error */
mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
mSilentDownloadTask->SetErrorMsg("File Write Error.");
return -1;
}
mSilentDownloadTask->SetNextByte(nextByte+len);
}
} while (len > 0 && byteCountDown > 0);
return 0;
}
NS_IMETHODIMP
nsSilentDownloadListener::SetSilentDownloadInfo(nsIDOMSilentDownloadTask* con)
{
nsString aFile;
mSilentDownloadTask = con;
con->AddRef();
mSilentDownloadTask->GetOutFile(aFile);
mOutFileDesc = PR_Open(nsAutoCString(aFile), PR_CREATE_FILE | PR_RDWR, 0644);
if(mOutFileDesc == NULL)
{
mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR);
mSilentDownloadTask->SetErrorMsg("Could not create OUT file.");
return NS_OK;
};
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// DLL Entry Points:
////////////////////////////////////////////////////////////////////////////////
extern "C" NS_EXPORT PRBool
NSCanUnload(nsISupports* aServMgr)
{
return PRBool (gInstanceCnt == 0 && gLockCnt == 0);
}
extern "C" NS_EXPORT nsresult
NSRegisterSelf(nsISupports* aServMgr, const char *path)
{
nsresult rv;
nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &rv));
if (NS_FAILED(rv)) return rv;
nsIComponentManager* compMgr;
rv = servMgr->GetService(kComponentManagerCID,
NS_GET_IID(nsIComponentManager),
(nsISupports**)&compMgr);
if (NS_FAILED(rv)) return rv;
#ifdef NS_DEBUG
printf("*** SilentDownload is being registered\n");
#endif
rv = compMgr->RegisterComponent(kSilentDownloadCID, NULL, NULL, path, PR_TRUE, PR_TRUE);
if (NS_FAILED(rv)) goto done;
rv = compMgr->RegisterComponent(kSilentDownloadTaskCID, NULL, NULL, path, PR_TRUE, PR_TRUE);
done:
(void)servMgr->ReleaseService(kComponentManagerCID, compMgr);
return rv;
}
extern "C" NS_EXPORT nsresult
NSUnregisterSelf(nsISupports* aServMgr, const char *path)
{
nsresult rv;
nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &rv));
if (NS_FAILED(rv)) return rv;
nsIComponentManager* compMgr;
rv = servMgr->GetService(kComponentManagerCID,
NS_GET_IID(nsIComponentManager),
(nsISupports**)&compMgr);
if (NS_FAILED(rv)) return rv;
#ifdef NS_DEBUG
printf("*** SilentDownload is being unregistered\n");
#endif
rv = compMgr->UnregisterComponent(kSilentDownloadCID, path);
if (NS_FAILED(rv)) goto done;
rv = compMgr->UnregisterComponent(kSilentDownloadTaskCID, path);
done:
(void)servMgr->ReleaseService(kComponentManagerCID, compMgr);
return rv;
}
extern "C" NS_EXPORT nsresult
NSGetFactory(nsISupports* aServMgr,
const nsCID &aClass,
const char *aClassName,
const char *aProgID,
nsIFactory **aFactory)
{
if (aFactory == NULL)
{
return NS_ERROR_NULL_POINTER;
}
*aFactory = NULL;
nsISupports *inst;
if ( aClass.Equals(kSilentDownloadCID) )
{
inst = new nsSilentDownloadManagerFactory();
}
else if ( aClass.Equals(kSilentDownloadTaskCID) )
{
inst = new nsSilentDownloadTaskFactory();
}
else
{
return NS_ERROR_ILLEGAL_VALUE;
}
if (inst == NULL)
{
return NS_ERROR_OUT_OF_MEMORY;
}
nsresult res = inst->QueryInterface(kIFactoryIID, (void**) aFactory);
if (res != NS_OK)
{
delete inst;
}
return res;
}
Reference in New Issue View Git Blame Copy Permalink