Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 10:44:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fixes bug 124042 "support internationalized URIs" r=dougt, sr=alecf, a=asa

Browse Source
This commit is contained in:
darin%netscape.com 2002-03-06 07:48:55 +00:00
parent aa69c199eb
commit f1a6738b6c
373 changed files with 5638 additions and 5259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
accessible/src/base/nsRootAccessible.cpp
View File

@ -586,15 +586,15 @@ NS_IMETHODIMP nsDocAccessibleMixin::GetURL(nsAWritableString& aURL)
GetDocShellFromPS(presShell, getter_AddRefs(docShell));
nsCOMPtr<nsIWebNavigation> webNav(do_GetInterface(docShell));
nsXPIDLCString theURL;
nsCAutoString theURL;
if (webNav) {
nsCOMPtr<nsIURI> pURI;
webNav->GetCurrentURI(getter_AddRefs(pURI));
if (pURI)
pURI->GetSpec(getter_Copies(theURL));
pURI->GetSpec(theURL);
}
//XXXaaronl Need to use CopyUTF8toUCS2(nsDependentCString(theURL), aURL); when it's written
aURL.Assign(NS_ConvertUTF8toUCS2(theURL).get());
aURL.Assign(NS_ConvertUTF8toUCS2(theURL));
return NS_OK;
}

81
caps/src/nsCodebasePrincipal.cpp
View File

