void
MediaDocument::GetFileName(nsAString& aResult)
{
aResult.Truncate();
nsCOMPtr<nsIURL> url = do_QueryInterface(mDocumentURI);
if (!url)
return;
nsCAutoString fileName;
url->GetFileName(fileName);
if (fileName.IsEmpty())
return;
nsCAutoString docCharset;
// Now that the charset is set in |StartDocumentLoad| to the charset of
// the document viewer instead of a bogus value ("ISO-8859-1" set in
// |nsDocument|'s ctor), the priority is given to the current charset.
// This is necessary to deal with a media document being opened in a new
// window or a new tab, in which case |originCharset| of |nsIURI| is not
// reliable.
if (mCharacterSetSource != kCharsetUninitialized) {
docCharset = mCharacterSet;
} else {
// resort to |originCharset|
url->GetOriginCharset(docCharset);
SetDocumentCharacterSet(docCharset);
}
nsresult rv;
nsCOMPtr<nsITextToSubURI> textToSubURI =
do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
// UnEscapeURIForUI always succeeds
textToSubURI->UnEscapeURIForUI(docCharset, fileName, aResult);
} else {
CopyUTF8toUTF16(fileName, aResult);
}
}
NS_IMETHODIMP
nsHTMLSharedElement::GetHref(nsAString& aValue)
{
nsAutoString href;
GetAttr(kNameSpaceID_None, nsGkAtoms::href, href);
nsCOMPtr<nsIURI> uri;
nsIDocument* doc = GetOwnerDoc();
if (doc) {
nsContentUtils::NewURIWithDocumentCharset(
getter_AddRefs(uri), href, doc, doc->GetDocumentURI());
}
if (!uri) {
aValue = href;
return NS_OK;
}
nsCAutoString spec;
uri->GetSpec(spec);
CopyUTF8toUTF16(spec, aValue);
return NS_OK;
}
nsresult
nsXULContentUtils::MakeElementID(nsIDocument* aDocument,
const nsACString& aURI,
nsAString& aElementID)
{
// Convert a URI into an element ID that can be accessed from the
// DOM APIs.
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_NewURI(getter_AddRefs(uri), aURI,
aDocument->GetDocumentCharacterSet().get());
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIURL> url = do_QueryInterface(uri);
if (url) {
nsCAutoString ref;
url->GetRef(ref);
CopyUTF8toUTF16(ref, aElementID);
} else {
aElementID.Truncate();
}
return NS_OK;
}
void
GetRequestURLFromChrome(const nsAString& aInput, nsAString& aRequestURL,
nsACString& aURLfragment, ErrorResult& aRv)
{
nsCOMPtr<nsIURI> uri = ParseURLFromChrome(aInput, aRv);
if (aRv.Failed()) {
return;
}
// This fails with URIs with weird protocols, even when they are valid,
// so we ignore the failure
nsAutoCString credentials;
Unused << uri->GetUserPass(credentials);
if (!credentials.IsEmpty()) {
aRv.ThrowTypeError<MSG_URL_HAS_CREDENTIALS>(aInput);
return;
}
nsCOMPtr<nsIURI> uriClone;
// We use CloneIgnoringRef to strip away the fragment even if the original URI
// is immutable.
aRv = uri->CloneIgnoringRef(getter_AddRefs(uriClone));
if (NS_WARN_IF(aRv.Failed())) {
return;
}
nsAutoCString spec;
aRv = uriClone->GetSpec(spec);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
CopyUTF8toUTF16(spec, aRequestURL);
// Get the fragment from nsIURI.
aRv = uri->GetRef(aURLfragment);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
}
/* static */ void
nsGNOMERegistry::GetAppDescForScheme(const nsACString& aScheme,
nsAString& aDesc)
{
nsCOMPtr<nsIGConfService> gconf = do_GetService(NS_GCONFSERVICE_CONTRACTID);
nsCOMPtr<nsIGIOService> giovfs = do_GetService(NS_GIOSERVICE_CONTRACTID);
if (!gconf && !giovfs)
return;
nsCAutoString name;
if (giovfs) {
nsCOMPtr<nsIGIOMimeApp> app;
if (NS_FAILED(giovfs->GetAppForURIScheme(aScheme, getter_AddRefs(app))))
return;
app->GetName(name);
} else {
bool isEnabled;
if (NS_FAILED(gconf->GetAppForProtocol(aScheme, &isEnabled, name)))
return;
if (!name.IsEmpty()) {
// Try to only provide the executable name, as it is much simpler than with the path and arguments
PRInt32 firstSpace = name.FindChar(' ');
if (firstSpace != kNotFound) {
name.Truncate(firstSpace);
PRInt32 lastSlash = name.RFindChar('/');
if (lastSlash != kNotFound) {
name.Cut(0, lastSlash + 1);
}
}
}
}
CopyUTF8toUTF16(name, aDesc);
}
void
nsReferencedElement::Reset(nsIContent* aFromContent, nsIURI* aURI,
bool aWatch, bool aReferenceImage)
{
NS_ABORT_IF_FALSE(aFromContent, "Reset() expects non-null content pointer");
Unlink();
if (!aURI)
return;
nsCAutoString refPart;
aURI->GetRef(refPart);
// Unescape %-escapes in the reference. The result will be in the
// origin charset of the URL, hopefully...
NS_UnescapeURL(refPart);
nsCAutoString charset;
aURI->GetOriginCharset(charset);
nsAutoString ref;
nsresult rv = nsContentUtils::ConvertStringFromCharset(charset, refPart, ref);
if (NS_FAILED(rv)) {
CopyUTF8toUTF16(refPart, ref);
}
if (ref.IsEmpty())
return;
// Get the current document
nsIDocument *doc = aFromContent->GetCurrentDoc();
if (!doc)
return;
nsIContent* bindingParent = aFromContent->GetBindingParent();
if (bindingParent) {
nsXBLBinding* binding = doc->BindingManager()->GetBinding(bindingParent);
if (binding) {
bool isEqualExceptRef;
rv = aURI->EqualsExceptRef(binding->PrototypeBinding()->DocURI(),
&isEqualExceptRef);
if (NS_SUCCEEDED(rv) && isEqualExceptRef) {
// XXX sXBL/XBL2 issue
// Our content is an anonymous XBL element from a binding inside the
// same document that the referenced URI points to. In order to avoid
// the risk of ID collisions we restrict ourselves to anonymous
// elements from this binding; specifically, URIs that are relative to
// the binding document should resolve to the copy of the target
// element that has been inserted into the bound document.
// If the URI points to a different document we don't need this
// restriction.
nsINodeList* anonymousChildren =
doc->BindingManager()->GetAnonymousNodesFor(bindingParent);
if (anonymousChildren) {
PRUint32 length;
anonymousChildren->GetLength(&length);
for (PRUint32 i = 0; i < length && !mElement; ++i) {
mElement =
nsContentUtils::MatchElementId(anonymousChildren->GetNodeAt(i), ref);
}
}
// We don't have watching working yet for XBL, so bail out here.
return;
}
}
}
bool isEqualExceptRef;
rv = aURI->EqualsExceptRef(doc->GetDocumentURI(), &isEqualExceptRef);
if (NS_FAILED(rv) || !isEqualExceptRef) {
nsRefPtr<nsIDocument::ExternalResourceLoad> load;
doc = doc->RequestExternalResource(aURI, aFromContent,
getter_AddRefs(load));
if (!doc) {
if (!load || !aWatch) {
// Nothing will ever happen here
return;
}
DocumentLoadNotification* observer =
new DocumentLoadNotification(this, ref);
mPendingNotification = observer;
if (observer) {
load->AddObserver(observer);
}
// Keep going so we set up our watching stuff a bit
}
}
if (aWatch) {
nsCOMPtr<nsIAtom> atom = do_GetAtom(ref);
if (!atom)
return;
atom.swap(mWatchID);
}
mReferencingImage = aReferenceImage;
HaveNewDocument(doc, aWatch, ref);
}
nsresult nsMsgI18NConvertToUnicode(const char* aCharset,
const nsCString& inString,
nsAString& outString,
bool aIsCharsetCanonical)
{
if (inString.IsEmpty()) {
outString.Truncate();
return NS_OK;
}
else if (!*aCharset || !PL_strcasecmp(aCharset, "us-ascii") ||
!PL_strcasecmp(aCharset, "ISO-8859-1")) {
// Despite its name, it also works for Latin-1.
CopyASCIItoUTF16(inString, outString);
return NS_OK;
}
else if (!PL_strcasecmp(aCharset, "UTF-8")) {
if (MsgIsUTF8(inString)) {
nsAutoString tmp;
CopyUTF8toUTF16(inString, tmp);
if (!tmp.IsEmpty() && tmp.First() == char16_t(0xFEFF))
tmp.Cut(0, 1);
outString.Assign(tmp);
return NS_OK;
}
NS_WARNING("Invalid UTF-8 string");
return NS_ERROR_UNEXPECTED;
}
nsresult rv;
nsCOMPtr <nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr <nsIUnicodeDecoder> decoder;
// get an unicode converter
if (aIsCharsetCanonical) // optimize for modified UTF-7 used by IMAP
rv = ccm->GetUnicodeDecoderRaw(aCharset, getter_AddRefs(decoder));
else
rv = ccm->GetUnicodeDecoderInternal(aCharset, getter_AddRefs(decoder));
NS_ENSURE_SUCCESS(rv, rv);
const char *originalSrcPtr = inString.get();
const char *currentSrcPtr = originalSrcPtr;
int32_t originalLength = inString.Length();
int32_t srcLength;
int32_t dstLength;
char16_t localbuf[512];
int32_t consumedLen = 0;
outString.Truncate();
// convert
while (consumedLen < originalLength) {
srcLength = originalLength - consumedLen;
dstLength = 512;
rv = decoder->Convert(currentSrcPtr, &srcLength, localbuf, &dstLength);
if (NS_FAILED(rv) || dstLength == 0)
break;
outString.Append(localbuf, dstLength);
currentSrcPtr += srcLength;
consumedLen = currentSrcPtr - originalSrcPtr; // src length used so far
}
return rv;
}
nsresult
nsDownloadScanner::Scan::Start()
{
mStartTime = PR_Now();
mThread = (HANDLE)_beginthreadex(nullptr, 0, ScannerThreadFunction,
this, CREATE_SUSPENDED, nullptr);
if (!mThread)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = NS_OK;
// Get the path to the file on disk
nsCOMPtr<nsIFile> file;
rv = mDownload->GetTargetFile(getter_AddRefs(file));
NS_ENSURE_SUCCESS(rv, rv);
rv = file->GetPath(mPath);
NS_ENSURE_SUCCESS(rv, rv);
// Grab the app name
nsCOMPtr<nsIXULAppInfo> appinfo =
do_GetService(XULAPPINFO_SERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoCString name;
rv = appinfo->GetName(name);
NS_ENSURE_SUCCESS(rv, rv);
CopyUTF8toUTF16(name, mName);
// Get the origin
nsCOMPtr<nsIURI> uri;
rv = mDownload->GetSource(getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoCString origin;
rv = uri->GetSpec(origin);
NS_ENSURE_SUCCESS(rv, rv);
// Certain virus interfaces do not like extremely long uris.
// Chop off the path and cgi data and just pass the base domain.
if (origin.Length() > MAX_IAEURILENGTH) {
rv = uri->GetPrePath(origin);
NS_ENSURE_SUCCESS(rv, rv);
}
CopyUTF8toUTF16(origin, mOrigin);
// We count https/ftp/http as an http download
bool isHttp(false), isFtp(false), isHttps(false);
nsCOMPtr<nsIURI> innerURI = NS_GetInnermostURI(uri);
if (!innerURI) innerURI = uri;
(void)innerURI->SchemeIs("http", &isHttp);
(void)innerURI->SchemeIs("ftp", &isFtp);
(void)innerURI->SchemeIs("https", &isHttps);
mIsHttpDownload = isHttp || isFtp || isHttps;
// IAttachementExecute prohibits src data: schemes by default but we
// support them. Mark the download if it's a data scheme, so we
// can skip off supplying the src to IAttachementExecute when we scan
// the resulting file.
(void)innerURI->SchemeIs("data", &mSkipSource);
// ResumeThread returns the previous suspend count
if (1 != ::ResumeThread(mThread)) {
CloseHandle(mThread);
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
/**
Parses e.g. "a(href,title)" (but not several tags at once).
*/
nsresult
mozSanitizingHTMLSerializer::ParseTagPref(const nsCAutoString& tagpref)
{
nsIParserService* parserService = nsContentUtils::GetParserService();
if (!parserService)
return NS_ERROR_OUT_OF_MEMORY;
// Parsing tag
PRInt32 bracket = tagpref.FindChar('(');
if (bracket == 0)
{
printf(" malformed pref: %s\n", tagpref.get());
return NS_ERROR_CANNOT_CONVERT_DATA;
}
nsAutoString tag;
CopyUTF8toUTF16(StringHead(tagpref, bracket), tag);
// Create key
PRInt32 tag_id = parserService->HTMLStringTagToId(tag);
if (tag_id == eHTMLTag_userdefined)
{
printf(" unknown tag <%s>, won't add.\n",
NS_ConvertUTF16toUTF8(tag).get());
return NS_ERROR_CANNOT_CONVERT_DATA;
}
nsPRUint32Key tag_key(tag_id);
if (mAllowedTags.Exists(&tag_key))
{
printf(" duplicate tag: %s\n", NS_ConvertUTF16toUTF8(tag).get());
return NS_ERROR_CANNOT_CONVERT_DATA;
}
if (bracket == kNotFound)
/* There are no attributes in the pref. So, allow none; only the tag
itself */
{
mAllowedTags.Put(&tag_key, 0);
}
else
{
// Attributes
// where is the macro for non-fatal errors in opt builds?
if(tagpref[tagpref.Length() - 1] != ')' ||
tagpref.Length() < PRUint32(bracket) + 3)
{
printf(" malformed pref: %s\n", tagpref.get());
return NS_ERROR_CANNOT_CONVERT_DATA;
}
nsCOMPtr<nsIProperties> attr_bag =
do_CreateInstance(NS_PROPERTIES_CONTRACTID);
NS_ENSURE_TRUE(attr_bag, NS_ERROR_INVALID_POINTER);
nsCAutoString attrList;
attrList.Append(Substring(tagpref,
bracket + 1,
tagpref.Length() - 2 - bracket));
char* attrs_lasts;
for (char* iAttr = PL_strtok_r(attrList.BeginWriting(),
",", &attrs_lasts);
iAttr;
iAttr = PL_strtok_r(NULL, ",", &attrs_lasts))
{
attr_bag->Set(iAttr, 0);
}
nsIProperties* attr_bag_raw = attr_bag;
NS_ADDREF(attr_bag_raw);
mAllowedTags.Put(&tag_key, attr_bag_raw);
}
return NS_OK;
}
nsresult
nsOperaProfileMigrator::CopyHistoryBatched(PRBool aReplace)
{
nsCOMPtr<nsIBrowserHistory> hist(do_GetService(NS_GLOBALHISTORY2_CONTRACTID));
nsCOMPtr<nsIFile> temp;
mOperaProfile->Clone(getter_AddRefs(temp));
nsCOMPtr<nsILocalFile> historyFile(do_QueryInterface(temp));
historyFile->Append(OPERA_HISTORY_FILE_NAME);
nsCOMPtr<nsIInputStream> fileStream;
NS_NewLocalFileInputStream(getter_AddRefs(fileStream), historyFile);
if (!fileStream) return NS_ERROR_OUT_OF_MEMORY;
nsCOMPtr<nsILineInputStream> lineStream = do_QueryInterface(fileStream);
nsCAutoString buffer, url;
nsAutoString title;
PRTime lastVisitDate;
PRBool moreData = PR_FALSE;
enum { TITLE, URL, LASTVISIT } state = TITLE;
// Format is "title\nurl\nlastvisitdate"
do {
nsresult rv = lineStream->ReadLine(buffer, &moreData);
if (NS_FAILED(rv))
return rv;
switch (state) {
case TITLE:
CopyUTF8toUTF16(buffer, title);
state = URL;
break;
case URL:
url = buffer;
state = LASTVISIT;
break;
case LASTVISIT:
// Opera time format is a second offset, PRTime is a microsecond offset
nsresult err;
lastVisitDate = buffer.ToInteger(&err);
PRInt64 temp, million;
LL_I2L(temp, lastVisitDate);
LL_I2L(million, PR_USEC_PER_SEC);
LL_MUL(lastVisitDate, temp, million);
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), url);
if (uri)
hist->AddPageWithDetails(uri, title.get(), lastVisitDate);
state = TITLE;
break;
}
}
while (moreData);
return NS_OK;
}
static int
MimeInlineTextPlain_parse_line (char *line, PRInt32 length, MimeObject *obj)
{
int status;
PRBool quoting = ( obj->options
&& ( obj->options->format_out == nsMimeOutput::nsMimeMessageQuoting ||
obj->options->format_out == nsMimeOutput::nsMimeMessageBodyQuoting
) ); // see above
PRBool plainHTML = quoting || (obj->options &&
obj->options->format_out == nsMimeOutput::nsMimeMessageSaveAs);
// see above
PRBool rawPlainText = obj->options &&
(obj->options->format_out == nsMimeOutput::nsMimeMessageFilterSniffer
|| obj->options->format_out == nsMimeOutput::nsMimeMessageAttach);
// this routine gets called for every line of data that comes through the
// mime converter. It's important to make sure we are efficient with
// how we allocate memory in this routine. be careful if you go to add
// more to this routine.
NS_ASSERTION(length > 0, "zero length");
if (length <= 0) return 0;
mozITXTToHTMLConv *conv = GetTextConverter(obj->options);
MimeInlineTextPlain *text = (MimeInlineTextPlain *) obj;
PRBool skipConversion = !conv || rawPlainText ||
(obj->options && obj->options->force_user_charset);
char *mailCharset = NULL;
nsresult rv;
// if this part has a name and it's not a message/rfc822, don't quote
if (quoting && obj->headers && MimeHeaders_get_name(obj->headers, obj->options)
&& PL_strcasecmp(obj->content_type, MESSAGE_RFC822))
return 0;
if (!skipConversion)
{
nsDependentCString inputStr(line, length);
nsAutoString lineSourceStr;
// For 'SaveAs', |line| is in |mailCharset|.
// convert |line| to UTF-16 before 'html'izing (calling ScanTXT())
if (obj->options->format_out == nsMimeOutput::nsMimeMessageSaveAs)
{ // Get the mail charset of this message.
MimeInlineText *inlinetext = (MimeInlineText *) obj;
if (!inlinetext->initializeCharset)
((MimeInlineTextClass*)&mimeInlineTextClass)->initialize_charset(obj);
mailCharset = inlinetext->charset;
if (mailCharset && *mailCharset) {
rv = nsMsgI18NConvertToUnicode(mailCharset, inputStr, lineSourceStr);
NS_ENSURE_SUCCESS(rv, -1);
}
else // this probably never happens ...
CopyUTF8toUTF16(inputStr, lineSourceStr);
}
else // line is in UTF-8
CopyUTF8toUTF16(inputStr, lineSourceStr);
nsCAutoString prefaceResultStr; // Quoting stuff before the real text
// Recognize quotes
PRUint32 oldCiteLevel = text->mCiteLevel;
PRUint32 logicalLineStart = 0;
rv = conv->CiteLevelTXT(lineSourceStr.get(),
&logicalLineStart, &(text->mCiteLevel));
NS_ENSURE_SUCCESS(rv, -1);
// Find out, which recognitions to do
PRBool whattodo = obj->options->whattodo;
if (plainHTML)
{
if (quoting)
whattodo = 0; // This is done on Send. Don't do it twice.
else
whattodo = whattodo & ~mozITXTToHTMLConv::kGlyphSubstitution;
/* Do recognition for the case, the result is viewed in
Mozilla, but not GlyphSubstitution, because other UAs
might not be able to display the glyphs. */
if (!text->mBlockquoting)
text->mCiteLevel = 0;
}
// Write blockquote
if (text->mCiteLevel > oldCiteLevel)
{
prefaceResultStr += "</pre>";
for (PRUint32 i = 0; i < text->mCiteLevel - oldCiteLevel; i++)
{
nsCAutoString style;
MimeTextBuildPrefixCSS(text->mQuotedSizeSetting, text->mQuotedStyleSetting,
text->mCitationColor, style);
if (!plainHTML && !style.IsEmpty())
{
prefaceResultStr += "<blockquote type=cite style=\"";
prefaceResultStr += style;
prefaceResultStr += "\">";
}
else
prefaceResultStr += "<blockquote type=cite>";
}
prefaceResultStr += "<pre wrap>";
}
else if (text->mCiteLevel < oldCiteLevel)
{
prefaceResultStr += "</pre>";
for (PRUint32 i = 0; i < oldCiteLevel - text->mCiteLevel; i++)
prefaceResultStr += "</blockquote>";
prefaceResultStr += "<pre wrap>";
if (text->mCiteLevel == 0)
prefaceResultStr += "<!---->"; /* Make sure, NGLayout puts out
a linebreak */
}
// Write plain text quoting tags
if (logicalLineStart != 0 && !(plainHTML && text->mBlockquoting))
{
if (!plainHTML)
prefaceResultStr += "<span class=\"moz-txt-citetags\">";
nsAutoString citeTagsSource;
lineSourceStr.Mid(citeTagsSource, 0, logicalLineStart);
// Convert to HTML
nsXPIDLString citeTagsResultUnichar;
rv = conv->ScanTXT(citeTagsSource.get(), 0 /* no recognition */,
getter_Copies(citeTagsResultUnichar));
if (NS_FAILED(rv)) return -1;
AppendUTF16toUTF8(citeTagsResultUnichar, prefaceResultStr);
if (!plainHTML)
prefaceResultStr += "</span>";
}
// recognize signature
if ((lineSourceStr.Length() >= 4)
&& lineSourceStr.First() == '-'
&& Substring(lineSourceStr, 0, 3).EqualsLiteral("-- ")
&& (lineSourceStr[3] == '\r' || lineSourceStr[3] == '\n') )
{
text->mIsSig = PR_TRUE;
if (!quoting)
prefaceResultStr += "<div class=\"moz-txt-sig\">";
}
/* This is the main TXT to HTML conversion:
escaping (very important), eventually recognizing etc. */
nsXPIDLString lineResultUnichar;
rv = conv->ScanTXT(lineSourceStr.get() + logicalLineStart,
whattodo, getter_Copies(lineResultUnichar));
NS_ENSURE_SUCCESS(rv, -1);
if (!(text->mIsSig && quoting))
{
status = MimeObject_write(obj, prefaceResultStr.get(), prefaceResultStr.Length(), PR_TRUE);
if (status < 0) return status;
nsCAutoString outString;
if (obj->options->format_out != nsMimeOutput::nsMimeMessageSaveAs ||
!mailCharset || !*mailCharset)
CopyUTF16toUTF8(lineResultUnichar, outString);
else
{ // convert back to mailCharset before writing.
rv = nsMsgI18NConvertFromUnicode(mailCharset,
lineResultUnichar, outString);
NS_ENSURE_SUCCESS(rv, -1);
}
status = MimeObject_write(obj, outString.get(), outString.Length(), PR_TRUE);
}
else
{
status = NS_OK;
}
}
else
{
status = MimeObject_write(obj, line, length, PR_TRUE);
}
return status;
}
// submission
// much of this is cut and paste from nsFormFrame::OnSubmit
NS_IMETHODIMP
nsIsIndexFrame::OnSubmit(nsPresContext* aPresContext)
{
if (!mContent || !mInputContent) {
return NS_ERROR_UNEXPECTED;
}
if (mContent->IsEditable()) {
return NS_OK;
}
nsresult result = NS_OK;
// Begin ProcessAsURLEncoded
nsAutoString data;
nsCOMPtr<nsIUnicodeEncoder> encoder;
if(NS_FAILED(GetEncoder(getter_AddRefs(encoder)))) // Non-fatal error
encoder = nsnull;
nsAutoString value;
GetInputValue(value);
URLEncode(value, encoder, data);
// End ProcessAsURLEncoded
// make the url string
nsAutoString href;
// Get the document.
// We'll need it now to form the URL we're submitting to.
// We'll also need it later to get the DOM window when notifying form submit observers (bug 33203)
nsCOMPtr<nsIDocument> document = mContent->GetDocument();
if (!document) return NS_OK; // No doc means don't submit, see Bug 28988
// Resolve url to an absolute url
nsIURI *baseURI = document->GetDocBaseURI();
if (!baseURI) {
NS_ERROR("No Base URL found in Form Submit!");
return NS_OK; // No base URL -> exit early, see Bug 30721
}
// If an action is not specified and we are inside
// a HTML document then reload the URL. This makes us
// compatible with 4.x browsers.
// If we are in some other type of document such as XML or
// XUL, do nothing. This prevents undesirable reloading of
// a document inside XUL.
nsresult rv;
nsCOMPtr<nsIHTMLDocument> htmlDoc;
htmlDoc = do_QueryInterface(document, &rv);
if (NS_FAILED(rv)) {
// Must be a XML, XUL or other non-HTML document type
// so do nothing.
return NS_OK;
}
// Necko's MakeAbsoluteURI doesn't reuse the baseURL's rel path if it is
// passed a zero length rel path.
nsCAutoString relPath;
baseURI->GetSpec(relPath);
if (!relPath.IsEmpty()) {
CopyUTF8toUTF16(relPath, href);
// If re-using the same URL, chop off old query string (bug 25330)
PRInt32 queryStart = href.FindChar('?');
if (kNotFound != queryStart) {
href.Truncate(queryStart);
}
} else {
NS_ERROR("Rel path couldn't be formed in form submit!");
return NS_ERROR_OUT_OF_MEMORY;
}
// Add the URI encoded form values to the URI
// Get the scheme of the URI.
nsCOMPtr<nsIURI> actionURL;
nsXPIDLCString scheme;
PRBool isJSURL = PR_FALSE;
const nsACString &docCharset = document->GetDocumentCharacterSet();
const nsPromiseFlatCString& flatDocCharset = PromiseFlatCString(docCharset);
if (NS_SUCCEEDED(result = NS_NewURI(getter_AddRefs(actionURL), href,
flatDocCharset.get(),
baseURI))) {
result = actionURL->SchemeIs("javascript", &isJSURL);
}
// Append the URI encoded variable/value pairs for GET's
if (!isJSURL) { // Not for JS URIs, see bug 26917
if (href.FindChar('?') == kNotFound) { // Add a ? if needed
href.Append(PRUnichar('?'));
} else { // Adding to existing query string
if (href.Last() != '&' && href.Last() != '?') { // Add a & if needed
href.Append(PRUnichar('&'));
}
}
href.Append(data);
}
nsCOMPtr<nsIURI> uri;
result = NS_NewURI(getter_AddRefs(uri), href,
flatDocCharset.get(), baseURI);
if (NS_FAILED(result)) return result;
// Now pretend we're triggering a link
nsContentUtils::TriggerLink(mContent, aPresContext, uri,
EmptyString(), PR_TRUE, PR_TRUE);
return result;
}
bool
nsMessengerUnixIntegration::BuildNotificationBody(nsIMsgDBHdr *aHdr,
nsIStringBundle *aBundle,
nsString &aBody)
{
nsAutoString alertBody;
bool showPreview = true;
bool showSubject = true;
bool showSender = true;
int32_t previewLength = SHOW_ALERT_PREVIEW_LENGTH_DEFAULT;
nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (!prefBranch)
return false;
prefBranch->GetBoolPref(SHOW_ALERT_PREVIEW, &showPreview);
prefBranch->GetBoolPref(SHOW_ALERT_SENDER, &showSender);
prefBranch->GetBoolPref(SHOW_ALERT_SUBJECT, &showSubject);
prefBranch->GetIntPref(SHOW_ALERT_PREVIEW_LENGTH, &previewLength);
nsCOMPtr<nsIMsgHeaderParser> parser = do_GetService(NS_MAILNEWS_MIME_HEADER_PARSER_CONTRACTID);
if (!parser)
return false;
nsCOMPtr<nsIMsgFolder> folder;
aHdr->GetFolder(getter_AddRefs(folder));
if (!folder)
return false;
nsCString msgURI;
folder->GetUriForMsg(aHdr, msgURI);
bool localOnly;
uint32_t msgURIIndex = mFetchingURIs.IndexOf(msgURI);
if (msgURIIndex == -1)
{
localOnly = false;
mFetchingURIs.AppendElement(msgURI);
}
else
localOnly = true;
uint32_t messageKey;
if (NS_FAILED(aHdr->GetMessageKey(&messageKey)))
return false;
bool asyncResult = false;
nsresult rv = folder->FetchMsgPreviewText(&messageKey, 1,
localOnly, this,
&asyncResult);
// If we're still waiting on getting the message previews,
// bail early. We'll come back later when the async operation
// finishes.
if (NS_FAILED(rv) || asyncResult)
return false;
// If we got here, that means that we've retrieved the message preview,
// so we can stop tracking it with our mFetchingURIs array.
if (msgURIIndex != -1)
mFetchingURIs.RemoveElementAt(msgURIIndex);
nsCString utf8previewString;
if (showPreview &&
NS_FAILED(aHdr->GetStringProperty("preview", getter_Copies(utf8previewString))))
return false;
// need listener that mailbox is remote such as IMAP
// to generate preview message
nsString previewString;
CopyUTF8toUTF16(utf8previewString, previewString);
nsString subject;
if (showSubject && NS_FAILED(aHdr->GetMime2DecodedSubject(subject)))
return false;
nsString author;
if (showSender)
{
if (NS_FAILED(aHdr->GetMime2DecodedAuthor(author)))
return false;
PRUnichar **emails;
PRUnichar **names;
PRUnichar **fullnames;
uint32_t num;
if (NS_FAILED(parser->ParseHeadersWithArray(author.get(),
&emails,
&names,
&fullnames, &num)))
return false;
if (num > 0)
{
author.Assign(names[0] ? names[0] : emails[0]);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(num, emails);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(num, names);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(num, fullnames);
}
}
if (showSubject && showSender)
{
nsString msgTitle;
const PRUnichar *formatStrings[] =
{
subject.get(), author.get()
};
aBundle->FormatStringFromName(NS_LITERAL_STRING("newMailNotification_messagetitle").get(),
formatStrings, 2, getter_Copies(msgTitle));
alertBody.Append(msgTitle);
}
else if (showSubject)
alertBody.Append(subject);
else if (showSender)
alertBody.Append(author);
if (showPreview && (showSubject || showSender))
{
alertBody.AppendLiteral("\n");
}
if (showPreview)
alertBody.Append(StringHead(previewString, previewLength));
if (alertBody.IsEmpty())
return false;
aBody.Assign(alertBody);
return true;
}
nsresult nsMsgCompFields::GetUnicodeHeader(MsgHeaderID header, nsAString& aResult)
{
CopyUTF8toUTF16(nsDependentCString(GetAsciiHeader(header)), aResult);
return NS_OK;
}
NS_IMETHODIMP nsMsgCompFields::GetBody(nsAString &_retval)
{
CopyUTF8toUTF16(m_body, _retval);
return NS_OK;
}
// Decode a parameter value using the encoding defined in RFC 5987
//
// charset "'" [ language ] "'" value-chars
NS_IMETHODIMP
nsMIMEHeaderParamImpl::DecodeRFC5987Param(const nsACString& aParamVal,
nsACString& aLang,
nsAString& aResult)
{
nsCAutoString charset;
nsCAutoString language;
nsCAutoString value;
PRUint32 delimiters = 0;
const char *encoded = PromiseFlatCString(aParamVal).get();
const char *c = encoded;
while (*c) {
char tc = *c++;
if (tc == '\'') {
// single quote
delimiters++;
} else if (tc >= 128) {
// fail early, not ASCII
NS_WARNING("non-US-ASCII character in RFC5987-encoded param");
return NS_ERROR_INVALID_ARG;
} else {
if (delimiters == 0) {
// valid characters are checked later implicitly
charset.Append(tc);
} else if (delimiters == 1) {
// no value checking for now
language.Append(tc);
} else if (delimiters == 2) {
if (IsRFC5987AttrChar(tc)) {
value.Append(tc);
} else if (tc == '%') {
if (!IsHexDigit(c[0]) || !IsHexDigit(c[1])) {
// we expect two more characters
NS_WARNING("broken %-escape in RFC5987-encoded param");
return NS_ERROR_INVALID_ARG;
}
value.Append(tc);
// we consume two more
value.Append(*c++);
value.Append(*c++);
} else {
// character not allowed here
NS_WARNING("invalid character in RFC5987-encoded param");
return NS_ERROR_INVALID_ARG;
}
}
}
}
if (delimiters != 2) {
NS_WARNING("missing delimiters in RFC5987-encoded param");
return NS_ERROR_INVALID_ARG;
}
// abort early for unsupported encodings
if (!charset.LowerCaseEqualsLiteral("utf-8")) {
NS_WARNING("unsupported charset in RFC5987-encoded param");
return NS_ERROR_INVALID_ARG;
}
// percent-decode
if (!PercentDecode(value)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// return the encoding
aLang.Assign(language);
// finally convert octet sequence to UTF-8 and be done
nsresult rv = NS_OK;
nsCOMPtr<nsIUTF8ConverterService> cvtUTF8 =
do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString utf8;
rv = cvtUTF8->ConvertStringToUTF8(value, charset.get(), true, false, 1, utf8);
NS_ENSURE_SUCCESS(rv, rv);
CopyUTF8toUTF16(utf8, aResult);
return NS_OK;
}
void
nsMediaDocument::UpdateTitleAndCharset(const nsACString& aTypeStr,
const char* const* aFormatNames,
PRInt32 aWidth, PRInt32 aHeight,
const nsAString& aStatus)
{
nsXPIDLString fileStr;
if (mDocumentURI) {
nsCAutoString fileName;
nsCOMPtr<nsIURL> url = do_QueryInterface(mDocumentURI);
if (url)
url->GetFileName(fileName);
nsCAutoString docCharset;
// Now that the charset is set in |StartDocumentLoad| to the charset of
// the document viewer instead of a bogus value ("ISO-8859-1" set in
// |nsDocument|'s ctor), the priority is given to the current charset.
// This is necessary to deal with a media document being opened in a new
// window or a new tab, in which case |originCharset| of |nsIURI| is not
// reliable.
if (mCharacterSetSource != kCharsetUninitialized) {
docCharset = mCharacterSet;
}
else {
// resort to |originCharset|
mDocumentURI->GetOriginCharset(docCharset);
SetDocumentCharacterSet(docCharset);
}
if (!fileName.IsEmpty()) {
nsresult rv;
nsCOMPtr<nsITextToSubURI> textToSubURI =
do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv))
// UnEscapeURIForUI always succeeds
textToSubURI->UnEscapeURIForUI(docCharset, fileName, fileStr);
else
CopyUTF8toUTF16(fileName, fileStr);
}
}
NS_ConvertASCIItoUTF16 typeStr(aTypeStr);
nsXPIDLString title;
if (mStringBundle) {
// if we got a valid size (not all media have a size)
if (aWidth != 0 && aHeight != 0) {
nsAutoString widthStr;
nsAutoString heightStr;
widthStr.AppendInt(aWidth);
heightStr.AppendInt(aHeight);
// If we got a filename, display it
if (!fileStr.IsEmpty()) {
const PRUnichar *formatStrings[4] = {fileStr.get(), typeStr.get(),
widthStr.get(), heightStr.get()};
NS_ConvertASCIItoUTF16 fmtName(aFormatNames[eWithDimAndFile]);
mStringBundle->FormatStringFromName(fmtName.get(), formatStrings, 4,
getter_Copies(title));
}
else {
const PRUnichar *formatStrings[3] = {typeStr.get(), widthStr.get(),
heightStr.get()};
NS_ConvertASCIItoUTF16 fmtName(aFormatNames[eWithDim]);
mStringBundle->FormatStringFromName(fmtName.get(), formatStrings, 3,
getter_Copies(title));
}
}
else {
// If we got a filename, display it
if (!fileStr.IsEmpty()) {
const PRUnichar *formatStrings[2] = {fileStr.get(), typeStr.get()};
NS_ConvertASCIItoUTF16 fmtName(aFormatNames[eWithFile]);
mStringBundle->FormatStringFromName(fmtName.get(), formatStrings, 2,
getter_Copies(title));
}
else {
const PRUnichar *formatStrings[1] = {typeStr.get()};
NS_ConvertASCIItoUTF16 fmtName(aFormatNames[eWithNoInfo]);
mStringBundle->FormatStringFromName(fmtName.get(), formatStrings, 1,
getter_Copies(title));
}
}
}
// set it on the document
if (aStatus.IsEmpty()) {
SetTitle(title);
}
else {
nsXPIDLString titleWithStatus;
const nsPromiseFlatString& status = PromiseFlatString(aStatus);
const PRUnichar *formatStrings[2] = {title.get(), status.get()};
NS_NAMED_LITERAL_STRING(fmtName, "TitleWithStatus");
mStringBundle->FormatStringFromName(fmtName.get(), formatStrings, 2,
getter_Copies(titleWithStatus));
SetTitle(titleWithStatus);
}
}
NS_IMETHODIMP
nsParserUtils::ParseFragment(const nsAString& aFragment,
PRUint32 aFlags,
bool aIsXML,
nsIURI* aBaseURI,
nsIDOMElement* aContextElement,
nsIDOMDocumentFragment** aReturn)
{
NS_ENSURE_ARG(aContextElement);
*aReturn = nsnull;
nsresult rv;
nsCOMPtr<nsIParser> parser = do_CreateInstance(kCParserCID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIDocument> document;
nsCOMPtr<nsIDOMDocument> domDocument;
nsCOMPtr<nsIDOMNode> contextNode;
contextNode = do_QueryInterface(aContextElement);
contextNode->GetOwnerDocument(getter_AddRefs(domDocument));
document = do_QueryInterface(domDocument);
NS_ENSURE_TRUE(document, NS_ERROR_NOT_AVAILABLE);
// stop scripts
nsRefPtr<nsScriptLoader> loader;
bool scripts_enabled = false;
if (document) {
loader = document->ScriptLoader();
scripts_enabled = loader->GetEnabled();
}
if (scripts_enabled) {
loader->SetEnabled(false);
}
// Wrap things in a div or body for parsing, but it won't show up in
// the fragment.
nsAutoTArray<nsString, 2> tagStack;
nsCAutoString base, spec;
if (aIsXML) {
// XHTML
if (aBaseURI) {
base.Append(NS_LITERAL_CSTRING(XHTML_DIV_TAG));
base.Append(NS_LITERAL_CSTRING(" xml:base=\""));
aBaseURI->GetSpec(spec);
// nsEscapeHTML is good enough, because we only need to get
// quotes, ampersands, and angle brackets
char* escapedSpec = nsEscapeHTML(spec.get());
if (escapedSpec)
base += escapedSpec;
NS_Free(escapedSpec);
base.Append(NS_LITERAL_CSTRING("\""));
tagStack.AppendElement(NS_ConvertUTF8toUTF16(base));
} else {
tagStack.AppendElement(NS_LITERAL_STRING(XHTML_DIV_TAG));
}
}
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIContent> fragment;
if (aIsXML) {
rv = nsContentUtils::ParseFragmentXML(aFragment,
document,
tagStack,
true,
aReturn);
fragment = do_QueryInterface(*aReturn);
} else {
NS_NewDocumentFragment(aReturn,
document->NodeInfoManager());
fragment = do_QueryInterface(*aReturn);
rv = nsContentUtils::ParseFragmentHTML(aFragment,
fragment,
nsGkAtoms::body,
kNameSpaceID_XHTML,
false,
true);
// Now, set the base URI on all subtree roots.
if (aBaseURI) {
aBaseURI->GetSpec(spec);
nsAutoString spec16;
CopyUTF8toUTF16(spec, spec16);
nsIContent* node = fragment->GetFirstChild();
while (node) {
if (node->IsElement()) {
node->SetAttr(kNameSpaceID_XML,
nsGkAtoms::base,
nsGkAtoms::xml,
spec16,
false);
}
node = node->GetNextSibling();
}
}
}
if (fragment) {
nsTreeSanitizer sanitizer(aFlags);
sanitizer.Sanitize(fragment);
}
}
if (scripts_enabled)
loader->SetEnabled(true);
return rv;
}
nsresult
nsExpatDriver::OpenInputStreamFromExternalDTD(const PRUnichar* aFPIStr,
const PRUnichar* aURLStr,
const PRUnichar* aBaseURL,
nsIInputStream** aStream,
nsAString& aAbsURL)
{
nsCOMPtr<nsIURI> baseURI;
nsresult rv = NS_NewURI(getter_AddRefs(baseURI),
NS_ConvertUTF16toUTF8(aBaseURL));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), NS_ConvertUTF16toUTF8(aURLStr), nsnull,
baseURI);
NS_ENSURE_SUCCESS(rv, rv);
// check if it is alright to load this uri
PRBool isChrome = PR_FALSE;
uri->SchemeIs("chrome", &isChrome);
if (!isChrome) {
// since the url is not a chrome url, check to see if we can map the DTD
// to a known local DTD, or if a DTD file of the same name exists in the
// special DTD directory
if (aFPIStr) {
// see if the Formal Public Identifier (FPI) maps to a catalog entry
mCatalogData = LookupCatalogData(aFPIStr);
}
nsCOMPtr<nsIURI> localURI;
GetLocalDTDURI(mCatalogData, uri, getter_AddRefs(localURI));
if (!localURI) {
return NS_ERROR_NOT_IMPLEMENTED;
}
localURI.swap(uri);
}
nsCOMPtr<nsIDocument> doc;
NS_ASSERTION(mSink == nsCOMPtr<nsIExpatSink>(do_QueryInterface(mOriginalSink)),
"In nsExpatDriver::OpenInputStreamFromExternalDTD: "
"mOriginalSink not the same object as mSink?");
if (mOriginalSink)
doc = do_QueryInterface(mOriginalSink->GetTarget());
PRInt16 shouldLoad = nsIContentPolicy::ACCEPT;
rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_DTD,
uri,
(doc ? doc->NodePrincipal() : nsnull),
doc,
EmptyCString(), //mime guess
nsnull, //extra
&shouldLoad);
if (NS_FAILED(rv)) return rv;
if (NS_CP_REJECTED(shouldLoad)) {
// Disallowed by content policy
return NS_ERROR_CONTENT_BLOCKED;
}
nsCAutoString absURL;
uri->GetSpec(absURL);
CopyUTF8toUTF16(absURL, aAbsURL);
nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannel(getter_AddRefs(channel), uri);
NS_ENSURE_SUCCESS(rv, rv);
channel->SetContentType(NS_LITERAL_CSTRING("application/xml"));
return channel->Open(aStream);
}
static int
MimeInlineTextPlainFlowed_parse_line (const char *aLine, PRInt32 length, MimeObject *obj)
{
int status;
PRBool quoting = ( obj->options
&& ( obj->options->format_out == nsMimeOutput::nsMimeMessageQuoting ||
obj->options->format_out == nsMimeOutput::nsMimeMessageBodyQuoting
) ); // see above
PRBool plainHTML = quoting || (obj->options &&
obj->options->format_out == nsMimeOutput::nsMimeMessageSaveAs);
// see above
struct MimeInlineTextPlainFlowedExData *exdata;
exdata = MimeInlineTextPlainFlowedExDataList;
while(exdata && (exdata->ownerobj != obj)) {
exdata = exdata->next;
}
NS_ASSERTION(exdata, "The extra data has disappeared!");
NS_ASSERTION(length > 0, "zero length");
if (length <= 0) return 0;
uint32 linequotelevel = 0;
nsCAutoString real_line(aLine, length);
char *line = real_line.BeginWriting();
const char *linep = real_line.BeginReading();
// Space stuffed?
if(' ' == *linep) {
linep++;
} else {
// count '>':s before the first non-'>'
while('>' == *linep) {
linep++;
linequotelevel++;
}
// Space stuffed?
if(' ' == *linep) {
linep++;
}
}
// Look if the last character (after stripping ending end
// of lines and quoting stuff) is a SPACE. If it is, we are looking at a
// flowed line. Normally we assume that the last two chars
// are CR and LF as said in RFC822, but that doesn't seem to
// be the case always.
PRBool flowed = PR_FALSE;
PRBool sigSeparator = PR_FALSE;
PRInt32 index = length-1;
while(index >= 0 && ('\r' == line[index] || '\n' == line[index])) {
index--;
}
if (index > linep - line && ' ' == line[index])
/* Ignore space stuffing, i.e. lines with just
(quote marks and) a space count as empty */
{
flowed = PR_TRUE;
sigSeparator = (index - (linep - line) + 1 == 3) && !strncmp(linep, "-- ", 3);
if (((MimeInlineTextPlainFlowed *) obj)->delSp && ! sigSeparator)
/* If line is flowed and DelSp=yes, logically
delete trailing space. Line consisting of
dash dash space ("-- "), commonly used as
signature separator, gets special handling
(RFC 3676) */
{
length--;
line[index] = '\0';
}
}
mozITXTToHTMLConv *conv = GetTextConverter(obj->options);
PRBool skipConversion = !conv ||
(obj->options && obj->options->force_user_charset);
nsAutoString lineSource;
nsString lineResult;
char *mailCharset = NULL;
nsresult rv;
if (!skipConversion)
{
// Convert only if the source string is not empty
if (length - (linep - line) > 0)
{
PRBool whattodo = obj->options->whattodo;
if (plainHTML)
{
if (quoting)
whattodo = 0;
else
whattodo = whattodo & ~mozITXTToHTMLConv::kGlyphSubstitution;
/* Do recognition for the case, the result is viewed in
Mozilla, but not GlyphSubstitution, because other UAs
might not be able to display the glyphs. */
}
const nsDependentCSubstring& inputStr = Substring(linep, linep + (length - (linep - line)));
// For 'SaveAs', |line| is in |mailCharset|.
// convert |line| to UTF-16 before 'html'izing (calling ScanTXT())
if (obj->options->format_out == nsMimeOutput::nsMimeMessageSaveAs)
{
// Get the mail charset of this message.
MimeInlineText *inlinetext = (MimeInlineText *) obj;
if (!inlinetext->initializeCharset)
((MimeInlineTextClass*)&mimeInlineTextClass)->initialize_charset(obj);
mailCharset = inlinetext->charset;
if (mailCharset && *mailCharset) {
rv = nsMsgI18NConvertToUnicode(mailCharset, PromiseFlatCString(inputStr), lineSource);
NS_ENSURE_SUCCESS(rv, -1);
}
else // this probably never happens...
CopyUTF8toUTF16(inputStr, lineSource);
}
else // line is in UTF-8
CopyUTF8toUTF16(inputStr, lineSource);
// This is the main TXT to HTML conversion:
// escaping (very important), eventually recognizing etc.
rv = conv->ScanTXT(lineSource.get(), whattodo, getter_Copies(lineResult));
NS_ENSURE_SUCCESS(rv, -1);
}
}
else
{
CopyUTF8toUTF16(nsDependentCString(line, length), lineResult);
status = NS_OK;
}
nsCAutoString preface;
/* Correct number of blockquotes */
int32 quoteleveldiff=linequotelevel - exdata->quotelevel;
if((quoteleveldiff != 0) && flowed && exdata->inflow) {
// From RFC 2646 4.5
// The receiver SHOULD handle this error by using the 'quote-depth-wins' rule,
// which is to ignore the flowed indicator and treat the line as fixed. That
// is, the change in quote depth ends the paragraph.
// We get that behaviour by just going on.
}
while(quoteleveldiff>0) {
quoteleveldiff--;
preface += "<blockquote type=cite";
// This is to have us observe the user pref settings for citations
MimeInlineTextPlainFlowed *tObj = (MimeInlineTextPlainFlowed *) obj;
nsCAutoString style;
MimeTextBuildPrefixCSS(tObj->mQuotedSizeSetting, tObj->mQuotedStyleSetting,
tObj->mCitationColor, style);
if (!plainHTML && !style.IsEmpty())
{
preface += " style=\"";
preface += style;
preface += '"';
}
preface += '>';
}
while(quoteleveldiff<0) {
quoteleveldiff++;
preface += "</blockquote>";
}
exdata->quotelevel = linequotelevel;
nsAutoString lineResult2;
if(flowed) {
// Check RFC 2646 "4.3. Usenet Signature Convention": "-- "+CRLF is
// not a flowed line
if (sigSeparator)
{
if (linequotelevel > 0 || exdata->isSig)
{
preface += "-- <br>";
} else {
exdata->isSig = PR_TRUE;
preface += "<div class=\"moz-txt-sig\"><span class=\"moz-txt-tag\">"
"-- <br></span>";
}
} else {
Line_convert_whitespace(lineResult, PR_FALSE /* Allow wraps */,
lineResult2);
}
exdata->inflow=PR_TRUE;
} else {
// Fixed paragraph.
Line_convert_whitespace(lineResult,
!plainHTML && !obj->options->wrap_long_lines_p
/* If wrap, convert all spaces but the last in
a row into nbsp, otherwise all. */,
lineResult2);
lineResult2.AppendLiteral("<br>");
exdata->inflow = PR_FALSE;
} // End Fixed line
if (!(exdata->isSig && quoting))
{
status = MimeObject_write(obj, preface.get(), preface.Length(), PR_TRUE);
if (status < 0) return status;
nsCAutoString outString;
if (obj->options->format_out != nsMimeOutput::nsMimeMessageSaveAs ||
!mailCharset || !*mailCharset)
CopyUTF16toUTF8(lineResult2, outString);
else
{ // convert back to mailCharset before writing.
rv = nsMsgI18NConvertFromUnicode(mailCharset, lineResult2, outString);
NS_ENSURE_SUCCESS(rv, -1);
}
status = MimeObject_write(obj, outString.get(), outString.Length(), PR_TRUE);
return status;
}
else
return NS_OK;
}
NS_IMETHODIMP
sbStringTransformImpl::NormalizeString(const nsAString & aCharset,
PRUint32 aTransformFlags,
const nsAString & aInput,
nsAString & _retval)
{
nsCString str;
CopyUTF16toUTF8(aInput, str);
if(aTransformFlags & sbIStringTransform::TRANSFORM_LOWERCASE) {
gchar* lowercaseStr = g_utf8_strdown(str.BeginReading(), str.Length());
NS_ENSURE_TRUE(lowercaseStr, NS_ERROR_OUT_OF_MEMORY);
str.Assign(lowercaseStr);
g_free(lowercaseStr);
}
if(aTransformFlags & sbIStringTransform::TRANSFORM_UPPERCASE) {
gchar* uppercaseStr = g_utf8_strup(str.BeginReading(), str.Length());
NS_ENSURE_TRUE(uppercaseStr, NS_ERROR_OUT_OF_MEMORY);
str.Assign(uppercaseStr);
g_free(uppercaseStr);
}
if(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONSPACE) {
nsString workingStr;
PRBool leadingOnly = aTransformFlags &
sbIStringTransform::TRANSFORM_IGNORE_LEADING;
PRBool bypassTest = PR_FALSE;
gchar* nonspaceStr = g_utf8_normalize(str.BeginReading(),
str.Length(),
G_NORMALIZE_ALL);
NS_ENSURE_TRUE(nonspaceStr, NS_ERROR_OUT_OF_MEMORY);
glong strLen = g_utf8_strlen(nonspaceStr, -1);
for(glong currentChar = 0; currentChar < strLen; ++currentChar) {
gchar* offset = g_utf8_offset_to_pointer(nonspaceStr, currentChar);
gunichar unichar = g_utf8_get_char(offset);
GUnicodeType unicharType = g_unichar_type(unichar);
if(bypassTest ||
(unicharType != G_UNICODE_NON_SPACING_MARK &&
unicharType != G_UNICODE_COMBINING_MARK &&
unicharType != G_UNICODE_ENCLOSING_MARK)) {
workingStr += unichar;
if(leadingOnly)
bypassTest = PR_TRUE;
}
}
g_free(nonspaceStr);
CopyUTF16toUTF8(workingStr, str);
}
if(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_SYMBOLS) {
nsString workingStr;
PRBool leadingOnly = aTransformFlags &
sbIStringTransform::TRANSFORM_IGNORE_LEADING;
PRBool bypassTest = PR_FALSE;
gchar* nosymbolsStr = g_utf8_normalize(str.BeginReading(),
str.Length(),
G_NORMALIZE_ALL);
NS_ENSURE_TRUE(nosymbolsStr, NS_ERROR_OUT_OF_MEMORY);
glong strLen = g_utf8_strlen(nosymbolsStr, -1);
for(glong currentChar = 0; currentChar < strLen; ++currentChar) {
gchar* offset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar);
gunichar unichar = g_utf8_get_char(offset);
GUnicodeType unicharType = g_unichar_type(unichar);
if (aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_KEEPNUMBERSYMBOLS) {
PRInt32 numberLength;
SB_ExtractLeadingNumber((const gchar *)offset, NULL, NULL, &numberLength);
if (numberLength > 0) {
for (glong copychar=0;copychar < numberLength;copychar++) {
gchar* copyoffset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar+copychar);
gunichar unichar = g_utf8_get_char(copyoffset);
workingStr += unichar;
}
currentChar += numberLength-1;
if(leadingOnly)
bypassTest = PR_TRUE;
continue;
}
}
if(bypassTest ||
(unicharType != G_UNICODE_CURRENCY_SYMBOL &&
unicharType != G_UNICODE_MODIFIER_SYMBOL &&
unicharType != G_UNICODE_MATH_SYMBOL &&
unicharType != G_UNICODE_OTHER_SYMBOL)) {
workingStr += unichar;
if(leadingOnly)
bypassTest = PR_TRUE;
}
}
g_free(nosymbolsStr);
CopyUTF16toUTF8(workingStr, str);
}
if((aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM) ||
(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM_IGNORE_SPACE)) {
nsString workingStr;
PRBool leadingOnly = aTransformFlags &
sbIStringTransform::TRANSFORM_IGNORE_LEADING;
PRBool bypassTest = PR_FALSE;
gchar* nosymbolsStr = g_utf8_normalize(str.BeginReading(),
str.Length(),
G_NORMALIZE_ALL);
NS_ENSURE_TRUE(nosymbolsStr, NS_ERROR_OUT_OF_MEMORY);
glong strLen = g_utf8_strlen(nosymbolsStr, -1);
for(glong currentChar = 0; currentChar < strLen; ++currentChar) {
gchar* offset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar);
gunichar unichar = g_utf8_get_char(offset);
GUnicodeType unicharType = g_unichar_type(unichar);
if (aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_KEEPNUMBERSYMBOLS) {
PRInt32 numberLength;
SB_ExtractLeadingNumber((const gchar *)offset, NULL, NULL, &numberLength);
if (numberLength > 0) {
for (glong copychar=0;copychar < numberLength;copychar++) {
gchar* copyoffset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar+copychar);
gunichar unichar = g_utf8_get_char(copyoffset);
workingStr += unichar;
}
currentChar += numberLength-1;
if(leadingOnly)
bypassTest = PR_TRUE;
continue;
}
}
if(bypassTest ||
(unicharType == G_UNICODE_LOWERCASE_LETTER ||
unicharType == G_UNICODE_MODIFIER_LETTER ||
unicharType == G_UNICODE_OTHER_LETTER ||
unicharType == G_UNICODE_TITLECASE_LETTER ||
unicharType == G_UNICODE_UPPERCASE_LETTER ||
unicharType == G_UNICODE_DECIMAL_NUMBER ||
unicharType == G_UNICODE_LETTER_NUMBER ||
unicharType == G_UNICODE_OTHER_NUMBER) ||
(!(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM_IGNORE_SPACE) &&
unichar == ' ')) {
workingStr += unichar;
if(leadingOnly)
bypassTest = PR_TRUE;
}
}
g_free(nosymbolsStr);
CopyUTF16toUTF8(workingStr, str);
}
CopyUTF8toUTF16(str, _retval);
return NS_OK;
}
nsresult
nsNetscapeProfileMigratorBase::GetProfileDataFromRegistry(nsILocalFile* aRegistryFile,
nsISupportsArray* aProfileNames,
nsISupportsArray* aProfileLocations)
{
nsresult rv;
REGERR errCode;
// Ensure aRegistryFile exists before open it
PRBool regFileExists = PR_FALSE;
rv = aRegistryFile->Exists(®FileExists);
NS_ENSURE_SUCCESS(rv, rv);
if (!regFileExists)
return NS_ERROR_FILE_NOT_FOUND;
// Open It
nsCAutoString regPath;
rv = aRegistryFile->GetNativePath(regPath);
NS_ENSURE_SUCCESS(rv, rv);
if ((errCode = NR_StartupRegistry()))
return regerr2nsresult(errCode);
HREG reg;
if ((errCode = NR_RegOpen(regPath.get(), ®))) {
NR_ShutdownRegistry();
return regerr2nsresult(errCode);
}
RKEY profilesTree;
if ((errCode = NR_RegGetKey(reg, ROOTKEY_COMMON, "Profiles", &profilesTree))) {
NR_RegClose(reg);
NR_ShutdownRegistry();
return regerr2nsresult(errCode);
}
char profileStr[MAXREGPATHLEN];
REGENUM enumState = nsnull;
while (!NR_RegEnumSubkeys(reg, profilesTree, &enumState, profileStr,
sizeof(profileStr), REGENUM_CHILDREN))
{
RKEY profileKey;
if (NR_RegGetKey(reg, profilesTree, profileStr, &profileKey))
continue;
// "migrated" is "yes" for all valid Seamonkey profiles. It is only "no"
// for 4.x profiles.
char migratedStr[3];
errCode = NR_RegGetEntryString(reg, profileKey, (char *)"migrated",
migratedStr, sizeof(migratedStr));
if ((errCode != REGERR_OK && errCode != REGERR_BUFTOOSMALL) ||
strcmp(migratedStr, "no") == 0)
continue;
// Get the profile location and add it to the locations array
REGINFO regInfo;
regInfo.size = sizeof(REGINFO);
if (NR_RegGetEntryInfo(reg, profileKey, (char *)"directory", ®Info))
continue;
nsCAutoString dirStr;
dirStr.SetLength(regInfo.entryLength);
errCode = NR_RegGetEntryString(reg, profileKey, (char *)"directory",
dirStr.BeginWriting(), regInfo.entryLength);
// Remove trailing \0
dirStr.SetLength(regInfo.entryLength-1);
nsCOMPtr<nsILocalFile> dir;
#ifdef XP_MACOSX
rv = NS_NewNativeLocalFile(EmptyCString(), PR_TRUE, getter_AddRefs(dir));
if (NS_FAILED(rv)) break;
dir->SetPersistentDescriptor(dirStr);
#else
rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(dirStr), PR_TRUE,
getter_AddRefs(dir));
if (NS_FAILED(rv)) break;
#endif
PRBool exists;
dir->Exists(&exists);
if (exists) {
aProfileLocations->AppendElement(dir);
// Get the profile name and add it to the names array
nsString profileName;
CopyUTF8toUTF16(nsDependentCString(profileStr), profileName);
nsCOMPtr<nsISupportsString> profileNameString(
do_CreateInstance("@mozilla.org/supports-string;1"));
profileNameString->SetData(profileName);
aProfileNames->AppendElement(profileNameString);
}
}
NR_RegClose(reg);
NR_ShutdownRegistry();
return rv;
}
nsresult
nsOperaProfileMigrator::ParseBookmarksFolder(nsILineInputStream* aStream,
PRInt64 aParent,
PRInt64 aToolbar,
nsINavBookmarksService* aBMS)
{
nsresult rv;
PRBool moreData = PR_FALSE;
nsAutoString buffer;
EntryType entryType = EntryType_BOOKMARK;
nsAutoString keyword, description;
nsCAutoString url, name;
PRBool onToolbar = PR_FALSE;
do {
nsCAutoString cBuffer;
rv = aStream->ReadLine(cBuffer, &moreData);
if (NS_FAILED(rv)) return rv;
CopyUTF8toUTF16(cBuffer, buffer);
nsString data;
LineType type = GetLineType(buffer, getter_Copies(data));
switch(type) {
case LineType_FOLDER:
entryType = EntryType_FOLDER;
break;
case LineType_BOOKMARK:
entryType = EntryType_BOOKMARK;
break;
case LineType_SEPARATOR:
// If we're here, we need to break out of the loop for the current folder,
// essentially terminating this instance of ParseBookmarksFolder and return
// to the calling function, which is either ParseBookmarksFolder for a parent
// folder, or CopyBookmarks (which means we're done parsing all bookmarks).
goto done;
case LineType_NAME:
name.Assign(NS_ConvertUTF16toUTF8(data));
break;
case LineType_URL:
url.Assign(NS_ConvertUTF16toUTF8(data));
break;
case LineType_KEYWORD:
keyword = data;
break;
case LineType_DESCRIPTION:
description = data;
break;
case LineType_ONTOOLBAR:
if (NS_LITERAL_STRING("YES").Equals(data))
onToolbar = PR_TRUE;
break;
case LineType_NL: {
// XXX We don't know for sure how Opera deals with IDN hostnames in URL.
// Assuming it's in UTF-8 is rather safe because it covers two cases
// (UTF-8 and ASCII) out of three cases (the last is a non-UTF-8
// multibyte encoding).
// XXX Todo: |description| is not saved.
if (entryType == EntryType_BOOKMARK) {
if (!name.IsEmpty() && !url.IsEmpty()) {
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), url);
if (NS_FAILED(rv))
continue;
PRInt64 id;
rv = aBMS->InsertBookmark(onToolbar ? aToolbar : aParent,
uri, nsINavBookmarksService::DEFAULT_INDEX,
name, &id);
if (NS_FAILED(rv))
continue;
name.Truncate();
url.Truncate();
keyword.Truncate();
description.Truncate();
onToolbar = PR_FALSE;
}
}
else if (entryType == EntryType_FOLDER) {
if (!name.IsEmpty()) {
PRInt64 newFolder;
rv = aBMS->CreateFolder(onToolbar ? aToolbar : aParent,
name, nsINavBookmarksService::DEFAULT_INDEX, &newFolder);
if (NS_FAILED(rv))
continue;
rv = ParseBookmarksFolder(aStream, newFolder, aToolbar, aBMS);
name.Truncate();
}
}
break;
}
case LineType_OTHER:
break;
}
}
while (moreData);
done:
return rv;
}
nsresult
nsDownloadScanner::Scan::Start()
{
mStartTime = PR_Now();
mThread = (HANDLE)_beginthreadex(NULL, 0, ScannerThreadFunction,
this, CREATE_SUSPENDED, NULL);
if (!mThread)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = NS_OK;
// Default is to try to clean downloads
mIsReadOnlyRequest = PR_FALSE;
nsCOMPtr<nsIPrefBranch> pref =
do_GetService(NS_PREFSERVICE_CONTRACTID);
if (pref)
rv = pref->GetBoolPref(PREF_BDA_DONTCLEAN, &mIsReadOnlyRequest);
// Get the path to the file on disk
nsCOMPtr<nsILocalFile> file;
rv = mDownload->GetTargetFile(getter_AddRefs(file));
NS_ENSURE_SUCCESS(rv, rv);
rv = file->GetPath(mPath);
NS_ENSURE_SUCCESS(rv, rv);
// Grab the app name
nsCOMPtr<nsIXULAppInfo> appinfo =
do_GetService(XULAPPINFO_SERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString name;
rv = appinfo->GetName(name);
NS_ENSURE_SUCCESS(rv, rv);
CopyUTF8toUTF16(name, mName);
// Get the origin
nsCOMPtr<nsIURI> uri;
rv = mDownload->GetSource(getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString origin;
rv = uri->GetSpec(origin);
NS_ENSURE_SUCCESS(rv, rv);
CopyUTF8toUTF16(origin, mOrigin);
// We count https/ftp/http as an http download
PRBool isHttp(PR_FALSE), isFtp(PR_FALSE), isHttps(PR_FALSE);
nsCOMPtr<nsIURI> innerURI = NS_GetInnermostURI(uri);
if (!innerURI) innerURI = uri;
(void)innerURI->SchemeIs("http", &isHttp);
(void)innerURI->SchemeIs("ftp", &isFtp);
(void)innerURI->SchemeIs("https", &isHttps);
mIsHttpDownload = isHttp || isFtp || isHttps;
// IAttachementExecute prohibits src data: schemes by default but we
// support them. Mark the download if it's a data scheme, so we
// can skip off supplying the src to IAttachementExecute when we scan
// the resulting file.
(void)innerURI->SchemeIs("data", &mSkipSource);
// ResumeThread returns the previous suspend count
if (1 != ::ResumeThread(mThread)) {
CloseHandle(mThread);
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
HRESULT
nsScriptablePeer::ConvertVariants(nsIVariant *aIn, VARIANT *aOut)
{
if (aIn == NULL || aOut == NULL)
{
return NS_ERROR_INVALID_ARG;
}
PRBool isWritable = PR_FALSE;
nsCOMPtr<nsIWritableVariant> writable = do_QueryInterface(aIn);
if (writable)
{
writable->GetWritable(&isWritable);
}
PRUint16 type;
nsresult rv = aIn->GetDataType(&type);
switch (type)
{
case nsIDataType::VTYPE_INT8:
{
PRUint8 value = 0;
rv = aIn->GetAsInt8(&value);
aOut->vt = VT_I1;
aOut->cVal = value;
}
break;
case nsIDataType::VTYPE_INT16:
{
PRInt16 value = 0;
rv = aIn->GetAsInt16(&value);
aOut->vt = VT_I2;
aOut->iVal = value;
}
break;
case nsIDataType::VTYPE_INT32:
{
PRInt32 value = 0;
rv = aIn->GetAsInt32(&value);
aOut->vt = VT_I4;
aOut->lVal = value;
}
break;
case nsIDataType::VTYPE_CHAR:
case nsIDataType::VTYPE_UINT8:
{
PRUint8 value = 0;
rv = aIn->GetAsInt8(&value);
aOut->vt = VT_UI1;
aOut->bVal = value;
}
break;
case nsIDataType::VTYPE_WCHAR:
case nsIDataType::VTYPE_UINT16:
{
PRUint16 value = 0;
rv = aIn->GetAsUint16(&value);
aOut->vt = VT_I2;
aOut->uiVal = value;
}
break;
case nsIDataType::VTYPE_UINT32:
{
PRUint32 value = 0;
rv = aIn->GetAsUint32(&value);
aOut->vt = VT_I4;
aOut->ulVal = value;
}
break;
case nsIDataType::VTYPE_FLOAT:
{
float value = 0;
rv = aIn->GetAsFloat(&value);
aOut->vt = VT_R4;
aOut->fltVal = value;
}
break;
case nsIDataType::VTYPE_DOUBLE:
{
double value = 0;
rv = aIn->GetAsDouble(&value);
aOut->vt = VT_R4;
aOut->dblVal = value;
}
break;
case nsIDataType::VTYPE_BOOL:
{
PRBool value = 0;
rv = aIn->GetAsBool(&value);
aOut->vt = VT_BOOL;
aOut->dblVal = value ? VARIANT_TRUE : VARIANT_FALSE;
}
break;
case nsIDataType::VTYPE_EMPTY:
VariantClear(aOut);
break;
case nsIDataType::VTYPE_STRING_SIZE_IS:
case nsIDataType::VTYPE_CHAR_STR:
{
nsCString value;
aIn->GetAsString(getter_Copies(value));
nsString valueWide;
NS_CStringToUTF16(value, NS_CSTRING_ENCODING_ASCII, valueWide);
aOut->vt = VT_BSTR;
aOut->bstrVal = SysAllocString(valueWide.get());
}
break;
case nsIDataType::VTYPE_WSTRING_SIZE_IS:
case nsIDataType::VTYPE_WCHAR_STR:
{
nsString value;
aIn->GetAsWString(getter_Copies(value));
aOut->vt = VT_BSTR;
aOut->bstrVal = SysAllocString(value.get());
}
break;
case nsIDataType::VTYPE_ASTRING:
{
nsAutoString value;
aIn->GetAsAString(value);
aOut->vt = VT_BSTR;
aOut->bstrVal = SysAllocString(value.get());
}
break;
case nsIDataType::VTYPE_DOMSTRING:
{
nsAutoString value;
aIn->GetAsAString(value);
aOut->vt = VT_BSTR;
aOut->bstrVal = SysAllocString(value.get());
}
break;
case nsIDataType::VTYPE_CSTRING:
{
nsCAutoString value;
aIn->GetAsACString(value);
nsAutoString valueWide;
NS_CStringToUTF16(value, NS_CSTRING_ENCODING_ASCII, valueWide);
aOut->vt = VT_BSTR;
aOut->bstrVal = SysAllocString(valueWide.get());
}
break;
case nsIDataType::VTYPE_UTF8STRING:
{
nsCAutoString value;
aIn->GetAsAUTF8String(value);
nsAutoString valueWide;
CopyUTF8toUTF16(value, valueWide);
aOut->vt = VT_BSTR;
aOut->bstrVal = SysAllocString(valueWide.get());
}
// Unsupported types
default:
case nsIDataType::VTYPE_INT64:
case nsIDataType::VTYPE_UINT64:
case nsIDataType::VTYPE_VOID:
case nsIDataType::VTYPE_ID:
case nsIDataType::VTYPE_INTERFACE:
case nsIDataType::VTYPE_INTERFACE_IS:
case nsIDataType::VTYPE_ARRAY:
case nsIDataType::VTYPE_EMPTY_ARRAY:
return E_INVALIDARG;
}
return S_OK;
}
nsresult
nsXULContentUtils::GetTextForNode(nsIRDFNode* aNode, nsAString& aResult)
{
if (! aNode) {
aResult.Truncate();
return NS_OK;
}
nsresult rv;
// Literals are the most common, so try these first.
nsCOMPtr<nsIRDFLiteral> literal = do_QueryInterface(aNode);
if (literal) {
const PRUnichar* p;
rv = literal->GetValueConst(&p);
if (NS_FAILED(rv)) return rv;
aResult = p;
return NS_OK;
}
nsCOMPtr<nsIRDFDate> dateLiteral = do_QueryInterface(aNode);
if (dateLiteral) {
PRInt64 value;
rv = dateLiteral->GetValue(&value);
if (NS_FAILED(rv)) return rv;
nsAutoString str;
rv = gFormat->FormatPRTime(nsnull /* nsILocale* locale */,
kDateFormatShort,
kTimeFormatSeconds,
PRTime(value),
str);
aResult.Assign(str);
if (NS_FAILED(rv)) return rv;
return NS_OK;
}
nsCOMPtr<nsIRDFInt> intLiteral = do_QueryInterface(aNode);
if (intLiteral) {
PRInt32 value;
rv = intLiteral->GetValue(&value);
if (NS_FAILED(rv)) return rv;
aResult.Truncate();
nsAutoString intStr;
intStr.AppendInt(value, 10);
aResult.Append(intStr);
return NS_OK;
}
nsCOMPtr<nsIRDFResource> resource = do_QueryInterface(aNode);
if (resource) {
const char* p;
rv = resource->GetValueConst(&p);
if (NS_FAILED(rv)) return rv;
CopyUTF8toUTF16(p, aResult);
return NS_OK;
}
NS_ERROR("not a resource or a literal");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsMacShellService::SetDesktopBackground(nsIDOMElement* aElement,
int32_t aPosition)
{
// Note: We don't support aPosition on OS X.
// Get the image URI:
nsresult rv;
nsCOMPtr<nsIImageLoadingContent> imageContent = do_QueryInterface(aElement,
&rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIURI> imageURI;
rv = imageContent->GetCurrentURI(getter_AddRefs(imageURI));
NS_ENSURE_SUCCESS(rv, rv);
// We need the referer URI for nsIWebBrowserPersist::saveURI
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsIURI *docURI = content->OwnerDoc()->GetDocumentURI();
if (!docURI)
return NS_ERROR_FAILURE;
// Get the desired image file name
nsCOMPtr<nsIURL> imageURL(do_QueryInterface(imageURI));
if (!imageURL) {
// XXXmano (bug 300293): Non-URL images (e.g. the data: protocol) are not
// yet supported. What filename should we take here?
return NS_ERROR_NOT_IMPLEMENTED;
}
nsAutoCString fileName;
imageURL->GetFileName(fileName);
nsCOMPtr<nsIProperties> fileLocator
(do_GetService("@mozilla.org/file/directory_service;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
// Get the current user's "Pictures" folder (That's ~/Pictures):
fileLocator->Get(NS_OSX_PICTURE_DOCUMENTS_DIR, NS_GET_IID(nsIFile),
getter_AddRefs(mBackgroundFile));
if (!mBackgroundFile)
return NS_ERROR_OUT_OF_MEMORY;
nsAutoString fileNameUnicode;
CopyUTF8toUTF16(fileName, fileNameUnicode);
// and add the imgage file name itself:
mBackgroundFile->Append(fileNameUnicode);
// Download the image; the desktop background will be set in OnStateChange()
nsCOMPtr<nsIWebBrowserPersist> wbp
(do_CreateInstance("@mozilla.org/embedding/browser/nsWebBrowserPersist;1", &rv));
NS_ENSURE_SUCCESS(rv, rv);
uint32_t flags = nsIWebBrowserPersist::PERSIST_FLAGS_NO_CONVERSION |
nsIWebBrowserPersist::PERSIST_FLAGS_REPLACE_EXISTING_FILES |
nsIWebBrowserPersist::PERSIST_FLAGS_FROM_CACHE;
wbp->SetPersistFlags(flags);
wbp->SetProgressListener(this);
nsCOMPtr<nsILoadContext> loadContext;
nsCOMPtr<nsISupports> container = content->OwnerDoc()->GetContainer();
nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(container);
if (docShell) {
loadContext = do_QueryInterface(docShell);
}
return wbp->SaveURI(imageURI, nullptr,
docURI, content->OwnerDoc()->GetReferrerPolicy(),
nullptr, nullptr,
mBackgroundFile, loadContext);
}
void
nsReferencedElement::Reset(nsIContent* aFromContent, nsIURI* aURI, PRBool aWatch)
{
Unlink();
nsCOMPtr<nsIURL> url = do_QueryInterface(aURI);
if (!url)
return;
nsCAutoString refPart;
url->GetRef(refPart);
// Unescape %-escapes in the reference. The result will be in the
// origin charset of the URL, hopefully...
NS_UnescapeURL(refPart);
nsCAutoString charset;
url->GetOriginCharset(charset);
nsAutoString ref;
nsresult rv = nsContentUtils::ConvertStringFromCharset(charset, refPart, ref);
if (NS_FAILED(rv)) {
CopyUTF8toUTF16(refPart, ref);
}
if (ref.IsEmpty())
return;
// Get the current document
nsIDocument *doc = aFromContent->GetCurrentDoc();
if (!doc)
return;
// This will be the URI of the document the content belongs to
// (the URI of the XBL document if the content is anonymous
// XBL content)
nsCOMPtr<nsIURL> documentURL = do_QueryInterface(doc->GetDocumentURI());
nsIContent* bindingParent = aFromContent->GetBindingParent();
PRBool isXBL = PR_FALSE;
if (bindingParent) {
nsXBLBinding* binding = doc->BindingManager()->GetBinding(bindingParent);
if (binding) {
// XXX sXBL/XBL2 issue
// If this is an anonymous XBL element then the URI is
// relative to the binding document. A full fix requires a
// proper XBL2 implementation but for now URIs that are
// relative to the binding document should be resolve to the
// copy of the target element that has been inserted into the
// bound document.
documentURL = do_QueryInterface(binding->PrototypeBinding()->DocURI());
isXBL = PR_TRUE;
}
}
if (!documentURL)
return;
if (!EqualExceptRef(url, documentURL)) {
// Don't take the XBL codepath here, since we'll want to just
// normally set up our external resource document and then watch
// it as needed.
isXBL = PR_FALSE;
nsRefPtr<nsIDocument::ExternalResourceLoad> load;
doc = doc->RequestExternalResource(url, aFromContent, getter_AddRefs(load));
if (!doc) {
if (!load || !aWatch) {
// Nothing will ever happen here
return;
}
DocumentLoadNotification* observer =
new DocumentLoadNotification(this, ref);
mPendingNotification = observer;
if (observer) {
load->AddObserver(observer);
}
// Keep going so we set up our watching stuff a bit
}
}
// Get the element
if (isXBL) {
nsCOMPtr<nsIDOMNodeList> anonymousChildren;
doc->BindingManager()->
GetAnonymousNodesFor(bindingParent, getter_AddRefs(anonymousChildren));
if (anonymousChildren) {
PRUint32 length;
anonymousChildren->GetLength(&length);
for (PRUint32 i = 0; i < length && !mContent; ++i) {
nsCOMPtr<nsIDOMNode> node;
anonymousChildren->Item(i, getter_AddRefs(node));
nsCOMPtr<nsIContent> c = do_QueryInterface(node);
if (c) {
mContent = nsContentUtils::MatchElementId(c, ref);
}
}
}
// We don't have watching working yet for XBL, so bail out here.
return;
}
if (aWatch) {
nsCOMPtr<nsIAtom> atom = do_GetAtom(ref);
if (!atom)
return;
atom.swap(mWatchID);
}
HaveNewDocument(doc, aWatch, ref);
}