virtual bool
MainThreadRun() override
{
AssertIsOnMainThread();
// Initialise an AutoJSAPI with the target window.
AutoJSAPI jsapi;
if (NS_WARN_IF(!jsapi.Init(mBackingStore->GetParentObject()))) {
mResult = NS_ERROR_UNEXPECTED;
return true;
}
JSContext* cx = jsapi.cx();
ErrorResult rv;
JS::Rooted<JS::Value> value(cx);
Read(mBackingStore->GetParentObject(), cx, &value, rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
mResult = NS_ERROR_DOM_DATA_CLONE_ERR;
return true;
}
RefPtr<Promise> promise = mBackingStore->Add(cx, value, mId,
mRevisionId, rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
mResult = NS_ERROR_FAILURE;
return true;
}
promise->AppendNativeHandler(mPromiseWorkerProxy);
return true;
}
BlobParent*
FileSystemTaskBase::GetBlobParent(BlobImpl* aFile) const
{
MOZ_ASSERT(XRE_IsParentProcess(),
"Only call from parent process!");
MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
MOZ_ASSERT(aFile);
// Load the lazy dom file data from the parent before sending to the child.
nsString mimeType;
aFile->GetType(mimeType);
// We call GetSize and GetLastModified to prepopulate the value in the
// BlobImpl.
{
ErrorResult rv;
aFile->GetSize(rv);
rv.SuppressException();
}
{
ErrorResult rv;
aFile->GetLastModified(rv);
rv.SuppressException();
}
ContentParent* cp = static_cast<ContentParent*>(mRequestParent->Manager());
return cp->GetOrCreateActorForBlobImpl(aFile);
}
NS_IMETHODIMP
FilePickerParent::IORunnable::Run()
{
// If we're on the main thread, then that means we're done. Just send the
// results.
if (NS_IsMainThread()) {
if (mFilePickerParent) {
mFilePickerParent->SendFilesOrDirectories(mResults);
}
return NS_OK;
}
// We're not on the main thread, so do the IO.
for (uint32_t i = 0; i < mFiles.Length(); ++i) {
if (mIsDirectory) {
nsAutoString path;
nsresult rv = mFiles[i]->GetPath(path);
if (NS_WARN_IF(NS_FAILED(rv))) {
continue;
}
BlobImplOrString* data = mResults.AppendElement();
data->mType = BlobImplOrString::eDirectoryPath;
data->mDirectoryPath = path;
continue;
}
RefPtr<BlobImpl> blobImpl = new BlobImplFile(mFiles[i]);
ErrorResult error;
blobImpl->GetSize(error);
if (NS_WARN_IF(error.Failed())) {
error.SuppressException();
continue;
}
blobImpl->GetLastModified(error);
if (NS_WARN_IF(error.Failed())) {
error.SuppressException();
continue;
}
BlobImplOrString* data = mResults.AppendElement();
data->mType = BlobImplOrString::eBlobImpl;
data->mBlobImpl = blobImpl;
}
// Dispatch ourselves back on the main thread.
if (NS_FAILED(NS_DispatchToMainThread(this))) {
// It's hard to see how we can recover gracefully in this case. The child
// process is waiting for an IPC, but that can only happen on the main
// thread.
MOZ_CRASH();
}
return NS_OK;
}
void
ImageDocument::SetModeClass(eModeClasses mode)
{
nsDOMTokenList* classList = mImageContent->ClassList();
ErrorResult rv;
if (mode == eShrinkToFit) {
classList->Add(NS_LITERAL_STRING("shrinkToFit"), rv);
} else {
classList->Remove(NS_LITERAL_STRING("shrinkToFit"), rv);
}
if (mode == eOverflowingVertical) {
classList->Add(NS_LITERAL_STRING("overflowingVertical"), rv);
} else {
classList->Remove(NS_LITERAL_STRING("overflowingVertical"), rv);
}
if (mode == eOverflowingHorizontalOnly) {
classList->Add(NS_LITERAL_STRING("overflowingHorizontalOnly"), rv);
} else {
classList->Remove(NS_LITERAL_STRING("overflowingHorizontalOnly"), rv);
}
rv.SuppressException();
}
CreateFileTask::CreateFileTask(FileSystemBase* aFileSystem,
const FileSystemCreateFileParams& aParam,
FileSystemRequestParent* aParent)
: FileSystemTaskBase(aFileSystem, aParam, aParent)
, mReplace(false)
{
MOZ_ASSERT(XRE_IsParentProcess(),
"Only call from parent process!");
MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
MOZ_ASSERT(aFileSystem);
GetOutputBufferSize();
mTargetRealPath = aParam.realPath();
mReplace = aParam.replace();
auto& data = aParam.data();
if (data.type() == FileSystemFileDataValue::TArrayOfuint8_t) {
mArrayData = data;
return;
}
BlobParent* bp = static_cast<BlobParent*>(static_cast<PBlobParent*>(data));
RefPtr<BlobImpl> blobImpl = bp->GetBlobImpl();
MOZ_ASSERT(blobImpl, "blobData should not be null.");
ErrorResult rv;
blobImpl->GetInternalStream(getter_AddRefs(mBlobStream), rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
}
}
NS_IMETHODIMP
InsertNodeTransaction::DoTransaction()
{
if (NS_WARN_IF(!mEditorBase) ||
NS_WARN_IF(!mContentToInsert) ||
NS_WARN_IF(!mPointToInsert.IsSet())) {
return NS_ERROR_NOT_INITIALIZED;
}
if (!mPointToInsert.IsSetAndValid()) {
// It seems that DOM tree has been changed after first DoTransaction()
// and current RedoTranaction() call.
if (mPointToInsert.GetChild()) {
EditorDOMPoint newPointToInsert(mPointToInsert.GetChild());
if (!newPointToInsert.IsSet()) {
// The insertion point has been removed from the DOM tree.
// In this case, we should append the node to the container instead.
newPointToInsert.SetToEndOf(mPointToInsert.GetContainer());
if (NS_WARN_IF(!newPointToInsert.IsSet())) {
return NS_ERROR_FAILURE;
}
}
mPointToInsert = newPointToInsert;
} else {
mPointToInsert.SetToEndOf(mPointToInsert.GetContainer());
if (NS_WARN_IF(!mPointToInsert.IsSet())) {
return NS_ERROR_FAILURE;
}
}
}
mEditorBase->MarkNodeDirty(GetAsDOMNode(mContentToInsert));
ErrorResult error;
mPointToInsert.GetContainer()->InsertBefore(*mContentToInsert,
mPointToInsert.GetChild(),
error);
error.WouldReportJSException();
if (NS_WARN_IF(error.Failed())) {
return error.StealNSResult();
}
// Only set selection to insertion point if editor gives permission
if (mEditorBase->GetShouldTxnSetSelection()) {
RefPtr<Selection> selection = mEditorBase->GetSelection();
if (NS_WARN_IF(!selection)) {
return NS_ERROR_FAILURE;
}
// Place the selection just after the inserted element
EditorRawDOMPoint afterInsertedNode(mContentToInsert);
DebugOnly<bool> advanced = afterInsertedNode.AdvanceOffset();
NS_WARNING_ASSERTION(advanced,
"Failed to advance offset after the inserted node");
selection->Collapse(afterInsertedNode, error);
if (NS_WARN_IF(error.Failed())) {
error.SuppressException();
}
}
return NS_OK;
}
static void
AppendBlobImplAsDirectory(nsTArray<OwningFileOrDirectory>& aArray,
BlobImpl* aBlobImpl,
nsIContent* aContent)
{
MOZ_ASSERT(aBlobImpl);
MOZ_ASSERT(aBlobImpl->IsDirectory());
nsAutoString fullpath;
ErrorResult err;
aBlobImpl->GetMozFullPath(fullpath, err);
if (err.Failed()) {
err.SuppressException();
return;
}
nsCOMPtr<nsIFile> file;
NS_ConvertUTF16toUTF8 path(fullpath);
nsresult rv = NS_NewNativeLocalFile(path, true, getter_AddRefs(file));
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
nsPIDOMWindowInner* inner = aContent->OwnerDoc()->GetInnerWindow();
if (!inner || !inner->IsCurrentInnerWindow()) {
return;
}
RefPtr<Directory> directory =
Directory::Create(inner, file);
MOZ_ASSERT(directory);
OwningFileOrDirectory* element = aArray.AppendElement();
element->SetAsDirectory() = directory;
}
void
HTMLVideoElement::UpdateScreenWakeLock()
{
bool hidden = OwnerDoc()->Hidden();
if (mScreenWakeLock && (mPaused || hidden || !mUseScreenWakeLock)) {
ErrorResult rv;
mScreenWakeLock->Unlock(rv);
rv.SuppressException();
mScreenWakeLock = nullptr;
return;
}
if (!mScreenWakeLock && !mPaused && !hidden &&
mUseScreenWakeLock && HasVideo()) {
RefPtr<power::PowerManagerService> pmService =
power::PowerManagerService::GetInstance();
NS_ENSURE_TRUE_VOID(pmService);
ErrorResult rv;
mScreenWakeLock = pmService->NewWakeLock(NS_LITERAL_STRING("screen"),
OwnerDoc()->GetInnerWindow(),
rv);
}
}
// This is called on main thread.
nsresult ReceiveBlob(already_AddRefed<Blob> aBlob)
{
RefPtr<Blob> blob = aBlob;
ErrorResult rv;
uint64_t size = blob->GetSize(rv);
if (rv.Failed()) {
rv.SuppressException();
} else {
AutoJSAPI jsapi;
if (jsapi.Init(mGlobal)) {
JS_updateMallocCounter(jsapi.cx(), size);
}
}
if (mPromise) {
RefPtr<Blob> newBlob = Blob::Create(mGlobal, blob->Impl());
mPromise->MaybeResolve(newBlob);
}
mGlobal = nullptr;
mPromise = nullptr;
return rv.StealNSResult();
}
void HTMLVideoElement::ReleaseVideoWakeLockIfExists() {
if (mScreenWakeLock) {
ErrorResult rv;
mScreenWakeLock->Unlock(rv);
rv.SuppressException();
mScreenWakeLock = nullptr;
return;
}
}
// Sets up |output| iff buffers are set in event handlers.
void DispatchAudioProcessEvent(ScriptProcessorNode* aNode,
AudioChunk* aOutput)
{
AudioContext* context = aNode->Context();
if (!context) {
return;
}
AutoJSAPI jsapi;
if (NS_WARN_IF(!jsapi.Init(aNode->GetOwner()))) {
return;
}
JSContext* cx = jsapi.cx();
uint32_t inputChannelCount = aNode->ChannelCount();
// Create the input buffer
RefPtr<AudioBuffer> inputBuffer;
if (mInputBuffer) {
ErrorResult rv;
inputBuffer =
AudioBuffer::Create(context->GetOwner(), inputChannelCount,
aNode->BufferSize(), context->SampleRate(),
mInputBuffer.forget(), rv);
if (rv.Failed()) {
rv.SuppressException();
return;
}
}
// Ask content to produce data in the output buffer
// Note that we always avoid creating the output buffer here, and we try to
// avoid creating the input buffer as well. The AudioProcessingEvent class
// knows how to lazily create them if needed once the script tries to access
// them. Otherwise, we may be able to get away without creating them!
RefPtr<AudioProcessingEvent> event =
new AudioProcessingEvent(aNode, nullptr, nullptr);
event->InitEvent(inputBuffer, inputChannelCount, mPlaybackTime);
aNode->DispatchTrustedEvent(event);
// Steal the output buffers if they have been set.
// Don't create a buffer if it hasn't been used to return output;
// FinishProducingOutputBuffer() will optimize output = null.
// GetThreadSharedChannelsForRate() may also return null after OOM.
if (event->HasOutputBuffer()) {
ErrorResult rv;
AudioBuffer* buffer = event->GetOutputBuffer(rv);
// HasOutputBuffer() returning true means that GetOutputBuffer()
// will not fail.
MOZ_ASSERT(!rv.Failed());
*aOutput = buffer->GetThreadSharedChannelsForRate(cx);
MOZ_ASSERT(aOutput->IsNull() ||
aOutput->mBufferFormat == AUDIO_FORMAT_FLOAT32,
"AudioBuffers initialized from JS have float data");
}
}
void
AccessibleCaret::RemoveCaretElement(nsIDocument* aDocument)
{
CaretElement()->RemoveEventListener(NS_LITERAL_STRING("touchstart"),
mDummyTouchListener, false);
ErrorResult rv;
aDocument->RemoveAnonymousContent(*mCaretElementHolder, rv);
// It's OK rv is failed since nsCanvasFrame might not exists now.
rv.SuppressException();
}
void
SendError(CB* aCallback, ErrorCode aErrorCode)
{
Rsp response;
response.mErrorCode.Construct(static_cast<uint32_t>(aErrorCode));
ErrorResult rv;
aCallback->Call(response, rv);
NS_WARN_IF(rv.Failed());
// Useful exceptions already got reported.
rv.SuppressException();
}
/* static */ already_AddRefed<dom::Promise>
MP4Decoder::IsVideoAccelerated(layers::LayersBackend aBackend, nsIGlobalObject* aParent)
{
MOZ_ASSERT(NS_IsMainThread());
ErrorResult rv;
RefPtr<dom::Promise> promise;
promise = dom::Promise::Create(aParent, rv);
if (rv.Failed()) {
rv.SuppressException();
return nullptr;
}
RefPtr<TaskQueue> taskQueue =
new TaskQueue(GetMediaThreadPool(MediaThreadType::PLATFORM_DECODER));
VideoInfo config;
RefPtr<MediaDataDecoder> decoder(CreateTestH264Decoder(aBackend, config, taskQueue));
if (!decoder) {
taskQueue->BeginShutdown();
taskQueue->AwaitShutdownAndIdle();
promise->MaybeResolve(NS_LITERAL_STRING("No; Failed to create H264 decoder"));
return promise.forget();
}
decoder->Init()
->Then(AbstractThread::MainThread(), __func__,
[promise, decoder, taskQueue] (TrackInfo::TrackType aTrack) {
nsCString failureReason;
bool ok = decoder->IsHardwareAccelerated(failureReason);
nsAutoString result;
if (ok) {
result.AssignLiteral("Yes");
} else {
result.AssignLiteral("No");
}
if (failureReason.Length()) {
result.AppendLiteral("; ");
AppendUTF8toUTF16(failureReason, result);
}
decoder->Shutdown();
taskQueue->BeginShutdown();
taskQueue->AwaitShutdownAndIdle();
promise->MaybeResolve(result);
},
[promise, decoder, taskQueue] (MediaDataDecoder::DecoderFailureReason aResult) {
decoder->Shutdown();
taskQueue->BeginShutdown();
taskQueue->AwaitShutdownAndIdle();
promise->MaybeResolve(NS_LITERAL_STRING("No; Failed to initialize H264 decoder"));
});
return promise.forget();
}
bool
TCPSocketParent::RecvResume()
{
NS_ENSURE_TRUE(mSocket, true);
ErrorResult rv;
mSocket->Resume(rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
}
return true;
}
bool
TCPSocketParent::RecvStartTLS()
{
NS_ENSURE_TRUE(mSocket, true);
ErrorResult rv;
mSocket->UpgradeToSecure(rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
}
return true;
}
void
ServiceWorkerJob::Finish(ErrorResult& aRv)
{
AssertIsOnMainThread();
MOZ_ASSERT(mState == State::Started);
// Ensure that we only surface SecurityErr, TypeErr or InvalidStateErr to script.
if (aRv.Failed() && !aRv.ErrorCodeIs(NS_ERROR_DOM_SECURITY_ERR) &&
!aRv.ErrorCodeIs(NS_ERROR_DOM_TYPE_ERR) &&
!aRv.ErrorCodeIs(NS_ERROR_DOM_INVALID_STATE_ERR)) {
// Remove the old error code so we can replace it with a TypeError.
aRv.SuppressException();
NS_ConvertUTF8toUTF16 scriptSpec(mScriptSpec);
NS_ConvertUTF8toUTF16 scope(mScope);
// Throw the type error with a generic error message.
aRv.ThrowTypeError<MSG_SW_INSTALL_ERROR>(scriptSpec, scope);
}
// The final callback may drop the last ref to this object.
RefPtr<ServiceWorkerJob> kungFuDeathGrip = this;
if (!mResultCallbacksInvoked) {
InvokeResultCallbacks(aRv);
}
mState = State::Finished;
mFinalCallback->JobFinished(this, aRv);
mFinalCallback = nullptr;
// The callback might not consume the error.
aRv.SuppressException();
// Async release this object to ensure that our caller methods complete
// as well.
NS_ReleaseOnMainThread(kungFuDeathGrip.forget(), true /* always proxy */);
}
virtual bool
MainThreadRun() override
{
AssertIsOnMainThread();
ErrorResult rv;
mReadOnly = mBackingStore->GetReadOnly(rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
}
return true;
}
bool
FileSystemBase::GetRealPath(BlobImpl* aFile, nsIFile** aPath) const
{
AssertIsOnOwningThread();
MOZ_ASSERT(aFile, "aFile Should not be null.");
MOZ_ASSERT(aPath);
nsAutoString filePath;
ErrorResult rv;
aFile->GetMozFullPathInternal(filePath, rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
return false;
}
rv = NS_NewLocalFile(filePath, true, aPath);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
return false;
}
return true;
}
void
URL::URLSearchParamsUpdated(URLSearchParams* aSearchParams)
{
MOZ_ASSERT(mSearchParams);
MOZ_ASSERT(mSearchParams == aSearchParams);
nsAutoString search;
mSearchParams->Serialize(search);
ErrorResult rv;
SetSearchInternal(search, rv);
NS_WARNING_ASSERTION(!rv.Failed(), "SetSearchInternal failed");
rv.SuppressException();
}
void
ImageDocument::ShrinkToFit()
{
if (!mImageContent) {
return;
}
if (GetZoomLevel() != mOriginalZoomLevel && mImageIsResized &&
!nsContentUtils::IsChildOfSameType(this)) {
// If we're zoomed, so that we don't maintain the invariant that
// mImageIsResized if and only if its displayed width/height fit in
// mVisibleWidth/mVisibleHeight, then we may need to switch to/from the
// overflowingVertical class here, because our viewport size may have
// changed and we don't plan to adjust the image size to compensate. Since
// mImageIsResized it has a "height" attribute set, and we can just get the
// displayed image height by getting .height on the HTMLImageElement.
HTMLImageElement* img = HTMLImageElement::FromContent(mImageContent);
uint32_t imageHeight = img->Height();
nsDOMTokenList* classList = img->ClassList();
ErrorResult ignored;
if (imageHeight > mVisibleHeight) {
classList->Add(NS_LITERAL_STRING("overflowingVertical"), ignored);
} else {
classList->Remove(NS_LITERAL_STRING("overflowingVertical"), ignored);
}
ignored.SuppressException();
return;
}
// Keep image content alive while changing the attributes.
nsCOMPtr<Element> imageContent = mImageContent;
nsCOMPtr<nsIDOMHTMLImageElement> image = do_QueryInterface(imageContent);
image->SetWidth(std::max(1, NSToCoordFloor(GetRatio() * mImageWidth)));
image->SetHeight(std::max(1, NSToCoordFloor(GetRatio() * mImageHeight)));
// The view might have been scrolled when zooming in, scroll back to the
// origin now that we're showing a shrunk-to-window version.
ScrollImageTo(0, 0, false);
if (!mImageContent) {
// ScrollImageTo flush destroyed our content.
return;
}
SetModeClass(eShrinkToFit);
mImageIsResized = true;
UpdateTitleAndCharset();
}
void WebAudioDecodeJob::OnSuccess(ErrorCode aErrorCode) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aErrorCode == NoError);
if (mSuccessCallback) {
ErrorResult rv;
mSuccessCallback->Call(*mOutput, rv);
// Ignore errors in calling the callback, since there is not much that we
// can do about it here.
rv.SuppressException();
}
mPromise->MaybeResolve(mOutput);
mContext->RemoveFromDecodeQueue(this);
}
virtual bool
MainThreadRun() override
{
AssertIsOnMainThread();
ErrorResult rv;
RefPtr<Promise> promise = mBackingStore->GetLength(rv);
promise->AppendNativeHandler(mPromiseWorkerProxy);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
mFailed = true;
}
return true;
}
virtual bool
MainThreadRun() override
{
AssertIsOnMainThread();
ErrorResult rv;
nsString string;
(mBackingStore.get()->*mFunc)(string, rv);
mString.Assign(string);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
}
return true;
}
void
GetEntryHelper::Run()
{
MOZ_ASSERT(!mParts.IsEmpty());
ErrorResult rv;
RefPtr<Promise> promise = mDirectory->Get(mParts[0], rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
Error(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
mParts.RemoveElementAt(0);
promise->AppendNativeHandler(this);
}
void
BlobImplFile::GetType(nsAString& aType)
{
aType.Truncate();
if (mContentType.IsVoid()) {
NS_ASSERTION(mWholeFile,
"Should only use lazy ContentType when using the whole file");
if (!NS_IsMainThread()) {
WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
if (!workerPrivate) {
// I have no idea in which thread this method is called. We cannot
// return any valid value.
return;
}
RefPtr<GetTypeRunnable> runnable =
new GetTypeRunnable(workerPrivate, this);
ErrorResult rv;
runnable->Dispatch(rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
}
return;
}
nsresult rv;
nsCOMPtr<nsIMIMEService> mimeService =
do_GetService(NS_MIMESERVICE_CONTRACTID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
nsAutoCString mimeType;
rv = mimeService->GetTypeFromFile(mFile, mimeType);
if (NS_FAILED(rv)) {
mimeType.Truncate();
}
AppendUTF8toUTF16(mimeType, mContentType);
mContentType.SetIsVoid(false);
}
aType = mContentType;
}
void
PerformanceObserver::Notify()
{
if (mQueuedEntries.IsEmpty()) {
return;
}
RefPtr<PerformanceObserverEntryList> list =
new PerformanceObserverEntryList(this, mQueuedEntries);
mQueuedEntries.Clear();
ErrorResult rv;
mCallback->Call(this, *list, *this, rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
}
}
already_AddRefed<DOMStringList>
DataTransfer::GetTypes(ErrorResult& aRv) const
{
RefPtr<DOMStringList> types = new DOMStringList();
const nsTArray<RefPtr<DataTransferItem>>* items = mItems->MozItemsAt(0);
if (NS_WARN_IF(!items)) {
return types.forget();
}
for (uint32_t i = 0; i < items->Length(); i++) {
DataTransferItem* item = items->ElementAt(i);
MOZ_ASSERT(item);
if (item->ChromeOnly() && !nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {
continue;
}
nsAutoString type;
item->GetType(type);
if (item->Kind() == DataTransferItem::KIND_STRING || type.EqualsASCII(kFileMime)) {
// If the entry has kind KIND_STRING, we want to add it to the list.
if (NS_WARN_IF(!types->Add(type))) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
}
}
for (uint32_t i = 0; i < mItems->Length(); ++i) {
ErrorResult rv;
bool found = false;
DataTransferItem* item = mItems->IndexedGetter(i, found, rv);
if (!found || rv.Failed() || item->Kind() != DataTransferItem::KIND_FILE) {
rv.SuppressException();
continue;
}
if (NS_WARN_IF(!types->Add(NS_LITERAL_STRING("Files")))) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
break;
}
return types.forget();
}
virtual bool
MainThreadRun() override
{
AssertIsOnMainThread();
// Point WorkerDataStoreCursor to DataStoreCursor.
ErrorResult rv;
RefPtr<DataStoreCursor> cursor = mBackingStore->Sync(mRevisionId, rv);
if (NS_WARN_IF(rv.Failed())) {
rv.SuppressException();
mFailed = true;
return true;
}
nsMainThreadPtrHandle<DataStoreCursor> backingCursor(
new nsMainThreadPtrHolder<DataStoreCursor>(cursor));
mWorkerCursor->SetBackingDataStoreCursor(backingCursor);
return true;
}
already_AddRefed<nsIDOMCSSStyleDeclaration>
nsWinUtils::GetComputedStyleDeclaration(nsIContent* aContent)
{
nsIContent* elm = nsCoreUtils::GetDOMElementFor(aContent);
if (!elm)
return nullptr;
// Returns number of items in style declaration
nsCOMPtr<nsPIDOMWindowInner> window = elm->OwnerDoc()->GetInnerWindow();
if (!window)
return nullptr;
ErrorResult dummy;
nsCOMPtr<nsICSSDeclaration> cssDecl;
nsCOMPtr<Element> domElement(do_QueryInterface(elm));
cssDecl = window->GetComputedStyle(*domElement, EmptyString(), dummy);
nsCOMPtr<nsIDOMCSSStyleDeclaration> domDecl = do_QueryInterface(cssDecl);
dummy.SuppressException();
return domDecl.forget();
}
