nsresult
nsJARInputStream::InitDirectory(nsZipArchive* aZip,
const nsACString& aJarDirSpec,
const char* aDir)
{
NS_ENSURE_ARG_POINTER(aZip);
NS_ENSURE_ARG_POINTER(aDir);
// Mark it as closed, in case something fails in initialisation
mClosed = PR_TRUE;
mDirectory = PR_TRUE;
// Keep the zipReader for getting the actual zipItems
mZip = aZip;
nsZipFind *find;
nsresult rv;
// We can get aDir's contents as strings via FindEntries
// with the following pattern (see nsIZipReader.findEntries docs)
// assuming dirName is properly escaped:
//
// dirName + "?*~" + dirName + "?*/?*"
nsDependentCString dirName(aDir);
mNameLen = dirName.Length();
// iterate through dirName and copy it to escDirName, escaping chars
// which are special at the "top" level of the regexp so FindEntries
// works correctly
nsCAutoString escDirName;
const char* curr = dirName.BeginReading();
const char* end = dirName.EndReading();
while (curr != end) {
switch (*curr) {
case '*':
case '?':
case '$':
case '[':
case ']':
case '^':
case '~':
case '(':
case ')':
case '\\':
escDirName.Append('\\');
// fall through
default:
escDirName.Append(*curr);
}
++curr;
}
nsCAutoString pattern = escDirName + NS_LITERAL_CSTRING("?*~") +
escDirName + NS_LITERAL_CSTRING("?*/?*");
rv = aZip->FindInit(pattern.get(), &find);
if (NS_FAILED(rv)) return rv;
const char *name;
while ((rv = find->FindNext( &name )) == NS_OK) {
// No need to copy string, just share the one from nsZipArchive
mArray.AppendCString(nsDependentCString(name));
}
delete find;
if (rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST && NS_FAILED(rv)) {
return NS_ERROR_FAILURE; // no error translation
}
// Sort it
mArray.Sort();
mBuffer.AssignLiteral("300: ");
mBuffer.Append(aJarDirSpec);
mBuffer.AppendLiteral("\n200: filename content-length last-modified file-type\n");
// Open for reading
mClosed = PR_FALSE;
mCurPos = 0;
mArrPos = 0;
return NS_OK;
}
NS_IMETHODIMP
nsFileProtocolHandler::GetURLSpecFromDir(nsIFile *file, nsACString &result)
{
NS_ENSURE_ARG_POINTER(file);
return net_GetURLSpecFromDir(file, result);
}
NS_IMETHODIMP nsPop3Sink::GetFolder(nsIMsgFolder **aFolder)
{
NS_ENSURE_ARG_POINTER(aFolder);
NS_IF_ADDREF(*aFolder = m_folder);
return NS_OK;
}
/*
This method handles finding in a single window (aka frame).
*/
nsresult nsWebBrowserFind::SearchInFrame(nsIDOMWindow* aWindow,
bool aWrapping,
bool* aDidFind)
{
NS_ENSURE_ARG(aWindow);
NS_ENSURE_ARG_POINTER(aDidFind);
*aDidFind = false;
nsCOMPtr<nsIDOMDocument> domDoc;
nsresult rv = aWindow->GetDocument(getter_AddRefs(domDoc));
NS_ENSURE_SUCCESS(rv, rv);
if (!domDoc) return NS_ERROR_FAILURE;
// Do security check, to ensure that the frame we're searching is
// acccessible from the frame where the Find is being run.
// get a uri for the window
nsCOMPtr<nsIDocument> theDoc = do_QueryInterface(domDoc);
if (!theDoc) return NS_ERROR_FAILURE;
nsCOMPtr<nsIScriptSecurityManager> secMan =
do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIPrincipal> subject;
rv = secMan->GetSubjectPrincipal(getter_AddRefs(subject));
NS_ENSURE_SUCCESS(rv, rv);
if (subject) {
bool subsumes;
rv = subject->Subsumes(theDoc->NodePrincipal(), &subsumes);
NS_ENSURE_SUCCESS(rv, rv);
if (!subsumes) {
return NS_ERROR_DOM_PROP_ACCESS_DENIED;
}
}
nsCOMPtr<nsIFind> find = do_CreateInstance(NS_FIND_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
(void) find->SetCaseSensitive(mMatchCase);
(void) find->SetFindBackwards(mFindBackwards);
// XXX Make and set a line breaker here, once that's implemented.
(void) find->SetWordBreaker(0);
// Now make sure the content (for actual finding) and frame (for
// selection) models are up to date.
theDoc->FlushPendingNotifications(Flush_Frames);
nsCOMPtr<nsISelection> sel;
GetFrameSelection(aWindow, getter_AddRefs(sel));
NS_ENSURE_ARG_POINTER(sel);
nsCOMPtr<nsIDOMRange> searchRange = nsFind::CreateRange();
NS_ENSURE_ARG_POINTER(searchRange);
nsCOMPtr<nsIDOMRange> startPt = nsFind::CreateRange();
NS_ENSURE_ARG_POINTER(startPt);
nsCOMPtr<nsIDOMRange> endPt = nsFind::CreateRange();
NS_ENSURE_ARG_POINTER(endPt);
nsCOMPtr<nsIDOMRange> foundRange;
// If !aWrapping, search from selection to end
if (!aWrapping)
rv = GetSearchLimits(searchRange, startPt, endPt, domDoc, sel,
false);
// If aWrapping, search the part of the starting frame
// up to the point where we left off.
else
rv = GetSearchLimits(searchRange, startPt, endPt, domDoc, sel,
true);
NS_ENSURE_SUCCESS(rv, rv);
rv = find->Find(mSearchString.get(), searchRange, startPt, endPt,
getter_AddRefs(foundRange));
if (NS_SUCCEEDED(rv) && foundRange)
{
*aDidFind = true;
sel->RemoveAllRanges();
// Beware! This may flush notifications via synchronous
// ScrollSelectionIntoView.
SetSelectionAndScroll(aWindow, foundRange);
}
return rv;
}
NS_IMETHODIMP
nsFilePicker::Show(PRInt16 *aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
nsXPIDLCString title;
title.Adopt(ToNewUTF8String(mTitle));
GtkWindow *parent_widget = get_gtk_window_for_nsiwidget(mParentWidget);
GtkFileChooserAction action = GetGtkFileChooserAction(mMode);
const gchar *accept_button = (mMode == GTK_FILE_CHOOSER_ACTION_SAVE)
? GTK_STOCK_SAVE : GTK_STOCK_OPEN;
GtkWidget *file_chooser =
_gtk_file_chooser_dialog_new(title, parent_widget, action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
accept_button, GTK_RESPONSE_ACCEPT,
NULL);
if (parent_widget && parent_widget->group) {
gtk_window_group_add_window(parent_widget->group, GTK_WINDOW(file_chooser));
}
if (mMode == nsIFilePicker::modeOpenMultiple) {
_gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(file_chooser), TRUE);
} else if (mMode == nsIFilePicker::modeSave) {
char *default_filename = ToNewUTF8String(mDefault);
_gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser),
NS_STATIC_CAST(const gchar*, default_filename));
nsMemory::Free(default_filename);
}
gtk_dialog_set_default_response(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT);
nsCAutoString directory;
if (mDisplayDirectory) {
mDisplayDirectory->GetNativePath(directory);
} else if (mPrevDisplayDirectory) {
mPrevDisplayDirectory->GetNativePath(directory);
}
if (!directory.IsEmpty()) {
_gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser),
directory.get());
}
PRInt32 count = mFilters.Count();
for (PRInt32 i = 0; i < count; ++i) {
// This is fun... the GTK file picker does not accept a list of filters
// so we need to split out each string, and add it manually.
char **patterns = g_strsplit(mFilters[i]->get(), ";", -1);
if (!patterns) {
return NS_ERROR_OUT_OF_MEMORY;
}
GtkFileFilter *filter = _gtk_file_filter_new ();
for (int j = 0; patterns[j] != NULL; ++j) {
_gtk_file_filter_add_pattern (filter, g_strstrip (patterns[j]));
}
g_strfreev(patterns);
if (!mFilterNames[i]->IsEmpty()) {
// If we have a name for our filter, let's use that.
const char *filter_name = mFilterNames[i]->get();
_gtk_file_filter_set_name (filter, filter_name);
} else {
// If we don't have a name, let's just use the filter pattern.
const char *filter_pattern = mFilters[i]->get();
_gtk_file_filter_set_name (filter, filter_pattern);
}
_gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), filter);
// Set the initially selected filter
if (mSelectedType == i) {
_gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(file_chooser), filter);
}
}
PRBool checkForOverwrite = PR_TRUE;
if (_gtk_file_chooser_set_do_overwrite_confirmation) {
checkForOverwrite = PR_FALSE;
// Only available in GTK 2.8
_gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), PR_TRUE);
}
gint response = gtk_dialog_run (GTK_DIALOG (file_chooser));
switch (response) {
case GTK_RESPONSE_ACCEPT:
ReadValuesFromFileChooser(file_chooser);
*aReturn = nsIFilePicker::returnOK;
if (mMode == nsIFilePicker::modeSave) {
nsCOMPtr<nsILocalFile> file;
GetFile(getter_AddRefs(file));
if (file) {
PRBool exists = PR_FALSE;
file->Exists(&exists);
if (exists) {
PRBool overwrite = !checkForOverwrite ||
confirm_overwrite_file (file_chooser, file);
if (overwrite) {
*aReturn = nsIFilePicker::returnReplace;
} else {
*aReturn = nsIFilePicker::returnCancel;
}
}
}
}
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_CLOSE:
case GTK_RESPONSE_DELETE_EVENT:
*aReturn = nsIFilePicker::returnCancel;
break;
default:
NS_WARNING("Unexpected response");
*aReturn = nsIFilePicker::returnCancel;
break;
}
gtk_widget_destroy(file_chooser);
return NS_OK;
}
/* attribute boolean entireWord; */
NS_IMETHODIMP nsWebBrowserFind::GetEntireWord(bool *aEntireWord)
{
NS_ENSURE_ARG_POINTER(aEntireWord);
*aEntireWord = mEntireWord;
return NS_OK;
}
// Set the range to go from the end of the current selection to the
// end of the document (forward), or beginning to beginning (reverse).
// or around the whole document if there's no selection.
nsresult
nsWebBrowserFind::GetSearchLimits(nsIDOMRange* aSearchRange,
nsIDOMRange* aStartPt,
nsIDOMRange* aEndPt,
nsIDOMDocument* aDoc,
nsISelection* aSel,
bool aWrap)
{
NS_ENSURE_ARG_POINTER(aSel);
// There is a selection.
int32_t count = -1;
nsresult rv = aSel->GetRangeCount(&count);
NS_ENSURE_SUCCESS(rv, rv);
if (count < 1)
return SetRangeAroundDocument(aSearchRange, aStartPt, aEndPt, aDoc);
// Need bodyNode, for the start/end of the document
nsCOMPtr<nsIDOMNode> bodyNode;
rv = GetRootNode(aDoc, getter_AddRefs(bodyNode));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIContent> bodyContent (do_QueryInterface(bodyNode));
NS_ENSURE_ARG_POINTER(bodyContent);
uint32_t childCount = bodyContent->GetChildCount();
// There are four possible range endpoints we might use:
// DocumentStart, SelectionStart, SelectionEnd, DocumentEnd.
nsCOMPtr<nsIDOMRange> range;
nsCOMPtr<nsIDOMNode> node;
int32_t offset;
// Forward, not wrapping: SelEnd to DocEnd
if (!mFindBackwards && !aWrap)
{
// This isn't quite right, since the selection's ranges aren't
// necessarily in order; but they usually will be.
aSel->GetRangeAt(count-1, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetEndContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetEndOffset(&offset);
aSearchRange->SetStart(node, offset);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(node, offset);
aStartPt->SetEnd(node, offset);
aEndPt->SetStart(bodyNode, childCount);
aEndPt->SetEnd(bodyNode, childCount);
}
// Backward, not wrapping: DocStart to SelStart
else if (mFindBackwards && !aWrap)
{
aSel->GetRangeAt(0, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetStartContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetStartOffset(&offset);
aSearchRange->SetStart(bodyNode, 0);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(node, offset);
aStartPt->SetEnd(node, offset);
aEndPt->SetStart(bodyNode, 0);
aEndPt->SetEnd(bodyNode, 0);
}
// Forward, wrapping: DocStart to SelEnd
else if (!mFindBackwards && aWrap)
{
aSel->GetRangeAt(count-1, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetEndContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetEndOffset(&offset);
aSearchRange->SetStart(bodyNode, 0);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(bodyNode, 0);
aStartPt->SetEnd(bodyNode, 0);
aEndPt->SetStart(node, offset);
aEndPt->SetEnd(node, offset);
}
// Backward, wrapping: SelStart to DocEnd
else if (mFindBackwards && aWrap)
{
aSel->GetRangeAt(0, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetStartContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetStartOffset(&offset);
aSearchRange->SetStart(bodyNode, 0);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(bodyNode, childCount);
aStartPt->SetEnd(bodyNode, childCount);
aEndPt->SetStart(node, offset);
aEndPt->SetEnd(node, offset);
}
return NS_OK;
}
nsresult PLUG_NewPluginNativeWindow(nsPluginNativeWindow ** aPluginNativeWindow)
{
NS_ENSURE_ARG_POINTER(aPluginNativeWindow);
*aPluginNativeWindow = new nsPluginNativeWindowGtk();
return *aPluginNativeWindow ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP
nsXMLDocument::Load(const nsAString& aUrl, bool *aReturn)
{
bool hasHadScriptObject = true;
nsIScriptGlobalObject* scriptObject =
GetScriptHandlingObject(hasHadScriptObject);
NS_ENSURE_STATE(scriptObject || !hasHadScriptObject);
ReportUseOfDeprecatedMethod(this, "UseOfDOM3LoadMethodWarning");
NS_ENSURE_ARG_POINTER(aReturn);
*aReturn = false;
nsCOMPtr<nsIDocument> callingDoc =
do_QueryInterface(nsContentUtils::GetDocumentFromContext());
nsIURI *baseURI = mDocumentURI;
nsCAutoString charset;
if (callingDoc) {
baseURI = callingDoc->GetDocBaseURI();
charset = callingDoc->GetDocumentCharacterSet();
}
// Create a new URI
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_NewURI(getter_AddRefs(uri), aUrl, charset.get(), baseURI);
if (NS_FAILED(rv)) {
return rv;
}
// Check to see whether the current document is allowed to load this URI.
// It's important to use the current document's principal for this check so
// that we don't end up in a case where code with elevated privileges is
// calling us and changing the principal of this document.
// Enforce same-origin even for chrome loaders to avoid someone accidentally
// using a document that content has a reference to and turn that into a
// chrome document.
nsCOMPtr<nsIPrincipal> principal = NodePrincipal();
if (!nsContentUtils::IsSystemPrincipal(principal)) {
rv = principal->CheckMayLoad(uri, false, false);
NS_ENSURE_SUCCESS(rv, rv);
int16_t shouldLoad = nsIContentPolicy::ACCEPT;
rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_XMLHTTPREQUEST,
uri,
principal,
callingDoc ? callingDoc.get() :
static_cast<nsIDocument*>(this),
NS_LITERAL_CSTRING("application/xml"),
nullptr,
&shouldLoad,
nsContentUtils::GetContentPolicy(),
nsContentUtils::GetSecurityManager());
NS_ENSURE_SUCCESS(rv, rv);
if (NS_CP_REJECTED(shouldLoad)) {
return NS_ERROR_CONTENT_BLOCKED;
}
} else {
// We're called from chrome, check to make sure the URI we're
// about to load is also chrome.
bool isChrome = false;
if (NS_FAILED(uri->SchemeIs("chrome", &isChrome)) || !isChrome) {
nsCAutoString spec;
if (mDocumentURI)
mDocumentURI->GetSpec(spec);
nsAutoString error;
error.AssignLiteral("Cross site loading using document.load is no "
"longer supported. Use XMLHttpRequest instead.");
nsCOMPtr<nsIScriptError> errorObject =
do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = errorObject->InitWithWindowID(error.get(), NS_ConvertUTF8toUTF16(spec).get(),
nullptr, 0, 0, nsIScriptError::warningFlag,
"DOM",
callingDoc ?
callingDoc->InnerWindowID() :
this->InnerWindowID());
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIConsoleService> consoleService =
do_GetService(NS_CONSOLESERVICE_CONTRACTID);
if (consoleService) {
consoleService->LogMessage(errorObject);
}
return NS_ERROR_DOM_SECURITY_ERR;
}
}
// Partial Reset, need to restore principal for security reasons and
// event listener manager so that load listeners etc. will
// remain. This should be done before the security check is done to
// ensure that the document is reset even if the new document can't
// be loaded. Note that we need to hold a strong ref to |principal|
// here, because ResetToURI will null out our node principal before
// setting the new one.
nsRefPtr<nsEventListenerManager> elm(mListenerManager);
mListenerManager = nullptr;
// When we are called from JS we can find the load group for the page,
// and add ourselves to it. This way any pending requests
// will be automatically aborted if the user leaves the page.
nsCOMPtr<nsILoadGroup> loadGroup;
if (callingDoc) {
loadGroup = callingDoc->GetDocumentLoadGroup();
}
ResetToURI(uri, loadGroup, principal);
mListenerManager = elm;
// Create a channel
nsCOMPtr<nsIInterfaceRequestor> req = nsContentUtils::GetSameOriginChecker();
NS_ENSURE_TRUE(req, NS_ERROR_OUT_OF_MEMORY);
nsCOMPtr<nsIChannel> channel;
// nsIRequest::LOAD_BACKGROUND prevents throbber from becoming active,
// which in turn keeps STOP button from becoming active
rv = NS_NewChannel(getter_AddRefs(channel), uri, nullptr, loadGroup, req,
nsIRequest::LOAD_BACKGROUND);
if (NS_FAILED(rv)) {
return rv;
}
// StartDocumentLoad asserts that readyState is uninitialized, so
// uninitialize it. SetReadyStateInternal make this transition invisible to
// Web content. But before doing that, assert that the current readyState
// is complete as it should be after the call to ResetToURI() above.
MOZ_ASSERT(GetReadyStateEnum() == nsIDocument::READYSTATE_COMPLETE,
"Bad readyState");
SetReadyStateInternal(nsIDocument::READYSTATE_UNINITIALIZED);
// Prepare for loading the XML document "into oneself"
nsCOMPtr<nsIStreamListener> listener;
if (NS_FAILED(rv = StartDocumentLoad(kLoadAsData, channel,
loadGroup, nullptr,
getter_AddRefs(listener),
false))) {
NS_ERROR("nsXMLDocument::Load: Failed to start the document load.");
return rv;
}
// After this point, if we error out of this method we should clear
// mChannelIsPending.
// Start an asynchronous read of the XML document
rv = channel->AsyncOpen(listener, nullptr);
if (NS_FAILED(rv)) {
mChannelIsPending = false;
return rv;
}
if (!mAsync) {
nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
nsAutoSyncOperation sync(this);
mLoopingForSyncLoad = true;
while (mLoopingForSyncLoad) {
if (!NS_ProcessNextEvent(thread))
break;
}
// We set return to true unless there was a parsing error
nsCOMPtr<nsIDOMNode> node = do_QueryInterface(GetRootElement());
if (node) {
nsAutoString name, ns;
if (NS_SUCCEEDED(node->GetLocalName(name)) &&
name.EqualsLiteral("parsererror") &&
NS_SUCCEEDED(node->GetNamespaceURI(ns)) &&
ns.EqualsLiteral("http://www.mozilla.org/newlayout/xml/parsererror.xml")) {
//return is already false
} else {
*aReturn = true;
}
}
} else {
*aReturn = true;
}
return NS_OK;
}
NS_IMETHODIMP nsPop3IncomingServer::GetRunningProtocol(nsIPop3Protocol **aProtocol)
{
NS_ENSURE_ARG_POINTER(aProtocol);
NS_IF_ADDREF(*aProtocol = m_runningProtocol);
return NS_OK;
}
NS_IMETHODIMP
nsTitleBarFrame::HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
NS_ENSURE_ARG_POINTER(aEventStatus);
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
bool doDefault = true;
switch (aEvent->message) {
case NS_MOUSE_BUTTON_DOWN: {
if (aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button ==
nsMouseEvent::eLeftButton)
{
// titlebar has no effect in non-chrome shells
nsCOMPtr<nsISupports> cont = aPresContext->GetContainer();
nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(cont);
if (dsti) {
PRInt32 type = -1;
if (NS_SUCCEEDED(dsti->GetItemType(&type)) &&
type == nsIDocShellTreeItem::typeChrome) {
// we're tracking.
mTrackingMouseMove = PR_TRUE;
// start capture.
nsIPresShell::SetCapturingContent(GetContent(), CAPTURE_IGNOREALLOWED);
// remember current mouse coordinates.
mLastPoint = aEvent->refPoint;
}
}
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_BUTTON_UP: {
if(mTrackingMouseMove && aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button ==
nsMouseEvent::eLeftButton)
{
// we're done tracking.
mTrackingMouseMove = PR_FALSE;
// end capture
nsIPresShell::SetCapturingContent(nsnull, 0);
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_MOVE: {
if(mTrackingMouseMove)
{
nsIntPoint nsMoveBy = aEvent->refPoint - mLastPoint;
nsIFrame* parent = GetParent();
while (parent && parent->GetType() != nsGkAtoms::menuPopupFrame)
parent = parent->GetParent();
// if the titlebar is in a popup, move the popup frame, otherwise
// move the widget associated with the window
if (parent) {
nsMenuPopupFrame* menuPopupFrame = static_cast<nsMenuPopupFrame*>(parent);
nsCOMPtr<nsIWidget> widget;
menuPopupFrame->GetWidget(getter_AddRefs(widget));
nsIntRect bounds;
widget->GetScreenBounds(bounds);
menuPopupFrame->MoveTo(bounds.x + nsMoveBy.x, bounds.y + nsMoveBy.y, PR_FALSE);
}
else {
nsIPresShell* presShell = aPresContext->PresShell();
nsPIDOMWindow *window = presShell->GetDocument()->GetWindow();
if (window) {
window->MoveBy(nsMoveBy.x, nsMoveBy.y);
}
}
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_CLICK:
if (NS_IS_MOUSE_LEFT_CLICK(aEvent))
{
MouseClicked(aPresContext, aEvent);
}
break;
}
if ( doDefault )
return nsBoxFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
else
return NS_OK;
}
NS_IMETHODIMP nsPop3IncomingServer::GetAuthenticated(bool *aAuthenticated)
{
NS_ENSURE_ARG_POINTER(aAuthenticated);
*aAuthenticated = m_authenticated;
return NS_OK;
}
NS_IMETHODIMP nsNNTPNewsgroupList::ApplyFilterHit(nsIMsgFilter *aFilter, nsIMsgWindow *aMsgWindow, bool *aApplyMore)
{
NS_ENSURE_ARG_POINTER(aFilter);
NS_ENSURE_ARG_POINTER(aApplyMore);
NS_ENSURE_TRUE(m_newMsgHdr, NS_ERROR_UNEXPECTED);
NS_ENSURE_TRUE(m_newsDB, NS_ERROR_UNEXPECTED);
// you can't move news messages, so applyMore is always true
*aApplyMore = true;
nsCOMPtr<nsISupportsArray> filterActionList;
nsresult rv = NS_NewISupportsArray(getter_AddRefs(filterActionList));
NS_ENSURE_SUCCESS(rv, rv);
rv = aFilter->GetSortedActionList(filterActionList);
NS_ENSURE_SUCCESS(rv, rv);
uint32_t numActions;
rv = filterActionList->Count(&numActions);
NS_ENSURE_SUCCESS(rv, rv);
bool loggingEnabled = false;
nsCOMPtr<nsIMsgFilterList> currentFilterList;
rv = aFilter->GetFilterList(getter_AddRefs(currentFilterList));
if (NS_SUCCEEDED(rv) && currentFilterList && numActions)
currentFilterList->GetLoggingEnabled(&loggingEnabled);
for (uint32_t actionIndex = 0; actionIndex < numActions; actionIndex++)
{
nsCOMPtr<nsIMsgRuleAction> filterAction;
filterActionList->QueryElementAt(actionIndex, NS_GET_IID(nsIMsgRuleAction), getter_AddRefs(filterAction));
if (!filterAction)
continue;
nsMsgRuleActionType actionType;
if (NS_SUCCEEDED(filterAction->GetType(&actionType)))
{
switch (actionType)
{
case nsMsgFilterAction::Delete:
m_addHdrToDB = false;
break;
case nsMsgFilterAction::MarkRead:
m_newsDB->MarkHdrRead(m_newMsgHdr, true, nullptr);
break;
case nsMsgFilterAction::MarkUnread:
m_newsDB->MarkHdrRead(m_newMsgHdr, false, nullptr);
break;
case nsMsgFilterAction::KillThread:
m_newMsgHdr->SetUint32Property("ProtoThreadFlags", nsMsgMessageFlags::Ignored);
break;
case nsMsgFilterAction::KillSubthread:
{
uint32_t newFlags;
m_newMsgHdr->OrFlags(nsMsgMessageFlags::Ignored, &newFlags);
}
break;
case nsMsgFilterAction::WatchThread:
{
uint32_t newFlags;
m_newMsgHdr->OrFlags(nsMsgMessageFlags::Watched, &newFlags);
}
break;
case nsMsgFilterAction::MarkFlagged:
m_newMsgHdr->MarkFlagged(true);
break;
case nsMsgFilterAction::ChangePriority:
{
nsMsgPriorityValue filterPriority;
filterAction->GetPriority(&filterPriority);
m_newMsgHdr->SetPriority(filterPriority);
}
break;
case nsMsgFilterAction::AddTag:
{
nsCString keyword;
filterAction->GetStrValue(keyword);
nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
messageArray->AppendElement(m_newMsgHdr, false);
nsCOMPtr <nsIMsgFolder> folder = do_QueryInterface(m_newsFolder, &rv);
if (folder)
folder->AddKeywordsToMessages(messageArray, keyword);
break;
}
case nsMsgFilterAction::Label:
{
nsMsgLabelValue filterLabel;
filterAction->GetLabel(&filterLabel);
nsMsgKey msgKey;
m_newMsgHdr->GetMessageKey(&msgKey);
m_newsDB->SetLabel(msgKey, filterLabel);
}
break;
case nsMsgFilterAction::StopExecution:
{
// don't apply any more filters
*aApplyMore = false;
}
break;
case nsMsgFilterAction::Custom:
{
nsCOMPtr<nsIMsgFilterCustomAction> customAction;
rv = filterAction->GetCustomAction(getter_AddRefs(customAction));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoCString value;
filterAction->GetStrValue(value);
nsCOMPtr<nsIMutableArray> messageArray(
do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
NS_ENSURE_TRUE(messageArray, rv);
messageArray->AppendElement(m_newMsgHdr, false);
customAction->Apply(messageArray, value, nullptr,
nsMsgFilterType::NewsRule, aMsgWindow);
}
break;
default:
NS_ERROR("unexpected action");
break;
}
if (loggingEnabled)
(void) aFilter->LogRuleHit(filterAction, m_newMsgHdr);
}
}
return NS_OK;
}
nsresult
nsNNTPNewsgroupList::GetRangeOfArtsToDownload(nsIMsgWindow *aMsgWindow,
int32_t first_possible,
int32_t last_possible,
int32_t maxextra,
int32_t *first,
int32_t *last,
int32_t *status)
{
nsresult rv = NS_OK;
NS_ENSURE_ARG_POINTER(first);
NS_ENSURE_ARG_POINTER(last);
NS_ENSURE_ARG_POINTER(status);
*first = 0;
*last = 0;
nsCOMPtr <nsIMsgFolder> folder = do_QueryInterface(m_newsFolder, &rv);
NS_ENSURE_SUCCESS(rv,rv);
m_msgWindow = aMsgWindow;
nsCOMPtr<nsINewsDatabase> db(do_QueryInterface(m_newsDB, &rv));
NS_ENSURE_SUCCESS(rv,rv);
rv = db->GetReadSet(&m_set);
if (NS_FAILED(rv) || !m_set)
return rv;
m_set->SetLastMember(last_possible); // make sure highwater mark is valid.
nsCOMPtr <nsIDBFolderInfo> newsGroupInfo;
rv = m_newsDB->GetDBFolderInfo(getter_AddRefs(newsGroupInfo));
if (NS_SUCCEEDED(rv) && newsGroupInfo) {
nsCString knownArtsString;
nsMsgKey mark;
newsGroupInfo->GetKnownArtsSet(getter_Copies(knownArtsString));
rv = newsGroupInfo->GetHighWater(&mark);
NS_ENSURE_SUCCESS(rv,rv);
if (last_possible < ((int32_t)mark))
newsGroupInfo->SetHighWater(last_possible);
if (m_knownArts.set)
delete m_knownArts.set;
m_knownArts.set = nsMsgKeySet::Create(knownArtsString.get());
}
else
{
if (m_knownArts.set)
delete m_knownArts.set;
m_knownArts.set = nsMsgKeySet::Create();
nsMsgKey low, high;
rv = m_newsDB->GetLowWaterArticleNum(&low);
NS_ENSURE_SUCCESS(rv,rv);
rv = m_newsDB->GetHighWaterArticleNum(&high);
NS_ENSURE_SUCCESS(rv,rv);
m_knownArts.set->AddRange(low,high);
}
if (m_knownArts.set->IsMember(last_possible)) {
nsString statusString;
nsCOMPtr<nsIStringBundleService> bundleService =
mozilla::services::GetStringBundleService();
NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle(NEWS_MSGS_URL, getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
rv = bundle->GetStringFromName(NS_LITERAL_STRING("noNewMessages").get(), getter_Copies(statusString));
NS_ENSURE_SUCCESS(rv, rv);
SetProgressStatus(statusString.get());
}
if (maxextra <= 0 || last_possible < first_possible || last_possible < 1)
{
*status=0;
return NS_OK;
}
m_knownArts.first_possible = first_possible;
m_knownArts.last_possible = last_possible;
nsCOMPtr <nsIMsgIncomingServer> server;
rv = folder->GetServer(getter_AddRefs(server));
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr<nsINntpIncomingServer> nntpServer = do_QueryInterface(server, &rv);
NS_ENSURE_SUCCESS(rv,rv);
/* Determine if we only want to get just new articles or more messages.
If there are new articles at the end we haven't seen, we always want to get those first.
Otherwise, we get the newest articles we haven't gotten, if we're getting more.
My thought for now is that opening a newsgroup should only try to get new articles.
Selecting "More Messages" will first try to get unseen messages, then old messages. */
if (m_getOldMessages || !m_knownArts.set->IsMember(last_possible))
{
bool notifyMaxExceededOn = true;
rv = nntpServer->GetNotifyOn(¬ifyMaxExceededOn);
if (NS_FAILED(rv)) notifyMaxExceededOn = true;
// if the preference to notify when downloading more than x headers is not on,
// and we're downloading new headers, set maxextra to a very large number.
if (!m_getOldMessages && !notifyMaxExceededOn)
maxextra = 0x7FFFFFFFL;
int result =
m_knownArts.set->LastMissingRange(first_possible, last_possible,
first, last);
if (result < 0) {
*status=result;
return NS_ERROR_NOT_INITIALIZED;
}
if (*first > 0 && *last - *first >= maxextra)
{
if (!m_getOldMessages && !m_promptedAlready && notifyMaxExceededOn)
{
m_downloadAll = false;
nsCOMPtr<nsINewsDownloadDialogArgs> args = do_CreateInstance("@mozilla.org/messenger/newsdownloaddialogargs;1", &rv);
if (NS_FAILED(rv)) return rv;
NS_ENSURE_SUCCESS(rv,rv);
rv = args->SetArticleCount(*last - *first + 1);
NS_ENSURE_SUCCESS(rv,rv);
nsString groupName;
rv = m_newsFolder->GetUnicodeName(groupName);
NS_ENSURE_SUCCESS(rv,rv);
rv = args->SetGroupName(groupName);
NS_ENSURE_SUCCESS(rv,rv);
// get the server key
nsCString serverKey;
rv = server->GetKey(serverKey);
NS_ENSURE_SUCCESS(rv,rv);
rv = args->SetServerKey(serverKey.get());
NS_ENSURE_SUCCESS(rv,rv);
// we many not have a msgWindow if we are running an autosubscribe url from the browser
// and there isn't a 3 pane open.
//
// if we don't have one, bad things will happen when we fail to open up the "download headers dialog"
// (we will subscribe to the newsgroup, but it will appear like there are no messages!)
//
// for now, act like the "download headers dialog" came up, and the user hit cancel. (very safe)
//
// TODO, figure out why we aren't opening and using a 3 pane when the autosubscribe url is run.
// perhaps we can find an available 3 pane, and use it.
bool download = false;
if (aMsgWindow) {
rv = openWindow(aMsgWindow, DOWNLOAD_HEADERS_URL, args);
NS_ENSURE_SUCCESS(rv,rv);
rv = args->GetHitOK(&download);
NS_ENSURE_SUCCESS(rv,rv);
}
if (download) {
rv = args->GetDownloadAll(&m_downloadAll);
NS_ENSURE_SUCCESS(rv,rv);
m_maxArticles = 0;
rv = nntpServer->GetMaxArticles(&m_maxArticles);
NS_ENSURE_SUCCESS(rv,rv);
maxextra = m_maxArticles;
if (!m_downloadAll)
{
bool markOldRead = false;
rv = nntpServer->GetMarkOldRead(&markOldRead);
if (NS_FAILED(rv)) markOldRead = false;
if (markOldRead && m_set)
m_set->AddRange(*first, *last - maxextra);
*first = *last - maxextra + 1;
}
}
else
*first = *last = 0;
m_promptedAlready = true;
}
else if (m_promptedAlready && !m_downloadAll)
*first = *last - m_maxArticles + 1;
else if (!m_downloadAll)
*first = *last - maxextra + 1;
}
}
m_firstMsgToDownload = *first;
m_lastMsgToDownload = *last;
*status=0;
return NS_OK;
}
/* attribute boolean findBackwards; */
NS_IMETHODIMP nsWebBrowserFind::GetFindBackwards(bool *aFindBackwards)
{
NS_ENSURE_ARG_POINTER(aFindBackwards);
*aFindBackwards = mFindBackwards;
return NS_OK;
}
NS_IMETHODIMP
nsChromeProtocolHandler::NewChannel2(nsIURI* aURI,
nsILoadInfo* aLoadInfo,
nsIChannel** aResult)
{
nsresult rv;
NS_ENSURE_ARG_POINTER(aURI);
NS_ENSURE_ARG_POINTER(aLoadInfo);
NS_PRECONDITION(aResult, "Null out param");
#ifdef DEBUG
// Check that the uri we got is already canonified
nsresult debug_rv;
nsCOMPtr<nsIURI> debugClone;
debug_rv = aURI->Clone(getter_AddRefs(debugClone));
if (NS_SUCCEEDED(debug_rv)) {
nsCOMPtr<nsIURL> debugURL (do_QueryInterface(debugClone));
debug_rv = nsChromeRegistry::Canonify(debugURL);
if (NS_SUCCEEDED(debug_rv)) {
bool same;
debug_rv = aURI->Equals(debugURL, &same);
if (NS_SUCCEEDED(debug_rv)) {
NS_ASSERTION(same, "Non-canonified chrome uri passed to nsChromeProtocolHandler::NewChannel!");
}
}
}
#endif
nsCOMPtr<nsIChannel> result;
if (!nsChromeRegistry::gChromeRegistry) {
// We don't actually want this ref, we just want the service to
// initialize if it hasn't already.
nsCOMPtr<nsIChromeRegistry> reg =
mozilla::services::GetChromeRegistryService();
NS_ENSURE_TRUE(nsChromeRegistry::gChromeRegistry, NS_ERROR_FAILURE);
}
nsCOMPtr<nsIURI> resolvedURI;
rv = nsChromeRegistry::gChromeRegistry->ConvertChromeURL(aURI, getter_AddRefs(resolvedURI));
if (NS_FAILED(rv)) {
#ifdef DEBUG
printf("Couldn't convert chrome URL: %s\n",
aURI->GetSpecOrDefault().get());
#endif
return rv;
}
// We don't want to allow the inner protocol handler modify the result principal URI
// since we want either |aURI| or anything pre-set by upper layers to prevail.
nsCOMPtr<nsIURI> savedResultPrincipalURI;
rv = aLoadInfo->GetResultPrincipalURI(getter_AddRefs(savedResultPrincipalURI));
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_NewChannelInternal(getter_AddRefs(result),
resolvedURI,
aLoadInfo);
NS_ENSURE_SUCCESS(rv, rv);
#ifdef DEBUG
nsCOMPtr<nsIFileChannel> fileChan(do_QueryInterface(result));
if (fileChan) {
nsCOMPtr<nsIFile> file;
fileChan->GetFile(getter_AddRefs(file));
bool exists = false;
file->Exists(&exists);
if (!exists) {
nsAutoCString path;
file->GetNativePath(path);
printf("Chrome file doesn't exist: %s\n", path.get());
}
}
#endif
// Make sure that the channel remembers where it was
// originally loaded from.
rv = aLoadInfo->SetResultPrincipalURI(savedResultPrincipalURI);
NS_ENSURE_SUCCESS(rv, rv);
rv = result->SetOriginalURI(aURI);
if (NS_FAILED(rv)) return rv;
// Get a system principal for content files and set the owner
// property of the result
nsCOMPtr<nsIURL> url = do_QueryInterface(aURI);
nsAutoCString path;
rv = url->GetPathQueryRef(path);
if (StringBeginsWith(path, NS_LITERAL_CSTRING("/content/"))) {
result->SetOwner(nsContentUtils::GetSystemPrincipal());
}
// XXX Removed dependency-tracking code from here, because we're not
// tracking them anyways (with fastload we checked only in DEBUG
// and with startupcache not at all), but this is where we would start
// if we need to re-add.
// See bug 531886, bug 533038.
result->SetContentCharset(NS_LITERAL_CSTRING("UTF-8"));
*aResult = result;
NS_ADDREF(*aResult);
return NS_OK;
}
/* attribute boolean wrapFind; */
NS_IMETHODIMP nsWebBrowserFind::GetWrapFind(bool *aWrapFind)
{
NS_ENSURE_ARG_POINTER(aWrapFind);
*aWrapFind = mWrapFind;
return NS_OK;
}
nsresult nsMsgHeaderParser::UnquotePhraseOrAddr (const char *line, PRBool preserveIntegrity, char** result)
{
NS_ENSURE_ARG_POINTER(result);
return msg_unquote_phrase_or_addr(line, preserveIntegrity, result);
}
/* attribute boolean matchCase; */
NS_IMETHODIMP nsWebBrowserFind::GetMatchCase(bool *aMatchCase)
{
NS_ENSURE_ARG_POINTER(aMatchCase);
*aMatchCase = mMatchCase;
return NS_OK;
}
nsresult nsMsgHeaderParser::ReformatUnquotedAddresses (const PRUnichar *line, PRUnichar ** result)
{
NS_ENSURE_ARG_POINTER(result);
*result = nsnull;
PRBool badInput = PR_FALSE;
NS_ConvertUTF16toUTF8 convertedLine(line);
PRInt32 lineLen = convertedLine.Length();
PRInt32 outputMaxLen = (lineLen * sizeof (char) * 2) + 2; //Let's presume we need to escape every char
char * outputStr = (char *) PR_Malloc(outputMaxLen);
if (!outputStr)
return NS_ERROR_OUT_OF_MEMORY;
const char *readPtr = convertedLine.get();
char *writePtr = outputStr;
const char *endOutputPtr = outputStr + outputMaxLen;
const char *endPtr = readPtr + lineLen;
const char *startRecipient = readPtr;
char* reformated;
PRBool openQuoteLevel1 = PR_FALSE;
PRBool openQuoteLevel2 = PR_FALSE;
while (readPtr <= endPtr && writePtr < endOutputPtr && !badInput)
{
if (*readPtr == '\\')
{
if (*(readPtr + 1) == '"')
{
openQuoteLevel2 = !openQuoteLevel2;
readPtr ++;
}
}
else if (*readPtr == '"')
{
openQuoteLevel1 = !openQuoteLevel1;
openQuoteLevel2 &= openQuoteLevel1;
}
else if (*readPtr == ',')
{
if (!openQuoteLevel1 && !openQuoteLevel2)
{
/* Ok, we found an address delimiter, temporary replace the delimiter with a \0
and quote the full address
*/
char * tempEnd = const_cast<char *>(readPtr);
*tempEnd = 0;
reformated = msg_reformat_Header_addresses(startRecipient);
if (reformated)
{
if ((PRInt32) strlen(reformated) < (endOutputPtr - writePtr))
{
strncpy(writePtr, reformated, endOutputPtr - writePtr);
writePtr += strlen(reformated);
}
else
{
badInput = PR_TRUE;
}
PR_Free(reformated);
}
else
{
strncpy(writePtr, startRecipient, endOutputPtr - writePtr);
writePtr += strlen(startRecipient);
}
*writePtr = ',';
writePtr ++;
*tempEnd = ',';
startRecipient = readPtr + 1;
}
}
readPtr ++;
}
/* write off the last recipient */
reformated = msg_reformat_Header_addresses(startRecipient);
if (reformated)
{
if ((PRInt32) strlen(reformated) < (endOutputPtr - writePtr))
strncpy(writePtr, reformated, endOutputPtr - writePtr);
else
badInput = PR_TRUE;
PR_Free(reformated);
}
else
strncpy(writePtr, startRecipient, endOutputPtr - writePtr);
if (!badInput)
*result = ToNewUnicode(NS_ConvertUTF8toUTF16(outputStr));
PR_Free(outputStr);
if (*result == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
if (badInput)
return NS_ERROR_INVALID_ARG;
return NS_OK;
}
/* attribute boolean searchParentFrames; */
NS_IMETHODIMP nsWebBrowserFind::GetSearchParentFrames(bool *aSearchParentFrames)
{
NS_ENSURE_ARG_POINTER(aSearchParentFrames);
*aSearchParentFrames = mSearchParentFrames;
return NS_OK;
}
/* attribute boolean processCanceledByUser; */
NS_IMETHODIMP nsPrintProgress::GetProcessCanceledByUser(PRBool *aProcessCanceledByUser)
{
NS_ENSURE_ARG_POINTER(aProcessCanceledByUser);
*aProcessCanceledByUser = m_processCanceled;
return NS_OK;
}
/* boolean findNext (); */
NS_IMETHODIMP nsWebBrowserFind::FindNext(bool *outDidFind)
{
NS_ENSURE_ARG_POINTER(outDidFind);
*outDidFind = false;
NS_ENSURE_TRUE(CanFindNext(), NS_ERROR_NOT_INITIALIZED);
nsresult rv = NS_OK;
nsCOMPtr<nsIDOMWindow> searchFrame = do_QueryReferent(mCurrentSearchFrame);
NS_ENSURE_TRUE(searchFrame, NS_ERROR_NOT_INITIALIZED);
nsCOMPtr<nsIDOMWindow> rootFrame = do_QueryReferent(mRootSearchFrame);
NS_ENSURE_TRUE(rootFrame, NS_ERROR_NOT_INITIALIZED);
// first, if there's a "cmd_findagain" observer around, check to see if it
// wants to perform the find again command . If it performs the find again
// it will return true, in which case we exit ::FindNext() early.
// Otherwise, nsWebBrowserFind needs to perform the find again command itself
// this is used by nsTypeAheadFind, which controls find again when it was
// the last executed find in the current window.
nsCOMPtr<nsIObserverService> observerSvc =
mozilla::services::GetObserverService();
if (observerSvc) {
nsCOMPtr<nsISupportsInterfacePointer> windowSupportsData =
do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupports> searchWindowSupports =
do_QueryInterface(rootFrame);
windowSupportsData->SetData(searchWindowSupports);
NS_NAMED_LITERAL_STRING(dnStr, "down");
NS_NAMED_LITERAL_STRING(upStr, "up");
observerSvc->NotifyObservers(windowSupportsData,
"nsWebBrowserFind_FindAgain",
mFindBackwards? upStr.get(): dnStr.get());
windowSupportsData->GetData(getter_AddRefs(searchWindowSupports));
// findnext performed if search window data cleared out
*outDidFind = searchWindowSupports == nullptr;
if (*outDidFind)
return NS_OK;
}
// next, look in the current frame. If found, return.
// Beware! This may flush notifications via synchronous
// ScrollSelectionIntoView.
rv = SearchInFrame(searchFrame, false, outDidFind);
if (NS_FAILED(rv)) return rv;
if (*outDidFind)
return OnFind(searchFrame); // we are done
// if we are not searching other frames, return
if (!mSearchSubFrames && !mSearchParentFrames)
return NS_OK;
nsIDocShell *rootDocShell = GetDocShellFromWindow(rootFrame);
if (!rootDocShell) return NS_ERROR_FAILURE;
int32_t enumDirection;
if (mFindBackwards)
enumDirection = nsIDocShell::ENUMERATE_BACKWARDS;
else
enumDirection = nsIDocShell::ENUMERATE_FORWARDS;
nsCOMPtr<nsISimpleEnumerator> docShellEnumerator;
rv = rootDocShell->GetDocShellEnumerator(nsIDocShellTreeItem::typeAll,
enumDirection, getter_AddRefs(docShellEnumerator));
if (NS_FAILED(rv)) return rv;
// remember where we started
nsCOMPtr<nsIDocShellTreeItem> startingItem =
do_QueryInterface(GetDocShellFromWindow(searchFrame), &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIDocShellTreeItem> curItem;
// XXX We should avoid searching in frameset documents here.
// We also need to honour mSearchSubFrames and mSearchParentFrames.
bool hasMore, doFind = false;
while (NS_SUCCEEDED(docShellEnumerator->HasMoreElements(&hasMore)) && hasMore)
{
nsCOMPtr<nsISupports> curSupports;
rv = docShellEnumerator->GetNext(getter_AddRefs(curSupports));
if (NS_FAILED(rv)) break;
curItem = do_QueryInterface(curSupports, &rv);
if (NS_FAILED(rv)) break;
if (doFind)
{
searchFrame = do_GetInterface(curItem, &rv);
if (NS_FAILED(rv)) break;
OnStartSearchFrame(searchFrame);
// Beware! This may flush notifications via synchronous
// ScrollSelectionIntoView.
rv = SearchInFrame(searchFrame, false, outDidFind);
if (NS_FAILED(rv)) return rv;
if (*outDidFind)
return OnFind(searchFrame); // we are done
OnEndSearchFrame(searchFrame);
}
if (curItem.get() == startingItem.get())
doFind = true; // start looking in frames after this one
};
if (!mWrapFind)
{
// remember where we left off
SetCurrentSearchFrame(searchFrame);
return NS_OK;
}
// From here on, we're wrapping, first through the other frames,
// then finally from the beginning of the starting frame back to
// the starting point.
// because nsISimpleEnumerator is totally lame and isn't resettable, I
// have to make a new one
docShellEnumerator = nullptr;
rv = rootDocShell->GetDocShellEnumerator(nsIDocShellTreeItem::typeAll,
enumDirection, getter_AddRefs(docShellEnumerator));
if (NS_FAILED(rv)) return rv;
while (NS_SUCCEEDED(docShellEnumerator->HasMoreElements(&hasMore)) && hasMore)
{
nsCOMPtr<nsISupports> curSupports;
rv = docShellEnumerator->GetNext(getter_AddRefs(curSupports));
if (NS_FAILED(rv)) break;
curItem = do_QueryInterface(curSupports, &rv);
if (NS_FAILED(rv)) break;
searchFrame = do_GetInterface(curItem, &rv);
if (NS_FAILED(rv)) break;
if (curItem.get() == startingItem.get())
{
// Beware! This may flush notifications via synchronous
// ScrollSelectionIntoView.
rv = SearchInFrame(searchFrame, true, outDidFind);
if (NS_FAILED(rv)) return rv;
if (*outDidFind)
return OnFind(searchFrame); // we are done
break;
}
OnStartSearchFrame(searchFrame);
// Beware! This may flush notifications via synchronous
// ScrollSelectionIntoView.
rv = SearchInFrame(searchFrame, false, outDidFind);
if (NS_FAILED(rv)) return rv;
if (*outDidFind)
return OnFind(searchFrame); // we are done
OnEndSearchFrame(searchFrame);
}
// remember where we left off
SetCurrentSearchFrame(searchFrame);
NS_ASSERTION(NS_SUCCEEDED(rv), "Something failed");
return rv;
}
//------------------------------------------------------------------
// Displays the native Print Dialog
static nsresult
ShowNativePrintDialog(HWND aHWnd,
nsIPrintSettings* aPrintSettings)
{
//NS_ENSURE_ARG_POINTER(aHWnd);
NS_ENSURE_ARG_POINTER(aPrintSettings);
gDialogWasExtended = false;
HGLOBAL hGlobalDevMode = nullptr;
HGLOBAL hDevNames = nullptr;
// Get the Print Name to be used
nsXPIDLString printerName;
aPrintSettings->GetPrinterName(getter_Copies(printerName));
// If there is no name then use the default printer
if (printerName.IsEmpty()) {
GetDefaultPrinterNameFromGlobalPrinters(printerName);
} else {
HANDLE hPrinter = nullptr;
if(!::OpenPrinterW(const_cast<wchar_t*>(printerName.get()), &hPrinter, nullptr)) {
// If the last used printer is not found, we should use default printer.
GetDefaultPrinterNameFromGlobalPrinters(printerName);
} else {
::ClosePrinter(hPrinter);
}
}
// Now create a DEVNAMES struct so the the dialog is initialized correctly.
uint32_t len = printerName.Length();
hDevNames = (HGLOBAL)::GlobalAlloc(GHND, sizeof(wchar_t) * (len + 1) +
sizeof(DEVNAMES));
if (!hDevNames) {
return NS_ERROR_OUT_OF_MEMORY;
}
DEVNAMES* pDevNames = (DEVNAMES*)::GlobalLock(hDevNames);
if (!pDevNames) {
::GlobalFree(hDevNames);
return NS_ERROR_FAILURE;
}
pDevNames->wDriverOffset = sizeof(DEVNAMES)/sizeof(wchar_t);
pDevNames->wDeviceOffset = sizeof(DEVNAMES)/sizeof(wchar_t);
pDevNames->wOutputOffset = sizeof(DEVNAMES)/sizeof(wchar_t)+len;
pDevNames->wDefault = 0;
memcpy(pDevNames+1, printerName, (len + 1) * sizeof(wchar_t));
::GlobalUnlock(hDevNames);
// Create a Moveable Memory Object that holds a new DevMode
// from the Printer Name
// The PRINTDLG.hDevMode requires that it be a moveable memory object
// NOTE: We only need to free hGlobalDevMode when the dialog is cancelled
// When the user prints, it comes back in the printdlg struct and
// is used and cleaned up later
hGlobalDevMode = CreateGlobalDevModeAndInit(printerName, aPrintSettings);
// Prepare to Display the Print Dialog
PRINTDLGW prntdlg;
memset(&prntdlg, 0, sizeof(PRINTDLGW));
prntdlg.lStructSize = sizeof(prntdlg);
prntdlg.hwndOwner = aHWnd;
prntdlg.hDevMode = hGlobalDevMode;
prntdlg.hDevNames = hDevNames;
prntdlg.hDC = nullptr;
prntdlg.Flags = PD_ALLPAGES | PD_RETURNIC |
PD_USEDEVMODECOPIESANDCOLLATE | PD_COLLATE;
// if there is a current selection then enable the "Selection" radio button
int16_t howToEnableFrameUI = nsIPrintSettings::kFrameEnableNone;
bool isOn;
aPrintSettings->GetPrintOptions(nsIPrintSettings::kEnableSelectionRB, &isOn);
if (!isOn) {
prntdlg.Flags |= PD_NOSELECTION;
}
aPrintSettings->GetHowToEnableFrameUI(&howToEnableFrameUI);
int32_t pg = 1;
aPrintSettings->GetStartPageRange(&pg);
prntdlg.nFromPage = pg;
aPrintSettings->GetEndPageRange(&pg);
prntdlg.nToPage = pg;
prntdlg.nMinPage = 1;
prntdlg.nMaxPage = 0xFFFF;
prntdlg.nCopies = 1;
prntdlg.lpfnSetupHook = nullptr;
prntdlg.lpSetupTemplateName = nullptr;
prntdlg.hPrintTemplate = nullptr;
prntdlg.hSetupTemplate = nullptr;
prntdlg.hInstance = nullptr;
prntdlg.lpPrintTemplateName = nullptr;
if (!ShouldExtendPrintDialog()) {
prntdlg.lCustData = 0;
prntdlg.lpfnPrintHook = nullptr;
} else {
// Set up print dialog "hook" procedure for extending the dialog
prntdlg.lCustData = (DWORD)howToEnableFrameUI;
prntdlg.lpfnPrintHook = (LPPRINTHOOKPROC)PrintHookProc;
prntdlg.Flags |= PD_ENABLEPRINTHOOK;
}
BOOL result = ::PrintDlgW(&prntdlg);
if (TRUE == result) {
// check to make sure we don't have any nullptr pointers
NS_ENSURE_TRUE(aPrintSettings && prntdlg.hDevMode, NS_ERROR_FAILURE);
if (prntdlg.hDevNames == nullptr) {
::GlobalFree(hGlobalDevMode);
return NS_ERROR_FAILURE;
}
// Lock the deviceNames and check for nullptr
DEVNAMES *devnames = (DEVNAMES *)::GlobalLock(prntdlg.hDevNames);
if (devnames == nullptr) {
::GlobalFree(hGlobalDevMode);
return NS_ERROR_FAILURE;
}
wchar_t* device = &(((wchar_t *)devnames)[devnames->wDeviceOffset]);
wchar_t* driver = &(((wchar_t *)devnames)[devnames->wDriverOffset]);
// Check to see if the "Print To File" control is checked
// then take the name from devNames and set it in the PrintSettings
//
// NOTE:
// As per Microsoft SDK documentation the returned value offset from
// devnames->wOutputOffset is either "FILE:" or nullptr
// if the "Print To File" checkbox is checked it MUST be "FILE:"
// We assert as an extra safety check.
if (prntdlg.Flags & PD_PRINTTOFILE) {
wchar_t* fileName = &(((wchar_t *)devnames)[devnames->wOutputOffset]);
NS_ASSERTION(wcscmp(fileName, L"FILE:") == 0, "FileName must be `FILE:`");
aPrintSettings->SetToFileName(fileName);
aPrintSettings->SetPrintToFile(true);
} else {
// clear "print to file" info
aPrintSettings->SetPrintToFile(false);
aPrintSettings->SetToFileName(nullptr);
}
nsCOMPtr<nsIPrintSettingsWin> psWin(do_QueryInterface(aPrintSettings));
if (!psWin) {
::GlobalFree(hGlobalDevMode);
return NS_ERROR_FAILURE;
}
// Setup local Data members
psWin->SetDeviceName(device);
psWin->SetDriverName(driver);
#if defined(DEBUG_rods) || defined(DEBUG_dcone)
wprintf(L"printer: driver %s, device %s flags: %d\n", driver, device, prntdlg.Flags);
#endif
// fill the print options with the info from the dialog
aPrintSettings->SetPrinterName(device);
if (prntdlg.Flags & PD_SELECTION) {
aPrintSettings->SetPrintRange(nsIPrintSettings::kRangeSelection);
} else if (prntdlg.Flags & PD_PAGENUMS) {
aPrintSettings->SetPrintRange(nsIPrintSettings::kRangeSpecifiedPageRange);
aPrintSettings->SetStartPageRange(prntdlg.nFromPage);
aPrintSettings->SetEndPageRange(prntdlg.nToPage);
} else { // (prntdlg.Flags & PD_ALLPAGES)
aPrintSettings->SetPrintRange(nsIPrintSettings::kRangeAllPages);
}
if (howToEnableFrameUI != nsIPrintSettings::kFrameEnableNone) {
// make sure the dialog got extended
if (gDialogWasExtended) {
// check to see about the frame radio buttons
switch (gFrameSelectedRadioBtn) {
case rad4:
aPrintSettings->SetPrintFrameType(nsIPrintSettings::kFramesAsIs);
break;
case rad5:
aPrintSettings->SetPrintFrameType(nsIPrintSettings::kSelectedFrame);
break;
case rad6:
aPrintSettings->SetPrintFrameType(nsIPrintSettings::kEachFrameSep);
break;
} // switch
} else {
// if it didn't get extended then have it default to printing
// each frame separately
aPrintSettings->SetPrintFrameType(nsIPrintSettings::kEachFrameSep);
}
} else {
aPrintSettings->SetPrintFrameType(nsIPrintSettings::kNoFrames);
}
// Unlock DeviceNames
::GlobalUnlock(prntdlg.hDevNames);
// Transfer the settings from the native data to the PrintSettings
LPDEVMODEW devMode = (LPDEVMODEW)::GlobalLock(prntdlg.hDevMode);
if (devMode == nullptr) {
::GlobalFree(hGlobalDevMode);
return NS_ERROR_FAILURE;
}
psWin->SetDevMode(devMode); // copies DevMode
SetPrintSettingsFromDevMode(aPrintSettings, devMode);
::GlobalUnlock(prntdlg.hDevMode);
#if defined(DEBUG_rods) || defined(DEBUG_dcone)
bool printSelection = prntdlg.Flags & PD_SELECTION;
bool printAllPages = prntdlg.Flags & PD_ALLPAGES;
bool printNumPages = prntdlg.Flags & PD_PAGENUMS;
int32_t fromPageNum = 0;
int32_t toPageNum = 0;
if (printNumPages) {
fromPageNum = prntdlg.nFromPage;
toPageNum = prntdlg.nToPage;
}
if (printSelection) {
printf("Printing the selection\n");
} else if (printAllPages) {
printf("Printing all the pages\n");
} else {
printf("Printing from page no. %d to %d\n", fromPageNum, toPageNum);
}
#endif
} else {
::SetFocus(aHWnd);
aPrintSettings->SetIsCancelled(true);
if (hGlobalDevMode) ::GlobalFree(hGlobalDevMode);
return NS_ERROR_ABORT;
}
return NS_OK;
}
NS_IMETHODIMP
nsNSSDialogs::ChooseCertificate(nsIInterfaceRequestor* ctx,
const nsAString& cnAndPort,
const nsAString& organization,
const nsAString& issuerOrg,
nsIArray* certList,
/*out*/ uint32_t* selectedIndex,
/*out*/ bool* certificateChosen)
{
NS_ENSURE_ARG_POINTER(ctx);
NS_ENSURE_ARG_POINTER(certList);
NS_ENSURE_ARG_POINTER(selectedIndex);
NS_ENSURE_ARG_POINTER(certificateChosen);
*certificateChosen = false;
nsCOMPtr<nsIDialogParamBlock> block =
do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID);
if (!block) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIMutableArray> paramBlockArray = nsArrayBase::Create();
if (!paramBlockArray) {
return NS_ERROR_FAILURE;
}
nsresult rv = paramBlockArray->AppendElement(certList, false);
if (NS_FAILED(rv)) {
return rv;
}
rv = block->SetObjects(paramBlockArray);
if (NS_FAILED(rv)) {
return rv;
}
rv = block->SetNumberStrings(3);
if (NS_FAILED(rv)) {
return rv;
}
rv = block->SetString(0, PromiseFlatString(cnAndPort).get());
if (NS_FAILED(rv)) {
return rv;
}
rv = block->SetString(1, PromiseFlatString(organization).get());
if (NS_FAILED(rv)) {
return rv;
}
rv = block->SetString(2, PromiseFlatString(issuerOrg).get());
if (NS_FAILED(rv)) {
return rv;
}
rv = nsNSSDialogHelper::openDialog(nullptr,
"chrome://pippki/content/clientauthask.xul",
block);
if (NS_FAILED(rv)) {
return rv;
}
int32_t status;
rv = block->GetInt(0, &status);
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsIClientAuthUserDecision> extraResult = do_QueryInterface(ctx);
if (extraResult) {
int32_t rememberSelection;
rv = block->GetInt(2, &rememberSelection);
if (NS_SUCCEEDED(rv)) {
extraResult->SetRememberClientAuthCertificate(rememberSelection!=0);
}
}
*certificateChosen = (status != 0);
if (*certificateChosen) {
int32_t index = 0;
rv = block->GetInt(1, &index);
if (NS_FAILED(rv)) {
return rv;
}
if (index < 0) {
MOZ_ASSERT_UNREACHABLE("Selected index should never be negative");
return NS_ERROR_FAILURE;
}
*selectedIndex = mozilla::AssertedCast<uint32_t>(index);
}
return NS_OK;
}
NS_IMETHODIMP nsDeviceContextSpecQt::GetSurfaceForPrinter(
gfxASurface** aSurface)
{
NS_ENSURE_ARG_POINTER(aSurface);
*aSurface = nsnull;
double width, height;
mPrintSettings->GetEffectivePageSize(&width, &height);
// If we're in landscape mode, we'll be rotating the output --
// need to swap width & height.
PRInt32 orientation;
mPrintSettings->GetOrientation(&orientation);
if (nsIPrintSettings::kLandscapeOrientation == orientation) {
double tmp = width;
width = height;
height = tmp;
}
// convert twips to points
width /= TWIPS_PER_POINT_FLOAT;
height /= TWIPS_PER_POINT_FLOAT;
DO_PR_DEBUG_LOG(("\"%s\", %f, %f\n", mPath, width, height));
QTemporaryFile file;
if(!file.open()) {
return NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE;
}
file.setAutoRemove(false);
nsresult rv = NS_NewNativeLocalFile(
nsDependentCString(file.fileName().toAscii().constData()),
false,
getter_AddRefs(mSpoolFile));
if (NS_FAILED(rv)) {
file.remove();
return NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE;
}
mSpoolName = file.fileName().toUtf8().constData();
mSpoolFile->SetPermissions(0600);
nsCOMPtr<nsIFileOutputStream> stream =
do_CreateInstance("@mozilla.org/network/file-output-stream;1");
rv = stream->Init(mSpoolFile, -1, -1, 0);
if (NS_FAILED(rv))
return rv;
PRInt16 format;
mPrintSettings->GetOutputFormat(&format);
nsRefPtr<gfxASurface> surface;
gfxSize surfaceSize(width, height);
if (format == nsIPrintSettings::kOutputFormatNative) {
if (mIsPPreview) {
// There is nothing to detect on Print Preview, use PS.
// TODO: implement for Qt?
//format = nsIPrintSettings::kOutputFormatPS;
return NS_ERROR_NOT_IMPLEMENTED;
}
format = nsIPrintSettings::kOutputFormatPDF;
}
if (format == nsIPrintSettings::kOutputFormatPDF) {
surface = new gfxPDFSurface(stream, surfaceSize);
} else {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_ABORT_IF_FALSE(surface, "valid address expected");
surface.swap(*aSurface);
return NS_OK;
}
NS_IMETHODIMP
nsMsgSendLater::RemoveListener(nsIMsgSendLaterListener *aListener)
{
NS_ENSURE_ARG_POINTER(aListener);
return mListenerArray.RemoveElement(aListener) ? NS_OK : NS_ERROR_INVALID_ARG;
}
NS_IMETHODIMP nsMovemailIncomingServer::CreateDefaultMailboxes(nsIFile *aPath)
{
NS_ENSURE_ARG_POINTER(aPath);
nsCOMPtr <nsIFile> path;
nsresult rv = aPath->Clone(getter_AddRefs(path));
NS_ENSURE_SUCCESS(rv, rv);
rv = path->AppendNative(NS_LITERAL_CSTRING("Inbox"));
if (NS_FAILED(rv)) return rv;
bool exists;
rv = path->Exists(&exists);
if (NS_FAILED(rv)) return rv;
if (!exists)
{
rv = path->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
if (NS_FAILED(rv)) return rv;
}
rv = path->SetNativeLeafName(NS_LITERAL_CSTRING("Trash"));
if (NS_FAILED(rv)) return rv;
rv = path->Exists(&exists);
if (NS_FAILED(rv)) return rv;
if (!exists) {
rv = path->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
if (NS_FAILED(rv)) return rv;
}
rv = path->SetNativeLeafName(NS_LITERAL_CSTRING("Sent"));
if (NS_FAILED(rv)) return rv;
rv = path->Exists(&exists);
if (NS_FAILED(rv)) return rv;
if (!exists) {
rv = path->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
if (NS_FAILED(rv)) return rv;
}
rv = path->SetNativeLeafName(NS_LITERAL_CSTRING("Drafts"));
if (NS_FAILED(rv)) return rv;
rv = path->Exists(&exists);
if (NS_FAILED(rv)) return rv;
if (!exists) {
rv = path->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
if (NS_FAILED(rv)) return rv;
}
rv = path->SetNativeLeafName(NS_LITERAL_CSTRING("Templates"));
if (NS_FAILED(rv)) return rv;
rv = path->Exists(&exists);
if (NS_FAILED(rv)) return rv;
if (!exists) {
rv = path->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
if (NS_FAILED(rv)) return rv;
}
rv = path->SetNativeLeafName(NS_LITERAL_CSTRING("Unsent Messages"));
if (NS_FAILED(rv)) return rv;
rv = path->Exists(&exists);
if (NS_FAILED(rv)) return rv;
if (!exists) {
rv = path->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
if (NS_FAILED(rv)) return rv;
}
return rv;
}
nsresult
sbFileSystemTreeState::LoadTreeState(nsID & aSessionID,
nsString & aSessionAbsolutePath,
PRBool *aIsRecursiveWatch,
sbFileSystemNode **aOutRootNode)
{
NS_ENSURE_ARG_POINTER(aOutRootNode);
// Setup and read the serialized data as defined above.
nsresult rv;
nsCOMPtr<nsIFile> savedSessionFile;
rv = GetTreeSessionFile(aSessionID,
PR_FALSE, // don't create
getter_AddRefs(savedSessionFile));
NS_ENSURE_SUCCESS(rv, rv);
// Ensure that the session file exists.
PRBool exists = PR_FALSE;
if (NS_FAILED(savedSessionFile->Exists(&exists)) || !exists) {
NS_WARNING("The saved session file no longer exists!");
return NS_ERROR_UNEXPECTED;
}
nsRefPtr<sbFileObjectInputStream> fileObjectStream =
new sbFileObjectInputStream();
NS_ENSURE_TRUE(fileObjectStream, NS_ERROR_OUT_OF_MEMORY);
rv = fileObjectStream->InitWithFile(savedSessionFile);
NS_ENSURE_SUCCESS(rv, rv);
// Now begin to read in the data in the sequence defined above:
// 1.) The tree schema version.
PRUint32 schemaVersion = 0;
rv = fileObjectStream->ReadUint32(&schemaVersion);
NS_ENSURE_SUCCESS(rv, rv);
// For now, just ensure that the schema version is the same.
// In the future, a migration handler will need to be written.
if (schemaVersion != TREE_SCHEMA_VERSION) {
return NS_ERROR_FAILURE;
}
// 2.) Tree root absolute path
rv = fileObjectStream->ReadString(aSessionAbsolutePath);
NS_ENSURE_SUCCESS(rv, rv);
// 3.) Is tree recursive watch.
rv = fileObjectStream->ReadPRBool(aIsRecursiveWatch);
NS_ENSURE_SUCCESS(rv, rv);
// 4.) Number of nodes
PRUint32 nodeCount = 0;
rv = fileObjectStream->ReadUint32(&nodeCount);
NS_ENSURE_SUCCESS(rv, rv);
// 5.) Node data
// Use the map to store guids to help rebuild the parent/child relationship.
nsRefPtr<sbFileSystemNode> savedRootNode;
sbNodeIDMap nodeIDMap;
for (PRUint32 i = 0; i < nodeCount; i++) {
nsRefPtr<sbFileSystemNode> curNode;
rv = ReadNode(fileObjectStream, getter_AddRefs(curNode));
// If one of the nodes is missing, it could corrupt the entire tree.
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(curNode, NS_ERROR_UNEXPECTED);
// Assign this node into the node ID map.
PRUint32 curNodeID;
rv = curNode->GetNodeID(&curNodeID);
// Once again, this will corrupt the entire tree if it fails.
NS_ENSURE_SUCCESS(rv, rv);
nodeIDMap.insert(sbNodeIDMapPair(curNodeID, curNode));
// If this is the first node read, it is the root node. Simply stash the
// references for later and continue.
if (i == 0) {
savedRootNode = curNode;
continue;
}
// Setup the relationship between parent and child.
rv = AssignRelationships(curNode, nodeIDMap);
// If this fails, it will also corrupt the entire tree.
NS_ENSURE_SUCCESS(rv, rv);
}
rv = fileObjectStream->Close();
NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Could not close the file object stream!");
savedRootNode.forget(aOutRootNode);
return NS_OK;
}
NS_IMETHODIMP
CVE_2014_1482_seamonkey2_9_RasterImage::Draw(gfxContext *aContext,
gfxPattern::GraphicsFilter aFilter,
const gfxMatrix &aUserSpaceToImageSpace,
const gfxRect &aFill,
const nsIntRect &aSubimage,
const nsIntSize& /*aViewportSize - ignored*/,
PRUint32 aFlags)
{
if (mError)
return NS_ERROR_FAILURE;
// Disallowed in the API
if (mInDecoder && (aFlags & imgIContainer::FLAG_SYNC_DECODE))
return NS_ERROR_FAILURE;
// Illegal -- you can't draw with non-default decode flags.
// (Disabling colorspace conversion might make sense to allow, but
// we don't currently.)
if ((aFlags & DECODE_FLAGS_MASK) != DECODE_FLAGS_DEFAULT)
return NS_ERROR_FAILURE;
NS_ENSURE_ARG_POINTER(aContext);
// We can only draw with the default decode flags
if (mFrameDecodeFlags != DECODE_FLAGS_DEFAULT) {
if (!CanForciblyDiscard())
return NS_ERROR_NOT_AVAILABLE;
ForceDiscard();
mFrameDecodeFlags = DECODE_FLAGS_DEFAULT;
}
// We use !mDecoded && mHasSourceData to mean discarded.
if (!mDecoded && mHasSourceData) {
mDrawStartTime = TimeStamp::Now();
}
// If a synchronous draw is requested, flush anything that might be sitting around
if (aFlags & FLAG_SYNC_DECODE) {
nsresult rv = SyncDecode();
NS_ENSURE_SUCCESS(rv, rv);
}
imgFrame *frame = GetCurrentDrawableImgFrame();
if (!frame) {
return NS_OK; // Getting the frame (above) touches the image and kicks off decoding
}
nsIntRect framerect = frame->GetRect();
nsIntMargin padding(framerect.x, framerect.y,
mSize.width - framerect.XMost(),
mSize.height - framerect.YMost());
frame->Draw(aContext, aFilter, aUserSpaceToImageSpace, aFill, padding, aSubimage);
if (mDecoded && !mDrawStartTime.IsNull()) {
TimeDuration drawLatency = TimeStamp::Now() - mDrawStartTime;
Telemetry::Accumulate(Telemetry::IMAGE_DECODE_ON_DRAW_LATENCY, PRInt32(drawLatency.ToMicroseconds()));
// clear the value of mDrawStartTime
mDrawStartTime = TimeStamp();
}
return NS_OK;
}
