NS_IMETHODIMP nsMailDatabase::GetSummaryValid(PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
PRUint32 folderSize;
PRUint32 folderDate;
PRUint32 actualFolderTimeStamp;
PRInt32 numUnreadMessages;
nsAutoString errorMsg;
*aResult = PR_FALSE;
if (m_folderFile && m_dbFolderInfo)
{
actualFolderTimeStamp = GetMailboxModDate();
m_dbFolderInfo->GetNumUnreadMessages(&numUnreadMessages);
m_dbFolderInfo->GetFolderSize(&folderSize);
m_dbFolderInfo->GetFolderDate(&folderDate);
// compare current version of db versus filed out version info,
// and file size in db vs file size on disk.
PRUint32 version;
m_dbFolderInfo->GetVersion(&version);
nsCOMPtr <nsIFile> copyFolderFile;
// clone file because nsLocalFile caches sizes.
nsresult rv = m_folderFile->Clone(getter_AddRefs(copyFolderFile));
NS_ENSURE_SUCCESS(rv, rv);
PRInt64 fileSize;
copyFolderFile->GetFileSize(&fileSize);
if (folderSize == fileSize &&
numUnreadMessages >= 0 && GetCurVersion() == version)
{
GetGlobalPrefs();
// if those values are ok, check time stamp
if (gTimeStampLeeway == 0)
*aResult = folderDate == actualFolderTimeStamp;
else
*aResult = PR_ABS((PRInt32) (actualFolderTimeStamp - folderDate)) <= gTimeStampLeeway;
#ifndef PUTUP_ALERT_ON_INVALID_DB
}
}
#else
if (!*aResult)
{
errorMsg.AppendLiteral("time stamp didn't match delta = ");
errorMsg.AppendInt(actualFolderTimeStamp - folderDate);
errorMsg.AppendLiteral(" leeway = ");
errorMsg.AppendInt(gTimeStampLeeway);
}
}
PRBool
tls13_InWindow(const sslSocket *ss, const sslSessionID *sid)
{
PRInt32 timeDelta;
/* Calculate the difference between the client's view of the age of the
* ticket (in |ss->xtnData.ticketAge|) and the server's view, which we now
* calculate. The result should be close to zero. timeDelta is signed to
* make the comparisons below easier. */
timeDelta = ss->xtnData.ticketAge -
((ssl_TimeUsec() - sid->creationTime) / PR_USEC_PER_MSEC);
/* Only allow the time delta to be at most half of our window. This is
* symmetrical, though it doesn't need to be; this assumes that clock errors
* on server and client will tend to cancel each other out.
*
* There are two anti-replay filters that roll over each window. In the
* worst case, immediately after a rollover of the filters, we only have a
* single window worth of recorded 0-RTT attempts. Thus, the period in
* which we can accept 0-RTT is at most one window wide. This uses PR_ABS()
* and half the window so that the first attempt can be up to half a window
* early and then replays will be caught until the attempts are half a
* window late.
*
* For example, a 0-RTT attempt arrives early, but near the end of window 1.
* The attempt is then recorded in window 1. Rollover to window 2 could
* occur immediately afterwards. Window 1 is still checked for new 0-RTT
* attempts for the remainder of window 2. Therefore, attempts to replay
* are detected because the value is recorded in window 1. When rollover
* occurs again, window 1 is erased and window 3 instated. If we allowed an
* attempt to be late by more than half a window, then this check would not
* prevent the same 0-RTT attempt from being accepted during window 1 and
* later window 3.
*/
return PR_ABS(timeDelta) < (ssl_anti_replay.window / 2);
}
nsresult
nsQueryContentEventHandler::QueryRectFor(nsQueryContentEvent* aEvent,
nsIRange* aRange,
nsICaret* aCaret)
{
PRInt32 offsetInFrame;
nsIFrame* frame;
nsresult rv = GetStartFrameAndOffset(aRange, &frame, &offsetInFrame);
NS_ENSURE_SUCCESS(rv, rv);
nsPoint posInFrame;
rv = frame->GetPointFromOffset(aRange->StartOffset(), &posInFrame);
NS_ENSURE_SUCCESS(rv, rv);
aEvent->mReply.mRect.y = posInFrame.y;
aEvent->mReply.mRect.height = frame->GetSize().height;
if (aEvent->message == NS_QUERY_CHARACTER_RECT) {
nsPoint nextPos;
rv = frame->GetPointFromOffset(aRange->EndOffset(), &nextPos);
NS_ENSURE_SUCCESS(rv, rv);
aEvent->mReply.mRect.x = PR_MIN(posInFrame.x, nextPos.x);
aEvent->mReply.mRect.width = PR_ABS(posInFrame.x - nextPos.x);
} else {
aEvent->mReply.mRect.x = posInFrame.x;
aEvent->mReply.mRect.width = aCaret->GetCaretRect().width;
}
// The coordinates are app units here, they will be converted to system
// coordinates by view manager.
rv = ConvertToRootViewRelativeOffset(frame, aEvent->mReply.mRect);
NS_ENSURE_SUCCESS(rv, rv);
aEvent->mSucceeded = PR_TRUE;
return NS_OK;
}
// static
void
nsSHistory::EvictGlobalContentViewer()
{
// true until the total number of content viewers is <= total max
// The usual case is that we only need to evict one content viewer.
// However, if somebody resets the pref value, we might occasionally
// need to evict more than one.
PRBool shouldTryEviction = PR_TRUE;
while (shouldTryEviction) {
// Walk through our list of SHistory objects, looking for content
// viewers in the possible active window of all of the SHEntry objects.
// Keep track of the SHEntry object that has a ContentViewer and is
// farthest from the current focus in any SHistory object. The
// ContentViewer associated with that SHEntry will be evicted
PRInt32 distanceFromFocus = 0;
nsCOMPtr<nsISHEntry> evictFromSHE;
nsCOMPtr<nsIContentViewer> evictViewer;
PRInt32 totalContentViewers = 0;
nsSHistory* shist = static_cast<nsSHistory*>
(PR_LIST_HEAD(&gSHistoryList));
while (shist != &gSHistoryList) {
// Calculate the window of SHEntries that could possibly have a content
// viewer. There could be up to gHistoryMaxViewers content viewers,
// but we don't know whether they are before or after the mIndex position
// in the SHEntry list. Just check both sides, to be safe.
PRInt32 startIndex = PR_MAX(0, shist->mIndex - gHistoryMaxViewers);
PRInt32 endIndex = PR_MIN(shist->mLength - 1,
shist->mIndex + gHistoryMaxViewers);
nsCOMPtr<nsISHTransaction> trans;
shist->GetTransactionAtIndex(startIndex, getter_AddRefs(trans));
for (PRInt32 i = startIndex; i <= endIndex; ++i) {
nsCOMPtr<nsISHEntry> entry;
trans->GetSHEntry(getter_AddRefs(entry));
nsCOMPtr<nsIContentViewer> viewer;
nsCOMPtr<nsISHEntry> ownerEntry;
entry->GetAnyContentViewer(getter_AddRefs(ownerEntry),
getter_AddRefs(viewer));
#ifdef DEBUG_PAGE_CACHE
nsCOMPtr<nsIURI> uri;
if (ownerEntry) {
ownerEntry->GetURI(getter_AddRefs(uri));
} else {
entry->GetURI(getter_AddRefs(uri));
}
nsCAutoString spec;
if (uri) {
uri->GetSpec(spec);
printf("Considering for eviction: %s\n", spec.get());
}
#endif
// This SHEntry has a ContentViewer, so check how far away it is from
// the currently used SHEntry within this SHistory object
if (viewer) {
PRInt32 distance = PR_ABS(shist->mIndex - i);
#ifdef DEBUG_PAGE_CACHE
printf("Has a cached content viewer: %s\n", spec.get());
printf("mIndex: %d i: %d\n", shist->mIndex, i);
#endif
totalContentViewers++;
if (distance > distanceFromFocus) {
#ifdef DEBUG_PAGE_CACHE
printf("Choosing as new eviction candidate: %s\n", spec.get());
#endif
distanceFromFocus = distance;
evictFromSHE = ownerEntry;
evictViewer = viewer;
}
}
nsISHTransaction* temp = trans;
temp->GetNext(getter_AddRefs(trans));
}
shist = static_cast<nsSHistory*>(PR_NEXT_LINK(shist));
}
#ifdef DEBUG_PAGE_CACHE
printf("Distance from focus: %d\n", distanceFromFocus);
printf("Total max viewers: %d\n", sHistoryMaxTotalViewers);
printf("Total number of viewers: %d\n", totalContentViewers);
#endif
if (totalContentViewers > sHistoryMaxTotalViewers && evictViewer) {
#ifdef DEBUG_PAGE_CACHE
nsCOMPtr<nsIURI> uri;
evictFromSHE->GetURI(getter_AddRefs(uri));
nsCAutoString spec;
if (uri) {
uri->GetSpec(spec);
printf("Evicting content viewer: %s\n", spec.get());
}
#endif
// Drop the presentation state before destroying the viewer, so that
// document teardown is able to correctly persist the state.
evictFromSHE->SetContentViewer(nsnull);
evictFromSHE->SyncPresentationState();
evictViewer->Destroy();
// If we only needed to evict one content viewer, then we are done.
// Otherwise, continue evicting until we reach the max total limit.
if (totalContentViewers - sHistoryMaxTotalViewers == 1) {
shouldTryEviction = PR_FALSE;
}
} else {
// couldn't find a content viewer to evict, so we are done
shouldTryEviction = PR_FALSE;
}
} // while shouldTryEviction
}
NS_IMETHODIMP
nsHTMLEditor::MouseMove(nsIDOMEvent* aMouseEvent)
{
NS_NAMED_LITERAL_STRING(leftStr, "left");
NS_NAMED_LITERAL_STRING(topStr, "top");
if (mIsResizing) {
// we are resizing and the mouse pointer's position has changed
// we have to resdisplay the shadow
nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
PRInt32 clientX, clientY;
mouseEvent->GetClientX(&clientX);
mouseEvent->GetClientY(&clientY);
PRInt32 newX = GetNewResizingX(clientX, clientY);
PRInt32 newY = GetNewResizingY(clientX, clientY);
PRInt32 newWidth = GetNewResizingWidth(clientX, clientY);
PRInt32 newHeight = GetNewResizingHeight(clientX, clientY);
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingShadow,
leftStr,
newX);
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingShadow,
topStr,
newY);
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingShadow,
NS_LITERAL_STRING("width"),
newWidth);
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingShadow,
NS_LITERAL_STRING("height"),
newHeight);
return SetResizingInfoPosition(newX, newY, newWidth, newHeight);
}
if (mGrabberClicked) {
nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
PRInt32 clientX, clientY;
mouseEvent->GetClientX(&clientX);
mouseEvent->GetClientY(&clientY);
nsCOMPtr<nsILookAndFeel> look = do_GetService(kLookAndFeelCID);
NS_ASSERTION(look, "Look and feel service must be implemented for this toolkit");
PRInt32 xThreshold=1, yThreshold=1;
look->GetMetric(nsILookAndFeel::eMetric_DragThresholdX, xThreshold);
look->GetMetric(nsILookAndFeel::eMetric_DragThresholdY, yThreshold);
if (PR_ABS(clientX - mOriginalX ) * 2 >= xThreshold ||
PR_ABS(clientY - mOriginalY ) * 2 >= yThreshold) {
mGrabberClicked = PR_FALSE;
StartMoving(nsnull);
}
}
if (mIsMoving) {
nsCOMPtr<nsIDOMMouseEvent> mouseEvent ( do_QueryInterface(aMouseEvent) );
PRInt32 clientX, clientY;
mouseEvent->GetClientX(&clientX);
mouseEvent->GetClientY(&clientY);
PRInt32 newX = mPositionedObjectX + clientX - mOriginalX;
PRInt32 newY = mPositionedObjectY + clientY - mOriginalY;
SnapToGrid(newX, newY);
mHTMLCSSUtils->SetCSSPropertyPixels(mPositioningShadow, leftStr, newX);
mHTMLCSSUtils->SetCSSPropertyPixels(mPositioningShadow, topStr, newY);
}
return NS_OK;
}
NS_IMETHODIMP
nsAccelerometer::AccelerationChanged(double alpha, double beta, double gamma)
{
if (!mEnabled)
return NS_ERROR_NOT_INITIALIZED;
if (alpha > 360)
alpha = 360;
if (alpha < 0)
alpha = 0;
if (beta > 180)
beta = 180;
if (beta < -180)
beta = -180;
if (gamma > 90)
gamma = 90;
if (gamma < -90)
gamma = -90;
if (!mNewListener) {
if (PR_ABS(mLastAlpha - alpha) < 1 &&
PR_ABS(mLastBeta - beta) < 1 &&
PR_ABS(mLastGamma - gamma) < 1)
return NS_OK;
}
mLastAlpha = alpha;
mLastBeta = beta;
mLastGamma = gamma;
mNewListener = PR_FALSE;
for (PRUint32 i = mListeners.Count(); i > 0 ; ) {
--i;
nsRefPtr<nsIAcceleration> a = new nsAcceleration(alpha, beta, gamma);
mListeners[i]->OnAccelerationChange(a);
}
for (PRUint32 i = mWindowListeners.Count(); i > 0 ; ) {
--i;
nsCOMPtr<nsIDOMDocument> domdoc;
mWindowListeners[i]->GetDocument(getter_AddRefs(domdoc));
nsCOMPtr<nsIDOMDocumentEvent> docevent(do_QueryInterface(domdoc));
nsCOMPtr<nsIDOMEvent> event;
PRBool defaultActionEnabled = PR_TRUE;
if (docevent) {
docevent->CreateEvent(NS_LITERAL_STRING("DeviceOrientationEvent"), getter_AddRefs(event));
nsCOMPtr<nsIDOMDeviceOrientationEvent> oe = do_QueryInterface(event);
if (event) {
oe->InitDeviceOrientationEvent(NS_LITERAL_STRING("deviceorientation"),
PR_TRUE,
PR_FALSE,
alpha,
beta,
gamma,
PR_TRUE);
nsCOMPtr<nsIPrivateDOMEvent> privateEvent = do_QueryInterface(event);
if (privateEvent)
privateEvent->SetTrusted(PR_TRUE);
nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(mWindowListeners[i]);
target->DispatchEvent(event, &defaultActionEnabled);
}
}
}
return NS_OK;
}
nsresult
nsHTMLEditor::SetResizingInfoPosition(PRInt32 aX, PRInt32 aY, PRInt32 aW, PRInt32 aH)
{
nsCOMPtr<nsIDOMDocument> domdoc;
nsEditor::GetDocument(getter_AddRefs(domdoc));
nsCOMPtr<nsIDocument> doc (do_QueryInterface(domdoc));
if (!doc)
return NS_ERROR_UNEXPECTED;
// get the root content
nsCOMPtr<nsIDOMNSHTMLElement> nsElement = do_QueryInterface(doc->GetRootContent());
if (!nsElement) {return NS_ERROR_NULL_POINTER; }
// let's get the size of the document
PRInt32 w, h;
nsElement->GetOffsetWidth(&w);
nsElement->GetOffsetHeight(&h);
if (mInfoXIncrement < 0)
aX = w - aX ;
if (mInfoYIncrement < 0)
aY = h - aY;
NS_NAMED_LITERAL_STRING(rightStr, "right");
NS_NAMED_LITERAL_STRING(leftStr, "left");
NS_NAMED_LITERAL_STRING(topStr, "top");
NS_NAMED_LITERAL_STRING(bottomStr, "bottom");
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingInfo,
(mInfoXIncrement < 0) ? rightStr : leftStr,
aX + PR_ABS(mInfoXIncrement));
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingInfo,
(mInfoYIncrement < 0) ? bottomStr : topStr,
aY + PR_ABS(mInfoYIncrement));
mHTMLCSSUtils->RemoveCSSProperty(mResizingInfo,
(mInfoXIncrement >= 0) ? rightStr : leftStr);
mHTMLCSSUtils->RemoveCSSProperty(mResizingInfo,
(mInfoYIncrement >= 0) ? bottomStr : topStr);
// let's make sure the info box does not go beyond the limits of the viewport
nsAutoString value;
float f;
nsCOMPtr<nsIAtom> unit;
if (mInfoXIncrement < 0) {
mHTMLCSSUtils->GetComputedProperty(mResizingInfo, nsEditProperty::cssLeft, value);
mHTMLCSSUtils->ParseLength(value, &f, getter_AddRefs(unit));
if (f <= 0) {
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingInfo, leftStr, 0);
mHTMLCSSUtils->RemoveCSSProperty(mResizingInfo,
rightStr);
}
}
if (mInfoYIncrement < 0) {
mHTMLCSSUtils->GetComputedProperty(mResizingInfo, nsEditProperty::cssTop, value);
mHTMLCSSUtils->ParseLength(value, &f, getter_AddRefs(unit));
if (f <= 0) {
mHTMLCSSUtils->SetCSSPropertyPixels(mResizingInfo, topStr, 0);
mHTMLCSSUtils->RemoveCSSProperty(mResizingInfo,
bottomStr);
}
}
nsCOMPtr<nsIDOMNode> textInfo;
nsresult res = mResizingInfo->GetFirstChild(getter_AddRefs(textInfo));
if (NS_FAILED(res)) return res;
nsCOMPtr<nsIDOMNode> junk;
if (textInfo) {
res = mResizingInfo->RemoveChild(textInfo, getter_AddRefs(junk));
if (NS_FAILED(res)) return res;
textInfo = nsnull;
junk = nsnull;
}
nsAutoString widthStr, heightStr, diffWidthStr, diffHeightStr;
widthStr.AppendInt(aW);
heightStr.AppendInt(aH);
PRInt32 diffWidth = aW - mResizedObjectWidth;
PRInt32 diffHeight = aH - mResizedObjectHeight;
if (diffWidth > 0)
diffWidthStr.AssignLiteral("+");
if (diffHeight > 0)
diffHeightStr.AssignLiteral("+");
diffWidthStr.AppendInt(diffWidth);
diffHeightStr.AppendInt(diffHeight);
nsAutoString info(widthStr + NS_LITERAL_STRING(" x ") + heightStr +
NS_LITERAL_STRING(" (") + diffWidthStr +
NS_LITERAL_STRING(", ") + diffHeightStr +
NS_LITERAL_STRING(")"));
nsCOMPtr<nsIDOMText> nodeAsText;
res = domdoc->CreateTextNode(info, getter_AddRefs(nodeAsText));
if (NS_FAILED(res)) return res;
textInfo = do_QueryInterface(nodeAsText);
res = mResizingInfo->AppendChild(textInfo, getter_AddRefs(junk));
if (NS_FAILED(res)) return res;
PRBool hasClass = PR_FALSE;
if (NS_SUCCEEDED(mResizingInfo->HasAttribute(NS_LITERAL_STRING("class"), &hasClass )) && hasClass)
res = mResizingInfo->RemoveAttribute(NS_LITERAL_STRING("class"));
return res;
}
