void main(int argc, char* argv[])
{
nsresult rv;
nsIServiceManager* servMgr;
rv = NS_InitXPCOM2(&servMgr, NULL, NULL);
NS_ASSERTION(NS_SUCCEEDED(rv), "NS_InitXPCOM failed");
// try loading a component and releasing it to see if it leaks
if (argc > 1 && argv[1] != nsnull) {
char* cidStr = argv[1];
nsISupports* obj = nsnull;
if (cidStr[0] == '{') {
nsCID cid;
cid.Parse(cidStr);
rv = CallCreateInstance(cid, &obj);
}
else {
// contractID case:
rv = CallCreateInstance(cidStr, &obj);
}
if (NS_SUCCEEDED(rv)) {
printf("Successfully created %s\n", cidStr);
NS_RELEASE(obj);
}
else {
printf("Failed to create %s (%x)\n", cidStr, rv);
}
}
rv = NS_ShutdownXPCOM(servMgr);
NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
}
int main()
{
/*
* NOTE: This does NOT demonstrate how these functions are
* intended to be used. They are intended for filling in out
* parameters that need to be |AddRef|ed. I'm just too lazy
* to write lots of little getter functions for a test program
* when I don't need to.
*/
NS_NOTREACHED("This test is not intended to run, only to compile!");
/* Test CallQueryInterface */
nsISupports *mySupportsPtr = reinterpret_cast<nsISupports*>(0x1000);
nsITestService *myITestService = nsnull;
CallQueryInterface(mySupportsPtr, &myITestService);
nsTestService *myTestService =
reinterpret_cast<nsTestService*>(mySupportsPtr);
nsISupportsWeakReference *mySupportsWeakRef;
CallQueryInterface(myTestService, &mySupportsWeakRef);
nsCOMPtr<nsISupports> mySupportsCOMPtr = mySupportsPtr;
CallQueryInterface(mySupportsCOMPtr, &myITestService);
nsRefPtr<nsTestService> myTestServiceRefPtr = myTestService;
CallQueryInterface(myTestServiceRefPtr, &mySupportsWeakRef);
/* Test CallQueryReferent */
nsIWeakReference *myWeakRef =
static_cast<nsIWeakReference*>(mySupportsPtr);
CallQueryReferent(myWeakRef, &myITestService);
/* Test CallCreateInstance */
CallCreateInstance(kTestServiceCID, mySupportsPtr, &myITestService);
CallCreateInstance(kTestServiceCID, &myITestService);
CallCreateInstance(NS_TEST_SERVICE_CONTRACTID, mySupportsPtr,
&myITestService);
CallCreateInstance(NS_TEST_SERVICE_CONTRACTID, &myITestService);
/* Test CallGetService */
CallGetService(kTestServiceCID, &myITestService);
CallGetService(NS_TEST_SERVICE_CONTRACTID, &myITestService);
/* Test CallGetInterface */
nsIInterfaceRequestor *myInterfaceRequestor =
static_cast<nsIInterfaceRequestor*>(mySupportsPtr);
CallGetInterface(myInterfaceRequestor, &myITestService);
return 0;
}
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
nsresult
nsNodeInfoManager::Init(nsIDocument *aDocument)
{
NS_ENSURE_TRUE(mNodeInfoHash, NS_ERROR_OUT_OF_MEMORY);
NS_PRECONDITION(!mPrincipal,
"Being inited when we already have a principal?");
nsresult rv = CallCreateInstance("@mozilla.org/nullprincipal;1",
&mPrincipal);
NS_ENSURE_TRUE(mPrincipal, rv);
if (aDocument) {
mBindingManager = new nsBindingManager(aDocument);
NS_ENSURE_TRUE(mBindingManager, NS_ERROR_OUT_OF_MEMORY);
NS_ADDREF(mBindingManager);
}
mDefaultPrincipal = mPrincipal;
mDocument = aDocument;
#ifdef PR_LOGGING
if (gNodeInfoManagerLeakPRLog)
PR_LOG(gNodeInfoManagerLeakPRLog, PR_LOG_DEBUG,
("NODEINFOMANAGER %p Init document=%p", this, aDocument));
#endif
return NS_OK;
}
void
posixlocale_reverse_conversion_test()
{
nsresult result;
nsIPosixLocale* posix_locale;
nsAutoString locale;
//
// create the locale object
//
result = CallCreateInstance(kPosixLocaleFactoryCID, &posix_locale);
NS_ASSERTION(posix_locale!=NULL,"nsLocaleTest: create interface failed.\n");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: create interface failed\n");
//
// test with a simple locale
//
result = posix_locale->GetXPLocale("en_US",locale);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetXPLocale failed.\n");
NS_ASSERTION(locale.EqualsLiteral("en-US"),"nsLocaleTest: GetXPLocale failed.\n");
result = posix_locale->GetXPLocale("C",locale);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetXPLocale failed.\n");
NS_ASSERTION(locale.EqualsLiteral("en"),"nsLocaleTest: GetXPLocale failed.\n");
result = posix_locale->GetXPLocale("en",locale);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetXPLocale failed.\n");
NS_ASSERTION(locale.EqualsLiteral("en"),"nsLocaleTest: GetXPLocale failed.\n");
posix_locale->Release();
}
static JSBool CreateNativeObject(JSContext *cx, JSObject *obj, nsIDOMInstallTriggerGlobal **aResult)
{
nsresult result;
nsIScriptObjectOwner *owner = nsnull;
nsIDOMInstallTriggerGlobal *nativeThis;
static NS_DEFINE_CID(kInstallTrigger_CID,
NS_SoftwareUpdateInstallTrigger_CID);
result = CallCreateInstance(kInstallTrigger_CID, &nativeThis);
if (NS_FAILED(result)) return JS_FALSE;
result = nativeThis->QueryInterface(NS_GET_IID(nsIScriptObjectOwner),
(void **)&owner);
if (NS_OK != result)
{
NS_RELEASE(nativeThis);
return JS_FALSE;
}
owner->SetScriptObject((void *)obj);
JS_SetPrivate(cx, obj, nativeThis);
*aResult = nativeThis;
NS_RELEASE(nativeThis); // we only want one refcnt. JSUtils cleans us up.
return JS_TRUE;
}
nsresult
nsXULContentUtils::Init()
{
if (gRefCnt++ == 0) {
nsresult rv = CallGetService(kRDFServiceCID, &gRDF);
if (NS_FAILED(rv)) {
return rv;
}
#define XUL_RESOURCE(ident, uri) \
PR_BEGIN_MACRO \
rv = gRDF->GetResource(NS_LITERAL_CSTRING(uri), &(ident)); \
if (NS_FAILED(rv)) return rv; \
PR_END_MACRO
#define XUL_LITERAL(ident, val) \
PR_BEGIN_MACRO \
rv = gRDF->GetLiteral(NS_LITERAL_STRING(val).get(), &(ident)); \
if (NS_FAILED(rv)) return rv; \
PR_END_MACRO
#include "nsXULResourceList.h"
#undef XUL_RESOURCE
#undef XUL_LITERAL
rv = CallCreateInstance(NS_DATETIMEFORMAT_CONTRACTID, &gFormat);
if (NS_FAILED(rv)) {
return rv;
}
}
return NS_OK;
}
nsresult nsEudoraCompose::CreateComponents(void)
{
nsresult rv = NS_OK;
if (!m_pIOService) {
IMPORT_LOG0("Creating nsIOService\n");
m_pIOService = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
}
NS_IF_RELEASE(m_pMsgFields);
if (!m_pListener && NS_SUCCEEDED(rv))
rv = EudoraSendListener::CreateSendListener(&m_pListener);
if (NS_SUCCEEDED(rv)) {
rv = CallCreateInstance(kMsgCompFieldsCID, &m_pMsgFields);
if (NS_SUCCEEDED(rv) && m_pMsgFields) {
// IMPORT_LOG0("nsOutlookCompose - CreateComponents succeeded\n");
m_pMsgFields->SetForcePlainText(false);
return NS_OK;
}
}
return NS_ERROR_FAILURE;
}
// This function takes a message uri, converts it into a file path & msgKey
// pair. It then turns that into a mailbox url object. It also registers a url
// listener if appropriate. AND it can take in a mailbox action and set that field
// on the returned url as well.
nsresult nsMailboxService::PrepareMessageUrl(const char * aSrcMsgMailboxURI, nsIUrlListener * aUrlListener,
nsMailboxAction aMailboxAction, nsIMailboxUrl ** aMailboxUrl,
nsIMsgWindow *msgWindow)
{
nsresult rv = CallCreateInstance(kCMailboxUrl, aMailboxUrl);
if (NS_SUCCEEDED(rv) && aMailboxUrl && *aMailboxUrl)
{
// okay now generate the url string
char * urlSpec;
nsCAutoString folderURI;
nsFileSpec folderPath;
nsMsgKey msgKey;
const char *part = PL_strstr(aSrcMsgMailboxURI, "part=");
const char *header = PL_strstr(aSrcMsgMailboxURI, "header=");
rv = nsParseLocalMessageURI(aSrcMsgMailboxURI, folderURI, &msgKey);
NS_ENSURE_SUCCESS(rv,rv);
rv = nsLocalURI2Path(kMailboxRootURI, folderURI.get(), folderPath);
if (NS_SUCCEEDED(rv))
{
// set up the url spec and initialize the url with it.
nsFilePath filePath(folderPath); // convert to file url representation...
nsCAutoString buf;
NS_EscapeURL((const char *)filePath,-1,
esc_Directory|esc_Forced|esc_AlwaysCopy,buf);
if (mPrintingOperation)
urlSpec = PR_smprintf("mailbox://%s?number=%d&header=print", buf.get(), msgKey);
else if (part)
urlSpec = PR_smprintf("mailbox://%s?number=%d&%s", buf.get(), msgKey, part);
else if (header)
urlSpec = PR_smprintf("mailbox://%s?number=%d&%s", buf.get(), msgKey, header);
else
urlSpec = PR_smprintf("mailbox://%s?number=%d", buf.get(), msgKey);
nsCOMPtr <nsIMsgMailNewsUrl> url = do_QueryInterface(*aMailboxUrl);
url->SetSpec(nsDependentCString(urlSpec));
PR_Free(urlSpec);
(*aMailboxUrl)->SetMailboxAction(aMailboxAction);
// set up the url listener
if (aUrlListener)
rv = url->RegisterListener(aUrlListener);
url->SetMsgWindow(msgWindow);
nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(url);
if (msgUrl)
{
msgUrl->SetOriginalSpec(aSrcMsgMailboxURI);
msgUrl->SetUri(aSrcMsgMailboxURI);
}
} // if we got a url
} // if we got a url
return rv;
}
// This function takes a message uri, converts it into a file path & msgKey
// pair. It then turns that into a mailbox url object. It also registers a url
// listener if appropriate. AND it can take in a mailbox action and set that field
// on the returned url as well.
nsresult nsMailboxService::PrepareMessageUrl(const char * aSrcMsgMailboxURI, nsIUrlListener * aUrlListener,
nsMailboxAction aMailboxAction, nsIMailboxUrl ** aMailboxUrl,
nsIMsgWindow *msgWindow)
{
nsresult rv = CallCreateInstance(NS_MAILBOXURL_CONTRACTID, aMailboxUrl);
if (NS_SUCCEEDED(rv) && aMailboxUrl && *aMailboxUrl)
{
// okay now generate the url string
char * urlSpec;
nsCAutoString folderURI;
nsMsgKey msgKey;
nsCString folderPath;
const char *part = PL_strstr(aSrcMsgMailboxURI, "part=");
const char *header = PL_strstr(aSrcMsgMailboxURI, "header=");
rv = nsParseLocalMessageURI(aSrcMsgMailboxURI, folderURI, &msgKey);
NS_ENSURE_SUCCESS(rv,rv);
rv = nsLocalURI2Path(kMailboxRootURI, folderURI.get(), folderPath);
if (NS_SUCCEEDED(rv))
{
// set up the url spec and initialize the url with it.
nsCAutoString buf;
MsgEscapeURL(folderPath,
nsINetUtil::ESCAPE_URL_DIRECTORY | nsINetUtil::ESCAPE_URL_FORCED, buf);
if (mPrintingOperation)
urlSpec = PR_smprintf("mailbox://%s?number=%lu&header=print", buf.get(), msgKey);
else if (part)
urlSpec = PR_smprintf("mailbox://%s?number=%lu&%s", buf.get(), msgKey, part);
else if (header)
urlSpec = PR_smprintf("mailbox://%s?number=%lu&%s", buf.get(), msgKey, header);
else
urlSpec = PR_smprintf("mailbox://%s?number=%lu", buf.get(), msgKey);
nsCOMPtr <nsIMsgMailNewsUrl> url = do_QueryInterface(*aMailboxUrl);
url->SetSpec(nsDependentCString(urlSpec));
PR_smprintf_free(urlSpec);
(*aMailboxUrl)->SetMailboxAction(aMailboxAction);
// set up the url listener
if (aUrlListener)
rv = url->RegisterListener(aUrlListener);
url->SetMsgWindow(msgWindow);
nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(url);
if (msgUrl)
{
msgUrl->SetOriginalSpec(aSrcMsgMailboxURI);
msgUrl->SetUri(aSrcMsgMailboxURI);
}
} // if we got a url
} // if we got a url
return rv;
}
void
macfactory_create_interface(void)
{
nsresult result;
nsIFactory* factory;
nsIMacLocale* mac_locale;
result = CallCreateInstance(kMacLocaleFactoryCID, &factory);
NS_ASSERTION(factory!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
factory->Release();
result = CallCreateInstance(kMacLocaleFactoryCID, &mac_locale);
NS_ASSERTION(posix_locale!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
mac_locale->Release();
}
void
factory_create_interface(void)
{
nsresult result;
nsILocaleFactory* localeFactory;
nsIFactory* genericFactory;
result = CallCreateInstance(kLocaleFactoryCID, &localeFactory);
NS_ASSERTION(localeFactory!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
localeFactory->Release();
result = CallCreateInstance(kLocaleFactoryCID, &genericFactory);
NS_ASSERTION(localeFactory!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
genericFactory->Release();
}
void
win32factory_create_interface(void)
{
nsresult result;
nsIFactory* factory;
nsIWin32Locale* win32Locale;
result = CallCreateInstance(kWin32LocaleFactoryCID, &factory);
NS_ASSERTION(factory!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
factory->Release();
result = CallCreateInstance(kWin32LocaleFactoryCID, &win32Locale);
NS_ASSERTION(win32Locale!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
win32Locale->Release();
}
nsresult nsEudoraCompose::CreateComponents( void)
{
nsresult rv = NS_OK;
if (!m_pIOService) {
IMPORT_LOG0( "Creating nsIOService\n");
NS_WITH_PROXIED_SERVICE(nsIIOService, service, NS_IOSERVICE_CONTRACTID, NS_PROXY_TO_MAIN_THREAD, &rv);
if (NS_FAILED(rv))
return( rv);
m_pIOService = service;
NS_IF_ADDREF( m_pIOService);
}
NS_IF_RELEASE( m_pMsgFields);
if (!m_pMsgSend) {
rv = CallCreateInstance( kMsgSendCID, &m_pMsgSend);
if (NS_SUCCEEDED( rv) && m_pMsgSend) {
rv = NS_GetProxyForObject( NS_PROXY_TO_MAIN_THREAD, NS_GET_IID(nsIMsgSend),
m_pMsgSend, NS_PROXY_SYNC, (void**)&m_pSendProxy);
if (NS_FAILED( rv)) {
m_pSendProxy = nsnull;
NS_RELEASE( m_pMsgSend);
m_pMsgSend = nsnull;
}
}
}
if (!m_pListener && NS_SUCCEEDED( rv)) {
rv = EudoraSendListener::CreateSendListener( &m_pListener);
}
if (NS_SUCCEEDED(rv) && m_pMsgSend) {
rv = CallCreateInstance( kMsgCompFieldsCID, &m_pMsgFields);
if (NS_SUCCEEDED(rv) && m_pMsgFields) {
// IMPORT_LOG0( "nsOutlookCompose - CreateComponents succeeded\n");
m_pMsgFields->SetForcePlainText( PR_FALSE);
return( NS_OK);
}
}
return NS_ERROR_FAILURE;
}
void
serivce_create_interface(void)
{
nsresult result;
nsILocaleService* localeService;
result = CallCreateInstance(kLocaleServiceCID, &localeService);
NS_ASSERTION(localeService!=NULL,"nsLocaleTest: service_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: service_create_interface failed");
localeService->Release();
}
static nsresult GetIconURLVariant(nsIFile* aApplication, nsIVariant* *_retval)
{
nsresult rv = CallCreateInstance("@mozilla.org/variant;1", _retval);
if (NS_FAILED(rv))
return rv;
nsCAutoString fileURLSpec;
NS_GetURLSpecFromFile(aApplication, fileURLSpec);
nsCAutoString iconURLSpec; iconURLSpec.AssignLiteral("moz-icon://");
iconURLSpec += fileURLSpec;
nsCOMPtr<nsIWritableVariant> writable(do_QueryInterface(*_retval));
writable->SetAsAUTF8String(iconURLSpec);
return NS_OK;
}
static nsresult PrepareMessageUrl(const char * messageURI,
nsIUrlListener * aUrlListener,
nsMailboxAction aMailboxAction,
nsIMailboxUrl ** aMailboxUrl,
nsIMsgWindow * aMsgWindow) {
nsAutoCString folderURI;
nsMsgKey msgKey;
char * part = NULL;
nsresult rv = ParseMessageURI(PromiseFlatCString(messageURI).get(),
folderURI, &msgKey, &part);
NS_ENSURE_SUCCESS(rv, rv);
rv = CallCreateInstance(MAIL_EWS_MSG_URL_CONTRACTID, aMailboxUrl);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMailboxUrl> mailboxurl(*aMailboxUrl);
nsCString msgUrlSpec(folderURI);
msgUrlSpec.AppendLiteral("?number=");
msgUrlSpec.AppendInt(msgKey, 10);
if (part) {
nsCString strPart;
strPart.Adopt(part);
msgUrlSpec.AppendLiteral("&");
msgUrlSpec.Append(strPart);
}
nsCOMPtr<nsIMsgMailNewsUrl> msgUrl;
msgUrl = do_QueryInterface(mailboxurl);
msgUrl->SetMsgWindow(aMsgWindow);
msgUrl->SetSpec(msgUrlSpec);
if (aUrlListener)
msgUrl->RegisterListener(aUrlListener);
nsCOMPtr<nsIMsgMessageUrl> url = do_QueryInterface(msgUrl);
if (url)
{
url->SetOriginalSpec(messageURI);
url->SetUri(messageURI);
}
//Update action the last step, since set spec will change the action
mailboxurl->SetMailboxAction(aMailboxAction);
return NS_OK;
}
void
win32locale_reverse_conversion_test(void)
{
nsresult result;
nsIWin32Locale* win32Locale;
result = CallCreateInstance(kWin32LocaleFactoryCID, &win32Locale);
NS_ASSERTION(win32Locale!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
//
// english and variants
//
win32Locale->Release();
}
NS_IMETHODIMP
nsPACMan::GetInterface(const nsIID &iid, void **result)
{
// In case loading the PAC file requires authentication.
if (iid.Equals(NS_GET_IID(nsIAuthPrompt)))
return CallCreateInstance(NS_DEFAULTAUTHPROMPT_CONTRACTID,
nsnull, iid, result);
// In case loading the PAC file results in a redirect.
if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) {
NS_ADDREF_THIS();
*result = static_cast<nsIChannelEventSink *>(this);
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
void InitTest(const char* creationPath, const char* appendPath)
{
nsILocalFile* file = nsnull;
nsresult rv = CallCreateInstance(NS_LOCAL_FILE_CONTRACTID, &file);
if (NS_FAILED(rv) || (!file))
{
printf("create nsILocalFile failed\n");
return;
}
nsCAutoString leafName;
Banner("InitWithPath");
printf("creationPath == %s\nappendPath == %s\n", creationPath, appendPath);
rv = file->InitWithNativePath(nsDependentCString(creationPath));
VerifyResult(rv);
printf("Getting Filename\n");
rv = file->GetNativeLeafName(leafName);
printf(" %s\n", leafName.get());
VerifyResult(rv);
printf("Appending %s \n", appendPath);
rv = file->AppendNative(nsDependentCString(appendPath));
VerifyResult(rv);
printf("Getting Filename\n");
rv = file->GetNativeLeafName(leafName);
printf(" %s\n", leafName.get());
VerifyResult(rv);
GetPaths(file);
printf("Check For Existence\n");
PRBool exists;
file->Exists(&exists);
if (exists)
printf("Yup!\n");
else
printf("no.\n");
}
void
win32locale_test(void)
{
nsresult result;
nsIWin32Locale* win32Locale;
nsAutoString locale;
LCID loc_id;
//
// test with a simple locale
//
locale.AssignLiteral("en-US");
loc_id = 0;
result = CallCreateInstance(kWin32LocaleFactoryCID, &win32Locale);
NS_ASSERTION(win32Locale!=NULL,"nsLocaleTest: factory_create_interface failed.");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: factory_create_interface failed");
result = win32Locale->GetPlatformLocale(locale,&loc_id);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetPlatformLocale failed.");
NS_ASSERTION(loc_id==MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),
"nsLocaleTest: GetPlatformLocale failed.");
//
// test with a not so simple locale
//
locale.AssignLiteral("x-netscape");
loc_id = 0;
result = win32Locale->GetPlatformLocale(locale,&loc_id);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetPlatformLocale failed.");
NS_ASSERTION(loc_id==MAKELCID(MAKELANGID(USER_DEFINED_PRIMARYLANG,USER_DEFINED_SUBLANGUAGE),SORT_DEFAULT),
"nsLocaleTest: GetPlatformLocale failed.");
locale.AssignLiteral("en");
loc_id = 0;
result = win32Locale->GetPlatformLocale(locale,&loc_id);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetPlatformLocale failed.");
NS_ASSERTION(loc_id==MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT),SORT_DEFAULT),
"nsLocaleTest: GetPlatformLocale failed.");
win32Locale->Release();
}
nsresult nsCollationFactory::CreateCollation(nsILocale* locale, nsICollation** instancePtr)
{
// Create a collation interface instance.
//
nsICollation *inst;
nsresult res;
res = CallCreateInstance(kCollationCID, &inst);
if (NS_FAILED(res)) {
return res;
}
inst->Initialize(locale);
*instancePtr = inst;
return res;
}
void
posixlocale_test(void)
{
nsresult result;
nsIPosixLocale* posix_locale;
nsAutoString locale;
char posix_locale_string[9];
//
// create the locale object
//
result = CallCreateInstance(kPosixLocaleFactoryCID, &posix_locale);
NS_ASSERTION(posix_locale!=NULL,"nsLocaleTest: create interface failed.\n");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: create interface failed\n");
//
// test with a simple locale
//
locale.AssignLiteral("en-US");
result = posix_locale->GetPlatformLocale(locale,posix_locale_string,9);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetPlatformLocale failed.\n");
NS_ASSERTION(strcmp("en_US",posix_locale_string)==0,"nsLocaleTest: GetPlatformLocale failed.\n");
//
// test with a not so simple locale
//
locale.AssignLiteral("x-netscape");
result = posix_locale->GetPlatformLocale(locale,posix_locale_string,9);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetPlatformLocale failed.\n");
NS_ASSERTION(strcmp("C",posix_locale_string)==0,"nsLocaleTest: GetPlatformLocale failed.\n");
//
// test with a generic locale
//
locale.AssignLiteral("en");
result = posix_locale->GetPlatformLocale(locale,posix_locale_string,9);
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: GetPlatformLocale failed.\n");
NS_ASSERTION(strcmp("en",posix_locale_string)==0,"nsLocaleTest: GetPlatformLocale failed.\n");
//
// release the locale interface
//
posix_locale->Release();
}
NS_IMETHODIMP
nsDateTimeHandler::NewURI(const nsACString &aSpec,
const char *aCharset, // ignore charset info
nsIURI *aBaseURI,
nsIURI **result) {
nsresult rv;
nsIURI* url;
rv = CallCreateInstance(kSimpleURICID, &url);
if (NS_FAILED(rv)) return rv;
rv = url->SetSpec(aSpec);
if (NS_FAILED(rv)) {
NS_RELEASE(url);
return rv;
}
*result = url;
return rv;
}
void
maclocale_test(void)
{
nsresult result;
nsIMacLocale* mac_locale;
nsString* locale;
short script_code;
//
// create the locale object
//
result = CallCreateInstance(kMacLocaleFactoryCID, &mac_locale);
NS_ASSERTION(posix_locale!=NULL,"nsLocaleTest: create interface failed.\n");
NS_ASSERTION(NS_SUCCEEDED(result),"nsLocaleTest: create interface failed\n");
//
// release the locale interface
//
mac_locale->Release();
}
//-------------------------------------------------------------------------
//
// Basic create.
//
//-------------------------------------------------------------------------
void nsBaseWidget::BaseCreate(nsIWidget *aParent,
const nsIntRect &aRect,
EVENT_CALLBACK aHandleEventFunction,
nsIDeviceContext *aContext,
nsIAppShell *aAppShell,
nsIToolkit *aToolkit,
nsWidgetInitData *aInitData)
{
if (nsnull == mToolkit) {
if (nsnull != aToolkit) {
mToolkit = (nsIToolkit*)aToolkit;
NS_ADDREF(mToolkit);
}
else {
if (nsnull != aParent) {
mToolkit = aParent->GetToolkit();
NS_IF_ADDREF(mToolkit);
}
// it's some top level window with no toolkit passed in.
// Create a default toolkit with the current thread
#if !defined(USE_TLS_FOR_TOOLKIT)
else {
static NS_DEFINE_CID(kToolkitCID, NS_TOOLKIT_CID);
nsresult res;
res = CallCreateInstance(kToolkitCID, &mToolkit);
NS_ASSERTION(NS_SUCCEEDED(res), "Can not create a toolkit in nsBaseWidget::Create");
if (mToolkit)
mToolkit->Init(PR_GetCurrentThread());
}
#else /* USE_TLS_FOR_TOOLKIT */
else {
nsresult rv;
rv = NS_GetCurrentToolkit(&mToolkit);
}
#endif /* USE_TLS_FOR_TOOLKIT */
}
}
static nsresult
SHA256(const char* aPlainText, nsAutoCString& aResult)
{
static nsICryptoHash* hasher = nullptr;
nsresult rv;
if (!hasher) {
rv = CallCreateInstance("@mozilla.org/security/hash;1", &hasher);
if (NS_FAILED(rv)) {
LOG(("nsHttpDigestAuth: no crypto hash!\n"));
return rv;
}
}
rv = hasher->Init(nsICryptoHash::SHA256);
NS_ENSURE_SUCCESS(rv, rv);
rv = hasher->Update((unsigned char*) aPlainText, strlen(aPlainText));
NS_ENSURE_SUCCESS(rv, rv);
rv = hasher->Finish(false, aResult);
return rv;
}
//
// Always set *identityInvalid == FALSE here. This
// will prevent the browser from popping up the authentication
// prompt window. Because GSSAPI does not have an API
// for fetching initial credentials (ex: A Kerberos TGT),
// there is no correct way to get the users credentials.
//
NS_IMETHODIMP
nsHttpNegotiateAuth::ChallengeReceived(nsIHttpAuthenticableChannel *authChannel,
const char *challenge,
bool isProxyAuth,
nsISupports **sessionState,
nsISupports **continuationState,
bool *identityInvalid)
{
nsIAuthModule *module = (nsIAuthModule *) *continuationState;
*identityInvalid = false;
if (module)
return NS_OK;
nsresult rv;
nsCOMPtr<nsIURI> uri;
rv = authChannel->GetURI(getter_AddRefs(uri));
if (NS_FAILED(rv))
return rv;
PRUint32 req_flags = nsIAuthModule::REQ_DEFAULT;
nsCAutoString service;
if (isProxyAuth) {
if (!TestBoolPref(kNegotiateAuthAllowProxies)) {
LOG(("nsHttpNegotiateAuth::ChallengeReceived proxy auth blocked\n"));
return NS_ERROR_ABORT;
}
nsCOMPtr<nsIProxyInfo> proxyInfo;
authChannel->GetProxyInfo(getter_AddRefs(proxyInfo));
NS_ENSURE_STATE(proxyInfo);
proxyInfo->GetHost(service);
}
else {
bool allowed = TestNonFqdn(uri) ||
TestPref(uri, kNegotiateAuthTrustedURIs);
if (!allowed) {
LOG(("nsHttpNegotiateAuth::ChallengeReceived URI blocked\n"));
return NS_ERROR_ABORT;
}
bool delegation = TestPref(uri, kNegotiateAuthDelegationURIs);
if (delegation) {
LOG((" using REQ_DELEGATE\n"));
req_flags |= nsIAuthModule::REQ_DELEGATE;
}
rv = uri->GetAsciiHost(service);
if (NS_FAILED(rv))
return rv;
}
LOG((" service = %s\n", service.get()));
//
// The correct service name for IIS servers is "HTTP/f.q.d.n", so
// construct the proper service name for passing to "gss_import_name".
//
// TODO: Possibly make this a configurable service name for use
// with non-standard servers that use stuff like "khttp/f.q.d.n"
// instead.
//
service.Insert("HTTP@", 0);
const char *contractID;
if (TestBoolPref(kNegotiateAuthSSPI)) {
LOG((" using negotiate-sspi\n"));
contractID = NS_AUTH_MODULE_CONTRACTID_PREFIX "negotiate-sspi";
}
else {
LOG((" using negotiate-gss\n"));
contractID = NS_AUTH_MODULE_CONTRACTID_PREFIX "negotiate-gss";
}
rv = CallCreateInstance(contractID, &module);
if (NS_FAILED(rv)) {
LOG((" Failed to load Negotiate Module \n"));
return rv;
}
rv = module->Init(service.get(), req_flags, nullptr, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_RELEASE(module);
return rv;
}
*continuationState = module;
return NS_OK;
}
int
main(int argc, char* argv[])
{
if (test_common_init(&argc, &argv) != 0)
return -1;
nsresult ret;
nsCOMPtr<nsIServiceManager> servMan;
NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull);
nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
NS_ASSERTION(registrar, "Null nsIComponentRegistrar");
registrar->AutoRegister(nsnull);
nsIInputStream* in = nsnull;
nsCOMPtr<nsIIOService> service(do_GetService(kIOServiceCID, &ret));
if (NS_FAILED(ret)) return ret;
nsCOMPtr<nsIEventQueueService> eventQService =
do_GetService(kEventQueueServiceCID, &ret);
if (NS_FAILED(ret)) return ret;
nsIChannel *channel = nsnull;
ret = service->NewChannel(NS_LITERAL_CSTRING(TEST_URL), nsnull, nsnull, &channel);
if (NS_FAILED(ret)) return ret;
nsIEventQueue *eventQ = nsnull;
ret = eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, &eventQ);
if (NS_FAILED(ret)) return ret;
ret = channel->Open(&in);
if (NS_FAILED(ret)) return ret;
nsIPersistentProperties* props;
ret = CallCreateInstance(kPersistentPropertiesCID, &props);
if (NS_FAILED(ret) || (!props)) {
printf("create nsIPersistentProperties failed\n");
return 1;
}
ret = props->Load(in);
if (NS_FAILED(ret)) {
printf("cannot load properties\n");
return 1;
}
int i = 1;
while (1) {
char name[16];
name[0] = 0;
sprintf(name, "%d", i);
nsAutoString v;
ret = props->GetStringProperty(nsDependentCString(name), v);
if (NS_FAILED(ret) || (!v.Length())) {
break;
}
char* value = ToNewCString(v);
if (value) {
printf("\"%d\"=\"%s\"\n", i, value);
delete[] value;
}
else {
printf("%d: ToNewCString failed\n", i);
}
i++;
}
nsCOMPtr<nsISimpleEnumerator> propEnum;
ret = props->Enumerate(getter_AddRefs(propEnum));
if (NS_FAILED(ret)) {
printf("cannot enumerate properties\n");
return 1;
}
printf("\nKey\tValue\n");
printf( "---\t-----\n");
PRBool hasMore;
while (NS_SUCCEEDED(propEnum->HasMoreElements(&hasMore)) &&
hasMore) {
nsCOMPtr<nsISupports> sup;
ret = propEnum->GetNext(getter_AddRefs(sup));
nsCOMPtr<nsIPropertyElement> propElem = do_QueryInterface(sup, &ret);
if (NS_FAILED(ret)) {
printf("failed to get current item\n");
return 1;
}
nsCAutoString key;
nsAutoString value;
ret = propElem->GetKey(key);
if (NS_FAILED(ret)) {
printf("failed to get current element's key\n");
return 1;
}
ret = propElem->GetValue(value);
if (NS_FAILED(ret)) {
printf("failed to get current element's value\n");
return 1;
}
printf("%s\t%s\n", key.get(), NS_ConvertUTF16toUTF8(value).get());
}
return 0;
}
nsresult Init() {
return CallCreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID, &mBlock);
}
int main(int argc, char *argv[])
{
nsCString topicA; topicA.Assign( "topic-A" );
nsCString topicB; topicB.Assign( "topic-B" );
nsresult rv;
nsresult res = CallCreateInstance("@mozilla.org/observer-service;1", &anObserverService);
if (res == NS_OK) {
nsIObserver *aObserver = new TestObserver(NS_LITERAL_STRING("Observer-A"));
aObserver->AddRef();
nsIObserver *bObserver = new TestObserver(NS_LITERAL_STRING("Observer-B"));
bObserver->AddRef();
printf("Adding Observer-A as observer of topic-A...\n");
rv = anObserverService->AddObserver(aObserver, topicA.get(), PR_FALSE);
testResult(rv);
printf("Adding Observer-B as observer of topic-A...\n");
rv = anObserverService->AddObserver(bObserver, topicA.get(), PR_FALSE);
testResult(rv);
printf("Adding Observer-B as observer of topic-B...\n");
rv = anObserverService->AddObserver(bObserver, topicB.get(), PR_FALSE);
testResult(rv);
printf("Testing Notify(observer-A, topic-A)...\n");
rv = anObserverService->NotifyObservers( aObserver,
topicA.get(),
NS_LITERAL_STRING("Testing Notify(observer-A, topic-A)").get() );
testResult(rv);
printf("Testing Notify(observer-B, topic-B)...\n");
rv = anObserverService->NotifyObservers( bObserver,
topicB.get(),
NS_LITERAL_STRING("Testing Notify(observer-B, topic-B)").get() );
testResult(rv);
printf("Testing EnumerateObserverList (for topic-A)...\n");
nsCOMPtr<nsISimpleEnumerator> e;
rv = anObserverService->EnumerateObservers(topicA.get(), getter_AddRefs(e));
testResult(rv);
printf("Enumerating observers of topic-A...\n");
if ( e ) {
nsCOMPtr<nsIObserver> observer;
PRBool loop = PR_TRUE;
while( NS_SUCCEEDED(e->HasMoreElements(&loop)) && loop)
{
e->GetNext(getter_AddRefs(observer));
printf("Calling observe on enumerated observer ");
printString(reinterpret_cast<TestObserver*>
(reinterpret_cast<void*>(observer.get()))->mName);
printf("...\n");
rv = observer->Observe( observer,
topicA.get(),
NS_LITERAL_STRING("during enumeration").get() );
testResult(rv);
}
}
printf("...done enumerating observers of topic-A\n");
printf("Removing Observer-A...\n");
rv = anObserverService->RemoveObserver(aObserver, topicA.get());
testResult(rv);
printf("Removing Observer-B (topic-A)...\n");
rv = anObserverService->RemoveObserver(bObserver, topicB.get());
testResult(rv);
printf("Removing Observer-B (topic-B)...\n");
rv = anObserverService->RemoveObserver(bObserver, topicA.get());
testResult(rv);
}
return NS_OK;
}