@ -151,19 +151,30 @@ nsCodebasePrincipal::GetURI(nsIURI **uri)
NS_IMETHODIMP
nsCodebasePrincipal::GetOrigin(char **origin)
{
nsXPIDLCString s;
if (NS_SUCCEEDED(mURI->GetHost(getter_Copies(s))))
return mURI->GetPrePath(origin);
nsresult rv;
nsCAutoString s;
if (NS_SUCCEEDED(mURI->GetHost(s)))
rv = mURI->GetPrePath(s);
else {
// Some URIs (e.g., nsSimpleURI) don't support host. Just
// get the full spec.
rv = mURI->GetSpec(s);
}
if (NS_FAILED(rv)) return rv;
// Some URIs (e.g., nsSimpleURI) don't support host. Just
// get the full spec.
return mURI->GetSpec(origin);
*origin = ToNewCString(s);
return *origin ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP
nsCodebasePrincipal::GetSpec(char **spec)
{
return mURI->GetSpec(spec);
nsCAutoString buf;
nsresult rv = mURI->GetSpec(buf);
if (NS_FAILED(rv)) return rv;
*spec = ToNewCString(buf);
return *spec ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
@ -189,44 +200,43 @@ nsCodebasePrincipal::Equals(nsIPrincipal *other, PRBool *result)
nsCOMPtr<nsIURI> otherURI;
if (NS_FAILED(otherCodebase->GetURI(getter_AddRefs(otherURI))))
return NS_ERROR_FAILURE;
nsXPIDLCString otherScheme;
nsresult rv = otherURI->GetScheme(getter_Copies(otherScheme));
nsXPIDLCString myScheme;
nsCAutoString otherScheme;
nsresult rv = otherURI->GetScheme(otherScheme);
nsCAutoString myScheme;
if (NS_SUCCEEDED(rv))
rv = mURI->GetScheme(getter_Copies(myScheme));
if (NS_SUCCEEDED(rv) && PL_strcmp(otherScheme, myScheme) == 0)
{
if (PL_strcmp(otherScheme, "file") == 0)
rv = mURI->GetScheme(myScheme);
if (NS_SUCCEEDED(rv) && strcmp(otherScheme.get(), myScheme.get()) == 0)
{
if (strcmp(otherScheme.get(), "file") == 0)
{
// All file: urls are considered to have the same origin.
*result = PR_TRUE;
}
else if (PL_strcmp(otherScheme, "imap") == 0 ||
PL_strcmp(otherScheme, "mailbox") == 0 ||
PL_strcmp(otherScheme, "news") == 0)
else if (strcmp(otherScheme.get(), "imap") == 0 ||
strcmp(otherScheme.get(), "mailbox") == 0 ||
strcmp(otherScheme.get(), "news") == 0)
{
// Each message is a distinct trust domain; use the
// whole spec for comparison
nsXPIDLCString otherSpec;
if (NS_FAILED(otherURI->GetSpec(getter_Copies(otherSpec))))
nsCAutoString otherSpec;
if (NS_FAILED(otherURI->GetSpec(otherSpec)))
return NS_ERROR_FAILURE;
nsXPIDLCString mySpec;
if (NS_FAILED(mURI->GetSpec(getter_Copies(mySpec))))
nsCAutoString mySpec;
if (NS_FAILED(mURI->GetSpec(mySpec)))
return NS_ERROR_FAILURE;
*result = PL_strcmp(otherSpec, mySpec) == 0;
*result = strcmp(otherSpec.get(), mySpec.get()) == 0;
}
else
{
// Need to check the host
nsXPIDLCString otherHost;
rv = otherURI->GetHost(getter_Copies(otherHost));
nsXPIDLCString myHost;
nsCAutoString otherHost;
rv = otherURI->GetHost(otherHost);
nsCAutoString myHost;
if (NS_SUCCEEDED(rv))
rv = mURI->GetHost(getter_Copies(myHost));
*result = NS_SUCCEEDED(rv) && PL_strcmp(otherHost, myHost) == 0;
rv = mURI->GetHost(myHost);
*result = NS_SUCCEEDED(rv) && strcmp(otherHost.get(), myHost.get()) == 0;
if (*result)
{
{
int otherPort;
rv = otherURI->GetPort(&otherPort);
int myPort;
@ -277,15 +287,12 @@ nsCodebasePrincipal::nsCodebasePrincipal() : mTrusted(PR_FALSE)
nsresult
nsCodebasePrincipal::Init(nsIURI *uri)
{
char *codebase;
if (uri == nsnull || NS_FAILED(uri->GetSpec(&codebase)))
nsCAutoString codebase;
if (uri == nsnull || NS_FAILED(uri->GetSpec(codebase)))
return NS_ERROR_FAILURE;
if (NS_FAILED(mJSPrincipals.Init(codebase)))
{
nsCRT::free(codebase);
if (NS_FAILED(mJSPrincipals.Init(ToNewCString(codebase))))
return NS_ERROR_FAILURE;
}
// JSPrincipals::Init adopts codebase, so no need to free now
// JSPrincipals::Init adopts its input
mURI = uri;
return NS_OK;
}
@ -298,7 +305,7 @@ nsCodebasePrincipal::InitFromPersistent(const char* aPrefName, const char* aURLS
{
nsresult rv;
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), aURLStr, nsnull);
rv = NS_NewURI(getter_AddRefs(uri), nsDependentCString(aURLStr), nsnull);
NS_ASSERTION(NS_SUCCEEDED(rv), "Malformed URI in security.principal preference.");
if (NS_FAILED(rv)) return rv;

60
caps/src/nsScriptSecurityManager.cpp
View File

@ -822,10 +822,10 @@ nsScriptSecurityManager::CheckLoadURIFromScript(JSContext *cx, nsIURI *aURI)
}
// Report error.
nsXPIDLCString spec;
if (NS_FAILED(aURI->GetSpec(getter_Copies(spec))))
nsCAutoString spec;
if (NS_FAILED(aURI->GetAsciiSpec(spec)))
return NS_ERROR_FAILURE;
JS_ReportError(cx, "illegal URL method '%s'", (const char *)spec);
JS_ReportError(cx, "illegal URL method '%s'", spec.get());
return NS_ERROR_DOM_BAD_URI;
}
@ -839,19 +839,19 @@ nsScriptSecurityManager::GetBaseURIScheme(nsIURI* aURI, char** aScheme)
nsCOMPtr<nsIURI> uri(aURI);
//-- get the source scheme
nsXPIDLCString scheme;
rv = uri->GetScheme(getter_Copies(scheme));
nsCAutoString scheme;
rv = uri->GetScheme(scheme);
if (NS_FAILED(rv)) return rv;
//-- If uri is a view-source URI, drill down to the base URI
nsXPIDLCString path;
while(PL_strcmp(scheme, "view-source") == 0)
nsCAutoString path;
while(PL_strcmp(scheme.get(), "view-source") == 0)
{
rv = uri->GetPath(getter_Copies(path));
rv = uri->GetPath(path);
if (NS_FAILED(rv)) return rv;
rv = NS_NewURI(getter_AddRefs(uri), path, nsnull);
if (NS_FAILED(rv)) return rv;
rv = uri->GetScheme(getter_Copies(scheme));
rv = uri->GetScheme(scheme);
if (NS_FAILED(rv)) return rv;
}
@ -866,30 +866,30 @@ nsScriptSecurityManager::GetBaseURIScheme(nsIURI* aURI, char** aScheme)
if (!uri) return NS_ERROR_FAILURE;
if (isJAR)
{
rv = uri->GetScheme(getter_Copies(scheme));
rv = uri->GetScheme(scheme);
if (NS_FAILED(rv)) return rv;
}
//-- if uri is an about uri, distinguish 'safe' and 'unsafe' about URIs
static const char aboutScheme[] = "about";
if(nsCRT::strcasecmp(scheme, aboutScheme) == 0)
*aScheme = PL_strdup(scheme);
if(nsCRT::strcasecmp(scheme.get(), aboutScheme) == 0)
*aScheme = nsCRT::strdup(scheme.get());
{
nsXPIDLCString spec;
if(NS_FAILED(uri->GetSpec(getter_Copies(spec))))
nsCAutoString spec;
if(NS_FAILED(uri->GetAsciiSpec(spec)))
return NS_ERROR_FAILURE;
const char* page = spec.get() + sizeof(aboutScheme);
if ((PL_strcmp(page, "blank") == 0) ||
(PL_strcmp(page, "") == 0) ||
(PL_strcmp(page, "mozilla") == 0) ||
(PL_strcmp(page, "credits") == 0))
if ((strcmp(page, "blank") == 0) ||
(strcmp(page, "") == 0) ||
(strcmp(page, "mozilla") == 0) ||
(strcmp(page, "credits") == 0))
{
*aScheme = PL_strdup("about safe");
*aScheme = nsCRT::strdup("about safe");
return *aScheme ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
}
*aScheme = PL_strdup(scheme);
*aScheme = nsCRT::strdup(scheme.get());
return *aScheme ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
@ -999,13 +999,13 @@ nsScriptSecurityManager::CheckLoadURI(nsIURI *aSourceURI, nsIURI *aTargetURI,
nsresult
nsScriptSecurityManager::ReportErrorToConsole(nsIURI* aTarget)
{
nsXPIDLCString spec;
nsresult rv = aTarget->GetSpec(getter_Copies(spec));
nsCAutoString spec;
nsresult rv = aTarget->GetAsciiSpec(spec);
if (NS_FAILED(rv)) return rv;
nsAutoString msg;
msg.Assign(NS_LITERAL_STRING("The link to "));
msg.AppendWithConversion(spec);
msg.AppendWithConversion(spec.get());
msg.Append(NS_LITERAL_STRING(" was blocked by the security manager.\nRemote content may not link to local content."));
// Report error in JS console
nsCOMPtr<nsIConsoleService> console(do_GetService("@mozilla.org/consoleservice;1"));
@ -1034,10 +1034,10 @@ nsScriptSecurityManager::CheckLoadURIStr(const char* aSourceURIStr, const char*
PRUint32 aFlags)
{
nsCOMPtr<nsIURI> source;
nsresult rv = NS_NewURI(getter_AddRefs(source), aSourceURIStr, nsnull);
nsresult rv = NS_NewURI(getter_AddRefs(source), nsDependentCString(aSourceURIStr), nsnull);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIURI> target;
rv = NS_NewURI(getter_AddRefs(target), aTargetURIStr, nsnull);
rv = NS_NewURI(getter_AddRefs(target), nsDependentCString(aTargetURIStr), nsnull);
NS_ENSURE_SUCCESS(rv, rv);
return CheckLoadURI(source, target, aFlags);
}
@ -1688,7 +1688,7 @@ Localize(const char *genericString, nsString &result)
return ret;
}
nsIURI *uri = nsnull;
ret = pNetService->NewURI(PROPERTIES_URL, nsnull, &uri);
ret = pNetService->NewURI(NS_LITERAL_CSTRING(PROPERTIES_URL), nsnull, nsnull, &uri);
if (NS_FAILED(ret))
{
NS_WARNING("cannot create URI\n");
@ -1715,18 +1715,16 @@ Localize(const char *genericString, nsString &result)
NS_WARNING("cannot get string service\n");
return ret;
}
char *spec = nsnull;
ret = url->GetSpec(&spec);
nsCAutoString spec;
ret = url->GetAsciiSpec(spec);
if (NS_FAILED(ret))
{
NS_WARNING("cannot get url spec\n");
nsServiceManager::ReleaseService(kStringBundleServiceCID, pStringService);
nsCRT::free(spec);
return ret;
}
nsIStringBundle *bundle = nsnull;
ret = pStringService->CreateBundle(spec, &bundle);
nsCRT::free(spec);
ret = pStringService->CreateBundle(spec.get(), &bundle);
nsServiceManager::ReleaseService(kStringBundleServiceCID, pStringService);
if (NS_FAILED(ret))
{

42
chrome/src/nsChromeProtocolHandler.cpp
View File

@ -52,6 +52,7 @@
#include "nsIEventQueueService.h"
#include "nsIFastLoadService.h"
#include "nsIFile.h"
#include "nsIFileURL.h"
#include "nsIFileChannel.h"
#include "nsIIOService.h"
#include "nsIJARChannel.h"
@ -60,11 +61,13 @@
#include "nsIObjectOutputStream.h"
#include "nsIScriptSecurityManager.h"
#include "nsIServiceManager.h"
#include "nsIStandardURL.h"
#include "nsIStreamListener.h"
#include "nsIXULPrototypeCache.h"
#include "nsIXULPrototypeDocument.h"
#include "nsNetCID.h"
#include "nsXPIDLString.h"
#include "nsString.h"
#include "prlog.h"
//----------------------------------------------------------------------
@ -515,11 +518,9 @@ nsChromeProtocolHandler::Create(nsISupports *aOuter, REFNSIID aIID, void **aResu
// nsIProtocolHandler methods:
NS_IMETHODIMP
nsChromeProtocolHandler::GetScheme(char* *result)
nsChromeProtocolHandler::GetScheme(nsACString &result)
{
*result = nsCRT::strdup("chrome");
if (*result == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
result = "chrome";
return NS_OK;
}
@ -546,7 +547,9 @@ nsChromeProtocolHandler::GetProtocolFlags(PRUint32 *result)
}
NS_IMETHODIMP
nsChromeProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
nsChromeProtocolHandler::NewURI(const nsACString &aSpec,
const char *aCharset,
nsIURI *aBaseURI,
nsIURI **result)
{
nsresult rv;
@ -554,26 +557,15 @@ nsChromeProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
// Chrome: URLs (currently) have no additional structure beyond that provided
// by standard URLs, so there is no "outer" given to CreateInstance
nsCOMPtr<nsIURI> url(do_CreateInstance(kStandardURLCID, &rv));
nsCOMPtr<nsIStandardURL> url(do_CreateInstance(kStandardURLCID, &rv));
if (NS_FAILED(rv))
return rv;
if (aBaseURI) {
nsXPIDLCString aResolvedURI;
rv = aBaseURI->Resolve(aSpec, getter_Copies(aResolvedURI));
if (NS_SUCCEEDED(rv))
rv = url->SetSpec(aResolvedURI);
}
else {
rv = url->SetSpec((char*)aSpec);
}
rv = url->Init(nsIStandardURL::URLTYPE_STANDARD, -1, aSpec, aCharset, aBaseURI);
if (NS_FAILED(rv))
return rv;
*result = url;
NS_ADDREF(*result);
return rv;
return CallQueryInterface(url, result);
}
NS_IMETHODIMP
@ -623,7 +615,7 @@ nsChromeProtocolHandler::NewChannel(nsIURI* aURI,
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIURI> chromeURI;
rv = ioServ->NewURI(spec, nsnull, getter_AddRefs(chromeURI));
rv = ioServ->NewURI(spec, nsnull, nsnull, getter_AddRefs(chromeURI));
if (NS_FAILED(rv)) return rv;
rv = ioServ->NewChannelFromURI(chromeURI, getter_AddRefs(result));
@ -649,11 +641,11 @@ nsChromeProtocolHandler::NewChannel(nsIURI* aURI,
// Get a system principal for xul files and set the owner
// property of the result
nsCOMPtr<nsIURL> url = do_QueryInterface(aURI);
nsXPIDLCString fileExtension;
rv = url->GetFileExtension(getter_Copies(fileExtension));
if (PL_strcasecmp(fileExtension, "xul") == 0 ||
PL_strcasecmp(fileExtension, "html") == 0 ||
PL_strcasecmp(fileExtension, "xml") == 0)
nsCAutoString fileExtension;
rv = url->GetFileExtension(fileExtension);
if (PL_strcasecmp(fileExtension.get(), "xul") == 0 ||
PL_strcasecmp(fileExtension.get(), "html") == 0 ||
PL_strcasecmp(fileExtension.get(), "xml") == 0)
{
nsCOMPtr<nsIScriptSecurityManager> securityManager =
do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);

60
chrome/src/nsChromeRegistry.cpp
View File

@ -221,7 +221,7 @@ NS_IMETHODIMP nsOverlayEnumerator::GetNext(nsISupports **aResult)
return rv;
nsCOMPtr<nsIURI> url;
rv = NS_NewURI(getter_AddRefs(url), NS_LossyConvertUCS2toASCII(valueStr).get());
rv = NS_NewURI(getter_AddRefs(url), NS_ConvertUCS2toUTF8(valueStr));
if (NS_FAILED(rv))
return NS_OK;
@ -387,16 +387,13 @@ SplitURL(nsIURI *aChromeURI, nsCString& aPackage, nsCString& aProvider, nsCStrin
nsresult rv;
nsXPIDLCString str;
rv = aChromeURI->GetSpec(getter_Copies(str));
nsCAutoString str;
rv = aChromeURI->GetSpec(str);
if (NS_FAILED(rv)) return rv;
if (!str.get())
return NS_ERROR_OUT_OF_MEMORY;
// We only want to deal with "chrome:" URLs here. We could return
// an error code if the URL isn't properly prefixed here...
if (PL_strncmp(str, kChromePrefix, sizeof(kChromePrefix) - 1) != 0)
if (PL_strncmp(str.get(), kChromePrefix, sizeof(kChromePrefix) - 1) != 0)
return NS_ERROR_INVALID_ARG;
// Cull out the "package" string; e.g., "navigator"
@ -497,7 +494,7 @@ nsChromeRegistry::Canonify(nsIURI* aChromeURI)
canonical += "/";
canonical += file;
return aChromeURI->SetSpec(canonical.get());
return aChromeURI->SetSpec(canonical);
}
NS_IMETHODIMP
@ -534,11 +531,11 @@ nsChromeRegistry::ConvertChromeURL(nsIURI* aChromeURL, char** aResult)
#ifdef DEBUG
if (NS_FAILED(rv)) {
nsCAutoString msg("chrome: failed to get base url");
nsXPIDLCString url;
rv = aChromeURL->GetSpec(getter_Copies(url));
nsCAutoString url;
rv = aChromeURL->GetSpec(url);
if (NS_SUCCEEDED(rv)) {
msg += " for ";
msg += (const char*)url;
msg += url.get();
}
msg += " -- using wacky default";
NS_WARNING(msg.get());
@ -858,10 +855,10 @@ NS_IMETHODIMP nsChromeRegistry::GetStyleSheets(nsIURI *aChromeURL, nsISupportsAr
nsCOMPtr<nsIURL> url(do_QueryInterface(supp));
if (url) {
nsCOMPtr<nsICSSStyleSheet> sheet;
nsXPIDLCString str;
rv = url->GetSpec(getter_Copies(str));
nsCAutoString str;
rv = url->GetSpec(str);
if (NS_FAILED(rv)) return rv;
rv = LoadStyleSheet(getter_AddRefs(sheet), nsCAutoString(str));
rv = LoadStyleSheet(getter_AddRefs(sheet), str);
if (NS_FAILED(rv)) return rv;
rv = (*aResult)->AppendElement(sheet) ? NS_OK : NS_ERROR_FAILURE;
if (NS_FAILED(rv)) return rv;
@ -894,13 +891,13 @@ NS_IMETHODIMP nsChromeRegistry::GetDynamicInfo(nsIURI *aChromeURL, PRBool aIsOve
if (NS_FAILED(rv)) return rv;
}
nsXPIDLCString lookup;
rv = aChromeURL->GetSpec(getter_Copies(lookup));
nsCAutoString lookup;
rv = aChromeURL->GetSpec(lookup);
if (NS_FAILED(rv)) return rv;
// Get the chromeResource from this lookup string
nsCOMPtr<nsIRDFResource> chromeResource;
rv = GetResource(nsCAutoString(lookup), getter_AddRefs(chromeResource));
rv = GetResource(lookup, getter_AddRefs(chromeResource));
if (NS_FAILED(rv)) {
NS_ERROR("Unable to retrieve the resource corresponding to the chrome skin or content.");
return rv;
@ -1345,7 +1342,7 @@ NS_IMETHODIMP nsChromeRegistry::WriteInfoToDataSource(const char *aDocURI,
nsresult rv;
nsCOMPtr<nsIURI> uri;
nsCAutoString str(aDocURI);
rv = NS_NewURI(getter_AddRefs(uri), str.get());
rv = NS_NewURI(getter_AddRefs(uri), str);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIRDFDataSource> dataSource;
@ -2529,13 +2526,7 @@ nsChromeRegistry::GetProfileRoot(nsCString& aFileURL)
if (NS_FAILED(rv))
return rv;
nsXPIDLCString urlSpec;
rv = NS_GetURLSpecFromFile(userChromeDir, getter_Copies(urlSpec));
if (NS_FAILED(rv))
return rv;
aFileURL = urlSpec;
return NS_OK;
return NS_GetURLSpecFromFile(userChromeDir, aFileURL);
}
NS_IMETHODIMP
@ -2550,13 +2541,7 @@ nsChromeRegistry::GetInstallRoot(nsCString& aFileURL)
if (NS_FAILED(rv) || !appChromeDir)
return NS_ERROR_FAILURE;
nsXPIDLCString urlSpec;
rv = NS_GetURLSpecFromFile(appChromeDir, getter_Copies(urlSpec));
if (NS_FAILED(rv))
return rv;
aFileURL = urlSpec;
return NS_OK;
return NS_GetURLSpecFromFile(appChromeDir, aFileURL);
}
NS_IMETHODIMP
@ -2719,7 +2704,7 @@ nsChromeRegistry::GetAgentSheets(nsIDocShell* aDocShell, nsISupportsArray **aRes
nsCOMPtr<nsIURI> docURL;
doc->GetDocumentURL(getter_AddRefs(docURL));
nsCOMPtr<nsIURI> url;
rv = NS_NewURI(getter_AddRefs(url), token, docURL);
rv = NS_NewURI(getter_AddRefs(url), nsDependentCString(token), nsnull, docURL);
PRBool enabled = PR_FALSE;
nsCOMPtr<nsICSSStyleSheet> sheet;
@ -2790,7 +2775,7 @@ nsChromeRegistry::GetUserSheets(PRBool aIsChrome, nsISupportsArray **aResult)
nsresult nsChromeRegistry::LoadStyleSheet(nsICSSStyleSheet** aSheet, const nsCString& aURL)
{
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_NewURI(getter_AddRefs(uri), aURL.get());
nsresult rv = NS_NewURI(getter_AddRefs(uri), aURL);
if (NS_FAILED(rv)) return rv;
rv = LoadStyleSheetWithURL(uri, aSheet);
@ -3084,11 +3069,8 @@ nsChromeRegistry::ProcessNewChromeBuffer(char *aBuffer, PRInt32 aLength)
/* xpidl strings aren't unified with strings, so this fu is necessary.
* all we want here is the canonical url
*/
nsXPIDLCString chromeURLfoopy;
rv = NS_GetURLSpecFromFile(chromeFile, getter_Copies(chromeURLfoopy));
if (NS_FAILED(rv))
return rv;
chromeURL = chromeURLfoopy;
rv = NS_GetURLSpecFromFile(chromeFile, chromeURL);
if (NS_FAILED(rv)) return rv;
/* if we're a file, we must be a jar file. do appropriate string munging.
* otherwise, the string we got from GetSpec is fine.

6
content/base/src/nsContentAreaDragDrop.cpp
View File

@ -298,9 +298,9 @@ nsContentAreaDragDrop::ExtractURLFromData(const nsACString & inFlavor, nsISuppor
nsCOMPtr<nsIIOService> ioService(do_GetService("@mozilla.org/network/io-service;1"));
nsCOMPtr<nsIFile> file(do_QueryInterface(inDataWrapper));
if ( ioService && file ) {
nsXPIDLCString url;
ioService->GetURLSpecFromFile(file, getter_Copies(url));
outURL = NS_ConvertUTF8toUCS2(url.get());
nsCAutoString url;
ioService->GetURLSpecFromFile(file, url);
outURL = NS_ConvertUTF8toUCS2(url);
}
}
}

8
content/base/src/nsDocument.cpp
View File

@ -3138,11 +3138,9 @@ nsDocument::GetBaseURI(nsAWritableString &aURI)
{
aURI.Truncate();
if (mDocumentBaseURL) {
nsXPIDLCString spec;
mDocumentBaseURL->GetSpec(getter_Copies(spec));
if (spec) {
CopyASCIItoUCS2(nsDependentCString(spec), aURI);
}
nsCAutoString spec;
mDocumentBaseURL->GetSpec(spec);
aURI = NS_ConvertUTF8toUCS2(spec);
}
return NS_OK;
}

15
content/base/src/nsDocumentViewer.cpp
View File

@ -1302,12 +1302,11 @@ DocumentViewerImpl::LoadComplete(nsresult aStatus)
mDocument->GetDocumentURL(getter_AddRefs(uri));
if (uri.get() != nsnull) {
//printf("DEBUG: getting spec fro uri (%p)\n", uri.get());
char *spec = nsnull;
uri->GetSpec(&spec);
if (spec && !strcmp(spec, "chrome://navigator/content/navigator.xul")) {
nsCAutoString spec;
uri->GetSpec(spec);
if (!strcmp(spec.get(), "chrome://navigator/content/navigator.xul")) {
NS_TIMELINE_MARK("Navigator Window visible now");
}
CRTFREEIF(spec);
}
}
#endif /* MOZ_TIMELINE */
@ -2461,11 +2460,9 @@ DocumentViewerImpl::GetWebShellTitleAndURL(nsIWebShell * aWebShell,
doc->GetDocumentURL(getter_AddRefs(url));
if (!url) return;
nsXPIDLCString urlCStr;
url->GetSpec(getter_Copies(urlCStr));
if (urlCStr.get()) {
*aURLStr = ToNewUnicode(urlCStr);
}
nsCAutoString urlCStr;
url->GetSpec(urlCStr);
*aURLStr = ToNewUnicode(NS_ConvertUTF8toUCS2(urlCStr));
}
//-------------------------------------------------------

10
content/base/src/nsGenericElement.cpp
View File

@ -237,11 +237,9 @@ nsNode3Tearoff::GetBaseURI(nsAWritableString& aURI)
}
if (uri) {
nsXPIDLCString spec;
uri->GetSpec(getter_Copies(spec));
CopyASCIItoUCS2(nsDependentCString(spec), aURI);
nsCAutoString spec;
uri->GetSpec(spec);
aURI = NS_ConvertUTF8toUCS2(spec);
}
return NS_OK;
@ -2623,7 +2621,7 @@ nsGenericElement::TriggerLink(nsIPresContext* aPresContext,
do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
nsCOMPtr<nsIURI> absURI;
if (NS_SUCCEEDED(rv))
rv = NS_NewURI(getter_AddRefs(absURI), absURLSpec, aBaseURL);
rv = NS_NewURI(getter_AddRefs(absURI), absURLSpec, nsnull, aBaseURL);
if (NS_SUCCEEDED(rv))
proceed = securityManager->CheckLoadURI(aBaseURL, absURI, nsIScriptSecurityManager::STANDARD);

8
content/base/src/nsScriptLoader.cpp
View File

@ -348,7 +348,7 @@ nsScriptLoader::ProcessScriptElement(nsIDOMHTMLScriptElement *aElement,
// Use the SRC attribute value to load the URL
mDocument->GetBaseURL(*getter_AddRefs(baseURI));
rv = NS_NewURI(getter_AddRefs(scriptURI), src, baseURI);
rv = NS_NewURI(getter_AddRefs(scriptURI), src, nsnull, baseURI);
if (NS_FAILED(rv)) {
return FireErrorNotification(rv, aElement, aObserver);
}
@ -568,10 +568,10 @@ nsScriptLoader::EvaluateScript(nsScriptLoadRequest* aRequest,
NS_ASSERTION(principal, "principal required for document");
nsAutoString ret;
nsXPIDLCString url;
nsCAutoString url;
if (aRequest->mURI) {
rv = aRequest->mURI->GetSpec(getter_Copies(url));
rv = aRequest->mURI->GetSpec(url);
if (NS_FAILED(rv)) {
return rv;
}
@ -580,7 +580,7 @@ nsScriptLoader::EvaluateScript(nsScriptLoadRequest* aRequest,
context->SetProcessingScriptTag(PR_TRUE);
PRBool isUndefined;
context->EvaluateString(aScript, nsnull, principal, url,
context->EvaluateString(aScript, nsnull, principal, url.get(),
aRequest->mLineNo, aRequest->mJSVersion,
ret, &isUndefined);

4
content/base/src/nsStyleSet.cpp
View File

@ -363,8 +363,8 @@ StyleSetImpl::StyleSetImpl()
NS_INIT_REFCNT();
if (gInstances++ == 0)
{
const char kQuirk_href[] = "resource:/res/quirk.css";
NS_NewURI (&gQuirkURI, kQuirk_href);
static const char kQuirk_href[] = "resource:/res/quirk.css";
NS_NewURI (&gQuirkURI, NS_LITERAL_CSTRING(kQuirk_href));
NS_ASSERTION (gQuirkURI != 0, "Cannot allocate nsStyleSetImpl::gQuirkURI");
}
}

2
content/base/src/nsSyncLoadService.cpp
View File

@ -210,7 +210,7 @@ nsSyncLoader::LoadDocument(nsIURI* documentURI, nsIDocument *aLoader, nsIDOMDocu
getter_AddRefs(DOMDocument));
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_OpenURI(getter_AddRefs(mChannel), documentURI, nsnull, loadGroup);
rv = NS_NewChannel(getter_AddRefs(mChannel), documentURI, nsnull, loadGroup);
NS_ENSURE_SUCCESS(rv, rv);
// Make sure we've been opened

4
content/build/nsContentDLF.cpp
View File

@ -317,7 +317,7 @@ nsContentDLF::CreateBlankDocument(nsILoadGroup *aLoadGroup, nsIDocument **aDocum
if (blankDoc) {
// initialize
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), "about:blank", 0);
NS_NewURI(getter_AddRefs(uri), NS_LITERAL_CSTRING("about:blank"));
if (uri)
rv = blankDoc->ResetToURI(uri, aLoadGroup);
}
@ -674,7 +674,7 @@ nsContentDLF::EnsureUAStyleSheet()
// Load the UA style sheet
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_NewURI(getter_AddRefs(uri), UA_CSS_URL);
nsresult rv = NS_NewURI(getter_AddRefs(uri), NS_LITERAL_CSTRING(UA_CSS_URL));
if (NS_FAILED(rv)) {
#ifdef DEBUG
printf("*** open of %s failed: error=%x\n", UA_CSS_URL, rv);

10
content/html/content/src/nsFormSubmission.cpp
View File

@ -302,8 +302,8 @@ nsFSURLEncoded::GetEncodedSubmission(nsIURI* aURI,
return NS_OK;
}
nsXPIDLCString path;
rv = aURI->GetPath(getter_Copies(path));
nsCAutoString path;
rv = aURI->GetPath(path);
NS_ENSURE_SUCCESS(rv, rv);
// Bug 42616: Trim off named anchor and save it to add later
PRInt32 namedAnchorPos = path.FindChar('#');
@ -324,7 +324,7 @@ nsFSURLEncoded::GetEncodedSubmission(nsIURI* aURI,
// Bug 42616: Add named anchor to end after query string
path.Append(mQueryString + namedAnchor);
aURI->SetPath(path.get());
aURI->SetPath(path);
}
return rv;
@ -736,8 +736,8 @@ nsFormSubmission::SubmitTo(nsIURI* aActionURL, const nsAString& aTarget,
nsCOMPtr<nsILinkHandler> handler;
aPresContext->GetLinkHandler(getter_AddRefs(handler));
if (handler) {
nsXPIDLCString actionURLSpec;
aActionURL->GetSpec(getter_Copies(actionURLSpec));
nsCAutoString actionURLSpec;
aActionURL->GetSpec(actionURLSpec);
handler->OnLinkClick(aSource, eLinkVerb_Replace,
NS_ConvertUTF8toUCS2(actionURLSpec).get(),

117
content/html/content/src/nsGenericHTMLElement.cpp
View File

@ -68,6 +68,7 @@
#include "nsISupportsArray.h"
#include "nsIURL.h"
#include "nsNetUtil.h"
#include "nsEscape.h"
#include "nsStyleConsts.h"
#include "nsIFrame.h"
#include "nsIScrollableFrame.h"
@ -1416,8 +1417,7 @@ nsGenericHTMLElement::HandleDOMEventForAnchors(nsIContent* aOuter,
// Only bother to handle the mouse event if there was an href
// specified.
if (hrefCStr) {
nsAutoString href;
href.AssignWithConversion(hrefCStr);
NS_ConvertUTF8toUCS2 href(hrefCStr);
// Strip off any unneeded CF/LF (for Bug 52119)
// It can't be done in the parser because of Bug 15204
href.StripChars("\r\n");
@ -2261,7 +2261,7 @@ nsGenericHTMLElement::GetBaseURL(const nsHTMLValue& aBaseHref,
nsIURI* url = nsnull;
{
result = NS_NewURI(&url, baseHref, docBaseURL);
result = NS_NewURI(&url, baseHref, nsnull, docBaseURL);
}
NS_IF_RELEASE(docBaseURL);
*aBaseURL = url;
@ -4483,10 +4483,10 @@ nsGenericHTMLElement::SetProtocolInHrefString(const nsAReadableString &aHref,
aProtocol.EndReading(end);
nsAString::const_iterator iter(start);
FindCharInReadable(':', iter, end);
uri->SetScheme(NS_ConvertUCS2toUTF8(Substring(start, iter)).get());
uri->SetScheme(NS_ConvertUCS2toUTF8(Substring(start, iter)));
nsXPIDLCString newHref;
uri->GetSpec(getter_Copies(newHref));
nsCAutoString newHref;
uri->GetSpec(newHref);
aResult.Assign(NS_ConvertUTF8toUCS2(newHref));
@ -4505,10 +4505,10 @@ nsGenericHTMLElement::SetHostnameInHrefString(const nsAReadableString &aHref,
if (NS_FAILED(rv))
return rv;
uri->SetHost(NS_ConvertUCS2toUTF8(aHostname).get());
uri->SetHost(NS_ConvertUCS2toUTF8(aHostname));
nsXPIDLCString newHref;
uri->GetSpec(getter_Copies(newHref));
nsCAutoString newHref;
uri->GetSpec(newHref);
aResult.Assign(NS_ConvertUTF8toUCS2(newHref));
@ -4531,10 +4531,10 @@ nsGenericHTMLElement::SetPathnameInHrefString(const nsAReadableString &aHref,
if (NS_FAILED(rv))
return rv;
url->SetFilePath(NS_ConvertUCS2toUTF8(aPathname).get());
url->SetFilePath(NS_ConvertUCS2toUTF8(aPathname));
nsXPIDLCString newHref;
uri->GetSpec(getter_Copies(newHref));
nsCAutoString newHref;
uri->GetSpec(newHref);
aResult.Assign(NS_ConvertUTF8toUCS2(newHref));
return NS_OK;
@ -4555,17 +4555,17 @@ nsGenericHTMLElement::SetHostInHrefString(const nsAReadableString &aHref,
if (NS_FAILED(rv))
return rv;
nsXPIDLCString scheme;
uri->GetScheme(getter_Copies(scheme));
nsXPIDLCString preHost;
uri->GetPreHost(getter_Copies(preHost));
nsXPIDLCString path;
uri->GetPath(getter_Copies(path));
nsCAutoString scheme, userpass, path;
uri->GetScheme(scheme);
uri->GetUserPass(userpass);
uri->GetPath(path);
if (!userpass.IsEmpty())
userpass.Append('@');
aResult.Assign(NS_ConvertUTF8toUCS2(scheme) + NS_LITERAL_STRING("://") +
NS_ConvertUTF8toUCS2(preHost) + aHost +
NS_ConvertUTF8toUCS2(userpass) + aHost +
NS_ConvertUTF8toUCS2(path));
return NS_OK;
}
@ -4586,10 +4586,10 @@ nsGenericHTMLElement::SetSearchInHrefString(const nsAReadableString &aHref,
if (NS_FAILED(rv))
return rv;
url->SetQuery(NS_ConvertUCS2toUTF8(aSearch).get());
url->SetQuery(NS_ConvertUCS2toUTF8(aSearch));
nsXPIDLCString newHref;
uri->GetSpec(getter_Copies(newHref));
nsCAutoString newHref;
uri->GetSpec(newHref);
aResult.Assign(NS_ConvertUTF8toUCS2(newHref));
return NS_OK;
@ -4612,10 +4612,10 @@ nsGenericHTMLElement::SetHashInHrefString(const nsAReadableString &aHref,
if (NS_FAILED(rv))
return rv;
rv = url->SetRef(NS_ConvertUCS2toUTF8(aHash).get());
rv = url->SetRef(NS_ConvertUCS2toUTF8(aHash));
nsXPIDLCString newHref;
uri->GetSpec(getter_Copies(newHref));
nsCAutoString newHref;
uri->GetSpec(newHref);
aResult.Assign(NS_ConvertUTF8toUCS2(newHref));
return NS_OK;
@ -4641,8 +4641,8 @@ nsGenericHTMLElement::SetPortInHrefString(const nsAReadableString &aHref,
uri->SetPort(port);
nsXPIDLCString newHref;
uri->GetSpec(getter_Copies(newHref));
nsCAutoString newHref;
uri->GetSpec(newHref);
aResult.Assign(NS_ConvertUTF8toUCS2(newHref));
return NS_OK;
@ -4658,12 +4658,10 @@ nsGenericHTMLElement::GetProtocolFromHrefString(const nsAReadableString& aHref,
NS_ENSURE_TRUE(nsHTMLUtils::IOService, NS_ERROR_FAILURE);
nsXPIDLCString protocol;
nsCAutoString protocol;
nsresult rv =
nsHTMLUtils::IOService->ExtractScheme(NS_ConvertUCS2toUTF8(aHref).get(),
nsnull, nsnull,
getter_Copies(protocol));
nsHTMLUtils::IOService->ExtractScheme(NS_ConvertUCS2toUTF8(aHref), protocol);
if (NS_SUCCEEDED(rv)) {
aProtocol.Assign(NS_ConvertASCIItoUCS2(protocol) + NS_LITERAL_STRING(":"));
@ -4681,7 +4679,7 @@ nsGenericHTMLElement::GetProtocolFromHrefString(const nsAReadableString& aHref,
}
if (uri) {
uri->GetScheme(getter_Copies(protocol));
uri->GetScheme(protocol);
}
if (protocol.IsEmpty()) {
@ -4708,22 +4706,12 @@ nsGenericHTMLElement::GetHostFromHrefString(const nsAReadableString& aHref,
if (NS_FAILED(rv))
return rv;
nsXPIDLCString host;
rv = uri->GetHost(getter_Copies(host));
nsCAutoString hostport;
rv = uri->GetHostPort(hostport);
if (NS_FAILED(rv))
return rv;
aHost.Assign(NS_ConvertASCIItoUCS2(host));
PRInt32 port;
uri->GetPort(&port);
if (-1 != port) {
aHost.Append(PRUnichar(':'));
nsAutoString portStr;
portStr.AppendInt(port, 10);
aHost.Append(portStr);
}
aHost.Assign(NS_ConvertUTF8toUCS2(hostport));
return NS_OK;
}
@ -4738,13 +4726,12 @@ nsGenericHTMLElement::GetHostnameFromHrefString(const nsAReadableString& aHref,
if (NS_FAILED(rv))
return rv;
nsXPIDLCString host;
rv = url->GetHost(getter_Copies(host));
nsCAutoString host;
rv = url->GetHost(host);
if (NS_FAILED(rv))
return rv;
CopyASCIItoUCS2(host, aHostname);
aHostname.Assign(NS_ConvertUTF8toUCS2(host));
return NS_OK;
}
@ -4764,14 +4751,12 @@ nsGenericHTMLElement::GetPathnameFromHrefString(const nsAReadableString& aHref,
if (NS_FAILED(rv))
return rv;
nsXPIDLCString file;
rv = url->GetFilePath(getter_Copies(file));
nsCAutoString file;
rv = url->GetFilePath(file);
if (NS_FAILED(rv))
return rv;
// XXX is filepath really ASCII and not UTF8?
CopyASCIItoUCS2(file, aPathname);
aPathname.Assign(NS_ConvertUTF8toUCS2(file));
return NS_OK;
}
@ -4791,16 +4776,13 @@ nsGenericHTMLElement::GetSearchFromHrefString(const nsAReadableString& aHref,
if (NS_FAILED(rv))
return rv;
nsXPIDLCString search;
rv = url->GetEscapedQuery(getter_Copies(search));
nsCAutoString search;
rv = url->GetQuery(search);
if (NS_FAILED(rv))
return rv;
if (!search.IsEmpty()) {
// XXX is escapedQuery really ASCII or UTF8
CopyASCIItoUCS2(NS_LITERAL_CSTRING("?") + search, aSearch);
}
if (!search.IsEmpty())
aSearch.Assign(NS_LITERAL_STRING("?") + NS_ConvertUTF8toUCS2(search));
return NS_OK;
}
@ -4849,14 +4831,13 @@ nsGenericHTMLElement::GetHashFromHrefString(const nsAReadableString& aHref,
if (NS_FAILED(rv))
return rv;
nsXPIDLCString ref;
rv = url->GetRef(getter_Copies(ref));
nsCAutoString ref;
rv = url->GetRef(ref);
if (NS_FAILED(rv))
return rv;
NS_UnescapeURL(ref); // XXX may result in random non-ASCII bytes!
if (!ref.IsEmpty()) {
CopyASCIItoUCS2(NS_LITERAL_CSTRING("#") + ref, aHash);
}
if (!ref.IsEmpty())
aHash.Assign(NS_LITERAL_STRING("#") + NS_ConvertASCIItoUCS2(ref));
return NS_OK;
}

4
content/html/content/src/nsHTMLAnchorElement.cpp
View File

@ -775,9 +775,11 @@ nsHTMLAnchorElement::GetHrefCString(char* &aBuf)
if (baseURL) {
// Get absolute URL.
NS_MakeAbsoluteURIWithCharset(&aBuf, relURLSpec, mDocument, baseURL,
nsCAutoString buf;
NS_MakeAbsoluteURIWithCharset(buf, relURLSpec, mDocument, baseURL,
nsHTMLUtils::IOService,
nsHTMLUtils::CharsetMgr);
aBuf = ToNewCString(buf);
}
else {
// Absolute URL is same as relative URL.

4
content/html/content/src/nsHTMLAreaElement.cpp
View File

@ -516,8 +516,10 @@ nsHTMLAreaElement::GetHrefCString(char* &aBuf)
if (baseURL) {
// Get absolute URL.
NS_MakeAbsoluteURIWithCharset(&aBuf, relURLSpec, mDocument, baseURL,
nsCAutoString buf;
NS_MakeAbsoluteURIWithCharset(buf, relURLSpec, mDocument, baseURL,
nsHTMLUtils::IOService, nsHTMLUtils::CharsetMgr);
aBuf = ToNewCString(buf);
}
else {
// Absolute URL is same as relative URL.

2
content/html/content/src/nsHTMLFormElement.cpp
View File

@ -900,7 +900,7 @@ nsHTMLFormElement::GetActionURL(nsIURI** aActionURL)
rv = docURL->Clone(getter_AddRefs(actionURL));
NS_ENSURE_SUCCESS(rv, rv);
} else {
rv = NS_NewURI(getter_AddRefs(actionURL), action, docURL);
rv = NS_NewURI(getter_AddRefs(actionURL), action, nsnull, docURL);
NS_ENSURE_SUCCESS(rv, rv);
}

2
content/html/content/src/nsHTMLImageElement.cpp
View File

@ -913,7 +913,7 @@ nsHTMLImageElement::SetSrcInner(nsIURI* aBaseURL,
}
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), aSrc, aBaseURL);
result = NS_NewURI(getter_AddRefs(uri), aSrc, nsnull, aBaseURL);
if (NS_FAILED(result)) return result;
nsCOMPtr<nsIDocument> document;

4
content/html/content/src/nsHTMLLinkElement.cpp
View File

@ -397,9 +397,11 @@ nsHTMLLinkElement::GetHrefCString(char* &aBuf)
if (baseURL) {
// Get absolute URL.
NS_MakeAbsoluteURIWithCharset(&aBuf, relURLSpec, mDocument, baseURL,
nsCAutoString buf;
NS_MakeAbsoluteURIWithCharset(buf, relURLSpec, mDocument, baseURL,
nsHTMLUtils::IOService,
nsHTMLUtils::CharsetMgr);
aBuf = ToNewCString(buf);
}
else {
// Absolute URL is same as relative URL.

4
content/html/content/src/nsHTMLScriptElement.cpp
View File

@ -327,8 +327,8 @@ nsHTMLScriptElement::ScriptAvailable(nsresult aResult,
NS_NAMED_LITERAL_STRING(errorString, "Error loading script");
event.errorMsg = errorString.get();
nsXPIDLCString spec;
aURI->GetSpec(getter_Copies(spec));
nsCAutoString spec;
aURI->GetSpec(spec);
NS_ConvertUTF8toUCS2 fileName(spec);

4
content/html/content/src/nsHTMLStyleElement.cpp
View File

@ -285,9 +285,11 @@ nsHTMLStyleElement::GetHrefCString(char* &aBuf)
if (baseURL) {
// Get absolute URL.
NS_MakeAbsoluteURIWithCharset(&aBuf, relURLSpec, mDocument, baseURL,
nsCAutoString buf;
NS_MakeAbsoluteURIWithCharset(buf, relURLSpec, mDocument, baseURL,
nsHTMLUtils::IOService,
nsHTMLUtils::CharsetMgr);
aBuf = ToNewCString(buf);
}
else {
// Absolute URL is same as relative URL.

27
content/html/document/src/nsHTMLContentSink.cpp
View File

@ -574,7 +574,7 @@ DummyParserRequest::DummyParserRequest(nsIHTMLContentSink* aSink)
if (gRefCnt++ == 0) {
nsresult rv;
rv = NS_NewURI(&gURI, "about:parser-dummy-request", nsnull);
rv = NS_NewURI(&gURI, NS_LITERAL_CSTRING("about:parser-dummy-request"));
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create about:parser-dummy-request");
}
@ -2624,12 +2624,11 @@ HTMLContentSink::Init(nsIDocument* aDoc,
mContextStack.AppendElement(mCurrentContext);
#ifdef NS_DEBUG
char* spec;
(void)aURL->GetSpec(&spec);
nsCAutoString spec;
(void)aURL->GetSpec(spec);
SINK_TRACE(SINK_TRACE_CALLS,
("HTMLContentSink::Init: this=%p url='%s'",
this, spec));
nsCRT::free(spec);
this, spec.get()));
#endif
MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::Init()\n"));
@ -3936,21 +3935,19 @@ HTMLContentSink::StartLayout()
// frameset document, disable the scroll bars on the views.
if (mDocumentURI) {
nsXPIDLCString ref;
nsCAutoString ref;
// Since all URI's that pass through here aren't URL's we can't
// rely on the nsIURI implementation for providing a way for
// finding the 'ref' part of the URI, we'll haveto revert to
// string routines for finding the data past '#'
rv = mDocumentURI->GetSpec(getter_Copies(ref));
nsDependentCString refstr(ref);
rv = mDocumentURI->GetSpec(ref);
nsReadingIterator<char> start, end;
refstr.BeginReading(start);
refstr.EndReading(end);
ref.BeginReading(start);
ref.EndReading(end);
if (FindCharInReadable('#', start, end)) {
++start; // Skip over the '#'
@ -4454,7 +4451,7 @@ HTMLContentSink::ProcessStyleLink(nsIHTMLContent* aElement,
if (isStyleSheet) {
nsIURI* url = nsnull;
{
result = NS_NewURI(&url, aHref, mDocumentBaseURL);
result = NS_NewURI(&url, aHref, nsnull, mDocumentBaseURL);
}
if (NS_OK != result) {
return NS_OK; // The URL is bad, move along, don't propagate the error (for now)
@ -5324,9 +5321,9 @@ HTMLContentSink::DumpContentModel()
mDocument->GetRootContent(&root);
if(root) {
if(mDocumentURI) {
char* buff[1]={0};
mDocumentURI->GetSpec(buff);
fputs(buff[0],out);
nsCAutoString buf;
mDocumentURI->GetSpec(buf);
fputs(buf.get(),out);
}
fputs(";",out);
result=root->DumpContent(out,0,PR_FALSE);

81
content/html/document/src/nsHTMLDocument.cpp
View File

@ -41,6 +41,7 @@
#include "nsCOMPtr.h"
#include "nsIFileChannel.h"
#include "nsXPIDLString.h"
#include "nsPrintfCString.h"
#include "nsReadableUtils.h"
#include "nsUnicharUtils.h"
#include "nsHTMLDocument.h"
@ -607,7 +608,7 @@ nsHTMLDocument::TryCacheCharset(nsICacheEntryDescriptor* aCacheDescriptor,
}
PRBool
nsHTMLDocument::TryBookmarkCharset(nsXPIDLCString* aUrlSpec,
nsHTMLDocument::TryBookmarkCharset(nsAFlatCString* aUrlSpec,
PRInt32& aCharsetSource,
nsAString& aCharset)
{
@ -621,7 +622,7 @@ nsHTMLDocument::TryBookmarkCharset(nsXPIDLCString* aUrlSpec,
if (bookmarks) {
if (aUrlSpec) {
nsXPIDLString pBookmarkedCharset;
rv = bookmarks->GetLastCharset(*aUrlSpec, getter_Copies(pBookmarkedCharset));
rv = bookmarks->GetLastCharset(aUrlSpec->get(), getter_Copies(pBookmarkedCharset));
if (NS_SUCCEEDED(rv) && (rv != NS_RDF_NO_VALUE)) {
aCharset = pBookmarkedCharset;
aCharsetSource = kCharsetFromBookmarks;
@ -947,11 +948,11 @@ nsHTMLDocument::StartDocumentLoad(const char* aCommand,
}
}
nsXPIDLCString scheme;
aURL->GetScheme(getter_Copies(scheme));
nsCAutoString scheme;
aURL->GetScheme(scheme);
nsXPIDLCString urlSpec;
aURL->GetSpec(getter_Copies(urlSpec));
nsCAutoString urlSpec;
aURL->GetSpec(urlSpec);
PRInt32 charsetSource = kCharsetUninitialized;
nsAutoString charset;
@ -968,11 +969,11 @@ nsHTMLDocument::StartDocumentLoad(const char* aCommand,
if (TryHttpHeaderCharset(httpChannel, charsetSource, charset)) {
// Use the header's charset.
}
else if (scheme && nsCRT::strcasecmp("about", scheme) && // don't try to access bookmarks for about:blank
else if (nsCRT::strcasecmp("about", scheme.get()) && // don't try to access bookmarks for about:blank
TryBookmarkCharset(&urlSpec, charsetSource, charset)) {
// Use the bookmark's charset.
}
else if (cacheDescriptor && urlSpec &&
else if (cacheDescriptor && !urlSpec.IsEmpty() &&
TryCacheCharset(cacheDescriptor, charsetSource, charset)) {
// Use the cache's charset.
}
@ -1800,11 +1801,9 @@ nsHTMLDocument::GetBaseURI(nsAWritableString &aURI)
aURI.Truncate();
nsCOMPtr<nsIURI> uri(do_QueryInterface(mBaseURL ? mBaseURL : mDocumentURL));
if (uri) {
nsXPIDLCString spec;
uri->GetSpec(getter_Copies(spec));
if (spec) {
CopyASCIItoUCS2(nsDependentCString(spec), aURI);
}
nsCAutoString spec;
uri->GetSpec(spec);
aURI = NS_ConvertUTF8toUCS2(spec);
}
return NS_OK;
}
@ -1872,11 +1871,10 @@ nsHTMLDocument::GetDomain(nsAWritableString& aDomain)
if (NS_FAILED(GetDomainURI(getter_AddRefs(uri))))
return NS_ERROR_FAILURE;
char *hostName;
if (NS_FAILED(uri->GetHost(&hostName)))
nsCAutoString hostName;
if (NS_FAILED(uri->GetHost(hostName)))
return NS_ERROR_FAILURE;
aDomain.Assign(NS_ConvertASCIItoUCS2(hostName));
nsCRT::free(hostName);
aDomain.Assign(NS_ConvertUTF8toUCS2(hostName));
return NS_OK;
}
@ -1909,16 +1907,14 @@ nsHTMLDocument::SetDomain(const nsAReadableString& aDomain)
nsCOMPtr<nsIURI> uri;
if (NS_FAILED(GetDomainURI(getter_AddRefs(uri))))
return NS_ERROR_FAILURE;
nsXPIDLCString scheme;
if (NS_FAILED(uri->GetScheme(getter_Copies(scheme))))
nsCAutoString scheme;
if (NS_FAILED(uri->GetScheme(scheme)))
return NS_ERROR_FAILURE;
nsXPIDLCString path;
if (NS_FAILED(uri->GetPath(getter_Copies(path))))
nsCAutoString path;
if (NS_FAILED(uri->GetPath(path)))
return NS_ERROR_FAILURE;
nsAutoString newURIString; newURIString.AssignWithConversion( NS_STATIC_CAST(const char*, scheme) );
newURIString.Append(NS_LITERAL_STRING("://"));
newURIString += aDomain;
newURIString.AppendWithConversion(path);
NS_ConvertUTF8toUCS2 newURIString(scheme);
newURIString += NS_LITERAL_STRING("://") + aDomain + NS_ConvertUTF8toUCS2(path);
nsIURI *newURI;
if (NS_FAILED(NS_NewURI(&newURI, newURIString)))
return NS_ERROR_FAILURE;
@ -1959,10 +1955,9 @@ NS_IMETHODIMP
nsHTMLDocument::GetURL(nsAWritableString& aURL)
{
if (nsnull != mDocumentURL) {
char* str;
mDocumentURL->GetSpec(&str);
aURL.Assign(NS_ConvertASCIItoUCS2(str));
nsCRT::free(str);
nsCAutoString str;
mDocumentURL->GetSpec(str);
aURL.Assign(NS_ConvertUTF8toUCS2(str));
}
return NS_OK;
}
@ -2268,7 +2263,7 @@ nsHTMLDocument::OpenCommon(nsIURI* aSourceURL)
nsCOMPtr<nsIChannel> channel;
nsCOMPtr<nsILoadGroup> group = do_QueryReferent(mDocumentLoadGroup);
result = NS_OpenURI(getter_AddRefs(channel), aSourceURL, nsnull, group);
result = NS_NewChannel(getter_AddRefs(channel), aSourceURL, nsnull, group);
if (NS_FAILED(result)) return result;
@ -2432,7 +2427,7 @@ nsHTMLDocument::Open(nsIDOMDocument** aReturn)
result = GetSourceDocumentURL(cx, getter_AddRefs(sourceURL));
// Recover if we had a problem obtaining the source URL
if (!sourceURL) {
result = NS_NewURI(getter_AddRefs(sourceURL), "about:blank");
result = NS_NewURI(getter_AddRefs(sourceURL), NS_LITERAL_CSTRING("about:blank"));
}
if (NS_SUCCEEDED(result)) {
@ -2560,14 +2555,14 @@ nsHTMLDocument::ScriptWriteCommon(PRBool aNewlineTerminate)
NS_ENSURE_SUCCESS(rv, rv);
}
nsXPIDLCString spec;
nsCAutoString spec;
if (mDocumentURL) {
rv = mDocumentURL->GetSpec(getter_Copies(spec));
rv = mDocumentURL->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
}
if (!mDocumentURL || nsCRT::strcasecmp(spec, "about:blank") == 0) {
if (!mDocumentURL || nsCRT::strcasecmp(spec.get(), "about:blank") == 0) {
// The current document's URL and principal are empty or "about:blank".
// By writing to this document, the script acquires responsibility for the
// document for security purposes. Thus a document.write of a script tag
@ -3825,17 +3820,15 @@ nsresult
nsHTMLDocument::CreateAndAddWyciwygChannel(void)
{
nsresult rv = NS_OK;
nsAutoString url;
nsXPIDLCString originalSpec, urlPart;
nsCAutoString url, originalSpec;
mDocumentURL->GetSpec(getter_Copies(originalSpec));
mDocumentURL->GetSpec(originalSpec);
// Generate the wyciwyg url
url.Assign(NS_LITERAL_STRING( "wyciwyg://" ));
url.AppendInt(mWyciwygSessionCnt++, 10);
url.Append(NS_LITERAL_STRING("/"));
url.Append(NS_ConvertUTF8toUCS2(originalSpec));
url = NS_LITERAL_CSTRING("wyciwyg://")
+ nsPrintfCString("%d", mWyciwygSessionCnt++)
+ NS_LITERAL_CSTRING("/")
+ originalSpec;
nsCOMPtr<nsIURI> wcwgURI;
NS_NewURI(getter_AddRefs(wcwgURI), url);
@ -3844,10 +3837,10 @@ nsHTMLDocument::CreateAndAddWyciwygChannel(void)
// out-of-band document.write() script to cache
nsCOMPtr<nsIChannel> channel;
// Create a wyciwyg Channel
rv = NS_OpenURI(getter_AddRefs(channel), wcwgURI);
rv = NS_NewChannel(getter_AddRefs(channel), wcwgURI);
if (NS_SUCCEEDED(rv) && channel) {
mWyciwygChannel = do_QueryInterface(channel);
mWyciwygChannel->CreateCacheEntry(NS_ConvertUCS2toUTF8(url).get());
mWyciwygChannel->CreateCacheEntry(url.get());
}
nsCOMPtr<nsILoadGroup> loadGroup;

2
content/html/document/src/nsHTMLDocument.h
View File

@ -260,7 +260,7 @@ protected:
static PRBool TryCacheCharset(nsICacheEntryDescriptor* aCacheDescriptor,
PRInt32& aCharsetSource,
nsAString& aCharset);
static PRBool TryBookmarkCharset(nsXPIDLCString* aUrlSpec,
static PRBool TryBookmarkCharset(nsAFlatCString* aUrlSpec,
PRInt32& aCharsetSource,
nsAString& aCharset);
static PRBool TryParentCharset(nsIDocumentCharsetInfo* aDocInfo,

14
content/html/document/src/nsImageDocument.cpp
View File

@ -391,10 +391,10 @@ nsImageDocument::CreateSyntheticDocument()
}
image->SetDocument(this, PR_FALSE, PR_TRUE);
nsXPIDLCString src;
mDocumentURL->GetSpec(getter_Copies(src));
nsCAutoString src;
mDocumentURL->GetSpec(src);
nsString src_string; src_string.AssignWithConversion(src);
NS_ConvertUTF8toUCS2 src_string(src);
nsHTMLValue val(src_string);
image->SetHTMLAttribute(nsHTMLAtoms::src, val, PR_FALSE);
@ -506,11 +506,9 @@ nsresult nsImageDocument::UpdateTitle( void )
nsCOMPtr<nsIURL> url = do_QueryInterface(mDocumentURL);
if (url) {
nsXPIDLCString pName;
url->GetFileName(getter_Copies(pName));
if(pName){
fileStr.Assign(NS_ConvertUTF8toUCS2(pName));
}
nsCAutoString pName;
url->GetFileName(pName);
fileStr.Assign(NS_ConvertUTF8toUCS2(pName));
}
if (mImageRequest) {

14
content/html/document/src/nsWyciwygChannel.cpp
View File

@ -95,10 +95,10 @@ NS_IMETHODIMP
nsWyciwygChannel::GetName(PRUnichar**aName)
{
NS_ENSURE_ARG_POINTER(aName);
nsXPIDLCString spec;
mURI->GetSpec(getter_Copies(spec));
*aName = ToNewUnicode(spec);
return NS_OK;
nsCAutoString spec;
mURI->GetSpec(spec);
*aName = ToNewUnicode(NS_ConvertUTF8toUCS2(spec));
return *aName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP
@ -359,7 +359,7 @@ nsWyciwygChannel::WriteToCache(const char * aScript)
// Get the outputstream from the transport.
if (mCacheTransport)
rv = mCacheTransport->OpenOutputStream(0, -1, 0, getter_AddRefs(mCacheOutputStream));
rv = mCacheTransport->OpenOutputStream(0, PRUint32(-1), 0, getter_AddRefs(mCacheOutputStream));
}
if (mCacheOutputStream)
@ -568,8 +568,8 @@ nsWyciwygChannel::Connect(PRBool aFirstTime)
if (aFirstTime) {
PRBool delayed = PR_FALSE;
nsXPIDLCString spec;
mURI->GetSpec(getter_Copies(spec));
nsCAutoString spec;
mURI->GetSpec(spec);
// open a cache entry for this channel...
rv = OpenCacheEntry(spec.get(), nsICache::ACCESS_READ, &delayed);

14
content/html/document/src/nsWyciwygProtocolHandler.cpp
View File

@ -50,10 +50,10 @@ NS_IMPL_ISUPPORTS1(nsWyciwygProtocolHandler, nsIProtocolHandler);
////////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsWyciwygProtocolHandler::GetScheme(char* *result)
nsWyciwygProtocolHandler::GetScheme(nsACString &result)
{
*result = nsCRT::strdup("wyciwyg");
return *result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
result = "wyciwyg";
return NS_OK;
}
NS_IMETHODIMP
@ -71,8 +71,10 @@ nsWyciwygProtocolHandler::AllowPort(PRInt32 port, const char *scheme, PRBool *_r
}
NS_IMETHODIMP
nsWyciwygProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
nsIURI **result)
nsWyciwygProtocolHandler::NewURI(const nsACString &aSpec,
const char *aCharset, // ignored
nsIURI *aBaseURI,
nsIURI **result)
{
nsresult rv;
@ -84,7 +86,7 @@ nsWyciwygProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
NS_GET_IID(nsIURI),
(void**)&url);
if (NS_FAILED(rv)) return rv;
rv = url->SetSpec((char*)aSpec);
rv = url->SetSpec(aSpec);
if (NS_FAILED(rv)) {
NS_RELEASE(url);
return rv;

53
content/html/style/src/nsCSSLoader.cpp
View File

@ -73,39 +73,28 @@ MOZ_DECL_CTOR_COUNTER(URLKey)
class URLKey: public nsHashKey {
public:
URLKey(nsIURI* aURL)
: nsHashKey(),
mURL(aURL),
mSpec(nsnull)
: mURL(aURL)
{
MOZ_COUNT_CTOR(URLKey);
NS_ADDREF(mURL);
mHashValue = 0;
mURL->GetSpec((char **)&mSpec);
if (mSpec) {
mHashValue = nsCRT::HashCode(mSpec);
mURL->GetSpec(mSpec);
if (!mSpec.IsEmpty()) {
mHashValue = nsCRT::HashCode(mSpec.get());
}
}
URLKey(const URLKey& aKey)
: nsHashKey(),
mURL(aKey.mURL),
: mURL(aKey.mURL),
mHashValue(aKey.mHashValue),
mSpec(nsnull)
mSpec(aKey.mSpec)
{
MOZ_COUNT_CTOR(URLKey);
NS_ADDREF(mURL);
if (aKey.mSpec)
mSpec = nsCRT::strdup(aKey.mSpec);
}
virtual ~URLKey(void)
{
MOZ_COUNT_DTOR(URLKey);
NS_RELEASE(mURL);
if (mSpec)
nsCRT::free((char *)mSpec);
mSpec = nsnull;
}
virtual PRUint32 HashCode(void) const
@ -121,7 +110,7 @@ public:
nsresult result = mURL->Equals(key->mURL, &equals);
return (NS_SUCCEEDED(result) && equals);
#else
return (nsCRT::strcasecmp(mSpec, key->mSpec) == 0);
return (nsCRT::strcasecmp(mSpec.get(), key->mSpec.get()) == 0);
#endif
}
@ -130,9 +119,9 @@ public:
return new URLKey(*this);
}
nsIURI* mURL;
PRUint32 mHashValue;
const char* mSpec;
nsCOMPtr<nsIURI> mURL;
PRUint32 mHashValue;
nsSharableCString mSpec;
};
class SheetLoadData : public nsIStreamLoaderObserver
@ -722,8 +711,8 @@ SheetLoadData::OnStreamComplete(nsIStreamLoader* aLoader,
* being fixed
*/
nsXPIDLCString uriStr;
mURL->GetSpec(getter_Copies(uriStr));
nsCAutoString uriStr;
mURL->GetSpec(uriStr);
nsCAutoString errorMessage;
errorMessage = NS_LITERAL_CSTRING("Decoding sheet from ") +
uriStr +
@ -1000,10 +989,10 @@ CSSLoaderImpl::DidLoadStyle(nsIStreamLoader* aLoader,
#ifdef DEBUG
if (mDocument && NS_FAILED(aStatus)) { // still have doc, must have failed
// Dump error message to console.
nsXPIDLCString url;
aLoadData->mURL->GetSpec(getter_Copies(url));
nsCAutoString url;
aLoadData->mURL->GetSpec(url);
nsCAutoString errorMessage(NS_LITERAL_CSTRING("CSSLoaderImpl::DidLoadStyle: Load of URL '") +
nsDependentCString(url) +
url +
NS_LITERAL_CSTRING("' failed. Error code: "));
errorMessage.AppendInt(NS_ERROR_GET_CODE(aStatus));
NS_WARNING(errorMessage.get());
@ -1286,10 +1275,10 @@ CSSLoaderImpl::LoadSheet(URLKey& aKey, SheetLoadData* aData)
#ifdef DEBUG
else {
// Dump an error message to the console
nsXPIDLCString url;
aKey.mURL->GetSpec(getter_Copies(url));
nsCAutoString url;
aKey.mURL->GetSpec(url);
nsCAutoString errorMessage(NS_LITERAL_CSTRING("CSSLoaderImpl::LoadSheet: Load of URL '") +
nsDependentCString(url) +
url +
NS_LITERAL_CSTRING("' failed. Error code: "));
errorMessage.AppendInt(NS_ERROR_GET_CODE(result));
NS_WARNING(errorMessage.get());
@ -1635,8 +1624,8 @@ CSSLoaderImpl::LoadAgentSheet(nsIURI* aURL,
else {
// Dump an error message to the console
PRBool ignoreError = PR_FALSE;
nsXPIDLCString url;
aURL->GetSpec(getter_Copies(url));
nsCAutoString url;
aURL->GetSpec(url);
// Ignore userChrome.css and userContent.css failures
#define USERCHROMECSS "userChrome.css"
#define USERCONTENTCSS "userContent.css"
@ -1651,7 +1640,7 @@ CSSLoaderImpl::LoadAgentSheet(nsIURI* aURL,
if (!ignoreError) {
nsCAutoString errorMessage(NS_LITERAL_CSTRING("CSSLoaderImpl::LoadAgentSheet: Load of URL '") +
nsDependentCString(url) +
url +
NS_LITERAL_CSTRING("' failed. Error code: "));
errorMessage.AppendInt(NS_ERROR_GET_CODE(result));
NS_WARNING(errorMessage.get());

5
content/html/style/src/nsCSSParser.cpp
View File

@ -1144,11 +1144,8 @@ PRBool CSSParserImpl::ProcessImport(PRInt32& aErrorCode, const nsString& aURLSpe
(*aAppendFunc)(rule, aData);
if (mChildLoader) {
// XXX probably need a way to encode unicode junk for the part of
// the url that follows a "?"
nsCOMPtr<nsIURI> url;
// XXX need to have nsILoadGroup passed in here
aErrorCode = NS_NewURI(getter_AddRefs(url), aURLSpec, mURL/*, group*/);
aErrorCode = NS_NewURI(getter_AddRefs(url), aURLSpec, nsnull, mURL);
if (NS_FAILED(aErrorCode)) {
// import url is bad

18
content/html/style/src/nsCSSStyleSheet.cpp
View File

@ -2485,11 +2485,10 @@ void CSSStyleSheetImpl::List(FILE* out, PRInt32 aIndent) const
}
fputs("CSS Style Sheet: ", out);
char* urlSpec = nsnull;
nsresult rv = mInner->mURL->GetSpec(&urlSpec);
if (NS_SUCCEEDED(rv) && urlSpec) {
fputs(urlSpec, out);
nsCRT::free(urlSpec);
nsCAutoString urlSpec;
nsresult rv = mInner->mURL->GetSpec(urlSpec);
if (NS_SUCCEEDED(rv) && !urlSpec.IsEmpty()) {
fputs(urlSpec.get(), out);
}
if (mMedia) {
@ -2677,12 +2676,9 @@ NS_IMETHODIMP
CSSStyleSheetImpl::GetHref(nsAWritableString& aHref)
{
if (mInner && mInner->mURL) {
char* str = nsnull;
mInner->mURL->GetSpec(&str);
aHref.Assign(NS_ConvertASCIItoUCS2(str));
if (str) {
nsCRT::free(str);
}
nsCAutoString str;
mInner->mURL->GetSpec(str);
aHref.Assign(NS_ConvertUTF8toUCS2(str));
}
else {
aHref.Truncate();

9
content/html/style/src/nsHTMLCSSStyleSheet.cpp
View File

@ -531,11 +531,10 @@ void HTMLCSSStyleSheetImpl::List(FILE* out, PRInt32 aIndent) const
for (PRInt32 index = aIndent; --index >= 0; ) fputs(" ", out);
fputs("HTML CSS Style Sheet: ", out);
char* urlSpec = nsnull;
mURL->GetSpec(&urlSpec);
if (urlSpec) {
fputs(urlSpec, out);
nsCRT::free(urlSpec);
nsCAutoString urlSpec;
mURL->GetSpec(urlSpec);
if (!urlSpec.IsEmpty()) {
fputs(urlSpec.get(), out);
}
fputs("\n", out);
}

9
content/html/style/src/nsHTMLStyleSheet.cpp
View File

@ -1523,11 +1523,10 @@ void HTMLStyleSheetImpl::List(FILE* out, PRInt32 aIndent) const
for (PRInt32 index = aIndent; --index >= 0; ) fputs(" ", out);
fputs("HTML Style Sheet: ", out);
char* urlSpec = nsnull;
mURL->GetSpec(&urlSpec);
if (urlSpec) {
fputs(urlSpec, out);
nsCRT::free(urlSpec);
nsCAutoString urlSpec;
mURL->GetSpec(urlSpec);
if (!urlSpec.IsEmpty()) {
fputs(urlSpec.get(), out);
}
fputs("\n", out);
}

5
content/shared/public/nsHTMLUtils.h
View File

@ -50,14 +50,17 @@ class nsIDocument;
class nsIIOService;
class nsIURI;
class nsString;
class nsACString;
/**
* A version of NS_MakeAbsoluteURI that's savvy to document character
* set encodings, and will recode a relative spec in the specified
* charset and URL-escape it before resolving.
*
* XXXdarin this should really return a nsIURI
*/
nsresult
NS_MakeAbsoluteURIWithCharset(char* *aResult,
NS_MakeAbsoluteURIWithCharset(nsACString &aResult,
const nsString& aSpec,
nsIDocument* aDocument,
nsIURI* aBaseURI = nsnull,

178
content/shared/src/nsHTMLUtils.cpp
View File

@ -48,68 +48,17 @@
#include "nsIIOService.h"
#include "nsIServiceManager.h"
#include "nsICharsetConverterManager.h"
#include "nsNetUtil.h"
#include "nsString.h"
#include "nsXPIDLString.h"
#include "prprf.h"
#include "nsEscape.h"
#include "nsNetCID.h"
#include "nsReadableUtils.h"
#include "nsIURI.h"
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
/*
* Extracts the hostname part from the given |uSpec|, encodes it to UTF8,
* and use it to update the hostname part in |spec|, putting the result
* in |targetSpec|
* XXX: If the hostname is ASCII, i.e. there is no need for conversion,
* |*targetSpec| would be set to nsnull.
*/
nsresult
ConvertHostnameToUTF8(char* *targetSpec,
const char* spec,
const nsString& uSpec,
nsIIOService* aIOService)
{
nsresult rv;
*targetSpec = nsnull;
nsCOMPtr<nsIIOService> serv;
if (!aIOService) {
serv = do_GetIOService(&rv);
if (NS_FAILED(rv))
return rv;
aIOService = serv.get();
}
NS_ConvertUCS2toUTF8 specUTF8(uSpec);
nsXPIDLCString hostUTF8;
rv = aIOService->ExtractUrlPart(specUTF8.get(), nsIIOService::url_Host,
nsnull, nsnull, getter_Copies(hostUTF8));
NS_ASSERTION(NS_SUCCEEDED(rv), "Unable to extract Hostname part from URL");
if (NS_FAILED(rv) || hostUTF8.IsEmpty())
return NS_OK; // spec may be relative, bailing out.
// If hostname is pure ASCII, get out of here.
if (nsCRT::IsAscii(hostUTF8.get()))
return NS_OK;
// Try creating a URI from the original spec
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), spec, nsnull, aIOService);
if (NS_FAILED(rv))
return NS_OK; // spec may be relative, bailing out
// replace the original hostname with hostUTF8
rv = uri->SetHost(hostUTF8.get());
if (NS_FAILED(rv))
return rv;
return uri->GetSpec(targetSpec);
}
nsresult
NS_MakeAbsoluteURIWithCharset(char* *aResult,
NS_MakeAbsoluteURIWithCharset(nsACString &aResult,
const nsString& aSpec,
nsIDocument* aDocument,
nsIURI* aBaseURI,
@ -117,7 +66,7 @@ NS_MakeAbsoluteURIWithCharset(char* *aResult,
nsICharsetConverterManager* aConvMgr)
{
// Initialize aResult in case of tragedy
*aResult = nsnull;
aResult.Truncate();
// Sanity
NS_PRECONDITION(aBaseURI != nsnull, "no base URI");
@ -126,112 +75,25 @@ NS_MakeAbsoluteURIWithCharset(char* *aResult,
// This gets the relative spec after gyrating it through all the
// necessary encodings and escaping.
nsCAutoString spec;
if (nsCRT::IsAscii(aSpec.get())) {
if (IsASCII(aSpec)) {
// If it's ASCII, then just copy the characters
spec.AssignWithConversion(aSpec);
}
else {
// If the scheme is javascript then no charset conversion is needed,
// escape non ASCII in \uxxxx form.
PRInt32 pos = aSpec.FindChar(':');
static const char kJavaScript[] = "javascript";
nsAutoString scheme;
if ((pos == (PRInt32)(sizeof kJavaScript - 1)) &&
(aSpec.Left(scheme, pos)) &&
scheme.EqualsIgnoreCase(kJavaScript)) {
char buf[6+1]; // space for \uXXXX plus a NUL at the end
spec.Truncate(0);
for (const PRUnichar* uch = aSpec.get(); *uch; ++uch) {
if (!nsCRT::IsAscii(*uch)) {
PR_snprintf(buf, sizeof(buf), "\\u%.4x", *uch);
spec.Append(buf);
}
else {
// it's ascii, so we're safe
spec.Append(char(*uch));
}
}
}
else {
// If the scheme is mailtourl then should not convert to a document charset
// because the charset cannot be passes to mailnews code,
// use UTF-8 instead and apply URL escape.
static const char kMailToURI[] = "mailto";
if ((pos == (PRInt32)(sizeof kMailToURI - 1)) &&
(aSpec.Left(scheme, pos)) &&
scheme.EqualsIgnoreCase(kMailToURI)) {
spec = NS_ConvertUCS2toUTF8(aSpec.get());
}
else {
// Otherwise, we'll need to use aDocument to cough up a character
// set converter, and re-encode the relative portion of the URL as
// 8-bit characters.
nsCOMPtr<nsIUnicodeEncoder> encoder;
if (aDocument) {
nsCOMPtr<nsICharsetConverterManager> convmgr;
if (aConvMgr) {
convmgr = aConvMgr;
}
else {
convmgr = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID);
}
if (! convmgr)
return NS_ERROR_FAILURE;
nsAutoString charSetID;
aDocument->GetDocumentCharacterSet(charSetID);
convmgr->GetUnicodeEncoder(&charSetID, getter_AddRefs(encoder));
}
if (encoder) {
// Got the encoder: let's party.
PRInt32 len = aSpec.Length();
PRInt32 maxlen;
encoder->GetMaxLength(aSpec.get(), len, &maxlen);
char buf[64], *p = buf;
if (PRUint32(maxlen) > sizeof(buf) - 1)
p = new char[maxlen + 1];
if (! p)
return NS_ERROR_OUT_OF_MEMORY;
encoder->Convert(aSpec.get(), &len, p, &maxlen);
p[maxlen] = 0;
spec = p;
encoder->Finish(p, &len);
p[len] = 0;
spec += p;
if (p != buf)
delete[] p;
// iDNS support: encode the hostname in the URL to UTF8
nsresult rv;
nsXPIDLCString newSpec;
rv = ConvertHostnameToUTF8(getter_Copies(newSpec), spec.get(), aSpec, aIOService);
if (NS_FAILED(rv))
return rv;
if (!newSpec.IsEmpty()) // hostname is non-ASCII
spec = newSpec;
}
else {
// No encoder, but we've got non-ASCII data. Let's UTF-8 encode
// by default.
spec = NS_ConvertUCS2toUTF8(aSpec.get());
}
}
}
return aBaseURI->Resolve(NS_LossyConvertUCS2toASCII(aSpec), aResult);
}
return aBaseURI->Resolve(spec.get(), aResult);
nsCOMPtr<nsIURI> absURI;
nsresult rv;
nsAutoString originCharset; // XXX why store charset as UCS2?
if (aDocument && NS_FAILED(aDocument->GetDocumentCharacterSet(originCharset)))
originCharset.Truncate();
rv = nsHTMLUtils::IOService->NewURI(NS_ConvertUCS2toUTF8(aSpec),
NS_LossyConvertUCS2toASCII(originCharset).get(),
aBaseURI, getter_AddRefs(absURI));
if (NS_FAILED(rv)) return rv;
return absURI->GetSpec(aResult);
}

34
content/xbl/src/nsBindingManager.cpp
View File

@ -831,17 +831,17 @@ NS_IMETHODIMP
nsBindingManager::LoadBindingDocument(nsIDocument* aBoundDoc, const nsAReadableString& aURL,
nsIDocument** aResult)
{
nsCAutoString url; url.AssignWithConversion(PromiseFlatString(aURL).get());
NS_ConvertUCS2toUTF8 url(aURL);
nsXPIDLCString otherScheme;
nsCOMPtr<nsIIOService> ioService = do_GetService(NS_IOSERVICE_CONTRACTID);
nsCAutoString otherScheme;
nsCOMPtr<nsIIOService> ioService = do_GetIOService();
if (!ioService) return NS_ERROR_FAILURE;
ioService->ExtractScheme(url.get(), 0, 0, getter_Copies(otherScheme));
ioService->ExtractScheme(url, otherScheme);
nsCOMPtr<nsIURI> docURL;
aBoundDoc->GetDocumentURL(getter_AddRefs(docURL));
nsXPIDLCString scheme;
docURL->GetScheme(getter_Copies(scheme));
nsCAutoString scheme;
docURL->GetScheme(scheme);
// First we need to load our binding.
*aResult = nsnull;
@ -857,7 +857,7 @@ nsBindingManager::LoadBindingDocument(nsIDocument* aBoundDoc, const nsAReadableS
if (!info)
return NS_ERROR_FAILURE;
if (!PL_strcmp(scheme, otherScheme))
if (!strcmp(scheme.get(), otherScheme.get()))
info->GetDocument(aResult); // Addref happens here.
return NS_OK;
@ -948,10 +948,10 @@ nsBindingManager::PutXBLDocumentInfo(nsIXBLDocumentInfo* aDocumentInfo)
nsCOMPtr<nsIURI> uri;
doc->GetDocumentURL(getter_AddRefs(uri));
nsXPIDLCString str;
uri->GetSpec(getter_Copies(str));
nsCAutoString str;
uri->GetSpec(str);
nsCStringKey key((const char*)str);
nsCStringKey key(str.get());
mDocumentTable->Put(&key, aDocumentInfo);
return NS_OK;
}
@ -967,10 +967,10 @@ nsBindingManager::RemoveXBLDocumentInfo(nsIXBLDocumentInfo* aDocumentInfo)
nsCOMPtr<nsIURI> uri;
doc->GetDocumentURL(getter_AddRefs(uri));
nsXPIDLCString str;
uri->GetSpec(getter_Copies(str));
nsCAutoString str;
uri->GetSpec(str);
nsCStringKey key((const char*)str);
nsCStringKey key(str.get());
mDocumentTable->Remove(&key);
return NS_OK;
}
@ -1035,11 +1035,11 @@ PRBool PR_CALLBACK MarkForDeath(nsHashKey* aKey, void* aData, void* aClosure)
nsCAutoString uriStr;
binding->GetDocURI(uriStr);
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), uriStr.get());
NS_NewURI(getter_AddRefs(uri), uriStr);
if (uri) {
nsXPIDLCString path;
uri->GetPath(getter_Copies(path));
if (!PL_strncmp(path.get(), "/skin", 5))
nsCAutoString path;
uri->GetPath(path);
if (!strncmp(path.get(), "/skin", 5))
binding->MarkForDeath();
}
return PR_TRUE;

6
content/xbl/src/nsXBLDocumentInfo.cpp
View File

@ -436,10 +436,10 @@ nsresult NS_NewXBLDocumentInfo(nsIDocument* aDocument, nsIXBLDocumentInfo** aRes
nsCOMPtr<nsIURI> url;
aDocument->GetDocumentURL(getter_AddRefs(url));
nsXPIDLCString str;
url->GetSpec(getter_Copies(str));
nsCAutoString str;
url->GetSpec(str);
*aResult = new nsXBLDocumentInfo((const char*)str, aDocument);
*aResult = new nsXBLDocumentInfo(str.get(), aDocument);
NS_IF_ADDREF(*aResult);
return NS_OK;

2
content/xbl/src/nsXBLResourceLoader.cpp
View File

@ -113,7 +113,7 @@ nsXBLResourceLoader::LoadResources(PRBool* aResult)
if (curr->mSrc.IsEmpty())
continue;
if (NS_FAILED(NS_NewURI(getter_AddRefs(url), curr->mSrc, docURL)))
if (NS_FAILED(NS_NewURI(getter_AddRefs(url), curr->mSrc, nsnull, docURL)))
continue;
if (curr->mType == nsXBLAtoms::image) {

35
content/xbl/src/nsXBLService.cpp
View File

@ -312,9 +312,9 @@ nsXBLStreamListener::OnStopRequest(nsIRequest* request, nsISupports* aCtxt, nsre
{
nsCOMPtr<nsIURI> channelURI;
aChannel->GetURI(getter_AddRefs(channelURI));
nsXPIDLCString str;
channelURI->GetSpec(getter_Copies(str));
printf("Failed to load XBL document %s\n", (const char*)str);
nsCAutoString str;
channelURI->GetAsciiSpec(str);
printf("Failed to load XBL document %s\n", str.get());
}
PRUint32 count = mBindingRequests.Count();
@ -377,9 +377,9 @@ nsXBLStreamListener::Load(nsIDOMEvent* aEvent)
doc->GetBindingManager(getter_AddRefs(bindingManager));
nsCOMPtr<nsIURI> uri;
mBindingDocument->GetDocumentURL(getter_AddRefs(uri));
nsXPIDLCString str;
uri->GetSpec(getter_Copies(str));
bindingManager->RemoveLoadingDocListener(nsCAutoString(NS_STATIC_CAST(const char*, str)));
nsCAutoString str;
uri->GetSpec(str);
bindingManager->RemoveLoadingDocListener(str);
nsCOMPtr<nsIContent> root;
mBindingDocument->GetRootContent(getter_AddRefs(root));
@ -392,7 +392,7 @@ nsXBLStreamListener::Load(nsIDOMEvent* aEvent)
nsCOMPtr<nsIXBLDocumentInfo> info;
nsCOMPtr<nsIBindingManager> xblDocBindingManager;
mBindingDocument->GetBindingManager(getter_AddRefs(xblDocBindingManager));
xblDocBindingManager->GetXBLDocumentInfo(nsCAutoString(NS_STATIC_CAST(const char*, str)), getter_AddRefs(info));
xblDocBindingManager->GetXBLDocumentInfo(str, getter_AddRefs(info));
xblDocBindingManager->RemoveXBLDocumentInfo(info); // Break the self-imposed cycle.
if (!info) {
NS_ERROR("An XBL file is malformed. Did you forget the XBL namespace on the bindings tag?");
@ -1047,13 +1047,12 @@ NS_IMETHODIMP nsXBLService::GetBindingInternal(nsIContent* aBoundElement,
if (hasExtends && (hasDisplay || nameSpace.IsEmpty())) {
// Look up the prefix.
// We have a base class binding. Load it right now.
nsCAutoString urlCString; urlCString.AssignWithConversion(value);
NS_ConvertUCS2toUTF8 urlCString(value);
nsCOMPtr<nsIURI> docURI;
doc->GetDocumentURL(getter_AddRefs(docURI));
nsXPIDLCString urlStr;
docURI->Resolve(urlCString.get(), getter_Copies(urlStr));
urlCString = urlStr.get();
if (NS_FAILED(GetBindingInternal(aBoundElement, urlCString, aPeekOnly, aIsReady, getter_AddRefs(baseBinding))))
nsCAutoString urlStr;
docURI->Resolve(urlCString, urlStr);
if (NS_FAILED(GetBindingInternal(aBoundElement, urlStr, aPeekOnly, aIsReady, getter_AddRefs(baseBinding))))
return NS_ERROR_FAILURE; // Binding not yet ready or an error occurred.
if (!aPeekOnly) {
// Make sure to set the base prototype.
@ -1141,7 +1140,7 @@ nsXBLService::LoadBindingDocumentInfo(nsIContent* aBoundElement, nsIDocument* aB
// Finally, if all lines of defense fail, we go and fetch the binding
// document.
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), aURLStr.get());
rv = NS_NewURI(getter_AddRefs(uri), aURLStr);
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create a url");
nsCOMPtr<nsIDocument> document;
@ -1206,7 +1205,7 @@ nsXBLService::FetchSyncXMLDocument(nsIURI* aURI, nsIDocument** aResult)
// Create an XML content sink and a parser.
nsCOMPtr<nsIRequest> request;
nsCOMPtr<nsIChannel> channel;
rv = NS_OpenURI(getter_AddRefs(channel), aURI, nsnull, nsnull);
rv = NS_NewChannel(getter_AddRefs(channel), aURI, nsnull, nsnull);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIStreamListener> listener;
@ -1310,7 +1309,7 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
aBoundDocument->GetDocumentLoadGroup(getter_AddRefs(loadGroup));
nsCOMPtr<nsIRequest> request;
nsCOMPtr<nsIChannel> channel;
rv = NS_OpenURI(getter_AddRefs(channel), aURI, nsnull, loadGroup);
rv = NS_NewChannel(getter_AddRefs(channel), aURI, nsnull, loadGroup);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIAtom> tagName;
@ -1350,10 +1349,10 @@ nsXBLService::FetchBindingDocument(nsIContent* aBoundElement, nsIDocument* aBoun
nsCOMPtr<nsIBindingManager> bindingManager;
if (aBoundDocument)
aBoundDocument->GetBindingManager(getter_AddRefs(bindingManager));
nsXPIDLCString uri;
aURI->GetSpec(getter_Copies(uri));
nsCAutoString uri;
aURI->GetSpec(uri);
if (bindingManager)
bindingManager->PutLoadingDocListener(nsCAutoString(NS_STATIC_CAST(const char*, uri)), xblListener);
bindingManager->PutLoadingDocListener(uri, xblListener);
// Add our request.
nsCAutoString bindingURI(uri);

28
content/xml/content/src/nsXMLElement.cpp
View File

@ -169,7 +169,7 @@ NS_IMPL_ADDREF_INHERITED(nsXMLElement, nsGenericElement)
NS_IMPL_RELEASE_INHERITED(nsXMLElement, nsGenericElement)
static inline nsresult MakeURI(const char *aSpec, nsIURI *aBase, nsIURI **aURI)
static inline nsresult MakeURI(const nsACString &aSpec, nsIURI *aBase, nsIURI **aURI)
{
nsresult rv;
static NS_DEFINE_CID(ioServCID,NS_IOSERVICE_CID);
@ -177,7 +177,7 @@ static inline nsresult MakeURI(const char *aSpec, nsIURI *aBase, nsIURI **aURI)
if (NS_FAILED(rv))
return rv;
return service->NewURI(aSpec,aBase,aURI);
return service->NewURI(aSpec,nsnull,aBase,aURI);
}
NS_IMETHODIMP
@ -202,18 +202,16 @@ nsXMLElement::GetXMLBaseURI(nsIURI **aURI)
// The complex looking if above is to make sure that we do not erroneously
// think a value of "./this:that" would have a scheme of "./that"
// XXX URL escape?
nsCAutoString str; str.AssignWithConversion(value);
NS_ConvertUCS2toUTF8 str(value);
rv = MakeURI(str.get(),nsnull,aURI);
rv = MakeURI(str,nsnull,aURI);
if (NS_FAILED(rv))
break;
if (!base.IsEmpty()) {
// XXX URL escape?
str.AssignWithConversion(base.get());
nsXPIDLCString resolvedStr;
rv = (*aURI)->Resolve(str.get(), getter_Copies(resolvedStr));
if (!base.IsEmpty()) { // XXXdarin base is always empty
str = NS_ConvertUCS2toUTF8(base);
nsCAutoString resolvedStr;
rv = (*aURI)->Resolve(str, resolvedStr);
if (NS_FAILED(rv)) break;
rv = (*aURI)->SetSpec(resolvedStr);
}
@ -252,9 +250,8 @@ nsXMLElement::GetXMLBaseURI(nsIURI **aURI)
*aURI = docBase.get();
NS_IF_ADDREF(*aURI); // nsCOMPtr releases this once
} else {
// XXX URL escape?
nsCAutoString str; str.AssignWithConversion(base);
rv = MakeURI(str.get(),docBase,aURI);
NS_ConvertUCS2toUTF8 str(base);
rv = MakeURI(str,docBase,aURI);
}
}
} else {
@ -316,13 +313,12 @@ static nsresult WebShellToPresContext(nsIWebShell *aShell,
static nsresult CheckLoadURI(nsIURI *aBaseURI, const nsAReadableString& aURI,
nsIURI **aAbsURI)
{
// XXX URL escape?
nsCAutoString str; str.Assign(NS_ConvertUCS2toUTF8(aURI));
NS_ConvertUCS2toUTF8 str(aURI);
*aAbsURI = nsnull;
nsresult rv;
rv = MakeURI(str.get(),aBaseURI,aAbsURI);
rv = MakeURI(str,aBaseURI,aAbsURI);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIScriptSecurityManager> securityManager =
do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);

13
content/xml/document/src/nsXMLContentSink.cpp
View File

@ -713,7 +713,7 @@ nsXMLContentSink::ProcessStyleLink(nsIContent* aElement,
return NS_OK;
nsCOMPtr<nsIURI> url;
rv = NS_NewURI(getter_AddRefs(url), aHref, mDocumentBaseURL);
rv = NS_NewURI(getter_AddRefs(url), aHref, nsnull, mDocumentBaseURL);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIScriptSecurityManager> secMan =
@ -749,7 +749,7 @@ nsXMLContentSink::ProcessBASETag()
if (NS_CONTENT_ATTR_HAS_VALUE == mBaseElement->GetAttr(kNameSpaceID_HTML, nsHTMLAtoms::href, value)) {
nsCOMPtr<nsIURI> baseURI;
rv = NS_NewURI(getter_AddRefs(baseURI), value, nsnull);
rv = NS_NewURI(getter_AddRefs(baseURI), value);
if (NS_SUCCEEDED(rv)) {
rv = mDocument->SetBaseURL(baseURI); // The document checks if it is legal to set this base
if (NS_SUCCEEDED(rv)) {
@ -970,15 +970,16 @@ nsXMLContentSink::StartLayout()
// If the document we are loading has a reference or it is a top level
// frameset document, disable the scroll bars on the views.
nsXPIDLCString ref;
nsCAutoString ref;
nsIURL* url;
nsresult rv = mDocumentURL->QueryInterface(NS_GET_IID(nsIURL), (void**)&url);
if (NS_SUCCEEDED(rv)) {
rv = url->GetRef(getter_Copies(ref));
rv = url->GetRef(ref);
NS_RELEASE(url);
}
if (rv == NS_OK) {
mRef.AssignWithConversion(ref);
NS_UnescapeURL(ref); // XXX this may result in random non-ASCII bytes!
mRef = NS_ConvertASCIItoUCS2(ref);
}
PRBool topLevelFrameset = PR_FALSE;
@ -991,7 +992,7 @@ nsXMLContentSink::StartLayout()
}
}
if (ref || topLevelFrameset) {
if (!ref.IsEmpty() || topLevelFrameset) {
// XXX support more than one presentation-shell here
// Get initial scroll preference and save it away; disable the

4
content/xml/document/src/nsXMLDocument.cpp
View File

@ -339,7 +339,7 @@ nsXMLDocument::Load(const nsAReadableString& aUrl)
nsresult rv;
// Create a new URI
rv = NS_NewURI(getter_AddRefs(uri), aUrl, mDocumentURL);
rv = NS_NewURI(getter_AddRefs(uri), aUrl, nsnull, mDocumentURL);
if (NS_FAILED(rv)) return rv;
// Get security manager, check to see if we're allowed to load this URI
@ -365,7 +365,7 @@ nsXMLDocument::Load(const nsAReadableString& aUrl)
SetBaseURL(uri);
// Create a channel
rv = NS_OpenURI(getter_AddRefs(channel), uri, nsnull, nsnull, this);
rv = NS_NewChannel(getter_AddRefs(channel), uri, nsnull, nsnull, this);
if (NS_FAILED(rv)) return rv;
// Set a principal for this document

8
content/xsl/document/src/nsXSLContentSink.cpp
View File

@ -44,6 +44,7 @@
#include "nsIParser.h"
#include "nsIURL.h"
#include "nsString2.h"
#include "nsEscape.h"
nsresult
NS_NewXSLContentSink(nsIXMLContentSink** aResult,
@ -109,13 +110,14 @@ nsXSLContentSink::DidBuildModel(PRInt32 aQualityLevel)
nsCOMPtr<nsIDOMNode> styleNode;
nsCOMPtr<nsIURL> url = do_QueryInterface(mDocumentURL);
if (url) {
nsXPIDLCString ref;
url->GetRef(getter_Copies(ref));
nsCAutoString ref;
url->GetRef(ref);
if (!ref.IsEmpty()) {
NS_UnescapeURL(ref); // XXX this may result in non-ASCII octets
nsCOMPtr<nsIDOMDocument> styleDoc = do_QueryInterface(mDocument);
NS_ENSURE_TRUE(styleDoc, NS_ERROR_NO_INTERFACE);
nsCOMPtr<nsIDOMElement> elem;
styleDoc->GetElementById(NS_ConvertASCIItoUCS2(ref),
styleDoc->GetElementById(NS_ConvertUTF8toUCS2(ref),
getter_AddRefs(elem));
styleNode = elem;
}

6
content/xul/content/src/nsXULElement.cpp
View File

@ -5205,15 +5205,15 @@ nsXULPrototypeScript::Compile(const PRUnichar* aText,
if (NS_FAILED(rv))
return rv;
nsXPIDLCString urlspec;
aURI->GetSpec(getter_Copies(urlspec));
nsCAutoString urlspec;
aURI->GetSpec(urlspec);
// Ok, compile it to create a prototype script object!
rv = context->CompileScript(aText,
aTextLength,
scopeObject,
principal,
urlspec,
urlspec.get(),
PRUint32(aLineNo),
mLangVersion,
(void**)&mJSObject);

20
content/xul/document/src/nsXULContentSink.cpp
View File

@ -611,7 +611,7 @@ XULContentSinkImpl::ProcessStyleLink(nsIContent* aElement,
if ((mimeType.IsEmpty()) || mimeType.EqualsIgnoreCase(kCSSType)) {
nsCOMPtr<nsIURI> url;
rv = NS_NewURI(getter_AddRefs(url), aHref, mDocumentURL);
rv = NS_NewURI(getter_AddRefs(url), aHref, nsnull, mDocumentURL);
if (NS_OK != rv) {
return NS_OK; // The URL is bad, move along, don't propagate the error (for now)
}
@ -1072,7 +1072,7 @@ XULContentSinkImpl::HandleProcessingInstruction(const PRUnichar *aTarget,
// Add the overlay to our list of overlays that need to be processed.
nsCOMPtr<nsIURI> url;
nsresult rv = NS_NewURI(getter_AddRefs(url), href, mDocumentURL);
nsresult rv = NS_NewURI(getter_AddRefs(url), href, nsnull, mDocumentURL);
if (NS_FAILED(rv)) {
// XXX This is wrong, the error message could be out of memory
// or something else equally bad, which we should propagate.
@ -1495,7 +1495,7 @@ XULContentSinkImpl::OpenScript(const PRUnichar** aAttributes,
// If there is a SRC attribute...
if (! src.IsEmpty()) {
// Use the SRC attribute value to load the URL
rv = NS_NewURI(getter_AddRefs(script->mSrcURI), src, mDocumentURL);
rv = NS_NewURI(getter_AddRefs(script->mSrcURI), src, nsnull, mDocumentURL);
if (NS_FAILED(rv)) {
delete script;
return rv;
@ -1546,10 +1546,10 @@ XULContentSinkImpl::OpenScript(const PRUnichar** aAttributes,
// AbortFastLoads if things look bad.
nsresult rv2 = NS_OK;
if (script->mSrcURI) {
nsXPIDLCString spec;
script->mSrcURI->GetSpec(getter_Copies(spec));
nsCAutoString spec;
script->mSrcURI->GetAsciiSpec(spec);
rv2 = fastLoadService->StartMuxedDocument(script->mSrcURI,
spec,
spec.get(),
nsIFastLoadService::NS_FASTLOAD_READ);
if (NS_SUCCEEDED(rv2))
rv2 = fastLoadService->SelectMuxedDocument(script->mSrcURI);
@ -1653,7 +1653,7 @@ XULContentSinkImpl::AddAttributes(const PRUnichar** aAttributes,
qnameC.Assign(aAttributes[0]);
PR_LOG(gLog, PR_LOG_ALWAYS,
("xul: unable to parse attribute '%s' at line %d",
NS_ConvertUCS2toUTF8(qnameC), -1)); // XXX pass in line number
NS_ConvertUCS2toUTF8(qnameC).get(), -1)); // XXX pass in line number
#endif
// Bring it. We'll just fail to copy an attribute that we
// can't parse. And that's one less attribute to worry
@ -1675,9 +1675,9 @@ XULContentSinkImpl::AddAttributes(const PRUnichar** aAttributes,
PR_LOG(gLog, PR_LOG_DEBUG,
("xul: %.5d. %s %s=%s",
-1, // XXX pass in line number
NS_ConvertUCS2toUTF8(extraWhiteSpace),
NS_ConvertUCS2toUTF8(qnameC),
NS_ConvertUCS2toUTF8(valueC)));
NS_ConvertUCS2toUTF8(extraWhiteSpace).get(),
NS_ConvertUCS2toUTF8(qnameC).get(),
NS_ConvertUCS2toUTF8(valueC).get()));
}
#endif
++attrs;

65
content/xul/document/src/nsXULDocument.cpp
View File

@ -394,7 +394,7 @@ PlaceHolderRequest::PlaceHolderRequest()
if (gRefCnt++ == 0) {
nsresult rv;
rv = NS_NewURI(&gURI, "about:xul-master-placeholder", nsnull);
rv = NS_NewURI(&gURI, NS_LITERAL_CSTRING("about:xul-master-placeholder"), nsnull);
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to create about:xul-master-placeholder");
}
}
@ -2996,12 +2996,12 @@ nsXULDocument::Persist(nsIContent* aElement, PRInt32 aNameSpaceID,
// Add it to the persisted set for this document (if it's not
// there already).
{
nsXPIDLCString docurl;
rv = mDocumentURL->GetSpec(getter_Copies(docurl));
nsCAutoString docurl;
rv = mDocumentURL->GetSpec(docurl);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIRDFResource> doc;
rv = gRDFService->GetResource(docurl, getter_AddRefs(doc));
rv = gRDFService->GetResource(docurl.get(), getter_AddRefs(doc));
if (NS_FAILED(rv)) return rv;
PRBool hasAssertion;
@ -4149,11 +4149,9 @@ nsXULDocument::GetBaseURI(nsAWritableString &aURI)
{
aURI.Truncate();
if (mDocumentBaseURL) {
nsXPIDLCString spec;
mDocumentBaseURL->GetSpec(getter_Copies(spec));
if (spec) {
CopyASCIItoUCS2(nsDependentCString(spec), aURI);
}
nsCAutoString spec;
mDocumentBaseURL->GetSpec(spec);
aURI = NS_ConvertUTF8toUCS2(spec);
}
return NS_OK;
}
@ -4345,11 +4343,11 @@ nsXULDocument::StartLayout(void)
{
if (! mRootContent) {
#ifdef PR_LOGGING
nsXPIDLCString urlspec;
mDocumentURL->GetSpec(getter_Copies(urlspec));
nsCAutoString urlspec;
mDocumentURL->GetSpec(urlspec);
PR_LOG(gXULLog, PR_LOG_ALWAYS,
("xul: unable to layout '%s'; no root content", (const char*) urlspec));
("xul: unable to layout '%s'; no root content", urlspec.get()));
#endif
return NS_OK;
}
@ -5210,8 +5208,8 @@ nsXULDocument::PrepareToLoadPrototype(nsIURI* aURI, const char* aCommand,
// sinking content, it "selects" the memorized document from the
// FastLoad multiplexor, using the nsIURI* as a fast identifier.
if (mIsFastLoad) {
nsXPIDLCString urlspec;
rv = aURI->GetSpec(getter_Copies(urlspec));
nsCAutoString urlspec;
rv = aURI->GetAsciiSpec(urlspec);
if (NS_FAILED(rv)) return rv;
// If StartMuxedDocument returns NS_ERROR_NOT_AVAILABLE, then
@ -5220,7 +5218,7 @@ nsXULDocument::PrepareToLoadPrototype(nsIURI* aURI, const char* aCommand,
// will therefore arrange to update the file, writing new data
// at the end while old (available) data continues to be read
// from the pre-existing part of the file.
rv = gFastLoadService->StartMuxedDocument(aURI, urlspec,
rv = gFastLoadService->StartMuxedDocument(aURI, urlspec.get(),
nsIFastLoadService::NS_FASTLOAD_READ |
nsIFastLoadService::NS_FASTLOAD_WRITE);
NS_ASSERTION(rv != NS_ERROR_NOT_AVAILABLE, "only reading FastLoad?!");
@ -5278,11 +5276,11 @@ nsXULDocument::ApplyPersistentAttributes()
rv = NS_NewISupportsArray(getter_AddRefs(elements));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString docurl;
mDocumentURL->GetSpec(getter_Copies(docurl));
nsCAutoString docurl;
mDocumentURL->GetSpec(docurl);
nsCOMPtr<nsIRDFResource> doc;
gRDFService->GetResource(docurl, getter_AddRefs(doc));
gRDFService->GetResource(docurl.get(), getter_AddRefs(doc));
nsCOMPtr<nsISimpleEnumerator> persisted;
mLocalStore->GetTargets(doc, kNC_persist, PR_TRUE, getter_AddRefs(persisted));
@ -5559,12 +5557,12 @@ nsXULDocument::PrepareToWalk()
rv = mCurrentPrototype->GetURI(getter_AddRefs(url));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString urlspec;
rv = url->GetSpec(getter_Copies(urlspec));
nsCAutoString urlspec;
rv = url->GetSpec(urlspec);
if (NS_FAILED(rv)) return rv;
PR_LOG(gXULLog, PR_LOG_ALWAYS,
("xul: error parsing '%s'", (const char*) urlspec));
("xul: error parsing '%s'", urlspec.get()));
#endif
return NS_OK;
@ -5844,11 +5842,11 @@ nsXULDocument::ResumeWalk()
#ifdef PR_LOGGING
if (PR_LOG_TEST(gXULLog, PR_LOG_DEBUG)) {
nsXPIDLCString urlspec;
uri->GetSpec(getter_Copies(urlspec));
nsCAutoString urlspec;
uri->GetSpec(urlspec);
PR_LOG(gXULLog, PR_LOG_DEBUG,
("xul: loading overlay %s", (const char*) urlspec));
("xul: loading overlay %s", urlspec.get()));
}
#endif
// Look in the prototype cache for the prototype document with
@ -6051,10 +6049,9 @@ nsXULDocument::OnStreamComplete(nsIStreamLoader* aLoader,
nsCOMPtr<nsIURI> uri;
channel->GetURI(getter_AddRefs(uri));
if (uri) {
nsXPIDLCString uriSpec;
uri->GetSpec(getter_Copies(uriSpec));
printf("Failed to load %s\n",
uriSpec.get() ? (const char*) uriSpec : "");
nsCAutoString uriSpec;
uri->GetSpec(uriSpec);
printf("Failed to load %s\n", uriSpec.get());
}
}
}
@ -6093,9 +6090,9 @@ nsXULDocument::OnStreamComplete(nsIStreamLoader* aLoader,
// End muxing afterward.
nsCOMPtr<nsIURI> uri = scriptProto->mSrcURI;
if (mIsFastLoad) {
nsXPIDLCString urispec;
uri->GetSpec(getter_Copies(urispec));
rv = gFastLoadService->StartMuxedDocument(uri, urispec,
nsCAutoString urispec;
uri->GetAsciiSpec(urispec);
rv = gFastLoadService->StartMuxedDocument(uri, urispec.get(),
nsIFastLoadService::NS_FASTLOAD_WRITE);
NS_ASSERTION(rv != NS_ERROR_NOT_AVAILABLE, "reading FastLoad?!");
if (NS_SUCCEEDED(rv))
@ -7255,10 +7252,10 @@ nsXULDocument::ParserObserver::OnStopRequest(nsIRequest *request,
nsCOMPtr<nsIURI> uri;
aChannel->GetOriginalURI(getter_AddRefs(uri));
nsXPIDLCString spec;
uri->GetSpec(getter_Copies(spec));
nsCAutoString spec;
uri->GetSpec(spec);
printf("*** Failed to load overlay %s\n", (const char*) spec);
printf("*** Failed to load overlay %s\n", spec.get());
#endif
rv = mDocument->ResumeWalk();

24
content/xul/document/src/nsXULPrototypeCache.cpp
View File

@ -108,9 +108,9 @@ protected:
~nsIURIKey(void) {}
PRUint32 HashCode(void) const {
nsXPIDLCString spec;
mKey->GetSpec(getter_Copies(spec));
return (PRUint32) PL_HashString(spec);
nsCAutoString spec;
mKey->GetSpec(spec);
return (PRUint32) PL_HashString(spec.get());
}
PRBool Equals(const nsHashKey *aKey) const {
@ -311,10 +311,10 @@ nsXULPrototypeCache::PutXBLDocumentInfo(nsIXBLDocumentInfo* aDocumentInfo)
nsCOMPtr<nsIURI> uri;
doc->GetDocumentURL(getter_AddRefs(uri));
nsXPIDLCString str;
uri->GetSpec(getter_Copies(str));
nsCAutoString str;
uri->GetSpec(str);
nsCStringKey key((const char*)str);
nsCStringKey key(str.get());
nsCOMPtr<nsIXBLDocumentInfo> info = getter_AddRefs(NS_STATIC_CAST(nsIXBLDocumentInfo*, mXBLDocTable.Get(&key)));
if (!info)
mXBLDocTable.Put(&key, aDocumentInfo);
@ -367,9 +367,9 @@ PRBool PR_CALLBACK FlushSkinXBL(nsHashKey* aKey, void* aData, void* aClosure)
docInfo->GetDocument(getter_AddRefs(doc));
nsCOMPtr<nsIURI> uri;
doc->GetDocumentURL(getter_AddRefs(uri));
nsXPIDLCString str;
uri->GetPath(getter_Copies(str));
if (!PL_strncmp(str.get(), "/skin", 5)) {
nsCAutoString str;
uri->GetPath(str);
if (!strncmp(str.get(), "/skin", 5)) {
// This is a skin binding. Add the key to the list.
nsHashKeys* list = (nsHashKeys*)aClosure;
list->AppendKey(aKey);
@ -382,9 +382,9 @@ PRBool PR_CALLBACK FlushSkinSheets(nsHashKey* aKey, void* aData, void* aClosure)
nsICSSStyleSheet* sheet = (nsICSSStyleSheet*)aData;
nsCOMPtr<nsIURI> uri;
sheet->GetURL(*getter_AddRefs(uri));
nsXPIDLCString str;
uri->GetPath(getter_Copies(str));
if (!PL_strncmp(str.get(), "/skin", 5)) {
nsCAutoString str;
uri->GetPath(str);
if (!strncmp(str.get(), "/skin", 5)) {
// This is a skin binding. Add the key to the list.
nsHashKeys* list = (nsHashKeys*)aClosure;
list->AppendKey(aKey);

17
content/xul/templates/src/nsXULContentUtils.cpp
View File

@ -373,17 +373,12 @@ nsXULContentUtils::MakeElementURI(nsIDocument* aDocument, const nsAReadableStrin
// figure out.
#define USE_BROKEN_RELATIVE_PARSING
#ifdef USE_BROKEN_RELATIVE_PARSING
nsXPIDLCString spec;
docURL->GetSpec(getter_Copies(spec));
if (! spec)
return NS_ERROR_FAILURE;
aURI.Assign(spec);
docURL->GetSpec(aURI);
if (aElementID.First() != '#') {
aURI.Append('#');
}
aURI.AppendWithConversion(aElementID);
aURI.Append(NS_ConvertUCS2toUTF8(aElementID));
#else
nsXPIDLCString spec;
rv = NS_MakeAbsoluteURI(nsCAutoString(aElementID), docURL, getter_Copies(spec));
@ -431,10 +426,8 @@ nsXULContentUtils::MakeElementID(nsIDocument* aDocument, const nsAReadableString
rv = aDocument->GetBaseURL(*getter_AddRefs(docURL));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString spec;
docURL->GetSpec(getter_Copies(spec));
if (! spec)
return NS_ERROR_FAILURE;
nsCAutoString spec;
docURL->GetSpec(spec);
// XXX FIX ME to not do a copy
nsAutoString str(aURI);
@ -444,7 +437,7 @@ nsXULContentUtils::MakeElementID(nsIDocument* aDocument, const nsAReadableString
#else
static const PRInt32 kFudge = 0;
#endif
PRInt32 len = PL_strlen(spec);
PRInt32 len = spec.Length();
aURI.Right(aElementID, aURI.Length() - (len + kFudge));
}
else {

13
directory/xpcom/base/src/nsLDAPProtocolHandler.cpp
View File

@ -59,13 +59,10 @@ nsLDAPProtocolHandler::~nsLDAPProtocolHandler()
// getter method for scheme attr
//
NS_IMETHODIMP
nsLDAPProtocolHandler::GetScheme(char **result)
nsLDAPProtocolHandler::GetScheme(nsACString &result)
{
*result = nsCRT::strdup("ldap");
if ( ! *result )
return NS_ERROR_OUT_OF_MEMORY;
else
return NS_OK;
result = "ldap";
return NS_OK;
}
// getter method for defaultPort attribute
@ -89,7 +86,9 @@ nsLDAPProtocolHandler::GetProtocolFlags(PRUint32 *result)
// construct an appropriate URI
//
NS_IMETHODIMP
nsLDAPProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
nsLDAPProtocolHandler::NewURI(const char *aSpec,
const char *aOriginCharset, // ignored
nsIURI *aBaseURI,
nsIURI **result)
{
nsCOMPtr<nsILDAPURL> url;

6
directory/xpcom/base/src/nsLDAPService.cpp
View File

@ -716,7 +716,7 @@ nsLDAPService::EstablishConnection(nsLDAPServiceEntry *aEntry,
nsCOMPtr<nsILDAPURL> url;
nsCOMPtr<nsILDAPConnection> conn, conn2;
nsCOMPtr<nsILDAPMessage> message;
nsXPIDLCString host;
nsCAutoString host;
nsXPIDLString binddn;
nsXPIDLString password;
PRInt32 port;
@ -744,7 +744,7 @@ nsLDAPService::EstablishConnection(nsLDAPServiceEntry *aEntry,
if (NS_FAILED(rv)) {
return NS_ERROR_FAILURE;
}
rv = url->GetHost(getter_Copies(host));
rv = url->GetAsciiHost(host);
if (NS_FAILED(rv)) {
return NS_ERROR_FAILURE;
}
@ -764,7 +764,7 @@ nsLDAPService::EstablishConnection(nsLDAPServiceEntry *aEntry,
// Here we need to provide the binddn, see bug #75990
//
rv = conn->Init(host, port, 0, this);
rv = conn->Init(host.get(), port, 0, this);
if (NS_FAILED(rv)) {
switch (rv) {
// Only pass along errors we are aware of

142
directory/xpcom/base/src/nsLDAPURL.cpp
View File

@ -35,11 +35,12 @@
#include "nsLDAPURL.h"
#include "nsReadableUtils.h"
#include "netCore.h"
// The two schemes we support, LDAP and LDAPS
//
static const char *kLDAPScheme = "ldap";
static const char *kLDAPSSLScheme = "ldaps";
static const char kLDAPScheme[] = "ldap";
static const char kLDAPSSLScheme[] = "ldaps";
// Constructor and destructor
@ -83,16 +84,11 @@ nsLDAPURL::Init()
// attribute string spec;
//
NS_IMETHODIMP
nsLDAPURL::GetSpec(char **_retval)
nsLDAPURL::GetSpec(nsACString &_retval)
{
nsCAutoString spec;
PRUint32 count;
if (!_retval) {
NS_ERROR("nsLDAPURL::GetSpec: null pointer ");
return NS_ERROR_NULL_POINTER;
}
spec = ((mOptions & OPT_SECURE) ? kLDAPSSLScheme : kLDAPScheme);
spec.Append("://");
if (mHost.Length() > 0) {
@ -134,16 +130,11 @@ nsLDAPURL::GetSpec(char **_retval)
}
}
*_retval = ToNewCString(spec);
if (!*_retval) {
NS_ERROR("nsLDAPURL::GetSpec: out of memory ");
return NS_ERROR_OUT_OF_MEMORY;
}
_retval = spec;
return NS_OK;
}
NS_IMETHODIMP
nsLDAPURL::SetSpec(const char *aSpec)
nsLDAPURL::SetSpec(const nsACString &aSpec)
{
PRUint32 rv, count;
LDAPURLDesc *desc;
@ -153,7 +144,7 @@ nsLDAPURL::SetSpec(const char *aSpec)
// This is from the LDAP C-SDK, which currently doesn't
// support everything from RFC 2255... :(
//
rv = ldap_url_parse(aSpec, &desc);
rv = ldap_url_parse(PromiseFlatCString(aSpec).get(), &desc);
switch (rv) {
case LDAP_SUCCESS:
mHost = desc->lud_host;
@ -204,39 +195,24 @@ nsLDAPURL::SetSpec(const char *aSpec)
// attribute string prePath;
//
NS_IMETHODIMP nsLDAPURL::GetPrePath(char **_retval)
NS_IMETHODIMP nsLDAPURL::GetPrePath(nsACString &_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsLDAPURL::SetPrePath(const char *aPrePath)
{
return NS_ERROR_NOT_IMPLEMENTED;
_retval.Truncate();
return NS_OK;
}
// attribute string scheme;
//
NS_IMETHODIMP nsLDAPURL::GetScheme(char **_retval)
NS_IMETHODIMP nsLDAPURL::GetScheme(nsACString &_retval)
{
if (!_retval) {
NS_ERROR("nsLDAPURL::GetScheme: null pointer ");
return NS_ERROR_NULL_POINTER;
}
*_retval = nsCRT::strdup((mOptions & OPT_SECURE) ? kLDAPSSLScheme :
kLDAPScheme);
if (!*_retval) {
NS_ERROR("nsLDAPURL::GetScheme: out of memory ");
return NS_ERROR_OUT_OF_MEMORY;
}
_retval = (mOptions & OPT_SECURE) ? kLDAPSSLScheme : kLDAPScheme;
return NS_OK;
}
NS_IMETHODIMP nsLDAPURL::SetScheme(const char *aScheme)
NS_IMETHODIMP nsLDAPURL::SetScheme(const nsACString &aScheme)
{
if (nsCRT::strcasecmp(aScheme, kLDAPScheme) == 0) {
if (aScheme.Equals(kLDAPScheme, nsCaseInsensitiveCStringComparator())) {
mOptions ^= OPT_SECURE;
} else if (nsCRT::strcasecmp(aScheme, kLDAPSSLScheme) == 0) {
} else if (aScheme.Equals(kLDAPSSLScheme, nsCaseInsensitiveCStringComparator())) {
mOptions |= OPT_SECURE;
} else {
return NS_ERROR_MALFORMED_URI;
@ -245,15 +221,16 @@ NS_IMETHODIMP nsLDAPURL::SetScheme(const char *aScheme)
return NS_OK;
}
// attribute string preHost;
// attribute string userPass;
//
NS_IMETHODIMP
nsLDAPURL::GetPreHost(char **_retval)
nsLDAPURL::GetUserPass(nsACString &_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
_retval.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsLDAPURL::SetPreHost(const char *aPreHost)
nsLDAPURL::SetUserPass(const nsACString &aPreHost)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
@ -261,12 +238,13 @@ nsLDAPURL::SetPreHost(const char *aPreHost)
// attribute string username
//
NS_IMETHODIMP
nsLDAPURL::GetUsername(char **_retval)
nsLDAPURL::GetUsername(nsACString &_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
_retval.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsLDAPURL::SetUsername(const char *aUsername)
nsLDAPURL::SetUsername(const nsACString &aUsername)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
@ -274,12 +252,27 @@ nsLDAPURL::SetUsername(const char *aUsername)
// attribute string password;
//
NS_IMETHODIMP
nsLDAPURL::GetPassword(char **_retval)
nsLDAPURL::GetPassword(nsACString &_retval)
{
_retval.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsLDAPURL::SetPassword(const nsACString &aPassword)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
// attribute string hostPort;
//
NS_IMETHODIMP
nsLDAPURL::SetPassword(const char *aPassword)
nsLDAPURL::GetHostPort(nsACString &_retval)
{
_retval.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsLDAPURL::SetHostPort(const nsACString &aHostPort)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
@ -287,23 +280,13 @@ nsLDAPURL::SetPassword(const char *aPassword)
// attribute string host;
//
NS_IMETHODIMP
nsLDAPURL::GetHost(char **_retval)
nsLDAPURL::GetHost(nsACString &_retval)
{
if (!_retval) {
NS_ERROR("nsLDAPURL::GetHost: null pointer ");
return NS_ERROR_NULL_POINTER;
}
*_retval = ToNewCString(mHost);
if (!*_retval) {
NS_ERROR("nsLDAPURL::GetHost: out of memory ");
return NS_ERROR_OUT_OF_MEMORY;
}
_retval = mHost;
return NS_OK;
}
NS_IMETHODIMP
nsLDAPURL::SetHost(const char *aHost)
nsLDAPURL::SetHost(const nsACString &aHost)
{
mHost = aHost;
return NS_OK;
@ -346,27 +329,34 @@ nsLDAPURL::SetPort(PRInt32 aPort)
// attribute string path;
// XXXleif: For now, these are identical to SetDn()/GetDn().
NS_IMETHODIMP nsLDAPURL::GetPath(char **_retval)
NS_IMETHODIMP nsLDAPURL::GetPath(nsACString &_retval)
{
if (!_retval) {
NS_ERROR("nsLDAPURL::GetPath: null pointer ");
return NS_ERROR_NULL_POINTER;
}
*_retval = ToNewCString(mDN);
if (!*_retval) {
NS_ERROR("nsLDAPURL::GetPath: out of memory ");
return NS_ERROR_OUT_OF_MEMORY;
}
_retval = mDN;
return NS_OK;
}
NS_IMETHODIMP nsLDAPURL::SetPath(const char *aPath)
NS_IMETHODIMP nsLDAPURL::SetPath(const nsACString &aPath)
{
mDN = aPath;
return NS_OK;
}
// attribute string specA
NS_IMETHODIMP nsLDAPURL::GetAsciiSpec(nsACString &_retval)
{
return GetSpec(_retval);
}
// attribute string hostA
NS_IMETHODIMP nsLDAPURL::GetAsciiHost(nsACString &_retval)
{
return GetHost(_retval);
}
NS_IMETHODIMP nsLDAPURL::GetOriginCharset(nsACString &result)
{
result.Truncate();
return NS_OK;
}
// boolean equals (in nsIURI other)
//
NS_IMETHODIMP nsLDAPURL::Equals(nsIURI *other, PRBool *_retval)
@ -397,8 +387,8 @@ NS_IMETHODIMP nsLDAPURL::Clone(nsIURI **_retval)
// string resolve (in string relativePath);
//
NS_IMETHODIMP nsLDAPURL::Resolve(const char *relativePath,
char **_retval)
NS_IMETHODIMP nsLDAPURL::Resolve(const nsACString &relativePath,
nsACString &_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
}

29
docshell/base/nsDefaultURIFixup.cpp
View File

@ -88,10 +88,9 @@ nsDefaultURIFixup::CreateFixupURI(const PRUnichar *aStringURI, PRUint32 aFixupFl
getter_AddRefs(uri));
if (NS_FAILED(rv) || !uri)
return NS_ERROR_FAILURE;
nsXPIDLCString spec;
uri->GetSpec(getter_Copies(spec));
uriString.Assign(NS_LITERAL_STRING("view-source:"));
uriString.Append(NS_ConvertASCIItoUCS2(spec));
nsCAutoString spec;
uri->GetSpec(spec);
uriString.Assign(NS_LITERAL_STRING("view-source:") + NS_ConvertUTF8toUCS2(spec));
}
else {
// Check for if it is a file URL
@ -205,20 +204,14 @@ PRBool nsDefaultURIFixup::MakeAlternateURI(nsIURI *aURI)
}
// Security - URLs with user / password info should NOT be fixed up
nsXPIDLCString username;
nsXPIDLCString password;
aURI->GetUsername(getter_Copies(username));
aURI->GetPassword(getter_Copies(password));
if (username.Length() > 0 || password.Length() > 0)
{
nsCAutoString userpass;
aURI->GetUserPass(userpass);
if (userpass.Length() > 0) {
return PR_FALSE;
}
nsXPIDLCString host;
aURI->GetHost(getter_Copies(host));
nsCAutoString oldHost(host);
nsCAutoString newHost;
nsCAutoString oldHost, newHost;
aURI->GetHost(oldHost);
// Count the dots
PRInt32 numDots = 0;
@ -267,7 +260,7 @@ PRBool nsDefaultURIFixup::MakeAlternateURI(nsIURI *aURI)
}
// Assign the new host string over the old one
aURI->SetHost(newHost.get());
aURI->SetHost(newHost);
return PR_TRUE;
}
@ -352,9 +345,7 @@ nsresult nsDefaultURIFixup::ConvertFileToStringURI(nsString& aIn,
nsresult rv = NS_NewLocalFile(file.get(), PR_FALSE, getter_AddRefs(filePath));
if (NS_SUCCEEDED(rv))
{
nsXPIDLCString fileurl;
NS_GetURLSpecFromFile(filePath, getter_Copies(fileurl));
aOut.Assign(fileurl);
NS_GetURLSpecFromFile(filePath, aOut);
return NS_OK;
}
}

123
docshell/base/nsDocShell.cpp
View File

@ -516,8 +516,8 @@ nsDocShell::LoadURI(nsIURI * aURI,
#ifdef PR_LOGGING
if (PR_LOG_TEST(gDocShellLog, PR_LOG_DEBUG)) {
nsXPIDLCString uristr;
aURI->GetSpec(getter_Copies(uristr));
nsCAutoString uristr;
aURI->GetAsciiSpec(uristr);
PR_LOG(gDocShellLog, PR_LOG_DEBUG,
("nsDocShell[%p]: loading %s with flags 0x%08x",
this, uristr.get(), aLoadFlags));
@ -675,7 +675,7 @@ nsDocShell::LoadStream(nsIInputStream * aStream, nsIURI * aURI,
return rv;
// Make sure that the URI spec "looks" like a protocol and path...
// For now, just use a bogus protocol called "internal"
rv = uri->SetSpec("internal:load-stream");
rv = uri->SetSpec(NS_LITERAL_CSTRING("internal:load-stream"));
if (NS_FAILED(rv))
return rv;
}
@ -770,35 +770,35 @@ nsDocShell::FireUnloadNotification()
static
PRBool SameOrSubdomainOfTarget(nsIURI* aOriginURI, nsIURI* aTargetURI, PRBool aDocumentDomainSet)
{
nsXPIDLCString targetScheme;
nsresult rv = aTargetURI->GetScheme(getter_Copies(targetScheme));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetScheme, PR_TRUE);
nsCAutoString targetScheme;
nsresult rv = aTargetURI->GetScheme(targetScheme);
NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE);
nsXPIDLCString originScheme;
rv = aOriginURI->GetScheme(getter_Copies(originScheme));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && originScheme, PR_TRUE);
nsCAutoString originScheme;
rv = aOriginURI->GetScheme(originScheme);
NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE);
if (PL_strcmp(targetScheme, originScheme))
if (strcmp(targetScheme.get(), originScheme.get()))
return PR_FALSE; // Different schemes - check fails
if (! PL_strcmp(targetScheme, "file"))
if (! strcmp(targetScheme.get(), "file"))
return PR_TRUE; // All file: urls are considered to have the same origin.
if (! PL_strcmp(targetScheme, "imap") ||
! PL_strcmp(targetScheme, "mailbox") ||
! PL_strcmp(targetScheme, "news"))
if (! strcmp(targetScheme.get(), "imap") ||
! strcmp(targetScheme.get(), "mailbox") ||
! strcmp(targetScheme.get(), "news"))
{
// Each message is a distinct trust domain; use the whole spec for comparison
nsXPIDLCString targetSpec;
rv =aTargetURI->GetSpec(getter_Copies(targetSpec));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetSpec, PR_TRUE);
nsCAutoString targetSpec;
rv =aTargetURI->GetAsciiSpec(targetSpec);
NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE);
nsXPIDLCString originSpec;
rv = aOriginURI->GetSpec(getter_Copies(originSpec));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && originSpec, PR_TRUE);
nsCAutoString originSpec;
rv = aOriginURI->GetAsciiSpec(originSpec);
NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE);
return (! PL_strcmp(targetSpec, originSpec)); // True if full spec is same, false otherwise
return (! strcmp(targetSpec.get(), originSpec.get())); // True if full spec is same, false otherwise
}
// Compare ports.
@ -813,28 +813,28 @@ PRBool SameOrSubdomainOfTarget(nsIURI* aOriginURI, nsIURI* aTargetURI, PRBool aD
return PR_FALSE; // Different port - check fails
// Need to check the hosts
nsXPIDLCString targetHost;
rv = aTargetURI->GetHost(getter_Copies(targetHost));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetHost, PR_TRUE);
nsCAutoString targetHost;
rv = aTargetURI->GetHost(targetHost);
NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE);
nsXPIDLCString originHost;
rv = aOriginURI->GetHost(getter_Copies(originHost));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && originHost, PR_TRUE);
nsCAutoString originHost;
rv = aOriginURI->GetHost(originHost);
NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE);
if (!PL_strcmp(targetHost, originHost))
if (!strcmp(targetHost.get(), originHost.get()))
return PR_TRUE; // Hosts are the same - check passed
// If document.domain was set, do the relaxed check
// Right align hostnames and compare - ensure preceeding char is . or /
if (aDocumentDomainSet)
{
int targetHostLen = PL_strlen(targetHost);
int originHostLen = PL_strlen(originHost);
int targetHostLen = targetHost.Length();
int originHostLen = originHost.Length();
int prefixChar = originHostLen-targetHostLen-1;
return ((originHostLen > targetHostLen) &&
(! PL_strcmp((originHost+prefixChar+1), targetHost)) &&
(originHost[prefixChar] == '.' || originHost[prefixChar] == '/'));
(! strcmp((originHost.get()+prefixChar+1), targetHost.get())) &&
(originHost.CharAt(prefixChar) == '.' || originHost.CharAt(prefixChar) == '/'));
}
return PR_FALSE; // document.domain not set and hosts not same - check failed
@ -2884,12 +2884,12 @@ nsDocShell::SetTitle(const PRUnichar * aTitle)
}
if (mGlobalHistory && mCurrentURI) {
nsXPIDLCString url;
mCurrentURI->GetSpec(getter_Copies(url));
nsCAutoString url;
mCurrentURI->GetSpec(url);
nsCOMPtr<nsIBrowserHistory> browserHistory =
do_QueryInterface(mGlobalHistory);
if (browserHistory)
browserHistory->SetPageTitle(url, aTitle);
browserHistory->SetPageTitle(url.get(), aTitle);
}
@ -3472,7 +3472,7 @@ nsDocShell::SetupRefreshURIFromHeader(nsIURI * aBaseURI,
}
else {
uriAttrib = Substring(tokenStart, iter);
rv = NS_NewURI(getter_AddRefs(uri), uriAttrib, aBaseURI);
rv = NS_NewURI(getter_AddRefs(uri), uriAttrib, nsnull, aBaseURI);
}
if (NS_SUCCEEDED(rv)) {
@ -3726,9 +3726,9 @@ nsDocShell::OnStateChange(nsIWebProgress * aProgress, nsIRequest * aRequest,
nsCOMPtr<nsIBrowserHistory> browserHistory =
do_QueryInterface(mGlobalHistory);
if (browserHistory) {
nsXPIDLCString urlString;
if (NS_SUCCEEDED(uri->GetSpec(getter_Copies(urlString))))
browserHistory->HidePage(urlString);
nsCAutoString urlString;
if (NS_SUCCEEDED(uri->GetSpec(urlString)))
browserHistory->HidePage(urlString.get());
}
}
@ -4325,14 +4325,14 @@ nsDocShell::InternalLoad(nsIURI * aURI,
name.EqualsIgnoreCase("_blank")))
{
nsCOMPtr<nsIExternalProtocolService> extProtService;
nsXPIDLCString urlScheme;
nsCAutoString urlScheme;
extProtService = do_GetService(NS_EXTERNALPROTOCOLSERVICE_CONTRACTID);
if (extProtService) {
PRBool haveHandler = PR_FALSE;
aURI->GetScheme(getter_Copies(urlScheme));
aURI->GetScheme(urlScheme);
extProtService->ExternalProtocolHandlerExists(urlScheme,
extProtService->ExternalProtocolHandlerExists(urlScheme.get(),
&haveHandler);
if (haveHandler)
return extProtService->LoadUrl(aURI);
@ -4534,7 +4534,7 @@ nsDocShell::CreateFixupURI(const PRUnichar * aStringURI, nsIURI ** aURI)
mURIFixup = do_GetService(NS_URIFIXUP_CONTRACTID);
if (!mURIFixup) {
// No fixup service so try and create a URI and see what happens
return NS_NewURI(aURI, uriString, nsnull);
return NS_NewURI(aURI, uriString);
}
}
@ -4606,11 +4606,11 @@ nsresult nsDocShell::DoURILoad(nsIURI * aURI,
// open a channel for the url
nsCOMPtr<nsIChannel> channel;
rv = NS_OpenURI(getter_AddRefs(channel),
aURI,
nsnull,
loadGroup,
NS_STATIC_CAST(nsIInterfaceRequestor *, this));
rv = NS_NewChannel(getter_AddRefs(channel),
aURI,
nsnull,
loadGroup,
NS_STATIC_CAST(nsIInterfaceRequestor *, this));
if (NS_FAILED(rv))
return rv;
@ -4975,12 +4975,12 @@ nsDocShell::ScrollIfAnchor(nsIURI * aURI, PRBool * aWasAnchor)
// NOTE: we assume URIs are absolute for comparison purposes
nsXPIDLCString currentSpec;
NS_ENSURE_SUCCESS(mCurrentURI->GetSpec(getter_Copies(currentSpec)),
nsCAutoString currentSpec;
NS_ENSURE_SUCCESS(mCurrentURI->GetSpec(currentSpec),
NS_ERROR_FAILURE);
nsXPIDLCString newSpec;
NS_ENSURE_SUCCESS(aURI->GetSpec(getter_Copies(newSpec)), NS_ERROR_FAILURE);
nsCAutoString newSpec;
NS_ENSURE_SUCCESS(aURI->GetSpec(newSpec), NS_ERROR_FAILURE);
// Search for hash marks in the current URI and the new URI and
// take a copy of everything to the left of the hash for
@ -5271,21 +5271,18 @@ nsDocShell::ShouldAddToSessionHistory(nsIURI * aURI)
// should just do a spec compare, rather than two gets of the scheme and
// then the path. -Gagan
nsresult rv;
nsXPIDLCString buffer;
nsCAutoString schemeStr;
nsCAutoString buf;
rv = aURI->GetScheme(getter_Copies(buffer));
rv = aURI->GetScheme(buf);
if (NS_FAILED(rv))
return PR_FALSE;
schemeStr = buffer;
if (schemeStr.Equals("about")) {
rv = aURI->GetPath(getter_Copies(buffer));
if (buf.Equals("about")) {
rv = aURI->GetPath(buf);
if (NS_FAILED(rv))
return PR_FALSE;
schemeStr = buffer;
if (schemeStr.Equals("blank")) {
if (buf.Equals("blank")) {
return PR_FALSE;
}
}
@ -5776,10 +5773,10 @@ nsDocShell::AddToGlobalHistory(nsIURI * aURI)
{
NS_ENSURE_STATE(mGlobalHistory);
nsXPIDLCString spec;
NS_ENSURE_SUCCESS(aURI->GetSpec(getter_Copies(spec)), NS_ERROR_FAILURE);
nsCAutoString spec;
NS_ENSURE_SUCCESS(aURI->GetSpec(spec), NS_ERROR_FAILURE);
NS_ENSURE_SUCCESS(mGlobalHistory->AddPage(spec), NS_ERROR_FAILURE);
NS_ENSURE_SUCCESS(mGlobalHistory->AddPage(spec.get()), NS_ERROR_FAILURE);
return NS_OK;
}

48
docshell/base/nsWebShell.cpp
View File

@ -586,13 +586,13 @@ nsWebShell::HandleLinkClickEvent(nsIContent *aContent,
if (!uri && NS_SUCCEEDED(EnsureContentListener()))
{
nsCOMPtr<nsIURIContentListener> listener = do_QueryInterface(mContentListener);
nsCAutoString spec; spec.AssignWithConversion(aURLSpec);
NS_ConvertUCS2toUTF8 spec(aURLSpec);
PRBool abort = PR_FALSE;
uri = do_CreateInstance(kSimpleURICID, &rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "can't create simple uri");
if (NS_SUCCEEDED(rv))
{
rv = uri->SetSpec(spec.get());
rv = uri->SetSpec(spec);
NS_ASSERTION(NS_SUCCEEDED(rv), "spec is invalid");
if (NS_SUCCEEDED(rv))
{
@ -734,10 +734,10 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
getter_Copies(messageStr));
if (NS_SUCCEEDED(rv) && messageStr) {
nsXPIDLCString spec;
url->GetPath(getter_Copies(spec));
nsCAutoString spec;
url->GetPath(spec);
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, (const char*)spec);
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, spec.get());
if (!msg) return NS_ERROR_OUT_OF_MEMORY;
prompter->Alert(nsnull, msg);
@ -760,8 +760,8 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
//
nsCOMPtr<nsIURI> newURI;
nsXPIDLCString oldSpec;
url->GetSpec(getter_Copies(oldSpec));
nsCAutoString oldSpec;
url->GetSpec(oldSpec);
NS_ConvertUTF8toUCS2 oldSpecW(oldSpec);
//
@ -812,12 +812,12 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
url->Equals(newURI, &sameURI);
if (!sameURI)
{
nsXPIDLCString newSpec;
newURI->GetSpec(getter_Copies(newSpec));
nsAutoString newSpecW; newSpecW.AssignWithConversion(newSpec.get());
nsCAutoString newSpec;
newURI->GetSpec(newSpec);
NS_ConvertUTF8toUCS2 newSpecW(newSpec);
// This seems evil, since it is modifying the original URL
rv = url->SetSpec(newSpec.get());
rv = url->SetSpec(newSpec);
if (NS_FAILED(rv)) return rv;
return LoadURI(newSpecW.get(), // URI string
@ -851,9 +851,9 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
getter_Copies(messageStr));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString host;
url->GetHost(getter_Copies(host));
if (host) {
nsCAutoString host;
url->GetHost(host);
if (!host.IsEmpty()) {
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, host.get());
if (!msg) return NS_ERROR_OUT_OF_MEMORY;
@ -866,11 +866,6 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
// throw a connection failure dialog
//
else if(aStatus == NS_ERROR_CONNECTION_REFUSED) {
PRInt32 port = -1;
rv = url->GetPort(&port);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIPrompt> prompter;
nsCOMPtr<nsIStringBundle> stringBundle;
@ -886,15 +881,10 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
if (NS_FAILED(rv)) return rv;
// build up the host:port string.
nsXPIDLCString host;
url->GetHost(getter_Copies(host));
nsCAutoString combo(host);
if (port > 0) {
combo.Append(':');
combo.AppendInt(port);
}
nsCAutoString hostport;
url->GetHostPort(hostport);
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, combo.get());
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, hostport.get());
if (!msg) return NS_ERROR_OUT_OF_MEMORY;
prompter->Alert(nsnull, msg);
@ -919,8 +909,8 @@ nsresult nsWebShell::EndPageLoad(nsIWebProgress *aProgress,
getter_Copies(messageStr));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString host;
url->GetHost(getter_Copies(host));
nsCAutoString host;
url->GetHost(host);
PRUnichar *msg = nsTextFormatter::smprintf(messageStr, host.get());
if (!msg) return NS_ERROR_OUT_OF_MEMORY;

8
dom/src/base/nsGlobalWindow.cpp
View File

@ -409,12 +409,12 @@ GlobalWindowImpl::SetNewDocument(nsIDOMDocument* aDocument,
}
if (docURL) {
nsXPIDLCString url;
nsCAutoString url;
docURL->GetSpec(getter_Copies(url));
docURL->GetSpec(url);
//about:blank URL's do not have ClearScope called on page change.
if (nsCRT::strcmp(url.get(), "about:blank") != 0) {
if (strcmp(url.get(), "about:blank") != 0) {
ClearAllTimeouts();
if (mSidebar) {
@ -4533,7 +4533,7 @@ GlobalWindowImpl::SecurityCheckURL(const char *aURL)
}
}
rv = NS_NewURI(getter_AddRefs(uriToLoad), aURL, baseURI);
rv = NS_NewURI(getter_AddRefs(uriToLoad), nsDependentCString(aURL), nsnull, baseURI);
if (NS_FAILED(rv))
return rv;

4
dom/src/base/nsGlobalWindow.h
View File

@ -408,7 +408,9 @@ public:
NS_DECL_NSIDOMNSLOCATION
protected:
nsresult SetURL(nsIURI* aURL);
nsresult GetURI(nsIURI** aURL);
nsresult GetWritableURI(nsIURI** aURL);
nsresult SetURI(nsIURI* aURL);
nsresult SetHrefWithBase(const nsAReadableString& aHref, nsIURI* aBase,
PRBool aReplace);
nsresult SetHrefWithContext(JSContext* cx, const nsAReadableString& aHref,

34
dom/src/base/nsHistory.cpp
View File

@ -100,7 +100,7 @@ NS_IMETHODIMP
HistoryImpl::GetCurrent(nsAWritableString& aCurrent)
{
PRInt32 curIndex=0;
char * curURL=nsnull;
nsCAutoString curURL;
nsCOMPtr<nsISHistory> sHistory;
// Get SessionHistory from docshell
@ -119,9 +119,8 @@ HistoryImpl::GetCurrent(nsAWritableString& aCurrent)
// Get the URI for the current entry
curEntry->GetURI(getter_AddRefs(uri));
NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
uri->GetSpec(&curURL);
aCurrent.Assign(NS_ConvertASCIItoUCS2(curURL));
nsCRT::free(curURL);
uri->GetSpec(curURL);
aCurrent.Assign(NS_ConvertUTF8toUCS2(curURL));
return NS_OK;
}
@ -130,7 +129,7 @@ NS_IMETHODIMP
HistoryImpl::GetPrevious(nsAWritableString& aPrevious)
{
PRInt32 curIndex;
char * prevURL = nsnull;
nsCAutoString prevURL;
nsCOMPtr<nsISHistory> sHistory;
// Get session History from docshell
@ -149,9 +148,8 @@ HistoryImpl::GetPrevious(nsAWritableString& aPrevious)
// Get the URI for the previous entry
prevEntry->GetURI(getter_AddRefs(uri));
NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
uri->GetSpec(&prevURL);
aPrevious.Assign(NS_ConvertASCIItoUCS2(prevURL));
nsCRT::free(prevURL);
uri->GetSpec(prevURL);
aPrevious.Assign(NS_ConvertUTF8toUCS2(prevURL));
return NS_OK;
}
@ -160,7 +158,7 @@ NS_IMETHODIMP
HistoryImpl::GetNext(nsAWritableString& aNext)
{
PRInt32 curIndex;
char * nextURL = nsnull;
nsCAutoString nextURL;
nsCOMPtr<nsISHistory> sHistory;
// Get session History from docshell
@ -179,9 +177,8 @@ HistoryImpl::GetNext(nsAWritableString& aNext)
// Get the URI for the next entry
nextEntry->GetURI(getter_AddRefs(uri));
NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
uri->GetSpec(&nextURL);
aNext.Assign(NS_ConvertASCIItoUCS2(nextURL));
nsCRT::free(nextURL);
uri->GetSpec(nextURL);
aNext.Assign(NS_ConvertUTF8toUCS2(nextURL));
return NS_OK;
}
@ -272,11 +269,10 @@ HistoryImpl::GoUri(const nsAReadableString& aUriSubstring)
rv = sh_entry->GetURI(getter_AddRefs(uri));
if (uri) {
nsXPIDLCString urlCString;
rv = uri->GetSpec(getter_Copies(urlCString));
nsCAutoString urlCString;
rv = uri->GetSpec(urlCString);
nsAutoString url;
url.AssignWithConversion(urlCString);
NS_ConvertUTF8toUCS2 url(urlCString);
nsReadingIterator<PRUnichar> start;
nsReadingIterator<PRUnichar> end;
@ -364,10 +360,10 @@ HistoryImpl::Item(PRUint32 aIndex, nsAWritableString& aReturn)
}
if (uri) {
nsXPIDLCString urlCString;
rv = uri->GetSpec(getter_Copies(urlCString));
nsCAutoString urlCString;
rv = uri->GetSpec(urlCString);
aReturn.Assign(NS_ConvertASCIItoUCS2(urlCString));
aReturn.Assign(NS_ConvertUTF8toUCS2(urlCString));
}
return rv;

364
dom/src/base/nsLocation.cpp
View File

@ -51,6 +51,7 @@
#include "prprf.h"
#include "prmem.h"
#include "nsCOMPtr.h"
#include "nsEscape.h"
#include "nsJSUtils.h"
#include "nsIScriptSecurityManager.h"
#include "nsICodebasePrincipal.h"
@ -230,9 +231,30 @@ LocationImpl::CheckURL(nsIURI* aURI, nsIDocShellLoadInfo** aLoadInfo)
return NS_OK;
}
nsresult
LocationImpl::GetURI(nsIURI** aURI)
{
nsresult rv;
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell, &rv));
if (NS_FAILED(rv)) return rv;
return webNav->GetCurrentURI(aURI);
}
nsresult
LocationImpl::SetURL(nsIURI* aURI)
LocationImpl::GetWritableURI(nsIURI** aURI)
{
nsCOMPtr<nsIURI> uri;
nsresult rv = GetURI(getter_AddRefs(uri));
if (NS_FAILED(rv)) return rv;
return uri->Clone(aURI);
}
nsresult
LocationImpl::SetURI(nsIURI* aURI)
{
if (mDocShell) {
nsCOMPtr<nsIDocShellLoadInfo> loadInfo;
@ -252,31 +274,26 @@ LocationImpl::SetURL(nsIURI* aURI)
NS_IMETHODIMP
LocationImpl::GetHash(nsAWritableString& aHash)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
nsCAutoString ref;
result = NS_NewURI(getter_AddRefs(uri), href);
if (url) {
result = url->GetRef(ref);
// XXX danger... this may result in non-ASCII octets!
NS_UnescapeURL(ref);
}
if (uri) {
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
nsXPIDLCString ref;
if (url) {
result = url->GetRef(getter_Copies(ref));
}
if (NS_SUCCEEDED(result) && ref && *ref) {
aHash.Assign(NS_LITERAL_STRING("#"));
aHash.Append(NS_ConvertASCIItoUCS2(ref));
}
else {
aHash.SetLength(0);
}
if (NS_SUCCEEDED(result) && !ref.IsEmpty()) {
aHash.Assign(NS_LITERAL_STRING("#") + NS_ConvertASCIItoUCS2(ref));
}
else {
aHash.SetLength(0);
}
}
@ -286,23 +303,15 @@ LocationImpl::GetHash(nsAWritableString& aHash)
NS_IMETHODIMP
LocationImpl::SetHash(const nsAReadableString& aHash)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetWritableURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), href);
if (NS_FAILED(result))
return result;
nsCOMPtr<nsIURL> url(do_QueryInterface(uri, &result));
if (url) {
url->SetRef(NS_ConvertUCS2toUTF8(aHash).get());
url->SetRef(NS_ConvertUCS2toUTF8(aHash));
if (mDocShell) {
nsCOMPtr<nsIDocShellLoadInfo> loadInfo;
@ -323,38 +332,18 @@ LocationImpl::SetHash(const nsAReadableString& aHash)
NS_IMETHODIMP
LocationImpl::GetHost(nsAWritableString& aHost)
{
nsAutoString href;
nsresult result = NS_OK;
nsCOMPtr<nsIURI> uri;
nsresult result;
result = GetHref(href);
result = GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
nsCAutoString hostport;
result = NS_NewURI(getter_AddRefs(uri), href);
result = uri->GetHostPort(hostport);
if (uri) {
nsXPIDLCString host;
result = uri->GetHost(getter_Copies(host));
if (NS_SUCCEEDED(result)) {
PRInt32 port;
CopyASCIItoUCS2(nsDependentCString(host), aHost);
uri->GetPort(&port);
if (port != -1) {
aHost.Append(PRUnichar(':'));
nsAutoString tmpHost;
tmpHost.AppendInt(port);
aHost.Append(tmpHost);
}
}
}
if (NS_SUCCEEDED(result))
aHost = NS_ConvertUTF8toUCS2(hostport);
}
return result;
@ -363,21 +352,14 @@ LocationImpl::GetHost(nsAWritableString& aHost)
NS_IMETHODIMP
LocationImpl::SetHost(const nsAReadableString& aHost)
{
nsAutoString href;
nsresult result = NS_OK;
nsCOMPtr<nsIURI> uri;
nsresult result;
result = GetHref(href);
result = GetWritableURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), href);
if (uri) {
uri->SetHost(NS_ConvertUCS2toUTF8(aHost).get());
SetURL(uri);
}
uri->SetHostPort(NS_ConvertUCS2toUTF8(aHost));
SetURI(uri);
}
return result;
@ -386,25 +368,18 @@ LocationImpl::SetHost(const nsAReadableString& aHost)
NS_IMETHODIMP
LocationImpl::GetHostname(nsAWritableString& aHostname)
{
nsAutoString href;
nsresult result = NS_OK;
nsCOMPtr<nsIURI> uri;
nsresult result;
result = GetHref(href);
result = GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
nsCAutoString host;
result = NS_NewURI(getter_AddRefs(uri), href);
result = uri->GetHost(host);
if (uri) {
nsXPIDLCString host;
result = uri->GetHost(getter_Copies(host));
if (NS_SUCCEEDED(result)) {
CopyASCIItoUCS2(nsDependentCString(host), aHostname);
}
}
if (NS_SUCCEEDED(result))
aHostname = NS_ConvertUTF8toUCS2(host);
}
return result;
@ -413,20 +388,14 @@ LocationImpl::GetHostname(nsAWritableString& aHostname)
NS_IMETHODIMP
LocationImpl::SetHostname(const nsAReadableString& aHostname)
{
nsAutoString href;
nsresult result = NS_OK;
nsCOMPtr<nsIURI> uri;
nsresult result;
result = GetHref(href);
result = GetWritableURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), href);
if (uri) {
uri->SetHost(NS_ConvertUCS2toUTF8(aHostname).get());
SetURL(uri);
}
uri->SetHost(NS_ConvertUCS2toUTF8(aHostname));
SetURI(uri);
}
return result;
@ -435,23 +404,18 @@ LocationImpl::SetHostname(const nsAReadableString& aHostname)
NS_IMETHODIMP
LocationImpl::GetHref(nsAWritableString& aHref)
{
nsresult result = NS_OK;
nsCOMPtr<nsIURI> uri;
nsresult result;
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
result = GetURI(getter_AddRefs(uri));
if (webNav) {
nsCOMPtr<nsIURI> uri;
if (NS_SUCCEEDED(result) && uri) {
nsCAutoString uriString;
result = webNav->GetCurrentURI(getter_AddRefs(uri));
result = uri->GetSpec(uriString);
if (NS_SUCCEEDED(result) && uri) {
nsXPIDLCString uriString;
result = uri->GetSpec(getter_Copies(uriString));
if (NS_SUCCEEDED(result))
CopyASCIItoUCS2(nsDependentCString(uriString), aHref);
}
if (NS_SUCCEEDED(result))
aHref = NS_ConvertUTF8toUCS2(uriString);
}
return result;
@ -526,9 +490,9 @@ LocationImpl::SetHrefWithBase(const nsAReadableString& aHref,
(void) EscapeNonAsciiInURI(aHref, escapedHref);
if (escapedHref.IsEmpty())
result = NS_NewURI(getter_AddRefs(newUri), aHref, aBase);
result = NS_NewURI(getter_AddRefs(newUri), aHref, nsnull, aBase);
else
result = NS_NewURI(getter_AddRefs(newUri), escapedHref.get(), aBase);
result = NS_NewURI(getter_AddRefs(newUri), escapedHref, nsnull, aBase);
if (newUri && mDocShell) {
nsCOMPtr<nsIDocShellLoadInfo> loadInfo;
@ -581,29 +545,22 @@ LocationImpl::SetHrefWithBase(const nsAReadableString& aHref,
NS_IMETHODIMP
LocationImpl::GetPathname(nsAWritableString& aPathname)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
aPathname.Truncate();
result = GetHref(href);
result = GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
nsCAutoString file;
result = NS_NewURI(getter_AddRefs(uri), href);
result = url->GetFilePath(file);
if (uri) {
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
nsXPIDLCString file;
result = url->GetFilePath(getter_Copies(file));
if (NS_SUCCEEDED(result)) {
CopyASCIItoUCS2(nsDependentCString(file), aPathname);
}
}
if (NS_SUCCEEDED(result))
aPathname = NS_ConvertUTF8toUCS2(file);
}
}
@ -613,20 +570,14 @@ LocationImpl::GetPathname(nsAWritableString& aPathname)
NS_IMETHODIMP
LocationImpl::SetPathname(const nsAReadableString& aPathname)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetWritableURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), href);
if (uri) {
uri->SetPath(NS_ConvertUCS2toUTF8(aPathname).get());
SetURL(uri);
}
uri->SetPath(NS_ConvertUCS2toUTF8(aPathname));
SetURI(uri);
}
return result;
@ -635,27 +586,21 @@ LocationImpl::SetPathname(const nsAReadableString& aPathname)
NS_IMETHODIMP
LocationImpl::GetPort(nsAWritableString& aPort)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
aPort.SetLength(0);
result = NS_NewURI(getter_AddRefs(uri), href);
PRInt32 port;
uri->GetPort(&port);
if (uri) {
aPort.SetLength(0);
PRInt32 port;
uri->GetPort(&port);
if (-1 != port) {
nsAutoString portStr;
portStr.AppendInt(port);
aPort.Append(portStr);
}
if (-1 != port) {
nsAutoString portStr;
portStr.AppendInt(port);
aPort.Append(portStr);
}
}
@ -665,33 +610,27 @@ LocationImpl::GetPort(nsAWritableString& aPort)
NS_IMETHODIMP
LocationImpl::SetPort(const nsAReadableString& aPort)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetWritableURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
// perhaps use nsReadingIterators at some point?
NS_ConvertUCS2toUTF8 portStr(aPort);
const char *buf = portStr.get();
PRInt32 port = -1;
result = NS_NewURI(getter_AddRefs(uri), href);
if (uri) {
// perhaps use nsReadingIterators at some point?
NS_ConvertUCS2toUTF8 portStr(aPort);
const char *buf = portStr.get();
PRInt32 port = -1;
if (buf) {
if (*buf == ':') {
port = atol(buf+1);
}
else {
port = atol(buf);
}
if (buf) {
if (*buf == ':') {
port = atol(buf+1);
}
else {
port = atol(buf);
}
uri->SetPort(port);
SetURL(uri);
}
uri->SetPort(port);
SetURI(uri);
}
return result;
@ -700,25 +639,19 @@ LocationImpl::SetPort(const nsAReadableString& aPort)
NS_IMETHODIMP
LocationImpl::GetProtocol(nsAWritableString& aProtocol)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
nsCAutoString protocol;
result = NS_NewURI(getter_AddRefs(uri), href);
result = uri->GetScheme(protocol);
if (uri) {
nsXPIDLCString protocol;
result = uri->GetScheme(getter_Copies(protocol));
if (NS_SUCCEEDED(result)) {
aProtocol.Assign(NS_ConvertASCIItoUCS2(protocol));
aProtocol.Append(PRUnichar(':'));
}
if (NS_SUCCEEDED(result)) {
aProtocol.Assign(NS_ConvertASCIItoUCS2(protocol));
aProtocol.Append(PRUnichar(':'));
}
}
@ -728,20 +661,14 @@ LocationImpl::GetProtocol(nsAWritableString& aProtocol)
NS_IMETHODIMP
LocationImpl::SetProtocol(const nsAReadableString& aProtocol)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetWritableURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), href);
if (uri) {
uri->SetScheme(NS_ConvertUCS2toUTF8(aProtocol).get());
SetURL(uri);
}
uri->SetScheme(NS_ConvertUCS2toUTF8(aProtocol));
SetURI(uri);
}
return result;
@ -750,31 +677,24 @@ LocationImpl::SetProtocol(const nsAReadableString& aProtocol)
NS_IMETHODIMP
LocationImpl::GetSearch(nsAWritableString& aSearch)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
nsCAutoString search;
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
result = NS_NewURI(getter_AddRefs(uri), href);
if (url) {
result = url->GetQuery(search);
}
if (uri) {
nsXPIDLCString search;
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
result = url->GetEscapedQuery(getter_Copies(search));
}
if (NS_SUCCEEDED(result) && search && *search) {
aSearch.Assign(NS_LITERAL_STRING("?"));
aSearch.Append(NS_ConvertASCIItoUCS2(search));
}
else {
aSearch.SetLength(0);
}
if (NS_SUCCEEDED(result) && !search.IsEmpty()) {
aSearch.Assign(NS_LITERAL_STRING("?") + NS_ConvertUTF8toUCS2(search));
}
else {
aSearch.SetLength(0);
}
}
@ -784,24 +704,16 @@ LocationImpl::GetSearch(nsAWritableString& aSearch)
NS_IMETHODIMP
LocationImpl::SetSearch(const nsAReadableString& aSearch)
{
nsAutoString href;
nsCOMPtr<nsIURI> uri;
nsresult result = NS_OK;
result = GetHref(href);
result = GetWritableURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(result)) {
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), href);
if (uri) {
nsCOMPtr<nsIURL> url(do_QueryInterface(uri, &result));
if (url) {
result = url->SetQuery(NS_ConvertUCS2toUTF8(aSearch).get());
SetURL(uri);
}
nsCOMPtr<nsIURL> url(do_QueryInterface(uri, &result));
if (url) {
result = url->SetQuery(NS_ConvertUCS2toUTF8(aSearch));
SetURI(uri);
}
}

54
dom/src/jsurl/nsJSProtocolHandler.cpp
View File

@ -63,6 +63,7 @@
#include "nsIJSConsoleService.h"
#include "nsIConsoleService.h"
#include "nsXPIDLString.h"
#include "prprf.h"
static NS_DEFINE_CID(kSimpleURICID, NS_SIMPLEURI_CID);
static NS_DEFINE_CID(kWindowMediatorCID, NS_WINDOWMEDIATOR_CID);
@ -124,21 +125,21 @@ nsresult nsJSThunk::EvaluateScript()
NS_ENSURE_ARG_POINTER(mChannel);
// Get the script string to evaluate...
nsXPIDLCString script;
rv = mURI->GetPath(getter_Copies(script));
nsCAutoString script;
rv = mURI->GetPath(script);
if (NS_FAILED(rv)) return rv;
// If mURI is just "javascript:", we bring up the JavaScript console
// and return NS_ERROR_DOM_RETVAL_UNDEFINED.
if (*((const char*)script) == '\0') {
if (script.IsEmpty()) {
rv = BringUpConsole();
if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
return NS_ERROR_DOM_RETVAL_UNDEFINED;
}
// Get the url.
nsXPIDLCString url;
rv = mURI->GetSpec(getter_Copies(url));
nsCAutoString url;
rv = mURI->GetSpec(url);
if (NS_FAILED(rv)) return rv;
// Get an interface requestor from the channel callbacks.
@ -258,7 +259,7 @@ nsresult nsJSThunk::EvaluateScript()
rv = scriptContext->EvaluateString(scriptString,
nsnull, // obj
principal,
url, // url
url.get(), // url
1, // line no
nsnull,
result,
@ -388,7 +389,13 @@ nsJSThunk::GetOutputStream(nsIOutputStream* *aOutputStream)
NS_IMETHODIMP
nsJSThunk::GetName(char* *aName)
{
return mURI->GetSpec(aName);
nsCAutoString buf;
nsresult rv = mURI->GetSpec(buf);
if (NS_FAILED(rv)) return rv;
*aName = ToNewCString(buf);
return *aName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
@ -722,11 +729,9 @@ nsJSProtocolHandler::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)
// nsIProtocolHandler methods:
NS_IMETHODIMP
nsJSProtocolHandler::GetScheme(char* *result)
nsJSProtocolHandler::GetScheme(nsACString &result)
{
*result = nsCRT::strdup("javascript");
if (!*result)
return NS_ERROR_OUT_OF_MEMORY;
result = "javascript";
return NS_OK;
}
@ -745,7 +750,9 @@ nsJSProtocolHandler::GetProtocolFlags(PRUint32 *result)
}
NS_IMETHODIMP
nsJSProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
nsJSProtocolHandler::NewURI(const nsACString &aSpec,
const char *aCharset, // ignore charset info
nsIURI *aBaseURI,
nsIURI **result)
{
nsresult rv;
@ -765,7 +772,28 @@ nsJSProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
if (NS_FAILED(rv))
return rv;
rv = url->SetSpec((char*)aSpec);
if (IsASCII(aSpec))
rv = url->SetSpec(aSpec);
else {
// need special encoding for unicode characters...
// XXXdarin iterate over the UTF-8 chars instead
NS_ConvertUTF8toUCS2 ucsSpec(aSpec);
nsCAutoString encSpec;
char buf[6+1]; // space for \uXXXX plus a NUL at the end
for (const PRUnichar *uch = ucsSpec.get(); *uch; ++uch) {
if (*uch > 0x7F) {
PR_snprintf(buf, sizeof(buf), "\\u%.4x", *uch);
encSpec.Append(buf);
}
else {
// it's ASCII so we're safe...
encSpec.Append(char(*uch));
}
}
rv = url->SetSpec(encSpec);
}
if (NS_FAILED(rv)) {
NS_RELEASE(url);
return rv;

13
editor/composer/src/nsEditorShell.cpp
View File

@ -57,6 +57,7 @@
#include "nsICSSStyleSheet.h"
#include "nsIStyleSheet.h"
#include "nsIURI.h"
#include "nsIFileURL.h"
#include "nsNetUtil.h"
#include "nsIWebNavigation.h"
@ -1844,16 +1845,16 @@ nsEditorShell::UpdateWindowTitleAndRecentMenu(PRBool aSaveToPrefs)
if (url)
{
// Prefix filename with scheme so user can tell if editing a remote vs. local file
nsXPIDLCString schemeChar;
docFileSpec->GetScheme(getter_Copies(schemeChar));
nsXPIDLCString fileNameChar;
url->GetFileName(getter_Copies(fileNameChar));
nsCAutoString schemeChar;
docFileSpec->GetScheme(schemeChar);
nsCAutoString fileNameChar;
url->GetFileName(fileNameChar);
if (fileNameChar.Length() > 0)
{
windowCaption += NS_LITERAL_STRING(" [") +
NS_ConvertASCIItoUCS2(schemeChar) +
NS_ConvertUTF8toUCS2(schemeChar) +
NS_LITERAL_STRING(":/.../") +
NS_ConvertASCIItoUCS2(fileNameChar) +
NS_ConvertUTF8toUCS2(fileNameChar) +
NS_LITERAL_STRING("]");
}
}

29
editor/libeditor/html/nsHTMLDataTransfer.cpp
View File

@ -736,43 +736,40 @@ NS_IMETHODIMP nsHTMLEditor::InsertFromTransferable(nsITransferable *transferable
if ( fileURL )
{
PRBool insertAsImage = PR_FALSE;
char *fileextension = nsnull;
rv = fileURL->GetFileExtension( &fileextension );
if ( NS_SUCCEEDED(rv) && fileextension )
nsCAutoString fileextension;
rv = fileURL->GetFileExtension( fileextension );
if ( NS_SUCCEEDED(rv) && !fileextension.IsEmpty() )
{
if ( (nsCRT::strcasecmp( fileextension, "jpg" ) == 0 )
|| (nsCRT::strcasecmp( fileextension, "jpeg" ) == 0 )
|| (nsCRT::strcasecmp( fileextension, "gif" ) == 0 )
|| (nsCRT::strcasecmp( fileextension, "png" ) == 0 ) )
if ( (nsCRT::strcasecmp( fileextension.get(), "jpg" ) == 0 )
|| (nsCRT::strcasecmp( fileextension.get(), "jpeg" ) == 0 )
|| (nsCRT::strcasecmp( fileextension.get(), "gif" ) == 0 )
|| (nsCRT::strcasecmp( fileextension.get(), "png" ) == 0 ) )
{
insertAsImage = PR_TRUE;
}
}
if (fileextension) nsCRT::free(fileextension);
char *urltext = nsnull;
rv = fileURL->GetSpec( &urltext );
if ( NS_SUCCEEDED(rv) && urltext && urltext[0] != 0)
nsCAutoString urltext;
rv = fileURL->GetSpec( urltext );
if ( NS_SUCCEEDED(rv) && !urltext.IsEmpty() )
{
len = strlen(urltext);
if ( insertAsImage )
{
stuffToPaste.Assign(NS_LITERAL_STRING("<IMG src=\""));
stuffToPaste.AppendWithConversion ( urltext, len );
stuffToPaste.Append(NS_ConvertUTF8toUCS2(urltext));
stuffToPaste.Append(NS_LITERAL_STRING("\" alt=\"\" >"));
}
else /* insert as link */
{
stuffToPaste.Assign(NS_LITERAL_STRING("<A href=\""));
stuffToPaste.AppendWithConversion ( urltext, len );
stuffToPaste.Append(NS_ConvertUTF8toUCS2(urltext));
stuffToPaste.Append(NS_LITERAL_STRING("\">"));
stuffToPaste.AppendWithConversion ( urltext, len );
stuffToPaste.Append(NS_ConvertUTF8toUCS2(urltext));
stuffToPaste.Append(NS_LITERAL_STRING("</A>"));
}
nsAutoEditBatch beginBatching(this);
rv = InsertHTML(stuffToPaste);
}
if (urltext) nsCRT::free(urltext);
}
}
}

10
editor/ui/composer/content/editorUtilities.js
View File

@ -557,7 +557,7 @@ function MakeAbsoluteUrl(url)
// Make a URI object to use its "resolve" method
var absoluteUrl = resultUrl;
var docUri = IOService.newURI(docUrl, null);
var docUri = IOService.newURI(docUrl, null, null);
try {
absoluteUrl = docUri.resolve(resultUrl);
@ -710,11 +710,11 @@ function StripUsernamePasswordFromURI(uri)
{
try {
url = uri.spec;
var preHost = uri.preHost;
if (preHost)
var userPass = uri.userPass;
if (userPass)
{
start = url.indexOf(preHost);
url = url.slice(0, start) + url.slice(start+preHost.length+1);
start = url.indexOf(userPass);
url = url.slice(0, start) + url.slice(start+userPass.length+1);
}
} catch (e) {}
}

2
editor/ui/dialogs/content/EdImageOverlay.js
View File

@ -319,7 +319,7 @@ function LoadPreviewImage()
if (GetScheme(imageSrc))
{
var uri = IOService.newURI(imageSrc, null);
var uri = IOService.newURI(imageSrc, null, null);
if (uri)
{
var imgCacheService = Components.classes["@mozilla.org/image/cache;1"].getService();

12
embedding/browser/activex/src/control/MozillaBrowser.cpp
View File

@ -731,12 +731,12 @@ LRESULT CMozillaBrowser::OnViewSource(WORD wNotifyCode, WORD wID, HWND hWndCtl,
}
// Get the current URI
nsXPIDLCString aURI;
mWebBrowserContainer->m_pCurrentURI->GetSpec(getter_Copies(aURI));
nsCAutoString aURI;
mWebBrowserContainer->m_pCurrentURI->GetSpec(aURI);
nsAutoString strURI;
strURI.Assign(NS_LITERAL_STRING("view-source:"));
strURI.AppendWithConversion(aURI);
strURI.Append(NS_ConvertUTF8toUCS2(aURI));
CIPtr(IDispatch) spDispNew;
VARIANT_BOOL bCancel = VARIANT_FALSE;
@ -2355,9 +2355,9 @@ HRESULT STDMETHODCALLTYPE CMozillaBrowser::get_LocationURL(BSTR __RPC_FAR *Locat
if (uri)
{
USES_CONVERSION;
nsXPIDLCString aURI;
uri->GetSpec(getter_Copies(aURI));
*LocationURL = SysAllocString(A2OLE((const char *) aURI));
nsCAutoString aURI;
uri->GetAsciiSpec(aURI);
*LocationURL = SysAllocString(A2OLE(aURI.get()));
}
else
{

24
embedding/browser/activex/src/control/WebBrowserContainer.cpp
View File

@ -155,9 +155,9 @@ NS_IMETHODIMP CWebBrowserContainer::OnStateChange(nsIWebProgress* aWebProgress,
rv = channel->GetURI(getter_AddRefs(uri));
if (NS_SUCCEEDED(rv))
{
nsXPIDLCString aURI;
uri->GetSpec(getter_Copies(aURI));
NG_TRACE(_T("CWebBrowserContainer::OnStateChange->Doc Start(..., %s, \"\")\n"), A2CT(aURI));
nsCAutoString aURI;
uri->GetAsciiSpec(aURI);
NG_TRACE(_T("CWebBrowserContainer::OnStateChange->Doc Start(..., %s, \"\")\n"), A2CT(aURI.get()));
}
}
@ -188,12 +188,12 @@ NS_IMETHODIMP CWebBrowserContainer::OnStateChange(nsIWebProgress* aWebProgress,
rv = aChannel->GetURI(getter_AddRefs(pURI));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString aURI;
rv = pURI->GetSpec(getter_Copies(aURI));
nsCAutoString aURI;
rv = pURI->GetAsciiSpec(aURI);
if (NS_FAILED(rv)) return rv;
USES_CONVERSION;
BSTR bstrURI = SysAllocString(A2OLE((const char *) aURI));
BSTR bstrURI = SysAllocString(A2OLE(aURI.get()));
// Fire a DocumentComplete event
CComVariant vURI(bstrURI);
@ -219,15 +219,15 @@ NS_IMETHODIMP CWebBrowserContainer::OnStateChange(nsIWebProgress* aWebProgress,
if (progressStateFlags & STATE_STOP)
{
nsXPIDLCString aURI;
nsCAutoString aURI;
if (m_pCurrentURI)
{
m_pCurrentURI->GetSpec(getter_Copies(aURI));
m_pCurrentURI->GetAsciiSpec(aURI);
}
// Fire a NavigateComplete event
USES_CONVERSION;
BSTR bstrURI = SysAllocString(A2OLE((const char *) aURI));
BSTR bstrURI = SysAllocString(A2OLE(aURI.get()));
m_pEvents1->Fire_NavigateComplete(bstrURI);
// Fire a NavigateComplete2 event
@ -324,8 +324,8 @@ NS_IMETHODIMP CWebBrowserContainer::OnStartURIOpen(nsIURI *pURI, PRBool *aAbortO
NG_ASSERT(m_pCurrentURI);
m_pCurrentURI->AddRef();
nsXPIDLCString aURI;
m_pCurrentURI->GetSpec(getter_Copies(aURI));
nsCAutoString aURI;
m_pCurrentURI->GetSpec(aURI);
// Setup the post data
CComVariant vPostDataRef;
@ -336,7 +336,7 @@ NS_IMETHODIMP CWebBrowserContainer::OnStartURIOpen(nsIURI *pURI, PRBool *aAbortO
// Fire a BeforeNavigate event
BSTR bstrURI = SysAllocString(A2OLE((const char *)aURI));
BSTR bstrURI = SysAllocString(A2OLE(aURI.get()));
BSTR bstrTargetFrameName = NULL;
BSTR bstrHeaders = NULL;
VARIANT_BOOL bCancel = VARIANT_FALSE;

6
embedding/browser/gtk/src/EmbedContentListener.cpp
View File

@ -53,8 +53,8 @@ EmbedContentListener::OnStartURIOpen(nsIURI *aURI,
{
nsresult rv;
nsXPIDLCString specString;
rv = aURI->GetSpec(getter_Copies(specString));
nsCAutoString specString;
rv = aURI->GetSpec(specString);
if (NS_FAILED(rv))
return rv;
@ -62,7 +62,7 @@ EmbedContentListener::OnStartURIOpen(nsIURI *aURI,
gint return_val = FALSE;
gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget),
moz_embed_signals[OPEN_URI],
(const char *)specString, &return_val);
specString.get(), &return_val);
*aAbortOpen = return_val;

14
embedding/browser/gtk/src/EmbedProgress.cpp
View File

@ -128,11 +128,11 @@ EmbedProgress::OnLocationChange(nsIWebProgress *aWebProgress,
nsIRequest *aRequest,
nsIURI *aLocation)
{
nsXPIDLCString newURI;
nsCAutoString newURI;
NS_ENSURE_ARG_POINTER(aLocation);
aLocation->GetSpec(getter_Copies(newURI));
aLocation->GetSpec(newURI);
mOwner->SetURI(newURI);
mOwner->SetURI(newURI.get());
gtk_signal_emit(GTK_OBJECT(mOwner->mOwningWidget),
moz_embed_signals[LOCATION]);
return NS_OK;
@ -185,10 +185,8 @@ EmbedProgress::RequestToURIString(nsIRequest *aRequest, char **aString)
if (!uri)
return;
nsXPIDLCString uriString;
uri->GetSpec(getter_Copies(uriString));
if (!uriString)
return;
nsCAutoString uriString;
uri->GetSpec(uriString);
*aString = nsCRT::strdup((const char *)uriString);
*aString = strdup(uriString.get());
}

4
embedding/browser/powerplant/source/CBrowserApp.cp
View File

@ -441,8 +441,8 @@ CBrowserApp::ObeyCommand(
rv = NS_NewLocalFileWithFSSpec(&fileSpec, PR_TRUE, getter_AddRefs(macFile));
ThrowIfError_(NS_ERROR_GET_CODE(rv));
nsXPIDLCString urlSpec;
rv = NS_GetURLSpecFromFile(macFile, getter_Copies(urlSpec));
nsCAutoString urlSpec;
rv = NS_GetURLSpecFromFile(macFile, urlSpec);
ThrowIfError_(NS_ERROR_GET_CODE(rv));
LWindow *theWindow = CWindowCreator::CreateWindowInternal(nsIWebBrowserChrome::CHROME_DEFAULT, -1, -1);

8
embedding/browser/powerplant/source/CBrowserShell.cpp
View File

@ -206,10 +206,10 @@ NS_IMETHODIMP CBrowserShellProgressListener::OnLocationChange(nsIWebProgress *aW
{
NS_ENSURE_TRUE(mpOwner, NS_ERROR_NULL_POINTER);
nsXPIDLCString spec;
nsCAutoString spec;
if (location)
location->GetSpec(getter_Copies(spec));
location->GetSpec(spec);
MsgLocationChangeInfo info(mpOwner, spec.get());
mpOwner->BroadcastMessage(msg_OnLocationChange, &info);
@ -962,10 +962,8 @@ NS_METHOD CBrowserShell::GetCurrentURL(nsACString& urlText)
nsCOMPtr<nsIURI> currentURI;
rv = mWebBrowserAsWebNav->GetCurrentURI(getter_AddRefs(currentURI));
if (NS_FAILED(rv)) return rv;
nsXPIDLCString urlPath;
rv = currentURI->GetSpec(getter_Copies(urlPath));
rv = currentURI->GetSpec(urlText);
if (NS_FAILED(rv)) return rv;
urlText.Assign(urlPath.get());
return NS_OK;
}

76
embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp
View File

@ -40,6 +40,7 @@
#include "nsCExternalHandlerService.h"
#include "nsIURL.h"
#include "nsIFileURL.h"
#include "nsIDocument.h"
#include "nsIDOMDocument.h"
#include "nsIDOMNode.h"
@ -925,12 +926,10 @@ nsresult nsWebBrowserPersist::AppendPathToURI(nsIURI *aURI, const nsAString & aP
{
NS_ENSURE_ARG_POINTER(aURI);
nsXPIDLCString oldPath;
nsresult rv = aURI->GetPath(getter_Copies(oldPath));
nsCAutoString newPath;
nsresult rv = aURI->GetPath(newPath);
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
nsCAutoString newPath(oldPath);
// Append a forward slash if necessary
PRInt32 len = newPath.Length();
if (len > 0 && newPath.CharAt(len - 1) != '/')
@ -939,8 +938,8 @@ nsresult nsWebBrowserPersist::AppendPathToURI(nsIURI *aURI, const nsAString & aP
}
// Store the path back on the URI
newPath.AppendWithConversion(aPath);
aURI->SetPath(newPath.get());
newPath += NS_ConvertUCS2toUTF8(aPath);
aURI->SetPath(newPath);
return NS_OK;
}
@ -967,7 +966,7 @@ nsresult nsWebBrowserPersist::SaveURIInternal(
// Open a channel to the URI
nsCOMPtr<nsIChannel> inputChannel;
rv = NS_OpenURI(getter_AddRefs(inputChannel), aURI,
rv = NS_NewChannel(getter_AddRefs(inputChannel), aURI,
nsnull, nsnull, NS_STATIC_CAST(nsIInterfaceRequestor *, this),
loadFlags);
@ -1243,7 +1242,7 @@ nsresult nsWebBrowserPersist::SaveDocumentInternal(
nsCOMPtr<nsIURL> urlToChopOffFile = do_QueryInterface(pathToFileParent);
if (urlToChopOffFile)
{
urlToChopOffFile->SetFileName("");
urlToChopOffFile->SetFileName(NS_LITERAL_CSTRING(""));
}
PRBool isEqual = PR_FALSE;
if (NS_SUCCEEDED(aDataPath->Equals(pathToFileParent, &isEqual))
@ -1442,11 +1441,8 @@ nsWebBrowserPersist::CalculateAndAppendFileExt(nsIURI *aURI, nsIChannel *aChanne
nsCOMPtr<nsIURL> url(do_QueryInterface(aURI));
NS_ENSURE_TRUE(url, NS_ERROR_FAILURE);
nsXPIDLCString fileName;
url->GetFileName(getter_Copies(fileName));
nsCString newFileName;
newFileName.Assign(fileName);
nsCAutoString newFileName;
url->GetFileName(newFileName);
// Test if the current extension is current for the mime type
PRBool hasExtension = PR_FALSE;
@ -1463,7 +1459,7 @@ nsWebBrowserPersist::CalculateAndAppendFileExt(nsIURI *aURI, nsIChannel *aChanne
// Test if previous extension is acceptable
nsCOMPtr<nsIURL> oldurl(do_QueryInterface(aOriginalURIWithExtension));
NS_ENSURE_TRUE(oldurl, NS_ERROR_FAILURE);
oldurl->GetFileExtension(getter_Copies(fileExt));
oldurl->GetFileExtension(fileExt);
PRBool useOldExt = PR_FALSE;
if (!fileExt.IsEmpty())
{
@ -1479,7 +1475,7 @@ nsWebBrowserPersist::CalculateAndAppendFileExt(nsIURI *aURI, nsIChannel *aChanne
if (!fileExt.IsEmpty())
{
newFileName.Append(".");
newFileName.Append(fileExt.get());
newFileName.Append(fileExt);
}
if (localFile)
@ -1493,7 +1489,7 @@ nsWebBrowserPersist::CalculateAndAppendFileExt(nsIURI *aURI, nsIChannel *aChanne
}
else
{
url->SetFileName(newFileName.get());
url->SetFileName(newFileName);
}
}
@ -2066,8 +2062,8 @@ nsWebBrowserPersist::FixupNodeAttribute(nsIDOMNode *aNode,
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), oldCValue.get(), mCurrentBaseURI);
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
nsXPIDLCString spec;
rv = uri->GetSpec(getter_Copies(spec));
nsCAutoString spec;
rv = uri->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
// Search for the URI in the map and replace it with the local file
@ -2091,25 +2087,22 @@ nsWebBrowserPersist::FixupNodeAttribute(nsIDOMNode *aNode,
{
nsCOMPtr<nsIURL> url(do_QueryInterface(fileAsURI));
NS_ENSURE_TRUE(url, NS_ERROR_FAILURE);
nsXPIDLCString filename;
url->GetFileName(getter_Copies(filename));
nsCAutoString filename;
url->GetFileName(filename);
nsCAutoString rawPathURL;
rawPathURL.Assign(data->mRelativePathToData);
rawPathURL.Append(filename);
nsCAutoString buf;
if (NS_EscapeURLPart(rawPathURL.get(), rawPathURL.Length(),
esc_Directory | esc_FileBaseName | esc_FileExtension, buf))
newValue.AssignWithConversion(buf.get());
else
newValue.AssignWithConversion(rawPathURL.get());
newValue = NS_ConvertUTF8toUCS2(
NS_EscapeURL(rawPathURL, esc_FilePath, buf));
}
else
{
nsXPIDLCString fileurl;
fileAsURI->GetSpec(getter_Copies(fileurl));
newValue.AssignWithConversion(fileurl);
nsCAutoString fileurl;
fileAsURI->GetSpec(fileurl);
newValue.Assign(NS_ConvertUTF8toUCS2(fileurl));
}
if (data->mIsSubFrame)
{
@ -2152,10 +2145,9 @@ nsWebBrowserPersist::FixupAnchor(nsIDOMNode *aNode)
rv = NS_NewURI(getter_AddRefs(newURI), oldCValue.get(), mCurrentBaseURI);
if (NS_SUCCEEDED(rv))
{
nsXPIDLCString uriSpec;
newURI->GetSpec(getter_Copies(uriSpec));
nsAutoString newValue; newValue.AssignWithConversion(uriSpec);
attrNode->SetNodeValue(newValue);
nsCAutoString uriSpec;
newURI->GetSpec(uriSpec);
attrNode->SetNodeValue(NS_ConvertUTF8toUCS2(uriSpec));
}
}
@ -2309,8 +2301,8 @@ nsWebBrowserPersist::MakeAndStoreLocalFilenameInURIMap(
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), aURI, mCurrentBaseURI);
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
nsXPIDLCString spec;
rv = uri->GetSpec(getter_Copies(spec));
nsCAutoString spec;
rv = uri->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
// Create a sensibly named filename for the URI and store in the URI map
@ -2366,15 +2358,16 @@ nsWebBrowserPersist::MakeFilenameFromURI(nsIURI *aURI, nsString &aFilename)
nsCOMPtr<nsIURL> url(do_QueryInterface(aURI));
if (url)
{
char *nameFromURL = nsnull;
url->GetFileName(&nameFromURL);
if (nameFromURL)
nsCAutoString nameFromURL;
url->GetFileName(nameFromURL);
if (!nameFromURL.IsEmpty())
{
const PRInt32 kMaxFileNameLength = 20;
// Unescape the file name (GetFileName escapes it)
nsAutoString fileName;
PRInt32 length = 0;
char *p = nsUnescape(nameFromURL);
NS_UnescapeURL(nameFromURL);
const char *p = nameFromURL.get();
for (;*p && *p != ';' && *p != '?' && *p != '#' && *p != '.' &&
length < kMaxFileNameLength
;p++, length++)
@ -2390,7 +2383,6 @@ nsWebBrowserPersist::MakeFilenameFromURI(nsIURI *aURI, nsString &aFilename)
}
}
aFilename = fileName;
nsCRT::free(nameFromURL);
}
}
@ -2477,9 +2469,9 @@ nsWebBrowserPersist::SetDocumentBase(
{
return NS_ERROR_FAILURE;
}
nsXPIDLCString uriSpec;
aBaseURI->GetSpec(getter_Copies(uriSpec));
nsString href; href.AssignWithConversion(uriSpec);
nsCAutoString uriSpec;
aBaseURI->GetSpec(uriSpec);
NS_ConvertUTF8toUCS2 href(uriSpec);
baseElement->SetAttribute(NS_LITERAL_STRING("href"), href);
}
else

4
embedding/tests/mfcembed/BrowserFrameGlue.cpp
View File

@ -111,8 +111,8 @@ void CBrowserFrame::BrowserFrameGlueObj::UpdateCurrentURI(nsIURI *aLocation)
if(aLocation)
{
nsXPIDLCString uriString;
aLocation->GetSpec(getter_Copies(uriString));
nsCAutoString uriString;
aLocation->GetSpec(uriString);
pThis->m_wndUrlBar.SetCurrentURL(uriString.get());
}

17
embedding/tests/mfcembed/BrowserView.cpp
View File

@ -399,8 +399,8 @@ void CBrowserView::OnViewSource()
return;
// Get the uri string associated with the nsIURI object
nsXPIDLCString uriString;
rv = currentURI->GetSpec(getter_Copies(uriString));
nsCAutoString uriString;
rv = currentURI->GetSpec(uriString);
if(NS_FAILED(rv))
return;
@ -814,11 +814,10 @@ void CBrowserView::OnSaveLinkAs()
// Get the "path" portion (see nsIURI.h for more info
// on various parts of a URI)
nsXPIDLCString path;
linkURI->GetPath(getter_Copies(path));
nsCAutoString fileName;
linkURI->GetPath(fileName);
// The path may have the "/" char in it - strip those
nsCAutoString fileName(path);
fileName.StripChars("\\/");
// Now, use this file name in a File Save As dlg...
@ -864,8 +863,8 @@ void CBrowserView::OnSaveImageAs()
// Get the "path" portion (see nsIURI.h for more info
// on various parts of a URI)
nsXPIDLCString path;
linkURI->GetPath(getter_Copies(path));
nsCAutoString path;
linkURI->GetPath(path);
// The path may have the "/" char in it - strip those
nsCAutoString fileName(path);
@ -1003,8 +1002,8 @@ void CBrowserView::OnFilePrint()
nsresult rv = mWebNav->GetCurrentURI(getter_AddRefs(currentURI));
if(NS_SUCCEEDED(rv) || currentURI)
{
nsXPIDLCString path;
currentURI->GetPath(getter_Copies(path));
nsCAutoString path;
currentURI->GetPath(path);
dlg.SetURI(path.get());
}
m_bCurrentlyPrinting = TRUE;

4
embedding/tests/mfcembed/components/HelperAppDlg.cpp
View File

@ -592,8 +592,8 @@ BOOL CProgressDlg::OnInitDialog()
nsresult rv = m_HelperAppLauncher->GetSource(getter_AddRefs(srcUri));
if(NS_SUCCEEDED(rv))
{
nsXPIDLCString uriString;
srcUri->GetSpec(getter_Copies(uriString));
nsCAutoString uriString;
srcUri->GetSpec(uriString);
m_SavingFrom.SetWindowText(uriString.get());
}

4
embedding/tests/winEmbed/WebBrowserChrome.cpp
View File

@ -363,10 +363,10 @@ WebBrowserChrome::OnHistoryPurge(PRInt32 aNumEntries, PRBool *aContinue)
nsresult
WebBrowserChrome::SendHistoryStatusMessage(nsIURI * aURI, char * operation, PRInt32 info1, PRUint32 aReloadFlags)
{
nsXPIDLCString uriCStr;
nsCAutoString uriCStr;
if (aURI)
{
aURI->GetSpec(getter_Copies(uriCStr));
aURI->GetSpec(uriCStr);
}
nsString uriAStr;

4
embedding/tests/winEmbed/winEmbed.cpp
View File

@ -1205,8 +1205,8 @@ void WebBrowserChromeUI::UpdateCurrentURI(nsIWebBrowserChrome *aChrome)
webNavigation->GetCurrentURI(getter_AddRefs(currentURI));
if (currentURI)
{
nsXPIDLCString uriString;
currentURI->GetSpec(getter_Copies(uriString));
nsCAutoString uriString;
currentURI->GetAsciiSpec(uriString);
HWND hwndDlg = GetBrowserDlgFromChrome(aChrome);
SetDlgItemText(hwndDlg, IDC_ADDRESS, uriString.get());
}

37
extensions/cookie/nsCookieService.cpp
View File

@ -159,10 +159,10 @@ nsCookieService::OnSecurityChange(nsIWebProgress *aWebProgress,
NS_IMETHODIMP
nsCookieService::GetCookieString(nsIURI *aURL, char ** aCookie) {
nsXPIDLCString spec;
nsresult rv = aURL->GetSpec(getter_Copies(spec));
nsCAutoString spec;
nsresult rv = aURL->GetAsciiSpec(spec);
if (NS_FAILED(rv)) return rv;
*aCookie = COOKIE_GetCookie((char *)(const char *)spec, mIOService);
*aCookie = COOKIE_GetCookie((char *)spec.get(), mIOService);
return NS_OK;
}
@ -171,46 +171,43 @@ nsCookieService::GetCookieStringFromHttp(nsIURI *aURL, nsIURI *aFirstURL, char *
if (!aURL) {
return NS_ERROR_FAILURE;
}
nsXPIDLCString spec;
nsresult rv = aURL->GetSpec(getter_Copies(spec));
nsCAutoString spec;
nsresult rv = aURL->GetAsciiSpec(spec);
if (NS_FAILED(rv)) return rv;
if (aFirstURL) {
nsXPIDLCString firstSpec;
rv = aFirstURL->GetSpec(getter_Copies(firstSpec));
nsCAutoString firstSpec;
rv = aFirstURL->GetAsciiSpec(firstSpec);
if (NS_FAILED(rv)) return rv;
*aCookie = COOKIE_GetCookieFromHttp((char *)(const char *)spec, (char *)(const char *)firstSpec, mIOService);
*aCookie = COOKIE_GetCookieFromHttp((char *) spec.get(), (char *) firstSpec.get(), mIOService);
} else {
*aCookie = COOKIE_GetCookieFromHttp((char *)(const char *)spec, nsnull, mIOService);
*aCookie = COOKIE_GetCookieFromHttp((char *) spec.get(), nsnull, mIOService);
}
return NS_OK;
}
NS_IMETHODIMP
nsCookieService::SetCookieString(nsIURI *aURL, nsIPrompt* aPrompt, const char * aCookie, nsIHttpChannel* aHttpChannel) {
char *spec = NULL;
nsresult result = aURL->GetSpec(&spec);
nsCAutoString spec;
nsresult result = aURL->GetAsciiSpec(spec);
NS_ASSERTION(result == NS_OK, "deal with this");
COOKIE_SetCookieString(spec, aPrompt, aCookie, mIOService, aHttpChannel);
nsCRT::free(spec);
COOKIE_SetCookieString((char *) spec.get(), aPrompt, aCookie, mIOService, aHttpChannel);
return NS_OK;
}
NS_IMETHODIMP
nsCookieService::SetCookieStringFromHttp(nsIURI *aURL, nsIURI *aFirstURL, nsIPrompt *aPrompter, const char *aCookie, const char *aExpires, nsIHttpChannel* aHttpChannel)
{
char *spec = NULL;
nsresult rv = aURL->GetSpec(&spec);
nsCAutoString spec;
nsresult rv = aURL->GetAsciiSpec(spec);
if (NS_FAILED(rv)) return rv;
NS_ASSERTION(aFirstURL,"aFirstURL is null");
if (aFirstURL) {
char *firstSpec = NULL;
rv = aFirstURL->GetSpec(&firstSpec);
nsCAutoString firstSpec;
rv = aFirstURL->GetAsciiSpec(firstSpec);
if (NS_FAILED(rv)) return rv;
COOKIE_SetCookieStringFromHttp(spec, firstSpec, aPrompter, aCookie, (char *)aExpires, mIOService, aHttpChannel);
nsCRT::free(firstSpec);
COOKIE_SetCookieStringFromHttp((char *) spec.get(), (char *) firstSpec.get(), aPrompter, aCookie, (char *)aExpires, mIOService, aHttpChannel);
}
nsCRT::free(spec);
return NS_OK;
}

118
extensions/cookie/nsCookies.cpp
View File

@ -646,21 +646,19 @@ COOKIE_GetCookie(char * address, nsIIOService* ioService) {
if (cookie_list == nsnull) {
return nsnull;
}
char *host = nsnull;
char *path = nsnull;
PRUint32 start, end;
nsCAutoString host, path;
// Get host and path
nsresult result;
NS_ASSERTION(ioService, "IOService not available");
result = ioService->ExtractUrlPart(address, nsIIOService::url_Host |
nsIIOService::url_Port, &start, &end,
&host);
if (NS_FAILED(result) || !host) {
result = ioService->ExtractUrlPart(nsDependentCString(address),
nsIIOService::url_Host |
nsIIOService::url_Port, host);
if (NS_FAILED(result)) {
return nsnull;
}
result = ioService->ExtractUrlPart(address, nsIIOService::url_Path,
&start, &end, &path);
if (NS_FAILED(result) || !path) {
result = ioService->ExtractUrlPart(nsDependentCString(address),
nsIIOService::url_Path, path);
if (NS_FAILED(result)) {
return nsnull;
}
@ -671,25 +669,25 @@ COOKIE_GetCookie(char * address, nsIIOService* ioService) {
/* check the host or domain first */
if(cookie_s->isDomain) {
char *cp;
const char *cp;
/* calculate the host length by looking at all characters up to a
* colon or '\0'. That way we won't include port numbers in domains
*/
for(cp=host; *cp != '\0' && *cp != ':'; cp++) {
for(cp=host.get(); *cp != '\0' && *cp != ':'; cp++) {
; /* null body */
}
host_length = cp - host;
if(!cookie_IsInDomain(cookie_s->host, host, host_length)) {
host_length = cp - host.get();
if(!cookie_IsInDomain(cookie_s->host, (char*)host.get(), host_length)) {
continue;
}
} else if(PL_strcasecmp(host, cookie_s->host)) {
} else if(PL_strcasecmp(host.get(), cookie_s->host)) {
/* hostname matchup failed. FAIL */
continue;
}
/* shorter strings always come last so there can be no ambiquity */
if(cookie_s->path && !PL_strncmp(path, cookie_s->path, PL_strlen(cookie_s->path))) {
if(cookie_s->path && !PL_strncmp(path.get(), cookie_s->path, PL_strlen(cookie_s->path))) {
/* if the cookie is secure and the path isn't, dont send it */
if (cookie_s->isSecure & !isSecure) {
@ -731,8 +729,6 @@ COOKIE_GetCookie(char * address, nsIIOService* ioService) {
}
PR_FREEIF(name);
PR_FREEIF(path);
PR_FREEIF(host);
/* may be nsnull */
return(rv);
@ -786,39 +782,39 @@ cookie_isForeign (char * curURL, char * firstURL, nsIIOService* ioService) {
if (!firstURL) {
return PR_FALSE;
}
char *curHost = nsnull;
char *firstHost = nsnull;
PRUint32 start,end;
nsCAutoString curHost, firstHost;
nsresult rv;
NS_ASSERTION(ioService, "IOService not available");
// Get hosts
rv = ioService->ExtractUrlPart(curURL, nsIIOService::url_Host |
nsIIOService::url_Port, &start, &end,
&curHost);
if (NS_FAILED(rv) || !curHost) {
rv = ioService->ExtractUrlPart(nsDependentCString(curURL),
nsIIOService::url_Host |
nsIIOService::url_Port,
curHost);
if (NS_FAILED(rv)) {
return PR_FALSE;
}
rv = ioService->ExtractUrlPart(firstURL, nsIIOService::url_Host |
nsIIOService::url_Port, &start, &end,
&firstHost);
if (NS_FAILED(rv) || !firstHost) {
rv = ioService->ExtractUrlPart(nsDependentCString(firstURL),
nsIIOService::url_Host |
nsIIOService::url_Port,
firstHost);
if (NS_FAILED(rv)) {
return PR_FALSE;
}
char * curHostColon = 0;
char * firstHostColon = 0;
/* strip ports */
curHostColon = PL_strchr(curHost, ':');
curHostColon = strchr(curHost.get(), ':');
if(curHostColon) {
*curHostColon = '\0';
}
firstHostColon = PL_strchr(firstHost, ':');
firstHostColon = strchr(firstHost.get(), ':');
if(firstHostColon) {
*firstHostColon = '\0';
}
/* determine if it's foreign */
PRBool retval = (!cookie_SameDomain(curHost, firstHost));
PRBool retval = (!cookie_SameDomain((char*)curHost.get(), (char*)firstHost.get()));
/* clean up our garbage and return */
if(curHostColon) {
@ -827,8 +823,6 @@ cookie_isForeign (char * curURL, char * firstURL, nsIIOService* ioService) {
if(firstHostColon) {
*firstHostColon = ':';
}
PR_FREEIF(curHost);
PR_FREEIF(firstHost);
return retval;
}
@ -997,21 +991,21 @@ cookie_SetCookieString(char * curURL, nsIPrompt *aPrompter, const char * setCook
cookie_CookieStruct * prev_cookie;
char *path_from_header=nsnull, *host_from_header=nsnull;
char *name_from_header=nsnull, *cookie_from_header=nsnull;
char *cur_host = nsnull;
char *cur_path = nsnull;
PRUint32 start,end;
nsCAutoString cur_host, cur_path;
nsresult rv;
NS_ASSERTION(ioService, "IOService not available");
// Get host and path
rv = ioService->ExtractUrlPart(curURL, nsIIOService::url_Host |
nsIIOService::url_Port, &start, &end,
&cur_host);
if (NS_FAILED(rv) || !cur_host) {
rv = ioService->ExtractUrlPart(nsDependentCString(curURL),
nsIIOService::url_Host |
nsIIOService::url_Port,
cur_host);
if (NS_FAILED(rv)) {
return;
}
rv = ioService->ExtractUrlPart(curURL, nsIIOService::url_Path,
&start, &end, &cur_path);
if (NS_FAILED(rv) || !cur_path) {
rv = ioService->ExtractUrlPart(nsDependentCString(curURL),
nsIIOService::url_Path,
cur_path);
if (NS_FAILED(rv)) {
return;
}
char *semi_colon, *ptr, *equal;
@ -1031,16 +1025,12 @@ cookie_SetCookieString(char * curURL, nsIPrompt *aPrompter, const char * setCook
}
*/
if(cookie_GetBehaviorPref() == PERMISSION_DontUse) {
PR_Free(cur_path);
PR_Free(cur_host);
return;
}
//printf("\nSetCookieString(URL '%s', header '%s') time %d == %s\n",curURL,setCookieHeader,timeToExpire,asctime(gmtime(&timeToExpire)));
if(cookie_GetLifetimePref() == COOKIE_Discard) {
if(cookie_GetLifetimeTime() < timeToExpire) {
PR_Free(cur_path);
PR_Free(cur_host);
return;
}
}
@ -1132,29 +1122,25 @@ cookie_SetCookieString(char * curURL, nsIPrompt *aPrompter, const char * setCook
/* did not pass two dot test. FAIL */
PR_FREEIF(path_from_header);
PR_Free(domain_from_header);
PR_Free(cur_path);
PR_Free(cur_host);
// TRACEMSG(("DOMAIN failed two dot test"));
nsCRT::free(setCookieHeaderInternal);
return;
}
/* strip port numbers from the current host for the domain test */
colon = PL_strchr(cur_host, ':');
colon = strchr(cur_host.get(), ':');
if(colon) {
*colon = '\0';
}
domain_length = PL_strlen(domain_from_header);
cur_host_length = PL_strlen(cur_host);
cur_host_length = cur_host.Length();
/* check to see if the host is in the domain */
if (!cookie_IsInDomain(domain_from_header, cur_host, cur_host_length)) {
if (!cookie_IsInDomain(domain_from_header, (char*)cur_host.get(), cur_host_length)) {
// TRACEMSG(("DOMAIN failed host within domain test."
// " Domain: %s, Host: %s", domain_from_header, cur_host));
PR_FREEIF(path_from_header);
PR_Free(domain_from_header);
PR_Free(cur_path);
PR_Free(cur_host);
nsCRT::free(setCookieHeaderInternal);
return;
}
@ -1180,16 +1166,14 @@ cookie_SetCookieString(char * curURL, nsIPrompt *aPrompter, const char * setCook
pref_scd = PR_FALSE;
}
if ( pref_scd == PR_TRUE ) {
cur_host[cur_host_length-domain_length] = '\0';
dot = PL_strchr(cur_host, '.');
cur_host[cur_host_length-domain_length] = '.';
cur_host.SetCharAt(cur_host_length-domain_length, '\0');
dot = strchr(cur_host.get(), '.');
cur_host.SetCharAt(cur_host_length-domain_length, '.');
if (dot) {
// TRACEMSG(("host minus domain failed no-dot test."
// " Domain: %s, Host: %s", domain_from_header, cur_host));
PR_FREEIF(path_from_header);
PR_Free(domain_from_header);
PR_Free(cur_path);
PR_Free(cur_host);
nsCRT::free(setCookieHeaderInternal);
return;
}
@ -1204,18 +1188,14 @@ cookie_SetCookieString(char * curURL, nsIPrompt *aPrompter, const char * setCook
}
if(!path_from_header) {
/* strip down everything after the last slash to get the path. */
char * slash = PL_strrchr(cur_path, '/');
char * slash = PL_strrchr(cur_path.get(), '/');
if(slash) {
*slash = '\0';
}
path_from_header = cur_path;
} else {
PR_Free(cur_path);
path_from_header = nsCRT::strdup(cur_path.get());
}
if(!host_from_header) {
host_from_header = cur_host;
} else {
PR_Free(cur_host);
host_from_header = nsCRT::strdup(cur_host.get());
}
/* keep cookies under the max bytes limit */
@ -1387,12 +1367,12 @@ PUBLIC void
COOKIE_SetCookieString(char * aURL, nsIPrompt *aPrompter, const char * setCookieHeader, nsIIOService* ioService, nsIHttpChannel* aHttpChannel) {
nsCOMPtr<nsIURI> pFirstURL;
nsresult rv;
nsXPIDLCString firstSpec;
nsCAutoString firstSpec;
if (aHttpChannel) {
rv = aHttpChannel->GetDocumentURI(getter_AddRefs(pFirstURL));
if (NS_FAILED(rv)) return;
rv = pFirstURL->GetSpec(getter_Copies(firstSpec));
rv = pFirstURL->GetSpec(firstSpec);
if (NS_FAILED(rv)) return;
}
COOKIE_SetCookieStringFromHttp(aURL, NS_CONST_CAST(char *, firstSpec.get()), aPrompter, setCookieHeader, 0, ioService, aHttpChannel);

1
extensions/cookie/nsCookies.h
View File

@ -55,6 +55,7 @@ class nsIHttpChannel;
extern nsresult COOKIE_Read();
extern nsresult COOKIE_Write();
//XXX these should operate on |const char*|
extern char * COOKIE_GetCookie(char * address, nsIIOService* ioService);
extern char * COOKIE_GetCookieFromHttp(char * address, char * firstAddress, nsIIOService* ioService);
extern void COOKIE_SetCookieString(char * cur_url, nsIPrompt *aPrompter, const char * set_cookie_header, nsIIOService* ioService, nsIHttpChannel* aHttpChannel);

10
extensions/cookie/nsImages.cpp
View File

@ -204,11 +204,11 @@ IMAGE_Block(const char* imageURL,
return NS_ERROR_NULL_POINTER;
}
nsresult rv = NS_OK;
char *host = nsnull;
PRUint32 start,end;
nsCAutoString host;
NS_ASSERTION(ioService, "IOService not available");
rv = ioService->ExtractUrlPart(imageURL, nsIIOService::url_Host |
nsIIOService::url_Port, &start, &end, &host);
Permission_AddHost(host, PR_FALSE, IMAGEPERMISSION, PR_TRUE);
rv = ioService->ExtractUrlPart(nsDependentCString(imageURL),
nsIIOService::url_Host |
nsIIOService::url_Port, host);
Permission_AddHost((char*)host.get(), PR_FALSE, IMAGEPERMISSION, PR_TRUE);
return NS_OK;
}

14
extensions/cookie/nsImgManager.cpp
View File

@ -125,15 +125,15 @@ NS_IMETHODIMP nsImgManager::ShouldLoad(PRInt32 aContentType,
if (NS_FAILED(rv) || !httpType) return rv;
}
nsXPIDLCString baseHost;
rv = baseURI->GetHost(getter_Copies(baseHost));
if (NS_FAILED(rv) || !baseHost) return rv;
nsCAutoString baseHost;
rv = baseURI->GetAsciiHost(baseHost);
if (NS_FAILED(rv)) return rv;
nsXPIDLCString host;
rv = aContentLoc->GetHost(getter_Copies(host));
if (NS_FAILED(rv) || !host) return rv;
nsCAutoString host;
rv = aContentLoc->GetAsciiHost(host);
if (NS_FAILED(rv)) return rv;
return ::IMAGE_CheckForPermission(host, baseHost,
return ::IMAGE_CheckForPermission(host.get(), baseHost.get(),
_retval);
}
}

21
extensions/cookie/nsPermissions.cpp
View File

@ -698,11 +698,11 @@ PERMISSION_Add(const char * objectURL, PRBool permission, PRInt32 type,
return;
}
nsresult rv = NS_OK;
char *host = nsnull;
PRUint32 start,end;
nsCAutoString host;
NS_ASSERTION(ioService, "IOService not available");
rv = ioService->ExtractUrlPart(objectURL, nsIIOService::url_Host |
nsIIOService::url_Port, &start, &end, &host);
rv = ioService->ExtractUrlPart(nsDependentCString(objectURL),
nsIIOService::url_Host |
nsIIOService::url_Port, host);
/*
* if permission is false, it will be added to the permission list
@ -710,7 +710,7 @@ PERMISSION_Add(const char * objectURL, PRBool permission, PRInt32 type,
* true permission being added
*/
if (permission) {
char * hostPtr = host;
char * hostPtr = (char *)host.get();
while (PR_TRUE) {
permission_Unblock(hostPtr, type);
hostPtr = PL_strchr(hostPtr, '.');
@ -719,10 +719,9 @@ PERMISSION_Add(const char * objectURL, PRBool permission, PRInt32 type,
}
hostPtr++; /* get passed the period */
}
Recycle(host);
return;
}
Permission_AddHost(host, permission, type, PR_TRUE);
Permission_AddHost((char*)host.get(), permission, type, PR_TRUE);
}
PUBLIC void
@ -732,11 +731,11 @@ PERMISSION_TestForBlocking(const char * objectURL, PRBool* blocked, PRInt32 type
return;
}
nsresult rv = NS_OK;
nsXPIDLCString host;
PRUint32 start,end;
nsCAutoString host;
NS_ASSERTION(ioService, "IOService not available");
rv = ioService->ExtractUrlPart(objectURL, nsIIOService::url_Host |
nsIIOService::url_Port, &start, &end, getter_Copies(host));
rv = ioService->ExtractUrlPart(nsDependentCString(objectURL),
nsIIOService::url_Host |
nsIIOService::url_Port, host);
const char * hostPtr = host.get();
while (PR_TRUE) {

6
extensions/datetime/nsDateTimeChannel.cpp
View File

@ -78,7 +78,7 @@ nsDateTimeChannel::Init(nsIURI* uri, nsIProxyInfo* proxyInfo)
if (NS_FAILED(rv) || mPort < 1)
mPort = DATETIME_PORT;
rv = mUrl->GetPath(getter_Copies(mHost));
rv = mUrl->GetPath(mHost);
if (NS_FAILED(rv)) return rv;
if (!*(const char *)mHost) return NS_ERROR_NOT_INITIALIZED;
@ -193,7 +193,7 @@ nsDateTimeChannel::Open(nsIInputStream **_retval)
transport->SetNotificationCallbacks(mCallbacks,
(mLoadFlags & LOAD_BACKGROUND));
return transport->OpenInputStream(0, -1, 0, _retval);
return transport->OpenInputStream(0, PRUint32(-1), 0, _retval);
}
NS_IMETHODIMP
@ -223,7 +223,7 @@ nsDateTimeChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)
mListener = aListener;
nsCOMPtr<nsIRequest> request;
return transport->AsyncRead(this, ctxt, 0, -1, 0, getter_AddRefs(request));
return transport->AsyncRead(this, ctxt, 0, PRUint32(-1), 0, getter_AddRefs(request));
}
NS_IMETHODIMP

13
extensions/datetime/nsDateTimeHandler.cpp
View File

@ -78,9 +78,8 @@ nsDateTimeHandler::Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult
// nsIProtocolHandler methods:
NS_IMETHODIMP
nsDateTimeHandler::GetScheme(char* *result) {
*result = nsCRT::strdup("datetime");
if (!*result) return NS_ERROR_OUT_OF_MEMORY;
nsDateTimeHandler::GetScheme(nsACString &result) {
result = "datetime";
return NS_OK;
}
@ -97,8 +96,10 @@ nsDateTimeHandler::GetProtocolFlags(PRUint32 *result) {
}
NS_IMETHODIMP
nsDateTimeHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
nsIURI **result) {
nsDateTimeHandler::NewURI(const nsACString &aSpec,
const char *aCharset, // ignore charset info
nsIURI *aBaseURI,
nsIURI **result) {
nsresult rv;
// no concept of a relative datetime url
@ -109,7 +110,7 @@ nsDateTimeHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
NS_GET_IID(nsIURI),
(void**)&url);
if (NS_FAILED(rv)) return rv;
rv = url->SetSpec((char*)aSpec);
rv = url->SetSpec(aSpec);
if (NS_FAILED(rv)) {
NS_RELEASE(url);
return rv;

12
extensions/finger/nsFingerChannel.cpp
View File

@ -65,7 +65,7 @@ nsresult
nsFingerChannel::Init(nsIURI* uri, nsIProxyInfo* proxyInfo)
{
nsresult rv;
nsXPIDLCString autoBuffer;
nsCAutoString autoBuffer;
NS_ASSERTION(uri, "no uri");
@ -77,12 +77,12 @@ nsFingerChannel::Init(nsIURI* uri, nsIProxyInfo* proxyInfo)
mPort = FINGER_PORT;
rv = mUrl->GetPath(getter_Copies(autoBuffer)); // autoBuffer = user@host
rv = mUrl->GetPath(autoBuffer); // autoBuffer = user@host
if (NS_FAILED(rv)) return rv;
// Now parse out the user and host
const char* buf = autoBuffer.get();
const char* pos = PL_strchr(buf, '@');
const char* pos = strchr(buf, '@');
// Catch the case of just the host being given
if (!pos) {
@ -383,9 +383,9 @@ nsFingerChannel::OnStopRequest(nsIRequest *aRequest, nsISupports* aContext,
nsCOMPtr<nsITXTToHTMLConv> converter(do_QueryInterface(converterListener));
if (converter) {
nsAutoString title(NS_LITERAL_STRING("Finger information for "));
nsXPIDLCString userHost;
rv = mUrl->GetPath(getter_Copies(userHost));
title.AppendWithConversion(userHost);
nsCAutoString userHost;
rv = mUrl->GetPath(userHost);
title.Append(NS_ConvertUTF8toUCS2(userHost));
converter->SetTitle(title.get());
converter->PreFormatHTML(PR_TRUE);
}

13
extensions/finger/nsFingerHandler.cpp
View File

@ -63,9 +63,8 @@ nsFingerHandler::Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult)
// nsIProtocolHandler methods:
NS_IMETHODIMP
nsFingerHandler::GetScheme(char* *result) {
*result = nsCRT::strdup("finger");
if (!*result) return NS_ERROR_OUT_OF_MEMORY;
nsFingerHandler::GetScheme(nsACString &result) {
result = "finger";
return NS_OK;
}
@ -82,8 +81,10 @@ nsFingerHandler::GetProtocolFlags(PRUint32 *result) {
}
NS_IMETHODIMP
nsFingerHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
nsIURI **result) {
nsFingerHandler::NewURI(const nsACString &aSpec,
const char *aCharset, // ignore charset info
nsIURI *aBaseURI,
nsIURI **result) {
nsresult rv;
// no concept of a relative finger url
@ -94,7 +95,7 @@ nsFingerHandler::NewURI(const char *aSpec, nsIURI *aBaseURI,
NS_GET_IID(nsIURI),
(void**)&url);
if (NS_FAILED(rv)) return rv;
rv = url->SetSpec((char*)aSpec);
rv = url->SetSpec(aSpec);
if (NS_FAILED(rv)) {
NS_RELEASE(url);
return rv;

16
extensions/inspector/base/src/inBitmapProtocolHandler.cpp
View File

@ -46,10 +46,9 @@ NS_IMPL_ISUPPORTS2(inBitmapProtocolHandler, nsIProtocolHandler, nsISupportsWeakR
////////////////////////////////////////////////////////////////////////////////
// nsIProtocolHandler
NS_IMETHODIMP inBitmapProtocolHandler::GetScheme(char* *result)
NS_IMETHODIMP inBitmapProtocolHandler::GetScheme(nsACString &result)
{
*result = nsCRT::strdup("moz-bitmap");
if (!*result) return NS_ERROR_OUT_OF_MEMORY;
result = "moz-bitmap";
return NS_OK;
}
@ -67,12 +66,15 @@ NS_IMETHODIMP inBitmapProtocolHandler::GetProtocolFlags(PRUint32 *result)
NS_IMETHODIMP inBitmapProtocolHandler::AllowPort(PRInt32 port, const char *scheme, PRBool *_retval)
{
// don't override anything.
*_retval = PR_FALSE;
return NS_OK;
// don't override anything.
*_retval = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP inBitmapProtocolHandler::NewURI(const char *aSpec, nsIURI *aBaseURI, nsIURI **result)
NS_IMETHODIMP inBitmapProtocolHandler::NewURI(const nsACString &aSpec,
const char *aOriginCharset, // ignored
nsIURI *aBaseURI,
nsIURI **result)
{
// no concept of a relative bitmap url
NS_ASSERTION(!aBaseURI, "base url passed into bitmap protocol handler");

130
extensions/inspector/base/src/inBitmapURI.cpp
View File

@ -58,123 +58,127 @@ inBitmapURI::GetBitmapName(PRUnichar** aBitmapName)
////////////////////////////////////////////////////////////////////////////////
nsresult
inBitmapURI::FormatSpec(char* *result)
inBitmapURI::FormatSpec(nsACString &result)
{
*result = ToNewCString(NS_LITERAL_CSTRING(NS_BITMAP_SCHEME "//") +
mBitmapName);
return *result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
result = NS_LITERAL_CSTRING(NS_BITMAP_SCHEME "//") + mBitmapName;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIURI
NS_IMETHODIMP
inBitmapURI::GetSpec(char* *aSpec)
inBitmapURI::GetSpec(nsACString &aSpec)
{
return FormatSpec(aSpec);
}
NS_IMETHODIMP
inBitmapURI::SetSpec(const char* aSpec)
inBitmapURI::SetSpec(const nsACString &aSpec)
{
nsresult rv;
nsCOMPtr<nsIIOService> ioService (do_GetService(kIOServiceCID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 startPos, endPos;
rv = ioService->ExtractScheme(aSpec, &startPos, &endPos, nsnull);
nsCAutoString scheme;
rv = ioService->ExtractScheme(aSpec, scheme);
NS_ENSURE_SUCCESS(rv, rv);
if (nsCRT::strncmp("moz-bitmap", &aSpec[startPos], endPos - startPos - 1) != 0)
if (strcmp("moz-bitmap", scheme.get()) != 0)
return NS_ERROR_MALFORMED_URI;
nsCAutoString path(aSpec);
PRInt32 pos = path.FindChar(NS_BITMAP_DELIMITER);
nsACString::const_iterator end, colon, delim;
aSpec.BeginReading(colon);
aSpec.EndReading(end);
if (pos == -1) // additional parameters
{
path.Right(mBitmapName, path.Length() - endPos);
}
else
{
path.Mid(mBitmapName, endPos, pos - endPos);
// TODO: parse out other parameters
}
if (!FindCharInReadable(':', colon, end))
return NS_ERROR_MALFORMED_URI;
if (!FindCharInReadable(NS_BITMAP_DELIMITER, delim = ++colon, end))
delim = end;
mBitmapName = Substring(colon, delim);
// TODO: parse out other parameters
return NS_OK;
}
NS_IMETHODIMP
inBitmapURI::GetPrePath(char** prePath)
inBitmapURI::GetPrePath(nsACString &prePath)
{
*prePath = nsCRT::strdup(NS_BITMAP_SCHEME);
return *prePath ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
prePath = NS_BITMAP_SCHEME;
return NS_OK;
}
NS_IMETHODIMP
inBitmapURI::SetPrePath(const char* prePath)
inBitmapURI::GetScheme(nsACString &aScheme)
{
NS_NOTREACHED("inBitmapURI::SetPrePath");
return NS_ERROR_NOT_IMPLEMENTED;
aScheme = "moz-bitmap";
return NS_OK;
}
NS_IMETHODIMP
inBitmapURI::GetScheme(char * *aScheme)
{
*aScheme = nsCRT::strdup("moz-bitmap");
return *aScheme ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP
inBitmapURI::SetScheme(const char * aScheme)
inBitmapURI::SetScheme(const nsACString &aScheme)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::GetUsername(char * *aUsername)
inBitmapURI::GetUsername(nsACString &aUsername)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::SetUsername(const char * aUsername)
inBitmapURI::SetUsername(const nsACString &aUsername)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::GetPassword(char * *aPassword)
inBitmapURI::GetPassword(nsACString &aPassword)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::SetPassword(const char * aPassword)
inBitmapURI::SetPassword(const nsACString &aPassword)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::GetPreHost(char * *aPreHost)
inBitmapURI::GetUserPass(nsACString &aUserPass)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::SetPreHost(const char * aPreHost)
inBitmapURI::SetUserPass(const nsACString &aUserPass)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::GetHost(char * *aHost)
inBitmapURI::GetHostPort(nsACString &aHostPort)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::SetHost(const char * aHost)
inBitmapURI::SetHostPort(const nsACString &aHostPort)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::GetHost(nsACString &aHost)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::SetHost(const nsACString &aHost)
{
return NS_ERROR_FAILURE;
}
@ -192,29 +196,47 @@ inBitmapURI::SetPort(PRInt32 aPort)
}
NS_IMETHODIMP
inBitmapURI::GetPath(char * *aPath)
inBitmapURI::GetPath(nsACString &aPath)
{
aPath.Truncate();
return NS_OK;
}
NS_IMETHODIMP
inBitmapURI::SetPath(const nsACString &aPath)
{
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
inBitmapURI::SetPath(const char * aPath)
inBitmapURI::GetAsciiSpec(nsACString &aSpec)
{
return NS_ERROR_FAILURE;
return GetSpec(aSpec);
}
NS_IMETHODIMP
inBitmapURI::GetAsciiHost(nsACString &aHost)
{
return GetHost(aHost);
}
NS_IMETHODIMP
inBitmapURI::GetOriginCharset(nsACString &result)
{
result.Truncate();
return NS_OK;
}
NS_IMETHODIMP
inBitmapURI::Equals(nsIURI *other, PRBool *result)
{
nsXPIDLCString spec1;
nsXPIDLCString spec2;
nsCAutoString spec1;
nsCAutoString spec2;
other->GetSpec(getter_Copies(spec2));
GetSpec(getter_Copies(spec1));
if (!nsCRT::strcasecmp(spec1, spec2))
*result = PR_TRUE;
else
*result = PR_FALSE;
other->GetSpec(spec2);
GetSpec(spec1);
*result = !nsCRT::strcasecmp(spec1.get(), spec2.get());
return NS_OK;
}
@ -235,7 +257,7 @@ inBitmapURI::Clone(nsIURI **result)
}
NS_IMETHODIMP
inBitmapURI::Resolve(const char *relativePath, char **result)
inBitmapURI::Resolve(const nsACString &relativePath, nsACString &result)
{
return NS_OK;
}

2
extensions/inspector/base/src/inBitmapURI.h
View File

@ -38,7 +38,7 @@ public:
protected:
nsCString mBitmapName;
nsresult FormatSpec(char** result);
nsresult FormatSpec(nsACString &result);
};
#endif // __inBitmapURI_h__

4
extensions/irc/js/lib/chatzilla-service.js
View File

@ -175,7 +175,7 @@ function (aPort, aScheme)
}
IRCProtocolHandler.prototype.newURI =
function (aSpec, aBaseURI)
function (aSpec, aCharset, aBaseURI)
{
if (aBaseURI)
{
@ -185,7 +185,7 @@ function (aSpec, aBaseURI)
var url = Components.classes[STANDARDURL_CONTRACTID].
createInstance(nsIStandardURL);
url.init(nsIStandardURL.URLTYPE_STANDARD, 6667, aSpec, aBaseURI);
url.init(nsIStandardURL.URLTYPE_STANDARD, 6667, aSpec, aCharset, aBaseURI);
return url.QueryInterface(nsIURI);
}

2
extensions/irc/js/lib/connection-xpcom.js
View File

@ -90,7 +90,7 @@ function bc_connect(host, port, bind, tcp_flag, observer)
var ios = Components.classes["@mozilla.org/network/io-service;1"].
getService(Components.interfaces.nsIIOService);
var spec = "irc://" + host + ':' + port;
var uri = ios.newURI(spec,null);
var uri = ios.newURI(spec,null,null);
var info = pps.examineForProxy(uri);
this._transport = this._sockService.createTransport (host, port, info,

2
extensions/pref/autoconfig/src/nsAutoConfig.cpp
View File

@ -314,7 +314,7 @@ nsresult nsAutoConfig::downloadAutoConfig()
return rv;
// open a channel for the url
rv = NS_OpenURI(getter_AddRefs(channel),url, nsnull, nsnull, nsnull, nsIRequest::INHIBIT_PERSISTENT_CACHING | nsIRequest::LOAD_BYPASS_CACHE);
rv = NS_NewChannel(getter_AddRefs(channel),url, nsnull, nsnull, nsnull, nsIRequest::INHIBIT_PERSISTENT_CACHING | nsIRequest::LOAD_BYPASS_CACHE);
if (NS_FAILED(rv))
return rv;

6
extensions/pref/autoconfig/src/nsLDAPSyncQuery.cpp
View File

@ -386,8 +386,8 @@ nsresult nsLDAPSyncQuery::InitConnection()
// host to connect to
//
nsXPIDLCString host;
rv = mServerURL->GetHost(getter_Copies(host));
nsCAutoString host;
rv = mServerURL->GetAsciiHost(host);
if (NS_FAILED(rv)) {
FinishLDAPQuery();
return NS_ERROR_FAILURE;
@ -416,7 +416,7 @@ nsresult nsLDAPSyncQuery::InitConnection()
return NS_ERROR_FAILURE;
}
rv = mConnection->Init(host, port, 0, selfProxy);
rv = mConnection->Init(host.get(), port, 0, selfProxy);
if (NS_FAILED(rv)) {
FinishLDAPQuery();
return NS_ERROR_UNEXPECTED; // this should never happen

2
extensions/transformiix/resources/buster/txTools.js
View File

@ -136,7 +136,7 @@ function loadFile(url)
if (!serv)
throw Components.results.ERR_FAILURE;
var chan = serv.newChannel(url, null);
var chan = serv.newChannel(url, null, null);
var instream =
Components.classes[SIS_CTRID].createInstance(nsIScriptableInputStream);

2
extensions/transformiix/source/xml/parser/nsSyncLoader.cpp
View File

@ -210,7 +210,7 @@ nsSyncLoader::LoadDocument(nsIURI* documentURI, nsIDocument *aLoader, nsIDOMDocu
getter_AddRefs(DOMDocument));
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_OpenURI(getter_AddRefs(mChannel), documentURI, nsnull, loadGroup);
rv = NS_NewChannel(getter_AddRefs(mChannel), documentURI, nsnull, loadGroup);
NS_ENSURE_SUCCESS(rv, rv);
// Make sure we've been opened

2
extensions/venkman/resources/content/venkman-url-loader.js
View File

@ -46,7 +46,7 @@ function _getChannelForURL (url)
if (!serv)
throw new BadMojo(ERR_FAILURE);
return serv.newChannel(url, null);
return serv.newChannel(url, null, null);
}

21
extensions/wallet/src/nsWalletService.cpp
View File

@ -224,10 +224,9 @@ NS_IMETHODIMP nsWalletlibService::Observe(nsISupports *aSubject, const char *aTo
// A login succeeded; store the password.
nsCOMPtr<nsIURI> uri = do_QueryInterface(aSubject);
if (uri) {
nsXPIDLCString spec;
uri->GetSpec(getter_Copies(spec));
if (spec)
SI_StorePassword(spec, nsnull, someData);
nsCAutoString spec;
if (NS_SUCCEEDED(uri->GetSpec(spec)))
SI_StorePassword(spec.get(), nsnull, someData);
}
}
else if (!nsCRT::strcmp(aTopic, "login-failed")) {
@ -235,10 +234,10 @@ NS_IMETHODIMP nsWalletlibService::Observe(nsISupports *aSubject, const char *aTo
// the URL where the failure occurred.
nsCOMPtr<nsIURI> uri = do_QueryInterface(aSubject);
if (uri) {
nsXPIDLCString spec;
uri->GetSpec(getter_Copies(spec));
if (spec)
SI_RemoveUser(spec, nsnull);
nsCAutoString spec;
uri->GetSpec(spec);
if (NS_SUCCEEDED(uri->GetSpec(spec)))
SI_RemoveUser(spec.get(), nsnull);
}
}
return NS_OK;
@ -395,8 +394,8 @@ nsWalletlibService::OnStateChange(nsIWebProgress* aWebProgress,
return NS_OK;
}
nsXPIDLCString spec;
rv = uri->GetSpec(getter_Copies(spec));
nsCAutoString spec;
rv = uri->GetSpec(spec);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIDOMHTMLCollection> forms;
@ -475,7 +474,7 @@ nsWalletlibService::OnStateChange(nsIWebProgress* aWebProgress,
wwatch->GetNewPrompter(0, getter_AddRefs(prompter));
}
if (prompter) {
SINGSIGN_RestoreSignonData(prompter, spec, nameString, &valueString, elementNumber++);
SINGSIGN_RestoreSignonData(prompter, spec.get(), nameString, &valueString, elementNumber++);
}
if (valueString) {
value = valueString;

14
extensions/wallet/src/singsign.cpp
View File

@ -2053,12 +2053,12 @@ SINGSIGN_RememberSignonData
nsIDOMWindowInternal* window)
{
nsXPIDLCString strippedRealm;
nsCAutoString strippedRealm;
nsCOMPtr<nsIIOService> ioService = do_GetService(NS_IOSERVICE_CONTRACTID);
if (!ioService) return;
ioService->ExtractUrlPart(passwordRealm, nsIIOService::url_Host, 0, 0, getter_Copies(strippedRealm));
if (strippedRealm) {
si_RememberSignonData(dialog, strippedRealm, signonData, window);
ioService->ExtractUrlPart(nsDependentCString(passwordRealm), nsIIOService::url_Host, strippedRealm);
if (!strippedRealm.IsEmpty()) {
si_RememberSignonData(dialog, strippedRealm.get(), signonData, window);
}
}
@ -2168,11 +2168,11 @@ si_RestoreSignonData(nsIPrompt* dialog, const char* passwordRealm, const PRUnich
PUBLIC void
SINGSIGN_RestoreSignonData(nsIPrompt* dialog, const char* passwordRealm, const PRUnichar* name, PRUnichar** value, PRUint32 elementNumber) {
nsXPIDLCString strippedRealm;
nsCAutoString strippedRealm;
nsCOMPtr<nsIIOService> ioService = do_GetService(NS_IOSERVICE_CONTRACTID);
if (!ioService) return;
ioService->ExtractUrlPart(passwordRealm, nsIIOService::url_Host, 0, 0, getter_Copies(strippedRealm));
si_RestoreSignonData(dialog, strippedRealm, name, value, elementNumber);
ioService->ExtractUrlPart(nsDependentCString(passwordRealm), nsIIOService::url_Host, strippedRealm);
si_RestoreSignonData(dialog, (char*)strippedRealm.get(), name, value, elementNumber);
}
/*

36
extensions/wallet/src/wallet.cpp
View File

@ -1624,21 +1624,18 @@ static void
wallet_GetHostFile(nsIURI * url, nsString& outHostFile)
{
outHostFile.Truncate(0);
nsAutoString urlName;
char* host = nsnull;
nsresult rv = url->GetHost(&host);
nsCAutoString host;
nsresult rv = url->GetHost(host);
if (NS_FAILED(rv)) {
return;
}
urlName.AppendWithConversion(host);
nsCRT::free(host);
char* file = nsnull;
rv = url->GetPath(&file);
NS_ConvertUTF8toUCS2 urlName(host);
nsCAutoString file;
rv = url->GetPath(file);
if (NS_FAILED(rv)) {
return;
}
urlName.AppendWithConversion(file);
nsCRT::free(file);
urlName.Append(NS_ConvertUTF8toUCS2(file));
PRInt32 queryPos = urlName.FindChar('?');
PRInt32 stringEnd = (queryPos == kNotFound) ? urlName.Length() : queryPos;
@ -3864,19 +3861,19 @@ public:
PRIVATE PRBool
wallet_IsFromCartman(nsIURI* aURL) {
PRBool retval = PR_FALSE;
nsXPIDLCString host;
if (NS_SUCCEEDED(aURL->GetHost(getter_Copies(host))) && host) {
if (PL_strncasecmp(host, "127.0.0.1", 9) == 0) {
nsCAutoString host;
if (NS_SUCCEEDED(aURL->GetHost(host))) {
if (PL_strncasecmp(host.get(), "127.0.0.1", 9) == 0) {
/* submit is to server on local machine */
nsresult res;
nsCOMPtr<nsISecurityManagerComponent> psm =
do_GetService(PSM_COMPONENT_CONTRACTID, &res);
if (NS_SUCCEEDED(res)) {
nsXPIDLCString password;
if (NS_SUCCEEDED(aURL->GetPassword(getter_Copies(password))) && password) {
nsCAutoString password;
if (NS_SUCCEEDED(aURL->GetPassword(password))) {
nsXPIDLCString secmanPassword;
if (NS_SUCCEEDED(psm->GetPassword(getter_Copies(secmanPassword))) && secmanPassword) {
if (PL_strncasecmp(password, secmanPassword, 9) == 0) {
if (PL_strncasecmp(password.get(), secmanPassword, 9) == 0) {
/* password for submit is cartman's password */
retval = PR_TRUE;
}
@ -3916,7 +3913,7 @@ WLLT_OnSubmit(nsIContent* currentForm, nsIDOMWindowInternal* window) {
nsCOMPtr<nsIDOMHTMLFormElement> currentFormNode(do_QueryInterface(currentForm));
/* get url name as ascii string */
char *URLName = nsnull;
nsCAutoString URLName;
nsAutoString strippedURLNameUCS2;
nsCOMPtr<nsIDocument> doc;
currentForm->GetDocument(*getter_AddRefs(doc));
@ -3928,21 +3925,19 @@ WLLT_OnSubmit(nsIContent* currentForm, nsIDOMWindowInternal* window) {
if (!docURL || wallet_IsFromCartman(docURL)) {
return;
}
(void)docURL->GetSpec(&URLName);
(void)docURL->GetSpec(URLName);
wallet_GetHostFile(docURL, strippedURLNameUCS2);
nsCAutoString strippedURLNameUTF8 = NS_ConvertUCS2toUTF8(strippedURLNameUCS2);
/* get to the form elements */
nsCOMPtr<nsIDOMHTMLDocument> htmldoc(do_QueryInterface(doc));
if (htmldoc == nsnull) {
nsCRT::free(URLName);
return;
}
nsCOMPtr<nsIDOMHTMLCollection> forms;
nsresult rv = htmldoc->GetForms(getter_AddRefs(forms));
if (NS_FAILED(rv) || (forms == nsnull)) {
nsCRT::free(URLName);
return;
}
@ -4133,7 +4128,7 @@ WLLT_OnSubmit(nsIContent* currentForm, nsIDOMWindowInternal* window) {
wwatch->GetNewPrompter(0, getter_AddRefs(dialog));
if (dialog) {
SINGSIGN_RememberSignonData(dialog, URLName, signonData, window);
SINGSIGN_RememberSignonData(dialog, (char*)URLName.get(), signonData, window);
}
}
PRInt32 count2 = signonData->Count();
@ -4176,7 +4171,6 @@ WLLT_OnSubmit(nsIContent* currentForm, nsIDOMWindowInternal* window) {
}
}
}
nsCRT::free(URLName);
}
PUBLIC void

10
extensions/webservices/schema/src/nsSchemaLoader.cpp
View File

@ -820,7 +820,7 @@ nsSchemaLoader::GetResolvedURI(const nsAReadableString& aSchemaURI,
}
}
rv = NS_NewURI(aURI, aSchemaURI, baseURI);
rv = NS_NewURI(aURI, aSchemaURI, nsnull, baseURI);
if (NS_FAILED(rv)) return rv;
rv = secMan->CheckLoadURIFromScript(cx, *aURI);
@ -852,8 +852,8 @@ nsSchemaLoader::Load(const nsAReadableString& schemaURI,
if (NS_FAILED(rv)) {
return rv;
}
nsXPIDLCString spec;
resolvedURI->GetSpec(getter_Copies(spec));
nsCAutoString spec;
resolvedURI->GetSpec(spec);
nsCOMPtr<nsIXMLHttpRequest> request(do_CreateInstance(NS_XMLHTTPREQUEST_CONTRACTID, &rv));
if (!request) {
@ -908,8 +908,8 @@ nsSchemaLoader::LoadAsync(const nsAReadableString& schemaURI,
if (NS_FAILED(rv)) {
return rv;
}
nsXPIDLCString spec;
resolvedURI->GetSpec(getter_Copies(spec));
nsCAutoString spec;
resolvedURI->GetSpec(spec);
nsCOMPtr<nsIXMLHttpRequest> request(do_CreateInstance(NS_XMLHTTPREQUEST_CONTRACTID, &rv));
if (!request) {

4
extensions/webservices/soap/src/nsSOAPCall.cpp
View File

@ -99,14 +99,14 @@ nsresult nsSOAPCall::GetTransport(nsISOAPTransport ** aTransport)
NS_ENSURE_ARG_POINTER(aTransport);
nsresult rv;
nsCOMPtr < nsIURI > uri;
nsXPIDLCString protocol;
nsCAutoString protocol;
nsCString transportURI(ToNewCString(mTransportURI));
rv = NS_NewURI(getter_AddRefs(uri), transportURI.get());
if (NS_FAILED(rv))
return rv;
uri->GetScheme(getter_Copies(protocol));
uri->GetScheme(protocol);
nsCAutoString transportContractid;
transportContractid.Assign(NS_SOAPTRANSPORT_CONTRACTID_PREFIX);

Some files were not shown because too many files have changed in this diff Show More