NS_IMETHODIMP
nsGIOProtocolHandler::NewChannel2(nsIURI* aURI,
nsILoadInfo* aLoadInfo,
nsIChannel** aResult)
{
NS_ENSURE_ARG_POINTER(aURI);
nsresult rv;
nsAutoCString spec;
rv = aURI->GetSpec(spec);
if (NS_FAILED(rv))
return rv;
RefPtr<nsGIOInputStream> stream = new nsGIOInputStream(spec);
if (!stream) {
return NS_ERROR_OUT_OF_MEMORY;
}
rv = NS_NewInputStreamChannelInternal(aResult,
aURI,
stream,
NS_LITERAL_CSTRING(UNKNOWN_CONTENT_TYPE),
EmptyCString(), // aContentCharset
aLoadInfo);
if (NS_SUCCEEDED(rv)) {
stream->SetChannel(*aResult);
}
return rv;
}
nsresult nsAddbookProtocolHandler::GenerateXMLOutputChannel(
nsString &aOutput, nsIAddbookUrl *addbookUrl, nsIURI *aURI,
nsILoadInfo *aLoadInfo, nsIChannel **_retval) {
nsresult rv;
nsCOMPtr<nsIStringInputStream> inStr(
do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
NS_ConvertUTF16toUTF8 utf8String(aOutput.get());
rv = inStr->SetData(utf8String.get(), utf8String.Length());
NS_ENSURE_SUCCESS(rv, rv);
if (aLoadInfo) {
return NS_NewInputStreamChannelInternal(_retval, aURI, inStr.forget(),
NS_LITERAL_CSTRING("text/xml"),
EmptyCString(), aLoadInfo);
}
nsCOMPtr<nsIPrincipal> nullPrincipal =
do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "CreateInstance of nullprincipalfailed.");
if (NS_FAILED(rv)) return rv;
return NS_NewInputStreamChannel(
_retval, aURI, inStr.forget(), nullPrincipal,
nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
nsIContentPolicy::TYPE_OTHER, NS_LITERAL_CSTRING("text/xml"));
}
nsresult
nsViewSourceChannel::InitSrcdoc(nsIURI* aURI,
nsIURI* aBaseURI,
const nsAString &aSrcdoc,
nsINode *aLoadingNode,
nsIPrincipal *aLoadingPrincipal,
nsIPrincipal *aTriggeringPrincipal,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType)
{
nsresult rv;
nsCOMPtr<nsIURI> inStreamURI;
// Need to strip view-source: from the URI. Hardcoded to
// about:srcdoc as this is the only permissible URI for srcdoc
// loads
rv = NS_NewURI(getter_AddRefs(inStreamURI),
NS_LITERAL_STRING("about:srcdoc"));
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_NewInputStreamChannelInternal(getter_AddRefs(mChannel),
inStreamURI,
aSrcdoc,
NS_LITERAL_CSTRING("text/html"),
aLoadingNode,
aLoadingPrincipal,
aTriggeringPrincipal,
aSecurityFlags,
aContentPolicyType,
true);
NS_ENSURE_SUCCESS(rv, rv);
mOriginalURI = aURI;
mIsSrcdocChannel = true;
mChannel->SetOriginalURI(mOriginalURI);
mHttpChannel = do_QueryInterface(mChannel);
mHttpChannelInternal = do_QueryInterface(mChannel);
mCachingChannel = do_QueryInterface(mChannel);
mCacheInfoChannel = do_QueryInterface(mChannel);
mApplicationCacheChannel = do_QueryInterface(mChannel);
mUploadChannel = do_QueryInterface(mChannel);
nsCOMPtr<nsIInputStreamChannel> isc = do_QueryInterface(mChannel);
MOZ_ASSERT(isc);
isc->SetBaseURI(aBaseURI);
return NS_OK;
}
NS_IMETHODIMP
nsAboutBlank::NewChannel(nsIURI* aURI,
nsILoadInfo* aLoadInfo,
nsIChannel** result)
{
NS_ENSURE_ARG_POINTER(aURI);
nsCOMPtr<nsIInputStream> in;
nsresult rv = NS_NewCStringInputStream(getter_AddRefs(in), EmptyCString());
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIChannel> channel;
// Bug 1087720 (and Bug 1099296):
// Once all callsites have been updated to call NewChannel2()
// instead of NewChannel() we should have a non-null loadInfo
// consistently. Until then we have to branch on the loadInfo.
if (aLoadInfo) {
rv = NS_NewInputStreamChannelInternal(getter_AddRefs(channel),
aURI,
in,
NS_LITERAL_CSTRING("text/html"),
NS_LITERAL_CSTRING("utf-8"),
aLoadInfo);
}
else {
rv = NS_NewInputStreamChannel(getter_AddRefs(channel),
aURI,
in,
nsContentUtils::GetSystemPrincipal(),
nsILoadInfo::SEC_NORMAL,
nsIContentPolicy::TYPE_OTHER,
NS_LITERAL_CSTRING("text/html"),
NS_LITERAL_CSTRING("utf-8"));
}
if (NS_FAILED(rv)) return rv;
channel.forget(result);
return rv;
}
NS_IMETHODIMP nsSmtpService::NewChannel2(nsIURI *aURI,
nsILoadInfo* aLoadInfo,
nsIChannel **_retval)
{
NS_ENSURE_ARG_POINTER(aURI);
// create an empty pipe for use with the input stream channel.
nsCOMPtr<nsIAsyncInputStream> pipeIn;
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
nsCOMPtr<nsIPipe> pipe = do_CreateInstance("@mozilla.org/pipe;1");
nsresult rv = pipe->Init(false, false, 0, 0);
if (NS_FAILED(rv))
return rv;
pipe->GetInputStream(getter_AddRefs(pipeIn));
pipe->GetOutputStream(getter_AddRefs(pipeOut));
pipeOut->Close();
if (aLoadInfo) {
return NS_NewInputStreamChannelInternal(_retval,
aURI,
pipeIn,
NS_LITERAL_CSTRING("application/x-mailto"),
EmptyCString(),
aLoadInfo);
}
nsCOMPtr<nsIPrincipal> nullPrincipal =
do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "CreateInstance of nullprincipal failed.");
if (NS_FAILED(rv))
return rv;
return NS_NewInputStreamChannel(_retval, aURI, pipeIn,
nullPrincipal, nsILoadInfo::SEC_NORMAL,
nsIContentPolicy::TYPE_OTHER,
NS_LITERAL_CSTRING("application/x-mailto"));
}
NS_IMETHODIMP
nsAddbookProtocolHandler::NewChannel(nsIURI *aURI, nsILoadInfo *aLoadInfo,
nsIChannel **_retval) {
nsresult rv;
nsCOMPtr<nsIAddbookUrl> addbookUrl = do_QueryInterface(aURI, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = addbookUrl->GetAddbookOperation(&mAddbookOperation);
NS_ENSURE_SUCCESS(rv, rv);
if (mAddbookOperation == nsIAddbookUrlOperation::InvalidUrl) {
nsAutoString errorString;
errorString.AssignLiteral("Unsupported format/operation requested for ");
nsAutoCString spec;
rv = aURI->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
errorString.Append(NS_ConvertUTF8toUTF16(spec));
rv = GenerateXMLOutputChannel(errorString, addbookUrl, aURI, aLoadInfo,
_retval);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
if (mAddbookOperation == nsIAddbookUrlOperation::AddVCard) {
// create an empty pipe for use with the input stream channel.
nsCOMPtr<nsIAsyncInputStream> pipeIn;
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
nsCOMPtr<nsIPipe> pipe = do_CreateInstance("@mozilla.org/pipe;1");
rv = pipe->Init(false, false, 0, 0);
NS_ENSURE_SUCCESS(rv, rv);
// These always succeed because the pipe is initialized above.
MOZ_ALWAYS_SUCCEEDS(pipe->GetInputStream(getter_AddRefs(pipeIn)));
MOZ_ALWAYS_SUCCEEDS(pipe->GetOutputStream(getter_AddRefs(pipeOut)));
pipeOut->Close();
if (aLoadInfo) {
return NS_NewInputStreamChannelInternal(
_retval, aURI, pipeIn.forget(),
NS_LITERAL_CSTRING("application/x-addvcard"), EmptyCString(),
aLoadInfo);
}
nsCOMPtr<nsIPrincipal> nullPrincipal =
do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "CreateInstance of nullprincipal failed.");
if (NS_FAILED(rv)) return rv;
return NS_NewInputStreamChannel(
_retval, aURI, pipeIn.forget(), nullPrincipal,
nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
nsIContentPolicy::TYPE_OTHER,
NS_LITERAL_CSTRING("application/x-addvcard"));
}
nsString output;
rv = GeneratePrintOutput(addbookUrl, output);
if (NS_FAILED(rv)) {
output.AssignLiteral("failed to print. url=");
nsAutoCString spec;
rv = aURI->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
output.Append(NS_ConvertUTF8toUTF16(spec));
}
rv = GenerateXMLOutputChannel(output, addbookUrl, aURI, aLoadInfo, _retval);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsAboutBloat::NewChannel(nsIURI* aURI,
nsILoadInfo* aLoadInfo,
nsIChannel** result)
{
NS_ENSURE_ARG_POINTER(aURI);
nsresult rv;
nsAutoCString path;
rv = aURI->GetPath(path);
if (NS_FAILED(rv)) return rv;
nsTraceRefcnt::StatisticsType statType = nsTraceRefcnt::ALL_STATS;
bool clear = false;
bool leaks = false;
int32_t pos = path.Find("?");
if (pos > 0) {
nsAutoCString param;
(void)path.Right(param, path.Length() - (pos+1));
if (param.EqualsLiteral("new"))
statType = nsTraceRefcnt::NEW_STATS;
else if (param.EqualsLiteral("clear"))
clear = true;
else if (param.EqualsLiteral("leaks"))
leaks = true;
}
nsCOMPtr<nsIInputStream> inStr;
if (clear) {
nsTraceRefcnt::ResetStatistics();
rv = NS_NewCStringInputStream(getter_AddRefs(inStr),
NS_LITERAL_CSTRING("Bloat statistics cleared."));
if (NS_FAILED(rv)) return rv;
}
else if (leaks) {
// dump the current set of leaks.
GC_gcollect();
rv = NS_NewCStringInputStream(getter_AddRefs(inStr),
NS_LITERAL_CSTRING("Memory leaks dumped."));
if (NS_FAILED(rv)) return rv;
}
else {
nsCOMPtr<nsIFile> file;
rv = NS_GetSpecialDirectory(NS_OS_CURRENT_PROCESS_DIR,
getter_AddRefs(file));
if (NS_FAILED(rv)) return rv;
rv = file->AppendNative(NS_LITERAL_CSTRING("bloatlogs"));
if (NS_FAILED(rv)) return rv;
bool exists;
rv = file->Exists(&exists);
if (NS_FAILED(rv)) return rv;
if (!exists) {
// On all the platforms that I know use permissions,
// directories need to have the executable flag set
// if you want to do anything inside the directory.
rv = file->Create(nsIFile::DIRECTORY_TYPE, 0755);
if (NS_FAILED(rv)) return rv;
}
nsAutoCString dumpFileName;
if (statType == nsTraceRefcnt::ALL_STATS)
dumpFileName.AssignLiteral("all-");
else
dumpFileName.AssignLiteral("new-");
PRExplodedTime expTime;
PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &expTime);
char time[128];
PR_FormatTimeUSEnglish(time, 128, "%Y-%m-%d-%H%M%S.txt", &expTime);
dumpFileName += time;
rv = file->AppendNative(dumpFileName);
if (NS_FAILED(rv)) return rv;
FILE* out;
rv = file->OpenANSIFileDesc("w", &out);
if (NS_FAILED(rv)) return rv;
rv = nsTraceRefcnt::DumpStatistics(statType, out);
::fclose(out);
if (NS_FAILED(rv)) return rv;
rv = NS_NewLocalFileInputStream(getter_AddRefs(inStr), file);
if (NS_FAILED(rv)) return rv;
}
nsIChannel* channel = nullptr;
rv = NS_NewInputStreamChannelInternal(&channel,
aURI,
inStr,
NS_LITERAL_CSTRING("text/plain"),
NS_LITERAL_CSTRING("utf-8"),
aLoadInfo);
if (NS_FAILED(rv)) return rv;
*result = channel;
return rv;
}
