nsresult NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult, const nsAString& aNamespaceURI, const nsAString& aQualifiedName, nsIDOMDocumentType* aDoctype, nsIURI* aDocumentURI, nsIURI* aBaseURI, nsIPrincipal* aPrincipal, bool aLoadedAsData, nsIScriptGlobalObject* aEventObject, DocumentFlavor aFlavor) { // Note: can't require that aDocumentURI/aBaseURI/aPrincipal be non-null, // since at least one caller (XMLHttpRequest) doesn't have decent args to // pass in. nsresult rv; *aInstancePtrResult = nullptr; nsCOMPtr<nsIDocument> d; bool isHTML = false; bool isXHTML = false; if (aFlavor == DocumentFlavorSVG) { rv = NS_NewSVGDocument(getter_AddRefs(d)); } else if (aFlavor == DocumentFlavorHTML) { rv = NS_NewHTMLDocument(getter_AddRefs(d)); isHTML = true; } else if (aDoctype) { nsAutoString publicId, name; aDoctype->GetPublicId(publicId); if (publicId.IsEmpty()) { aDoctype->GetName(name); } if (name.EqualsLiteral("html") || publicId.EqualsLiteral("-//W3C//DTD HTML 4.01//EN") || publicId.EqualsLiteral("-//W3C//DTD HTML 4.01 Frameset//EN") || publicId.EqualsLiteral("-//W3C//DTD HTML 4.01 Transitional//EN") || publicId.EqualsLiteral("-//W3C//DTD HTML 4.0//EN") || publicId.EqualsLiteral("-//W3C//DTD HTML 4.0 Frameset//EN") || publicId.EqualsLiteral("-//W3C//DTD HTML 4.0 Transitional//EN")) { rv = NS_NewHTMLDocument(getter_AddRefs(d)); isHTML = true; } else if (publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Strict//EN") || publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Transitional//EN") || publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Frameset//EN")) { rv = NS_NewHTMLDocument(getter_AddRefs(d)); isHTML = true; isXHTML = true; } else if (publicId.EqualsLiteral("-//W3C//DTD SVG 1.1//EN")) { rv = NS_NewSVGDocument(getter_AddRefs(d)); } // XXX Add support for XUL documents. else { rv = NS_NewXMLDocument(getter_AddRefs(d)); } } else { rv = NS_NewXMLDocument(getter_AddRefs(d)); } if (NS_FAILED(rv)) { return rv; } d->SetScriptHandlingObject(aEventObject); if (isHTML) { nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(d); NS_ASSERTION(htmlDoc, "HTML Document doesn't implement nsIHTMLDocument?"); htmlDoc->SetCompatibilityMode(eCompatibility_FullStandards); htmlDoc->SetIsXHTML(isXHTML); } nsDocument* doc = static_cast<nsDocument*>(d.get()); doc->SetLoadedAsData(aLoadedAsData); doc->nsDocument::SetDocumentURI(aDocumentURI); // Must set the principal first, since SetBaseURI checks it. doc->SetPrincipal(aPrincipal); doc->SetBaseURI(aBaseURI); // XMLDocuments and documents "created in memory" get to be UTF-8 by default, // unlike the legacy HTML mess doc->SetDocumentCharacterSet(NS_LITERAL_CSTRING("UTF-8")); if (aDoctype) { nsCOMPtr<nsIDOMNode> tmpNode; rv = doc->AppendChild(aDoctype, getter_AddRefs(tmpNode)); NS_ENSURE_SUCCESS(rv, rv); } if (!aQualifiedName.IsEmpty()) { nsCOMPtr<nsIDOMElement> root; rv = doc->CreateElementNS(aNamespaceURI, aQualifiedName, getter_AddRefs(root)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIDOMNode> tmpNode; rv = doc->AppendChild(root, getter_AddRefs(tmpNode)); NS_ENSURE_SUCCESS(rv, rv); } *aInstancePtrResult = doc; NS_ADDREF(*aInstancePtrResult); return NS_OK; }
RangedPtr<const PRUnichar> SVGContentUtils::GetEndRangedPtr(const nsAString& aString) { return RangedPtr<const PRUnichar>(aString.Data() + aString.Length(), aString.Data(), aString.Length()); }
NS_IMETHODIMP nsDBusHandlerApp::GetName(nsAString& aName) { aName.Assign(mName); return NS_OK; }
nsresult nsXULMenubarAccessible::GetNameInternal(nsAString& aName) { aName.AssignLiteral("Application"); return NS_OK; }
static int32_t BlacklistFeatureToGfxFeature(const nsAString& aFeature) { MOZ_ASSERT(!aFeature.IsEmpty()); if (aFeature.EqualsLiteral("DIRECT2D")) return nsIGfxInfo::FEATURE_DIRECT2D; else if (aFeature.EqualsLiteral("DIRECT3D_9_LAYERS")) return nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS; else if (aFeature.EqualsLiteral("DIRECT3D_10_LAYERS")) return nsIGfxInfo::FEATURE_DIRECT3D_10_LAYERS; else if (aFeature.EqualsLiteral("DIRECT3D_10_1_LAYERS")) return nsIGfxInfo::FEATURE_DIRECT3D_10_1_LAYERS; else if (aFeature.EqualsLiteral("DIRECT3D_11_LAYERS")) return nsIGfxInfo::FEATURE_DIRECT3D_11_LAYERS; else if (aFeature.EqualsLiteral("DIRECT3D_11_ANGLE")) return nsIGfxInfo::FEATURE_DIRECT3D_11_ANGLE; else if (aFeature.EqualsLiteral("HARDWARE_VIDEO_DECODING")) return nsIGfxInfo::FEATURE_HARDWARE_VIDEO_DECODING; else if (aFeature.EqualsLiteral("OPENGL_LAYERS")) return nsIGfxInfo::FEATURE_OPENGL_LAYERS; else if (aFeature.EqualsLiteral("WEBGL_OPENGL")) return nsIGfxInfo::FEATURE_WEBGL_OPENGL; else if (aFeature.EqualsLiteral("WEBGL_ANGLE")) return nsIGfxInfo::FEATURE_WEBGL_ANGLE; else if (aFeature.EqualsLiteral("WEBGL_MSAA")) return nsIGfxInfo::FEATURE_WEBGL_MSAA; else if (aFeature.EqualsLiteral("STAGEFRIGHT")) return nsIGfxInfo::FEATURE_STAGEFRIGHT; else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION_ENCODE")) return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE; else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION_DECODE")) return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE; else if (aFeature.EqualsLiteral("WEBRTC_HW_ACCELERATION")) return nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION; else if (aFeature.EqualsLiteral("CANVAS2D_ACCELERATION")) return nsIGfxInfo::FEATURE_CANVAS2D_ACCELERATION; // If we don't recognize the feature, it may be new, and something // this version doesn't understand. So, nothing to do. This is // different from feature not being specified at all, in which case // this method should not get called and we should continue with the // "all features" blocklisting. return -1; }
/* readonly attribute wstring name; */ NS_IMETHODIMP nsSchemaBuiltinType::GetName(nsAString& aName) { switch (mBuiltinType) { case BUILTIN_TYPE_ANYTYPE: aName.AssignLiteral("anyType"); break; case BUILTIN_TYPE_STRING: aName.AssignLiteral("string"); break; case BUILTIN_TYPE_NORMALIZED_STRING: aName.AssignLiteral("normalizedString"); break; case BUILTIN_TYPE_TOKEN: aName.AssignLiteral("token"); break; case BUILTIN_TYPE_BYTE: aName.AssignLiteral("byte"); break; case BUILTIN_TYPE_UNSIGNEDBYTE: aName.AssignLiteral("unsignedByte"); break; case BUILTIN_TYPE_BASE64BINARY: aName.AssignLiteral("base64Binary"); break; case BUILTIN_TYPE_HEXBINARY: aName.AssignLiteral("hexBinary"); break; case BUILTIN_TYPE_INTEGER: aName.AssignLiteral("integer"); break; case BUILTIN_TYPE_POSITIVEINTEGER: aName.AssignLiteral("positiveInteger"); break; case BUILTIN_TYPE_NEGATIVEINTEGER: aName.AssignLiteral("negativeInteger"); break; case BUILTIN_TYPE_NONNEGATIVEINTEGER: aName.AssignLiteral("nonNegativeInteger"); break; case BUILTIN_TYPE_NONPOSITIVEINTEGER: aName.AssignLiteral("nonPositiveInteger"); break; case BUILTIN_TYPE_INT: aName.AssignLiteral("int"); break; case BUILTIN_TYPE_UNSIGNEDINT: aName.AssignLiteral("unsignedInt"); break; case BUILTIN_TYPE_LONG: aName.AssignLiteral("long"); break; case BUILTIN_TYPE_UNSIGNEDLONG: aName.AssignLiteral("unsignedLong"); break; case BUILTIN_TYPE_SHORT: aName.AssignLiteral("short"); break; case BUILTIN_TYPE_UNSIGNEDSHORT: aName.AssignLiteral("unsignedShort"); break; case BUILTIN_TYPE_DECIMAL: aName.AssignLiteral("decimal"); break; case BUILTIN_TYPE_FLOAT: aName.AssignLiteral("float"); break; case BUILTIN_TYPE_DOUBLE: aName.AssignLiteral("double"); break; case BUILTIN_TYPE_BOOLEAN: aName.AssignLiteral("boolean"); break; case BUILTIN_TYPE_TIME: aName.AssignLiteral("time"); break; case BUILTIN_TYPE_DATETIME: aName.AssignLiteral("dateTime"); break; case BUILTIN_TYPE_DURATION: aName.AssignLiteral("duration"); break; case BUILTIN_TYPE_DATE: aName.AssignLiteral("date"); break; case BUILTIN_TYPE_GMONTH: aName.AssignLiteral("gMonth"); break; case BUILTIN_TYPE_GYEAR: aName.AssignLiteral("gYear"); break; case BUILTIN_TYPE_GYEARMONTH: aName.AssignLiteral("gYearMonth"); break; case BUILTIN_TYPE_GDAY: aName.AssignLiteral("gDay"); break; case BUILTIN_TYPE_GMONTHDAY: aName.AssignLiteral("gMonthDay"); break; case BUILTIN_TYPE_NAME: aName.AssignLiteral("Name"); break; case BUILTIN_TYPE_QNAME: aName.AssignLiteral("QName"); break; case BUILTIN_TYPE_NCNAME: aName.AssignLiteral("NCName"); break; case BUILTIN_TYPE_ANYURI: aName.AssignLiteral("anyURI"); break; case BUILTIN_TYPE_LANGUAGE: aName.AssignLiteral("language"); break; case BUILTIN_TYPE_ID: aName.AssignLiteral("ID"); break; case BUILTIN_TYPE_IDREF: aName.AssignLiteral("IDREF"); break; case BUILTIN_TYPE_IDREFS: aName.AssignLiteral("IDREFS"); break; case BUILTIN_TYPE_ENTITY: aName.AssignLiteral("ENTITY"); break; case BUILTIN_TYPE_ENTITIES: aName.AssignLiteral("ENTITIES"); break; case BUILTIN_TYPE_NOTATION: aName.AssignLiteral("NOTATION"); break; case BUILTIN_TYPE_NMTOKEN: aName.AssignLiteral("NMTOKEN"); break; case BUILTIN_TYPE_NMTOKENS: aName.AssignLiteral("NMTOKENS"); break; default: NS_ERROR("Unknown builtin type!"); aName.Truncate(); } return NS_OK; }
/* static */ already_AddRefed<MediaEncoder> MediaEncoder::CreateEncoder(const nsAString& aMIMEType, uint8_t aTrackTypes) { if (!gMediaEncoderLog) { gMediaEncoderLog = PR_NewLogModule("MediaEncoder"); } PROFILER_LABEL("MediaEncoder", "CreateEncoder", js::ProfileEntry::Category::OTHER); nsAutoPtr<ContainerWriter> writer; nsAutoPtr<AudioTrackEncoder> audioEncoder; nsAutoPtr<VideoTrackEncoder> videoEncoder; nsRefPtr<MediaEncoder> encoder; nsString mimeType; if (!aTrackTypes) { LOG(PR_LOG_ERROR, ("NO TrackTypes!!!")); return nullptr; } #ifdef MOZ_WEBM_ENCODER else if (MediaEncoder::IsWebMEncoderEnabled() && (aMIMEType.EqualsLiteral(VIDEO_WEBM) || (aTrackTypes & ContainerWriter::CREATE_VIDEO_TRACK))) { if (aTrackTypes & ContainerWriter::CREATE_AUDIO_TRACK) { audioEncoder = new VorbisTrackEncoder(); NS_ENSURE_TRUE(audioEncoder, nullptr); } videoEncoder = new VP8TrackEncoder(); writer = new WebMWriter(aTrackTypes); NS_ENSURE_TRUE(writer, nullptr); NS_ENSURE_TRUE(videoEncoder, nullptr); mimeType = NS_LITERAL_STRING(VIDEO_WEBM); } #endif //MOZ_WEBM_ENCODER #ifdef MOZ_OMX_ENCODER else if (MediaEncoder::IsOMXEncoderEnabled() && (aMIMEType.EqualsLiteral(VIDEO_MP4) || (aTrackTypes & ContainerWriter::CREATE_VIDEO_TRACK))) { if (aTrackTypes & ContainerWriter::CREATE_AUDIO_TRACK) { audioEncoder = new OmxAACAudioTrackEncoder(); NS_ENSURE_TRUE(audioEncoder, nullptr); } videoEncoder = new OmxVideoTrackEncoder(); writer = new ISOMediaWriter(aTrackTypes); NS_ENSURE_TRUE(writer, nullptr); NS_ENSURE_TRUE(videoEncoder, nullptr); mimeType = NS_LITERAL_STRING(VIDEO_MP4); } else if (MediaEncoder::IsOMXEncoderEnabled() && (aMIMEType.EqualsLiteral(AUDIO_3GPP))) { audioEncoder = new OmxAMRAudioTrackEncoder(); NS_ENSURE_TRUE(audioEncoder, nullptr); writer = new ISOMediaWriter(aTrackTypes, ISOMediaWriter::TYPE_FRAG_3GP); NS_ENSURE_TRUE(writer, nullptr); mimeType = NS_LITERAL_STRING(AUDIO_3GPP); } #endif // MOZ_OMX_ENCODER else if (MediaDecoder::IsOggEnabled() && MediaDecoder::IsOpusEnabled() && (aMIMEType.EqualsLiteral(AUDIO_OGG) || (aTrackTypes & ContainerWriter::CREATE_AUDIO_TRACK))) { writer = new OggWriter(); audioEncoder = new OpusTrackEncoder(); NS_ENSURE_TRUE(writer, nullptr); NS_ENSURE_TRUE(audioEncoder, nullptr); mimeType = NS_LITERAL_STRING(AUDIO_OGG); } else { LOG(PR_LOG_ERROR, ("Can not find any encoder to record this media stream")); return nullptr; } LOG(PR_LOG_DEBUG, ("Create encoder result:a[%d] v[%d] w[%d] mimeType = %s.", audioEncoder != nullptr, videoEncoder != nullptr, writer != nullptr, mimeType.get())); encoder = new MediaEncoder(writer.forget(), audioEncoder.forget(), videoEncoder.forget(), mimeType); return encoder.forget(); }
NS_IMETHODIMP Navigator::GetVendorSub(nsAString& aVendorSub) { aVendorSub.Truncate(); return NS_OK; }
NS_IMETHODIMP Navigator::GetProduct(nsAString& aProduct) { aProduct.AssignLiteral("Gecko"); return NS_OK; }
// performs a locale sensitive date formatting operation on the struct tm parameter nsresult nsDateTimeFormatWin::FormatTMTime(nsILocale* locale, const nsDateFormatSelector dateFormatSelector, const nsTimeFormatSelector timeFormatSelector, const struct tm* tmTime, nsAString& stringOut) { SYSTEMTIME system_time; DWORD dwFlags_Date = 0, dwFlags_Time = 0; int dateLen, timeLen; char16_t dateBuffer[NSDATETIMEFORMAT_BUFFER_LEN], timeBuffer[NSDATETIMEFORMAT_BUFFER_LEN]; // set up locale data (void) Initialize(locale); // Map tm to SYSTEMTIME system_time.wYear = 1900 + tmTime->tm_year; system_time.wMonth = tmTime->tm_mon + 1; system_time.wDayOfWeek = tmTime->tm_wday; system_time.wDay = tmTime->tm_mday; system_time.wHour = tmTime->tm_hour; system_time.wMinute = tmTime->tm_min; system_time.wSecond = tmTime->tm_sec; system_time.wMilliseconds = 0; // Map to WinAPI date format switch (dateFormatSelector) { case kDateFormatLong: dwFlags_Date = DATE_LONGDATE; break; case kDateFormatShort: dwFlags_Date = DATE_SHORTDATE; break; case kDateFormatWeekday: dwFlags_Date = 0; break; case kDateFormatYearMonth: dwFlags_Date = 0; // TODO:only availabe NT5 break; } // Map to WinAPI time format switch (timeFormatSelector) { case kTimeFormatSeconds: dwFlags_Time = 0; break; case kTimeFormatNoSeconds: dwFlags_Time = TIME_NOSECONDS; break; case kTimeFormatSecondsForce24Hour: dwFlags_Time = TIME_FORCE24HOURFORMAT; break; case kTimeFormatNoSecondsForce24Hour: dwFlags_Time = TIME_NOSECONDS + TIME_FORCE24HOURFORMAT; break; } // Call GetDateFormatW if (dateFormatSelector == kDateFormatNone) { dateLen = 0; } else { if (dateFormatSelector == kDateFormatYearMonth) { dateLen = nsGetDateFormatW(0, &system_time, "yyyy/MM", dateBuffer, NSDATETIMEFORMAT_BUFFER_LEN); } else if (dateFormatSelector == kDateFormatWeekday) { dateLen = nsGetDateFormatW(0, &system_time, "ddd", dateBuffer, NSDATETIMEFORMAT_BUFFER_LEN); } else { dateLen = nsGetDateFormatW(dwFlags_Date, &system_time, nullptr, dateBuffer, NSDATETIMEFORMAT_BUFFER_LEN); } if (dateLen != 0) { dateLen--; // Since the count includes the terminating null. } } // Call GetTimeFormatW if (timeFormatSelector == kTimeFormatNone) { timeLen = 0; } else { timeLen = nsGetTimeFormatW(dwFlags_Time, &system_time, nullptr, timeBuffer, NSDATETIMEFORMAT_BUFFER_LEN); if (timeLen != 0) { timeLen--; // Since the count includes the terminating null. } } NS_ASSERTION(NSDATETIMEFORMAT_BUFFER_LEN >= (uint32_t) (dateLen + 1), "internal date buffer is not large enough"); NS_ASSERTION(NSDATETIMEFORMAT_BUFFER_LEN >= (uint32_t) (timeLen + 1), "internal time buffer is not large enough"); // Copy the result stringOut.Truncate(); if (dateLen != 0 && timeLen != 0) { stringOut.Assign(dateBuffer, dateLen); stringOut.Append((char16_t *)(L" "), 1); stringOut.Append(timeBuffer, timeLen); } else if (dateLen != 0 && timeLen == 0) { stringOut.Assign(dateBuffer, dateLen); } else if (dateLen == 0 && timeLen != 0) { stringOut.Assign(timeBuffer, timeLen); } return NS_OK; }
nsresult nsHTMLCanvasElement::ToDataURLImpl(const nsAString& aMimeType, nsIVariant* aEncoderOptions, nsAString& aDataURL) { bool fallbackToPNG = false; nsIntSize size = GetWidthHeight(); if (size.height == 0 || size.width == 0) { aDataURL = NS_LITERAL_STRING("data:,"); return NS_OK; } nsAutoString type; nsresult rv = nsContentUtils::ASCIIToLower(aMimeType, type); if (NS_FAILED(rv)) { return rv; } nsAutoString params; // Quality parameter is only valid for the image/jpeg MIME type if (type.EqualsLiteral("image/jpeg")) { PRUint16 vartype; if (aEncoderOptions && NS_SUCCEEDED(aEncoderOptions->GetDataType(&vartype)) && vartype <= nsIDataType::VTYPE_DOUBLE) { double quality; // Quality must be between 0.0 and 1.0, inclusive if (NS_SUCCEEDED(aEncoderOptions->GetAsDouble(&quality)) && quality >= 0.0 && quality <= 1.0) { params.AppendLiteral("quality="); params.AppendInt(NS_lround(quality * 100.0)); } } } // If we haven't parsed the params check for proprietary options. // The proprietary option -moz-parse-options will take a image lib encoder // parse options string as is and pass it to the encoder. bool usingCustomParseOptions = false; if (params.Length() == 0) { NS_NAMED_LITERAL_STRING(mozParseOptions, "-moz-parse-options:"); nsAutoString paramString; if (NS_SUCCEEDED(aEncoderOptions->GetAsAString(paramString)) && StringBeginsWith(paramString, mozParseOptions)) { nsDependentSubstring parseOptions = Substring(paramString, mozParseOptions.Length(), paramString.Length() - mozParseOptions.Length()); params.Append(parseOptions); usingCustomParseOptions = true; } } nsCOMPtr<nsIInputStream> stream; rv = ExtractData(type, params, getter_AddRefs(stream), fallbackToPNG); // If there are unrecognized custom parse options, we should fall back to // the default values for the encoder without any options at all. if (rv == NS_ERROR_INVALID_ARG && usingCustomParseOptions) { fallbackToPNG = false; rv = ExtractData(type, EmptyString(), getter_AddRefs(stream), fallbackToPNG); } NS_ENSURE_SUCCESS(rv, rv); // build data URL string if (fallbackToPNG) aDataURL = NS_LITERAL_STRING("data:image/png;base64,"); else aDataURL = NS_LITERAL_STRING("data:") + type + NS_LITERAL_STRING(";base64,"); PRUint32 count; rv = stream->Available(&count); NS_ENSURE_SUCCESS(rv, rv); return Base64EncodeInputStream(stream, aDataURL, count, aDataURL.Length()); }
void HTMLLabelAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) { if (aIndex == 0) { if (nsCoreUtils::IsLabelWithControl(mContent)) aName.AssignLiteral("click"); } }
/* static */ nsresult nsEventDispatcher::CreateEvent(nsPresContext* aPresContext, nsEvent* aEvent, const nsAString& aEventType, nsIDOMEvent** aDOMEvent) { *aDOMEvent = nullptr; if (aEvent) { switch(aEvent->eventStructType) { case NS_MUTATION_EVENT: return NS_NewDOMMutationEvent(aDOMEvent, aPresContext, static_cast<nsMutationEvent*>(aEvent)); case NS_GUI_EVENT: case NS_SCROLLPORT_EVENT: case NS_UI_EVENT: return NS_NewDOMUIEvent(aDOMEvent, aPresContext, static_cast<nsGUIEvent*>(aEvent)); case NS_SCROLLAREA_EVENT: return NS_NewDOMScrollAreaEvent(aDOMEvent, aPresContext, static_cast<nsScrollAreaEvent *>(aEvent)); case NS_KEY_EVENT: return NS_NewDOMKeyboardEvent(aDOMEvent, aPresContext, static_cast<nsKeyEvent*>(aEvent)); case NS_COMPOSITION_EVENT: return NS_NewDOMCompositionEvent( aDOMEvent, aPresContext, static_cast<nsCompositionEvent*>(aEvent)); case NS_MOUSE_EVENT: return NS_NewDOMMouseEvent(aDOMEvent, aPresContext, static_cast<nsInputEvent*>(aEvent)); case NS_MOUSE_SCROLL_EVENT: return NS_NewDOMMouseScrollEvent(aDOMEvent, aPresContext, static_cast<nsInputEvent*>(aEvent)); case NS_WHEEL_EVENT: return NS_NewDOMWheelEvent(aDOMEvent, aPresContext, static_cast<widget::WheelEvent*>(aEvent)); case NS_DRAG_EVENT: return NS_NewDOMDragEvent(aDOMEvent, aPresContext, static_cast<nsDragEvent*>(aEvent)); case NS_TEXT_EVENT: return NS_NewDOMTextEvent(aDOMEvent, aPresContext, static_cast<nsTextEvent*>(aEvent)); case NS_SVG_EVENT: return NS_NewDOMSVGEvent(aDOMEvent, aPresContext, aEvent); case NS_SVGZOOM_EVENT: return NS_NewDOMSVGZoomEvent(aDOMEvent, aPresContext, static_cast<nsGUIEvent*>(aEvent)); case NS_SMIL_TIME_EVENT: return NS_NewDOMTimeEvent(aDOMEvent, aPresContext, aEvent); case NS_COMMAND_EVENT: return NS_NewDOMCommandEvent(aDOMEvent, aPresContext, static_cast<nsCommandEvent*>(aEvent)); case NS_SIMPLE_GESTURE_EVENT: return NS_NewDOMSimpleGestureEvent(aDOMEvent, aPresContext, static_cast<nsSimpleGestureEvent*>(aEvent)); case NS_TOUCH_EVENT: return NS_NewDOMTouchEvent(aDOMEvent, aPresContext, static_cast<nsTouchEvent*>(aEvent)); case NS_TRANSITION_EVENT: return NS_NewDOMTransitionEvent(aDOMEvent, aPresContext, static_cast<nsTransitionEvent*>(aEvent)); case NS_ANIMATION_EVENT: return NS_NewDOMAnimationEvent(aDOMEvent, aPresContext, static_cast<nsAnimationEvent*>(aEvent)); default: // For all other types of events, create a vanilla event object. return NS_NewDOMEvent(aDOMEvent, aPresContext, aEvent); } } // And if we didn't get an event, check the type argument. if (aEventType.LowerCaseEqualsLiteral("mouseevent") || aEventType.LowerCaseEqualsLiteral("mouseevents") || aEventType.LowerCaseEqualsLiteral("popupevents")) return NS_NewDOMMouseEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("mousescrollevents")) return NS_NewDOMMouseScrollEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("dragevent") || aEventType.LowerCaseEqualsLiteral("dragevents")) return NS_NewDOMDragEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("keyboardevent") || aEventType.LowerCaseEqualsLiteral("keyevents")) return NS_NewDOMKeyboardEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("compositionevent")) return NS_NewDOMCompositionEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("mutationevent") || aEventType.LowerCaseEqualsLiteral("mutationevents")) return NS_NewDOMMutationEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("textevent") || aEventType.LowerCaseEqualsLiteral("textevents")) return NS_NewDOMTextEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("popupblockedevents")) return NS_NewDOMPopupBlockedEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("deviceorientationevent")) return NS_NewDOMDeviceOrientationEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("devicemotionevent")) return NS_NewDOMDeviceMotionEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("uievent") || aEventType.LowerCaseEqualsLiteral("uievents")) return NS_NewDOMUIEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("event") || aEventType.LowerCaseEqualsLiteral("events") || aEventType.LowerCaseEqualsLiteral("htmlevents")) return NS_NewDOMEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("svgevent") || aEventType.LowerCaseEqualsLiteral("svgevents")) return NS_NewDOMSVGEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("svgzoomevent") || aEventType.LowerCaseEqualsLiteral("svgzoomevents")) return NS_NewDOMSVGZoomEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("timeevent") || aEventType.LowerCaseEqualsLiteral("timeevents")) return NS_NewDOMTimeEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("xulcommandevent") || aEventType.LowerCaseEqualsLiteral("xulcommandevents")) return NS_NewDOMXULCommandEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("commandevent") || aEventType.LowerCaseEqualsLiteral("commandevents")) return NS_NewDOMCommandEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("datacontainerevent") || aEventType.LowerCaseEqualsLiteral("datacontainerevents")) return NS_NewDOMDataContainerEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("messageevent")) return NS_NewDOMMessageEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("progressevent")) return NS_NewDOMProgressEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("notifypaintevent")) return NS_NewDOMNotifyPaintEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("simplegestureevent")) return NS_NewDOMSimpleGestureEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("beforeunloadevent")) return NS_NewDOMBeforeUnloadEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("pagetransition")) return NS_NewDOMPageTransitionEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("scrollareaevent")) return NS_NewDOMScrollAreaEvent(aDOMEvent, aPresContext, nullptr); // FIXME: Should get spec to say what the right string is here! This // is probably wrong! if (aEventType.LowerCaseEqualsLiteral("transitionevent")) return NS_NewDOMTransitionEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("animationevent")) return NS_NewDOMAnimationEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("popstateevent")) return NS_NewDOMPopStateEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("mozaudioavailableevent")) return NS_NewDOMAudioAvailableEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("closeevent")) return NS_NewDOMCloseEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("touchevent") && nsDOMTouchEvent::PrefEnabled()) return NS_NewDOMTouchEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("hashchangeevent")) return NS_NewDOMHashChangeEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("customevent")) return NS_NewDOMCustomEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("mozsmsevent")) return NS_NewDOMSmsEvent(aDOMEvent, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("storageevent")) { return NS_NewDOMStorageEvent(aDOMEvent, aPresContext, nullptr); } return NS_ERROR_DOM_NOT_SUPPORTED_ERR; }
NS_IMETHODIMP nsDOMFile::GetAsDataURL(nsAString &aResult) { aResult.AssignLiteral("data:"); nsresult rv; if (!mContentType.Length()) { nsCOMPtr<nsIMIMEService> mimeService = do_GetService(NS_MIMESERVICE_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString contentType; rv = mimeService->GetTypeFromFile(mFile, contentType); if (NS_SUCCEEDED(rv)) { CopyUTF8toUTF16(contentType, mContentType); } } if (mContentType.Length()) { aResult.Append(mContentType); } else { aResult.AppendLiteral("application/octet-stream"); } aResult.AppendLiteral(";base64,"); nsCOMPtr<nsIInputStream> stream; rv = GetInternalStream(getter_AddRefs(stream)); NS_ENSURE_SUCCESS(rv, DOMFileResult(rv)); char readBuf[4096]; PRUint32 leftOver = 0; PRUint32 numRead; do { rv = stream->Read(readBuf + leftOver, sizeof(readBuf) - leftOver, &numRead); NS_ENSURE_SUCCESS(rv, DOMFileResult(rv)); PRUint32 numEncode = numRead + leftOver; leftOver = 0; if (numEncode == 0) break; // unless this is the end of the file, encode in multiples of 3 if (numRead > 0) { leftOver = numEncode % 3; numEncode -= leftOver; } // out buffer should be at least 4/3rds the read buf, plus a terminator char *base64 = PL_Base64Encode(readBuf, numEncode, nsnull); if (!base64) { return DOMFileResult(NS_ERROR_OUT_OF_MEMORY); } nsDependentCString str(base64); PRUint32 strLen = str.Length(); PRUint32 oldLength = aResult.Length(); AppendASCIItoUTF16(str, aResult); PR_Free(base64); if (aResult.Length() - oldLength != strLen) { return DOMFileResult(NS_ERROR_OUT_OF_MEMORY); } if (leftOver) { memmove(readBuf, readBuf + numEncode, leftOver); } } while (numRead > 0); return NS_OK; }
nsresult BluetoothService::HandleSettingsChanged(const nsAString& aData) { MOZ_ASSERT(NS_IsMainThread()); // The string that we're interested in will be a JSON string that looks like: // {"key":"bluetooth.enabled","value":true} JSContext* cx = nsContentUtils::GetSafeJSContext(); if (!cx) { return NS_OK; } JS::Value val; if (!JS_ParseJSON(cx, aData.BeginReading(), aData.Length(), &val)) { return JS_ReportPendingException(cx) ? NS_OK : NS_ERROR_OUT_OF_MEMORY; } if (!val.isObject()) { return NS_OK; } JSObject& obj(val.toObject()); JS::Value key; if (!JS_GetProperty(cx, &obj, "key", &key)) { MOZ_ASSERT(!JS_IsExceptionPending(cx)); return NS_ERROR_OUT_OF_MEMORY; } if (!key.isString()) { return NS_OK; } JSBool match; if (!JS_StringEqualsAscii(cx, key.toString(), BLUETOOTH_ENABLED_SETTING, &match)) { MOZ_ASSERT(!JS_IsExceptionPending(cx)); return NS_ERROR_OUT_OF_MEMORY; } if (!match) { return NS_OK; } JS::Value value; if (!JS_GetProperty(cx, &obj, "value", &value)) { MOZ_ASSERT(!JS_IsExceptionPending(cx)); return NS_ERROR_OUT_OF_MEMORY; } if (!value.isBoolean()) { MOZ_ASSERT(false, "Expecting a boolean for 'bluetooth.enabled'!"); return NS_ERROR_UNEXPECTED; } if (mSettingsCheckInProgress) { // Somehow the setting for bluetooth has been flipped before our first // settings check completed. Flip this flag so that we ignore the result // of that check whenever it finishes. mSettingsCheckInProgress = false; } if (value.toBoolean() == IsEnabled()) { // Nothing to do here. return NS_OK; } nsresult rv; if (IsEnabled()) { rv = StartStopBluetooth(false); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } rv = StartStopBluetooth(true); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; }
NS_IMETHODIMP nsCommandLine::ResolveFile(const nsAString& aArgument, nsIFile* *aResult) { NS_ENSURE_TRUE(mWorkingDir, NS_ERROR_NOT_INITIALIZED); // This is some seriously screwed-up code. nsIFile.appendRelativeNativePath // explicitly does not accept .. or . path parts, but that is exactly what we // need here. So we hack around it. nsresult rv; #if defined(MOZ_WIDGET_COCOA) nsCOMPtr<nsILocalFileMac> lfm (do_QueryInterface(mWorkingDir)); NS_ENSURE_TRUE(lfm, NS_ERROR_NO_INTERFACE); nsCOMPtr<nsILocalFileMac> newfile (do_CreateInstance(NS_LOCAL_FILE_CONTRACTID)); NS_ENSURE_TRUE(newfile, NS_ERROR_OUT_OF_MEMORY); CFURLRef baseurl; rv = lfm->GetCFURL(&baseurl); NS_ENSURE_SUCCESS(rv, rv); nsAutoCString path; NS_CopyUnicodeToNative(aArgument, path); CFURLRef newurl = CFURLCreateFromFileSystemRepresentationRelativeToBase(nullptr, (const UInt8*) path.get(), path.Length(), true, baseurl); CFRelease(baseurl); rv = newfile->InitWithCFURL(newurl); CFRelease(newurl); if (NS_FAILED(rv)) return rv; newfile.forget(aResult); return NS_OK; #elif defined(XP_UNIX) nsCOMPtr<nsIFile> lf (do_CreateInstance(NS_LOCAL_FILE_CONTRACTID)); NS_ENSURE_TRUE(lf, NS_ERROR_OUT_OF_MEMORY); if (aArgument.First() == '/') { // absolute path rv = lf->InitWithPath(aArgument); if (NS_FAILED(rv)) return rv; NS_ADDREF(*aResult = lf); return NS_OK; } nsAutoCString nativeArg; NS_CopyUnicodeToNative(aArgument, nativeArg); nsAutoCString newpath; mWorkingDir->GetNativePath(newpath); newpath.Append('/'); newpath.Append(nativeArg); rv = lf->InitWithNativePath(newpath); if (NS_FAILED(rv)) return rv; rv = lf->Normalize(); if (NS_FAILED(rv)) return rv; lf.forget(aResult); return NS_OK; #elif defined(XP_WIN32) nsCOMPtr<nsIFile> lf (do_CreateInstance(NS_LOCAL_FILE_CONTRACTID)); NS_ENSURE_TRUE(lf, NS_ERROR_OUT_OF_MEMORY); rv = lf->InitWithPath(aArgument); if (NS_FAILED(rv)) { // If it's a relative path, the Init is *going* to fail. We use string magic and // win32 _fullpath. Note that paths of the form "\Relative\To\CurDrive" are // going to fail, and I haven't figured out a way to work around this without // the PathCombine() function, which is not available in plain win95/nt4 nsAutoString fullPath; mWorkingDir->GetPath(fullPath); fullPath.Append('\\'); fullPath.Append(aArgument); WCHAR pathBuf[MAX_PATH]; if (!_wfullpath(pathBuf, fullPath.get(), MAX_PATH)) return NS_ERROR_FAILURE; rv = lf->InitWithPath(nsDependentString(pathBuf)); if (NS_FAILED(rv)) return rv; } lf.forget(aResult); return NS_OK; #else #error Need platform-specific logic here. #endif }
NS_IMETHODIMP nsXMLProcessingInstruction::GetNodeName(nsAString& aNodeName) { aNodeName.Assign(mTarget); return NS_OK; }
nsresult nsKeygenFormProcessor::GetPublicKey(nsAString& aValue, nsAString& aChallenge, nsAFlatString& aKeyType, nsAString& aOutPublicKey, nsAString& aKeyParams) { nsNSSShutDownPreventionLock locker; nsresult rv = NS_ERROR_FAILURE; char *keystring = nullptr; char *keyparamsString = nullptr, *str = nullptr; uint32_t keyGenMechanism; int32_t primeBits; PK11SlotInfo *slot = nullptr; PK11RSAGenParams rsaParams; SECOidTag algTag; int keysize = 0; void *params; SECKEYPrivateKey *privateKey = nullptr; SECKEYPublicKey *publicKey = nullptr; CERTSubjectPublicKeyInfo *spkInfo = nullptr; PLArenaPool *arena = nullptr; SECStatus sec_rv = SECFailure; SECItem spkiItem; SECItem pkacItem; SECItem signedItem; CERTPublicKeyAndChallenge pkac; pkac.challenge.data = nullptr; nsIGeneratingKeypairInfoDialogs * dialogs; nsKeygenThread *KeygenRunnable = 0; nsCOMPtr<nsIKeygenThread> runnable; // permanent and sensitive flags for keygen PK11AttrFlags attrFlags = PK11_ATTR_TOKEN | PK11_ATTR_SENSITIVE | PK11_ATTR_PRIVATE; // Get the key size // for (size_t i = 0; i < number_of_key_size_choices; ++i) { if (aValue.Equals(mSECKeySizeChoiceList[i].name)) { keysize = mSECKeySizeChoiceList[i].size; break; } } if (!keysize) { goto loser; } arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); if (!arena) { goto loser; } // Set the keygen mechanism if (aKeyType.IsEmpty() || aKeyType.LowerCaseEqualsLiteral("rsa")) { keyGenMechanism = CKM_RSA_PKCS_KEY_PAIR_GEN; } else if (aKeyType.LowerCaseEqualsLiteral("dsa")) { char * end; keyparamsString = ToNewCString(aKeyParams); if (!keyparamsString) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } keyGenMechanism = CKM_DSA_KEY_PAIR_GEN; if (strcmp(keyparamsString, "null") == 0) goto loser; str = keyparamsString; bool found_match = false; do { end = strchr(str, ','); if (end) *end = '\0'; primeBits = pqg_prime_bits(str); if (keysize == primeBits) { found_match = true; break; } str = end + 1; } while (end); if (!found_match) { goto loser; } } else if (aKeyType.LowerCaseEqualsLiteral("ec")) { keyparamsString = ToNewCString(aKeyParams); if (!keyparamsString) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } keyGenMechanism = CKM_EC_KEY_PAIR_GEN; /* ecParams are initialized later */ } else { goto loser; } // Get the slot rv = GetSlot(keyGenMechanism, &slot); if (NS_FAILED(rv)) { goto loser; } switch (keyGenMechanism) { case CKM_RSA_PKCS_KEY_PAIR_GEN: rsaParams.keySizeInBits = keysize; rsaParams.pe = DEFAULT_RSA_KEYGEN_PE; algTag = DEFAULT_RSA_KEYGEN_ALG; params = &rsaParams; break; case CKM_DSA_KEY_PAIR_GEN: // XXX Fix this! XXX // goto loser; case CKM_EC_KEY_PAIR_GEN: /* XXX We ought to rethink how the KEYGEN tag is * displayed. The pulldown selections presented * to the user must depend on the keytype. * The displayed selection could be picked * from the keyparams attribute (this is currently called * the pqg attribute). * For now, we pick ecparams from the keyparams field * if it specifies a valid supported curve, or else * we pick one of secp384r1, secp256r1 or secp192r1 * respectively depending on the user's selection * (High, Medium, Low). * (RSA uses RSA-2048, RSA-1024 and RSA-512 for historical * reasons, while ECC choices represent a stronger mapping) * NOTE: The user's selection * is silently ignored when a valid curve is presented * in keyparams. */ if ((params = decode_ec_params(keyparamsString)) == nullptr) { /* The keyparams attribute did not specify a valid * curve name so use a curve based on the keysize. * NOTE: Here keysize is used only as an indication of * High/Medium/Low strength; elliptic curve * cryptography uses smaller keys than RSA to provide * equivalent security. */ switch (keysize) { case 2048: params = decode_ec_params("secp384r1"); break; case 1024: case 512: params = decode_ec_params("secp256r1"); break; } } /* XXX The signature algorithm ought to choose the hashing * algorithm based on key size once ECDSA variations based * on SHA256 SHA384 and SHA512 are standardized. */ algTag = SEC_OID_ANSIX962_ECDSA_SIGNATURE_WITH_SHA1_DIGEST; break; default: goto loser; } /* Make sure token is initialized. */ rv = setPassword(slot, m_ctx); if (NS_FAILED(rv)) goto loser; sec_rv = PK11_Authenticate(slot, true, m_ctx); if (sec_rv != SECSuccess) { goto loser; } rv = getNSSDialogs((void**)&dialogs, NS_GET_IID(nsIGeneratingKeypairInfoDialogs), NS_GENERATINGKEYPAIRINFODIALOGS_CONTRACTID); if (NS_SUCCEEDED(rv)) { KeygenRunnable = new nsKeygenThread(); NS_IF_ADDREF(KeygenRunnable); } if (NS_FAILED(rv) || !KeygenRunnable) { rv = NS_OK; privateKey = PK11_GenerateKeyPairWithFlags(slot, keyGenMechanism, params, &publicKey, attrFlags, m_ctx); } else { KeygenRunnable->SetParams( slot, attrFlags, nullptr, 0, keyGenMechanism, params, m_ctx ); runnable = do_QueryInterface(KeygenRunnable); if (runnable) { { nsPSMUITracker tracker; if (tracker.isUIForbidden()) { rv = NS_ERROR_NOT_AVAILABLE; } else { rv = dialogs->DisplayGeneratingKeypairInfo(m_ctx, runnable); // We call join on the thread, // so we can be sure that no simultaneous access to the passed parameters will happen. KeygenRunnable->Join(); } } NS_RELEASE(dialogs); if (NS_SUCCEEDED(rv)) { PK11SlotInfo *used_slot = nullptr; rv = KeygenRunnable->ConsumeResult(&used_slot, &privateKey, &publicKey); if (NS_SUCCEEDED(rv) && used_slot) { PK11_FreeSlot(used_slot); } } } } if (NS_FAILED(rv) || !privateKey) { goto loser; } // just in case we'll need to authenticate to the db -jp // privateKey->wincx = m_ctx; /* * Create a subject public key info from the public key. */ spkInfo = SECKEY_CreateSubjectPublicKeyInfo(publicKey); if ( !spkInfo ) { goto loser; } /* * Now DER encode the whole subjectPublicKeyInfo. */ sec_rv=DER_Encode(arena, &spkiItem, CERTSubjectPublicKeyInfoTemplate, spkInfo); if (sec_rv != SECSuccess) { goto loser; } /* * set up the PublicKeyAndChallenge data structure, then DER encode it */ pkac.spki = spkiItem; pkac.challenge.len = aChallenge.Length(); pkac.challenge.data = (unsigned char *)ToNewCString(aChallenge); if (!pkac.challenge.data) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } sec_rv = DER_Encode(arena, &pkacItem, CERTPublicKeyAndChallengeTemplate, &pkac); if ( sec_rv != SECSuccess ) { goto loser; } /* * now sign the DER encoded PublicKeyAndChallenge */ sec_rv = SEC_DerSignData(arena, &signedItem, pkacItem.data, pkacItem.len, privateKey, algTag); if ( sec_rv != SECSuccess ) { goto loser; } /* * Convert the signed public key and challenge into base64/ascii. */ keystring = BTOA_DataToAscii(signedItem.data, signedItem.len); if (!keystring) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } CopyASCIItoUTF16(keystring, aOutPublicKey); nsCRT::free(keystring); rv = NS_OK; loser: if ( sec_rv != SECSuccess ) { if ( privateKey ) { PK11_DestroyTokenObject(privateKey->pkcs11Slot,privateKey->pkcs11ID); } if ( publicKey ) { PK11_DestroyTokenObject(publicKey->pkcs11Slot,publicKey->pkcs11ID); } } if ( spkInfo ) { SECKEY_DestroySubjectPublicKeyInfo(spkInfo); } if ( publicKey ) { SECKEY_DestroyPublicKey(publicKey); } if ( privateKey ) { SECKEY_DestroyPrivateKey(privateKey); } if ( arena ) { PORT_FreeArena(arena, true); } if (slot) { PK11_FreeSlot(slot); } if (KeygenRunnable) { NS_RELEASE(KeygenRunnable); } if (keyparamsString) { nsMemory::Free(keyparamsString); } if (pkac.challenge.data) { nsMemory::Free(pkac.challenge.data); } return rv; }
void nsCSSSelector::AppendToStringWithoutCombinatorsOrNegations (nsAString& aString, CSSStyleSheet* aSheet, bool aIsNegated) const { nsAutoString temp; bool isPseudoElement = IsPseudoElement(); // For non-pseudo-element selectors or for lone pseudo-elements, deal with // namespace prefixes. bool wroteNamespace = false; if (!isPseudoElement || !mNext) { // append the namespace prefix if needed nsXMLNameSpaceMap *sheetNS = aSheet ? aSheet->GetNameSpaceMap() : nullptr; // sheetNS is non-null if and only if we had an @namespace rule. If it's // null, that means that the only namespaces we could have are the // wildcard namespace (which can be implicit in this case) and the "none" // namespace, which then needs to be explicitly specified. if (!sheetNS) { NS_ASSERTION(mNameSpace == kNameSpaceID_Unknown || mNameSpace == kNameSpaceID_None, "How did we get this namespace?"); if (mNameSpace == kNameSpaceID_None) { aString.Append(char16_t('|')); wroteNamespace = true; } } else if (sheetNS->FindNameSpaceID(nullptr) == mNameSpace) { // We have the default namespace (possibly including the wildcard // namespace). Do nothing. NS_ASSERTION(mNameSpace == kNameSpaceID_Unknown || CanBeNamespaced(aIsNegated), "How did we end up with this namespace?"); } else if (mNameSpace == kNameSpaceID_None) { NS_ASSERTION(CanBeNamespaced(aIsNegated), "How did we end up with this namespace?"); aString.Append(char16_t('|')); wroteNamespace = true; } else if (mNameSpace != kNameSpaceID_Unknown) { NS_ASSERTION(CanBeNamespaced(aIsNegated), "How did we end up with this namespace?"); nsIAtom *prefixAtom = sheetNS->FindPrefix(mNameSpace); NS_ASSERTION(prefixAtom, "how'd we get a non-default namespace " "without a prefix?"); nsStyleUtil::AppendEscapedCSSIdent(nsDependentAtomString(prefixAtom), aString); aString.Append(char16_t('|')); wroteNamespace = true; } else { // A selector for an element in any namespace, while the default // namespace is something else. :not() is special in that the default // namespace is not implied for non-type selectors, so if this is a // negated non-type selector we don't need to output an explicit wildcard // namespace here, since those default to a wildcard namespace. if (CanBeNamespaced(aIsNegated)) { aString.AppendLiteral("*|"); wroteNamespace = true; } } } if (!mLowercaseTag) { // Universal selector: avoid writing the universal selector when we // can avoid it, especially since we're required to avoid it for the // inside of :not() if (wroteNamespace || (!mIDList && !mClassList && !mPseudoClassList && !mAttrList && (aIsNegated || !mNegations))) { aString.Append(char16_t('*')); } } else { // Append the tag name nsAutoString tag; (isPseudoElement ? mLowercaseTag : mCasedTag)->ToString(tag); if (isPseudoElement) { if (!mNext) { // Lone pseudo-element selector -- toss in a wildcard type selector // XXXldb Why? aString.Append(char16_t('*')); } // While our atoms use one colon, most pseudo-elements require two // colons (those not in CSS level 2) and all pseudo-elements allow // two colons. So serialize to the non-deprecated two colon syntax. aString.Append(char16_t(':')); // This should not be escaped since (a) the pseudo-element string // has a ":" that can't be escaped and (b) all pseudo-elements at // this point are known, and therefore we know they don't need // escaping. aString.Append(tag); } else { nsStyleUtil::AppendEscapedCSSIdent(tag, aString); } } // Append the id, if there is one if (mIDList) { nsAtomList* list = mIDList; while (list != nullptr) { list->mAtom->ToString(temp); aString.Append(char16_t('#')); nsStyleUtil::AppendEscapedCSSIdent(temp, aString); list = list->mNext; } } // Append each class in the linked list if (mClassList) { if (isPseudoElement) { #ifdef MOZ_XUL MOZ_ASSERT(nsCSSAnonBoxes::IsTreePseudoElement(mLowercaseTag), "must be tree pseudo-element"); aString.Append(char16_t('(')); for (nsAtomList* list = mClassList; list; list = list->mNext) { nsStyleUtil::AppendEscapedCSSIdent(nsDependentAtomString(list->mAtom), aString); aString.Append(char16_t(',')); } // replace the final comma with a close-paren aString.Replace(aString.Length() - 1, 1, char16_t(')')); #else NS_ERROR("Can't happen"); #endif } else { nsAtomList* list = mClassList; while (list != nullptr) { list->mAtom->ToString(temp); aString.Append(char16_t('.')); nsStyleUtil::AppendEscapedCSSIdent(temp, aString); list = list->mNext; } } } // Append each attribute selector in the linked list if (mAttrList) { nsAttrSelector* list = mAttrList; while (list != nullptr) { aString.Append(char16_t('[')); // Append the namespace prefix if (list->mNameSpace == kNameSpaceID_Unknown) { aString.Append(char16_t('*')); aString.Append(char16_t('|')); } else if (list->mNameSpace != kNameSpaceID_None) { if (aSheet) { nsXMLNameSpaceMap *sheetNS = aSheet->GetNameSpaceMap(); nsIAtom *prefixAtom = sheetNS->FindPrefix(list->mNameSpace); // Default namespaces don't apply to attribute selectors, so // we must have a useful prefix. NS_ASSERTION(prefixAtom, "How did we end up with a namespace if the prefix " "is unknown?"); nsAutoString prefix; prefixAtom->ToString(prefix); nsStyleUtil::AppendEscapedCSSIdent(prefix, aString); aString.Append(char16_t('|')); } } // Append the attribute name list->mCasedAttr->ToString(temp); nsStyleUtil::AppendEscapedCSSIdent(temp, aString); if (list->mFunction != NS_ATTR_FUNC_SET) { // Append the function if (list->mFunction == NS_ATTR_FUNC_INCLUDES) aString.Append(char16_t('~')); else if (list->mFunction == NS_ATTR_FUNC_DASHMATCH) aString.Append(char16_t('|')); else if (list->mFunction == NS_ATTR_FUNC_BEGINSMATCH) aString.Append(char16_t('^')); else if (list->mFunction == NS_ATTR_FUNC_ENDSMATCH) aString.Append(char16_t('$')); else if (list->mFunction == NS_ATTR_FUNC_CONTAINSMATCH) aString.Append(char16_t('*')); aString.Append(char16_t('=')); // Append the value nsStyleUtil::AppendEscapedCSSString(list->mValue, aString); } aString.Append(char16_t(']')); list = list->mNext; } } // Append each pseudo-class in the linked list for (nsPseudoClassList* list = mPseudoClassList; list; list = list->mNext) { nsCSSPseudoClasses::PseudoTypeToString(list->mType, temp); // This should not be escaped since (a) the pseudo-class string // has a ":" that can't be escaped and (b) all pseudo-classes at // this point are known, and therefore we know they don't need // escaping. aString.Append(temp); if (list->u.mMemory) { aString.Append(char16_t('(')); if (nsCSSPseudoClasses::HasStringArg(list->mType)) { nsStyleUtil::AppendEscapedCSSIdent( nsDependentString(list->u.mString), aString); } else if (nsCSSPseudoClasses::HasNthPairArg(list->mType)) { int32_t a = list->u.mNumbers[0], b = list->u.mNumbers[1]; temp.Truncate(); if (a != 0) { if (a == -1) { temp.Append(char16_t('-')); } else if (a != 1) { temp.AppendInt(a); } temp.Append(char16_t('n')); } if (b != 0 || a == 0) { if (b >= 0 && a != 0) // check a != 0 for whether we printed above temp.Append(char16_t('+')); temp.AppendInt(b); } aString.Append(temp); } else { NS_ASSERTION(nsCSSPseudoClasses::HasSelectorListArg(list->mType), "unexpected pseudo-class"); nsString tmp; list->u.mSelectors->ToString(tmp, aSheet); aString.Append(tmp); } aString.Append(char16_t(')')); } } }
nsresult nsMsgI18NConvertToUnicode(const char* aCharset, const nsCString& inString, nsAString& outString, bool aIsCharsetCanonical) { if (inString.IsEmpty()) { outString.Truncate(); return NS_OK; } else if (!*aCharset || !PL_strcasecmp(aCharset, "us-ascii") || !PL_strcasecmp(aCharset, "ISO-8859-1")) { // Despite its name, it also works for Latin-1. CopyASCIItoUTF16(inString, outString); return NS_OK; } else if (!PL_strcasecmp(aCharset, "UTF-8")) { if (MsgIsUTF8(inString)) { nsAutoString tmp; CopyUTF8toUTF16(inString, tmp); if (!tmp.IsEmpty() && tmp.First() == char16_t(0xFEFF)) tmp.Cut(0, 1); outString.Assign(tmp); return NS_OK; } NS_WARNING("Invalid UTF-8 string"); return NS_ERROR_UNEXPECTED; } nsresult rv; nsCOMPtr <nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr <nsIUnicodeDecoder> decoder; // get an unicode converter if (aIsCharsetCanonical) // optimize for modified UTF-7 used by IMAP rv = ccm->GetUnicodeDecoderRaw(aCharset, getter_AddRefs(decoder)); else rv = ccm->GetUnicodeDecoderInternal(aCharset, getter_AddRefs(decoder)); NS_ENSURE_SUCCESS(rv, rv); const char *originalSrcPtr = inString.get(); const char *currentSrcPtr = originalSrcPtr; int32_t originalLength = inString.Length(); int32_t srcLength; int32_t dstLength; char16_t localbuf[512]; int32_t consumedLen = 0; outString.Truncate(); // convert while (consumedLen < originalLength) { srcLength = originalLength - consumedLen; dstLength = 512; rv = decoder->Convert(currentSrcPtr, &srcLength, localbuf, &dstLength); if (NS_FAILED(rv) || dstLength == 0) break; outString.Append(localbuf, dstLength); currentSrcPtr += srcLength; consumedLen = currentSrcPtr - originalSrcPtr; // src length used so far } return rv; }
NS_IMETHODIMP nsPopupBoxObject::GetAlignmentPosition(nsAString& positionStr) { positionStr.Truncate(); // This needs to flush layout. nsMenuPopupFrame *menuPopupFrame = do_QueryFrame(GetFrame(true)); if (!menuPopupFrame) return NS_OK; int8_t position = menuPopupFrame->GetAlignmentPosition(); switch (position) { case POPUPPOSITION_AFTERSTART: positionStr.AssignLiteral("after_start"); break; case POPUPPOSITION_AFTEREND: positionStr.AssignLiteral("after_end"); break; case POPUPPOSITION_BEFORESTART: positionStr.AssignLiteral("before_start"); break; case POPUPPOSITION_BEFOREEND: positionStr.AssignLiteral("before_end"); break; case POPUPPOSITION_STARTBEFORE: positionStr.AssignLiteral("start_before"); break; case POPUPPOSITION_ENDBEFORE: positionStr.AssignLiteral("end_before"); break; case POPUPPOSITION_STARTAFTER: positionStr.AssignLiteral("start_after"); break; case POPUPPOSITION_ENDAFTER: positionStr.AssignLiteral("end_after"); break; case POPUPPOSITION_OVERLAP: positionStr.AssignLiteral("overlap"); break; case POPUPPOSITION_AFTERPOINTER: positionStr.AssignLiteral("after_pointer"); break; default: // Leave as an empty string. break; } return NS_OK; }
NS_IMETHODIMP nsMovemailIncomingServer::GetAccountManagerChrome(nsAString& aResult) { aResult.AssignLiteral("am-main.xul"); return NS_OK; }
static OperatingSystem BlacklistOSToOperatingSystem(const nsAString& os) { if (os.EqualsLiteral("WINNT 5.1")) return DRIVER_OS_WINDOWS_XP; else if (os.EqualsLiteral("WINNT 5.2")) return DRIVER_OS_WINDOWS_SERVER_2003; else if (os.EqualsLiteral("WINNT 6.0")) return DRIVER_OS_WINDOWS_VISTA; else if (os.EqualsLiteral("WINNT 6.1")) return DRIVER_OS_WINDOWS_7; else if (os.EqualsLiteral("WINNT 6.2")) return DRIVER_OS_WINDOWS_8; else if (os.EqualsLiteral("WINNT 6.3")) return DRIVER_OS_WINDOWS_8_1; else if (os.EqualsLiteral("WINNT 10.0")) return DRIVER_OS_WINDOWS_10; else if (os.EqualsLiteral("Linux")) return DRIVER_OS_LINUX; else if (os.EqualsLiteral("Darwin 9")) return DRIVER_OS_OS_X_10_5; else if (os.EqualsLiteral("Darwin 10")) return DRIVER_OS_OS_X_10_6; else if (os.EqualsLiteral("Darwin 11")) return DRIVER_OS_OS_X_10_7; else if (os.EqualsLiteral("Darwin 12")) return DRIVER_OS_OS_X_10_8; else if (os.EqualsLiteral("Darwin 13")) return DRIVER_OS_OS_X_10_9; else if (os.EqualsLiteral("Darwin 14")) return DRIVER_OS_OS_X_10_10; else if (os.EqualsLiteral("Darwin 15")) return DRIVER_OS_OS_X_10_11; else if (os.EqualsLiteral("Android")) return DRIVER_OS_ANDROID; else if (os.EqualsLiteral("All")) return DRIVER_OS_ALL; return DRIVER_OS_UNKNOWN; }
void ChromiumCDMProxy::Init(PromiseId aPromiseId, const nsAString& aOrigin, const nsAString& aTopLevelOrigin, const nsAString& aGMPName) { MOZ_ASSERT(NS_IsMainThread()); NS_ENSURE_TRUE_VOID(!mKeys.IsNull()); EME_LOG( "ChromiumCDMProxy::Init (pid=%u, origin=%s, topLevelOrigin=%s, gmp=%s)", aPromiseId, NS_ConvertUTF16toUTF8(aOrigin).get(), NS_ConvertUTF16toUTF8(aTopLevelOrigin).get(), NS_ConvertUTF16toUTF8(aGMPName).get()); if (!mGMPThread) { RejectPromise( aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, NS_LITERAL_CSTRING("Couldn't get GMP thread ChromiumCDMProxy::Init")); return; } if (aGMPName.IsEmpty()) { RejectPromise(aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, nsPrintfCString("Unknown GMP for keysystem '%s'", NS_ConvertUTF16toUTF8(mKeySystem).get())); return; } gmp::NodeId nodeId(aOrigin, aTopLevelOrigin, aGMPName); RefPtr<AbstractThread> thread = mGMPThread; RefPtr<GMPCrashHelper> helper(mCrashHelper); RefPtr<ChromiumCDMProxy> self(this); nsCString keySystem = NS_ConvertUTF16toUTF8(mKeySystem); RefPtr<Runnable> task(NS_NewRunnableFunction( [self, nodeId, helper, aPromiseId, thread, keySystem]() -> void { MOZ_ASSERT(self->IsOnOwnerThread()); RefPtr<gmp::GeckoMediaPluginService> service = gmp::GeckoMediaPluginService::GetGeckoMediaPluginService(); if (!service) { self->RejectPromise( aPromiseId, NS_ERROR_DOM_INVALID_STATE_ERR, NS_LITERAL_CSTRING( "Couldn't get GeckoMediaPluginService in ChromiumCDMProxy::Init")); return; } RefPtr<gmp::GetCDMParentPromise> promise = service->GetCDM(nodeId, { keySystem }, helper); promise->Then( thread, __func__, [self, aPromiseId](RefPtr<gmp::ChromiumCDMParent> cdm) { if (!cdm->Init(self, self->mDistinctiveIdentifierRequired, self->mPersistentStateRequired)) { self->RejectPromise(aPromiseId, NS_ERROR_FAILURE, NS_LITERAL_CSTRING("GetCDM failed.")); return; } { MutexAutoLock lock(self->mCDMMutex); self->mCDM = cdm; } self->OnCDMCreated(aPromiseId); }, [self, aPromiseId](nsresult rv) { self->RejectPromise( aPromiseId, NS_ERROR_FAILURE, NS_LITERAL_CSTRING("GetCDM failed.")); }); })); mGMPThread->Dispatch(task.forget()); }
int32_t GfxInfoBase::FindBlocklistedDeviceInList(const nsTArray<GfxDriverInfo>& info, nsAString& aSuggestedVersion, int32_t aFeature, OperatingSystem os) { int32_t status = nsIGfxInfo::FEATURE_STATUS_UNKNOWN; uint32_t i = 0; for (; i < info.Length(); i++) { // Do the operating system check first, no point in getting the driver // info if we won't need to use it. If the OS of the system we are running // on is unknown, we still let DRIVER_OS_ALL catch and disable it; // if the OS of the downloadable entry is unknown, we skip the entry // as invalid. if (info[i].mOperatingSystem == DRIVER_OS_UNKNOWN || (info[i].mOperatingSystem != DRIVER_OS_ALL && info[i].mOperatingSystem != os)) { continue; } if (info[i].mOperatingSystemVersion && info[i].mOperatingSystemVersion != OperatingSystemVersion()) { continue; } // XXX: it would be better not to do this everytime round the loop nsAutoString adapterVendorID; nsAutoString adapterDeviceID; nsAutoString adapterDriverVersionString; if (info[i].mGpu2) { if (NS_FAILED(GetAdapterVendorID2(adapterVendorID)) || NS_FAILED(GetAdapterDeviceID2(adapterDeviceID)) || NS_FAILED(GetAdapterDriverVersion2(adapterDriverVersionString))) { return 0; } } else { if (NS_FAILED(GetAdapterVendorID(adapterVendorID)) || NS_FAILED(GetAdapterDeviceID(adapterDeviceID)) || NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString))) { return 0; } } #if defined(XP_WIN) || defined(ANDROID) uint64_t driverVersion; ParseDriverVersion(adapterDriverVersionString, &driverVersion); #endif if (!info[i].mAdapterVendor.Equals(GfxDriverInfo::GetDeviceVendor(VendorAll), nsCaseInsensitiveStringComparator()) && !info[i].mAdapterVendor.Equals(adapterVendorID, nsCaseInsensitiveStringComparator())) { continue; } if (info[i].mDevices != GfxDriverInfo::allDevices && info[i].mDevices->Length()) { bool deviceMatches = false; for (uint32_t j = 0; j < info[i].mDevices->Length(); j++) { if ((*info[i].mDevices)[j].Equals(adapterDeviceID, nsCaseInsensitiveStringComparator())) { deviceMatches = true; break; } } if (!deviceMatches) { continue; } } bool match = false; if (!info[i].mHardware.IsEmpty() && !info[i].mHardware.Equals(Hardware())) { continue; } if (!info[i].mModel.IsEmpty() && !info[i].mModel.Equals(Model())) { continue; } if (!info[i].mProduct.IsEmpty() && !info[i].mProduct.Equals(Product())) { continue; } if (!info[i].mManufacturer.IsEmpty() && !info[i].mManufacturer.Equals(Manufacturer())) { continue; } #if defined(XP_WIN) || defined(ANDROID) switch (info[i].mComparisonOp) { case DRIVER_LESS_THAN: match = driverVersion < info[i].mDriverVersion; break; case DRIVER_LESS_THAN_OR_EQUAL: match = driverVersion <= info[i].mDriverVersion; break; case DRIVER_GREATER_THAN: match = driverVersion > info[i].mDriverVersion; break; case DRIVER_GREATER_THAN_OR_EQUAL: match = driverVersion >= info[i].mDriverVersion; break; case DRIVER_EQUAL: match = driverVersion == info[i].mDriverVersion; break; case DRIVER_NOT_EQUAL: match = driverVersion != info[i].mDriverVersion; break; case DRIVER_BETWEEN_EXCLUSIVE: match = driverVersion > info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax; break; case DRIVER_BETWEEN_INCLUSIVE: match = driverVersion >= info[i].mDriverVersion && driverVersion <= info[i].mDriverVersionMax; break; case DRIVER_BETWEEN_INCLUSIVE_START: match = driverVersion >= info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax; break; case DRIVER_COMPARISON_IGNORED: // We don't have a comparison op, so we match everything. match = true; break; default: NS_WARNING("Bogus op in GfxDriverInfo"); break; } #else // We don't care what driver version it was. We only check OS version and if // the device matches. match = true; #endif if (match || info[i].mDriverVersion == GfxDriverInfo::allDriverVersions) { if (info[i].mFeature == GfxDriverInfo::allFeatures || info[i].mFeature == aFeature) { status = info[i].mFeatureStatus; break; } } } #if defined(XP_WIN) // As a very special case, we block D2D on machines with an NVidia 310M GPU // as either the primary or secondary adapter. D2D is also blocked when the // NV 310M is the primary adapter (using the standard blocklisting mechanism). // If the primary GPU already matched something in the blocklist then we // ignore this special rule. See bug 1008759. if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN && (aFeature == nsIGfxInfo::FEATURE_DIRECT2D)) { nsAutoString adapterVendorID2; nsAutoString adapterDeviceID2; if ((!NS_FAILED(GetAdapterVendorID2(adapterVendorID2))) && (!NS_FAILED(GetAdapterDeviceID2(adapterDeviceID2)))) { nsAString &nvVendorID = (nsAString &)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA); const nsString nv310mDeviceId = NS_LITERAL_STRING("0x0A70"); if (nvVendorID.Equals(adapterVendorID2, nsCaseInsensitiveStringComparator()) && nv310mDeviceId.Equals(adapterDeviceID2, nsCaseInsensitiveStringComparator())) { status = nsIGfxInfo::FEATURE_BLOCKED_DEVICE; } } } // Depends on Windows driver versioning. We don't pass a GfxDriverInfo object // back to the Windows handler, so we must handle this here. if (status == FEATURE_BLOCKED_DRIVER_VERSION) { if (info[i].mSuggestedVersion) { aSuggestedVersion.AppendPrintf("%s", info[i].mSuggestedVersion); } else if (info[i].mComparisonOp == DRIVER_LESS_THAN && info[i].mDriverVersion != GfxDriverInfo::allDriverVersions) { aSuggestedVersion.AppendPrintf("%lld.%lld.%lld.%lld", (info[i].mDriverVersion & 0xffff000000000000) >> 48, (info[i].mDriverVersion & 0x0000ffff00000000) >> 32, (info[i].mDriverVersion & 0x00000000ffff0000) >> 16, (info[i].mDriverVersion & 0x000000000000ffff)); } }
DOMHighResTimeStamp nsPerformance::GetPerformanceTimingFromString(const nsAString& aProperty) { if (!IsPerformanceTimingAttribute(aProperty)) { return 0; } if (aProperty.EqualsLiteral("navigationStart")) { // DOMHighResTimeStamp is in relation to navigationStart, so this will be // zero. return GetDOMTiming()->GetNavigationStart(); } if (aProperty.EqualsLiteral("unloadEventStart")) { return GetDOMTiming()->GetUnloadEventStart(); } if (aProperty.EqualsLiteral("unloadEventEnd")) { return GetDOMTiming()->GetUnloadEventEnd(); } if (aProperty.EqualsLiteral("redirectStart")) { return Timing()->RedirectStart(); } if (aProperty.EqualsLiteral("redirectEnd")) { return Timing()->RedirectEnd(); } if (aProperty.EqualsLiteral("fetchStart")) { return Timing()->FetchStart(); } if (aProperty.EqualsLiteral("domainLookupStart")) { return Timing()->DomainLookupStart(); } if (aProperty.EqualsLiteral("domainLookupEnd")) { return Timing()->DomainLookupEnd(); } if (aProperty.EqualsLiteral("connectStart")) { return Timing()->ConnectStart(); } if (aProperty.EqualsLiteral("connectEnd")) { return Timing()->ConnectEnd(); } if (aProperty.EqualsLiteral("requestStart")) { return Timing()->RequestStart(); } if (aProperty.EqualsLiteral("responseStart")) { return Timing()->ResponseStart(); } if (aProperty.EqualsLiteral("responseEnd")) { return Timing()->ResponseEnd(); } if (aProperty.EqualsLiteral("domLoading")) { return GetDOMTiming()->GetDomLoading(); } if (aProperty.EqualsLiteral("domInteractive")) { return GetDOMTiming()->GetDomInteractive(); } if (aProperty.EqualsLiteral("domContentLoadedEventStart")) { return GetDOMTiming()->GetDomContentLoadedEventStart(); } if (aProperty.EqualsLiteral("domContentLoadedEventEnd")) { return GetDOMTiming()->GetDomContentLoadedEventEnd(); } if (aProperty.EqualsLiteral("domComplete")) { return GetDOMTiming()->GetDomComplete(); } if (aProperty.EqualsLiteral("loadEventStart")) { return GetDOMTiming()->GetLoadEventStart(); } if (aProperty.EqualsLiteral("loadEventEnd")) { return GetDOMTiming()->GetLoadEventEnd(); } MOZ_CRASH("IsPerformanceTimingAttribute and GetPerformanceTimingFromString are out of sync"); return 0; }
void HTMLTextAreaElement::GetType(nsAString& aType) { aType.AssignLiteral("textarea"); }
bool nsDOMUIEvent::GetModifierStateInternal(const nsAString& aKey) { if (!NS_IS_INPUT_EVENT(mEvent)) { MOZ_CRASH("mEvent must be nsInputEvent or derived class"); } nsInputEvent* inputEvent = static_cast<nsInputEvent*>(mEvent); if (aKey.EqualsLiteral(NS_DOM_KEYNAME_SHIFT)) { return inputEvent->IsShift(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_CONTROL)) { return inputEvent->IsControl(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_META)) { return inputEvent->IsMeta(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_ALT)) { return inputEvent->IsAlt(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_ALTGRAPH)) { return inputEvent->IsAltGraph(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_OS)) { return inputEvent->IsOS(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_CAPSLOCK)) { return inputEvent->IsCapsLocked(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_NUMLOCK)) { return inputEvent->IsNumLocked(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_FN)) { return inputEvent->IsFn(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_SCROLLLOCK)) { return inputEvent->IsScrollLocked(); } if (aKey.EqualsLiteral(NS_DOM_KEYNAME_SYMBOLLOCK)) { return inputEvent->IsSymbolLocked(); } return false; }
NS_IMETHODIMP nsDBusHandlerApp::GetDetailedDescription(nsAString& aDescription) { aDescription.Assign(mDetailedDescription); return NS_OK; }
/* static */ nsresult EventDispatcher::CreateEvent(EventTarget* aOwner, nsPresContext* aPresContext, WidgetEvent* aEvent, const nsAString& aEventType, nsIDOMEvent** aDOMEvent) { *aDOMEvent = nullptr; if (aEvent) { switch(aEvent->eventStructType) { case NS_MUTATION_EVENT: return NS_NewDOMMutationEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsMutationEvent()); case NS_GUI_EVENT: case NS_SCROLLPORT_EVENT: case NS_UI_EVENT: return NS_NewDOMUIEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsGUIEvent()); case NS_SCROLLAREA_EVENT: return NS_NewDOMScrollAreaEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsScrollAreaEvent()); case NS_KEY_EVENT: return NS_NewDOMKeyboardEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsKeyboardEvent()); case NS_COMPOSITION_EVENT: return NS_NewDOMCompositionEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsCompositionEvent()); case NS_MOUSE_EVENT: return NS_NewDOMMouseEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsMouseEvent()); case NS_FOCUS_EVENT: return NS_NewDOMFocusEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsFocusEvent()); case NS_MOUSE_SCROLL_EVENT: return NS_NewDOMMouseScrollEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsMouseScrollEvent()); case NS_WHEEL_EVENT: return NS_NewDOMWheelEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsWheelEvent()); case NS_EDITOR_INPUT_EVENT: return NS_NewDOMInputEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsEditorInputEvent()); case NS_DRAG_EVENT: return NS_NewDOMDragEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsDragEvent()); case NS_TEXT_EVENT: return NS_NewDOMUIEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsTextEvent()); case NS_CLIPBOARD_EVENT: return NS_NewDOMClipboardEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsClipboardEvent()); case NS_SVGZOOM_EVENT: return NS_NewDOMSVGZoomEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsGUIEvent()); case NS_SMIL_TIME_EVENT: return NS_NewDOMTimeEvent(aDOMEvent, aOwner, aPresContext, aEvent); case NS_COMMAND_EVENT: return NS_NewDOMCommandEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsCommandEvent()); case NS_SIMPLE_GESTURE_EVENT: return NS_NewDOMSimpleGestureEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsSimpleGestureEvent()); case NS_POINTER_EVENT: return NS_NewDOMPointerEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsPointerEvent()); case NS_TOUCH_EVENT: return NS_NewDOMTouchEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsTouchEvent()); case NS_TRANSITION_EVENT: return NS_NewDOMTransitionEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsTransitionEvent()); case NS_ANIMATION_EVENT: return NS_NewDOMAnimationEvent(aDOMEvent, aOwner, aPresContext, aEvent->AsAnimationEvent()); default: // For all other types of events, create a vanilla event object. return NS_NewDOMEvent(aDOMEvent, aOwner, aPresContext, aEvent); } } // And if we didn't get an event, check the type argument. if (aEventType.LowerCaseEqualsLiteral("mouseevent") || aEventType.LowerCaseEqualsLiteral("mouseevents") || aEventType.LowerCaseEqualsLiteral("popupevents")) return NS_NewDOMMouseEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("mousescrollevents")) return NS_NewDOMMouseScrollEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("dragevent") || aEventType.LowerCaseEqualsLiteral("dragevents")) return NS_NewDOMDragEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("keyboardevent") || aEventType.LowerCaseEqualsLiteral("keyevents")) return NS_NewDOMKeyboardEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("compositionevent")) return NS_NewDOMCompositionEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("mutationevent") || aEventType.LowerCaseEqualsLiteral("mutationevents")) return NS_NewDOMMutationEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("textevent") || aEventType.LowerCaseEqualsLiteral("textevents")) return NS_NewDOMUIEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("popupblockedevents")) return NS_NewDOMPopupBlockedEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("deviceorientationevent")) return NS_NewDOMDeviceOrientationEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("devicemotionevent")) return NS_NewDOMDeviceMotionEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("uievent") || aEventType.LowerCaseEqualsLiteral("uievents")) return NS_NewDOMUIEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("event") || aEventType.LowerCaseEqualsLiteral("events") || aEventType.LowerCaseEqualsLiteral("htmlevents") || aEventType.LowerCaseEqualsLiteral("svgevent") || aEventType.LowerCaseEqualsLiteral("svgevents")) return NS_NewDOMEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("svgzoomevent") || aEventType.LowerCaseEqualsLiteral("svgzoomevents")) return NS_NewDOMSVGZoomEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("timeevent") || aEventType.LowerCaseEqualsLiteral("timeevents")) return NS_NewDOMTimeEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("xulcommandevent") || aEventType.LowerCaseEqualsLiteral("xulcommandevents")) return NS_NewDOMXULCommandEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("commandevent") || aEventType.LowerCaseEqualsLiteral("commandevents")) return NS_NewDOMCommandEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("elementreplace")) return NS_NewDOMElementReplaceEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("datacontainerevent") || aEventType.LowerCaseEqualsLiteral("datacontainerevents")) return NS_NewDOMDataContainerEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("messageevent")) return NS_NewDOMMessageEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("notifypaintevent")) return NS_NewDOMNotifyPaintEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("simplegestureevent")) return NS_NewDOMSimpleGestureEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("beforeunloadevent")) return NS_NewDOMBeforeUnloadEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("pagetransition")) return NS_NewDOMPageTransitionEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("domtransaction")) return NS_NewDOMDOMTransactionEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("scrollareaevent")) return NS_NewDOMScrollAreaEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("popstateevent")) return NS_NewDOMPopStateEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("closeevent")) return NS_NewDOMCloseEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("touchevent") && TouchEvent::PrefEnabled()) return NS_NewDOMTouchEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("hashchangeevent")) return NS_NewDOMHashChangeEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("customevent")) return NS_NewDOMCustomEvent(aDOMEvent, aOwner, aPresContext, nullptr); if (aEventType.LowerCaseEqualsLiteral("storageevent")) { return NS_NewDOMStorageEvent(aDOMEvent, aOwner); } // NEW EVENT TYPES SHOULD NOT BE ADDED HERE; THEY SHOULD USE ONLY EVENT // CONSTRUCTORS return NS_ERROR_DOM_NOT_SUPPORTED_ERR; }