NS_IMETHODIMP
SendOperationListener::GetMessageId(nsACString& messageId)
{
NS_NOTREACHED("SendOperationListener::GetMessageId()\n");
return NS_ERROR_NOT_IMPLEMENTED;
}
/**
* SetToTransformFunction is essentially a giant switch statement that fans
* out to many smaller helper functions.
*/
static void
MatrixForTransformFunction(gfx3DMatrix& aMatrix,
const nsCSSValue::Array * aData,
nsStyleContext* aContext,
nsPresContext* aPresContext,
bool& aCanStoreInRuleTree,
nsRect& aBounds)
{
NS_PRECONDITION(aData, "Why did you want to get data from a null array?");
// It's OK if aContext and aPresContext are null if the caller already
// knows that all length units have been converted to pixels (as
// nsStyleAnimation does).
/* Get the keyword for the transform. */
switch (TransformFunctionOf(aData)) {
case eCSSKeyword_translatex:
ProcessTranslateX(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree, aBounds);
break;
case eCSSKeyword_translatey:
ProcessTranslateY(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree, aBounds);
break;
case eCSSKeyword_translatez:
ProcessTranslateZ(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree);
break;
case eCSSKeyword_translate:
ProcessTranslate(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree, aBounds);
break;
case eCSSKeyword_translate3d:
ProcessTranslate3D(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree, aBounds);
break;
case eCSSKeyword_scalex:
ProcessScaleX(aMatrix, aData);
break;
case eCSSKeyword_scaley:
ProcessScaleY(aMatrix, aData);
break;
case eCSSKeyword_scalez:
ProcessScaleZ(aMatrix, aData);
break;
case eCSSKeyword_scale:
ProcessScale(aMatrix, aData);
break;
case eCSSKeyword_scale3d:
ProcessScale3D(aMatrix, aData);
break;
case eCSSKeyword_skewx:
ProcessSkewX(aMatrix, aData);
break;
case eCSSKeyword_skewy:
ProcessSkewY(aMatrix, aData);
break;
case eCSSKeyword_skew:
ProcessSkew(aMatrix, aData);
break;
case eCSSKeyword_rotatex:
ProcessRotateX(aMatrix, aData);
break;
case eCSSKeyword_rotatey:
ProcessRotateY(aMatrix, aData);
break;
case eCSSKeyword_rotatez:
case eCSSKeyword_rotate:
ProcessRotateZ(aMatrix, aData);
break;
case eCSSKeyword_rotate3d:
ProcessRotate3D(aMatrix, aData);
break;
case eCSSKeyword_matrix:
ProcessMatrix(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree, aBounds);
break;
case eCSSKeyword_matrix3d:
ProcessMatrix3D(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree, aBounds);
break;
case eCSSKeyword_interpolatematrix:
ProcessInterpolateMatrix(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree, aBounds);
break;
case eCSSKeyword_perspective:
ProcessPerspective(aMatrix, aData, aContext, aPresContext,
aCanStoreInRuleTree);
break;
default:
NS_NOTREACHED("Unknown transform function!");
}
}
/* virtual */ void
nsStyleLinkElement::OverrideBaseURI(nsIURI* aNewBaseURI)
{
NS_NOTREACHED("Base URI can't be overriden in this implementation "
"of nsIStyleSheetLinkingElement.");
}
NS_IMETHODIMP
nsAutoCompleteController::IsContainerEmpty(PRInt32 index, bool *_retval)
{
NS_NOTREACHED("no container cells");
return NS_OK;
}
NS_IMETHODIMP
DefaultController::OnActivate(bool *rAcceptActivation) {
*rAcceptActivation = true;
NS_NOTREACHED("OnActivate should not be called for TaskbarWindowPreviews");
return NS_OK;
}
void
nsTypeAheadFind::RangeStartsInsideLink(nsIDOMRange *aRange,
nsIPresShell *aPresShell,
bool *aIsInsideLink,
bool *aIsStartingLink)
{
*aIsInsideLink = PR_FALSE;
*aIsStartingLink = PR_TRUE;
// ------- Get nsIContent to test -------
nsCOMPtr<nsIDOMNode> startNode;
nsCOMPtr<nsIContent> startContent, origContent;
aRange->GetStartContainer(getter_AddRefs(startNode));
PRInt32 startOffset;
aRange->GetStartOffset(&startOffset);
startContent = do_QueryInterface(startNode);
if (!startContent) {
NS_NOTREACHED("startContent should never be null");
return;
}
origContent = startContent;
if (startContent->IsElement()) {
nsIContent *childContent = startContent->GetChildAt(startOffset);
if (childContent) {
startContent = childContent;
}
}
else if (startOffset > 0) {
const nsTextFragment *textFrag = startContent->GetText();
if (textFrag) {
// look for non whitespace character before start offset
for (PRInt32 index = 0; index < startOffset; index++) {
if (!XP_IS_SPACE(textFrag->CharAt(index))) {
*aIsStartingLink = PR_FALSE; // not at start of a node
break;
}
}
}
}
// ------- Check to see if inside link ---------
// We now have the correct start node for the range
// Search for links, starting with startNode, and going up parent chain
nsCOMPtr<nsIAtom> tag, hrefAtom(do_GetAtom("href"));
nsCOMPtr<nsIAtom> typeAtom(do_GetAtom("type"));
while (PR_TRUE) {
// Keep testing while startContent is equal to something,
// eventually we'll run out of ancestors
if (startContent->IsHTML()) {
nsCOMPtr<nsILink> link(do_QueryInterface(startContent));
if (link) {
// Check to see if inside HTML link
*aIsInsideLink = startContent->HasAttr(kNameSpaceID_None, hrefAtom);
return;
}
}
else {
// Any xml element can be an xlink
*aIsInsideLink = startContent->HasAttr(kNameSpaceID_XLink, hrefAtom);
if (*aIsInsideLink) {
if (!startContent->AttrValueIs(kNameSpaceID_XLink, typeAtom,
NS_LITERAL_STRING("simple"),
eCaseMatters)) {
*aIsInsideLink = PR_FALSE; // Xlink must be type="simple"
}
return;
}
}
// Get the parent
nsCOMPtr<nsIContent> parent = startContent->GetParent();
if (!parent)
break;
nsIContent *parentsFirstChild = parent->GetChildAt(0);
// We don't want to look at a whitespace-only first child
if (parentsFirstChild && parentsFirstChild->TextIsOnlyWhitespace()) {
parentsFirstChild = parent->GetChildAt(1);
}
if (parentsFirstChild != startContent) {
// startContent wasn't a first child, so we conclude that
// if this is inside a link, it's not at the beginning of it
*aIsStartingLink = PR_FALSE;
}
startContent = parent;
}
*aIsStartingLink = PR_FALSE;
}
NS_IMETHODIMP
nsAutoCompleteController::GetProgressMode(PRInt32 row, nsITreeColumn* col, PRInt32* _retval)
{
NS_NOTREACHED("tree has no progress cells");
return NS_OK;
}
NS_IMETHODIMP
nsExtProtocolChannel::SetContentLength(int64_t aContentLength)
{
NS_NOTREACHED("SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsExtProtocolChannel::Suspend()
{
NS_NOTREACHED("Suspend");
return NS_ERROR_NOT_IMPLEMENTED;
}
void
TelephonyCall::ChangeStateInternal(uint16_t aCallState, bool aFireEvents)
{
nsRefPtr<TelephonyCall> kungFuDeathGrip(this);
nsString stateString;
switch (aCallState) {
case nsITelephonyProvider::CALL_STATE_DIALING:
stateString.AssignLiteral("dialing");
break;
case nsITelephonyProvider::CALL_STATE_ALERTING:
stateString.AssignLiteral("alerting");
break;
case nsITelephonyProvider::CALL_STATE_CONNECTING:
stateString.AssignLiteral("connecting");
break;
case nsITelephonyProvider::CALL_STATE_CONNECTED:
stateString.AssignLiteral("connected");
break;
case nsITelephonyProvider::CALL_STATE_HOLDING:
stateString.AssignLiteral("holding");
break;
case nsITelephonyProvider::CALL_STATE_HELD:
stateString.AssignLiteral("held");
break;
case nsITelephonyProvider::CALL_STATE_RESUMING:
stateString.AssignLiteral("resuming");
break;
case nsITelephonyProvider::CALL_STATE_DISCONNECTING:
stateString.AssignLiteral("disconnecting");
break;
case nsITelephonyProvider::CALL_STATE_DISCONNECTED:
stateString.AssignLiteral("disconnected");
break;
case nsITelephonyProvider::CALL_STATE_INCOMING:
stateString.AssignLiteral("incoming");
break;
default:
NS_NOTREACHED("Unknown state!");
}
mState = stateString;
mCallState = aCallState;
if (aCallState == nsITelephonyProvider::CALL_STATE_DIALING) {
mOutgoing = true;
}
if (aCallState == nsITelephonyProvider::CALL_STATE_DISCONNECTED) {
NS_ASSERTION(mLive, "Should be live!");
mTelephony->RemoveCall(this);
mLive = false;
} else if (!mLive) {
mTelephony->AddCall(this);
mLive = true;
}
if (aFireEvents) {
nsresult rv = DispatchCallEvent(NS_LITERAL_STRING("statechange"), this);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to dispatch specific event!");
}
// This can change if the statechange handler called back here... Need to
// figure out something smarter.
if (mCallState == aCallState) {
rv = DispatchCallEvent(stateString, this);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to dispatch specific event!");
}
}
}
}
nscoord
nsBlockReflowState::ClearFloats(nscoord aY, PRUint8 aBreakType,
nsIFrame *aReplacedBlock)
{
#ifdef DEBUG
if (nsBlockFrame::gNoisyReflow) {
nsFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent);
printf("clear floats: in: aY=%d(%d)\n",
aY, aY - BorderPadding().top);
}
#endif
#ifdef NOISY_FLOAT_CLEARING
printf("nsBlockReflowState::ClearFloats: aY=%d breakType=%d\n",
aY, aBreakType);
mFloatManager->List(stdout);
#endif
const nsMargin& bp = BorderPadding();
nscoord newY = aY;
if (aBreakType != NS_STYLE_CLEAR_NONE) {
newY = bp.top + mFloatManager->ClearFloats(newY - bp.top, aBreakType);
}
if (aReplacedBlock) {
for (;;) {
nsFlowAreaRect floatAvailableSpace =
GetFloatAvailableSpace(newY, PR_FALSE);
nsBlockFrame::ReplacedElementWidthToClear replacedWidth =
nsBlockFrame::WidthToClearPastFloats(*this, floatAvailableSpace.mRect,
aReplacedBlock);
if (!floatAvailableSpace.mHasFloats ||
NS_MAX(floatAvailableSpace.mRect.x, replacedWidth.marginLeft) +
replacedWidth.borderBoxWidth +
NS_MAX(mContentArea.width -
NS_MIN(mContentArea.width,
floatAvailableSpace.mRect.XMost()),
replacedWidth.marginRight) <=
mContentArea.width) {
break;
}
// See the analogous code for inlines in nsBlockFrame::DoReflowInlineFrames
if (floatAvailableSpace.mRect.height > 0) {
// See if there's room in the next band.
newY += floatAvailableSpace.mRect.height;
} else {
if (mReflowState.availableHeight != NS_UNCONSTRAINEDSIZE) {
// Stop trying to clear here; we'll just get pushed to the
// next column or page and try again there.
break;
}
NS_NOTREACHED("avail space rect with zero height!");
newY += 1;
}
}
}
#ifdef DEBUG
if (nsBlockFrame::gNoisyReflow) {
nsFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent);
printf("clear floats: out: y=%d(%d)\n", newY, newY - bp.top);
}
#endif
return newY;
}
nsresult
nsThebesDeviceContext::SetDPI()
{
float dpi = -1.0f;
// PostScript, PDF and Mac (when printing) all use 72 dpi
// Use a printing DC to determine the other dpi values
if (mPrintingSurface) {
switch (mPrintingSurface->GetType()) {
case gfxASurface::SurfaceTypePDF:
case gfxASurface::SurfaceTypePS:
case gfxASurface::SurfaceTypeQuartz:
dpi = 72.0f;
break;
#ifdef XP_WIN
case gfxASurface::SurfaceTypeWin32:
case gfxASurface::SurfaceTypeWin32Printing: {
PRInt32 OSVal = GetDeviceCaps(GetPrintHDC(), LOGPIXELSY);
dpi = 144.0f;
mPrintingScale = float(OSVal) / dpi;
break;
}
#endif
#ifdef XP_OS2
case gfxASurface::SurfaceTypeOS2:
LONG lDPI;
if (DevQueryCaps(GetPrintHDC(), CAPS_VERTICAL_FONT_RES, 1, &lDPI))
dpi = lDPI;
break;
#endif
default:
NS_NOTREACHED("Unexpected printing surface type");
break;
}
mAppUnitsPerDevNotScaledPixel =
NS_lround((AppUnitsPerCSSPixel() * 96) / dpi);
} else {
nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
// A value of -1 means use the maximum of 96 and the system DPI.
// A value of 0 means use the system DPI. A positive value is used as the DPI.
// This sets the physical size of a device pixel and thus controls the
// interpretation of physical units.
PRInt32 prefDPI = -1;
if (prefs) {
nsresult rv = prefs->GetIntPref("layout.css.dpi", &prefDPI);
if (NS_FAILED(rv)) {
prefDPI = -1;
}
}
if (prefDPI > 0) {
dpi = prefDPI;
} else if (mWidget) {
dpi = mWidget->GetDPI();
if (prefDPI < 0) {
dpi = PR_MAX(96.0f, dpi);
}
} else {
dpi = 96.0f;
}
// The number of device pixels per CSS pixel. A value <= 0 means choose
// automatically based on the DPI. A positive value is used as-is. This effectively
// controls the size of a CSS "px".
float devPixelsPerCSSPixel = -1.0;
if (prefs) {
nsXPIDLCString prefString;
nsresult rv = prefs->GetCharPref("layout.css.devPixelsPerPx", getter_Copies(prefString));
if (NS_SUCCEEDED(rv) && !prefString.IsEmpty()) {
devPixelsPerCSSPixel = static_cast<float>(atof(prefString));
}
}
if (devPixelsPerCSSPixel <= 0) {
if (mWidget) {
devPixelsPerCSSPixel = mWidget->GetDefaultScale();
} else {
devPixelsPerCSSPixel = 1.0;
}
}
mAppUnitsPerDevNotScaledPixel =
PR_MAX(1, NS_lround(AppUnitsPerCSSPixel() / devPixelsPerCSSPixel));
}
NS_ASSERTION(dpi != -1.0, "no dpi set");
mAppUnitsPerPhysicalInch = NS_lround(dpi * mAppUnitsPerDevNotScaledPixel);
UpdateScaledAppUnits();
return NS_OK;
}
/**
* Creates a PathExpr using the given txExprLexer
* @param lexer the txExprLexer for retrieving Tokens
*/
nsresult
txExprParser::createPathExpr(txExprLexer& lexer, txIParseContext* aContext,
Expr** aResult)
{
*aResult = nullptr;
nsAutoPtr<Expr> expr;
Token* tok = lexer.peek();
// is this a root expression?
if (tok->mType == Token::PARENT_OP) {
if (!isLocationStepToken(lexer.peekAhead())) {
lexer.nextToken();
*aResult = new RootExpr();
return NS_OK;
}
}
// parse first step (possibly a FilterExpr)
nsresult rv = NS_OK;
if (tok->mType != Token::PARENT_OP &&
tok->mType != Token::ANCESTOR_OP) {
rv = createFilterOrStep(lexer, aContext, getter_Transfers(expr));
NS_ENSURE_SUCCESS(rv, rv);
// is this a singlestep path expression?
tok = lexer.peek();
if (tok->mType != Token::PARENT_OP &&
tok->mType != Token::ANCESTOR_OP) {
*aResult = expr.forget();
return NS_OK;
}
}
else {
expr = new RootExpr();
#ifdef TX_TO_STRING
static_cast<RootExpr*>(expr.get())->setSerialize(false);
#endif
}
// We have a PathExpr containing several steps
nsAutoPtr<PathExpr> pathExpr(new PathExpr());
rv = pathExpr->addExpr(expr, PathExpr::RELATIVE_OP);
NS_ENSURE_SUCCESS(rv, rv);
expr.forget();
// this is ugly
while (1) {
PathExpr::PathOperator pathOp;
switch (lexer.peek()->mType) {
case Token::ANCESTOR_OP :
pathOp = PathExpr::DESCENDANT_OP;
break;
case Token::PARENT_OP :
pathOp = PathExpr::RELATIVE_OP;
break;
default:
*aResult = pathExpr.forget();
return NS_OK;
}
lexer.nextToken();
rv = createLocationStep(lexer, aContext, getter_Transfers(expr));
NS_ENSURE_SUCCESS(rv, rv);
rv = pathExpr->addExpr(expr, pathOp);
NS_ENSURE_SUCCESS(rv, rv);
expr.forget();
}
NS_NOTREACHED("internal xpath parser error");
return NS_ERROR_UNEXPECTED;
}
/**
* Creates a binary Expr for the given operator
*/
nsresult
txExprParser::createBinaryExpr(nsAutoPtr<Expr>& left, nsAutoPtr<Expr>& right,
Token* op, Expr** aResult)
{
NS_ASSERTION(op, "internal error");
*aResult = nullptr;
Expr* expr = nullptr;
switch (op->mType) {
//-- math ops
case Token::ADDITION_OP :
expr = new txNumberExpr(left, right, txNumberExpr::ADD);
break;
case Token::SUBTRACTION_OP:
expr = new txNumberExpr(left, right, txNumberExpr::SUBTRACT);
break;
case Token::DIVIDE_OP :
expr = new txNumberExpr(left, right, txNumberExpr::DIVIDE);
break;
case Token::MODULUS_OP :
expr = new txNumberExpr(left, right, txNumberExpr::MODULUS);
break;
case Token::MULTIPLY_OP :
expr = new txNumberExpr(left, right, txNumberExpr::MULTIPLY);
break;
//-- case boolean ops
case Token::AND_OP:
expr = new BooleanExpr(left, right, BooleanExpr::AND);
break;
case Token::OR_OP:
expr = new BooleanExpr(left, right, BooleanExpr::OR);
break;
//-- equality ops
case Token::EQUAL_OP :
expr = new RelationalExpr(left, right, RelationalExpr::EQUAL);
break;
case Token::NOT_EQUAL_OP :
expr = new RelationalExpr(left, right, RelationalExpr::NOT_EQUAL);
break;
//-- relational ops
case Token::LESS_THAN_OP:
expr = new RelationalExpr(left, right, RelationalExpr::LESS_THAN);
break;
case Token::GREATER_THAN_OP:
expr = new RelationalExpr(left, right,
RelationalExpr::GREATER_THAN);
break;
case Token::LESS_OR_EQUAL_OP:
expr = new RelationalExpr(left, right,
RelationalExpr::LESS_OR_EQUAL);
break;
case Token::GREATER_OR_EQUAL_OP:
expr = new RelationalExpr(left, right,
RelationalExpr::GREATER_OR_EQUAL);
break;
default:
NS_NOTREACHED("operator tokens should be already checked");
return NS_ERROR_UNEXPECTED;
}
NS_ENSURE_TRUE(expr, NS_ERROR_OUT_OF_MEMORY);
left.forget();
right.forget();
*aResult = expr;
return NS_OK;
}
/**
* See sbIMediaList
*/
NS_IMETHODIMP
sbLocalDatabaseMediaListBase::EnumerateItemsByProperties(sbIPropertyArray* aProperties,
sbIMediaListEnumerationListener* aEnumerationListener,
PRUint16 aEnumerationType)
{
NS_ENSURE_ARG_POINTER(aProperties);
NS_ENSURE_ARG_POINTER(aEnumerationListener);
PRUint32 propertyCount;
nsresult rv = aProperties->GetLength(&propertyCount);
NS_ENSURE_SUCCESS(rv, rv);
// It doesn't make sense to call this method without specifying any properties
// so it is probably a caller error if we have none.
NS_ENSURE_STATE(propertyCount);
// The guidArray needs AddFilter called only once per property with an
// enumerator that contains all the values. We were given an array of
// id/value pairs, so this is a little tricky. We make a hash table that
// uses the property id for a key and an array of values as its data. Then
// we load the arrays in a loop and finally call AddFilter as an enumeration
// function.
sbStringArrayHash propertyHash;
// Init with the propertyCount as the number of buckets to create. This will
// probably be too many, but it's likely less than the default of 16.
propertyHash.Init(propertyCount);
nsCOMPtr<sbIPropertyManager> propMan =
do_GetService(SB_PROPERTYMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Load the hash table with properties from the array.
for (PRUint32 index = 0; index < propertyCount; index++) {
// Get the property.
nsCOMPtr<sbIProperty> property;
rv = aProperties->GetPropertyAt(index, getter_AddRefs(property));
SB_CONTINUE_IF_FAILED(rv);
// Get the id of the property. This will be the key for the hash table.
nsString propertyID;
rv = property->GetId(propertyID);
SB_CONTINUE_IF_FAILED(rv);
// Get the string array associated with the key. If it doesn't yet exist
// then we need to create it.
sbStringArray* stringArray;
bool arrayExists = propertyHash.Get(propertyID, &stringArray);
if (!arrayExists) {
NS_NEWXPCOM(stringArray, sbStringArray);
SB_CONTINUE_IF_FALSE(stringArray);
// Try to add the array to the hash table.
bool success = propertyHash.Put(propertyID, stringArray);
if (!success) {
NS_WARNING("Failed to add string array to property hash!");
// Make sure to delete the new array, otherwise it will leak.
NS_DELETEXPCOM(stringArray);
continue;
}
}
NS_ASSERTION(stringArray, "Must have a valid pointer here!");
// Now we need a slot for the property value.
nsString* valueString = stringArray->AppendElement();
SB_CONTINUE_IF_FALSE(valueString);
// Make the value sortable and assign it
nsCOMPtr<sbIPropertyInfo> info;
rv = propMan->GetPropertyInfo(propertyID, getter_AddRefs(info));
SB_CONTINUE_IF_FAILED(rv);
nsAutoString value;
rv = property->GetValue(value);
SB_CONTINUE_IF_FAILED(rv);
nsAutoString sortableValue;
rv = info->MakeSortable(value, *valueString);
SB_CONTINUE_IF_FAILED(rv);
}
switch (aEnumerationType) {
case sbIMediaList::ENUMERATIONTYPE_LOCKING: {
NS_ENSURE_TRUE(mFullArrayMonitor, NS_ERROR_FAILURE);
nsAutoMonitor mon(mFullArrayMonitor);
// Don't reenter!
NS_ENSURE_FALSE(mLockedEnumerationActive, NS_ERROR_FAILURE);
mLockedEnumerationActive = PR_TRUE;
PRUint16 stepResult;
rv = aEnumerationListener->OnEnumerationBegin(this, &stepResult);
if (NS_SUCCEEDED(rv)) {
if (stepResult == sbIMediaListEnumerationListener::CONTINUE) {
rv = EnumerateItemsByPropertiesInternal(&propertyHash,
aEnumerationListener);
}
else {
// The user cancelled the enumeration.
rv = NS_ERROR_ABORT;
}
}
mLockedEnumerationActive = PR_FALSE;
} break; // ENUMERATIONTYPE_LOCKING
case sbIMediaList::ENUMERATIONTYPE_SNAPSHOT: {
PRUint16 stepResult;
rv = aEnumerationListener->OnEnumerationBegin(this, &stepResult);
if (NS_SUCCEEDED(rv)) {
if (stepResult == sbIMediaListEnumerationListener::CONTINUE) {
rv = EnumerateItemsByPropertiesInternal(&propertyHash,
aEnumerationListener);
}
else {
// The user cancelled the enumeration.
rv = NS_ERROR_ABORT;
}
}
} break; // ENUMERATIONTYPE_SNAPSHOT
default: {
NS_NOTREACHED("Invalid enumeration type");
rv = NS_ERROR_INVALID_ARG;
} break;
}
aEnumerationListener->OnEnumerationEnd(this, rv);
return NS_OK;
}
NS_IMETHODIMP nsExtProtocolChannel::Resume()
{
NS_NOTREACHED("Resume");
return NS_ERROR_NOT_IMPLEMENTED;
}
// Determine if any URI of the window hierarchy of aWindow is foreign with
// respect to aSecondURI. See docs for mozIThirdPartyUtil.
NS_IMETHODIMP
ThirdPartyUtil::IsThirdPartyWindow(nsIDOMWindow* aWindow,
nsIURI* aURI,
bool* aResult)
{
NS_ENSURE_ARG(aWindow);
NS_ASSERTION(aResult, "null outparam pointer");
bool result;
// Get the URI of the window, and its base domain.
nsresult rv;
nsCOMPtr<nsIURI> currentURI;
rv = GetURIFromWindow(aWindow, getter_AddRefs(currentURI));
NS_ENSURE_SUCCESS(rv, rv);
nsCString bottomDomain;
rv = GetBaseDomain(currentURI, bottomDomain);
if (NS_FAILED(rv))
return rv;
if (aURI) {
// Determine whether aURI is foreign with respect to currentURI.
rv = IsThirdPartyInternal(bottomDomain, aURI, &result);
if (NS_FAILED(rv))
return rv;
if (result) {
*aResult = true;
return NS_OK;
}
}
nsCOMPtr<nsIDOMWindow> current = aWindow, parent;
nsCOMPtr<nsIURI> parentURI;
do {
// We use GetScriptableParent rather than GetParent because we consider
// <iframe mozbrowser/mozapp> to be a top-level frame.
rv = current->GetScriptableParent(getter_AddRefs(parent));
NS_ENSURE_SUCCESS(rv, rv);
if (SameCOMIdentity(parent, current)) {
// We're at the topmost content window. We already know the answer.
*aResult = false;
return NS_OK;
}
rv = GetURIFromWindow(parent, getter_AddRefs(parentURI));
NS_ENSURE_SUCCESS(rv, rv);
rv = IsThirdPartyInternal(bottomDomain, parentURI, &result);
if (NS_FAILED(rv))
return rv;
if (result) {
*aResult = true;
return NS_OK;
}
current = parent;
currentURI = parentURI;
} while (1);
NS_NOTREACHED("should've returned");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
sbLocalDatabaseMediaListBase::Remove(sbIMediaItem* aMediaItem)
{
NS_NOTREACHED("Not meant to be implemented in this base class");
return NS_ERROR_NOT_IMPLEMENTED;
}
void
ClientCanvasLayer::Initialize(const Data& aData)
{
CopyableCanvasLayer::Initialize(aData);
mCanvasClient = nullptr;
if (mGLContext) {
GLScreenBuffer* screen = mGLContext->Screen();
SurfaceCaps caps = screen->Caps();
if (mStream) {
// The screen caps are irrelevant if we're using a separate stream
caps = GetContentFlags() & CONTENT_OPAQUE ? SurfaceCaps::ForRGB() : SurfaceCaps::ForRGBA();
}
SurfaceStreamType streamType =
SurfaceStream::ChooseGLStreamType(SurfaceStream::OffMainThread,
screen->PreserveBuffer());
SurfaceFactory_GL* factory = nullptr;
if (!gfxPrefs::WebGLForceLayersReadback()) {
if (ClientManager()->AsShadowForwarder()->GetCompositorBackendType() == mozilla::layers::LayersBackend::LAYERS_OPENGL) {
if (mGLContext->GetContextType() == GLContextType::EGL) {
bool isCrossProcess = !(XRE_GetProcessType() == GeckoProcessType_Default);
if (!isCrossProcess) {
// [Basic/OGL Layers, OMTC] WebGL layer init.
factory = SurfaceFactory_EGLImage::Create(mGLContext, caps);
} else {
// [Basic/OGL Layers, OOPC] WebGL layer init. (Out Of Process Compositing)
#ifdef MOZ_WIDGET_GONK
factory = new SurfaceFactory_Gralloc(mGLContext, caps, ClientManager()->AsShadowForwarder());
#else
// we could do readback here maybe
NS_NOTREACHED("isCrossProcess but not on native B2G!");
#endif
}
} else {
// [Basic Layers, OMTC] WebGL layer init.
// Well, this *should* work...
#ifdef XP_MACOSX
factory = new SurfaceFactory_IOSurface(mGLContext, caps);
#else
factory = new SurfaceFactory_GLTexture(mGLContext, nullptr, caps);
#endif
}
}
}
if (mStream) {
// We're using a stream other than the one in the default screen
mFactory = factory;
if (!mFactory) {
// Absolutely must have a factory here, so create a basic one
mFactory = new SurfaceFactory_Basic(mGLContext, caps);
}
gfx::IntSize size = gfx::IntSize(aData.mSize.width, aData.mSize.height);
mTextureSurface = SharedSurface_GLTexture::Create(mGLContext, mGLContext,
mGLContext->GetGLFormats(),
size, caps.alpha, aData.mTexID);
SharedSurface* producer = mStream->SwapProducer(mFactory, size);
if (!producer) {
// Fallback to basic factory
delete mFactory;
mFactory = new SurfaceFactory_Basic(mGLContext, caps);
producer = mStream->SwapProducer(mFactory, size);
MOZ_ASSERT(producer, "Failed to create initial canvas surface with basic factory");
}
} else if (factory) {
screen->Morph(factory, streamType);
}
}
}
NS_IMETHODIMP
sbLocalDatabaseMediaListBase::RemoveByIndex(PRUint32 aIndex)
{
NS_NOTREACHED("Not meant to be implemented in this base class");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsAutoCompleteController::GetCellValue(PRInt32 row, nsITreeColumn* col, nsAString& _retval)
{
NS_NOTREACHED("all of our cells are text");
return NS_OK;
}
NS_IMETHODIMP
sbLocalDatabaseMediaListBase::RemoveSome(nsISimpleEnumerator* aMediaItems)
{
NS_NOTREACHED("Not meant to be implemented in this base class");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
DefaultController::OnClose(void) {
NS_NOTREACHED("OnClose should not be called for TaskbarWindowPreviews");
return NS_OK;
}
NS_IMETHODIMP
sbLocalDatabaseMediaListBase::Clear()
{
NS_NOTREACHED("Not meant to be implemented in this base class");
return NS_ERROR_NOT_IMPLEMENTED;
}
/*
* Add external H.264 video codec.
*/
MediaConduitErrorCode
MediaPipelineFactory::EnsureExternalCodec(VideoSessionConduit& aConduit,
VideoCodecConfig* aConfig,
bool aIsSend)
{
if (aConfig->mName == "VP8") {
#ifdef MOZ_WEBRTC_MEDIACODEC
if (aIsSend) {
#ifdef MOZILLA_INTERNAL_API
bool enabled = mozilla::Preferences::GetBool("media.navigator.hardware.vp8_encode.acceleration_enabled", false);
#else
bool enabled = false;
#endif
if (enabled) {
nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
if (gfxInfo) {
int32_t status;
if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE, &status))) {
if (status != nsIGfxInfo::FEATURE_STATUS_OK) {
NS_WARNING("VP8 encoder hardware is not whitelisted: disabling.\n");
} else {
VideoEncoder* encoder = nullptr;
encoder = MediaCodecVideoCodec::CreateEncoder(MediaCodecVideoCodec::CodecType::CODEC_VP8);
if (encoder) {
return aConduit.SetExternalSendCodec(aConfig, encoder);
} else {
return kMediaConduitNoError;
}
}
}
}
}
} else {
#ifdef MOZILLA_INTERNAL_API
bool enabled = mozilla::Preferences::GetBool("media.navigator.hardware.vp8_decode.acceleration_enabled", false);
#else
bool enabled = false;
#endif
if (enabled) {
nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
if (gfxInfo) {
int32_t status;
if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE, &status))) {
if (status != nsIGfxInfo::FEATURE_STATUS_OK) {
NS_WARNING("VP8 decoder hardware is not whitelisted: disabling.\n");
} else {
VideoDecoder* decoder;
decoder = MediaCodecVideoCodec::CreateDecoder(MediaCodecVideoCodec::CodecType::CODEC_VP8);
if (decoder) {
return aConduit.SetExternalRecvCodec(aConfig, decoder);
} else {
return kMediaConduitNoError;
}
}
}
}
}
}
#endif
return kMediaConduitNoError;
} else if (aConfig->mName == "VP9") {
return kMediaConduitNoError;
} else if (aConfig->mName == "H264") {
if (aConduit.CodecPluginID() != 0) {
return kMediaConduitNoError;
}
// Register H.264 codec.
if (aIsSend) {
VideoEncoder* encoder = nullptr;
#ifdef MOZ_WEBRTC_OMX
encoder =
OMXVideoCodec::CreateEncoder(OMXVideoCodec::CodecType::CODEC_H264);
#else
encoder = GmpVideoCodec::CreateEncoder();
#endif
if (encoder) {
return aConduit.SetExternalSendCodec(aConfig, encoder);
} else {
return kMediaConduitInvalidSendCodec;
}
} else {
VideoDecoder* decoder = nullptr;
#ifdef MOZ_WEBRTC_OMX
decoder =
OMXVideoCodec::CreateDecoder(OMXVideoCodec::CodecType::CODEC_H264);
#else
decoder = GmpVideoCodec::CreateDecoder();
#endif
if (decoder) {
return aConduit.SetExternalRecvCodec(aConfig, decoder);
} else {
return kMediaConduitInvalidReceiveCodec;
}
}
NS_NOTREACHED("Shouldn't get here!");
} else {
MOZ_MTLOG(ML_ERROR,
"Invalid video codec configured: " << aConfig->mName.c_str());
return aIsSend ? kMediaConduitInvalidSendCodec
: kMediaConduitInvalidReceiveCodec;
}
NS_NOTREACHED("Shouldn't get here!");
}
NS_IMETHODIMP
sbLocalDatabaseMediaListBase::GetType(nsAString& aType)
{
NS_NOTREACHED("Not meant to be implemented in this base class");
return NS_ERROR_NOT_IMPLEMENTED;
}
void nsProfileLock::FatalSignalHandler(int signo
#ifdef SA_SIGINFO
, siginfo_t *info, void *context
#endif
)
{
// Remove any locks still held.
RemovePidLockFiles(true);
// Chain to the old handler, which may exit.
struct sigaction *oldact = nullptr;
switch (signo) {
case SIGHUP:
oldact = &SIGHUP_oldact;
break;
case SIGINT:
oldact = &SIGINT_oldact;
break;
case SIGQUIT:
oldact = &SIGQUIT_oldact;
break;
case SIGILL:
oldact = &SIGILL_oldact;
break;
case SIGABRT:
oldact = &SIGABRT_oldact;
break;
case SIGSEGV:
oldact = &SIGSEGV_oldact;
break;
case SIGTERM:
oldact = &SIGTERM_oldact;
break;
default:
NS_NOTREACHED("bad signo");
break;
}
if (oldact) {
if (oldact->sa_handler == SIG_DFL) {
// Make sure the default sig handler is executed
// We need it to get Mozilla to dump core.
sigaction(signo,oldact, nullptr);
// Now that we've restored the default handler, unmask the
// signal and invoke it.
sigset_t unblock_sigs;
sigemptyset(&unblock_sigs);
sigaddset(&unblock_sigs, signo);
sigprocmask(SIG_UNBLOCK, &unblock_sigs, nullptr);
raise(signo);
}
#ifdef SA_SIGINFO
else if (oldact->sa_sigaction &&
(oldact->sa_flags & SA_SIGINFO) == SA_SIGINFO) {
oldact->sa_sigaction(signo, info, context);
}
#endif
else if (oldact->sa_handler && oldact->sa_handler != SIG_IGN)
{
oldact->sa_handler(signo);
}
}
#ifdef MOZ_B2G
switch (signo) {
case SIGQUIT:
case SIGILL:
case SIGABRT:
case SIGSEGV:
#ifndef MOZ_CRASHREPORTER
// Retrigger the signal for those that can generate a core dump
signal(signo, SIG_DFL);
if (info->si_code <= 0) {
if (syscall(__NR_tgkill, getpid(), syscall(__NR_gettid), signo) < 0) {
break;
}
}
#endif
return;
default:
break;
}
#endif
// Backstop exit call, just in case.
_exit(signo);
}
/**
* See sbIMediaList
*/
NS_IMETHODIMP
sbLocalDatabaseMediaListBase::EnumerateItemsByProperty(const nsAString& aID,
const nsAString& aValue,
sbIMediaListEnumerationListener* aEnumerationListener,
PRUint16 aEnumerationType)
{
NS_ENSURE_ARG_POINTER(aEnumerationListener);
nsresult rv = NS_ERROR_UNEXPECTED;
// A property id must be specified.
NS_ENSURE_TRUE(!aID.IsEmpty(), NS_ERROR_INVALID_ARG);
// Get the sortable format of the value
nsCOMPtr<sbIPropertyManager> propMan =
do_GetService(SB_PROPERTYMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<sbIPropertyInfo> info;
rv = propMan->GetPropertyInfo(aID, getter_AddRefs(info));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString sortableValue;
rv = info->MakeSortable(aValue, sortableValue);
NS_ENSURE_SUCCESS(rv, rv);
// Make a single-item string array to hold our property value.
sbStringArray valueArray(1);
nsString* value = valueArray.AppendElement(sortableValue);
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
// Make a string enumerator for it.
nsCOMPtr<nsIStringEnumerator> valueEnum =
new sbTArrayStringEnumerator(&valueArray);
NS_ENSURE_TRUE(valueEnum, NS_ERROR_OUT_OF_MEMORY);
switch (aEnumerationType) {
case sbIMediaList::ENUMERATIONTYPE_LOCKING: {
NS_ENSURE_TRUE(mFullArrayMonitor, NS_ERROR_FAILURE);
nsAutoMonitor mon(mFullArrayMonitor);
// Don't reenter!
NS_ENSURE_FALSE(mLockedEnumerationActive, NS_ERROR_FAILURE);
mLockedEnumerationActive = PR_TRUE;
PRUint16 stepResult;
rv = aEnumerationListener->OnEnumerationBegin(this, &stepResult);
if (NS_SUCCEEDED(rv)) {
if (stepResult == sbIMediaListEnumerationListener::CONTINUE) {
rv = EnumerateItemsByPropertyInternal(aID, valueEnum,
aEnumerationListener);
}
else {
// The user cancelled the enumeration.
rv = NS_ERROR_ABORT;
}
}
mLockedEnumerationActive = PR_FALSE;
} break; // ENUMERATIONTYPE_LOCKING
case sbIMediaList::ENUMERATIONTYPE_SNAPSHOT: {
PRUint16 stepResult;
rv = aEnumerationListener->OnEnumerationBegin(this, &stepResult);
if (NS_SUCCEEDED(rv)) {
if (stepResult == sbIMediaListEnumerationListener::CONTINUE) {
rv = EnumerateItemsByPropertyInternal(aID, valueEnum,
aEnumerationListener);
}
else {
// The user cancelled the enumeration.
rv = NS_ERROR_ABORT;
}
}
} break; // ENUMERATIONTYPE_SNAPSHOT
default: {
NS_NOTREACHED("Invalid enumeration type");
rv = NS_ERROR_INVALID_ARG;
} break;
}
aEnumerationListener->OnEnumerationEnd(this, rv);
return NS_OK;
}
NS_IMETHODIMP nsIconChannel::SetContentLength(PRInt64 aContentLength)
{
NS_NOTREACHED("nsIconChannel::SetContentLength");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
SendOperationListener::SetMessageKey(uint32_t aKey)
{
NS_NOTREACHED("SendOperationListener::SetMessageKey()");
return NS_ERROR_NOT_IMPLEMENTED;
}