|
Times Different | |||||
31602 | }else if( eFileLock==EXCLUSIVE_LOCK ){ | 4 | ||||
31603 | pFile->eFileLock = PENDING_LOCK; | 4 | ||||
31604 | pInode->eFileLock = PENDING_LOCK; | 4 | ||||
53425 | && pPager->journalMode==PAGER_JOURNALMODE_PERSIST | 10 | ||||
61460 | p->pNext = pSib; | 2 | ||||
61461 | p->pPrev = 0; | 2 | ||||
61462 | pSib->pPrev = p; | 2 |
|
Times Different | |||||
2457 | obs->Reflow(aStart, aEnd); | 6 |
|
Times Different | |||||
568 | nsSHistory::GetEntryAtIndex(int32_t aIndex, bool aModifyIndex, | 6 | ||||
575 | rv = GetTransactionAtIndex(aIndex, getter_AddRefs(txn)); | 6 | ||||
576 | if (NS_SUCCEEDED(rv) && txn) { | 6 | ||||
578 | rv = txn->GetSHEntry(aResult); | 6 | ||||
579 | if (NS_SUCCEEDED(rv) && (*aResult)) { | 6 | ||||
581 | if (aModifyIndex) { | 6 | ||||
587 | return rv; | 6 |
|
Times Different | |||||
147 | std::max(std::min(StickyTimeDuration(localTime - aTiming.Delay()), | 7 | ||||
148 | result.mActiveDuration), | 7 | ||||
149 | zeroDuration); | 7 | ||||
205 | progress == 0.0 && | 7 | ||||
207 | (result.mActiveTime != zeroDuration || | 7 | ||||
213 | MOZ_ASSERT(result.mCurrentIteration != 0, | 7 | ||||
215 | progress = 1.0; | 7 | ||||
216 | if (result.mCurrentIteration != UINT64_MAX) { | 7 | ||||
217 | result.mCurrentIteration--; | 7 |
|
Times Different | |||||
222 | aDriver->RemoveRefreshObserver(this, FlushType::Style); | 4 | ||||
223 | mIsObservingRefreshDriver = false; | 4 |
|
Times Different | |||||
343 | bool& postedRestyle = iter.Data(); | 6 | ||||
344 | if (postedRestyle) { | 6 | ||||
350 | cascadeLevel); | 2 | ||||
351 | postedRestyle = true; | 2 |
|
Times Different | |||||
725 | KeyframeEffectReadOnly::IsRunningOnCompositor() const | 2 | ||||
731 | for (const AnimationProperty& property : mProperties) { | 2 | ||||
732 | if (property.mIsRunningOnCompositor) { | 2 | ||||
736 | return false; | 2 |
|
Times Different | |||||
1685 | MarkUncollectableForCCGeneration(nsCCUncollectableMarker::sGeneration); | 2 | ||||
1687 | for (uint32_t i = 0; i < grayNodes.Length(); ++i) { | 2 | ||||
1697 | nsIContent* purple = nodesToUnpurple[i]; | 2 | ||||
1699 | if (purple != aNode) { | 2 | ||||
1700 | purple->RemovePurple(); | 4 | ||||
1721 | uint32_t len = gNodesToUnbind->Length(); | 4 | ||||
1722 | for (uint32_t i = 0; i < len; ++i) { | 4 | ||||
1723 | nsIContent* c = gNodesToUnbind->ElementAt(i); | 4 | ||||
1724 | c->SetIsPurpleRoot(false); | 4 | ||||
1725 | ContentUnbinder::Append(c); | 4 | ||||
1727 | delete gNodesToUnbind; | 4 | ||||
1728 | gNodesToUnbind = nullptr; | 4 | ||||
1841 | if (node->IsPurple() && (node != aNode || aRemovingAllowed)) { | 6 | ||||
1842 | node->RemovePurple(); | 6 | ||||
1844 | MarkNodeChildren(node); | 6 | ||||
1858 | if (!gNodesToUnbind) { | 4 | ||||
1859 | gNodesToUnbind = new AutoTArray |
4 | ||||
1861 | gNodesToUnbind->AppendElement(static_cast |
4 | ||||
1862 | for (uint32_t i = 0; i < nodesToClear.Length(); ++i) { | 4 | ||||
1863 | nsIContent* n = nodesToClear[i]; | 4 | ||||
1864 | if ((n != aNode || aRemovingAllowed) && n->IsPurple()) { | 4 | ||||
1865 | n->RemovePurple(); | 4 | ||||
1892 | nsIContent* n = nodesToClear[i]; | 6 | ||||
1893 | MarkNodeChildren(n); | 6 | ||||
1896 | if ((n != aNode || aRemovingAllowed) && n->IsPurple()) { | 6 | ||||
1897 | n->RemovePurple(); | 6 |
|
Times Different | |||||
707 | mExecutor->Cancel(); | 6 | ||||
709 | OrderedTimeoutIterator iter(mNormalTimeouts, mTrackingTimeouts); | 6 | ||||
710 | Timeout* nextTimeout = iter.Next(); | 6 | ||||
711 | if (nextTimeout) { | 6 | ||||
712 | MOZ_ALWAYS_SUCCEEDS(MaybeSchedule(nextTimeout->When())); | 6 | ||||
713 | } | 6 | ||||
724 | return; | 6 | ||||
770 | deadline = aTargetDeadline; | 4 | ||||
839 | return; | 6 |
|
Times Different | |||||
138 | static_cast |
6 | ||||
139 | EventListenerManager* elm = et->GetExistingListenerManager(); | 6 | ||||
140 | if (elm) { | 6 | ||||
141 | elm->MarkForCC(); | 6 | ||||
144 | } | 6 | ||||
239 | MarkSHEntry(nsISHEntry* aSHEntry, bool aCleanupJS, bool aPrepareForCC) | 6 | ||||
241 | if (!aSHEntry) { | 6 | ||||
246 | aSHEntry->GetContentViewer(getter_AddRefs(cview)); | 6 | ||||
247 | MarkContentViewer(cview, aCleanupJS, aPrepareForCC); | 6 | ||||
249 | nsCOMPtr |
6 | ||||
250 | int32_t i = 0; | 6 | ||||
251 | while (NS_SUCCEEDED(aSHEntry->ChildShellAt(i++, getter_AddRefs(child))) && | 6 | ||||
256 | nsCOMPtr |
6 | ||||
258 | shCont->GetChildCount(&count); | 6 | ||||
259 | for (i = 0; i < count; ++i) { | 6 | ||||
263 | } | 6 | ||||
287 | history->GetEntryAtIndex(i, false, getter_AddRefs(shEntry)); | 6 | ||||
289 | MarkSHEntry(shEntry, aCleanupJS, aPrepareForCC); | 6 | ||||
290 | } | 6 |
|
Times Different | |||||
60 | NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsBaseContentList) | 6 | ||||
61 | if (nsCCUncollectableMarker::sGeneration && tmp->HasKnownLiveWrapper()) { | 6 | ||||
62 | for (uint32_t i = 0; i < tmp->mElements.Length(); ++i) { | 6 | ||||
63 | nsIContent* c = tmp->mElements[i]; | 6 | ||||
64 | if (c->IsPurple()) { | 6 | ||||
65 | c->RemovePurple(); | 6 | ||||
67 | Element::MarkNodeChildren(c); | 6 |
|
Times Different | |||||
189 | nsCOMPtr |
10 | ||||
190 | isTopLevel = topWindow == window; | 10 |
|
Times Different | |||||
241 | if (mDeferredFlushTags) { | 2 | ||||
244 | if (mDeferredLayoutStart) { | 2 | ||||
251 | StartLayout(false); | 2 | ||||
255 | ScrollToRef(); | 2 | ||||
1321 | mDeferredFlushTags = true; | 7 |
|
Times Different | |||||
313 | virtual bool OwnedOnlyByTheDOMTree() override | 2 | ||||
315 | return GetParent() && mRefCnt.get() == 1; | 2 | ||||
322 | virtual void RemovePurple() override | 6 | ||||
324 | mRefCnt.RemovePurple(); | 6 | ||||
325 | } | 6 |
|
Times Different | |||||
1779 | js::SetProxyReservedSlot(proxy, 0, js::PrivateValue(nullptr)); | 6 | ||||
2304 | tmp->mTimeoutManager->ForEachUnorderedTimeout([&cb](Timeout* timeout) { | 8 | ||||
2305 | cb.NoteNativeChild(timeout, NS_CYCLE_COLLECTION_PARTICIPANT(Timeout)); | 8 | ||||
2326 | cb.NoteNativeChild(request, NS_CYCLE_COLLECTION_PARTICIPANT(IdleRequest)); | 8 |
|
Times Different | |||||
119 | nsInProcessTabChildGlobal::MarkForCC() | 6 | ||||
121 | MarkScopesForCC(); | 6 | ||||
122 | return mMessageManager ? mMessageManager->MarkForCC() : false; | 6 |
|
Times Different | |||||
1470 | idleDuration = aDeadline - startTimeStamp; | 6 | ||||
2079 | ccDelay = NS_CC_DELAY / 3; | 2 | ||||
2081 | PRTime now = PR_Now(); | 2 | ||||
2082 | if (sCCLockedOutTime == 0) { | 2 | ||||
2088 | sCCRunnerFireCount = 0; | 2 | ||||
2089 | sCCLockedOutTime = now; | 2 | ||||
2090 | return false; | 2 | ||||
2092 | if (now - sCCLockedOutTime < NS_MAX_CC_LOCKEDOUT_TIME) { | 2 | ||||
2272 | sNeedsGCAfterCC = true; | 2 | ||||
2273 | return; | 2 |
|
Times Different | |||||
414 | buff = static_cast |
4 | ||||
415 | if (!buff) { | 4 | ||||
419 | memcpy(buff, m1b, mState.mLength); | 4 | ||||
420 | mState.mInHeap = true; | 4 |
|
Times Different | |||||
657 | mCheckTimerWaitingForCCEnd = true; | 2 | ||||
658 | return; | 2 |
|
Times Different | |||||
22 | const_cast |
4 | ||||
23 | return nullptr; | 4 | ||||
56 | *hasGrayObjects = true; | 6 |
|
Times Different | |||||
600 | TErrorResult |
2 | ||||
602 | AssertInOwningThread(); | 2 | ||||
603 | if (JS_IsExceptionPending(aCx)) { | 2 | ||||
606 | mResult = NS_ERROR_UNCATCHABLE_EXCEPTION; | 2 | ||||
608 | } | 2 |
|
Times Different | |||||
32 | NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(CustomEvent, Event) | 6 | ||||
33 | tmp->mDetail.setUndefined(); | 6 | ||||
35 | NS_IMPL_CYCLE_COLLECTION_UNLINK_END | 6 |
|
Times Different | |||||
374 | DOMEventTargetHelper::GetContextForEventHandlers(nsresult* aRv) | 4 | ||||
376 | *aRv = CheckInnerWindowCorrectness(); | 4 | ||||
377 | if (NS_FAILED(*aRv)) { | 4 | ||||
380 | nsPIDOMWindowInner* owner = GetOwner(); | 4 | ||||
382 | : nullptr; | 4 |
|
Times Different | |||||
151 | NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Event) | 6 | ||||
152 | if (tmp->mEventIsInternal) { | 6 | ||||
153 | tmp->mEvent->mTarget = nullptr; | 6 | ||||
154 | tmp->mEvent->mCurrentTarget = nullptr; | 6 | ||||
155 | tmp->mEvent->mOriginalTarget = nullptr; | 6 | ||||
156 | switch (tmp->mEvent->mClass) { | 6 | ||||
183 | NS_IMPL_CYCLE_COLLECTION_UNLINK(mPresContext); | 6 | ||||
184 | NS_IMPL_CYCLE_COLLECTION_UNLINK(mExplicitOriginalTarget); | 6 | ||||
185 | NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner); | 6 | ||||
186 | NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER | 6 | ||||
187 | NS_IMPL_CYCLE_COLLECTION_UNLINK_END | 6 | ||||
220 | NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mEvent->mRelatedTarget"); | 2 | ||||
221 | cb.NoteXPCOMChild(tmp->mEvent->AsFocusEvent()->mRelatedTarget); | 2 | ||||
222 | break; | 2 |
|
Times Different | |||||
1318 | aEvent->mFlags.mExceptionWasRaised = true; | 2 |
|
Times Different | |||||
4262 | targetElement = mDocument->GetRootElement(); | 6 | ||||
4746 | mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(content)); | 6 |
|
Times Different | |||||
148 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(IMEContentObserver) | 2 | ||||
149 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWidget) | 2 | ||||
150 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFocusedWidget) | 2 | ||||
151 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelection) | 2 | ||||
152 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootContent) | 2 | ||||
153 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditableNode) | 2 | ||||
154 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocShell) | 2 | ||||
155 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditorBase) | 2 | ||||
156 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentObserver) | 2 | ||||
157 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEndOfAddedTextCache.mContainerNode) | 2 | ||||
158 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE( | 2 | ||||
160 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END | 2 | ||||
734 | IMEContentObserver::Reflow(DOMHighResTimeStamp aStart, | 6 | ||||
737 | if (!NeedsPositionChangeNotification()) { | 6 | ||||
741 | MaybeNotifyIMEOfPositionChange(); | 6 | ||||
742 | return NS_OK; | 6 | ||||
1746 | return; | 11 | ||||
2160 | return; | 9 | ||||
2164 | MOZ_LOG(sIMECOLog, LogLevel::Debug, | 9 | ||||
2262 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(IMEContentObserver::DocumentObserver) | 2 | ||||
2263 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIMEContentObserver) | 2 | ||||
2264 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument) | 2 | ||||
2265 | NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END | 2 |
|
Times Different | |||||
217 | return rv.StealNSResult(); | 2 |
|
Times Different | |||||
2849 | if (aRead && !history->HasStates()) { | 7 |
|
Times Different | |||||
5715 | return mIdleTime < aOther.mIdleTime; | 3 | ||||
5736 | operator==(const IdleThreadInfo& aOther) const | 3 | ||||
5738 | return mThreadInfo.mRunnable == aOther.mThreadInfo.mRunnable && | 3 | ||||
5739 | mThreadInfo.mThread == aOther.mThreadInfo.mThread; | 3 | ||||
5745 | return mIdleTime < aOther.mIdleTime; | 3 | ||||
12083 | IdleThreadInfo& info = self->mIdleThreads[index]; | 3 | ||||
12084 | MOZ_ASSERT(info.mThreadInfo.mThread); | 3 | ||||
12085 | MOZ_ASSERT(info.mThreadInfo.mRunnable); | 3 | ||||
12087 | if (now >= info.mIdleTime) { | 3 | ||||
12447 | (newTargetIdleTime.IsNull() || mTargetIdleTime != newTargetIdleTime)) { | 3 | ||||
12636 | const uint32_t lastIndex = mIdleThreads.Length() - 1; | 3 | ||||
12638 | ThreadInfo& threadInfo = mIdleThreads[lastIndex].mThreadInfo; | 3 | ||||
12640 | dbInfo->mThreadInfo.mRunnable.swap(threadInfo.mRunnable); | 3 | ||||
12641 | dbInfo->mThreadInfo.mThread.swap(threadInfo.mThread); | 3 | ||||
12643 | mIdleThreads.RemoveElementAt(lastIndex); | 3 | ||||
12645 | AdjustIdleTimer(); | 3 |
|
Times Different | |||||
2420 | &ScriptLoader::ProcessPendingRequests); | 7 | ||||
2421 | if (mDocument) { | 7 | ||||
2422 | mDocument->Dispatch("ScriptLoader", TaskCategory::Other, task.forget()); | 7 | ||||
2425 | } | 7 |
|
Times Different | |||||
536 | WarningOnlyErrorReporter(JSContext* aCx, JSErrorReport* aRep) | 2 | ||||
538 | MOZ_ASSERT(JSREPORT_IS_WARNING(aRep->flags)); | 2 | ||||
539 | if (!NS_IsMainThread()) { | 2 | ||||
547 | workers::WorkerPrivate* worker = workers::GetWorkerPrivateFromContext(aCx); | 2 | ||||
548 | MOZ_ASSERT(worker); | 2 | ||||
550 | worker->ReportError(aCx, JS::ConstUTF8CharsZ(), aRep); | 2 | ||||
551 | return; | 2 |
|
Times Different | |||||
399 | nsIPresShell *presShell = doc->GetShell(); | 8 | ||||
400 | if (!presShell) | 8 |
|
Times Different | |||||
2347 | NS_ASSERTION(!workers->IsEmpty(), "Should have been removed!"); | 4 | ||||
2348 | aWorkers.AppendElements(*workers); | 4 | ||||
2364 | for (uint32_t index = 0; index < workers.Length(); index++) { | 4 | ||||
2365 | WorkerPrivate*& worker = workers[index]; | 4 | ||||
2367 | if (worker->IsSharedWorker()) { | 4 | ||||
2370 | worker->Cancel(); | 4 |
|
Times Different | |||||
1685 | NS_IMETHOD_(bool) IsOnCurrentThreadInfallible() override | 7 | ||||
1687 | MutexAutoLock lock(mMutex); | 7 | ||||
1689 | if (!mWorkerPrivate) { | 7 | ||||
1693 | return mWorkerPrivate->IsOnCurrentThread(); | 7 | ||||
1697 | IsOnCurrentThread(bool* aIsOnCurrentThread) override | 7 | ||||
1699 | MOZ_ASSERT(aIsOnCurrentThread); | 7 | ||||
1700 | *aIsOnCurrentThread = IsOnCurrentThreadInfallible(); | 7 | ||||
1701 | return NS_OK; | 7 | ||||
5305 | mayContinue = false; | 2 | ||||
5337 | NS_ASSERTION(!JS_IsExceptionPending(aCx), | 2 | ||||
5349 | WorkerPrivate::IsOnCurrentThread() | 7 | ||||
5353 | MOZ_ASSERT(mPRThread); | 7 | ||||
5354 | return PR_GetCurrentThread() == mPRThread; | 7 | ||||
5833 | normalRunnablesPending = NS_HasPendingEvents(mThread); | 2 | ||||
5838 | if (loopInfo->mCompleted) { | 2 | ||||
6261 | WorkerPrivate::ReportError(JSContext* aCx, JS::ConstUTF8CharsZ aToStringResult, | 2 | ||||
6264 | AssertIsOnWorkerThread(); | 2 | ||||
6266 | if (!MayContinueRunning() || mErrorHandlerRecursionCount == 2) { | 2 | ||||
6267 | return; | 2 |
|
Times Different | |||||
354 | Cancel() | 4 | ||||
356 | return Notify(Canceling); | 4 |
|
Times Different | |||||
376 | XMLHttpRequestMainThread::IsCertainlyAliveForCC() const | 2 | ||||
378 | return mWaitingForOnStopRequest; | 2 | ||||
3711 | XMLHttpRequestMainThread::Notify(nsITimer* aTimer) | 6 | ||||
3713 | if (mProgressNotifier == aTimer) { | 6 | ||||
3714 | HandleProgressTimerCallback(); | 6 | ||||
3715 | return NS_OK; | 6 | ||||
3734 | XMLHttpRequestMainThread::HandleProgressTimerCallback() | 6 | ||||
3737 | if (!mLoadTotal && mLoadTransferred) { | 6 | ||||
3741 | mProgressTimerIsActive = false; | 6 | ||||
3743 | if (!mProgressSinceLastProgressEvent || mErrorLoad != ErrorType::eOK) { | 6 | ||||
3951 | XMLHttpRequestMainThread::GetName(nsACString& aName) | 6 | ||||
3953 | aName.AssignLiteral("XMLHttpRequest"); | 6 | ||||
3954 | return NS_OK; | 6 |
|
Times Different | |||||
765 | ++mInNotification; | 4 | ||||
769 | --mInNotification; | 4 |
|
Times Different | |||||
72 | NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsXULPopupListener) | 6 | ||||
74 | if (tmp->mElement) { | 6 | ||||
75 | return mozilla::dom::FragmentOrElement::CanSkip(tmp->mElement, true); | 6 |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
530 | return Rect(); | 7 |
|
Times Different | |||||
81 | static IntPointTyped |
12 | ||||
82 | return IntPointTyped(int32_t(floorf(aX + 0.5)), int32_t(floorf(aY + 0.5))); | 12 | ||||
189 | IntPointTyped |
12 | ||||
191 | return IntPointTyped::Round(aPoint.x, aPoint.y); | 12 |
|
Times Different | |||||
237 | RectTyped() : Super() {} | 7 |
|
Times Different | |||||
223 | step = 1; | 5 | ||||
329 | step = 1; | 4 | ||||
460 | step = 1; | 2 |
|
Times Different | |||||
103 | info->src_format == src_format && | 9 | ||||
104 | info->mask_format == mask_format && | 9 | ||||
105 | info->dest_format == dest_format && | 9 | ||||
106 | info->src_flags == src_flags && | 9 | ||||
107 | info->mask_flags == mask_flags && | 9 | ||||
108 | info->dest_flags == dest_flags && | 9 | ||||
109 | info->func) | 9 | ||||
111 | *out_imp = cache->cache[i].imp; | 9 | ||||
112 | *out_func = cache->cache[i].fast_path.func; | 9 | ||||
114 | goto update_cache; | 9 |
|
Times Different | |||||
1534 | EXCHANGE_RECTS (i, j); | 3 | ||||
1798 | reg->extents.y2 = hreg->extents.y2; | 9 | ||||
2158 | part_out = FALSE; | 9 | ||||
2159 | part_in = FALSE; | 9 | ||||
2162 | x = prect->x1; | 9 | ||||
2163 | y = prect->y1; | 9 | ||||
2166 | for (pbox = PIXREGION_BOXPTR (region), pbox_end = pbox + numRects; | 9 | ||||
2171 | if (pbox->y2 <= y) | 9 | ||||
2177 | if (pbox->y1 > y) | 9 | ||||
2185 | if (pbox->x2 <= x) | 9 | ||||
2188 | if (pbox->x1 > x) | 9 | ||||
2190 | part_out = TRUE; /* missed part of rectangle to left */ | 9 | ||||
2191 | if (part_in) | 9 | ||||
2195 | if (pbox->x1 < prect->x2) | 9 | ||||
2197 | part_in = TRUE; /* definitely overlap */ | 9 | ||||
2198 | if (part_out) | 9 | ||||
2223 | if (part_in) | 9 | ||||
2225 | if (y < prect->y2) | 9 |
|
Times Different | |||||
371 | BufferTextureData::UpdateFromSurface(gfx::SourceSurface* aSurface) | 12 | ||||
373 | if (mDescriptor.type() != BufferDescriptor::TRGBDescriptor) { | 12 | ||||
376 | const RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor(); | 12 | ||||
378 | uint32_t stride = ImageDataSerializer::GetRGBStride(rgb); | 12 | ||||
380 | gfx::Factory::CreateWrappingDataSourceSurface(GetBuffer(), stride, | 12 | ||||
381 | rgb.size(), rgb.format()); | 12 | ||||
383 | if (!surface) { | 12 | ||||
388 | RefPtr |
12 | ||||
390 | if (!srcSurf) { | 12 | ||||
395 | if (surface->GetSize() != srcSurf->GetSize() || surface->GetFormat() != srcSurf->GetFormat()) { | 12 | ||||
402 | if (!srcSurf->Map(gfx::DataSourceSurface::READ, &sourceMap)) { | 12 | ||||
407 | if (!surface->Map(gfx::DataSourceSurface::WRITE, &destMap)) { | 12 | ||||
414 | for (int y = 0; y < srcSurf->GetSize().height; y++) { | 12 | ||||
415 | memcpy(destMap.mData + destMap.mStride * y, | 12 | ||||
416 | sourceMap.mData + sourceMap.mStride * y, | 12 | ||||
417 | srcSurf->GetSize().width * BytesPerPixel(srcSurf->GetFormat())); | 12 | ||||
420 | srcSurf->Unmap(); | 12 | ||||
421 | surface->Unmap(); | 12 | ||||
423 | return true; | 12 |
|
Times Different | |||||
58 | BufferRecycleBin::BufferRecycleBin() | 12 | ||||
63 | , mRecycledBufferSize(0) | 12 | ||||
65 | } | 12 | ||||
156 | ImageContainer::ImageContainer(Mode flag) | 12 | ||||
158 | mGenerationCounter(++sGenerationCounter), | 12 | ||||
163 | mIsAsync(flag == ASYNCHRONOUS), | 12 | ||||
164 | mCurrentProducerID(-1) | 12 | ||||
166 | if (flag == ASYNCHRONOUS) { | 12 | ||||
169 | } | 12 | ||||
185 | ImageContainer::~ImageContainer() | 12 | ||||
187 | if (mNotifyCompositeListener) { | 12 | ||||
190 | if (mAsyncContainerHandle) { | 12 | ||||
195 | } | 12 | ||||
220 | ImageContainer::SetCurrentImageInternal(const nsTArray |
12 | ||||
222 | ReentrantMonitorAutoEnter mon(mReentrantMonitor); | 12 | ||||
224 | mGenerationCounter = ++sGenerationCounter; | 12 | ||||
226 | if (!aImages.IsEmpty()) { | 12 | ||||
227 | NS_ASSERTION(mCurrentImages.IsEmpty() || | 12 | ||||
231 | if (aImages[0].mProducerID != mCurrentProducerID) { | 12 | ||||
232 | mFrameIDsNotYetComposited.Clear(); | 12 | ||||
233 | mCurrentProducerID = aImages[0].mProducerID; | 12 | ||||
234 | } else if (!aImages[0].mTimeStamp.IsNull()) { | 6 | ||||
260 | for (uint32_t i = 0; i < aImages.Length(); ++i) { | 12 | ||||
261 | NS_ASSERTION(aImages[i].mImage, "image can't be null"); | 12 | ||||
262 | NS_ASSERTION(!aImages[i].mTimeStamp.IsNull() || aImages.Length() == 1, | 12 | ||||
264 | if (i > 0) { | 12 | ||||
272 | OwningImage* img = newImages.AppendElement(); | 12 | ||||
273 | img->mImage = aImages[i].mImage; | 12 | ||||
274 | img->mTimeStamp = aImages[i].mTimeStamp; | 12 | ||||
275 | img->mFrameID = aImages[i].mFrameID; | 12 | ||||
276 | img->mProducerID = aImages[i].mProducerID; | 12 | ||||
277 | for (auto& oldImg : mCurrentImages) { | 12 | ||||
278 | if (oldImg.mFrameID == img->mFrameID && | 6 | ||||
286 | mCurrentImages.SwapElements(newImages); | 12 | ||||
287 | } | 12 | ||||
297 | ImageContainer::SetCurrentImages(const nsTArray |
6 | ||||
299 | MOZ_ASSERT(!aImages.IsEmpty()); | 6 | ||||
300 | ReentrantMonitorAutoEnter mon(mReentrantMonitor); | 6 | ||||
301 | if (mImageClient) { | 6 | ||||
306 | SetCurrentImageInternal(aImages); | 6 | ||||
307 | } | 6 | ||||
348 | ImageContainer::SetCurrentImagesInTransaction(const nsTArray |
12 | ||||
350 | NS_ASSERTION(NS_IsMainThread(), "Should be on main thread."); | 12 | ||||
351 | NS_ASSERTION(!mImageClient, "Should use async image transfer with ImageBridge."); | 12 | ||||
353 | SetCurrentImageInternal(aImages); | 12 | ||||
354 | } | 12 | ||||
356 | bool ImageContainer::IsAsync() const | 12 | ||||
358 | return mIsAsync; | 12 | ||||
378 | ImageContainer::GetCurrentImages(nsTArray |
12 | ||||
381 | ReentrantMonitorAutoEnter mon(mReentrantMonitor); | 12 | ||||
383 | *aImages = mCurrentImages; | 12 | ||||
384 | if (aGenerationCounter) { | 12 | ||||
385 | *aGenerationCounter = mGenerationCounter; | 12 | ||||
386 | } | 12 | ||||
387 | } | 12 | ||||
390 | ImageContainer::GetCurrentSize() | 12 | ||||
392 | ReentrantMonitorAutoEnter mon(mReentrantMonitor); | 12 | ||||
394 | if (mCurrentImages.IsEmpty()) { | 12 | ||||
398 | return mCurrentImages[0].mImage->GetSize(); | 12 | ||||
805 | SourceSurfaceImage::SourceSurfaceImage(gfx::SourceSurface* aSourceSurface) | 12 | ||||
807 | mSize(aSourceSurface->GetSize()), | 12 | ||||
809 | mTextureFlags(TextureFlags::DEFAULT) | 12 | ||||
810 | {} | 12 | ||||
815 | SourceSurfaceImage::GetTextureClient(KnowsCompositor* aForwarder) | 12 | ||||
817 | if (!aForwarder) { | 12 | ||||
821 | auto entry = mTextureClients.LookupForAdd(aForwarder->GetSerial()); | 12 | ||||
822 | if (entry) { | 12 | ||||
826 | RefPtr |
12 | ||||
827 | RefPtr |
12 | ||||
828 | MOZ_ASSERT(surface); | 12 | ||||
829 | if (surface) { | 12 | ||||
831 | textureClient = | 12 | ||||
836 | ALLOC_DEFAULT); | 12 | ||||
838 | if (textureClient) { | 12 | ||||
839 | textureClient->SyncWithObject(aForwarder->GetSyncObject()); | 12 | ||||
840 | entry.OrInsert([&textureClient](){ return textureClient; }); | 12 | ||||
841 | return textureClient; | 12 | ||||
846 | return nullptr; | 12 |
|
Times Different | |||||
95 | class nsAutoRefTraits |
12 | ||||
118 | void Release(RawRef aRawRef) | 12 | ||||
120 | MOZ_ASSERT(mOwningEventTarget); | 12 | ||||
121 | if (mOwningEventTarget->IsOnCurrentThread()) { | 12 | ||||
122 | aRawRef->Release(); | 12 | ||||
123 | return; | 12 | ||||
128 | void AddRef(RawRef aRawRef) | 12 | ||||
130 | MOZ_ASSERT(!mOwningEventTarget); | 12 | ||||
131 | mOwningEventTarget = mozilla::GetCurrentThreadSerialEventTarget(); | 12 | ||||
132 | aRawRef->AddRef(); | 12 | ||||
133 | } | 12 | ||||
200 | NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Image) | 12 | ||||
207 | virtual gfx::IntPoint GetOrigin() | 12 | ||||
209 | return gfx::IntPoint(0, 0); | 12 | ||||
211 | virtual gfx::IntRect GetPictureRect() | 12 | ||||
213 | return gfx::IntRect(GetOrigin().x, GetOrigin().y, GetSize().width, GetSize().height); | 12 | ||||
225 | virtual bool IsValid() { return true; } | 12 | ||||
249 | Image(void* aImplData, ImageFormat aFormat) : | 12 | ||||
251 | mSerial(++sSerialCounter), | 12 | ||||
252 | mFormat(aFormat) | 12 | ||||
253 | {} | 12 | ||||
256 | virtual ~Image() {} | 12 | ||||
278 | NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BufferRecycleBin) | 12 | ||||
293 | ~BufferRecycleBin() | 12 | ||||
294 | { | 12 | ||||
295 | } | 12 | ||||
326 | NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageFactory) | 12 | ||||
330 | ImageFactory() {} | 12 | ||||
331 | virtual ~ImageFactory() {} | 12 | ||||
382 | NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageContainer) | 12 | ||||
508 | struct OwningImage { | 12 | ||||
509 | OwningImage() : mFrameID(0), mProducerID(0), mComposited(false) {} | 12 | ||||
682 | class AutoLockImage | 12 | ||||
685 | explicit AutoLockImage(ImageContainer *aContainer) | 12 | ||||
686 | { | 12 | ||||
687 | aContainer->GetCurrentImages(&mImages); | 12 | ||||
688 | } | 12 | ||||
690 | bool HasImage() const { return !mImages.IsEmpty(); } | 12 | ||||
932 | class SourceSurfaceImage final : public Image { | 12 | ||||
934 | virtual already_AddRefed |
12 | ||||
936 | RefPtr |
12 | ||||
937 | return surface.forget(); | 12 | ||||
943 | virtual gfx::IntSize GetSize() override { return mSize; } | 12 |
|
Times Different | |||||
16 | ImageLayer::ImageLayer(LayerManager* aManager, void* aImplData) | 12 | ||||
18 | , mScaleMode(ScaleMode::SCALE_NONE) | 12 | ||||
19 | {} | 12 | ||||
21 | ImageLayer::~ImageLayer() | 12 | ||||
22 | {} | 12 | ||||
24 | void ImageLayer::SetContainer(ImageContainer* aContainer) | 12 | ||||
26 | mContainer = aContainer; | 12 | ||||
27 | } | 12 | ||||
29 | void ImageLayer::ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) | 12 | ||||
31 | gfx::Matrix4x4 local = GetLocalTransform(); | 12 | ||||
35 | if (mContainer) { | 12 | ||||
36 | sourceRect.SizeTo(SizeDouble(mContainer->GetCurrentSize())); | 12 | ||||
43 | SnapTransform(local, sourceRect, nullptr) * | 12 | ||||
44 | SnapTransformTranslation(aTransformToSurface, nullptr); | 12 | ||||
46 | if (mScaleMode != ScaleMode::SCALE_NONE && | 12 | ||||
57 | mEffectiveTransformForBuffer = mEffectiveTransform; | 12 | ||||
60 | ComputeEffectiveTransformForMaskLayers(aTransformToSurface); | 12 | ||||
61 | } | 12 |
|
Times Different | |||||
41 | void SetSamplingFilter(gfx::SamplingFilter aSamplingFilter) | 12 | ||||
43 | if (mSamplingFilter != aSamplingFilter) { | 12 | ||||
48 | } | 12 | ||||
54 | void SetScaleToSize(const gfx::IntSize &aSize, ScaleMode aMode) | 12 | ||||
56 | if (mScaleToSize != aSize || mScaleMode != aMode) { | 12 | ||||
61 | } | 12 | ||||
64 | ImageContainer* GetContainer() { return mContainer; } | 12 | ||||
66 | const gfx::IntSize& GetScaleToSize() { return mScaleToSize; } | 12 | ||||
69 | MOZ_LAYER_DECL_NAME("ImageLayer", TYPE_IMAGE) | 12 | ||||
73 | virtual const gfx::Matrix4x4& GetEffectiveTransformForBuffer() const override | 12 | ||||
75 | return mEffectiveTransformForBuffer; | 12 | ||||
78 | virtual ImageLayer* AsImageLayer() override { return this; } | 12 |
|
Times Different | |||||
593 | static ImageHost* GetImageHost(Layer* aLayer) | 12 | ||||
595 | HostLayer* compositor = aLayer->AsHostLayer(); | 12 | ||||
596 | if (compositor) { | 12 | ||||
597 | return static_cast |
12 | ||||
602 | struct ImageLayerProperties : public LayerPropertiesBase | 12 | ||||
604 | explicit ImageLayerProperties(ImageLayer* aImage, bool aIsMask) | 12 | ||||
608 | , mSamplingFilter(aImage->GetSamplingFilter()) | 12 | ||||
610 | , mScaleMode(aImage->GetScaleMode()) | 12 | ||||
613 | , mIsMask(aIsMask) | 12 | ||||
615 | if (mImageHost) { | 12 | ||||
616 | mLastProducerID = mImageHost->GetLastProducerID(); | 12 | ||||
617 | mLastFrameID = mImageHost->GetLastFrameID(); | 12 | ||||
619 | } | 12 | ||||
621 | nsIntRegion ComputeChangeInternal(const char* aPrefix, | 12 | ||||
624 | ImageLayer* imageLayer = static_cast |
12 | ||||
626 | if (!imageLayer->GetLocalVisibleRegion().ToUnknownRegion().IsEqual(mVisibleRegion)) { | 12 | ||||
632 | ImageContainer* container = imageLayer->GetContainer(); | 12 | ||||
633 | ImageHost* host = GetImageHost(imageLayer); | 12 | ||||
634 | if (mContainer != container || | 12 | ||||
635 | mSamplingFilter != imageLayer->GetSamplingFilter() || | 12 | ||||
636 | mScaleToSize != imageLayer->GetScaleToSize() || | 12 | ||||
637 | mScaleMode != imageLayer->GetScaleMode() || | 12 | ||||
638 | host != mImageHost || | 12 | ||||
639 | (host && host->GetProducerID() != mLastProducerID) || | 12 | ||||
640 | (host && host->GetFrameID() != mLastFrameID)) { | 12 | ||||
642 | if (mIsMask) { | 8 | ||||
657 | return NewTransformedBounds(); | 8 | ||||
660 | return IntRect(); | 12 | ||||
718 | return MakeUnique |
12 |
|
Times Different | |||||
161 | LayerManager::CreateImageContainer(ImageContainer::Mode flag) | 12 | ||||
163 | RefPtr |
12 | ||||
164 | return container.forget(); | 12 | ||||
501 | Layer::SnapTransform(const Matrix4x4& aTransform, | 12 | ||||
505 | if (aResidualTransform) { | 12 | ||||
509 | Matrix matrix2D; | 12 | ||||
510 | Matrix4x4 result; | 12 | ||||
511 | if (mManager->IsSnappingEffectiveTransforms() && | 12 | ||||
512 | aTransform.Is2D(&matrix2D) && | 12 | ||||
513 | gfxSize(1.0, 1.0) <= aSnapRect.Size() && | 12 | ||||
514 | matrix2D.PreservesAxisAlignedRectangles()) { | 12 | ||||
515 | auto transformedTopLeft = IntPoint::Round(matrix2D.TransformPoint(ToPoint(aSnapRect.TopLeft()))); | 12 | ||||
516 | auto transformedTopRight = IntPoint::Round(matrix2D.TransformPoint(ToPoint(aSnapRect.TopRight()))); | 12 | ||||
517 | auto transformedBottomRight = IntPoint::Round(matrix2D.TransformPoint(ToPoint(aSnapRect.BottomRight()))); | 12 | ||||
520 | transformedTopLeft, transformedTopRight, transformedBottomRight); | 12 | ||||
522 | result = Matrix4x4::From2D(snappedMatrix); | 12 | ||||
523 | if (aResidualTransform && !snappedMatrix.IsSingular()) { | 12 | ||||
534 | return result; | 12 |
|
Times Different | |||||
53 | result.x = 0; | 7 | ||||
54 | result.width = mBufferRotation.x; | 7 | ||||
392 | *aRotationPoint += aSize; | 4 | ||||
457 | } else if (neededRegion.GetBounds().Size() <= mBufferRect.Size()) { | 4 | ||||
460 | destBufferRect = IntRect(neededRegion.GetBounds().TopLeft(), mBufferRect.Size()); | 4 |
|
Times Different | |||||
354 | BasicCompositor::SupportsEffect(EffectTypes aEffect) | 12 | ||||
356 | return aEffect != EffectTypes::YCBCR && aEffect != EffectTypes::COMPONENT_ALPHA; | 12 |
|
Times Different | |||||
28 | explicit ClientImageLayer(ClientLayerManager* aLayerManager) | 12 | ||||
30 | , mImageClientTypeContainer(CompositableType::UNKNOWN) | 12 | ||||
32 | MOZ_COUNT_CTOR(ClientImageLayer); | 12 | ||||
33 | } | 12 | ||||
36 | virtual ~ClientImageLayer() | 12 | ||||
37 | { | 12 | ||||
38 | DestroyBackBuffer(); | 12 | ||||
39 | MOZ_COUNT_DTOR(ClientImageLayer); | 12 | ||||
40 | } | 12 | ||||
42 | virtual void SetContainer(ImageContainer* aContainer) override | 12 | ||||
44 | ImageLayer::SetContainer(aContainer); | 12 | ||||
45 | mImageClientTypeContainer = CompositableType::UNKNOWN; | 12 | ||||
46 | } | 12 | ||||
48 | virtual void SetVisibleRegion(const LayerIntRegion& aRegion) override | 12 | ||||
50 | NS_ASSERTION(ClientManager()->InConstruction(), | 12 | ||||
52 | ImageLayer::SetVisibleRegion(aRegion); | 12 | ||||
53 | } | 12 | ||||
77 | virtual void FillSpecificAttributes(SpecificLayerAttributes& aAttrs) override | 12 | ||||
79 | aAttrs = ImageLayerAttributes(mSamplingFilter, mScaleToSize, mScaleMode); | 12 | ||||
80 | } | 12 | ||||
82 | virtual Layer* AsLayer() override { return this; } | 12 | ||||
83 | virtual ShadowableLayer* AsShadowableLayer() override { return this; } | 12 | ||||
90 | void DestroyBackBuffer() | 12 | ||||
92 | if (mImageClient) { | 12 | ||||
93 | mImageClient->SetLayer(nullptr); | 12 | ||||
94 | mImageClient->OnDetach(); | 12 | ||||
95 | mImageClient = nullptr; | 12 | ||||
97 | } | 12 | ||||
110 | CompositableType GetImageClientType() | 12 | ||||
112 | if (mImageClientTypeContainer != CompositableType::UNKNOWN) { | 12 | ||||
116 | if (mContainer->IsAsync()) { | 12 | ||||
121 | AutoLockImage autoLock(mContainer); | 12 | ||||
124 | ? CompositableType::IMAGE : CompositableType::UNKNOWN; | 12 | ||||
125 | return mImageClientTypeContainer; | 12 | ||||
133 | ClientImageLayer::RenderLayer() | 12 | ||||
135 | RenderMaskLayers(this); | 12 | ||||
137 | if (!mContainer) { | 12 | ||||
141 | if (!mImageClient || | 12 | ||||
142 | !mImageClient->UpdateImage(mContainer, GetContentFlags())) { | 8 | ||||
143 | CompositableType type = GetImageClientType(); | 12 | ||||
144 | if (type == CompositableType::UNKNOWN) { | 12 | ||||
147 | TextureFlags flags = TextureFlags::DEFAULT; | 12 | ||||
148 | mImageClient = ImageClient::CreateImageClient(type, | 12 | ||||
149 | ClientManager()->AsShadowForwarder(), | 12 | ||||
150 | flags); | 12 | ||||
151 | if (!mImageClient) { | 12 | ||||
154 | mImageClient->SetLayer(this); | 12 | ||||
155 | if (HasShadow() && !mContainer->IsAsync()) { | 12 | ||||
156 | mImageClient->Connect(); | 12 | ||||
157 | ClientManager()->AsShadowForwarder()->Attach(mImageClient, this); | 12 | ||||
159 | if (!mImageClient->UpdateImage(mContainer, GetContentFlags())) { | 12 | ||||
163 | ClientManager()->Hold(this); | 12 | ||||
167 | ClientLayerManager::CreateImageLayer() | 12 | ||||
169 | NS_ASSERTION(InConstruction(), "Only allowed in construction phase"); | 12 | ||||
171 | new ClientImageLayer(this); | 12 | ||||
172 | CREATE_SHADOW(Image); | 12 | ||||
173 | return layer.forget(); | 12 |
|
Times Different | |||||
493 | ClientLayerManager::ScheduleComposite() | 2 | ||||
495 | mForwarder->Composite(); | 2 | ||||
496 | } | 2 |
|
Times Different | |||||
42 | ImageClient::CreateImageClient(CompositableType aCompositableHostType, | 12 | ||||
47 | switch (aCompositableHostType) { | 12 | ||||
49 | result = new ImageClientSingle(aForwarder, aFlags, CompositableType::IMAGE); | 12 | ||||
61 | NS_ASSERTION(result, "Failed to create ImageClient"); | 12 | ||||
63 | return result.forget(); | 12 | ||||
67 | ImageClient::RemoveTexture(TextureClient* aTexture) | 8 | ||||
69 | GetForwarder()->RemoveTextureFromCompositable(this, aTexture); | 8 | ||||
70 | } | 8 | ||||
72 | ImageClientSingle::ImageClientSingle(CompositableForwarder* aFwd, | 12 | ||||
75 | : ImageClient(aFwd, aFlags, aType) | 12 | ||||
77 | } | 12 | ||||
79 | TextureInfo ImageClientSingle::GetTextureInfo() const | 12 | ||||
81 | return TextureInfo(CompositableType::IMAGE); | 12 | ||||
173 | ImageClientSingle::UpdateImage(ImageContainer* aContainer, uint32_t aContentFlags) | 12 | ||||
175 | AutoTArray |
12 | ||||
177 | aContainer->GetCurrentImages(&images, &generationCounter); | 12 | ||||
179 | if (mLastUpdateGenerationCounter == generationCounter) { | 12 | ||||
182 | mLastUpdateGenerationCounter = generationCounter; | 12 | ||||
184 | for (int32_t i = images.Length() - 1; i >= 0; --i) { | 12 | ||||
185 | if (!images[i].mImage->IsValid()) { | 12 | ||||
190 | if (images.IsEmpty()) { | 12 | ||||
205 | AutoTArray |
12 | ||||
207 | for (auto& img : images) { | 12 | ||||
208 | Image* image = img.mImage; | 12 | ||||
210 | RefPtr |
12 | ||||
211 | const bool hasTextureClient = !!texture; | 12 | ||||
213 | for (int32_t i = mBuffers.Length() - 1; i >= 0; --i) { | 12 | ||||
214 | if (mBuffers[i].mImageSerial == image->GetSerial()) { | 8 | ||||
226 | if (!texture) { | 12 | ||||
233 | if (!texture) { | 12 | ||||
240 | if (!texture->GetAllocator()->IPCOpen()) { | 12 | ||||
243 | if (!AddTextureClient(texture)) { | 12 | ||||
247 | CompositableForwarder::TimedTextureClient* t = textures.AppendElement(); | 12 | ||||
248 | t->mTextureClient = texture; | 12 | ||||
249 | t->mTimeStamp = img.mTimeStamp; | 12 | ||||
250 | t->mPictureRect = image->GetPictureRect(); | 12 | ||||
251 | t->mFrameID = img.mFrameID; | 12 | ||||
252 | t->mProducerID = img.mProducerID; | 12 | ||||
254 | Buffer* newBuf = newBuffers.AppendElement(); | 12 | ||||
255 | newBuf->mImageSerial = image->GetSerial(); | 12 | ||||
256 | newBuf->mTextureClient = texture; | 12 | ||||
258 | texture->SyncWithObject(GetForwarder()->GetSyncObject()); | 12 | ||||
259 | } | 12 | ||||
261 | GetForwarder()->UseTextures(this, textures); | 12 | ||||
263 | for (auto& b : mBuffers) { | 12 | ||||
264 | RemoveTexture(b.mTextureClient); | 8 | ||||
266 | mBuffers.SwapElements(newBuffers); | 12 | ||||
268 | return true; | 12 | ||||
272 | ImageClientSingle::AddTextureClient(TextureClient* aTexture) | 12 | ||||
274 | MOZ_ASSERT((mTextureFlags & aTexture->GetFlags()) == mTextureFlags); | 12 | ||||
275 | return CompositableClient::AddTextureClient(aTexture); | 12 | ||||
279 | ImageClientSingle::OnDetach() | 12 | ||||
281 | mBuffers.Clear(); | 12 | ||||
282 | } | 12 | ||||
284 | ImageClient::ImageClient(CompositableForwarder* aFwd, TextureFlags aFlags, | 12 | ||||
289 | , mLastUpdateGenerationCounter(0) | 12 | ||||
290 | {} | 12 |
|
Times Different | |||||
49 | virtual ~ImageClient() {} | 12 | ||||
87 | class ImageClientSingle : public ImageClient | 12 | ||||
109 | struct Buffer { | 12 |
|
Times Different | |||||
599 | aDescriptor = null_t(); | 12 | ||||
600 | return false; | 12 | ||||
610 | TextureClient::UpdateFromSurface(gfx::SourceSurface* aSurface) | 12 | ||||
612 | MOZ_ASSERT(IsValid()); | 12 | ||||
613 | MOZ_ASSERT(mIsLocked); | 12 | ||||
614 | MOZ_ASSERT(aSurface); | 12 | ||||
617 | MOZ_ASSERT(!mBorrowedDrawTarget); | 12 | ||||
624 | if (mData->UpdateFromSurface(aSurface)) { | 12 | ||||
1132 | TextureClient::CreateFromSurface(KnowsCompositor* aAllocator, | 12 | ||||
1139 | if (!aAllocator || !aAllocator->GetTextureForwarder()->IPCOpen()) { | 12 | ||||
1143 | gfx::IntSize size = aSurface->GetSize(); | 12 | ||||
1145 | if (!gfx::Factory::AllowedSurfaceSize(size)) { | 12 | ||||
1149 | TextureData* data = nullptr; | 12 | ||||
1174 | TextureAllocationFlags allocFlags = TextureAllocationFlags(aAllocFlags | ALLOC_UPDATE_FROM_SURFACE); | 12 | ||||
1175 | RefPtr |
12 | ||||
1176 | aSelector, aTextureFlags, allocFlags); | 12 | ||||
1177 | if (!client) { | 12 | ||||
1181 | TextureClientAutoLock autoLock(client, OpenMode::OPEN_WRITE_ONLY); | 12 | ||||
1182 | if (!autoLock.Succeeded()) { | 12 | ||||
1186 | client->UpdateFromSurface(aSurface); | 12 | ||||
1187 | return client.forget(); | 12 |
|
Times Different | |||||
132 | if (gfxVars::UseWebRender()) { | 12 | ||||
135 | result = new ImageHost(aTextureInfo); | 12 | ||||
169 | CompositableHost::GetLayerManager() const | 12 | ||||
171 | if (!mLayer || !mLayer->Manager()) { | 12 | ||||
174 | return mLayer->Manager()->AsHostLayerManager(); | 12 |
|
Times Different | |||||
16 | ImageComposite::ImageComposite() | 12 | ||||
19 | , mBias(BIAS_NONE) | 12 | ||||
20 | {} | 12 | ||||
22 | ImageComposite::~ImageComposite() | 12 | ||||
24 | } | 12 | ||||
40 | ImageComposite::UpdateBias(const TimeStamp& aCompositionTime, | 12 | ||||
45 | if (aCompositedImageTime.IsNull()) { | 12 | ||||
81 | ImageComposite::ChooseImageIndex() const | 12 | ||||
83 | if (mImages.IsEmpty()) { | 12 | ||||
86 | TimeStamp now = GetCompositionTime(); | 12 | ||||
88 | if (now.IsNull()) { | 12 | ||||
101 | while (result + 1 < mImages.Length() && | 12 | ||||
102 | GetBiasedTime(mImages[result + 1].mTimeStamp, mBias) <= now) { | 12 | ||||
105 | return result; | 12 | ||||
108 | const ImageComposite::TimedImage* ImageComposite::ChooseImage() const | 12 | ||||
110 | int index = ChooseImageIndex(); | 12 | ||||
111 | return index >= 0 ? &mImages[index] : nullptr; | 12 | ||||
114 | ImageComposite::TimedImage* ImageComposite::ChooseImage() | 12 | ||||
116 | int index = ChooseImageIndex(); | 12 | ||||
117 | return index >= 0 ? &mImages[index] : nullptr; | 12 |
|
Times Different | |||||
27 | ImageHost::ImageHost(const TextureInfo& aTextureInfo) | 12 | ||||
30 | , mLocked(false) | 12 | ||||
31 | {} | 12 | ||||
33 | ImageHost::~ImageHost() | 12 | ||||
35 | } | 12 | ||||
38 | ImageHost::UseTextureHost(const nsTArray |
12 | ||||
40 | MOZ_ASSERT(!mLocked); | 12 | ||||
42 | CompositableHost::UseTextureHost(aTextures); | 12 | ||||
43 | MOZ_ASSERT(aTextures.Length() >= 1); | 12 | ||||
47 | for (uint32_t i = 0; i < aTextures.Length(); ++i) { | 12 | ||||
48 | const TimedTexture& t = aTextures[i]; | 12 | ||||
49 | MOZ_ASSERT(t.mTexture); | 12 | ||||
50 | if (i + 1 < aTextures.Length() && | 12 | ||||
51 | t.mProducerID == mLastProducerID && t.mFrameID < mLastFrameID) { | 12 | ||||
58 | TimedImage& img = *newImages.AppendElement(); | 12 | ||||
59 | img.mTextureHost = t.mTexture; | 12 | ||||
60 | img.mTimeStamp = t.mTimeStamp; | 12 | ||||
61 | img.mPictureRect = t.mPictureRect; | 12 | ||||
62 | img.mFrameID = t.mFrameID; | 12 | ||||
63 | img.mProducerID = t.mProducerID; | 12 | ||||
64 | img.mTextureHost->SetCropRect(img.mPictureRect); | 12 | ||||
65 | img.mTextureHost->Updated(); | 12 | ||||
68 | mImages.SwapElements(newImages); | 12 | ||||
69 | newImages.Clear(); | 12 | ||||
73 | if (mImages.Length() == 1) { | 12 | ||||
74 | SetCurrentTextureHost(mImages[0].mTextureHost); | 12 | ||||
77 | HostLayerManager* lm = GetLayerManager(); | 12 | ||||
83 | if (lm && mLastFrameID >= 0) { | 12 | ||||
84 | for (size_t i = 0; i < mImages.Length(); ++i) { | 6 | ||||
85 | bool frameComesAfter = mImages[i].mFrameID > mLastFrameID || | 6 | ||||
86 | mImages[i].mProducerID != mLastProducerID; | 6 | ||||
87 | if (frameComesAfter && !mImages[i].mTimeStamp.IsNull()) { | 6 | ||||
94 | } | 12 | ||||
97 | ImageHost::SetCurrentTextureHost(TextureHost* aTexture) | 12 | ||||
99 | if (aTexture == mCurrentTextureHost.get()) { | 12 | ||||
100 | return; | 12 | ||||
103 | bool swapTextureSources = !!mCurrentTextureHost && !!mCurrentTextureSource | 12 | ||||
104 | && mCurrentTextureHost->HasIntermediateBuffer(); | 12 | ||||
106 | if (swapTextureSources) { | 12 | ||||
123 | mExtraTextureSource = nullptr; | 12 | ||||
126 | mCurrentTextureHost = aTexture; | 12 | ||||
127 | mCurrentTextureHost->PrepareTextureSource(mCurrentTextureSource); | 12 | ||||
131 | ImageHost::CleanupResources() | 12 | ||||
133 | mExtraTextureSource = nullptr; | 12 | ||||
134 | mCurrentTextureSource = nullptr; | 12 | ||||
135 | mCurrentTextureHost = nullptr; | 12 | ||||
136 | } | 12 | ||||
139 | ImageHost::RemoveTextureHost(TextureHost* aTexture) | 8 | ||||
141 | MOZ_ASSERT(!mLocked); | 8 | ||||
143 | CompositableHost::RemoveTextureHost(aTexture); | 8 | ||||
145 | for (int32_t i = mImages.Length() - 1; i >= 0; --i) { | 8 | ||||
146 | if (mImages[i].mTextureHost == aTexture) { | 8 | ||||
151 | } | 8 | ||||
154 | ImageHost::GetCompositionTime() const | 12 | ||||
156 | TimeStamp time; | 12 | ||||
157 | if (HostLayerManager* lm = GetLayerManager()) { | 12 | ||||
158 | time = lm->GetCompositionTime(); | 12 | ||||
160 | return time; | 12 | ||||
176 | void ImageHost::Attach(Layer* aLayer, | 12 | ||||
180 | CompositableHost::Attach(aLayer, aProvider, aFlags); | 12 | ||||
181 | for (auto& img : mImages) { | 12 | ||||
185 | } | 12 | ||||
188 | ImageHost::Composite(Compositor* aCompositor, | 12 | ||||
199 | if (!PrepareToRender(aCompositor, &info)) { | 12 | ||||
203 | TimedImage* img = info.img; | 12 | ||||
206 | AutoLockCompositableHost autoLock(this); | 12 | ||||
207 | if (autoLock.Failed()) { | 12 | ||||
212 | if (!mCurrentTextureHost->BindTextureSource(mCurrentTextureSource)) { | 12 | ||||
216 | if (!mCurrentTextureSource) { | 12 | ||||
223 | !(mCurrentTextureHost->GetFlags() & TextureFlags::NON_PREMULTIPLIED); | 12 | ||||
226 | mCurrentTextureSource.get(), aSamplingFilter, isAlphaPremultiplied); | 12 | ||||
227 | if (!effect) { | 12 | ||||
231 | if (!aCompositor->SupportsEffect(effect->mType)) { | 12 | ||||
235 | DiagnosticFlags diagnosticFlags = DiagnosticFlags::IMAGE; | 12 | ||||
236 | if (effect->mType == EffectTypes::NV12) { | 12 | ||||
238 | } else if (effect->mType == EffectTypes::YCBCR) { | 12 | ||||
242 | aEffectChain.mPrimaryEffect = effect; | 12 | ||||
243 | gfx::Rect pictureRect(0, 0, img->mPictureRect.width, img->mPictureRect.height); | 12 | ||||
244 | BigImageIterator* it = mCurrentTextureSource->AsBigImageIterator(); | 12 | ||||
245 | if (it) { | 12 | ||||
286 | IntSize textureSize = mCurrentTextureSource->GetSize(); | 12 | ||||
287 | effect->mTextureCoords = Rect(Float(img->mPictureRect.x) / textureSize.width, | 12 | ||||
290 | Float(img->mPictureRect.height) / textureSize.height); | 12 | ||||
292 | if (img->mTextureHost->GetFlags() & TextureFlags::ORIGIN_BOTTOM_LEFT) { | 12 | ||||
298 | aOpacity, aTransform, aGeometry); | 12 | ||||
301 | aTransform, mFlashCounter); | 12 | ||||
302 | } | 12 | ||||
305 | FinishRendering(info); | 12 | ||||
309 | ImageHost::PrepareToRender(TextureSourceProvider* aProvider, RenderInfo* aOutInfo) | 12 | ||||
311 | HostLayerManager* lm = GetLayerManager(); | 12 | ||||
312 | if (!lm) { | 12 | ||||
316 | int imageIndex = ChooseImageIndex(); | 12 | ||||
317 | if (imageIndex < 0) { | 12 | ||||
321 | if (uint32_t(imageIndex) + 1 < mImages.Length()) { | 12 | ||||
325 | TimedImage* img = &mImages[imageIndex]; | 12 | ||||
326 | img->mTextureHost->SetTextureSourceProvider(aProvider); | 12 | ||||
327 | SetCurrentTextureHost(img->mTextureHost); | 12 | ||||
329 | aOutInfo->imageIndex = imageIndex; | 12 | ||||
330 | aOutInfo->img = img; | 12 | ||||
331 | aOutInfo->host = mCurrentTextureHost; | 12 | ||||
332 | return true; | 12 | ||||
346 | ImageHost::FinishRendering(const RenderInfo& aInfo) | 12 | ||||
348 | HostLayerManager* lm = GetLayerManager(); | 12 | ||||
349 | TimedImage* img = aInfo.img; | 12 | ||||
350 | int imageIndex = aInfo.imageIndex; | 12 | ||||
352 | if (mLastFrameID != img->mFrameID || mLastProducerID != img->mProducerID) { | 12 | ||||
353 | if (mAsyncRef) { | 12 | ||||
362 | mLastFrameID = img->mFrameID; | 12 | ||||
363 | mLastProducerID = img->mProducerID; | 12 | ||||
372 | lm->GetCompositionTime(), mImages[imageIndex].mTimeStamp, | 12 | ||||
373 | uint32_t(imageIndex + 1) < mImages.Length() ? | 12 | ||||
375 | mBias); | 12 | ||||
376 | } | 12 | ||||
379 | ImageHost::SetTextureSourceProvider(TextureSourceProvider* aProvider) | 12 | ||||
381 | if (mTextureSourceProvider != aProvider) { | 12 | ||||
382 | for (auto& img : mImages) { | 12 | ||||
386 | CompositableHost::SetTextureSourceProvider(aProvider); | 12 | ||||
387 | } | 12 | ||||
429 | ImageHost::Lock() | 12 | ||||
431 | MOZ_ASSERT(!mLocked); | 12 | ||||
432 | TimedImage* img = ChooseImage(); | 12 | ||||
433 | if (!img) { | 12 | ||||
437 | SetCurrentTextureHost(img->mTextureHost); | 12 | ||||
439 | if (!mCurrentTextureHost->Lock()) { | 12 | ||||
442 | mLocked = true; | 12 | ||||
443 | return true; | 12 | ||||
447 | ImageHost::Unlock() | 12 | ||||
449 | MOZ_ASSERT(mLocked); | 12 | ||||
451 | if (mCurrentTextureHost) { | 12 | ||||
452 | mCurrentTextureHost->Unlock(); | 12 | ||||
454 | mLocked = false; | 12 | ||||
455 | } | 12 | ||||
458 | ImageHost::GetImageSize() const | 12 | ||||
460 | const TimedImage* img = ChooseImage(); | 12 | ||||
461 | if (img) { | 12 | ||||
462 | return IntSize(img->mPictureRect.width, img->mPictureRect.height); | 12 |
|
Times Different | |||||
46 | virtual CompositableType GetType() override { return mTextureInfo.mCompositableType; } | 12 | ||||
93 | struct RenderInfo { | 12 | ||||
98 | RenderInfo() : imageIndex(-1), img(nullptr) | 12 |
|
Times Different | |||||
32 | ImageLayerComposite::ImageLayerComposite(LayerManagerComposite* aManager) | 12 | ||||
35 | , mImageHost(nullptr) | 12 | ||||
37 | MOZ_COUNT_CTOR(ImageLayerComposite); | 12 | ||||
38 | mImplData = static_cast |
12 | ||||
39 | } | 12 | ||||
41 | ImageLayerComposite::~ImageLayerComposite() | 12 | ||||
43 | MOZ_COUNT_DTOR(ImageLayerComposite); | 12 | ||||
44 | MOZ_ASSERT(mDestroyed); | 12 | ||||
46 | CleanupResources(); | 12 | ||||
47 | } | 12 | ||||
50 | ImageLayerComposite::SetCompositableHost(CompositableHost* aHost) | 12 | ||||
52 | switch (aHost->GetType()) { | 12 | ||||
54 | mImageHost = static_cast |
12 | ||||
55 | return true; | 12 | ||||
62 | ImageLayerComposite::Disconnect() | 12 | ||||
64 | Destroy(); | 12 | ||||
65 | } | 12 | ||||
68 | ImageLayerComposite::GetLayer() | 12 | ||||
70 | return this; | 12 | ||||
84 | ImageLayerComposite::RenderLayer(const IntRect& aClipRect, | 12 | ||||
87 | if (!mImageHost || !mImageHost->IsAttached()) { | 12 | ||||
88 | return; | 12 | ||||
92 | if (gfxEnv::DumpCompositorTextures()) { | 12 | ||||
100 | mCompositor->MakeCurrent(); | 12 | ||||
103 | [&](EffectChain& effectChain, const IntRect& clipRect) { | 12 | ||||
104 | mImageHost->SetTextureSourceProvider(mCompositor); | 12 | ||||
105 | mImageHost->Composite(mCompositor, this, effectChain, | 12 | ||||
107 | GetEffectiveTransformForBuffer(), | 12 | ||||
109 | clipRect); | 12 | ||||
110 | }); | 12 | ||||
111 | mImageHost->BumpFlashCounter(); | 12 | ||||
115 | ImageLayerComposite::ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) | 12 | ||||
117 | gfx::Matrix4x4 local = GetLocalTransform(); | 12 | ||||
121 | if (mImageHost && | 12 | ||||
122 | mImageHost->IsAttached()) { | 12 | ||||
123 | IntSize size = mImageHost->GetImageSize(); | 12 | ||||
124 | sourceRect.SizeTo(size.width, size.height); | 12 | ||||
131 | SnapTransform(local, sourceRect, nullptr) * | 12 | ||||
132 | SnapTransformTranslation(aTransformToSurface, nullptr); | 12 | ||||
134 | if (mScaleMode != ScaleMode::SCALE_NONE && | 12 | ||||
145 | mEffectiveTransformForBuffer = mEffectiveTransform; | 12 | ||||
148 | ComputeEffectiveTransformForMaskLayers(aTransformToSurface); | 12 | ||||
149 | } | 12 | ||||
152 | ImageLayerComposite::IsOpaque() | 12 | ||||
154 | if (!mImageHost || | 12 | ||||
155 | !mImageHost->IsAttached()) { | 12 | ||||
159 | if (mScaleMode == ScaleMode::STRETCH) { | 12 | ||||
183 | ImageLayerComposite::GetCompositableHost() | 12 | ||||
185 | if (mImageHost && mImageHost->IsAttached()) { | 12 | ||||
186 | return mImageHost.get(); | 12 | ||||
193 | ImageLayerComposite::CleanupResources() | 12 | ||||
195 | if (mImageHost) { | 12 | ||||
196 | mImageHost->CleanupResources(); | 12 | ||||
197 | mImageHost->Detach(this); | 12 | ||||
199 | mImageHost = nullptr; | 12 | ||||
200 | } | 12 | ||||
205 | return mSamplingFilter; | 12 |
|
Times Different | |||||
57 | virtual HostLayer* AsHostLayer() override { return this; } | 12 | ||||
59 | virtual const char* Name() const override { return "ImageLayerComposite"; } | 12 |
|
Times Different | |||||
1339 | LayerManagerComposite::CreateImageLayer() | 12 | ||||
1341 | if (mDestroyed) { | 12 | ||||
1345 | return RefPtr |
12 | ||||
1450 | LayerComposite::Destroy() | 12 | ||||
1452 | if (!mDestroyed) { | 12 | ||||
1453 | mDestroyed = true; | 12 | ||||
1454 | CleanupResources(); | 12 | ||||
1456 | } | 12 |
|
Times Different | |||||
874 | BufferTextureHost::GetFormat() const | 12 | ||||
881 | if (mFormat == gfx::SurfaceFormat::YUV && | 12 | ||||
882 | mProvider && | 12 | ||||
886 | return mFormat; | 12 | ||||
1250 | TextureHost::ReceivedDestroy(PTextureParent* aActor) | 6 | ||||
1252 | static_cast |
6 | ||||
1253 | } | 6 |
|
Times Different | |||||
144 | const OpRemoveTexture& op = aEdit.detail().get_OpRemoveTexture(); | 9 | ||||
146 | RefPtr |
9 | ||||
148 | MOZ_ASSERT(tex.get()); | 9 | ||||
149 | compositable->RemoveTextureHost(tex); | 9 | ||||
150 | break; | 9 | ||||
224 | CompositableParentManager::DestroyActor(const OpDestroy& aOp) | 7 | ||||
226 | switch (aOp.type()) { | 7 | ||||
228 | auto actor = aOp.get_PTextureParent(); | 7 | ||||
229 | TextureHost::ReceivedDestroy(actor); | 7 | ||||
230 | break; | 7 | ||||
240 | } | 7 |
|
Times Different | |||||
1274 | CompositorBridgeParent::ForceComposite(LayerTransactionParent* aLayerTree) | 2 | ||||
1276 | ScheduleComposition(); | 2 | ||||
1277 | } | 2 |
|
Times Different | |||||
125 | mLayerTransaction->DestroyActor(op); | 6 | ||||
211 | MOZ_LAYERS_LOG(("[ParentSide] CreateImageLayer")); | 12 | ||||
213 | RefPtr |
12 | ||||
214 | if (!BindLayer(layer, edit.get_OpCreateImageLayer())) { | 12 | ||||
218 | UpdateHitTestingTree(layer, "CreateImageLayer"); | 12 | ||||
219 | break; | 12 | ||||
666 | MOZ_LAYERS_LOG(("[ParentSide] image layer")); | 12 | ||||
668 | ImageLayer* imageLayer = layer->AsImageLayer(); | 12 | ||||
669 | if (!imageLayer) { | 12 | ||||
672 | const ImageLayerAttributes& attrs = specific.get_ImageLayerAttributes(); | 12 | ||||
673 | imageLayer->SetSamplingFilter(attrs.samplingFilter()); | 12 | ||||
674 | imageLayer->SetScaleToSize(attrs.scaleToSize(), attrs.scaleMode()); | 12 | ||||
675 | break; | 12 | ||||
899 | LayerTransactionParent::RecvForceComposite() | 2 | ||||
901 | mCompositorBridge->ForceComposite(this); | 2 | ||||
902 | return IPC_OK(); | 2 |
|
Times Different | |||||
291 | ShadowLayerForwarder::CreatedImageLayer(ShadowableLayer* aImage) | 12 | ||||
293 | CreatedLayer |
12 | ||||
294 | } | 12 | ||||
527 | aTxn->mDestroyedActors.AppendElement(op); | 6 | ||||
528 | return true; | 6 | ||||
544 | ShadowLayerForwarder::RemoveTextureFromCompositable(CompositableClient* aCompositable, | 8 | ||||
547 | MOZ_ASSERT(aCompositable); | 8 | ||||
548 | MOZ_ASSERT(aTexture); | 8 | ||||
549 | MOZ_ASSERT(aTexture->GetIPDLActor()); | 8 | ||||
550 | MOZ_RELEASE_ASSERT(aTexture->GetIPDLActor()->GetIPCChannel() == mShadowManager->GetIPCChannel()); | 8 | ||||
551 | if (!aCompositable->IsConnected() || !aTexture->GetIPDLActor()) { | 8 | ||||
553 | return; | 8 | ||||
559 | OpRemoveTexture(nullptr, aTexture->GetIPDLActor()))); | 8 | ||||
901 | void ShadowLayerForwarder::Composite() | 2 | ||||
903 | if (!IPCOpen()) { | 2 | ||||
904 | return; | 2 | ||||
906 | mShadowManager->SendForceComposite(); | 2 |
|
Times Different | |||||
25 | void operator()(Fn&& fn, Args&&... args) { | 7 | ||||
26 | auto state = fState.load(std::memory_order_acquire); | 7 | ||||
28 | if (state == Done) { | 7 | ||||
29 | return; | 7 | ||||
33 | if (state == NotStarted && fState.compare_exchange_strong(state, Claimed, | 7 | ||||
35 | std::memory_order_relaxed)) { | 7 | ||||
37 | fn(std::forward |
7 | ||||
38 | return fState.store(Done, std::memory_order_release); | 7 |
|
Times Different | |||||
168 | return const_cast |
7 |
|
Times Different | |||||
286 | *riteZ = *leftZ; | 11 | ||||
540 | return this->setEmpty(); | 6 | ||||
1064 | this->addRun(x + width, y, rightAlpha, 1); | 7 | ||||
1089 | return target->setEmpty(); | 9 | ||||
1252 | fBuilder->addRun(fLeft, y - 1, 0, fRight - fLeft); | 11 | ||||
1723 | return this->setEmpty(); | 9 | ||||
1804 | if (SkRegion::kIntersect_Op == op) { | 5 | ||||
1805 | return this->setEmpty(); | 5 |
|
Times Different | |||||
29 | void SkAlphaRuns::assertValid(int y, int maxStep) const { | 9 | ||||
42 | } | 9 |
|
Times Different | |||||
65 | if (startAlpha) { | 9 | ||||
66 | SkAlphaRuns::Break(runs, alpha, x, 1); | 9 | ||||
72 | unsigned tmp = alpha[x] + startAlpha; | 9 | ||||
73 | SkASSERT(tmp <= 256); | 9 | ||||
74 | alpha[x] = SkToU8(tmp - (tmp >> 8)); // was (tmp >> 7), but that seems wrong if we're trying to catch 256 | 9 | ||||
76 | runs += x + 1; | 9 | ||||
77 | alpha += x + 1; | 9 | ||||
78 | x = 0; | 9 | ||||
79 | SkDEBUGCODE(this->validate();) | 9 | ||||
99 | if (stopAlpha) { | 9 | ||||
100 | SkAlphaRuns::Break(runs, alpha, x, 1); | 9 | ||||
101 | alpha += x; | 9 | ||||
102 | alpha[0] = SkToU8(alpha[0] + stopAlpha); | 9 | ||||
103 | SkDEBUGCODE(this->validate();) | 9 | ||||
104 | lastAlpha = alpha; | 9 |
|
Times Different | |||||
447 | colors += n; | 2 | ||||
448 | ix = 0; | 2 | ||||
449 | } | 2 |
|
Times Different | |||||
196 | static inline U16CPU int_repeat(int x, int n) { | 7 | ||||
197 | return sk_int_mod(x, n); | 7 |
|
Times Different | |||||
815 | bool deviceIsOpaque = kRGB_565_SkColorType == device.colorType(); | 7 | ||||
816 | switch (SkInterpretXfermode(*paint, deviceIsOpaque)) { | 7 | ||||
897 | SkASSERT(!drawCoverage); // Handled above. | 7 | ||||
898 | if (shader) { | 7 | ||||
899 | blitter = alloc->make |
7 |
|
Times Different | |||||
229 | SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkPixmap& device, const SkPaint& paint, | 7 | ||||
231 | : INHERITED(device, paint, shaderContext) | 7 | ||||
233 | fXfermode = SkXfermode::Peek(paint.getBlendMode()); | 7 | ||||
234 | SkASSERT(!fXfermode || fShaderContext); | 7 | ||||
236 | int width = device.width(); | 7 | ||||
237 | fBuffer = (SkPMColor*)sk_malloc_throw(sizeof(SkPMColor) * (width + (SkAlign4(width) >> 2))); | 7 | ||||
238 | fAAExpand = (uint8_t*)(fBuffer + width); | 7 | ||||
239 | } | 7 | ||||
241 | SkA8_Shader_Blitter::~SkA8_Shader_Blitter() { | 7 | ||||
242 | sk_free(fBuffer); | 7 | ||||
243 | } | 7 | ||||
245 | void SkA8_Shader_Blitter::blitH(int x, int y, int width) { | 7 | ||||
246 | SkASSERT(x >= 0 && y >= 0 && | 7 | ||||
249 | uint8_t* device = fDevice.writable_addr8(x, y); | 7 | ||||
250 | SkShader::Context* shaderContext = fShaderContext; | 7 | ||||
252 | if ((shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) && !fXfermode) { | 7 | ||||
255 | SkPMColor* span = fBuffer; | 7 | ||||
257 | shaderContext->shadeSpan(x, y, span, width); | 7 | ||||
258 | if (fXfermode) { | 7 | ||||
261 | for (int i = width - 1; i >= 0; --i) { | 7 | ||||
262 | unsigned srcA = SkGetPackedA32(span[i]); | 7 | ||||
263 | unsigned scale = 256 - SkAlpha255To256(srcA); | 7 | ||||
265 | device[i] = SkToU8(srcA + SkAlphaMul(device[i], scale)); | 7 | ||||
269 | } | 7 |
|
Times Different | |||||
356 | if (fXfermode->asMode(&mode)) { | 7 | ||||
357 | if (SkXfermode::kSrc_Mode == mode) { | 7 | ||||
358 | fShadeDirectlyIntoDevice = true; | 7 | ||||
359 | fProc32Blend = blend_srcmode; | 7 |
|
Times Different | |||||
39 | SkASSERT(0 == intervals); | 2 | ||||
40 | SkASSERT(SkRegion::kRunTypeSentinel == runs[0]); | 2 | ||||
900 | oper.addSpan(top, gSentinel, gSentinel); | 2 | ||||
1337 | fRect.fTop = runs[0]; | 2 | ||||
1338 | runs += 3; | 2 | ||||
1368 | fIter.next(); | 8 | ||||
1389 | fIter.next(); | 8 |
|
Times Different | |||||
87 | static RunHead* Alloc(int count, int yspancount, int intervalCount) { | 7 | ||||
88 | if (yspancount <= 0 || intervalCount <= 1) { | 7 | ||||
92 | RunHead* head = Alloc(count); | 7 | ||||
93 | if (!head) { | 7 | ||||
96 | head->fYSpanCount = yspancount; | 7 | ||||
97 | head->fIntervalCount = intervalCount; | 7 | ||||
98 | return head; | 7 | ||||
116 | writable = Alloc(fRunCount, fYSpanCount, fIntervalCount); | 7 | ||||
117 | memcpy(writable->writable_runs(), this->readonly_runs(), | 7 | ||||
118 | fRunCount * sizeof(RunType)); | 7 | ||||
123 | if (sk_atomic_dec(&fRefCnt) == 1) { | 7 |
|
Times Different | |||||
584 | static inline SkFixed approximateIntersection(SkFixed l1, SkFixed r1, SkFixed l2, SkFixed r2) { | 9 | ||||
585 | if (l1 > r1) { SkTSwap(l1, r1); } | 9 | ||||
586 | if (l2 > r2) { SkTSwap(l2, r2); } | 9 | ||||
587 | return (SkTMax(l1, l2) + SkTMin(r1, r2)) >> 1; | 9 | ||||
823 | ll = lr = approximateIntersection(ul, ll, ur, lr); | 9 | ||||
1104 | f2a(SkFixedMul(partialTop, partialRite))); | 7 | ||||
1127 | f2a(SkFixedMul(partialBot, partialRite))); | 7 | ||||
1253 | *nextNextY = nextY + (SK_Fixed1 >> SkAnalyticEdge::kDefaultAccuracy); | 9 |
|
Times Different | |||||
107 | ~SuperBlitter() override { | 9 | ||||
108 | this->flush(); | 9 | ||||
109 | } | 9 | ||||
133 | int getRunsSz() const { return (fWidth + 1 + (fWidth + 2)/2) * sizeof(int16_t); } | 9 | ||||
138 | void advanceRuns() { | 9 | ||||
139 | const size_t kRunsSz = this->getRunsSz(); | 9 | ||||
140 | fCurrentRun = (fCurrentRun + 1) % fRunsToBuffer; | 9 | ||||
142 | reinterpret_cast |
9 | ||||
143 | fRuns.fAlpha = reinterpret_cast |
9 | ||||
144 | fRuns.reset(fWidth); | 9 | ||||
145 | } | 9 | ||||
150 | SuperBlitter::SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip, | 9 | ||||
152 | : BaseSuperBlitter(realBlitter, ir, clip, isInverse) | 9 | ||||
154 | fRunsToBuffer = realBlitter->requestRowsPreserved(); | 9 | ||||
155 | fRunsBuffer = realBlitter->allocBlitMemory(fRunsToBuffer * this->getRunsSz()); | 9 | ||||
156 | fCurrentRun = -1; | 9 | ||||
158 | this->advanceRuns(); | 9 | ||||
160 | fOffsetX = 0; | 9 | ||||
161 | } | 9 | ||||
163 | void SuperBlitter::flush() { | 9 | ||||
164 | if (fCurrIY >= fTop) { | 9 | ||||
166 | SkASSERT(fCurrentRun < fRunsToBuffer); | 9 | ||||
167 | if (!fRuns.empty()) { | 9 | ||||
169 | fRealBlitter->blitAntiH(fLeft, fCurrIY, fRuns.fAlpha, fRuns.fRuns); | 9 | ||||
170 | this->advanceRuns(); | 9 | ||||
171 | fOffsetX = 0; | 9 | ||||
174 | fCurrIY = fTop - 1; | 9 | ||||
175 | SkDEBUGCODE(fCurrX = -1;) | 9 | ||||
177 | } | 9 | ||||
199 | void SuperBlitter::blitH(int x, int y, int width) { | 9 | ||||
200 | SkASSERT(width > 0); | 9 | ||||
202 | int iy = y >> SHIFT; | 9 | ||||
203 | SkASSERT(iy >= fCurrIY); | 9 | ||||
205 | x -= fSuperLeft; | 9 | ||||
207 | if (x < 0) { | 9 | ||||
213 | SkASSERT(y != fCurrY || x >= fCurrX); | 9 | ||||
215 | SkASSERT(y >= fCurrY); | 9 | ||||
216 | if (fCurrY != y) { | 9 | ||||
217 | fOffsetX = 0; | 9 | ||||
218 | fCurrY = y; | 9 | ||||
221 | if (iy != fCurrIY) { // new scanline | 9 | ||||
222 | this->flush(); | 9 | ||||
223 | fCurrIY = iy; | 9 | ||||
226 | int start = x; | 9 | ||||
227 | int stop = x + width; | 9 | ||||
229 | SkASSERT(start >= 0 && stop > start); | 9 | ||||
231 | int fb = start & MASK; | 9 | ||||
232 | int fe = stop & MASK; | 9 | ||||
233 | int n = (stop >> SHIFT) - (start >> SHIFT) - 1; | 9 | ||||
235 | if (n < 0) { | 9 | ||||
240 | if (fb == 0) { | 9 | ||||
243 | fb = SCALE - fb; | 9 | ||||
249 | (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT), | 9 | ||||
250 | fOffsetX); | 9 | ||||
253 | fRuns.assertValid(y & MASK, (1 << (8 - SHIFT))); | 9 | ||||
254 | fCurrX = x + width; | 9 | ||||
256 | } | 9 | ||||
724 | SuperBlitter superBlit(blitter, ir, *clipRgn, isInverse); | 9 | ||||
726 | superClipRect == nullptr); | 9 | ||||
785 | SkRegion tmp; | 9 | ||||
786 | SkAAClipBlitter aaBlitter; | 9 | ||||
788 | tmp.setRect(clip.getBounds()); | 9 | ||||
789 | aaBlitter.init(blitter, &clip.aaRgn()); | 9 | ||||
790 | SkScan::AntiFillPath(path, tmp, &aaBlitter, true); | 9 |
|
Times Different | |||||
1115 | bool SkProcCoeffXfermode::asMode(Mode* mode) const { | 7 | ||||
1116 | if (mode) { | 7 | ||||
1117 | *mode = (Mode)fMode; | 7 | ||||
1119 | return true; | 7 | ||||
1326 | const int COUNT_BLENDMODES = (int)SkBlendMode::kLastMode + 1; | 7 | ||||
1329 | static SkOnce once[COUNT_BLENDMODES]; | 7 | ||||
1332 | once[(int)mode]([mode] { | 7 | ||||
1333 | ProcCoeff rec = gProcCoeffs[(int)mode]; | 7 | ||||
1334 | if (auto xfermode = SkOpts::create_xfermode(rec, mode)) { | 7 | ||||
1335 | cached[(int)mode] = xfermode; | 7 | ||||
1339 | }); | 7 | ||||
1340 | return sk_ref_sp(cached[(int)mode]); | 7 |
|
Times Different | |||||
11 | static bool just_solid_color(const SkPaint& p) { | 7 | ||||
12 | return SK_AlphaOPAQUE == p.getAlpha() && !p.getColorFilter() && !p.getShader(); | 7 | ||||
15 | SkXfermodeInterpretation SkInterpretXfermode(const SkPaint& paint, bool dstIsOpaque) { | 7 | ||||
16 | switch (paint.getBlendMode()) { | 7 | ||||
20 | if (just_solid_color(paint)) { | 7 | ||||
23 | return kNormal_SkXfermodeInterpretation; | 7 |
|
Times Different | |||||
169 | SkASSERT(!xfer->unique()); | 7 | ||||
170 | return xfer.get(); | 7 | ||||
286 | SkXfermode() {} | 7 |
|
Times Different | |||||
25 | SkProcCoeffXfermode(const ProcCoeff& rec, SkBlendMode mode) { | 7 | ||||
26 | fMode = mode; | 7 | ||||
27 | fProc = rec.fProc; | 7 | ||||
29 | fSrcCoeff = rec.fSC; | 7 | ||||
30 | fDstCoeff = rec.fDC; | 7 |
|
Times Different | |||||
684 | find_backward(const SkLinearGradient::LinearGradientContext::Rec rec[], float tiledX) { | 7 | ||||
685 | SkASSERT(tiledX >= 0 && tiledX <= 1); | 7 | ||||
687 | SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1); | 7 | ||||
688 | SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1); | 7 | ||||
689 | SkASSERT(rec[0].fPos <= rec[1].fPos); | 7 | ||||
690 | while (tiledX < rec->fPos || rec[1].fPosScale == 0) { | 7 | ||||
691 | rec -= 1; | 12 | ||||
692 | SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1); | 12 | ||||
693 | SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1); | 12 | ||||
694 | SkASSERT(rec[0].fPos <= rec[1].fPos); | 12 | ||||
696 | return rec; | 7 | ||||
770 | template |
7 | ||||
772 | Sk4f dc2 = dc + dc; | 7 | ||||
773 | Sk4f dc4 = dc2 + dc2; | 7 | ||||
774 | Sk4f cd0 = pre_bias |
7 | ||||
775 | Sk4f cd1 = pre_bias |
7 | ||||
776 | Sk4f cd2 = cd0 + dc2; | 7 | ||||
777 | Sk4f cd3 = cd1 + dc2; | 7 | ||||
778 | while (n >= 4) { | 7 | ||||
783 | *dstC++ = trunc_from_255 |
7 | ||||
784 | *dstC++ = trunc_from_255 |
7 | ||||
785 | *dstC++ = trunc_from_255 |
7 | ||||
786 | *dstC++ = trunc_from_255 |
7 | ||||
788 | cd0 = cd0 + dc4; | 7 | ||||
789 | cd1 = cd1 + dc4; | 7 | ||||
790 | cd2 = cd2 + dc4; | 7 | ||||
791 | cd3 = cd3 + dc4; | 7 | ||||
792 | n -= 4; | 7 | ||||
794 | if (n & 2) { | 7 | ||||
795 | *dstC++ = trunc_from_255 |
11 | ||||
796 | *dstC++ = trunc_from_255 |
11 | ||||
797 | cd0 = cd0 + dc2; | 11 | ||||
799 | if (n & 1) { | 7 | ||||
800 | *dstC++ = trunc_from_255 |
8 | ||||
802 | } | 7 | ||||
805 | void SkLinearGradient::LinearGradientContext::shade4_dx_clamp(SkPMColor dstC[], int count, | 7 | ||||
808 | Sk4f dither0(dither[0]); | 7 | ||||
809 | Sk4f dither1(dither[1]); | 7 | ||||
810 | const Rec* rec = fRecs.begin(); | 7 | ||||
813 | SkDEBUGCODE(SkPMColor* endDstC = dstC + count;) | 7 | ||||
832 | if (fx > 1) { | 7 | ||||
848 | SkASSERT(count >= 0); | 7 | ||||
854 | r = fRecs.begin() + fRecs.count() - 2; // start at the end | 7 | ||||
857 | while (count > 0) { | 7 | ||||
864 | if (fx <= 0) { | 7 | ||||
873 | r = find_backward(r, fx); | 7 | ||||
875 | SkASSERT(r >= fRecs.begin() && r < fRecs.begin() + fRecs.count() - 1); | 7 | ||||
877 | const float p0 = r[0].fPos; | 7 | ||||
878 | const Sk4f c0 = r[0].fColor; | 7 | ||||
879 | const float p1 = r[1].fPos; | 7 | ||||
880 | const Sk4f diffc = Sk4f(r[1].fColor) - c0; | 7 | ||||
881 | const float scale = r[1].fPosScale; | 7 | ||||
882 | const float t = (fx - p0) * scale; | 7 | ||||
883 | const Sk4f c = c0 + Sk4f(t) * diffc; | 7 | ||||
884 | const Sk4f dc = diffc * dx4 * Sk4f(scale); | 7 | ||||
890 | n = SkTMin((int)((p0 - fx) * invDx) + 1, count); | 7 | ||||
893 | fx += n * dx; | 7 | ||||
899 | fx = SkTMin(fx, p0); | 7 | ||||
902 | ramp |
7 | ||||
903 | dstC += n; | 7 | ||||
904 | SkASSERT(dstC <= endDstC); | 7 | ||||
906 | if (n & 1) { | 7 | ||||
910 | count -= n; | 7 | ||||
911 | SkASSERT(count >= 0); | 7 | ||||
953 | SkASSERT(0.f != dx); | 7 | ||||
954 | const float invDx = 1 / dx; | 7 | ||||
955 | if (dx > 0) { | 7 | ||||
962 | if (fApplyAlphaAfterInterp) { | 7 | ||||
963 | this->shade4_dx_clamp |
7 |
|
Times Different | |||||
221 | : INHERITED(rec, mode) {} | 7 | ||||
318 | static SkXfermode* create_xfermode(const ProcCoeff& rec, SkBlendMode mode) { | 7 | ||||
319 | switch (mode) { | 7 | ||||
323 | CASE(Src); | 7 |
|
Times Different | |||||
161 | AnimationState::InitAnimationFrameTimeIfNecessary() | 6 | ||||
163 | if (mCurrentAnimationFrameTime.IsNull()) { | 6 | ||||
166 | } | 6 | ||||
169 | AnimationState::SetAnimationFrameTime(const TimeStamp& aTime) | 6 | ||||
171 | mCurrentAnimationFrameTime = aTime; | 6 | ||||
172 | } | 6 | ||||
175 | AnimationState::GetCurrentAnimationFrameIndex() const | 6 | ||||
177 | return mCurrentAnimationFrameIndex; | 6 | ||||
181 | AnimationState::LoopLength() const | 8 | ||||
184 | if (!mLoopLength) { | 8 | ||||
188 | MOZ_ASSERT(mHasBeenDecoded, "We know the loop length but decoding isn't done?"); | 8 | ||||
191 | if (mAnimationMode != imgIContainer::kNormalAnimMode) { | 8 | ||||
195 | return *mLoopLength; | 8 | ||||
204 | FrameAnimator::GetCurrentImgFrameEndTime(AnimationState& aState, | 6 | ||||
207 | TimeStamp currentFrameTime = aState.mCurrentAnimationFrameTime; | 6 | ||||
209 | GetTimeoutForFrame(aState, aFrames, aState.mCurrentAnimationFrameIndex); | 6 | ||||
211 | if (timeout.isNothing()) { | 6 | ||||
216 | if (*timeout == FrameTimeout::Forever()) { | 6 | ||||
228 | TimeDuration::FromMilliseconds(double(timeout->AsMilliseconds())); | 6 | ||||
229 | TimeStamp currentFrameEndTime = currentFrameTime + durationOfTimeout; | 6 | ||||
235 | FrameAnimator::AdvanceFrame(AnimationState& aState, | 8 | ||||
239 | NS_ASSERTION(aTime <= TimeStamp::Now(), | 8 | ||||
241 | AUTO_PROFILER_LABEL("FrameAnimator::AdvanceFrame", GRAPHICS); | 8 | ||||
243 | RefreshResult ret; | 8 | ||||
246 | uint32_t currentFrameIndex = aState.mCurrentAnimationFrameIndex; | 8 | ||||
247 | uint32_t nextFrameIndex = currentFrameIndex + 1; | 8 | ||||
251 | if (aState.FrameCount() == Some(nextFrameIndex)) { | 8 | ||||
276 | if (nextFrameIndex >= aState.KnownFrameCount()) { | 8 | ||||
296 | MOZ_ASSERT(nextFrameIndex < aState.KnownFrameCount()); | 8 | ||||
297 | RawAccessFrameRef nextFrame = GetRawFrame(aFrames, nextFrameIndex); | 8 | ||||
303 | if (!nextFrame || !nextFrame->IsFinished()) { | 8 | ||||
309 | Maybe |
8 | ||||
312 | MOZ_ASSERT(nextFrameTimeout.isSome()); | 8 | ||||
313 | if (*nextFrameTimeout == FrameTimeout::Forever()) { | 8 | ||||
317 | if (nextFrameIndex == 0) { | 8 | ||||
320 | MOZ_ASSERT(nextFrameIndex == currentFrameIndex + 1); | 8 | ||||
323 | if (!DoBlend(aFrames, &ret.mDirtyRect, currentFrameIndex, nextFrameIndex)) { | 8 | ||||
335 | nextFrame->SetCompositingFailed(false); | 8 | ||||
338 | Maybe |
8 | ||||
339 | MOZ_ASSERT(currentFrameEndTime.isSome()); | 8 | ||||
340 | aState.mCurrentAnimationFrameTime = *currentFrameEndTime; | 8 | ||||
348 | FrameTimeout loopTime = aState.LoopLength(); | 8 | ||||
349 | if (loopTime != FrameTimeout::Forever() && | 8 | ||||
350 | (aState.LoopCount() < 0 || aState.mLoopRemainingCount >= 0)) { | 8 | ||||
351 | TimeDuration delay = aTime - aState.mCurrentAnimationFrameTime; | 8 | ||||
352 | if (delay.ToMilliseconds() > loopTime.AsMilliseconds()) { | 8 | ||||
375 | aState.mCurrentAnimationFrameIndex = nextFrameIndex; | 8 | ||||
378 | ret.mFrameAdvanced = true; | 8 | ||||
380 | return ret; | 8 | ||||
384 | FrameAnimator::RequestRefresh(AnimationState& aState, | 6 | ||||
389 | RefreshResult ret; | 6 | ||||
391 | if (aState.IsDiscarded()) { | 6 | ||||
403 | PlaybackType::eAnimated)); | 6 | ||||
405 | ret.mDirtyRect = aState.UpdateStateInternal(result, aAnimationFinished, mSize); | 6 | ||||
406 | if (aState.IsDiscarded() || !result) { | 6 | ||||
416 | GetCurrentImgFrameEndTime(aState, result.Surface()); | 6 | ||||
417 | if (currentFrameEndTime.isNothing()) { | 6 | ||||
426 | while (*currentFrameEndTime <= aTime) { | 6 | ||||
427 | TimeStamp oldFrameEndTime = *currentFrameEndTime; | 8 | ||||
429 | RefreshResult frameRes = AdvanceFrame(aState, result.Surface(), aTime); | 8 | ||||
432 | ret.Accumulate(frameRes); | 8 | ||||
434 | currentFrameEndTime = GetCurrentImgFrameEndTime(aState, result.Surface()); | 8 | ||||
436 | MOZ_ASSERT(currentFrameEndTime.isSome()); | 8 | ||||
441 | if (!frameRes.mFrameAdvanced && (*currentFrameEndTime == oldFrameEndTime)) { | 8 | ||||
447 | if (*currentFrameEndTime > aTime) { | 6 | ||||
448 | aState.mCompositedFrameInvalid = false; | 6 | ||||
449 | ret.mDirtyRect = IntRect(IntPoint(0,0), mSize); | 6 | ||||
452 | MOZ_ASSERT(!aState.mIsCurrentlyDecoded || !aState.mCompositedFrameInvalid); | 6 | ||||
478 | (uint32_t(mLastCompositedFrameIndex) == aState.mCurrentAnimationFrameIndex)) { | 8 | ||||
480 | MatchType::EXACT); | 8 | ||||
491 | if (NS_FAILED(result.Surface().Seek(aState.mCurrentAnimationFrameIndex))) { | 6 | ||||
498 | MOZ_ASSERT(!result.Surface()->GetIsPaletted(), | 6 | ||||
501 | return result; | 6 | ||||
505 | FrameAnimator::GetTimeoutForFrame(AnimationState& aState, | 6 | ||||
509 | RawAccessFrameRef frame = GetRawFrame(aFrames, aFrameNum); | 6 | ||||
510 | if (frame) { | 6 | ||||
511 | AnimationData data = frame->GetAnimationData(); | 6 | ||||
512 | return Some(data.mTimeout); | 6 | ||||
516 | return Nothing(); | 6 | ||||
565 | FrameAnimator::GetRawFrame(DrawableSurface& aFrames, uint32_t aFrameNum) const | 6 | ||||
570 | if (NS_FAILED(aFrames.Seek(aFrameNum))) { | 6 | ||||
574 | return aFrames->RawAccessRef(); | 6 | ||||
581 | FrameAnimator::DoBlend(DrawableSurface& aFrames, | 8 | ||||
586 | RawAccessFrameRef prevFrame = GetRawFrame(aFrames, aPrevFrameIndex); | 8 | ||||
587 | RawAccessFrameRef nextFrame = GetRawFrame(aFrames, aNextFrameIndex); | 8 | ||||
589 | MOZ_ASSERT(prevFrame && nextFrame, "Should have frames here"); | 8 | ||||
591 | AnimationData prevFrameData = prevFrame->GetAnimationData(); | 8 | ||||
592 | if (prevFrameData.mDisposalMethod == DisposalMethod::RESTORE_PREVIOUS && | 8 | ||||
598 | ? prevFrameData.mRect.Intersect(*prevFrameData.mBlendRect) | 8 | ||||
599 | : prevFrameData.mRect; | 8 | ||||
601 | bool isFullPrevFrame = prevRect.x == 0 && prevRect.y == 0 && | 8 | ||||
602 | prevRect.width == mSize.width && | 8 | ||||
603 | prevRect.height == mSize.height; | 8 | ||||
607 | if (isFullPrevFrame && | 8 | ||||
608 | (prevFrameData.mDisposalMethod == DisposalMethod::CLEAR)) { | 8 | ||||
612 | AnimationData nextFrameData = nextFrame->GetAnimationData(); | 8 | ||||
615 | ? nextFrameData.mRect.Intersect(*nextFrameData.mBlendRect) | 8 | ||||
616 | : nextFrameData.mRect; | 8 | ||||
618 | bool isFullNextFrame = nextRect.x == 0 && nextRect.y == 0 && | 8 | ||||
619 | nextRect.width == mSize.width && | 8 | ||||
620 | nextRect.height == mSize.height; | 8 | ||||
622 | if (!nextFrame->GetIsPaletted()) { | 8 | ||||
625 | if (prevFrameData.mDisposalMethod == DisposalMethod::CLEAR_ALL) { | 8 | ||||
632 | if (isFullNextFrame && | 8 | ||||
633 | (nextFrameData.mDisposalMethod != DisposalMethod::RESTORE_PREVIOUS) && | 8 | ||||
634 | !nextFrameData.mHasAlpha) { | 8 | ||||
641 | switch (prevFrameData.mDisposalMethod) { | 8 | ||||
646 | *aDirtyRect = nextRect; | 8 | ||||
647 | break; | 8 | ||||
676 | if (mLastCompositedFrameIndex == int32_t(aNextFrameIndex)) { | 8 | ||||
680 | bool needToBlankComposite = false; | 8 | ||||
683 | if (!mCompositingFrame) { | 8 | ||||
684 | RefPtr |
8 | ||||
686 | SurfaceFormat::B8G8R8A8); | 8 | ||||
687 | if (NS_FAILED(rv)) { | 8 | ||||
691 | mCompositingFrame = newFrame->RawAccessRef(); | 8 | ||||
692 | needToBlankComposite = true; | 8 | ||||
693 | } else if (int32_t(aNextFrameIndex) != mLastCompositedFrameIndex+1) { | 8 | ||||
700 | AnimationData compositingFrameData = mCompositingFrame->GetAnimationData(); | 8 | ||||
708 | bool doDisposal = true; | 8 | ||||
709 | if (!nextFrameData.mHasAlpha && | 8 | ||||
728 | if (doDisposal) { | 8 | ||||
730 | switch (prevFrameData.mDisposalMethod) { | 8 | ||||
784 | if (mLastCompositedFrameIndex != int32_t(aNextFrameIndex - 1)) { | 8 | ||||
785 | if (isFullPrevFrame && !prevFrame->GetIsPaletted()) { | 8 | ||||
790 | compositingFrameData.mRect); | 8 | ||||
819 | if ((nextFrameData.mDisposalMethod == DisposalMethod::RESTORE_PREVIOUS) && | 8 | ||||
854 | nextFrameData.mBlendRect); | 8 | ||||
857 | mCompositingFrame->Finish(); | 8 | ||||
859 | mLastCompositedFrameIndex = int32_t(aNextFrameIndex); | 8 | ||||
861 | return true; | 8 | ||||
902 | FrameAnimator::CopyFrameImage(const uint8_t* aDataSrc, | 8 | ||||
907 | uint32_t dataLengthSrc = aRectSrc.width * aRectSrc.height * 4; | 8 | ||||
908 | uint32_t dataLengthDest = aRectDest.width * aRectDest.height * 4; | 8 | ||||
910 | if (!aDataDest || !aDataSrc || dataLengthSrc != dataLengthDest) { | 8 | ||||
914 | memcpy(aDataDest, aDataSrc, dataLengthDest); | 8 | ||||
916 | return true; | 8 | ||||
920 | FrameAnimator::DrawFrameTo(const uint8_t* aSrcData, const IntRect& aSrcRect, | 8 | ||||
925 | NS_ENSURE_ARG_POINTER(aSrcData); | 8 | ||||
926 | NS_ENSURE_ARG_POINTER(aDstPixels); | 8 | ||||
929 | if (aSrcRect.x < 0 || aSrcRect.y < 0) { | 8 | ||||
934 | if ((aSrcRect.x > aDstRect.width) || (aSrcRect.y > aDstRect.height)) { | 8 | ||||
938 | if (aSrcPaletteLength) { | 8 | ||||
988 | aSrcRect.width * 4); | 8 | ||||
989 | if (!src) { | 8 | ||||
997 | aDstRect.width * 4); | 8 | ||||
998 | if (!dst) { | 8 | ||||
1017 | : PIXMAN_OP_OVER; | 8 | ||||
1019 | if (aBlendMethod == BlendMethod::OVER || !aBlendRect || | 8 | ||||
1020 | (aBlendMethod == BlendMethod::SOURCE && aSrcRect.IsEqualEdges(*aBlendRect))) { | 8 | ||||
1030 | aSrcRect.width, aSrcRect.height); | 8 | ||||
1051 | pixman_image_unref(src); | 8 | ||||
1052 | pixman_image_unref(dst); | 8 |
|
Times Different | |||||
243 | RefreshResult() | 6 | ||||
245 | , mAnimationFinished(false) | 6 | ||||
246 | { } | 6 | ||||
249 | void Accumulate(const RefreshResult& aOther) | 8 | ||||
251 | mFrameAdvanced = mFrameAdvanced || aOther.mFrameAdvanced; | 8 | ||||
252 | mAnimationFinished = mAnimationFinished || aOther.mAnimationFinished; | 8 | ||||
253 | mDirtyRect = mDirtyRect.Union(aOther.mDirtyRect); | 8 | ||||
254 | } | 8 |
|
Times Different | |||||
89 | uint32_t AsMilliseconds() const | 6 | ||||
91 | if (*this == Forever()) { | 6 | ||||
96 | return uint32_t(mTimeout); | 6 |
|
Times Different | |||||
119 | ImageResource::HadRecentRefresh(const TimeStamp& aTime) | 6 | ||||
125 | TimeDuration::FromMilliseconds(nsRefreshDriver::DefaultInterval() / 2.0); | 6 | ||||
127 | if (!mLastRefreshTime.IsNull() && | 6 | ||||
128 | aTime - mLastRefreshTime < recentThreshold) { | 6 | ||||
134 | mLastRefreshTime = aTime; | 6 | ||||
135 | return false; | 6 | ||||
142 | nsresult rv = StartAnimation(); | 6 | ||||
143 | mAnimating = NS_SUCCEEDED(rv); | 6 |
|
Times Different | |||||
108 | status |= imgIRequest::STATUS_IS_ANIMATED; | 3 |
|
Times Different | |||||
161 | RasterImage::RequestRefresh(const TimeStamp& aTime) | 6 | ||||
163 | if (HadRecentRefresh(aTime)) { | 6 | ||||
167 | EvaluateAnimation(); | 6 | ||||
169 | if (!mAnimating) { | 6 | ||||
173 | RefreshResult res; | 6 | ||||
174 | if (mAnimationState) { | 6 | ||||
175 | MOZ_ASSERT(mFrameAnimator); | 6 | ||||
176 | res = mFrameAnimator->RequestRefresh(*mAnimationState, aTime, mAnimationFinished); | 6 | ||||
179 | if (res.mFrameAdvanced) { | 6 | ||||
184 | mFramesNotified++; | 8 | ||||
187 | NotifyProgress(NoProgress, res.mDirtyRect); | 8 | ||||
190 | if (res.mAnimationFinished) { | 6 | ||||
497 | *aAnimated = true; | 3 | ||||
498 | return NS_OK; | 3 | ||||
529 | MOZ_ASSERT(mAnimationState, "Animated images should have an AnimationState"); | 3 | ||||
530 | return mAnimationState->FirstFrameTimeout().AsEncodedValueDeprecated(); | 3 | ||||
592 | RasterImage::GetCurrentImage(ImageContainer* aContainer, uint32_t aFlags) | 12 | ||||
594 | MOZ_ASSERT(NS_IsMainThread()); | 12 | ||||
595 | MOZ_ASSERT(aContainer); | 12 | ||||
599 | Tie(drawResult, surface) = | 12 | ||||
600 | GetFrameInternal(mSize, FRAME_CURRENT, aFlags | FLAG_ASYNC_NOTIFY); | 12 | ||||
601 | if (!surface) { | 12 | ||||
607 | RefPtr |
12 | ||||
608 | return MakePair(drawResult, Move(image)); | 12 | ||||
612 | RasterImage::IsImageContainerAvailable(LayerManager* aManager, uint32_t aFlags) | 5 | ||||
614 | int32_t maxTextureSize = aManager->GetMaxTextureSize(); | 5 | ||||
615 | if (!mHasSize || | 5 | ||||
616 | mSize.width > maxTextureSize || | 6 | ||||
617 | mSize.height > maxTextureSize) { | 6 | ||||
621 | return true; | 6 | ||||
625 | RasterImage::GetImageContainer(LayerManager* aManager, uint32_t aFlags) | 12 | ||||
627 | MOZ_ASSERT(NS_IsMainThread()); | 12 | ||||
628 | MOZ_ASSERT(aManager); | 12 | ||||
629 | MOZ_ASSERT((aFlags & ~(FLAG_SYNC_DECODE | | 12 | ||||
635 | int32_t maxTextureSize = aManager->GetMaxTextureSize(); | 12 | ||||
636 | if (!mHasSize || | 12 | ||||
637 | mSize.width > maxTextureSize || | 12 | ||||
638 | mSize.height > maxTextureSize) { | 12 | ||||
642 | if (mAnimationConsumers == 0) { | 12 | ||||
646 | RefPtr |
12 | ||||
649 | (aFlags & (FLAG_SYNC_DECODE | FLAG_SYNC_DECODE_IF_FAST)) && | 12 | ||||
650 | mLastImageContainerDrawResult != DrawResult::SUCCESS && | 12 | ||||
651 | mLastImageContainerDrawResult != DrawResult::BAD_IMAGE; | 12 | ||||
653 | if (container && !mustRedecode) { | 12 | ||||
658 | container = LayerManager::CreateImageContainer(); | 12 | ||||
661 | RefPtr |
12 | ||||
662 | Tie(drawResult, image) = GetCurrentImage(container, aFlags); | 12 | ||||
663 | if (!image) { | 12 | ||||
670 | AutoTArray |
12 | ||||
673 | mImageProducerID)); | 12 | ||||
674 | container->SetCurrentImagesInTransaction(imageList); | 12 | ||||
676 | mLastImageContainerDrawResult = drawResult; | 12 | ||||
677 | mImageContainer = container; | 12 | ||||
679 | return container.forget(); | 12 | ||||
693 | RefPtr |
6 | ||||
694 | Tie(drawResult, image) = GetCurrentImage(container, FLAG_NONE); | 6 | ||||
695 | if (!image) { | 6 | ||||
699 | mLastImageContainerDrawResult = drawResult; | 6 | ||||
700 | AutoTArray |
6 | ||||
703 | mImageProducerID)); | 6 | ||||
704 | container->SetCurrentImages(imageList); | 6 | ||||
821 | RasterImage::StartAnimation() | 6 | ||||
823 | if (mError) { | 6 | ||||
827 | MOZ_ASSERT(ShouldAnimate(), "Should not animate!"); | 6 | ||||
831 | mPendingAnimation = !mAnimationState || mAnimationState->KnownFrameCount() < 1; | 6 | ||||
832 | if (mPendingAnimation) { | 6 | ||||
837 | if (mAnimationState->GetCurrentAnimationFrameIndex() == 0 && | 6 | ||||
838 | mAnimationState->FirstFrameTimeout() == FrameTimeout::Forever()) { | 6 | ||||
845 | mAnimationState->InitAnimationFrameTimeIfNecessary(); | 6 | ||||
847 | return NS_OK; | 6 | ||||
902 | RasterImage::SetAnimationStartTime(const TimeStamp& aTime) | 6 | ||||
904 | if (mError || mAnimationMode == kDontAnimMode || mAnimating || !mAnimationState) { | 6 | ||||
905 | return; | 6 | ||||
908 | mAnimationState->SetAnimationFrameTime(aTime); | 6 | ||||
1637 | RasterImage::ShouldAnimate() | 6 | ||||
1639 | return ImageResource::ShouldAnimate() && | 6 | ||||
1640 | mAnimationState && | 6 | ||||
1641 | mAnimationState->KnownFrameCount() >= 1 && | 6 | ||||
1642 | !mAnimationFinished; | 6 |
|
Times Different | |||||
541 | return; | 8 |
|
Times Different | |||||
694 | imgFrame::GetIsPaletted() const | 6 | ||||
917 | imgFrame::SetCompositingFailed(bool val) | 8 | ||||
919 | MOZ_ASSERT(NS_IsMainThread()); | 8 | ||||
920 | mCompositingFailed = val; | 8 | ||||
921 | } | 8 |
|
Times Different | |||||
117 | nsresult InitForAnimator(const nsIntSize& aSize, | 9 | ||||
121 | aFormat, 0, false, true); | 9 |
|
Times Different | |||||
306 | LOG_SCOPE(gImgLog, "imgRequestProxy::Cancel"); | 6 | ||||
308 | mCanceled = true; | 6 | ||||
310 | nsCOMPtr |
6 | ||||
311 | return NS_DispatchToCurrentThread(ev); | 6 | ||||
315 | imgRequestProxy::DoCancel(nsresult status) | 6 | ||||
317 | if (GetOwner()) { | 6 | ||||
318 | GetOwner()->RemoveProxy(this, status); | 6 | ||||
321 | NullOutListener(); | 6 | ||||
322 | } | 6 |
|
Times Different | |||||
601 | if (delayed_run_time > other.delayed_run_time) | 7 |
|
Times Different | |||||
426 | const size_t prev_size = input_overflow_fds_.size(); | 1 | ||||
427 | input_overflow_fds_.resize(prev_size + num_wire_fds); | 1 | ||||
428 | memcpy(&input_overflow_fds_[prev_size], wire_fds, | 1 | ||||
429 | num_wire_fds * sizeof(int)); | 1 | ||||
430 | fds = &input_overflow_fds_[0]; | 1 | ||||
431 | num_fds = input_overflow_fds_.size(); | 1 | ||||
680 | switch (errno) { | 2 |
|
Times Different | |||||
650 | PrintErrorMessage(Side side, const char* channelName, const char* msg) | 10 | ||||
654 | : ((side == ParentSide) ? "Parent" : "Unknown"); | 10 | ||||
655 | printf_stderr("\n###!!! [%s][%s] Error: %s\n\n", from, channelName, msg); | 10 | ||||
656 | } | 10 | ||||
742 | task->Clear(); | 10 | ||||
1188 | MOZ_RELEASE_ASSERT(mPending.getLast()->Msg().compress_type() == | 2 | ||||
1190 | mPending.getLast()->Msg() = Move(aMsg); | 2 | ||||
1192 | reuseTask = true; | 2 | ||||
1280 | const Message &msg = it->Msg(); | 7 | ||||
1281 | if (!aInvoke(msg)) { | 7 | ||||
1849 | ReportConnectionError("RunMessage"); | 10 | ||||
1850 | return; | 10 | ||||
1970 | MessageChannel::MessageTask::Clear() | 10 | ||||
1972 | mChannel->AssertWorkerThread(); | 10 | ||||
1974 | mChannel = nullptr; | 10 | ||||
1975 | } | 10 | ||||
2409 | MessageChannel::ReportConnectionError(const char* aChannelName, Message* aMsg) const | 10 | ||||
2411 | AssertWorkerThread(); | 10 | ||||
2412 | mMonitor->AssertCurrentThreadOwns(); | 10 | ||||
2414 | const char* errorMsg = nullptr; | 10 | ||||
2415 | switch (mChannelState) { | 10 | ||||
2426 | errorMsg = "Channel closing: too late to send/recv, messages will be lost"; | 10 | ||||
2427 | break; | 10 | ||||
2436 | if (aMsg) { | 10 | ||||
2443 | PrintErrorMessage(mSide, aChannelName, errorMsg); | 10 | ||||
2446 | MonitorAutoUnlock unlock(*mMonitor); | 10 | ||||
2447 | mListener->ProcessingError(MsgDropped, errorMsg); | 10 | ||||
2448 | } | 10 |
|
Times Different | |||||
1166 | js::RegExpTesterRaw(JSContext* cx, HandleObject regexp, HandleString input, | 8 | ||||
1169 | MOZ_ASSERT(lastIndex >= 0); | 8 | ||||
1171 | size_t endIndexTmp = 0; | 8 | ||||
1173 | nullptr, &endIndexTmp, UpdateRegExpStatics); | 8 | ||||
1175 | if (status == RegExpRunStatus_Success) { | 8 | ||||
1180 | if (status == RegExpRunStatus_Success_NotFound) { | 8 | ||||
1181 | *endIndex = -1; | 8 | ||||
1182 | return true; | 8 |
|
Times Different | |||||
83 | SparseBitmap::bitwiseOrInto(DenseBitmap& other) const | 6 | ||||
85 | for (Data::Range r(data.all()); !r.empty(); r.popFront()) { | 6 | ||||
86 | BitBlock& block = *r.front().value(); | 6 | ||||
87 | size_t blockWord = r.front().key() * WordsInBlock; | 6 | ||||
88 | size_t numWords = wordIntersectCount(blockWord, other); | 6 | ||||
91 | for (size_t i = numWords; i < WordsInBlock; i++) | 6 | ||||
92 | MOZ_ASSERT(!block[i]); | 4 | ||||
94 | for (size_t i = 0; i < numWords; i++) | 6 | ||||
95 | other.word(blockWord + i) |= block[i]; | 6 | ||||
97 | } | 6 |
|
Times Different | |||||
45 | uintptr_t& word(size_t i) { return data[i]; } | 6 |
|
Times Different | |||||
755 | *y = x >> 1; | 6 | ||||
756 | return 1; | 6 | ||||
758 | *y = x >> 2; | 10 | ||||
759 | return 2; | 10 | ||||
767 | k += 8; | 8 | ||||
768 | x >>= 8; | 8 | ||||
775 | k += 2; | 5 | ||||
776 | x >>= 2; | 5 | ||||
779 | k++; | 5 | ||||
780 | x >>= 1; | 5 | ||||
781 | if (!x) | 5 | ||||
1059 | if (xa <= xa0) | 7 | ||||
1087 | c = Balloc(PASS_STATE 0); | 7 | ||||
1088 | c->wds = 1; | 7 | ||||
1089 | c->x[0] = 0; | 7 | ||||
1090 | return c; | 7 | ||||
1319 | x[0] = y; | 7 |
|
Times Different | |||||
8181 | return false; | 2 | ||||
8186 | return false; | 2 |
|
Times Different | |||||
3170 | return false; | 2 |
|
Times Different | |||||
1359 | hadUnicodeEscape = false; | 7 | ||||
1360 | goto identifier; | 7 | ||||
1915 | reportError(JSMSG_ILLEGAL_CHARACTER); | 1 | ||||
1967 | ungetCharIgnoreEOL(c); | 4 |
|
Times Different | |||||
344 | maybeLock.emplace(rt); | 9 | ||||
397 | arena->setNextAllocDuringSweep(arenasAllocatedDuringSweep); | 9 | ||||
398 | arenasAllocatedDuringSweep = arena; | 9 |
|
Times Different | |||||
144 | zone->markedAtoms().bitwiseOrInto(markedUnion); | 6 |
|
Times Different | |||||
81 | CurrentThreadIsIonCompilingSafeForMinorGC() | 9 | ||||
83 | return TlsContext.get()->ionCompilingSafeForMinorGC; | 9 |
|
Times Different | |||||
131 | for (Node* v = first; v; v = v->gcNextGraphNode) | 5 | ||||
132 | v->gcNextGraphComponent = nullptr; | 5 | ||||
139 | processNode(w); | 11 | ||||
140 | cur->gcLowLink = Min(cur->gcLowLink, w->gcLowLink); | 11 |
|
Times Different | |||||
759 | helperState.waitBackgroundSweepEnd(); | 7 | ||||
760 | allocTask.cancel(GCParallelTask::CancelAndWait); | 7 | ||||
791 | bool isShrinkingGC() const { return invocationKind == GC_SHRINK; } | 11 |
|
Times Different | |||||
701 | Arena* getNextAllocDuringSweep() const { | 9 | ||||
702 | MOZ_ASSERT(allocatedDuringIncremental); | 9 | ||||
703 | return reinterpret_cast |
9 | ||||
706 | void setNextAllocDuringSweep(Arena* arena) { | 9 | ||||
707 | MOZ_ASSERT(!(uintptr_t(arena) & ArenaMask)); | 9 | ||||
708 | MOZ_ASSERT(!auxNextLink && !allocatedDuringIncremental); | 9 | ||||
709 | allocatedDuringIncremental = 1; | 9 | ||||
710 | if (arena) | 9 | ||||
711 | auxNextLink = arena->address() >> ArenaShift; | 9 | ||||
712 | } | 9 | ||||
714 | void unsetAllocDuringSweep() { | 9 | ||||
715 | MOZ_ASSERT(allocatedDuringIncremental); | 9 | ||||
716 | allocatedDuringIncremental = 0; | 9 | ||||
717 | auxNextLink = 0; | 9 | ||||
718 | } | 9 |
|
Times Different | |||||
596 | js::TraceManuallyBarrieredCrossCompartmentEdge(JSTracer* trc, JSObject* src, T* dst, | 6 | ||||
599 | if (ShouldTraceCrossCompartment(trc, src, *dst)) | 6 | ||||
600 | DispatchToTracer(trc, dst, name); | 6 | ||||
601 | } | 6 | ||||
649 | js::TraceGenericPointerRoot(JSTracer* trc, Cell** thingp, const char* name) | 12 | ||||
651 | MOZ_ASSERT(thingp); | 12 | ||||
652 | if (!*thingp) | 12 | ||||
653 | return; | 12 | ||||
655 | DispatchTraceKindTyped(f, (*thingp)->getTraceKind(), trc, thingp, name); | 12 | ||||
1202 | next = &right->asRope(); | 4 | ||||
1222 | MOZ_ASSERT(savedPos < stack.position()); | 4 | ||||
1223 | rope = stack.popPtr().asTempRope(); | 4 | ||||
1610 | if (!markDelayedChildren(budget)) { | 13 | ||||
1611 | saveValueRanges(); | 10 | ||||
1612 | return false; | 10 | ||||
1997 | MarkStack::TaggedPtr::asTempRope() const | 4 | ||||
1999 | MOZ_ASSERT(tag() == TempRopeTag); | 4 | ||||
2000 | MOZ_ASSERT(ptr()->asTenured().getTraceKind() == JS::TraceKind::String); | 4 | ||||
2001 | return static_cast |
4 | ||||
2106 | return pushTaggedPtr(TempRopeTag, rope); | 4 | ||||
2498 | GCMarker::markDelayedChildren(Arena* arena) | 13 | ||||
2500 | if (arena->markOverflow) { | 13 | ||||
2512 | MOZ_ASSERT(arena->allocatedDuringIncremental); | 13 | ||||
2513 | PushArena(this, arena); | 13 | ||||
2515 | arena->allocatedDuringIncremental = 0; | 13 | ||||
2521 | } | 13 | ||||
2524 | GCMarker::markDelayedChildren(SliceBudget& budget) | 13 | ||||
2526 | GCRuntime& gc = runtime()->gc; | 13 | ||||
2527 | gcstats::AutoPhase ap(gc.stats(), gc.state() == State::Mark, gcstats::PhaseKind::MARK_DELAYED); | 13 | ||||
2529 | MOZ_ASSERT(unmarkedArenaStackTop); | 13 | ||||
2530 | do { | 13 | ||||
2536 | Arena* arena = unmarkedArenaStackTop; | 13 | ||||
2537 | MOZ_ASSERT(arena->hasDelayedMarking); | 13 | ||||
2538 | MOZ_ASSERT(markLaterArenas); | 13 | ||||
2539 | unmarkedArenaStackTop = arena->getNextDelayedMarking(); | 13 | ||||
2540 | arena->unsetDelayedMarking(); | 13 | ||||
2542 | markLaterArenas--; | 13 | ||||
2544 | markDelayedChildren(arena); | 13 | ||||
2546 | budget.step(150); | 13 | ||||
2547 | if (budget.isOverBudget()) | 13 | ||||
2549 | } while (unmarkedArenaStackTop); | 13 | ||||
2550 | MOZ_ASSERT(!markLaterArenas); | 11 | ||||
2557 | PushArenaTyped(GCMarker* gcmarker, Arena* arena) | 13 | ||||
2559 | for (ArenaCellIterUnderGC i(arena); !i.done(); i.next()) | 13 | ||||
2560 | gcmarker->traverse(i.get |
13 | ||||
2561 | } | 13 | ||||
2565 | PushArenaTyped |
13 | ||||
2570 | gc::PushArena(GCMarker* gcmarker, Arena* arena) | 13 | ||||
2573 | MapAllocToTraceKind(arena->getAllocKind()), gcmarker, arena); | 13 | ||||
2574 | } | 13 | ||||
2747 | jitcode->traceChildren(&mover); | 9 | ||||
2780 | TraceBufferedCells |
9 | ||||
2781 | break; | 9 |
|
Times Different | |||||
248 | JSObject* tmp = JS_FUNC_TO_DATA_PTR(JSObject*, setter); | 6 | ||||
249 | TraceRoot(trc, &tmp, "Descriptor::set"); | 6 | ||||
250 | setter = JS_DATA_TO_FUNC_PTR(JSSetterOp, tmp); | 6 |
|
Times Different | |||||
771 | CheckSelfTime(Phase parent, | 4 | ||||
777 | if (selfTimes[parent] < childTime) { | 4 | ||||
788 | } | 4 | ||||
791 | LongestPhaseSelfTime(const Statistics::PhaseTimeTable& times) | 4 | ||||
794 | Statistics::PhaseTimeTable selfTimes(times); | 4 | ||||
799 | for (auto i : AllPhases()) { | 4 | ||||
800 | Phase parent = phases[i].parent; | 4 | ||||
801 | if (parent != Phase::NONE) { | 4 | ||||
802 | CheckSelfTime(parent, i, times, selfTimes, times[i]); | 4 | ||||
803 | selfTimes[parent] -= times[i]; | 4 | ||||
809 | for (auto i : AllPhaseKinds()) | 4 | ||||
810 | phaseTimes[i] = SumPhase(i, selfTimes); | 4 | ||||
813 | TimeDuration longestTime = 0; | 4 | ||||
814 | PhaseKind longestPhase = PhaseKind::NONE; | 4 | ||||
815 | for (auto i : AllPhaseKinds()) { | 4 | ||||
816 | if (phaseTimes[i] > longestTime) { | 4 | ||||
817 | longestTime = phaseTimes[i]; | 4 | ||||
818 | longestPhase = i; | 4 | ||||
822 | return longestPhase; | 4 | ||||
975 | reportLongestPhase(slice.phaseTimes, JS_TELEMETRY_GC_SLOW_PHASE); | 4 | ||||
978 | TimeDuration joinTime = SumPhase(PhaseKind::JOIN_PARALLEL_TASKS, slice.phaseTimes); | 4 | ||||
979 | if (joinTime.ToMilliseconds() > budget_ms) | 4 | ||||
980 | reportLongestPhase(slice.parallelTimes, JS_TELEMETRY_GC_SLOW_TASK); | 4 | ||||
1022 | Statistics::reportLongestPhase(const PhaseTimeTable& times, int telemetryId) | 4 | ||||
1024 | PhaseKind longest = LongestPhaseSelfTime(times); | 4 | ||||
1025 | if (longest == PhaseKind::NONE) | 4 | ||||
1026 | return; | 4 | ||||
1028 | uint8_t bucket = phaseKinds[longest].telemetryBucket; | 4 | ||||
1029 | runtime->addTelemetry(telemetryId, bucket); | 4 |
|
Times Different | |||||
404 | : stats(stats), phaseKind(phaseKind), enabled(condition) | 13 | ||||
406 | if (enabled) | 13 | ||||
407 | stats.beginPhase(phaseKind); | 13 | ||||
411 | if (enabled) | 13 |
|
Times Different | |||||
141 | zone->group()->storeBuffer().setAboutToOverflow(); | 10 |
|
Times Different | |||||
138 | MOZ_ASSERT(isGCSweepingOrCompacting()); | 6 | ||||
139 | for (auto iter = cellIter |
6 | ||||
140 | JSScript* script = iter; | 6 | ||||
141 | if (!script->hasAnyBreakpointsOrStepMode()) | 6 | ||||
142 | continue; | 6 | ||||
319 | if (!r.front()->debuggeeIsBeingCollected(rt->gc.majorGCCount())) { | 4 |
|
Times Different | |||||
1835 | interpreted_assembler.emplace(cx, &alloc, shared, (data->capture_count + 1) * 2); | 6 | ||||
1836 | assembler = interpreted_assembler.ptr(); | 6 | ||||
4172 | if (preload_characters > 1) | 6 | ||||
4173 | preload_characters = 1; | 6 |
|
Times Different | |||||
45 | class MOZ_STACK_CLASS RegExpStackCursor | 6 | ||||
49 | : cx(cx), cursor(nullptr) | 6 | ||||
52 | bool init() { | 6 | ||||
53 | if (!stack.init()) { | 6 | ||||
57 | cursor = base(); | 6 | ||||
58 | return true; | 6 | ||||
61 | bool push(int32_t value) { | 6 | ||||
62 | *cursor++ = value; | 6 | ||||
63 | if (cursor >= stack.limit()) { | 6 | ||||
74 | int32_t pop() { | 6 | ||||
75 | MOZ_ASSERT(cursor > base()); | 6 | ||||
76 | return *--cursor; | 6 | ||||
100 | int32_t* base() { return (int32_t*) stack.base(); } | 6 | ||||
104 | Load32Aligned(const uint8_t* pc) | 6 | ||||
106 | MOZ_ASSERT((reinterpret_cast |
6 | ||||
107 | return *reinterpret_cast |
6 | ||||
121 | irregexp::InterpretCode(JSContext* cx, const uint8_t* byteCode, const CharT* chars, size_t current, | 6 | ||||
124 | const uint8_t* pc = byteCode; | 6 | ||||
126 | uint32_t current_char = current ? chars[current - 1] : '\n'; | 6 | ||||
130 | if (!stack.init()) | 6 | ||||
133 | int32_t numRegisters = Load32Aligned(pc); | 6 | ||||
134 | pc += 4; | 6 | ||||
136 | Vector |
6 | ||||
137 | if (!registers.growByUninitialized(numRegisters)) { | 6 | ||||
141 | for (size_t i = 0; i < (size_t) numRegisters; i++) | 6 | ||||
142 | registers[i] = -1; | 6 | ||||
145 | int32_t insn = Load32Aligned(pc); | 6 | ||||
146 | switch (insn & BYTECODE_MASK) { | 6 | ||||
155 | if (!stack.push(Load32Aligned(pc + 4))) | 6 | ||||
157 | pc += BC_PUSH_BT_LENGTH; | 6 | ||||
158 | break; | 6 | ||||
193 | if (!CheckForInterrupt(cx)) | 6 | ||||
195 | pc = byteCode + stack.pop(); | 6 | ||||
196 | break; | 6 | ||||
210 | current += insn >> BYTECODE_SHIFT; | 2 | ||||
211 | pc += BC_ADVANCE_CP_LENGTH; | 2 | ||||
212 | break; | 2 | ||||
217 | current += insn >> BYTECODE_SHIFT; | 3 | ||||
218 | pc = byteCode + Load32Aligned(pc + 4); | 3 | ||||
219 | break; | 3 | ||||
229 | size_t pos = current + (insn >> BYTECODE_SHIFT); | 6 | ||||
230 | if (pos >= length) { | 6 | ||||
231 | pc = byteCode + Load32Aligned(pc + 4); | 5 | ||||
233 | current_char = chars[pos]; | 6 | ||||
234 | pc += BC_LOAD_CURRENT_CHAR_LENGTH; | 6 | ||||
275 | uint32_t c = (insn >> BYTECODE_SHIFT); | 6 | ||||
276 | if (c == current_char) | 6 | ||||
279 | pc += BC_CHECK_CHAR_LENGTH; | 6 | ||||
291 | uint32_t c = (insn >> BYTECODE_SHIFT); | 8 | ||||
292 | if (c != current_char) | 8 | ||||
293 | pc = byteCode + Load32Aligned(pc + 4); | 8 | ||||
295 | pc += BC_CHECK_NOT_CHAR_LENGTH; | 2 | ||||
359 | int mask = RegExpMacroAssembler::kTableMask; | 3 | ||||
360 | uint8_t b = pc[8 + ((current_char & mask) >> kBitsPerByteLog2)]; | 3 | ||||
361 | int bit = (current_char & (kBitsPerByte - 1)); | 3 | ||||
362 | if ((b & (1 << bit)) != 0) | 3 | ||||
365 | pc += BC_CHECK_BIT_IN_TABLE_LENGTH; | 3 | ||||
479 | if (current == 0) | 8 | ||||
480 | pc += BC_CHECK_NOT_AT_START_LENGTH; | 8 |
|
Times Different | |||||
100 | InterpretedRegExpMacroAssembler::InterpretedRegExpMacroAssembler(JSContext* cx, LifoAlloc* alloc, | 6 | ||||
109 | length_(0) | 6 | ||||
112 | Emit32(0); | 6 | ||||
113 | } | 6 | ||||
115 | InterpretedRegExpMacroAssembler::~InterpretedRegExpMacroAssembler() | 6 | ||||
117 | js_free(buffer_); | 6 | ||||
118 | } | 6 | ||||
121 | InterpretedRegExpMacroAssembler::GenerateCode(JSContext* cx, bool match_only) | 6 | ||||
123 | Bind(&backtrack_); | 6 | ||||
127 | *(int32_t*)buffer_ = num_registers_; | 6 | ||||
130 | res.byteCode = buffer_; | 6 | ||||
131 | buffer_ = nullptr; | 6 | ||||
132 | return res; | 6 | ||||
136 | InterpretedRegExpMacroAssembler::AdvanceCurrentPosition(int by) | 6 | ||||
138 | MOZ_ASSERT(by >= kMinCPOffset); | 6 | ||||
139 | MOZ_ASSERT(by <= kMaxCPOffset); | 6 | ||||
140 | advance_current_start_ = pc_; | 6 | ||||
141 | advance_current_offset_ = by; | 6 | ||||
142 | Emit(BC_ADVANCE_CP, by); | 6 | ||||
143 | advance_current_end_ = pc_; | 6 | ||||
144 | } | 6 | ||||
155 | InterpretedRegExpMacroAssembler::Backtrack() | 8 | ||||
158 | } | 8 | ||||
161 | InterpretedRegExpMacroAssembler::Bind(jit::Label* label) | 6 | ||||
163 | advance_current_end_ = kInvalidPC; | 6 | ||||
164 | MOZ_ASSERT(!label->bound()); | 6 | ||||
165 | if (label->used()) { | 6 | ||||
166 | int pos = label->offset(); | 6 | ||||
167 | while (pos != jit::Label::INVALID_OFFSET) { | 6 | ||||
168 | int fixup = pos; | 6 | ||||
169 | pos = *reinterpret_cast |
6 | ||||
170 | *reinterpret_cast |
6 | ||||
173 | label->bind(pc_); | 6 | ||||
174 | } | 6 | ||||
184 | InterpretedRegExpMacroAssembler::CheckCharacter(unsigned c, jit::Label* on_equal) | 6 | ||||
186 | if (c > MAX_FIRST_ARG) { | 6 | ||||
192 | EmitOrLink(on_equal); | 6 | ||||
193 | } | 6 | ||||
196 | InterpretedRegExpMacroAssembler::CheckCharacterAfterAnd(unsigned c, unsigned and_with, jit::Label* on_equal) | 1 | ||||
198 | if (c > MAX_FIRST_ARG) { | 1 | ||||
204 | Emit32(and_with); | 1 | ||||
205 | EmitOrLink(on_equal); | 1 | ||||
206 | } | 1 | ||||
209 | InterpretedRegExpMacroAssembler::CheckCharacterGT(char16_t limit, jit::Label* on_greater) | 2 | ||||
211 | Emit(BC_CHECK_GT, limit); | 2 | ||||
212 | EmitOrLink(on_greater); | 2 | ||||
213 | } | 2 | ||||
216 | InterpretedRegExpMacroAssembler::CheckCharacterLT(char16_t limit, jit::Label* on_less) | 2 | ||||
218 | Emit(BC_CHECK_LT, limit); | 2 | ||||
219 | EmitOrLink(on_less); | 2 | ||||
220 | } | 2 | ||||
223 | InterpretedRegExpMacroAssembler::CheckGreedyLoop(jit::Label* on_tos_equals_current_position) | 2 | ||||
226 | EmitOrLink(on_tos_equals_current_position); | 2 | ||||
227 | } | 2 | ||||
230 | InterpretedRegExpMacroAssembler::CheckNotAtStart(jit::Label* on_not_at_start) | 6 | ||||
233 | EmitOrLink(on_not_at_start); | 6 | ||||
234 | } | 6 | ||||
260 | InterpretedRegExpMacroAssembler::CheckNotCharacter(unsigned c, jit::Label* on_not_equal) | 6 | ||||
262 | if (c > MAX_FIRST_ARG) { | 6 | ||||
268 | EmitOrLink(on_not_equal); | 6 | ||||
269 | } | 6 | ||||
316 | InterpretedRegExpMacroAssembler::CheckBitInTable(uint8_t* table, jit::Label* on_bit_set) | 5 | ||||
321 | EmitOrLink(on_bit_set); | 5 | ||||
322 | for (int i = 0; i < kTableSize; i += kBitsPerByte) { | 5 | ||||
324 | for (int j = 0; j < kBitsPerByte; j++) { | 5 | ||||
325 | if (table[i + j] != 0) | 5 | ||||
326 | byte |= 1 << j; | 5 | ||||
328 | Emit8(byte); | 5 | ||||
330 | } | 5 | ||||
333 | InterpretedRegExpMacroAssembler::JumpOrBacktrack(jit::Label* to) | 6 | ||||
335 | if (advance_current_end_ == pc_) { | 6 | ||||
337 | pc_ = advance_current_start_; | 5 | ||||
338 | Emit(BC_ADVANCE_CP_AND_GOTO, advance_current_offset_); | 5 | ||||
339 | EmitOrLink(to); | 5 | ||||
340 | advance_current_end_ = kInvalidPC; | 5 | ||||
344 | EmitOrLink(to); | 6 | ||||
346 | } | 6 | ||||
349 | InterpretedRegExpMacroAssembler::Fail() | 6 | ||||
352 | } | 6 | ||||
381 | InterpretedRegExpMacroAssembler::LoadCurrentCharacter(int cp_offset, jit::Label* on_end_of_input, | 6 | ||||
384 | MOZ_ASSERT(cp_offset >= kMinCPOffset); | 6 | ||||
385 | MOZ_ASSERT(cp_offset <= kMaxCPOffset); | 6 | ||||
387 | if (check_bounds) { | 6 | ||||
388 | if (characters == 4) { | 6 | ||||
390 | } else if (characters == 2) { | 6 | ||||
393 | MOZ_ASSERT(characters == 1); | 6 | ||||
397 | if (characters == 4) { | 6 | ||||
399 | } else if (characters == 2) { | 6 | ||||
402 | MOZ_ASSERT(characters == 1); | 6 | ||||
406 | Emit(bytecode, cp_offset); | 6 | ||||
407 | if (check_bounds) | 6 | ||||
408 | EmitOrLink(on_end_of_input); | 6 | ||||
409 | } | 6 | ||||
412 | InterpretedRegExpMacroAssembler::PopCurrentPosition() | 6 | ||||
415 | } | 6 | ||||
425 | InterpretedRegExpMacroAssembler::PushCurrentPosition() | 6 | ||||
428 | } | 6 | ||||
459 | InterpretedRegExpMacroAssembler::SetRegister(int reg, int to) | 6 | ||||
461 | checkRegister(reg); | 6 | ||||
462 | Emit(BC_SET_REGISTER, reg); | 6 | ||||
463 | Emit32(to); | 6 | ||||
464 | } | 6 | ||||
467 | InterpretedRegExpMacroAssembler::Succeed() | 6 | ||||
472 | return false; | 6 | ||||
476 | InterpretedRegExpMacroAssembler::WriteCurrentPositionToRegister(int reg, int cp_offset) | 6 | ||||
478 | checkRegister(reg); | 6 | ||||
479 | Emit(BC_SET_REGISTER_TO_CP, reg); | 6 | ||||
480 | Emit32(cp_offset); // Current position offset. | 6 | ||||
481 | } | 6 | ||||
484 | InterpretedRegExpMacroAssembler::ClearRegisters(int reg_from, int reg_to) | 6 | ||||
486 | MOZ_ASSERT(reg_from <= reg_to); | 6 | ||||
487 | for (int reg = reg_from; reg <= reg_to; reg++) | 6 | ||||
488 | SetRegister(reg, -1); | 6 | ||||
489 | } | 6 | ||||
499 | InterpretedRegExpMacroAssembler::PushBacktrack(jit::Label* label) | 6 | ||||
502 | EmitOrLink(label); | 6 | ||||
503 | } | 6 | ||||
506 | InterpretedRegExpMacroAssembler::BindBacktrack(jit::Label* label) | 6 | ||||
508 | Bind(label); | 6 | ||||
509 | } | 6 | ||||
512 | InterpretedRegExpMacroAssembler::EmitOrLink(jit::Label* label) | 6 | ||||
514 | if (label == nullptr) | 6 | ||||
515 | label = &backtrack_; | 6 | ||||
516 | if (label->bound()) { | 6 | ||||
517 | Emit32(label->offset()); | 6 | ||||
519 | int pos = label->use(pc_); | 6 | ||||
520 | Emit32(pos); | 6 | ||||
522 | } | 6 | ||||
527 | uint32_t word = ((twenty_four_bits << BYTECODE_SHIFT) | byte); | 6 | ||||
528 | Emit32(word); | 6 | ||||
532 | InterpretedRegExpMacroAssembler::Emit32(uint32_t word) | 6 | ||||
534 | MOZ_ASSERT(pc_ <= length_); | 6 | ||||
535 | if (pc_ + 3 >= length_) | 6 | ||||
536 | Expand(); | 6 | ||||
537 | *reinterpret_cast |
6 | ||||
538 | pc_ += 4; | 6 | ||||
539 | } | 6 | ||||
552 | InterpretedRegExpMacroAssembler::Emit8(uint32_t word) | 5 | ||||
554 | MOZ_ASSERT(pc_ <= length_); | 5 | ||||
555 | if (pc_ == length_) | 5 | ||||
557 | *reinterpret_cast |
5 | ||||
558 | pc_ += 1; | 5 | ||||
559 | } | 5 | ||||
562 | InterpretedRegExpMacroAssembler::Expand() | 6 | ||||
564 | AutoEnterOOMUnsafeRegion oomUnsafe; | 6 | ||||
566 | int newLength = Max(100, length_ * 2); | 6 | ||||
567 | if (newLength < length_ + 4) | 6 | ||||
570 | buffer_ = (uint8_t*) js_realloc(buffer_, newLength); | 6 | ||||
571 | if (!buffer_) | 6 | ||||
573 | length_ = newLength; | 6 | ||||
574 | } | 6 |
|
Times Different | |||||
91 | virtual bool CanReadUnaligned() { return false; } | 6 | ||||
145 | virtual void CheckPosition(int cp_offset, jit::Label* on_outside_input) { | 6 | ||||
146 | LoadCurrentCharacter(cp_offset, on_outside_input, true); | 6 | ||||
147 | } | 6 | ||||
285 | int stack_limit_slack() { return 1; } | 6 |
|
Times Different | |||||
483 | if (ins->getTemp(i)->policy() == LDefinition::MUST_REUSE_INPUT && | 2 | ||||
484 | ins->getOperand(ins->getTemp(i)->getReusedInput())->toUse() == use) | 2 | ||||
948 | ins->getOperand(def->getReusedInput()) == alloc) | 2 | ||||
949 | return def; | 2 | ||||
975 | MOZ_ASSERT(def.isTemp()); | 2 | ||||
976 | def.setMustCopyInput(); | 2 | ||||
977 | return true; | 2 |
|
Times Different | |||||
675 | BaselineCacheIRCompiler::emitCallProxyHasOwnResult() | 4 | ||||
677 | Register obj = allocator.useRegister(masm, reader.objOperandId()); | 4 | ||||
678 | ValueOperand idVal = allocator.useValueRegister(masm, reader.valOperandId()); | 4 | ||||
680 | AutoScratchRegister scratch(allocator, masm); | 4 | ||||
682 | allocator.discardStack(masm); | 4 | ||||
684 | AutoStubFrame stubFrame(*this); | 4 | ||||
685 | stubFrame.enter(masm, scratch); | 4 | ||||
687 | masm.Push(idVal); | 4 | ||||
688 | masm.Push(obj); | 4 | ||||
690 | if (!callVM(masm, ProxyHasOwnInfo)) | 4 | ||||
693 | stubFrame.leave(masm); | 4 | ||||
694 | return true; | 4 |
|
Times Different | |||||
2481 | frame.push(cx->runtime()->positiveInfinityValue); | 6 | ||||
2482 | return true; | 6 | ||||
4878 | MOZ_ASSERT(resumeKind == GeneratorObject::THROW || resumeKind == GeneratorObject::CLOSE); | 10 | ||||
4882 | scratch2); | 10 | ||||
4883 | masm.movePtr(scratch2, scratch1); | 10 | ||||
4884 | masm.subStackPtrFrom(scratch2); | 10 | ||||
4885 | masm.store32(scratch2, Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfFrameSize())); | 10 | ||||
4886 | masm.loadBaselineFramePtr(BaselineFrameReg, scratch2); | 10 | ||||
4888 | prepareVMCall(); | 10 | ||||
4889 | pushArg(Imm32(resumeKind)); | 10 | ||||
4890 | pushArg(retVal); | 10 | ||||
4891 | pushArg(genObj); | 10 | ||||
4892 | pushArg(scratch2); | 10 | ||||
4894 | JitCode* code = cx->runtime()->jitRuntime()->getVMWrapper(GeneratorThrowInfo); | 10 | ||||
4895 | if (!code) | 10 | ||||
4899 | masm.subStackPtrFrom(scratch1); | 10 | ||||
4900 | masm.makeFrameDescriptor(scratch1, JitFrame_BaselineJS, ExitFrameLayout::Size()); | 10 | ||||
4905 | masm.push(scratch1); | 10 | ||||
4909 | masm.push(ImmWord(0)); | 10 | ||||
4911 | masm.jump(code); | 10 | ||||
4920 | } else if (resumeKind == GeneratorObject::THROW) { | 10 | ||||
4921 | pushArg(ImmGCPtr(cx->names().throw_)); | 10 |
|
Times Different | |||||
187 | CollectJitStackScripts(JSContext* cx, const Debugger::ExecutionObservableSet& obs, | 6 | ||||
190 | ICStub* prevFrameStubPtr = nullptr; | 6 | ||||
191 | bool needsRecompileHandler = false; | 6 | ||||
192 | for (JitFrameIterator iter(activation); !iter.done(); ++iter) { | 6 | ||||
193 | switch (iter.type()) { | 6 | ||||
195 | JSScript* script = iter.script(); | 6 | ||||
197 | if (!obs.shouldRecompileOrInvalidate(script)) { | 6 | ||||
241 | reinterpret_cast |
6 | ||||
242 | break; | 6 | ||||
264 | if (needsRecompileHandler) { | 6 | ||||
850 | if (!CollectJitStackScripts(cx, obs, iter, entries)) | 6 |
|
Times Different | |||||
49 | TraceRoot(trc, returnValue().address(), "baseline-rval"); | 2 | ||||
55 | TraceRoot(trc, &argsObj_, "baseline-args-obj"); | 6 |
|
Times Different | |||||
353 | jsbytecode* overridePc() const { | 10 | ||||
354 | MOZ_ASSERT(hasOverridePc()); | 10 | ||||
355 | return script()->offsetToPC(overrideOffset_); | 10 | ||||
360 | return overridePc(); | 10 |
|
Times Different | |||||
553 | return extra_ & (1u << UNOPTIMIZABLE_ACCESS_BIT); | 4 |
|
Times Different | |||||
926 | size_t offset = reader.stubOffset(); | 4 | ||||
928 | &stub->stubInfo()->getStubField |
4 | ||||
930 | Shape* thisGlobalShape = nullptr; | 4 | ||||
931 | if (getter->isNative() && receiver.shape && | 4 | ||||
937 | if (*commonGetter && | 4 | ||||
938 | (*isOwnProperty || *globalShape != thisGlobalShape || *holderShape != objShape)) | 4 | ||||
943 | MOZ_ASSERT_IF(*commonGetter, *commonGetter == getter); | 4 | ||||
945 | if (obj->as |
4 | ||||
950 | if (!AddReceiver(receiver, receivers, convertUnboxedGroups)) | 4 | ||||
953 | *holder = obj; | 4 | ||||
954 | *holderShape = objShape; | 4 | ||||
955 | *commonGetter = getter; | 4 | ||||
956 | *isOwnProperty = false; | 4 | ||||
957 | return true; | 4 | ||||
991 | } else if (stub->isGetName_Fallback()) { | 4 | ||||
992 | if (stub->toGetName_Fallback()->hadUnoptimizableAccess()) | 4 |
|
Times Different | |||||
1340 | JSRope* rope = &str->asRope(); | 4 | ||||
1343 | if (size_t(index) >= rope->leftChild()->length()) | 4 | ||||
1346 | str = rope->leftChild(); | 4 |
|
Times Different | |||||
2584 | MOZ_ASSERT(info.fun->allowSuperProperty() || info.fun->isSelfHostedBuiltin() || | 2 | ||||
2587 | masm.storeValue(UndefinedValue(), Address(output, FunctionExtended::offsetOfExtendedSlot(0))); | 2 | ||||
2588 | masm.storeValue(UndefinedValue(), Address(output, FunctionExtended::offsetOfExtendedSlot(1))); | 2 | ||||
2818 | CodeGenerator::visitTableSwitch(LTableSwitch* ins) | 2 | ||||
2820 | MTableSwitch* mir = ins->mir(); | 2 | ||||
2821 | Label* defaultcase = skipTrivialBlocks(mir->getDefault())->lir()->label(); | 2 | ||||
2824 | if (mir->getOperand(0)->type() != MIRType::Int32) { | 2 | ||||
2831 | temp = ins->index(); | 2 | ||||
2834 | emitTableSwitchDispatch(mir, ToRegister(temp), ToRegisterOrInvalid(ins->tempPointer())); | 2 | ||||
2835 | } | 2 | ||||
2892 | CodeGenerator::visitIsConstructing(LIsConstructing* lir) | 2 | ||||
2894 | Register output = ToRegister(lir->output()); | 2 | ||||
2895 | Address calleeToken(masm.getStackPointer(), frameSize() + JitFrameLayout::offsetOfCalleeToken()); | 2 | ||||
2896 | masm.loadPtr(calleeToken, output); | 2 | ||||
2899 | MOZ_ASSERT(current->mir()->info().script()->functionNonDelazifying()); | 2 | ||||
2905 | masm.andPtr(Imm32(0x1), output); | 2 | ||||
2906 | } | 2 | ||||
3294 | CodeGenerator::emitSetPropertyPolymorphic(LInstruction* ins, Register obj, Register scratch, | 2 | ||||
3297 | MSetPropertyPolymorphic* mir = ins->mirRaw()->toSetPropertyPolymorphic(); | 2 | ||||
3300 | for (size_t i = 0; i < mir->numReceivers(); i++) { | 2 | ||||
3301 | ReceiverGuard receiver = mir->receiver(i); | 2 | ||||
3304 | GuardReceiver(masm, receiver, obj, scratch, &next, /* checkNullExpando = */ false); | 2 | ||||
3306 | if (receiver.shape) { | 2 | ||||
3309 | Register target = receiver.group ? scratch : obj; | 2 | ||||
3311 | Shape* shape = mir->shape(i); | 2 | ||||
3312 | if (shape->slot() < shape->numFixedSlots()) { | 2 | ||||
3314 | Address addr(target, NativeObject::getFixedSlotOffset(shape->slot())); | 2 | ||||
3315 | if (mir->needsBarrier()) | 2 | ||||
3316 | emitPreBarrier(addr); | 2 | ||||
3317 | masm.storeConstantOrRegister(value, addr); | 2 | ||||
3335 | if (i == mir->numReceivers() - 1) { | 2 | ||||
3336 | bailoutFrom(&next, ins->snapshot()); | 2 | ||||
3338 | masm.jump(&done); | 2 | ||||
3339 | masm.bind(&next); | 2 | ||||
3341 | } | 2 | ||||
3343 | masm.bind(&done); | 2 | ||||
3344 | } | 2 | ||||
3356 | CodeGenerator::visitSetPropertyPolymorphicT(LSetPropertyPolymorphicT* ins) | 2 | ||||
3358 | Register obj = ToRegister(ins->obj()); | 2 | ||||
3359 | Register temp = ToRegister(ins->temp()); | 2 | ||||
3362 | if (ins->mir()->value()->isConstant()) | 2 | ||||
3365 | value = TypedOrValueRegister(ins->mir()->value()->type(), ToAnyRegister(ins->value())); | 2 | ||||
3367 | emitSetPropertyPolymorphic(ins, obj, temp, value); | 2 | ||||
3368 | } | 2 | ||||
4469 | CodeGenerator::emitPushArguments(LApplyArrayGeneric* apply, Register extraStackSpace) | 2 | ||||
4471 | Label noCopy, epilogue; | 2 | ||||
4472 | Register tmpArgc = ToRegister(apply->getTempObject()); | 2 | ||||
4473 | Register elementsAndArgc = ToRegister(apply->getElements()); | 2 | ||||
4480 | Address length(ToRegister(apply->getElements()), ObjectElements::offsetOfLength()); | 2 | ||||
4481 | masm.load32(length, tmpArgc); | 2 | ||||
4484 | emitAllocateSpaceForApply(tmpArgc, extraStackSpace, &noCopy); | 2 | ||||
4488 | size_t argvDstOffset = 0; | 2 | ||||
4490 | Register argvSrcBase = elementsAndArgc; // Elements value | 2 | ||||
4492 | masm.push(extraStackSpace); | 2 | ||||
4493 | Register copyreg = extraStackSpace; | 2 | ||||
4494 | argvDstOffset += sizeof(void*); | 2 | ||||
4496 | masm.push(tmpArgc); | 2 | ||||
4497 | Register argvIndex = tmpArgc; | 2 | ||||
4498 | argvDstOffset += sizeof(void*); | 2 | ||||
4501 | emitCopyValuesForApply(argvSrcBase, argvIndex, copyreg, 0, argvDstOffset); | 2 | ||||
4504 | masm.pop(elementsAndArgc); | 2 | ||||
4505 | masm.pop(extraStackSpace); | 2 | ||||
4506 | masm.jump(&epilogue); | 2 | ||||
4509 | masm.bind(&noCopy); | 2 | ||||
4510 | masm.movePtr(ImmPtr(0), elementsAndArgc); | 2 | ||||
4514 | masm.bind(&epilogue); | 2 | ||||
4517 | masm.addPtr(Imm32(sizeof(Value)), extraStackSpace); | 2 | ||||
4518 | masm.pushValue(ToValue(apply, LApplyArgsGeneric::ThisIndex)); | 2 | ||||
4519 | } | 2 | ||||
4538 | masm.loadObjClass(calleereg, objreg); | 2 | ||||
4540 | ImmPtr ptr = ImmPtr(&JSFunction::class_); | 2 | ||||
4541 | bailoutCmpPtr(Assembler::NotEqual, objreg, ptr, apply->snapshot()); | 2 | ||||
4596 | Register nformals = extraStackSpace; | 2 | ||||
4597 | masm.load16ZeroExtend(Address(calleereg, JSFunction::offsetOfNargs()), nformals); | 2 | ||||
4598 | masm.branch32(Assembler::Below, argcreg, nformals, &underflow); | 2 | ||||
4668 | CodeGenerator::visitApplyArrayGeneric(LApplyArrayGeneric* apply) | 2 | ||||
4670 | LSnapshot* snapshot = apply->snapshot(); | 2 | ||||
4671 | Register tmp = ToRegister(apply->getTempObject()); | 2 | ||||
4673 | Address length(ToRegister(apply->getElements()), ObjectElements::offsetOfLength()); | 2 | ||||
4674 | masm.load32(length, tmp); | 2 | ||||
4678 | uint32_t limit = 3000 / sizeof(Value); | 2 | ||||
4679 | bailoutCmp32(Assembler::Above, tmp, Imm32(limit), snapshot); | 2 | ||||
4684 | ObjectElements::offsetOfInitializedLength()); | 2 | ||||
4685 | masm.sub32(initializedLength, tmp); | 2 | ||||
4686 | bailoutCmp32(Assembler::NotEqual, tmp, Imm32(0), snapshot); | 2 | ||||
4688 | emitApplyGeneric(apply); | 2 | ||||
4689 | } | 2 | ||||
7241 | label1.emplace(); | 2 | ||||
7242 | label2.emplace(); | 2 | ||||
7243 | nullOrLikeUndefined = label1.ptr(); | 2 | ||||
7244 | notNullOrLikeUndefined = label2.ptr(); | 2 | ||||
7304 | ifTrue = lir->ifTrue(); | 2 | ||||
7305 | ifFalse = lir->ifFalse(); | 2 | ||||
7332 | masm.branchTestUndefined(Assembler::Equal, tag, ifTrueLabel); | 2 | ||||
7351 | testNullEmitBranch(cond, value, lir->ifTrue(), lir->ifFalse()); | 2 | ||||
8356 | bailoutCmp32(Assembler::BelowOrEqual, ToAddress(length), Imm32(idx), snapshot); | 2 | ||||
8386 | bailoutCmp32(Assembler::BelowOrEqual, ToAddress(length), Imm32(nmax), snapshot); | 2 | ||||
11152 | masm.storeToTypedIntArray(writeType, Imm32(ToInt32(value)), dest); | 2 | ||||
11399 | CodeGenerator::visitInstanceOfV(LInstanceOfV* ins) | 2 | ||||
11401 | emitInstanceOf(ins, ins->mir()->prototypeObject()); | 2 | ||||
11402 | } | 2 | ||||
11416 | CodeGenerator::emitInstanceOf(LInstruction* ins, JSObject* prototypeObject) | 2 | ||||
11422 | Register output = ToRegister(ins->getDef(0)); | 2 | ||||
11426 | if (ins->isInstanceOfV()) { | 2 | ||||
11428 | ValueOperand lhsValue = ToValue(ins, LInstanceOfV::LHS); | 2 | ||||
11429 | masm.branchTestObject(Assembler::Equal, lhsValue, &isObject); | 2 | ||||
11430 | masm.mov(ImmWord(0), output); | 2 | ||||
11431 | masm.jump(&done); | 2 | ||||
11432 | masm.bind(&isObject); | 2 | ||||
11433 | objReg = masm.extractObject(lhsValue, output); | 2 | ||||
11443 | masm.loadObjProto(objReg, output); | 2 | ||||
11445 | Label testLazy; | 2 | ||||
11448 | masm.bind(&loopPrototypeChain); | 2 | ||||
11451 | Label notPrototypeObject; | 2 | ||||
11452 | masm.branchPtr(Assembler::NotEqual, output, ImmGCPtr(prototypeObject), ¬PrototypeObject); | 2 | ||||
11453 | masm.mov(ImmWord(1), output); | 2 | ||||
11454 | masm.jump(&done); | 2 | ||||
11455 | masm.bind(¬PrototypeObject); | 2 | ||||
11457 | MOZ_ASSERT(uintptr_t(TaggedProto::LazyProto) == 1); | 2 | ||||
11460 | masm.branchPtr(Assembler::BelowOrEqual, output, ImmWord(1), &testLazy); | 2 | ||||
11463 | masm.loadObjProto(output, output); | 2 | ||||
11465 | masm.jump(&loopPrototypeChain); | 2 | ||||
11475 | ArgList(ImmGCPtr(prototypeObject), objReg), | 2 | ||||
11476 | StoreRegisterTo(output)); | 2 | ||||
11479 | Label regenerate, *lazyEntry; | 2 | ||||
11480 | if (objReg != output) { | 2 | ||||
11483 | masm.bind(®enerate); | 2 | ||||
11484 | lazyEntry = ®enerate; | 2 | ||||
11485 | if (ins->isInstanceOfV()) { | 2 | ||||
11486 | ValueOperand lhsValue = ToValue(ins, LInstanceOfV::LHS); | 2 | ||||
11487 | objReg = masm.extractObject(lhsValue, output); | 2 | ||||
11491 | MOZ_ASSERT(objReg == output); | 2 | ||||
11492 | masm.jump(ool->entry()); | 2 | ||||
11495 | masm.bind(&testLazy); | 2 | ||||
11496 | masm.branchPtr(Assembler::Equal, output, ImmWord(1), lazyEntry); | 2 | ||||
11498 | masm.bind(&done); | 2 | ||||
11499 | masm.bind(ool->rejoin()); | 2 | ||||
11500 | } | 2 |
|
Times Different | |||||
76 | void setInvalid() { invalid_ = true; } | 6 |
|
Times Different | |||||
1044 | ionScript->trace(zone->barrierTracer()); | 2 | ||||
1257 | IonICEntry& entry = sharedStubList()[i]; | 6 | ||||
1258 | if (!entry.hasStub()) | 6 | ||||
1261 | ICStub* lastStub = entry.firstStub(); | 6 | ||||
1262 | while (lastStub->next()) | 6 | ||||
1265 | if (lastStub->isFallback()) { | 6 | ||||
1267 | ICStub* stub = entry.firstStub(); | 6 | ||||
1268 | ICStub* prev = nullptr; | 6 | ||||
1270 | while (stub->next()) { | 6 | ||||
1281 | lastStub->toFallbackStub()->setInvalid(); | 6 | ||||
1283 | if (lastStub->isMonitoredFallback()) { | 6 | ||||
1302 | IonICEntry& entry = sharedStubList()[i]; | 6 | ||||
1303 | if (!entry.hasStub()) | 6 | ||||
1306 | ICStub* stub = entry.firstStub(); | 6 | ||||
1307 | while (stub->next()) { | 6 | ||||
1471 | return false; | 8 | ||||
1482 | return false; | 8 | ||||
1493 | return false; | 10 | ||||
1542 | return false; | 2 | ||||
3109 | ionCode->traceChildren(zone->barrierTracer()); | 6 |
|
Times Different | |||||
445 | shouldBailout = false; | 2 | ||||
1710 | v = MagicValue(JS_UNINITIALIZED_LEXICAL); | 9 | ||||
1711 | break; | 9 | ||||
4232 | AbortReason reason = buildResult.unwrapErr(); | 2 | ||||
4233 | if (cx->isThrowingOverRecursed() || cx->isThrowingOutOfMemory()) | 2 | ||||
4235 | if (reason == AbortReason::Alloc) { | 2 | ||||
4239 | MOZ_ASSERT(!cx->isExceptionPending()); | 2 |
|
Times Different | |||||
381 | IonBuilder* path = it->callerBuilder_; | 4 | ||||
382 | if (!path || this->script() == path->script()) | 4 | ||||
487 | trackOptimizationOutcome(TrackedOutcome::HasCommonInliningPath); | 4 | ||||
488 | return DontInline(inlineScript, "Common inlining path"); | 4 | ||||
2684 | filter.addType(TypeSet::SymbolType(), alloc_->lifoAlloc()); | 2 | ||||
3367 | trackOptimizationOutcome(TrackedOutcome::OperandNotEasilyCoercibleToString); | 2 | ||||
3368 | return Ok(); | 2 | ||||
4066 | outerBaseline->setMaxInliningDepth(0); | 2 | ||||
4068 | trackOptimizationOutcome(TrackedOutcome::CantInlineExceededDepth); | 2 | ||||
4069 | return DontInline(targetScript, "Vetoed: exceeding allowed inline depth"); | 2 | ||||
4123 | return Ok(); | 2 | ||||
4636 | MOZ_ASSERT(current == inlineBlock); | 2 | ||||
4637 | graph().removeBlock(inlineBlock); | 2 | ||||
4638 | choiceSet[i] = false; | 2 | ||||
4909 | if (!templateObject->is |
4 | ||||
4911 | if (templateObject->staticPrototype() != proto) | 4 | ||||
4914 | TypeSet::ObjectKey* templateObjectKey = TypeSet::ObjectKey::get(templateObject->group()); | 4 | ||||
4915 | if (templateObjectKey->hasFlags(constraints(), OBJECT_FLAG_NEW_SCRIPT_CLEARED)) | 4 | ||||
4918 | StackTypeSet* thisTypes = TypeScript::ThisTypes(target->nonLazyScript()); | 4 | ||||
4919 | if (!thisTypes || !thisTypes->hasType(TypeSet::ObjectType(templateObject))) | 4 | ||||
4924 | MConstant* templateConst = MConstant::NewConstraintlessObject(alloc(), templateObject); | 4 | ||||
4926 | MCreateThisWithTemplate::New(alloc(), constraints(), templateConst, | 4 | ||||
4927 | templateObject->group()->initialHeap(constraints())); | 4 | ||||
4928 | current->add(templateConst); | 4 | ||||
4929 | current->add(createThis); | 4 | ||||
4931 | return createThis; | 4 | ||||
5139 | TemporaryTypeSet* objTypes = argument->resultTypeSet(); | 2 | ||||
5140 | if (native && native->isNative() && native->native() == fun_apply && | 2 | ||||
5141 | objTypes && | 2 | ||||
5142 | objTypes->getKnownClass(constraints()) == &ArrayObject::class_ && | 2 | ||||
5143 | !objTypes->hasObjectFlags(constraints(), OBJECT_FLAG_LENGTH_OVERFLOW) && | 2 | ||||
5144 | ElementAccessIsPacked(constraints(), argument)) | 2 | ||||
5146 | return jsop_funapplyarray(argc); | 2 | ||||
5207 | IonBuilder::jsop_funapplyarray(uint32_t argc) | 2 | ||||
5209 | MOZ_ASSERT(argc == 2); | 2 | ||||
5211 | int funcDepth = -((int)argc + 1); | 2 | ||||
5214 | TemporaryTypeSet* funTypes = current->peek(funcDepth)->resultTypeSet(); | 2 | ||||
5215 | JSFunction* target = getSingleCallTarget(funTypes); | 2 | ||||
5218 | MDefinition* argObj = current->pop(); | 2 | ||||
5220 | MElements* elements = MElements::New(alloc(), argObj); | 2 | ||||
5221 | current->add(elements); | 2 | ||||
5224 | MDefinition* argThis = current->pop(); | 2 | ||||
5227 | MDefinition* argFunc = current->pop(); | 2 | ||||
5230 | MDefinition* nativeFunc = current->pop(); | 2 | ||||
5233 | WrappedFunction* wrappedTarget = target ? new(alloc()) WrappedFunction(target) : nullptr; | 2 | ||||
5234 | MApplyArray* apply = MApplyArray::New(alloc(), wrappedTarget, argFunc, elements, argThis); | 2 | ||||
5235 | current->add(apply); | 2 | ||||
5236 | current->push(apply); | 2 | ||||
5237 | MOZ_TRY(resumeAfter(apply)); | 2 | ||||
5239 | TemporaryTypeSet* types = bytecodeTypes(pc); | 2 | ||||
5240 | return pushTypeBarrier(apply, types, BarrierKind::TypeSet); | 2 | ||||
5446 | return calleeTypes->unknownObject(); | 4 | ||||
7061 | if (thisSingleton != singleton) | 2 | ||||
9749 | trackOptimizationOutcome(TrackedOutcome::StructNoField); | 2 | ||||
9750 | return UINT32_MAX; | 2 | ||||
9795 | IonBuilder::commonPrototypeWithGetterSetter(TemporaryTypeSet* types, PropertyName* name, | 4 | ||||
9804 | if (!types || types->unknownObject()) | 4 | ||||
9934 | IonBuilder::testCommonGetterSetter(TemporaryTypeSet* types, PropertyName* name, | 4 | ||||
9940 | MOZ_ASSERT(getterOrSetter); | 4 | ||||
9941 | MOZ_ASSERT_IF(globalShape, globalGuard); | 4 | ||||
9946 | commonPrototypeWithGetterSetter(types, name, isGetter, getterOrSetter, &guardGlobal); | 4 | ||||
9947 | if (!foundProto || (guardGlobal && !globalShape)) { | 4 | ||||
9948 | trackOptimizationOutcome(TrackedOutcome::MultiProtoPaths); | 4 | ||||
9949 | return false; | 4 | ||||
10217 | uint32_t idx = current->stackDepth() - 1; | 2 | ||||
10218 | MOZ_ASSERT(current->getSlot(idx) == def); | 2 | ||||
10219 | current->setSlot(idx, unbox); | 2 | ||||
10746 | MInstruction* slots = MSlots::New(alloc(), obj); | 2 | ||||
10747 | current->add(slots); | 2 | ||||
10749 | load = MLoadSlot::New(alloc(), slots, slot - nfixed); | 2 | ||||
10916 | MDefinition* holderDef = constant(ObjectValue(*holder)); | 4 | ||||
10917 | addShapeGuard(holderDef, holderShape, Bailout_ShapeGuard); | 4 | ||||
10919 | return addGuardReceiverPolymorphic(obj, receivers); | 4 | ||||
10951 | globalShape, &globalGuard); | 4 | ||||
11063 | InliningDecision decision = makeInliningDecision(commonGetter, callInfo); | 4 | ||||
11064 | switch (decision) { | 4 | ||||
11072 | MOZ_TRY_VAR(status, inlineScriptedCall(callInfo, commonGetter)); | 4 | ||||
11073 | if (status == InliningStatus_Inlined) { | 4 | ||||
11074 | *emitted = true; | 4 | ||||
11075 | return Ok(); | 4 | ||||
11276 | MOZ_ASSERT(barrier <= protoBarrier); | 2 | ||||
11816 | store = MStoreUnboxedScalar::New(alloc(), elements, scaledOffset, value, Scalar::Uint8, | 2 | ||||
11818 | DoesNotRequireMemoryBarrier, elementsOffset); | 2 | ||||
11819 | break; | 2 | ||||
11999 | if (NeedsPostBarrier(value)) | 2 | ||||
12000 | current->add(MPostWriteBarrier::New(alloc(), obj, value)); | 2 | ||||
12002 | MSetPropertyPolymorphic* ins = MSetPropertyPolymorphic::New(alloc(), obj, value, name); | 2 | ||||
12003 | current->add(ins); | 2 | ||||
12004 | current->push(value); | 2 | ||||
12006 | for (size_t i = 0; i < receivers.length(); i++) { | 2 | ||||
12007 | Shape* propShape = nullptr; | 2 | ||||
12008 | if (receivers[i].shape) { | 2 | ||||
12009 | propShape = receivers[i].shape->searchLinear(NameToId(name)); | 2 | ||||
12010 | MOZ_ASSERT(propShape); | 2 | ||||
12012 | if (!ins->addReceiver(receivers[i], propShape)) | 2 | ||||
12016 | if (objTypes->propertyNeedsBarrier(constraints(), NameToId(name))) | 2 | ||||
12017 | ins->setNeedsBarrier(); | 2 | ||||
12019 | MOZ_TRY(resumeAfter(ins)); | 2 | ||||
12021 | trackOptimizationOutcome(TrackedOutcome::Polymorphic); | 2 | ||||
12022 | *emitted = true; | 2 | ||||
12880 | return Ok(); | 2 | ||||
12982 | MInstanceOf* ins = MInstanceOf::New(alloc(), obj, protoObject); | 2 | ||||
12984 | current->add(ins); | 2 | ||||
12985 | current->push(ins); | 2 |
|
Times Different | |||||
1245 | if (!propTypes || !propTypes->hasType(TypeSet::GetValueType(val.value()))) | 6 | ||||
1345 | IonCacheIRCompiler::emitStoreDynamicSlot() | 2 | ||||
1347 | Register obj = allocator.useRegister(masm, reader.objOperandId()); | 2 | ||||
1348 | int32_t offset = int32StubField(reader.stubOffset()); | 2 | ||||
1349 | ConstantOrRegister val = allocator.useConstantOrRegister(masm, reader.valOperandId()); | 2 | ||||
1350 | AutoScratchRegister scratch(allocator, masm); | 2 | ||||
1352 | if (typeCheckInfo_->isSet()) { | 2 | ||||
1354 | if (!addFailurePath(&failure)) | 2 | ||||
1357 | EmitCheckPropertyTypes(masm, typeCheckInfo_, obj, val, *liveRegs_, failure->label()); | 2 | ||||
1360 | masm.loadPtr(Address(obj, NativeObject::offsetOfSlots()), scratch); | 2 | ||||
1361 | Address slot(scratch, offset); | 2 | ||||
1362 | EmitPreBarrier(masm, slot, MIRType::Value); | 2 | ||||
1363 | masm.storeConstantOrRegister(val, slot); | 2 | ||||
1364 | if (needsPostBarrier()) | 2 | ||||
1365 | emitPostBarrierSlot(obj, val, scratch); | 2 | ||||
2124 | if (updated || (typeCheckInfo && typeCheckInfo->needsTypeBarrier())) { | 4 | ||||
2128 | *attached = true; | 4 | ||||
2130 | return; | 4 |
|
Times Different | |||||
71 | trace(zone->barrierTracer()); | 2 | ||||
306 | if (!FetchName |
2 |
|
Times Different | |||||
211 | return "Bailout_NonObjectInput"; | 4 |
|
Times Different | |||||
232 | *pcRes = overridePc; | 10 | ||||
638 | if (inForOfIterClose) | 10 | ||||
641 | SettleOnTryNote(cx, tn, frame, ei, rfe, pc); | 10 | ||||
642 | rfe->kind = ResumeFromException::RESUME_FINALLY; | 10 | ||||
643 | rfe->target = script->baselineScript()->nativeCodeForPC(script, *pc); | 10 | ||||
645 | if (!cx->getPendingException(MutableHandleValue::fromMarkedLocation(&rfe->exception))) | 10 | ||||
647 | cx->clearPendingException(); | 10 | ||||
648 | return true; | 10 | ||||
1023 | if (where.stack) | 12 | ||||
1024 | return (uintptr_t*)((uint8_t*)this - where.slot); | 12 | ||||
1041 | TraceThisAndArguments(JSTracer* trc, const JitFrameIterator& frame) | 12 | ||||
1051 | : frame.jsFrame(); | 12 | ||||
1053 | if (!CalleeTokenIsFunction(layout->calleeToken())) | 12 | ||||
1054 | return; | 12 | ||||
1056 | size_t nargs = layout->numActualArgs(); | 12 | ||||
1057 | size_t nformals = 0; | 12 | ||||
1059 | JSFunction* fun = CalleeTokenToFunction(layout->calleeToken()); | 12 | ||||
1060 | if (!frame.isExitFrameLayout |
12 | ||||
1061 | !fun->nonLazyScript()->mayReadFrameArgsDirectly()) | 12 | ||||
1063 | nformals = fun->nargs(); | 12 | ||||
1066 | size_t newTargetOffset = Max(nargs, fun->nargs()); | 12 | ||||
1068 | Value* argv = layout->argv(); | 12 | ||||
1071 | TraceRoot(trc, argv, "ion-thisv"); | 12 | ||||
1074 | for (size_t i = nformals + 1; i < nargs + 1; i++) | 12 | ||||
1079 | if (CalleeTokenIsConstructing(layout->calleeToken())) | 12 | ||||
1097 | TraceIonJSFrame(JSTracer* trc, const JitFrameIterator& frame) | 12 | ||||
1099 | JitFrameLayout* layout = (JitFrameLayout*)frame.fp(); | 12 | ||||
1101 | layout->replaceCalleeToken(TraceCalleeToken(trc, layout->calleeToken())); | 12 | ||||
1103 | IonScript* ionScript = nullptr; | 12 | ||||
1104 | if (frame.checkInvalidation(&ionScript)) { | 12 | ||||
1110 | ionScript = frame.ionScriptFromCalleeToken(); | 12 | ||||
1113 | TraceThisAndArguments(trc, frame); | 12 | ||||
1115 | const SafepointIndex* si = ionScript->getSafepointIndex(frame.returnAddressToFp()); | 12 | ||||
1117 | SafepointReader safepoint(ionScript, si); | 12 | ||||
1123 | while (safepoint.getGcSlot(&entry)) { | 12 | ||||
1124 | uintptr_t* ref = layout->slotRef(entry); | 12 | ||||
1125 | TraceGenericPointerRoot(trc, reinterpret_cast |
12 | ||||
1128 | while (safepoint.getValueSlot(&entry)) { | 12 | ||||
1133 | uintptr_t* spill = frame.spillBase(); | 12 | ||||
1136 | for (GeneralRegisterBackwardIterator iter(safepoint.allGprSpills()); iter.more(); ++iter) { | 12 | ||||
1137 | --spill; | 12 | ||||
1138 | if (gcRegs.has(*iter)) | 12 | ||||
1139 | TraceGenericPointerRoot(trc, reinterpret_cast |
12 | ||||
1140 | else if (valueRegs.has(*iter)) | 12 | ||||
1160 | } | 12 | ||||
1199 | UpdateIonJSFrameForMinorGC(JSTracer* trc, const JitFrameIterator& frame) | 12 | ||||
1204 | JitFrameLayout* layout = (JitFrameLayout*)frame.fp(); | 12 | ||||
1206 | IonScript* ionScript = nullptr; | 12 | ||||
1207 | if (frame.checkInvalidation(&ionScript)) { | 12 | ||||
1212 | ionScript = frame.ionScriptFromCalleeToken(); | 12 | ||||
1215 | Nursery& nursery = ionScript->method()->zone()->group()->nursery(); | 12 | ||||
1217 | const SafepointIndex* si = ionScript->getSafepointIndex(frame.returnAddressToFp()); | 12 | ||||
1218 | SafepointReader safepoint(ionScript, si); | 12 | ||||
1221 | uintptr_t* spill = frame.spillBase(); | 12 | ||||
1222 | for (GeneralRegisterBackwardIterator iter(safepoint.allGprSpills()); iter.more(); ++iter) { | 12 | ||||
1223 | --spill; | 12 | ||||
1224 | if (slotsRegs.has(*iter)) | 12 | ||||
1230 | while (safepoint.getGcSlot(&entry)); | 12 | ||||
1231 | while (safepoint.getValueSlot(&entry)); | 12 | ||||
1237 | while (safepoint.getSlotsOrElementsSlot(&entry)) { | 12 | ||||
1241 | } | 12 | ||||
1419 | TraceRoot(trc, reinterpret_cast |
2 | ||||
1420 | break; | 2 | ||||
1509 | TraceIonJSFrame(trc, frames); | 12 | ||||
1510 | break; | 12 | ||||
1545 | UpdateIonJSFrameForMinorGC(trc, frames); | 12 |
|
Times Different | |||||
395 | calleeToken_ = calleeToken; | 12 |
|
Times Different | |||||
598 | for (size_t i = 0; i < moves_.length(); i++) { | 2 | ||||
599 | if (to == moves_[i].to()) { | 2 |
|
Times Different | |||||
57 | cx->zone()->group()->storeBuffer().putWholeCell(code); | 9 |
|
Times Different | |||||
88 | LIRGenerator::visitIsConstructing(MIsConstructing* ins) | 2 | ||||
90 | define(new(alloc()) LIsConstructing(), ins); | 2 | ||||
91 | } | 2 | ||||
143 | LIRGenerator::visitTableSwitch(MTableSwitch* tableswitch) | 2 | ||||
145 | MDefinition* opd = tableswitch->getOperand(0); | 2 | ||||
148 | MOZ_ASSERT(tableswitch->numSuccessors() > 0); | 2 | ||||
151 | if (tableswitch->numSuccessors() == 1) { | 2 | ||||
157 | if (opd->type() == MIRType::Value) { | 2 | ||||
164 | if (opd->type() != MIRType::Int32 && opd->type() != MIRType::Double) { | 2 | ||||
171 | LAllocation index; | 2 | ||||
172 | LDefinition tempInt; | 2 | ||||
173 | if (opd->type() == MIRType::Int32) { | 2 | ||||
174 | index = useRegisterAtStart(opd); | 2 | ||||
175 | tempInt = tempCopy(opd, 0); | 2 | ||||
180 | add(newLTableSwitch(index, tempInt, tableswitch)); | 2 | ||||
597 | LIRGenerator::visitApplyArray(MApplyArray* apply) | 2 | ||||
599 | MOZ_ASSERT(apply->getFunction()->type() == MIRType::Object); | 2 | ||||
602 | MOZ_ASSERT(CallTempReg0 != ArgumentsRectifierReg); | 2 | ||||
603 | MOZ_ASSERT(CallTempReg1 != ArgumentsRectifierReg); | 2 | ||||
606 | MOZ_ASSERT(CallTempReg2 != JSReturnReg_Type); | 2 | ||||
607 | MOZ_ASSERT(CallTempReg2 != JSReturnReg_Data); | 2 | ||||
609 | LApplyArrayGeneric* lir = new(alloc()) LApplyArrayGeneric( | 2 | ||||
610 | useFixedAtStart(apply->getFunction(), CallTempReg3), | 2 | ||||
612 | useBoxFixedAtStart(apply->getThis(), CallTempReg4, CallTempReg5), | 2 | ||||
614 | tempFixed(CallTempReg2)); // stack counter register | 2 | ||||
620 | assignSnapshot(lir, Bailout_NonJSFunctionCallee); | 2 | ||||
622 | defineReturn(lir, apply); | 2 | ||||
623 | assignSafepoint(lir, apply); | 2 | ||||
624 | } | 2 | ||||
1106 | tmp = LDefinition::BogusTemp(); | 2 | ||||
1107 | tmpToUnbox = LDefinition::BogusTemp(); | 2 | ||||
2263 | redefine(truncate, opd); | 2 | ||||
2264 | break; | 2 | ||||
3611 | value = useByteOpRegisterOrNonDoubleConstant(ins->value()); | 2 | ||||
3790 | LIRGenerator::visitSetPropertyPolymorphic(MSetPropertyPolymorphic* ins) | 2 | ||||
3792 | MOZ_ASSERT(ins->object()->type() == MIRType::Object); | 2 | ||||
3794 | if (ins->value()->type() == MIRType::Value) { | 2 | ||||
3802 | LAllocation value = useRegisterOrConstant(ins->value()); | 2 | ||||
3804 | new(alloc()) LSetPropertyPolymorphicT(useRegister(ins->object()), value, | 2 | ||||
3805 | ins->value()->type(), temp()); | 2 | ||||
3806 | assignSnapshot(lir, Bailout_ShapeGuard); | 2 | ||||
3807 | add(lir, ins); | 2 | ||||
3809 | } | 2 | ||||
4222 | LIRGenerator::visitInstanceOf(MInstanceOf* ins) | 2 | ||||
4224 | MDefinition* lhs = ins->getOperand(0); | 2 | ||||
4226 | MOZ_ASSERT(lhs->type() == MIRType::Value || lhs->type() == MIRType::Object); | 2 | ||||
4228 | if (lhs->type() == MIRType::Object) { | 2 | ||||
4233 | LInstanceOfV* lir = new(alloc()) LInstanceOfV(useBox(lhs)); | 2 | ||||
4234 | define(lir, ins); | 2 | ||||
4235 | assignSafepoint(lir, ins); | 2 | ||||
4237 | } | 2 |
|
Times Different | |||||
3347 | MInstruction* ins = MIsConstructing::New(alloc()); | 2 | ||||
3348 | current->add(ins); | 2 | ||||
3349 | current->push(ins); | 2 | ||||
3350 | return InliningStatus_Inlined; | 2 |
|
Times Different | |||||
3886 | MOZ_ASSERT(!(lhs == MIRType::Boolean && rhs == MIRType::Boolean)); | 2 | ||||
3958 | type = JSTYPE_OBJECT; | 2 | ||||
3959 | break; | 2 | ||||
4507 | if (!typeOf->input()->mightBeType(MIRType::Undefined) && | 2 | ||||
4508 | !typeOf->inputMaybeCallableOrEmulatesUndefined()) | 2 | ||||
4510 | *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE); | 2 | ||||
4511 | return true; | 2 | ||||
4519 | if (!typeOf->input()->mightBeType(MIRType::Int32) && | 2 | ||||
4520 | !typeOf->input()->mightBeType(MIRType::Float32) && | 2 | ||||
4521 | !typeOf->input()->mightBeType(MIRType::Double)) | 2 | ||||
4523 | *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE); | 2 | ||||
4524 | return true; | 2 | ||||
4528 | *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE); | 2 | ||||
4529 | return true; | 2 | ||||
4532 | if (!typeOf->input()->mightBeType(MIRType::Symbol)) { | 2 | ||||
4533 | *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE); | 2 | ||||
4534 | return true; | 2 | ||||
4593 | MOZ_ASSERT(op == JSOP_STRICTEQ || op == JSOP_STRICTNE); | 2 | ||||
4594 | MOZ_ASSERT(rhs()->type() == MIRType::Boolean); | 2 | ||||
4595 | MOZ_ASSERT(lhs()->type() != MIRType::Boolean, "Should use Int32 comparison"); | 2 | ||||
4597 | if (!lhs()->mightBeType(MIRType::Boolean)) { | 2 | ||||
4598 | *result = (op == JSOP_STRICTNE); | 2 | ||||
4599 | return true; | 2 | ||||
4610 | *result = (op == JSOP_STRICTNE); | 2 | ||||
4611 | return true; | 2 | ||||
5641 | MSetPropertyPolymorphic::appendRoots(MRootList& roots) const | 2 | ||||
5643 | if (!roots.append(name_)) | 2 | ||||
5646 | for (const PolymorphicEntry& entry : receivers_) { | 2 | ||||
5647 | if (!entry.appendRoots(roots)) | 2 | ||||
5883 | return this; | 2 | ||||
6314 | return BarrierKind::TypeSet; | 2 |
|
Times Different | |||||
2839 | MIsConstructing() { | 2 | ||||
2840 | setResultType(MIRType::Boolean); | 2 | ||||
2841 | setMovable(); | 2 | ||||
2842 | } | 2 | ||||
2845 | INSTRUCTION_HEADER(IsConstructing) | 2 | ||||
2846 | TRIVIAL_NEW_WRAPPERS | 2 | ||||
2848 | bool congruentTo(const MDefinition* ins) const override { | 2 | ||||
2849 | return congruentIfOperandsEqual(ins); | 2 | ||||
2851 | AliasSet getAliasSet() const override { | 2 | ||||
2852 | return AliasSet::None(); | 2 | ||||
2934 | void replaceSuccessor(size_t i, MBasicBlock* successor) override { | 2 | ||||
2935 | MOZ_ASSERT(i < numSuccessors()); | 2 | ||||
2936 | successors_[i] = successor; | 2 | ||||
2937 | } | 2 | ||||
2948 | return getSuccessor(0); | 2 | ||||
4321 | MApplyArray(WrappedFunction* target, MDefinition* fun, MDefinition* elements, MDefinition* self) | 2 | ||||
4322 | : target_(target) | 2 | ||||
4324 | initOperand(0, fun); | 2 | ||||
4325 | initOperand(1, elements); | 2 | ||||
4326 | initOperand(2, self); | 2 | ||||
4327 | setResultType(MIRType::Value); | 2 | ||||
4328 | } | 2 | ||||
4331 | INSTRUCTION_HEADER(ApplyArray) | 2 | ||||
4332 | TRIVIAL_NEW_WRAPPERS | 2 | ||||
4333 | NAMED_OPERANDS((0, getFunction), (1, getElements), (2, getThis)) | 2 | ||||
4340 | bool possiblyCalls() const override { | 2 | ||||
4341 | return true; | 2 | ||||
4344 | bool appendRoots(MRootList& roots) const override { | 2 | ||||
4345 | if (target_) | 2 | ||||
11001 | MSetPropertyPolymorphic(TempAllocator& alloc, MDefinition* obj, MDefinition* value, | 2 | ||||
11006 | needsBarrier_(false) | 2 | ||||
11008 | } | 2 | ||||
11011 | INSTRUCTION_HEADER(SetPropertyPolymorphic) | 2 | ||||
11012 | NAMED_OPERANDS((0, object), (1, value)) | 2 | ||||
11014 | static MSetPropertyPolymorphic* New(TempAllocator& alloc, MDefinition* obj, MDefinition* value, | 2 | ||||
11016 | return new(alloc) MSetPropertyPolymorphic(alloc, obj, value, name); | 2 | ||||
11019 | MOZ_MUST_USE bool addReceiver(const ReceiverGuard& receiver, Shape* shape) { | 2 | ||||
11021 | entry.receiver = receiver; | 2 | ||||
11022 | entry.shape = shape; | 2 | ||||
11023 | return receivers_.append(entry); | 2 | ||||
11026 | return receivers_.length(); | 2 | ||||
11029 | return receivers_[i].receiver; | 2 | ||||
11032 | return receivers_[i].shape; | 2 | ||||
11041 | needsBarrier_ = true; | 2 | ||||
11043 | AliasSet getAliasSet() const override { | 2 | ||||
11044 | bool hasUnboxedStore = false; | 2 | ||||
11045 | for (size_t i = 0; i < numReceivers(); i++) { | 2 | ||||
11046 | if (!shape(i)) { | 2 | ||||
11054 | (hasUnboxedStore ? AliasSet::UnboxedElement : 0)); | 2 | ||||
12643 | protoObj_(proto) | 2 | ||||
12645 | setResultType(MIRType::Boolean); | 2 | ||||
12649 | INSTRUCTION_HEADER(InstanceOf) | 2 | ||||
12650 | TRIVIAL_NEW_WRAPPERS | 2 | ||||
12653 | return protoObj_; | 2 | ||||
12656 | bool appendRoots(MRootList& roots) const override { | 2 | ||||
12657 | return roots.append(protoObj_); | 2 | ||||
14713 | op = op->toBox()->input(); | 2 |
|
Times Different | |||||
256 | if ((*returnAccumulator_)[i] == block) | 2 | ||||
257 | returnAccumulator_->erase(returnAccumulator_->begin() + i); | 2 | ||||
259 | i++; | 2 |
|
Times Different | |||||
184 | comment("emit GC pointer checks"); | 2 | ||||
185 | lastBranch.emit(*this); | 2 | ||||
478 | if (output.type() == MIRType::Double) { | 2 | ||||
500 | load32(address, outReg); | 2 |
|
Times Different | |||||
1688 | store8(value, dest); | 2 | ||||
1689 | break; | 2 |
|
Times Different | |||||
608 | wrapAroundToBoolean(); | 2 | ||||
609 | break; | 2 | ||||
2478 | Range::wrapAroundToBoolean() | 2 | ||||
2480 | wrapAroundToInt32(); | 2 | ||||
2481 | if (!isBoolean()) | 2 | ||||
2483 | MOZ_ASSERT(isBoolean()); | 2 | ||||
2484 | } | 2 | ||||
2738 | MTruncateToInt32::operandTruncateKind(size_t index) const | 2 | ||||
2741 | return Truncate; | 2 |
|
Times Different | |||||
520 | bool isBoolean() const { | 2 | ||||
521 | return lower() >= 0 && upper() <= 1 && | 2 | ||||
522 | !canHaveFractionalPart_ && | 2 | ||||
523 | !canBeNegativeZero_; | 2 |
|
Times Different | |||||
554 | RNot::RNot(CompactBufferReader& reader) | 2 | ||||
1174 | MTypeOf::writeRecoverData(CompactBufferWriter& writer) const | 2 | ||||
1176 | MOZ_ASSERT(canRecoverOnBailout()); | 2 | ||||
1177 | writer.writeUnsigned(uint32_t(RInstruction::Recover_TypeOf)); | 2 | ||||
1178 | return true; | 2 |
|
Times Different | |||||
328 | RINSTRUCTION_HEADER_NUM_OP_(Not, 1) | 2 |
|
Times Different | |||||
444 | SafepointReader::getSlotFromBitmap(SafepointSlotEntry* entry) | 12 | ||||
446 | while (currentSlotChunk_ == 0) { | 12 | ||||
448 | if (currentSlotsAreStack_) { | 12 | ||||
449 | if (nextSlotChunkNumber_ == BitSet::RawLengthForBits(frameSlots_)) { | 12 | ||||
450 | nextSlotChunkNumber_ = 0; | 12 | ||||
451 | currentSlotsAreStack_ = false; | 12 | ||||
452 | continue; | 12 | ||||
454 | } else if (nextSlotChunkNumber_ == BitSet::RawLengthForBits(argumentSlots_)) { | 12 | ||||
459 | currentSlotChunk_ = stream_.readUnsigned(); | 12 | ||||
460 | nextSlotChunkNumber_++; | 12 | ||||
465 | uint32_t bit = FloorLog2(currentSlotChunk_); | 12 | ||||
466 | currentSlotChunk_ &= ~(1 << bit); | 12 | ||||
470 | entry->stack = currentSlotsAreStack_; | 12 | ||||
471 | entry->slot = (((nextSlotChunkNumber_ - 1) * BitSet::BitsPerWord) + bit) * sizeof(intptr_t); | 12 | ||||
472 | return true; | 12 | ||||
476 | SafepointReader::getGcSlot(SafepointSlotEntry* entry) | 12 | ||||
478 | if (getSlotFromBitmap(entry)) | 12 | ||||
481 | return false; | 12 | ||||
488 | currentSlotChunk_ = 0; | 12 | ||||
489 | nextSlotChunkNumber_ = 0; | 12 | ||||
490 | currentSlotsAreStack_ = true; | 12 | ||||
494 | SafepointReader::getValueSlot(SafepointSlotEntry* entry) | 12 | ||||
496 | if (getSlotFromBitmap(entry)) | 12 | ||||
499 | return false; | 12 | ||||
508 | nunboxSlotsRemaining_ = 0; | 12 | ||||
551 | slotsOrElementsSlotsRemaining_ = stream_.readUnsigned(); | 12 | ||||
555 | SafepointReader::getSlotsOrElementsSlot(SafepointSlotEntry* entry) | 12 | ||||
557 | if (!slotsOrElementsSlotsRemaining_--) | 12 |
|
Times Different | |||||
98 | return LiveGeneralRegisterSet(gcSpills_); | 12 | ||||
101 | return LiveGeneralRegisterSet(slotsOrElementsSpills_); | 12 | ||||
104 | return LiveGeneralRegisterSet(valueSpills_); | 12 |
|
Times Different | |||||
104 | IsLambdaEscaped(MInstruction* lambda, JSObject* obj) | 2 | ||||
106 | MOZ_ASSERT(lambda->isLambda() || lambda->isLambdaArrow()); | 2 | ||||
107 | JitSpewDef(JitSpew_Escape, "Check lambda\n", lambda); | 2 | ||||
108 | JitSpewIndent spewIndent(JitSpew_Escape); | 2 | ||||
112 | for (MUseIterator i(lambda->usesBegin()); i != lambda->usesEnd(); i++) { | 2 | ||||
113 | MNode* consumer = (*i)->consumer(); | 2 | ||||
114 | if (!consumer->isDefinition()) { | 2 | ||||
123 | MDefinition* def = consumer->toDefinition(); | 2 | ||||
124 | if (!def->isFunctionEnvironment()) { | 2 | ||||
125 | JitSpewDef(JitSpew_Escape, "is escaped by\n", def); | 2 | ||||
126 | return true; | 2 | ||||
248 | if (IsLambdaEscaped(def->toInstruction(), obj)) { | 2 | ||||
249 | JitSpewDef(JitSpew_Escape, "is indirectly escaped by\n", def); | 2 | ||||
250 | return true; | 2 |
|
Times Different | |||||
280 | ICTypeUpdate_SingleObject* updateStub = toTypeUpdate_SingleObject(); | 2 | ||||
281 | TraceEdge(trc, &updateStub->object(), "baseline-update-singleton"); | 2 | ||||
282 | break; | 2 | ||||
754 | if (!BitLsh(cx, lhs, rhs, &result)) | 2 | ||||
756 | ret.setInt32(result); | 2 | ||||
757 | break; | 2 |
|
Times Different | |||||
774 | state_.setInvalid(); | 6 |
|
Times Different | |||||
151 | def->getOperand(0)->type() == MIRType::Boolean) | 2 | ||||
160 | MDefinition* rhs = def->getOperand(1); | 2 | ||||
161 | if (rhs->type() != MIRType::Boolean) { | 2 | ||||
169 | MOZ_ASSERT(def->getOperand(0)->type() != MIRType::Boolean); | 2 | ||||
170 | MOZ_ASSERT(def->getOperand(1)->type() == MIRType::Boolean); | 2 | ||||
286 | MOZ_ASSERT(inputType != MIRType::Value); | 2 | ||||
287 | ins->replaceOperand(0, BoxAt(alloc, ins, ins->getOperand(0))); | 2 | ||||
288 | return true; | 2 | ||||
924 | InstanceOfPolicy::adjustInputs(TempAllocator& alloc, MInstruction* def) | 2 | ||||
927 | if (def->getOperand(0)->type() != MIRType::Object) | 2 | ||||
928 | if (!BoxPolicy<0>::staticAdjustInputs(alloc, def)) | 2 | ||||
994 | value = MTruncateToInt32::New(alloc, value); | 2 | ||||
995 | ins->block()->insertBefore(ins, value->toInstruction()); | 2 | ||||
1019 | ins->replaceOperand(valueOperand, value); | 2 |
|
Times Different | |||||
948 | DebugAfterYield(JSContext* cx, BaselineFrame* frame) | 10 | ||||
952 | if (frame->script()->isDebuggee()) | 10 | ||||
954 | return true; | 10 | ||||
958 | GeneratorThrowOrClose(JSContext* cx, BaselineFrame* frame, Handle |
10 | ||||
964 | JSScript* script = frame->script(); | 10 | ||||
965 | uint32_t offset = script->yieldAndAwaitOffsets()[genObj->yieldAndAwaitIndex()]; | 10 | ||||
966 | frame->setOverridePc(script->offsetToPC(offset)); | 10 | ||||
968 | MOZ_ALWAYS_TRUE(DebugAfterYield(cx, frame)); | 10 | ||||
969 | MOZ_ALWAYS_FALSE(js::GeneratorThrowOrClose(cx, frame, genObj, arg, resumeKind)); | 10 | ||||
970 | return false; | 10 | ||||
1416 | ObjectIsCallable(JSObject* obj) | 4 | ||||
1418 | return obj->isCallable(); | 4 | ||||
1441 | MarkObjectFromIon(JSRuntime* rt, JSObject** objp) | 6 | ||||
1443 | MOZ_ASSERT(*objp); | 6 | ||||
1444 | TraceManuallyBarrieredEdge(&rt->gc.marker, objp, "write barrier"); | 6 | ||||
1445 | } | 6 |
|
Times Different | |||||
485 | return &patchAt_; | 2 | ||||
488 | return &target_; | 2 |
|
Times Different | |||||
136 | return a ? ToRegister(a) : InvalidReg; | 2 | ||||
286 | CodeGeneratorShared::ToAddress(const LAllocation& a) | 2 | ||||
288 | MOZ_ASSERT(a.isMemory()); | 2 | ||||
289 | return Address(masm.getStackPointer(), ToStackOffset(&a)); | 2 | ||||
295 | return ToAddress(*a); | 2 |
|
Times Different | |||||
963 | class LIsConstructing : public LInstructionHelper<1, 0, 0> | 2 | ||||
966 | LIR_HEADER(IsConstructing) | 2 | ||||
2235 | LIR_HEADER(ApplyArrayGeneric) | 2 | ||||
2237 | LApplyArrayGeneric(const LAllocation& func, const LAllocation& elements, | 2 | ||||
2240 | { | 2 | ||||
2241 | setOperand(0, func); | 2 | ||||
2242 | setOperand(1, elements); | 2 | ||||
2243 | setBoxOperand(ThisIndex, thisv); | 2 | ||||
2244 | setTemp(0, tmpobjreg); | 2 | ||||
2245 | setTemp(1, tmpcopy); | 2 | ||||
2246 | } | 2 | ||||
2249 | return mir_->toApplyArray(); | 2 | ||||
2256 | return mir()->getSingleTarget(); | 2 | ||||
2260 | return getOperand(0); | 2 | ||||
2263 | return getOperand(1); | 2 | ||||
2268 | return getOperand(1); | 2 | ||||
2273 | return getTemp(0); | 2 | ||||
2276 | return getTemp(1); | 2 | ||||
6834 | LIR_HEADER(SetPropertyPolymorphicT) | 2 | ||||
6836 | LSetPropertyPolymorphicT(const LAllocation& obj, const LAllocation& value, MIRType valueType, | 2 | ||||
6838 | : valueType_(valueType) | 2 | ||||
6840 | setOperand(0, obj); | 2 | ||||
6841 | setOperand(1, value); | 2 | ||||
6842 | setTemp(0, temp); | 2 | ||||
6843 | } | 2 | ||||
6846 | return getOperand(0); | 2 | ||||
6849 | return getOperand(1); | 2 | ||||
6852 | return getTemp(0); | 2 | ||||
6858 | return mir_->toSetPropertyPolymorphic(); | 2 | ||||
6860 | const char* extraName() const { | 2 | ||||
6861 | return StringFromMIRType(valueType_); | 2 | ||||
7933 | LIR_HEADER(InstanceOfV) | 2 | ||||
7934 | explicit LInstanceOfV(const LBoxAllocation& lhs) { | 2 | ||||
7935 | setBoxOperand(LHS, lhs); | 2 | ||||
7936 | } | 2 | ||||
7939 | return mir_->toInstanceOf(); | 2 |
|
Times Different | |||||
379 | (as->isConstant() && | 2 | ||||
380 | (def->type() == MIRType::Int32 || def->type() == MIRType::Boolean) && | 2 | ||||
381 | (as->type() == MIRType::Int32 || as->type() == MIRType::Boolean)))) | 2 | ||||
385 | if (as->type() == MIRType::Int32) | 2 | ||||
388 | replacement = MConstant::New(alloc(), Int32Value(as->toConstant()->toBoolean())); | 2 | ||||
389 | def->block()->insertBefore(def->toInstruction(), replacement); | 2 | ||||
390 | emitAtUses(replacement->toInstruction()); | 2 | ||||
645 | LIRGeneratorShared::tempCopy(MDefinition* input, uint32_t reusedInput) | 2 | ||||
647 | MOZ_ASSERT(input->virtualRegister()); | 2 | ||||
648 | LDefinition t = temp(LDefinition::TypeFrom(input->type()), LDefinition::MUST_REUSE_INPUT); | 2 | ||||
650 | return t; | 2 |
|
Times Different | |||||
39 | LIRGeneratorX64::useByteOpRegisterOrNonDoubleConstant(MDefinition* mir) | 2 | ||||
41 | return useRegisterOrNonDoubleConstant(mir); | 2 |
|
Times Different | |||||
442 | void cmpPtr(Register lhs, const ImmWord rhs) { | 2 | ||||
443 | ScratchRegisterScope scratch(asMasm()); | 2 | ||||
444 | MOZ_ASSERT(lhs != scratch); | 2 | ||||
445 | if (intptr_t(rhs.value) <= INT32_MAX && intptr_t(rhs.value) >= INT32_MIN) { | 2 | ||||
451 | } | 2 | ||||
453 | cmpPtr(lhs, ImmWord(uintptr_t(rhs.value))); | 2 |
|
Times Different | |||||
128 | masm.unboxInt32(R0, ExtractTemp0); | 2 | ||||
129 | masm.unboxInt32(R1, ecx); // Unboxing R1 to ecx, clobbers R0. | 2 | ||||
130 | masm.shll_cl(ExtractTemp0); | 2 | ||||
131 | masm.boxValue(JSVAL_TYPE_INT32, ExtractTemp0, R0.valueReg()); | 2 | ||||
132 | break; | 2 |
|
Times Different | |||||
760 | MOZ_CRASH("NYI: x64 callVM should not be used with 128bits values."); | 2 |
|
Times Different | |||||
59 | X86Encoding::SetPointer(buffer + offset, v.bitsAsPunboxPointer()); | 9 | ||||
125 | blackbox = dump; | 2 | ||||
126 | blackbox[0] = uintptr_t(0xABCD4321); | 2 | ||||
127 | blackbox[1] = uintptr_t(len); | 2 | ||||
128 | blackbox[2] = uintptr_t(startOffset); | 2 | ||||
129 | blackbox[3] = uintptr_t(endOffset); | 2 | ||||
130 | blackbox[4] = uintptr_t(0xFFFF8888); | 2 | ||||
131 | MOZ_CRASH("Corrupt code buffer"); | 2 |
|
Times Different | |||||
274 | embedsNurseryPointers_ = true; | 9 | ||||
458 | masm.haltingAlign(alignment); | 2 | ||||
463 | void writeCodePointer(CodeOffset* label) { | 2 | ||||
465 | masm.jumpTablePointer(LabelBase::INVALID_OFFSET); | 2 | ||||
466 | label->bind(masm.size()); | 2 | ||||
467 | } | 2 | ||||
945 | masm.jmp_m(op.disp(), op.base(), op.index(), op.scale()); | 2 | ||||
946 | break; | 2 | ||||
1702 | masm.shll_CLr(dest.encoding()); | 2 |
|
Times Different | |||||
1560 | void shll_CLr(RegisterID dst) | 2 | ||||
1562 | spew("shll %%cl, %s", GPReg32Name(dst)); | 2 | ||||
1563 | m_formatter.oneByteOp(OP_GROUP2_EvCL, dst, GROUP2_OP_SHL); | 2 | ||||
1564 | } | 2 | ||||
2625 | void jmp_m(int32_t offset, RegisterID base, RegisterID index, int scale) { | 2 | ||||
2626 | spew("jmp *" MEM_obs, ADDR_obs(offset, base, index, scale)); | 2 | ||||
2627 | m_formatter.oneByteOp(OP_GROUP5_Ev, offset, base, index, scale, GROUP5_OP_JMPN); | 2 | ||||
2628 | } | 2 | ||||
3762 | void jumpTablePointer(uintptr_t ptr) | 2 | ||||
3765 | spew(".quad 0x%" PRIxPTR, ptr); | 2 | ||||
3769 | m_formatter.jumpTablePointer(ptr); | 2 | ||||
3770 | } | 2 | ||||
5114 | void jumpTablePointer(uintptr_t ptr) | 2 | ||||
5116 | m_buffer.ensureSpace(sizeof(uintptr_t)); | 2 | ||||
5118 | m_buffer.putInt64Unchecked(ptr); | 2 | ||||
5122 | } | 2 |
|
Times Different | |||||
1811 | void accept(CodeGeneratorX86Shared* codegen) { | 2 | ||||
1812 | codegen->visitOutOfLineTableSwitch(this); | 2 | ||||
1813 | } | 2 | ||||
1817 | : mir_(mir) | 2 | ||||
1825 | return &jumpLabel_; | 2 | ||||
1830 | CodeGeneratorX86Shared::visitOutOfLineTableSwitch(OutOfLineTableSwitch* ool) | 2 | ||||
1832 | MTableSwitch* mir = ool->mir(); | 2 | ||||
1834 | masm.haltingAlign(sizeof(void*)); | 2 | ||||
1835 | masm.use(ool->jumpLabel()->target()); | 2 | ||||
1836 | masm.addCodeLabel(*ool->jumpLabel()); | 2 | ||||
1838 | for (size_t i = 0; i < mir->numCases(); i++) { | 2 | ||||
1839 | LBlock* caseblock = skipTrivialBlocks(mir->getCase(i))->lir(); | 2 | ||||
1840 | Label* caseheader = caseblock->label(); | 2 | ||||
1841 | uint32_t caseoffset = caseheader->offset(); | 2 | ||||
1846 | masm.writeCodePointer(cl.patchAt()); | 2 | ||||
1847 | cl.target()->bind(caseoffset); | 2 | ||||
1848 | masm.addCodeLabel(cl); | 2 | ||||
1850 | } | 2 | ||||
1853 | CodeGeneratorX86Shared::emitTableSwitchDispatch(MTableSwitch* mir, Register index, Register base) | 2 | ||||
1855 | Label* defaultcase = skipTrivialBlocks(mir->getDefault())->lir()->label(); | 2 | ||||
1858 | if (mir->low() != 0) | 2 | ||||
1862 | int32_t cases = mir->numCases(); | 2 | ||||
1863 | masm.cmp32(index, Imm32(cases)); | 2 | ||||
1864 | masm.j(AssemblerX86Shared::AboveOrEqual, defaultcase); | 2 | ||||
1869 | OutOfLineTableSwitch* ool = new(alloc()) OutOfLineTableSwitch(mir); | 2 | ||||
1870 | addOutOfLineCode(ool, mir); | 2 | ||||
1873 | masm.mov(ool->jumpLabel()->patchAt(), base); | 2 | ||||
1877 | masm.jmp(pointer); | 2 | ||||
1878 | } | 2 |
|
Times Different | |||||
148 | void testNullEmitBranch(Assembler::Condition cond, const ValueOperand& value, | 2 | ||||
151 | cond = masm.testNull(cond, value); | 2 | ||||
152 | emitBranch(cond, ifTrue, ifFalse); | 2 | ||||
153 | } | 2 |
|
Times Different | |||||
247 | LIR_HEADER(TableSwitch) | 2 | ||||
249 | LTableSwitch(const LAllocation& in, const LDefinition& inputCopy, | 2 | ||||
251 | { | 2 | ||||
252 | setOperand(0, in); | 2 | ||||
253 | setTemp(0, inputCopy); | 2 | ||||
254 | setTemp(1, jumpTablePointer); | 2 | ||||
255 | setMir(ins); | 2 | ||||
256 | } | 2 | ||||
259 | return mir_->toTableSwitch(); | 2 | ||||
263 | return getOperand(0); | 2 | ||||
269 | return getTemp(1); | 2 |
|
Times Different | |||||
23 | LIRGeneratorX86Shared::newLTableSwitch(const LAllocation& in, const LDefinition& inputCopy, | 2 | ||||
26 | return new(alloc()) LTableSwitch(in, inputCopy, temp(), tableswitch); | 2 |
|
Times Different | |||||
218 | MacroAssembler::sub32(const Address& src, Register dest) | 2 | ||||
220 | subl(Operand(src), dest); | 2 | ||||
221 | } | 2 |
|
Times Different | |||||
163 | void cmp32(const Address& lhs, Imm32 rhs) { | 2 | ||||
164 | cmp32(Operand(lhs), rhs); | 2 | ||||
165 | } | 2 |
|
Times Different | |||||
126 | inCycle_ = false; | 4 | ||||
127 | continue; | 4 |
|
Times Different | |||||
2549 | JS_DefineElement(JSContext* cx, HandleObject obj, uint32_t index, uint32_t valueArg, | 7 | ||||
2552 | Value value = NumberValue(valueArg); | 7 | ||||
2554 | attrs, getter, setter); | 7 | ||||
6085 | JS_ReportErrorFlagsAndNumberUC(JSContext* cx, unsigned flags, | 2 | ||||
6092 | AssertHeapIsIdle(); | 2 | ||||
6093 | va_start(ap, errorNumber); | 2 | ||||
6095 | errorNumber, ArgumentsAreUnicode, ap); | 2 | ||||
6096 | va_end(ap); | 2 | ||||
6097 | return ok; | 2 |
|
Times Different | |||||
3740 | } | 12 |
|
Times Different | |||||
267 | p = rt->atomsAddedWhileSweeping()->lookup(lookup); | 2 | ||||
376 | MOZ_ASSERT(rt->atomsZone(lock)->isGCSweeping()); | 2 | ||||
377 | p = atomsAddedWhileSweeping->lookupForAdd(lookup); | 2 | ||||
381 | if (!p) { | 2 | ||||
382 | if (AtomSet::AddPtr p2 = atoms.lookupForAdd(lookup)) { | 2 | ||||
383 | JSAtom* atom = p2->asPtrUnbarriered(); | 2 | ||||
384 | if (!IsAboutToBeFinalizedUnbarriered(&atom)) | 2 | ||||
385 | p = p2; | 2 | ||||
605 | if (!atom && !allowGC) { | 4 |
|
Times Different | |||||
304 | CallWarningReporter(cx, reportp); | 2 |
|
Times Different | |||||
1459 | cx_->compartment()->objectMetadataState = prevState_; | 12 |
|
Times Different | |||||
278 | MOZ_ASSERT(!(bxe[1] & ~mask)); | 8 | ||||
279 | if (k) | 8 | ||||
280 | result |= bxe[1] << (32 - k); | 8 | ||||
474 | if (j > 0) | 7 | ||||
493 | digit++; | 12 | ||||
497 | digit++; | 10 | ||||
498 | done = true; | 10 |
|
Times Different | |||||
358 | explicit SuppressErrorsGuard(JSContext* cx) | 2 | ||||
360 | prevReporter(JS::SetWarningReporter(cx, nullptr)), | 2 | ||||
361 | prevState(cx) | 2 | ||||
362 | {} | 2 | ||||
364 | ~SuppressErrorsGuard() | 2 | ||||
365 | { | 2 | ||||
366 | JS::SetWarningReporter(cx, prevReporter); | 2 | ||||
367 | } | 2 | ||||
382 | js::ComputeStackString(JSContext* cx) | 2 | ||||
384 | SuppressErrorsGuard seg(cx); | 2 | ||||
386 | RootedObject stack(cx); | 2 | ||||
387 | if (!CaptureStack(cx, &stack)) | 2 | ||||
390 | RootedString str(cx); | 2 | ||||
391 | if (!BuildStackString(cx, stack, &str)) | 2 | ||||
394 | return str.get(); | 2 |
|
Times Different | |||||
1757 | gcTriggerBytes_ -= amount; | 4 | ||||
1812 | FinishGC(cx); | 4 | ||||
4705 | ZoneComponentFinder::mergeGroups(currentSweepGroup); | 5 | ||||
4708 | MOZ_ASSERT(!isIncremental); | 5 | ||||
4709 | for (GCSweepGroupIter zone(rt); !zone.done(); zone.next()) { | 5 | ||||
4710 | MOZ_ASSERT(!zone->gcNextGraphComponent); | 5 | ||||
4711 | MOZ_ASSERT(zone->isGCMarking()); | 5 | ||||
4712 | zone->setNeedsIncrementalBarrier(false); | 5 | ||||
4713 | zone->setGCState(Zone::NoGC); | 5 | ||||
4714 | zone->gcGrayRoots().clearAndFree(); | 5 | ||||
4717 | for (GCCompartmentGroupIter comp(rt); !comp.done(); comp.next()) | 5 | ||||
4718 | ResetGrayList(comp); | 5 | ||||
4720 | abortSweepAfterCurrentGroup = false; | 5 | ||||
4721 | currentSweepGroup = nullptr; | 5 | ||||
5403 | arenasAllocatedDuringSweep = arena->getNextAllocDuringSweep(); | 9 | ||||
5404 | arena->unsetAllocDuringSweep(); | 9 | ||||
5455 | incrementalSweptArenaKind = thingKind; | 9 | ||||
5456 | incrementalSweptArenas = sweepList.toArenaList(); | 9 | ||||
5457 | return false; | 9 | ||||
5618 | return NotFinished; | 11 | ||||
5631 | if (!atomsTable->putNew(AtomHasher::Lookup(r.front().asPtrUnbarriered()), r.front())) | 2 | ||||
6110 | marker.reset(); | 7 | ||||
6112 | for (CompartmentsIter c(rt, SkipAtoms); !c.done(); c.next()) | 7 | ||||
6113 | c->scheduledForDestruction = false; | 7 | ||||
6116 | abortSweepAfterCurrentGroup = true; | 7 | ||||
6119 | bool wasCompacting = isCompacting; | 7 | ||||
6120 | isCompacting = false; | 7 | ||||
6123 | incrementalCollectSlice(unlimited, JS::gcreason::RESET, lock); | 7 | ||||
6125 | isCompacting = wasCompacting; | 7 | ||||
6128 | gcstats::AutoPhase ap(stats(), gcstats::PhaseKind::WAIT_BACKGROUND_THREAD); | 7 | ||||
6129 | rt->gc.waitBackgroundSweepOrAllocEnd(); | 7 | ||||
6792 | return true; | 8 | ||||
6905 | GCRuntime::finishGC(JS::gcreason::Reason reason) | 4 | ||||
6907 | MOZ_ASSERT(isIncrementalGCInProgress()); | 4 | ||||
6912 | if (!IsOOMReason(initialReason)) { | 4 | ||||
6913 | if (incrementalState == State::Compact) { | 4 | ||||
6915 | return; | 4 | ||||
6918 | isCompacting = false; | 4 | ||||
6921 | collect(false, SliceBudget::unlimited(), reason); | 4 | ||||
7034 | return; | 4 | ||||
7105 | JS::PrepareForIncrementalGC(cx); | 4 | ||||
7106 | JS::FinishIncrementalGC(cx, JS::gcreason::API); | 4 | ||||
7735 | JS::FinishIncrementalGC(JSContext* cx, gcreason::Reason reason) | 4 | ||||
7737 | cx->runtime()->gc.finishGC(reason); | 4 | ||||
7738 | } | 4 |
|
Times Different | |||||
513 | *other.cursorp_ = *cursorp_; | 9 | ||||
514 | *cursorp_ = other.head_; | 9 | ||||
515 | cursorp_ = other.cursorp_; | 9 | ||||
516 | check(); | 9 | ||||
517 | return *this; | 9 | ||||
698 | return incrementalSweptArenas.ref().head(); | 3 |
|
Times Different | |||||
67 | addPtr = table.lookupForAdd(key); | 5 |
|
Times Different | |||||
1743 | a->traceChildren(zone->barrierTracer()); | 6 | ||||
1744 | b->traceChildren(zone->barrierTracer()); | 6 |
|
Times Different | |||||
936 | uint32_t defaultOffset = offset + GET_JUMP_OFFSET(pc); | 4 | ||||
937 | jsbytecode* pc2 = pc + JUMP_OFFSET_LEN; | 4 | ||||
938 | int32_t low = GET_JUMP_OFFSET(pc2); | 4 | ||||
939 | pc2 += JUMP_OFFSET_LEN; | 4 | ||||
940 | int32_t high = GET_JUMP_OFFSET(pc2); | 4 | ||||
941 | pc2 += JUMP_OFFSET_LEN; | 4 | ||||
943 | if (!addJump(defaultOffset, &nextOffset, stackDepth, offsetStack, | 4 | ||||
944 | pc, JumpKind::SwitchDefault)) | 4 | ||||
949 | for (int32_t i = low; i <= high; i++) { | 4 | ||||
950 | uint32_t targetOffset = offset + GET_JUMP_OFFSET(pc2); | 4 | ||||
951 | if (targetOffset != offset) { | 4 | ||||
952 | if (!addJump(targetOffset, &nextOffset, stackDepth, offsetStack, | 4 | ||||
953 | pc, JumpKind::SwitchCase)) | 4 | ||||
958 | pc2 += JUMP_OFFSET_LEN; | 4 | ||||
1883 | return decompilePCForStackOperand(pc, -int32_t(GET_ARGC(pc) + 2)) && | 4 | ||||
1884 | write("(...)"); | 4 |
|
Times Different | |||||
1976 | return; | 2 |
|
Times Different | |||||
4466 | if (u != 0) { | 4 |
|
Times Different | |||||
319 | bool findZoneEdges() override { | 10 | ||||
321 | return true; | 10 |
|
Times Different | |||||
1273 | dst.setSlot(DATA_SLOT, PrivateValue(dst.inlineDataPointer())); | 4 |
|
Times Different | |||||
59 | MOZ_ASSERT(ret == Z_DATA_ERROR); | 2 | ||||
60 | MOZ_ASSERT(!finished); | 2 |
|
Times Different | |||||
3061 | GlobalObject* global = c->unsafeUnbarrieredMaybeGlobal(); | 4 | ||||
3062 | if (!IsMarkedUnbarriered(rt, &global)) | 4 | ||||
3069 | const GlobalObject::DebuggerVector* debuggers = global->getDebuggers(); | 4 | ||||
3070 | MOZ_ASSERT(debuggers); | 4 | ||||
3071 | for (auto p = debuggers->begin(); p != debuggers->end(); p++) { | 4 | ||||
3072 | Debugger* dbg = *p; | 4 | ||||
3080 | GCPtrNativeObject& dbgobj = dbg->toJSObjectRef(); | 4 | ||||
3081 | if (!dbgobj->zone()->isGCMarking()) | 4 | ||||
3084 | bool dbgMarked = IsMarked(rt, &dbgobj); | 4 | ||||
3085 | if (!dbgMarked && dbg->hasAnyLiveHooks(rt)) { | 4 | ||||
3095 | if (dbgMarked) { | 4 | ||||
3097 | for (Breakpoint* bp = dbg->firstBreakpoint(); bp; bp = bp->nextInDebugger()) { | 4 | ||||
3173 | dbg->trace(trc); | 6 | ||||
3235 | GlobalObject* global = e.front().unbarrieredGet(); | 4 | ||||
3236 | if (debuggerDying || IsAboutToBeFinalizedUnbarriered(&global)) | 4 | ||||
3268 | Zone* w = dbg->object->zone(); | 10 | ||||
3269 | if (w == zone || !w->isGCMarking()) | 10 | ||||
3271 | if (dbg->debuggeeZones.has(zone) || | 10 | ||||
3272 | dbg->scripts.hasKeyInZone(zone) || | 10 | ||||
3273 | dbg->sources.hasKeyInZone(zone) || | 10 | ||||
3274 | dbg->objects.hasKeyInZone(zone) || | 10 | ||||
3275 | dbg->environments.hasKeyInZone(zone) || | 10 | ||||
3276 | dbg->wasmInstanceScripts.hasKeyInZone(zone) || | 10 | ||||
3277 | dbg->wasmInstanceSources.hasKeyInZone(zone)) | 10 | ||||
3279 | finder.addEdgeTo(w); | 10 | ||||
5463 | if (cell->getTraceKind() == JS::TraceKind::Script) { | 6 | ||||
5464 | JSScript* script = static_cast |
6 | ||||
5466 | "Debugger.Script script referent"); | 6 | ||||
5467 | obj->as |
6 | ||||
7158 | "Debugger.Source referent"); | 6 | ||||
7159 | obj->as |
6 | ||||
9023 | "Debugger.Object referent"); | 6 | ||||
9024 | obj->as |
6 | ||||
11976 | if (dbg->enabled && | 6 | ||||
11977 | dbg->observedGC(data->majorGCNumber()) && | 6 | ||||
11978 | dbg->getHook(Debugger::OnGarbageCollection)) | 4 |
|
Times Different | |||||
156 | bool hasKeyInZone(JS::Zone* zone) { | 10 | ||||
157 | CountMap::Ptr p = zoneCounts.lookup(zone); | 10 | ||||
158 | MOZ_ASSERT_IF(p.found(), p->value() > 0); | 10 | ||||
159 | return p.found(); | 10 | ||||
164 | void sweep() { | 6 | ||||
165 | MOZ_ASSERT(CurrentThreadIsPerformingGC()); | 6 | ||||
166 | for (Enum e(*static_cast |
6 | ||||
167 | if (gc::IsAboutToBeFinalized(&e.front().mutableKey())) { | 6 | ||||
172 | Base::assertEntriesNotAboutToBeFinalized(); | 6 | ||||
173 | } | 6 | ||||
331 | return observedGCs.has(majorGCNumber); | 4 | ||||
337 | return observedGCs.put(majorGCNumber); | 4 | ||||
1763 | Debugger::toJSObjectRef() | 4 | ||||
1765 | MOZ_ASSERT(object); | 4 | ||||
1766 | return object; | 4 |
|
Times Different | |||||
26 | js::CallWarningReporter(JSContext* cx, JSErrorReport* reportp) | 2 | ||||
28 | MOZ_ASSERT(reportp); | 2 | ||||
29 | MOZ_ASSERT(JSREPORT_IS_WARNING(reportp->flags)); | 2 | ||||
31 | if (JS::WarningReporter warningReporter = cx->runtime()->warningReporter) | 2 | ||||
32 | warningReporter(cx, reportp); | 2 | ||||
33 | } | 2 |
|
Times Different | |||||
272 | jit::IonBuilder* builder = worklist[i]; | 1 | ||||
273 | if (builder->script()->compartment() == comp) | 1 | ||||
969 | count++; | 5 | ||||
1173 | IonBuilderHasHigherPriority(thisThread.ionBuilder(), thread->ionBuilder())) | 8 | ||||
2083 | builder->trace(trc); | 7 | ||||
2085 | builder->trace(trc); | 7 | ||||
2090 | builder->trace(trc); | 6 |
|
Times Different | |||||
782 | BitLsh(JSContext* cx, HandleValue lhs, HandleValue rhs, int* out) | 2 | ||||
785 | if (!ToInt32(cx, lhs, &left) || !ToInt32(cx, rhs, &right)) | 2 | ||||
787 | *out = uint32_t(left) << (right & 31); | 2 | ||||
788 | return true; | 2 |
|
Times Different | |||||
1193 | UnwindIteratorsForUncatchableException(JSContext* cx, const InterpreterRegs& regs) | 2 | ||||
1197 | for (TryNoteIterInterpreter tni(cx, regs); !tni.done(); ++tni) { | 2 | ||||
1204 | } | 2 | ||||
1390 | if (MOZ_UNLIKELY(cx->isPropagatingForcedReturn())) { | 2 | ||||
1397 | UnwindIteratorsForUncatchableException(cx, regs); | 2 | ||||
5002 | RootedObjectGroup group(cx, templateObject->group()); | 9 | ||||
5003 | return UnboxedPlainObject::create(cx, group, newKind); | 9 |
|
Times Different | |||||
234 | dst->set(this, HeapSlot::Element, dst - elements_ + numShifted, *src); | 4 |
|
Times Different | |||||
1328 | void** pprivate = &privateRef(numFixedSlots()); | 6 | ||||
1329 | *pprivate = data; | 6 |
|
Times Different | |||||
775 | if (group != type.groupNoBarrier()) | 6 | ||||
1179 | return true; | 4 |
|
Times Different | |||||
1032 | else if (code.byteCode) | 6 | ||||
1033 | compilation.byteCode = code.byteCode; | 6 | ||||
1136 | if (!jit::CheckOverRecursed(cx)) | 6 | ||||
1152 | if (!compileIfNecessary(cx, re, input, mode, ForceByteCode)) | 6 | ||||
1155 | uint8_t* byteCode = re->compilation(mode, input->hasLatin1Chars()).byteCode; | 6 | ||||
1156 | AutoTraceLog logInterpreter(logger, TraceLogger_IrregexpExecute); | 6 | ||||
1158 | AutoStableStringChars inputChars(cx); | 6 | ||||
1159 | if (!inputChars.init(cx, input)) | 6 | ||||
1163 | if (inputChars.isLatin1()) { | 6 | ||||
1164 | const Latin1Char* chars = inputChars.latin1Range().begin().get(); | 6 | ||||
1165 | result = irregexp::InterpretCode(cx, byteCode, chars, start, length, matches, endIndex); | 6 | ||||
1171 | if (result == RegExpRunStatus_Success && matches) | 6 |
|
Times Different | |||||
521 | stop = true; | 2 | ||||
556 | JSString* stack = ComputeStackString(cx); | 2 | ||||
557 | JSFlatString* flat = stack ? stack->ensureFlat(cx) : nullptr; | 2 | ||||
560 | AutoStableStringChars stableChars(cx); | 2 | ||||
561 | if (flat && stableChars.initTwoByte(cx, flat)) | 2 | ||||
562 | chars = stableChars.twoByteRange().begin().get(); | 2 | ||||
566 | JSMSG_TERMINATED, chars); | 2 | ||||
568 | return false; | 2 |
|
Times Different | |||||
868 | return gc.atomsZone; | 2 | ||||
1063 | MOZ_ASSERT(rt->stackFormat_ == js::StackFormat::Default); | 2 | ||||
1064 | rt = rt->parentRuntime; | 2 |
|
Times Different | |||||
1507 | !IsAboutToBeFinalizedUnbarriered(&existingShape)) | 6 | ||||
1517 | MOZ_ASSERT(parent->isMarked()); | 6 | ||||
1518 | parent->removeChild(existingShape); | 6 | ||||
2037 | TraceRoot(trc, (JSObject**) psetter, "AutoRooterGetterSetter setter"); | 6 |
|
Times Different | |||||
664 | CopyAndInflateChars(twoByteBuf + leftLen, rightLinear->latin1Chars(nogc), rightLen); | 10 | ||||
989 | base = base->asDependent().base(); | 2 |
|
Times Different | |||||
56 | TraceManuallyBarrieredEdge(trc, &proto, "TaggedProto"); | 10 |
|
Times Different | |||||
970 | constraint->newPropertyState(cx, this); | 6 | ||||
971 | constraint = constraint->next(); | 6 |
|
Times Different | |||||
1197 | void newPropertyState(JSContext* cx, TypeSet* source) { | 6 | ||||
1198 | if (data.invalidateOnNewPropertyState(source)) | 6 | ||||
1200 | } | 6 | ||||
4295 | if (AutoEnterAnalysis* analysis = zone->types.activeAnalysis) { | 9 | ||||
4296 | if (analysis->oom.isNothing()) | 6 | ||||
4297 | analysis->oom.emplace(zone); | 6 | ||||
4298 | oom = analysis->oom.ptr(); | 6 | ||||
4300 | fallback.emplace(zone); | 9 | ||||
4301 | oom = &fallback.ref(); | 9 | ||||
4390 | oom->setOOM(); | 4 | ||||
4391 | addFlags(OBJECT_FLAG_DYNAMIC_MASK | OBJECT_FLAG_UNKNOWN_PROPERTIES); | 4 | ||||
4454 | !hasIonScript()) | 2 | ||||
4456 | types_->destroy(); | 2 | ||||
4457 | types_ = nullptr; | 2 | ||||
4461 | hasFreezeConstraints_ = false; | 2 |
|
Times Different | |||||
642 | oom = true; | 4 |
|
Times Different | |||||
194 | if (oldObj->hasInlineElements()) | 2 |
|
Times Different | |||||
1601 | case nsXPTType::T_CHAR_STR : POPULATE(fr, char*); break; | 9 |
|
Times Different | |||||
111 | void WakeUp() | 13 | ||||
113 | MOZ_ASSERT(Initialized()); | 13 | ||||
114 | MOZ_ASSERT(Hibernating()); | 13 | ||||
115 | mHibernating = false; | 13 | ||||
116 | PR_NotifyCondVar(mWakeup); | 13 | ||||
117 | } | 13 | ||||
297 | mWatchdog->WakeUp(); | 13 |
|
Times Different | |||||
2599 | Telemetry::Accumulate(Telemetry::GC_SLOW_PHASE, sample); | 4 | ||||
2600 | break; | 4 | ||||
2602 | Telemetry::Accumulate(Telemetry::GC_SLOW_TASK, sample); | 4 | ||||
2603 | break; | 4 |
|
Times Different | |||||
882 | cache->UpdateWrapper(obj, old); | 6 |
|
Times Different | |||||
1277 | mDelayedPaintTimer->Cancel(); | 8 | ||||
1278 | mDelayedPaintTimer = nullptr; | 8 | ||||
3711 | if (!mDelayedPaintTimer) { | 8 | ||||
3713 | PaintTimerCallBack = [](nsITimer* aTimer, void* aClosure) { | 8 | ||||
3717 | auto self = static_cast |
8 | ||||
3719 | self->ScheduleViewManagerFlush(); | 8 | ||||
3720 | }; | 8 | ||||
3722 | mDelayedPaintTimer = do_CreateInstance(NS_TIMER_CONTRACTID); | 8 | ||||
3723 | mDelayedPaintTimer->SetTarget( | 8 | ||||
3724 | mDocument->EventTargetFor(TaskCategory::Other)); | 8 | ||||
3725 | mDelayedPaintTimer->InitWithNamedFuncCallback(PaintTimerCallBack, | 8 | ||||
3729 | "PaintTimerCallBack"); | 8 | ||||
6454 | mNextPaintCompressed = false; | 8 | ||||
6704 | currentEventFrame->GetContentForEvent(aEvent, getter_AddRefs(content)); | 6 | ||||
6705 | NS_ASSERTION(!content || content->GetComposedDoc() == mDocument, | 6 | ||||
8259 | Telemetry::Accumulate(Telemetry::LOAD_INPUT_EVENT_RESPONSE_MS, millis); | 6 |
|
Times Different | |||||
112 | cur = cur->GetPreviousSibling()) { | 2 |
|
Times Different | |||||
248 | LOG_RESTYLE("skipping, already restyled"); | 7 | ||||
249 | continue; | 7 |
|
Times Different | |||||
8966 | aContent->TextIsOnlyWhitespace())) { | 4 | ||||
8968 | nsIFrame* frame = aContent->GetPrimaryFrame(); | 4 | ||||
8969 | NS_ASSERTION(!frame || !frame->IsGeneratedContentFrame(), | 4 | ||||
8972 | LAYOUT_PHASE_TEMP_EXIT(); | 4 | ||||
8974 | REMOVE_FOR_RECONSTRUCTION, nullptr); | 4 | ||||
8975 | LAYOUT_PHASE_TEMP_REENTER(); | 4 | ||||
10615 | return; | 4 | ||||
10653 | spaceEndIter.item().IsWhitespace(aState)) { | 4 | ||||
10654 | bool trailingSpaces = spaceEndIter.SkipWhitespace(aState); | 4 | ||||
10664 | if ((!trailingSpaces && | 4 | ||||
10665 | IsTableParentType(spaceEndIter.item().DesiredParentType())) || | 4 | ||||
10666 | (trailingSpaces && ourParentType != eTypeBlock)) { | 4 | ||||
10699 | (endIter == spaceEndIter || | 4 | ||||
10700 | spaceEndIter.IsDone() || | 4 | ||||
12905 | if (aItems.AreAllItemsInline()) { | 2 | ||||
13229 | nsCSSFrameConstructor::FrameConstructionItemList:: | 4 | ||||
13232 | NS_PRECONDITION(!IsDone(), "Shouldn't be done yet"); | 4 | ||||
13233 | NS_PRECONDITION(item().IsWhitespace(aState), "Not pointing to whitespace?"); | 4 | ||||
13234 | do { | 4 | ||||
13235 | Next(); | 4 | ||||
13236 | if (IsDone()) { | 4 | ||||
13239 | } while (item().IsWhitespace(aState)); | 4 | ||||
13309 | mCurrent->setPrevious(aItem); | 4 |
|
Times Different | |||||
140 | nsLayoutHistoryState::HasStates() | 7 |
|
Times Different | |||||
3711 | flags |= nsDisplayList::PAINT_COMPRESSED; | 8 | ||||
4459 | nsLayoutUtils::FindNearestBlockAncestor(nsIFrame* aFrame) | 2 | ||||
4462 | for (nextAncestor = aFrame->GetParent(); nextAncestor; | 2 | ||||
4464 | nsBlockFrame* block = GetAsBlock(nextAncestor); | 2 | ||||
4465 | if (block) | 2 | ||||
4466 | return block; | 2 | ||||
7837 | nsLayoutUtils::RegisterImageRequest(nsPresContext* aPresContext, | 3 | ||||
7841 | if (!aPresContext) { | 3 | ||||
7845 | if (aRequestRegistered && *aRequestRegistered) { | 3 | ||||
7851 | if (aRequest) { | 3 | ||||
7852 | if (!aPresContext->RefreshDriver()->AddImageRequest(aRequest)) { | 3 | ||||
7857 | if (aRequestRegistered) { | 3 | ||||
7858 | *aRequestRegistered = true; | 3 | ||||
7922 | *aRequestRegistered = false; | 3 | ||||
9264 | [](const IPC::Message& aMsg) -> bool { | 7 | ||||
9265 | if (aMsg.type() == mozilla::layers::PAPZ::Msg_RequestContentRepaint__ID) { | 7 |
|
Times Different | |||||
76 | void* ptr = iter.Key(); | 2 | ||||
77 | ArenaObjectID id = iter.UserData(); | 2 | ||||
78 | ClearArenaRefPtrWithoutDeregistering(ptr, id); | 2 |
|
Times Different | |||||
2434 | aTimeStamp = mozilla::TimeStamp::Now(); | 7 | ||||
3384 | nsAutoScriptBlocker blockScripts; | 7 | ||||
3385 | self->NotifyDidPaintForSubtree(aTransactionId); | 7 |
|
Times Different | |||||
190 | if (mRootRefreshDrivers.Contains(aDriver)) { | 2 | ||||
193 | NS_ASSERTION(mContentRefreshDrivers.Contains(aDriver), | 2 | ||||
195 | mContentRefreshDrivers.RemoveElement(aDriver); | 2 | ||||
1080 | return static_cast |
3 | ||||
1095 | nsRefreshDriver::DefaultInterval() | 6 | ||||
1097 | return NSToIntRound(1000.0 / gfxPlatform::GetDefaultFrameRate()); | 6 | ||||
1318 | nsRefreshDriver::AddImageRequest(imgIRequest* aRequest) | 3 | ||||
1320 | uint32_t delay = GetFirstFrameDelay(aRequest); | 3 | ||||
1321 | if (delay == 0) { | 3 | ||||
1325 | [] () { return new ImageStartData(); }); | 3 | ||||
1326 | start->mEntries.PutEntry(aRequest); | 3 | ||||
1329 | EnsureTimerStarted(); | 3 | ||||
1331 | return true; | 3 | ||||
1342 | ImageStartData* start = mStartTable.Get(delay); | 3 | ||||
1343 | if (start) { | 3 | ||||
1344 | start->mEntries.RemoveEntry(aRequest); | 3 | ||||
1459 | count += iter.UserData()->mEntries.Count(); | 3 | ||||
1975 | const uint32_t& delay = iter.Key(); | 3 | ||||
1976 | ImageStartData* data = iter.UserData(); | 3 | ||||
1978 | if (data->mStartTime) { | 3 | ||||
1979 | TimeStamp& start = *data->mStartTime; | 3 | ||||
1980 | TimeDuration prev = previousRefresh - start; | 3 | ||||
1981 | TimeDuration curr = aNowTime - start; | 3 | ||||
1982 | uint32_t prevMultiple = uint32_t(prev.ToMilliseconds()) / delay; | 3 | ||||
1988 | if (prevMultiple != uint32_t(curr.ToMilliseconds()) / delay) { | 3 | ||||
1990 | start + TimeDuration::FromMilliseconds(prevMultiple * delay); | 3 | ||||
1991 | BeginRefreshingImages(data->mEntries, desired); | 3 | ||||
1997 | mozilla::TimeStamp desired = aNowTime; | 3 | ||||
1998 | BeginRefreshingImages(data->mEntries, desired); | 3 | ||||
1999 | data->mStartTime.emplace(aNowTime); | 3 | ||||
2008 | nsCOMArray |
6 | ||||
2010 | for (auto iter = mRequests.Iter(); !iter.Done(); iter.Next()) { | 6 | ||||
2011 | nsISupportsHashKey* entry = iter.Get(); | 6 | ||||
2012 | auto req = static_cast |
6 | ||||
2013 | MOZ_ASSERT(req, "Unable to retrieve the image request"); | 6 | ||||
2015 | if (NS_SUCCEEDED(req->GetImage(getter_AddRefs(image)))) { | 6 | ||||
2016 | imagesToRefresh.AppendElement(image.forget()); | 6 | ||||
2018 | } | 6 | ||||
2020 | for (uint32_t i = 0; i < imagesToRefresh.Length(); i++) { | 6 | ||||
2021 | imagesToRefresh[i]->RequestRefresh(aNowTime); | 6 | ||||
2095 | nsRefreshDriver::BeginRefreshingImages(RequestTable& aEntries, | 3 | ||||
2098 | for (auto iter = aEntries.Iter(); !iter.Done(); iter.Next()) { | 6 | ||||
2099 | auto req = static_cast |
6 | ||||
2100 | MOZ_ASSERT(req, "Unable to retrieve the image request"); | 6 | ||||
2102 | mRequests.PutEntry(req); | 6 | ||||
2105 | if (NS_SUCCEEDED(req->GetImage(getter_AddRefs(image)))) { | 6 | ||||
2106 | image->SetAnimationStartTime(aDesired); | 6 | ||||
2108 | } | 6 | ||||
2110 | } | 3 |
|
Times Different | |||||
360 | struct ImageStartData { | 3 | ||||
361 | ImageStartData() | 3 | ||||
362 | { | 3 | ||||
363 | } | 3 |
|
Times Different | |||||
86 | nsGfxButtonControlFrame::GetDefaultLabel(nsXPIDLString& aString) const | 7 | ||||
88 | nsCOMPtr |
7 | ||||
89 | NS_ENSURE_TRUE(form, NS_ERROR_UNEXPECTED); | 7 | ||||
91 | int32_t type = form->ControlType(); | 7 | ||||
93 | if (type == NS_FORM_INPUT_RESET) { | 7 | ||||
96 | else if (type == NS_FORM_INPUT_SUBMIT) { | 7 | ||||
100 | aString.Truncate(); | 7 | ||||
101 | return NS_OK; | 7 | ||||
122 | rv = GetDefaultLabel(aLabel); | 7 | ||||
123 | NS_ENSURE_SUCCESS(rv, rv); | 7 | ||||
154 | nsGfxButtonControlFrame::AttributeChanged(int32_t aNameSpaceID, | 7 | ||||
158 | nsresult rv = NS_OK; | 7 | ||||
161 | if (nsGkAtoms::value == aAttribute) { | 7 | ||||
162 | if (mTextContent && mContent) { | 7 | ||||
163 | nsXPIDLString label; | 7 | ||||
164 | rv = GetLabel(label); | 7 | ||||
165 | NS_ENSURE_SUCCESS(rv, rv); | 7 | ||||
167 | mTextContent->SetText(label, true); | 7 | ||||
176 | return rv; | 7 |
|
Times Different | |||||
1235 | AreAllEarlierInFlowFramesEmpty(nsIFrame* aFrame, | 7 | ||||
1239 | if (aFrame == aDescendant) { | 7 | ||||
1240 | *aFound = true; | 7 | ||||
1241 | return true; | 7 | ||||
1243 | if (aFrame->IsPlaceholderFrame()) { | 7 | ||||
1248 | if (!aFrame->IsSelfEmpty()) { | 7 | ||||
1252 | for (nsIFrame* f : aFrame->PrincipalChildList()) { | 7 | ||||
1259 | *aFound = false; | 7 | ||||
1260 | return true; | 7 | ||||
1411 | aPlaceholderFrame->SetLineIsEmptySoFar(true); | 7 | ||||
1412 | allEmpty = true; | 7 | ||||
1414 | auto prev = aPlaceholderFrame->GetPrevSibling(); | 7 | ||||
1415 | if (prev && prev->IsPlaceholderFrame()) { | 7 | ||||
1423 | bool found = false; | 7 | ||||
1424 | while (firstFrame) { // See bug 223064 | 7 | ||||
1426 | aPlaceholderFrame, &found); | 7 | ||||
1427 | if (found || !allEmpty) { | 7 | ||||
1430 | firstFrame = firstFrame->GetNextSibling(); | 7 | ||||
1432 | aPlaceholderFrame->SetLineIsEmptySoFar(allEmpty); | 7 |
|
Times Different | |||||
4160 | FrameLines* overflowLines = GetOverflowLines(); | 7 | ||||
4163 | bool pushedToOverflowLines = overflowLines && | 7 | ||||
4164 | overflowLines->mLines.front() == aLine.get(); | 7 | ||||
4165 | if (pushedToOverflowLines) { | 7 | ||||
4170 | nsBlockInFlowLineIterator iter(this, aLine, pushedToOverflowLines); | 7 | ||||
4171 | if (iter.Next() && iter.GetLine()->IsInline()) { | 7 | ||||
4296 | breakType = StyleClear::None; | 7 | ||||
5612 | nsBlockInFlowLineIterator::nsBlockInFlowLineIterator(nsBlockFrame* aFrame, | 7 | ||||
5616 | : &aFrame->mLines) | 7 | ||||
5618 | } | 7 | ||||
6943 | aChild->IsAbsolutelyPositioned()) { | 2 |
|
Times Different | |||||
2608 | set.BlockBorderBackgrounds()->DeleteAll(); | 4 | ||||
2609 | set.Floats()->DeleteAll(); | 4 | ||||
2610 | set.Content()->DeleteAll(); | 4 | ||||
2611 | set.PositionedDescendants()->DeleteAll(); | 4 | ||||
2612 | set.Outlines()->DeleteAll(); | 4 |
|
Times Different | |||||
525 | nsInlineFrame::DrainSelfOverflowList() | 2 | ||||
527 | nsIFrame* lineContainer = nsLayoutUtils::FindNearestBlockAncestor(this); | 2 | ||||
530 | DrainFlags flags = DrainFlags(0); | 2 | ||||
531 | for (nsIFrame* p = GetParent(); p != lineContainer; p = p->GetParent()) { | 2 | ||||
537 | return DrainSelfOverflowListInternal(flags, lineContainer); | 2 |
|
Times Different | |||||
319 | frame = frame->GetNextSibling(); | 7 |
|
Times Different | |||||
226 | mDirtyNextLine = true; | 7 |
|
Times Different | |||||
229 | !(aFlags & IGNORE_PAINT_SUPPRESSION))) { | 4 |
|
Times Different | |||||
1637 | return mMappedFlows.Length() == 1 && | 7 | ||||
1638 | mMappedFlows[0].mStartFrame == GetFrameForSimpleFlow(aTextRun) && | 7 | ||||
1639 | mMappedFlows[0].mEndFrame == nullptr; | 7 | ||||
1642 | auto userData = static_cast |
7 | ||||
1643 | TextRunMappedFlow* userMappedFlows = GetMappedFlows(aTextRun); | 7 | ||||
1644 | if (userData->mMappedFlowCount != mMappedFlows.Length()) | 7 | ||||
1646 | for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) { | 7 | ||||
1647 | if (userMappedFlows[i].mStartFrame != mMappedFlows[i].mStartFrame || | 7 | ||||
1648 | int32_t(userMappedFlows[i].mContentLength) != | 7 | ||||
1649 | mMappedFlows[i].GetContentEnd() - mMappedFlows[i].mStartFrame->GetContentOffset()) | 7 | ||||
2465 | mMappedFlows[0].mStartFrame->GetContentOffset() == 0) { | 7 | ||||
2472 | userData = CreateUserData(mMappedFlows.Length()); | 7 | ||||
2473 | userMappedFlows = reinterpret_cast |
7 | ||||
2474 | userDataToDestroy = userData; | 7 | ||||
9730 | aStatus.SetInlineLineBreakAfter(); | 7 |
|
Times Different | |||||
237 | bool IsSelfEmpty() override { return IsEmpty(); } | 7 |
|
Times Different | |||||
231 | rect.YMost() > rr.mRect.YMost() - rr.mRadii[eCornerBottomLeftY]) { | 9 | ||||
232 | if (!IsInsideEllipse(rr.mRadii[eCornerBottomLeftX], | 9 | ||||
236 | rr.mRect.YMost() - rr.mRadii[eCornerBottomLeftY], | 9 | ||||
237 | rect.YMost())) { | 9 | ||||
243 | rect.YMost() > rr.mRect.YMost() - rr.mRadii[eCornerBottomRightY]) { | 3 | ||||
244 | if (!IsInsideEllipse(rr.mRadii[eCornerBottomRightX], | 3 | ||||
245 | rr.mRect.XMost() - rr.mRadii[eCornerBottomRightX], | 3 | ||||
248 | rr.mRect.YMost() - rr.mRadii[eCornerBottomRightY], | 3 | ||||
249 | rect.YMost())) { | 3 |
|
Times Different | |||||
2188 | ContainerState::CreateOrRecycleImageLayer(PaintedLayer *aPainted) | 12 | ||||
2191 | static_cast |
12 | ||||
2192 | RefPtr |
12 | ||||
2193 | if (layer) { | 12 | ||||
2194 | ResetLayerStateForRecycling(layer); | 8 | ||||
2195 | layer->ClearExtraDumpInfo(); | 8 | ||||
2198 | layer = mManager->CreateImageLayer(); | 12 | ||||
2199 | if (!layer) | 12 | ||||
2202 | data->mImageLayer = layer; | 12 | ||||
2203 | layer->SetUserData(&gImageLayerUserData, nullptr); | 12 | ||||
2206 | data->mColorLayer = nullptr; | 12 | ||||
2208 | return layer.forget(); | 12 | ||||
2724 | PaintedLayerData::GetContainerForImageLayer(nsDisplayListBuilder* aBuilder) | 12 | ||||
2726 | if (!mImage) { | 12 | ||||
2730 | return mImage->GetContainer(mLayer->Manager(), aBuilder); | 12 | ||||
3068 | return aLayerBuilder->CheckInLayerTreeCompressionMode(); | 8 | ||||
3085 | ContainerState::PrepareImageLayer(PaintedLayerData* aData) | 12 | ||||
3088 | aData->GetContainerForImageLayer(mBuilder); | 12 | ||||
3089 | if (!imageContainer) { | 12 | ||||
3093 | RefPtr |
12 | ||||
3094 | imageLayer->SetContainer(imageContainer); | 12 | ||||
3095 | aData->mImage->ConfigureLayer(imageLayer, mParameters); | 12 | ||||
3096 | imageLayer->SetPostScale(mParameters.mXScale, | 12 | ||||
3097 | mParameters.mYScale); | 12 | ||||
3099 | if (aData->mItemClip.HasClip()) { | 12 | ||||
3101 | ViewAs |
12 | ||||
3102 | clip.MoveBy(ViewAs |
12 | ||||
3103 | imageLayer->SetClipRect(Some(clip)); | 12 | ||||
3108 | FLB_LOG_PAINTED_LAYER_DECISION(aData, | 12 | ||||
3111 | return imageLayer.forget(); | 12 | ||||
4915 | FrameLayerBuilder::CheckInLayerTreeCompressionMode() | 8 | ||||
4917 | if (mInLayerTreeCompressionMode) { | 8 | ||||
4923 | mRootPresContext->PresShell()->GetRootFrame()->SchedulePaint(nsIFrame::PAINT_DELAYED_COMPRESS); | 8 | ||||
4925 | return false; | 8 | ||||
5837 | return element->mOptLayer; | 8 |
|
Times Different | |||||
264 | return LayerIntPoint::FromUnknownPoint(mOffset); | 12 | ||||
744 | void SetLayerTreeCompressionMode() { mInLayerTreeCompressionMode = true; } | 8 |
|
Times Different | |||||
1184 | state->mIsBackgroundOnly = true; | 3 | ||||
1185 | buildCaret = false; | 3 | ||||
2132 | layerBuilder->SetLayerTreeCompressionMode(); | 8 | ||||
2869 | nsDisplaySolidColor::Paint(nsDisplayListBuilder* aBuilder, | 13 | ||||
2872 | int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel(); | 13 | ||||
2873 | DrawTarget* drawTarget = aCtx->GetDrawTarget(); | 13 | ||||
2875 | NSRectToSnappedRect(mVisibleRect, appUnitsPerDevPixel, *drawTarget); | 13 | ||||
2876 | drawTarget->FillRect(rect, ColorPattern(ToDeviceColor(mColor))); | 13 | ||||
2877 | } | 13 | ||||
3665 | nsDisplayBackgroundImage::RenderingMightDependOnPositioningAreaSizeChange() | 11 | ||||
3667 | if (!mBackgroundStyle) | 11 | ||||
3671 | if (mFrame->GetBorderRadii(radii)) { | 11 | ||||
3677 | const nsStyleImageLayers::Layer &layer = mBackgroundStyle->mImage.mLayers[mLayer]; | 11 | ||||
3678 | if (layer.RenderingMightDependOnPositioningAreaSizeChange()) { | 11 | ||||
3733 | RenderingMightDependOnPositioningAreaSizeChange())) { | 11 | ||||
3739 | NotifyRenderingChanged(); | 11 | ||||
3977 | nsDisplayImageContainer::ConfigureLayer(ImageLayer* aLayer, | 12 | ||||
3980 | aLayer->SetSamplingFilter(nsLayoutUtils::GetSamplingFilterForFrame(mFrame)); | 12 | ||||
3982 | nsCOMPtr |
12 | ||||
3983 | MOZ_ASSERT(image); | 12 | ||||
3986 | image->GetWidth(&imageWidth); | 12 | ||||
3987 | image->GetHeight(&imageHeight); | 12 | ||||
3988 | NS_ASSERTION(imageWidth != 0 && imageHeight != 0, "Invalid image size!"); | 12 | ||||
3990 | if (imageWidth > 0 && imageHeight > 0) { | 12 | ||||
3993 | nsDisplayBackgroundGeometry::UpdateDrawResult(this, DrawResult::SUCCESS); | 12 | ||||
4000 | MOZ_ASSERT(aParameters.Offset() == LayerIntPoint(0,0)); | 12 | ||||
4012 | : IntSize(imageWidth, imageHeight); | 12 | ||||
4014 | const int32_t factor = mFrame->PresContext()->AppUnitsPerDevPixel(); | 12 | ||||
4016 | LayoutDeviceIntRect::FromAppUnitsToNearest(GetDestRect(), factor)); | 12 | ||||
4018 | const LayoutDevicePoint p = destRect.TopLeft(); | 12 | ||||
4019 | Matrix transform = Matrix::Translation(p.x, p.y); | 12 | ||||
4021 | destRect.height / containerSize.height); | 12 | ||||
4022 | aLayer->SetBaseTransform(gfx::Matrix4x4::From2D(transform)); | 12 | ||||
4023 | } | 12 | ||||
4026 | nsDisplayImageContainer::GetContainer(LayerManager* aManager, | 12 | ||||
4029 | nsCOMPtr |
12 | ||||
4030 | if (!image) { | 12 | ||||
4036 | uint32_t flags = imgIContainer::FLAG_ASYNC_NOTIFY; | 12 | ||||
4037 | if (aBuilder->ShouldSyncDecodeImages()) { | 12 | ||||
4041 | return image->GetImageContainer(aManager, flags); | 12 | ||||
4063 | image->GetWidth(&imageWidth); | 6 | ||||
4064 | image->GetHeight(&imageHeight); | 6 | ||||
4066 | if (imageWidth == 0 || imageHeight == 0) { | 6 | ||||
4071 | const int32_t factor = mFrame->PresContext()->AppUnitsPerDevPixel(); | 6 | ||||
4073 | LayoutDeviceIntRect::FromAppUnitsToNearest(GetDestRect(), factor)); | 6 | ||||
4076 | const gfxSize scale = gfxSize(destRect.width / imageWidth, | 6 | ||||
4077 | destRect.height / imageHeight); | 6 | ||||
4079 | if (scale.width < 0.34 || scale.height < 0.34) { | 6 | ||||
4085 | if (mFrame->IsImageFrame()) { | 6 |
|
Times Different | |||||
629 | void SetInTransform(bool aInTransform) { mInTransform = aInTransform; } | 11 |
|
Times Different | |||||
242 | return a.mTimeStamp.IsNull(); | 2 |
|
Times Different | |||||
328 | AppendCSSShadowValue(const nsCSSShadowItem *aShadow, | 7 | ||||
332 | MOZ_ASSERT(aShadow, "shadow expected"); | 7 | ||||
335 | RefPtr |
7 | ||||
336 | arr->Item(0).SetIntegerCoordValue(aShadow->mXOffset); | 7 | ||||
337 | arr->Item(1).SetIntegerCoordValue(aShadow->mYOffset); | 7 | ||||
338 | arr->Item(2).SetIntegerCoordValue(aShadow->mRadius); | 7 | ||||
339 | if (aProperty == eCSSProperty_box_shadow) { | 7 | ||||
340 | arr->Item(3).SetIntegerCoordValue(aShadow->mSpread); | 7 | ||||
342 | if (aShadow->mHasColor) { | 7 | ||||
343 | arr->Item(4).SetColorValue(aShadow->mColor); | 7 | ||||
345 | if (aShadow->mInset) { | 7 | ||||
346 | arr->Item(5).SetEnumValue(StyleBoxShadowType::Inset); | 7 | ||||
349 | nsCSSValueList *resultItem = new nsCSSValueList; | 7 | ||||
350 | resultItem->mValue.SetArrayValue(arr, eCSSUnit_Array); | 7 | ||||
351 | *aResultTail = resultItem; | 7 | ||||
352 | aResultTail = &resultItem->mNext; | 7 | ||||
353 | } | 7 | ||||
4836 | nsCSSValueList **resultTail = getter_Transfers(result); | 7 | ||||
4837 | for (uint32_t i = 0, i_end = shadowArray->Length(); i < i_end; ++i) { | 7 | ||||
4838 | AppendCSSShadowValue(shadowArray->ShadowAt(i), resultTail, aProperty); | 7 | ||||
4841 | eUnit_Shadow); | 7 | ||||
4842 | return true; | 7 |
|
Times Different | |||||
290 | NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsComputedDOMStyle) | 6 | ||||
291 | return tmp->HasKnownLiveWrapper(); | 6 |
|
Times Different | |||||
45 | NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsDOMCSSAttributeDeclaration) | 10 | ||||
46 | if (tmp->mElement && Element::CanSkip(tmp->mElement, true)) { | 10 | ||||
47 | if (tmp->PreservingWrapper()) { | 12 | ||||
52 | return tmp->HasKnownLiveWrapper(); | 4 |
|
Times Different | |||||
1689 | ruleWalker.CurrentNode()->SetIsAnimationRule(); | 2 |
|
Times Different | |||||
2876 | nsStyleImageLayers::Size::DependsOnPositioningAreaSize(const nsStyleImage& aImage) const | 12 | ||||
2878 | MOZ_ASSERT(aImage.GetType() != eStyleImageType_Null, | 12 | ||||
2883 | if ((mWidthType == eLengthPercentage && mWidth.mPercent != 0.0f) || | 12 | ||||
2884 | (mHeightType == eLengthPercentage && mHeight.mPercent != 0.0f)) { | 12 | ||||
3011 | nsStyleImageLayers::Layer::RenderingMightDependOnPositioningAreaSizeChange() const | 12 | ||||
3014 | if (mImage.IsEmpty()) { | 12 | ||||
3018 | return mPosition.DependsOnPositioningAreaSize() || | 12 | ||||
3019 | mSize.DependsOnPositioningAreaSize(mImage) || | 12 | ||||
3020 | mRepeat.DependsOnPositioningAreaSize(); | 12 |
|
Times Different | |||||
142 | bool DependsOnPositioningAreaSize() const { | 11 | ||||
143 | return mXPosition.mPercent != 0.0f || mYPosition.mPercent != 0.0f; | 11 | ||||
1081 | const nsCSSShadowItem* ShadowAt(uint32_t i) const { | 7 | ||||
1082 | MOZ_ASSERT(i < mLength, "Accessing too high an index in the text shadow array!"); | 7 | ||||
1083 | return &mArray[i]; | 7 |
|
Times Different | |||||
258 | TimeStamp activeTimeStamp = ElapsedTimeToTimeStamp(aActiveTime); | 2 | ||||
261 | activeTimeStamp }); | 2 | ||||
279 | } else if (currentPhase == TransitionPhase::After) { | 12 | ||||
282 | zeroTimeStamp }); | 12 | ||||
285 | startTimeStamp }); | 12 | ||||
288 | endTimeStamp }); | 12 | ||||
301 | startTimeStamp }); | 14 | ||||
304 | endTimeStamp }); | 14 | ||||
980 | oldPT->mStartForReversingTest == endValue) { | 2 | ||||
1076 | oldPT->IsRunningOnCompositor() && | 2 |
|
Times Different | |||||
510 | BasicTableLayoutStrategy::MarkIntrinsicISizesDirty() | 4 | ||||
516 | } | 4 |
|
Times Different | |||||
1745 | nsTableFrame::MarkIntrinsicISizesDirty() | 4 | ||||
1747 | nsITableLayoutStrategy* tls = LayoutStrategy(); | 4 | ||||
1748 | if (MOZ_UNLIKELY(!tls)) { | 4 | ||||
1755 | return; | 4 | ||||
1757 | tls->MarkIntrinsicISizesDirty(); | 4 | ||||
1761 | nsContainerFrame::MarkIntrinsicISizesDirty(); | 4 |
|
Times Different | |||||
509 | nsDisplayXULImage::GetDestRect() | 6 | ||||
512 | return static_cast |
6 | ||||
706 | return OnImageIsAnimated(aRequest); | 3 | ||||
767 | nsImageBoxFrame::OnImageIsAnimated(imgIRequest* aRequest) | 3 | ||||
771 | &mRequestRegistered); | 3 | ||||
773 | return NS_OK; | 3 |
|
Times Different | |||||
143 | unsafe_interval - rest >= ten_kappa && // Negated condition 2 | 2 | ||||
144 | (rest + ten_kappa < small_distance || // buffer{-1} > w_high | 8 | ||||
145 | small_distance - rest >= rest + ten_kappa - small_distance)) { | 8 | ||||
146 | buffer[length - 1]--; | 8 | ||||
147 | rest += ten_kappa; | 8 | ||||
155 | (rest + ten_kappa < big_distance || | 8 | ||||
156 | big_distance - rest > rest + ten_kappa - big_distance)) { | 8 | ||||
366 | static_cast |
11 |
|
Times Different | |||||
147 | if (width > cvtwidth) { | 6 | ||||
336 | if (i > 0) | 2 | ||||
337 | MOZ_CRASH("Bad format string"); | 2 | ||||
860 | MOZ_ASSERT(0); | 2 |
|
Times Different | |||||
77 | if (aIsInconsistent) { | 2 | ||||
80 | ts = sInitOnce.mFirstTimeStamp; | 2 |
|
Times Different | |||||
677 | return; | 2 | ||||
693 | return; | 2 | ||||
703 | do_QueryInterface(cacheToken); | 2 | ||||
704 | if (!cacheEntry) { | 2 | ||||
708 | cacheEntry->SetMetaDataElement("necko:classified", | 2 | ||||
709 | NS_SUCCEEDED(status) ? "1" : nullptr); | 2 |
|
Times Different | |||||
458 | NS_ASSERTION(NS_SUCCEEDED(mStatus), | 2 |
|
Times Different | |||||
272 | firstError = rv; | 2 | ||||
787 | auto e = static_cast |
2 | ||||
788 | RescheduleRequest(e->mKey, aDelta); | 2 |
|
Times Different | |||||
1133 | dnsFlags |= nsIDNSService::RESOLVE_DISABLE_IPV6; | 9 |
|
Times Different | |||||
338 | mActiveList[index] = mActiveList[mActiveCount-1]; | 2 | ||||
339 | mPollList[index+1] = mPollList[mActiveCount]; | 2 |
|
Times Different | |||||
413 | } else if (!strcmp("suspend_process_notification", topic)) { | 8 | ||||
417 | } else if (!strcmp("profile-do-change", topic)) { | 8 | ||||
427 | } else if (!strcmp(NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, topic)) { | 8 | ||||
430 | if (!mHaveProfile) | 8 | ||||
431 | return NS_OK; | 4 | ||||
433 | nsCOMPtr |
6 | ||||
434 | if (NS_FAILED(rv)) | 6 | ||||
438 | if (!strcmp(DISK_CACHE_ENABLE_PREF, data.get())) { | 6 | ||||
446 | } else if (!strcmp(DISK_CACHE_CAPACITY_PREF, data.get())) { | 6 | ||||
448 | int32_t capacity = 0; | 6 | ||||
449 | rv = branch->GetIntPref(DISK_CACHE_CAPACITY_PREF, &capacity); | 6 | ||||
450 | if (NS_FAILED(rv)) | 6 | ||||
452 | mDiskCacheCapacity = std::max(0, capacity); | 6 | ||||
453 | nsCacheService::SetDiskCacheCapacity(mDiskCacheCapacity); | 6 | ||||
562 | } | 6 | ||||
2486 | nsCacheService::SetDiskCacheCapacity(int32_t capacity) | 6 | ||||
2488 | if (!gService) return; | 6 | ||||
2491 | if (gService->mDiskDevice) { | 6 | ||||
2495 | gService->mEnableDiskDevice = gService->mObserver->DiskCacheEnabled(); | 6 |
|
Times Different | |||||
67 | nsCOMPtr |
3 | ||||
68 | if (!ioTarget) { | 3 | ||||
72 | nsresult rv = ioTarget->Dispatch( | 3 | ||||
75 | nsIEventTarget::DISPATCH_NORMAL); | 3 | ||||
76 | if (NS_FAILED(rv)) { | 3 | ||||
80 | return true; | 3 | ||||
90 | return count; | 3 | ||||
3752 | CacheFileIOManager::StrToHash(const nsACString &aHash, SHA1Sum::Hash *_retval) | 8 | ||||
3754 | if (aHash.Length() != 2*sizeof(SHA1Sum::Hash)) { | 8 | ||||
3758 | for (uint32_t i=0 ; i 8 |
| ||||
3761 | if (aHash[i] >= '0' && aHash[i] <= '9') { | 8 | ||||
3762 | value = aHash[i] - '0'; | 8 | ||||
3763 | } else if (aHash[i] >= 'A' && aHash[i] <= 'F') { | 8 | ||||
3764 | value = aHash[i] - 'A' + 10; | 8 | ||||
3771 | if (i%2 == 0) { | 8 | ||||
3772 | (reinterpret_cast |
8 | ||||
3774 | (reinterpret_cast |
8 | ||||
4204 | SmartCacheSize(const uint32_t availKB) | 8 | ||||
4206 | uint32_t maxSize = kMaxCacheSizeKB; | 8 | ||||
4208 | if (availKB > 100 * 1024 * 1024) { | 8 | ||||
4215 | uint32_t sz10MBs = 0; | 8 | ||||
4216 | uint32_t avail10MBs = availKB / (1024*10); | 8 | ||||
4219 | if (avail10MBs > 2500) { | 8 | ||||
4220 | sz10MBs += static_cast |
8 | ||||
4221 | avail10MBs = 2500; | 8 | ||||
4224 | if (avail10MBs > 700) { | 8 | ||||
4225 | sz10MBs += static_cast |
8 | ||||
4226 | avail10MBs = 700; | 8 | ||||
4229 | if (avail10MBs > 50) { | 8 | ||||
4230 | sz10MBs += static_cast |
8 | ||||
4231 | avail10MBs = 50; | 8 | ||||
4243 | sz10MBs += std::max |
8 | ||||
4246 | return std::min |
8 | ||||
4280 | rv = CacheIndex::GetCacheSize(&cacheUsage); | 8 | ||||
4281 | if (NS_WARN_IF(NS_FAILED(rv))) { | 8 | ||||
4287 | mLastSmartSizeTime = TimeStamp::NowLoRes(); | 8 | ||||
4289 | uint32_t smartSize = SmartCacheSize(static_cast |
8 | ||||
4290 | cacheUsage); | 8 | ||||
4292 | if (smartSize == (CacheObserver::DiskCacheCapacity() >> 10)) { | 8 | ||||
4297 | CacheObserver::SetDiskCacheCapacity(smartSize << 10); | 8 | ||||
4299 | return NS_OK; | 8 |
|
Times Different | |||||
61 | case 9 : c += (uint32_t(k[8])<<8); MOZ_FALLTHROUGH; | 2 | ||||
63 | case 8 : b += (uint32_t(k[7])<<24); MOZ_FALLTHROUGH; | 2 | ||||
64 | case 7 : b += (uint32_t(k[6])<<16); MOZ_FALLTHROUGH; | 2 | ||||
65 | case 6 : b += (uint32_t(k[5])<<8); MOZ_FALLTHROUGH; | 4 |
|
Times Different | |||||
430 | MonitorAutoLock lock(mMonitor); | 2 | ||||
431 | while (!mXPCOMThread) { | 2 | ||||
432 | lock.Wait(); | 5 | ||||
435 | target = mXPCOMThread; | 2 | ||||
590 | mEventQueue[aLevel].InsertElementsAt(0, events.Elements() + index, length - index); | 7 |
|
Times Different | |||||
255 | NS_INTERFACE_MAP_BEGIN(CacheIndex) | 8 | ||||
256 | NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileIOListener) | 8 | ||||
257 | NS_INTERFACE_MAP_ENTRY(nsIRunnable) | 8 | ||||
258 | NS_INTERFACE_MAP_END_THREADSAFE | 8 | ||||
369 | nsCOMPtr |
8 | ||||
370 | event = NewRunnableMethod("net::CacheIndex::PreShutdownInternal", | 8 | ||||
372 | &CacheIndex::PreShutdownInternal); | 8 | ||||
374 | nsCOMPtr |
8 | ||||
375 | MOZ_ASSERT(ioTarget); | 8 | ||||
379 | rv = ioTarget->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL); | 8 | ||||
380 | if (NS_FAILED(rv)) { | 8 | ||||
390 | CacheIndex::PreShutdownInternal() | 8 | ||||
392 | StaticMutexAutoLock lock(sLock); | 8 | ||||
394 | LOG(("CacheIndex::PreShutdownInternal() - [state=%d, indexOnDiskIsValid=%d, " | 8 | ||||
398 | MOZ_ASSERT(mShuttingDown); | 8 | ||||
400 | if (mUpdateTimer) { | 8 | ||||
401 | mUpdateTimer = nullptr; | 8 | ||||
404 | switch (mState) { | 8 | ||||
416 | FinishUpdate(false); | 8 | ||||
417 | break; | 8 | ||||
423 | MOZ_ASSERT(mState == READY); | 8 | ||||
424 | } | 8 | ||||
2590 | CacheIndex::DelayedUpdate(nsITimer *aTimer, void *aClosure) | 8 | ||||
2592 | LOG(("CacheIndex::DelayedUpdate()")); | 8 | ||||
2594 | StaticMutexAutoLock lock(sLock); | 8 | ||||
2595 | RefPtr |
8 | ||||
2597 | if (!index) { | 8 | ||||
2601 | index->DelayedUpdateLocked(); | 8 | ||||
2606 | CacheIndex::DelayedUpdateLocked() | 8 | ||||
2608 | LOG(("CacheIndex::DelayedUpdateLocked()")); | 8 | ||||
2610 | sLock.AssertCurrentThreadOwns(); | 8 | ||||
2614 | mUpdateTimer = nullptr; | 8 | ||||
2616 | if (!IsIndexUsable()) { | 8 | ||||
2620 | if (mState == READY && mShuttingDown) { | 8 | ||||
2626 | MOZ_ASSERT(!mUpdateEventPending); | 8 | ||||
2627 | if (mState != BUILDING && mState != UPDATING) { | 8 | ||||
2633 | RefPtr |
8 | ||||
2634 | MOZ_ASSERT(ioThread); | 8 | ||||
2636 | mUpdateEventPending = true; | 8 | ||||
2637 | rv = ioThread->Dispatch(this, CacheIOThread::INDEX); | 8 | ||||
2638 | if (NS_FAILED(rv)) { | 8 | ||||
2643 | } | 8 | ||||
2676 | CacheIndex::SetupDirectoryEnumerator() | 8 | ||||
2678 | MOZ_ASSERT(!NS_IsMainThread()); | 8 | ||||
2679 | MOZ_ASSERT(!mDirEnumerator); | 8 | ||||
2684 | rv = mCacheDirectory->Clone(getter_AddRefs(file)); | 8 | ||||
2685 | NS_ENSURE_SUCCESS(rv, rv); | 8 | ||||
2687 | rv = file->AppendNative(NS_LITERAL_CSTRING(ENTRIES_DIR)); | 8 | ||||
2688 | NS_ENSURE_SUCCESS(rv, rv); | 8 | ||||
2691 | rv = file->Exists(&exists); | 8 | ||||
2692 | NS_ENSURE_SUCCESS(rv, rv); | 8 | ||||
2694 | if (!exists) { | 8 | ||||
2702 | nsCOMPtr |
8 | ||||
2703 | rv = file->GetDirectoryEntries(getter_AddRefs(enumerator)); | 8 | ||||
2704 | NS_ENSURE_SUCCESS(rv, rv); | 8 | ||||
2706 | mDirEnumerator = do_QueryInterface(enumerator, &rv); | 8 | ||||
2707 | NS_ENSURE_SUCCESS(rv, rv); | 8 | ||||
2709 | return NS_OK; | 8 | ||||
2774 | CacheIndex::BuildIndex() | 8 | ||||
2776 | LOG(("CacheIndex::BuildIndex()")); | 8 | ||||
2778 | sLock.AssertCurrentThreadOwns(); | 8 | ||||
2780 | MOZ_ASSERT(mPendingUpdates.Count() == 0); | 8 | ||||
2784 | if (!mDirEnumerator) { | 8 | ||||
2787 | StaticMutexAutoUnlock unlock(sLock); | 8 | ||||
2788 | rv = SetupDirectoryEnumerator(); | 8 | ||||
2790 | if (mState == SHUTDOWN) { | 8 | ||||
2796 | if (NS_FAILED(rv)) { | 8 | ||||
2803 | if (CacheIOThread::YieldAndRerun()) { | 8 | ||||
2806 | return; | 8 | ||||
2812 | StaticMutexAutoUnlock unlock(sLock); | 8 | ||||
2813 | rv = mDirEnumerator->GetNextFile(getter_AddRefs(file)); | 8 | ||||
2815 | if (mState == SHUTDOWN) { | 8 | ||||
2816 | return; | 8 | ||||
2818 | if (!file) { | 8 | ||||
2819 | FinishUpdate(NS_SUCCEEDED(rv)); | 8 | ||||
2820 | return; | 8 | ||||
2823 | nsAutoCString leaf; | 8 | ||||
2824 | rv = file->GetNativeLeafName(leaf); | 8 | ||||
2825 | if (NS_FAILED(rv)) { | 8 | ||||
2833 | rv = CacheFileIOManager::StrToHash(leaf, &hash); | 8 | ||||
2834 | if (NS_FAILED(rv)) { | 8 | ||||
2841 | CacheIndexEntry *entry = mIndex.GetEntry(hash); | 8 | ||||
2842 | if (entry && entry->IsRemoved()) { | 8 | ||||
2852 | CacheFileIOManager::gInstance->mHandles.GetHandle(&hash, | 8 | ||||
2853 | getter_AddRefs(handle)); | 8 | ||||
2856 | if (entry) { | 8 | ||||
2858 | LOG(("CacheIndex::BuildIndex() - Skipping file because the entry is up to" | 8 | ||||
2860 | entry->Log(); | 8 | ||||
2861 | MOZ_ASSERT(entry->IsFresh()); // The entry must be from this session | 8 | ||||
2863 | MOZ_ASSERT(entry->IsInitialized() || handle); | 8 | ||||
2864 | continue; | 8 | ||||
3181 | if (NS_IsMainThread()) { | 8 | ||||
3189 | mDirEnumerator->Close(); | 8 | ||||
3190 | mDirEnumerator = nullptr; | 8 | ||||
3195 | mDontMarkIndexClean = true; | 8 | ||||
3469 | CacheIndex::Run() | 8 | ||||
3471 | LOG(("CacheIndex::Run()")); | 8 | ||||
3473 | StaticMutexAutoLock lock(sLock); | 8 | ||||
3475 | if (!IsIndexUsable()) { | 8 | ||||
3479 | if (mState == READY && mShuttingDown) { | 8 | ||||
3483 | mUpdateEventPending = false; | 8 | ||||
3485 | switch (mState) { | 8 | ||||
3487 | BuildIndex(); | 8 | ||||
3488 | break; | 8 | ||||
3496 | return NS_OK; | 8 |
|
Times Different | |||||
296 | void Log() const { | 8 | ||||
297 | LOG(("CacheIndexEntry::Log() [this=%p, hash=%08x%08x%08x%08x%08x, fresh=%u," | 8 | ||||
305 | } | 8 |
|
Times Different | |||||
228 | sHalfLifeHours = 0.083F; // ~5 mintues | 10 | ||||
229 | break; | 10 | ||||
231 | sHalfLifeHours = 0.25F; // 15 mintues | 2 | ||||
232 | break; | 2 | ||||
234 | sHalfLifeHours = 1.0F; | 1 | ||||
235 | break; | 1 | ||||
237 | sHalfLifeHours = 6.0F; | 9 | ||||
238 | break; | 9 | ||||
316 | CacheObserver::SetDiskCacheCapacity(uint32_t aCapacity) | 8 | ||||
318 | sDiskCacheCapacity = aCapacity >> 10; | 8 | ||||
320 | if (!sSelf) { | 8 | ||||
321 | return; | 8 | ||||
324 | if (NS_IsMainThread()) { | 8 | ||||
330 | &CacheObserver::StoreDiskCacheCapacity); | 8 | ||||
331 | NS_DispatchToMainThread(event); | 8 | ||||
336 | CacheObserver::StoreDiskCacheCapacity() | 8 | ||||
339 | sDiskCacheCapacity); | 8 | ||||
340 | } | 8 |
|
Times Different | |||||
119 | LOG(("NulHttpTransaction::NullHttpTransaction() " | 4 |
|
Times Different | |||||
47 | NewHeapAtom(const char *value) { | 9 | ||||
48 | int len = strlen(value); | 9 | ||||
51 | reinterpret_cast |
9 | ||||
52 | if (!a) | 9 | ||||
54 | memcpy(a->value, value, len + 1); | 9 | ||||
57 | a->next = sHeapAtoms; | 9 | ||||
58 | sHeapAtoms = a; | 9 | ||||
60 | return a; | 9 | ||||
135 | HttpHeapAtom *next = sHeapAtoms->next; | 9 | ||||
136 | free(sHeapAtoms); | 9 | ||||
137 | sHeapAtoms = next; | 9 | ||||
172 | HttpHeapAtom *heapAtom = NewHeapAtom(str); | 9 | ||||
173 | if (!heapAtom) | 9 | ||||
176 | stub->key = atom._val = heapAtom->value; | 9 | ||||
177 | return atom; | 9 |
|
Times Different | |||||
23 | nsHttpActivityEvent(nsISupports* aHttpChannel, | 4 | ||||
37 | , mObservers(*aObservers) | 4 | ||||
39 | } | 4 | ||||
41 | NS_IMETHOD Run() override | 4 | ||||
43 | for (size_t i = 0 ; i < mObservers.Length() ; i++) { | 4 | ||||
45 | mObservers[i]->ObserveActivity(mHttpChannel, mActivityType, | 4 | ||||
48 | mExtraStringData); | 4 | ||||
50 | return NS_OK; | 4 | ||||
54 | virtual ~nsHttpActivityEvent() | 4 | ||||
55 | { | 4 | ||||
56 | } | 4 | ||||
82 | nsHttpActivityDistributor::ObserveActivity(nsISupports *aHttpChannel, | 4 | ||||
91 | MutexAutoLock lock(mLock); | 4 | ||||
93 | if (!mObservers.Length()) | 4 | ||||
99 | &mObservers); | 4 | ||||
101 | NS_ENSURE_TRUE(event, NS_ERROR_OUT_OF_MEMORY); | 4 | ||||
102 | return NS_DispatchToMainThread(event); | 4 |
|
Times Different | |||||
749 | mTransactionPump->Suspend(); | 2 | ||||
7916 | return CallQueryInterface(mCacheEntry, token); | 2 | ||||
8884 | rvTransaction = mTransactionPump->Resume(); | 2 |
|
Times Different | |||||
3713 | tmpFlags |= nsISocketTransport::DISABLE_IPV6; | 9 |
|
Times Different | |||||
256 | LOG(("nsHttpTransaction::Init() " \ | 4 | ||||
335 | rv = mActivityDistributor->ObserveActivity( | 4 | ||||
340 | mReqHeaderBuf); | 4 | ||||
341 | if (NS_FAILED(rv)) { | 4 | ||||
596 | if ((mHasRequestBody) && | 4 | ||||
609 | nsresult rv = mActivityDistributor->ObserveActivity( | 4 | ||||
615 | EmptyCString()); | 4 | ||||
616 | if (NS_FAILED(rv)) { | 4 | ||||
955 | if (!mResponseIsComplete) { | 4 | ||||
969 | nsresult rv = mActivityDistributor->ObserveActivity( | 4 | ||||
973 | PR_Now(), 0, EmptyCString()); | 4 | ||||
974 | if (NS_FAILED(rv)) { | 4 | ||||
1389 | mReportedStart = true; | 4 | ||||
1390 | rv = mActivityDistributor->ObserveActivity( | 4 | ||||
1394 | PR_Now(), 0, EmptyCString()); | 4 | ||||
1395 | if (NS_FAILED(rv)) { | 4 | ||||
1696 | rv = mActivityDistributor->ObserveActivity( | 4 | ||||
1702 | EmptyCString()); | 4 | ||||
1703 | if (NS_FAILED(rv)) { | 4 | ||||
1752 | !mReportedResponseHeader) { | 4 | ||||
1753 | mReportedResponseHeader = true; | 4 | ||||
1754 | nsAutoCString completeResponseHeaders; | 4 | ||||
1755 | mResponseHead->Flatten(completeResponseHeaders, false); | 4 | ||||
1756 | completeResponseHeaders.AppendLiteral("\r\n"); | 4 | ||||
1757 | rv = mActivityDistributor->ObserveActivity( | 4 | ||||
1762 | completeResponseHeaders); | 4 | ||||
1763 | if (NS_FAILED(rv)) { | 4 |
|
Times Different | |||||
189 | thred->id = id; | 8 | ||||
190 | thred->idSet = PR_TRUE; | 8 | ||||
521 | PR_ASSERT(pthread_equal(thred->id, id)); | 8 |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
Error: Couldn't find the file in hg. |
|
Times Different | |||||
1788 | if (resumable) { | 6 | ||||
1789 | errorCode = XML_ERROR_SUSPENDED; | 6 | ||||
1790 | return XML_STATUS_ERROR; | 6 | ||||
4782 | *nextPtr = next; | 7 | ||||
4783 | return XML_ERROR_NONE; | 7 |
|
Times Different | |||||
107 | class nsParserContinueEvent : public Runnable | 7 | ||||
112 | explicit nsParserContinueEvent(nsParser* aParser) | 7 | ||||
114 | , mParser(aParser) | 7 | ||||
115 | {} | 7 | ||||
117 | NS_IMETHOD Run() override | 7 | ||||
119 | mParser->HandleParserContinueEvent(this); | 7 | ||||
120 | return NS_OK; | 7 | ||||
202 | cb.NoteXPCOMChild(pc->mTokenizer); | 2 | ||||
203 | pc = pc->mPrevContext; | 2 | ||||
223 | nsParser::PostContinueEvent() | 7 | ||||
225 | if (!(mFlags & NS_PARSER_FLAG_PENDING_CONTINUE_EVENT)) { | 7 | ||||
227 | NS_ASSERTION(!mContinueEvent, "bad"); | 7 | ||||
231 | nsCOMPtr |
7 | ||||
232 | if (NS_FAILED(NS_DispatchToCurrentThread(event))) { | 7 | ||||
235 | mFlags |= NS_PARSER_FLAG_PENDING_CONTINUE_EVENT; | 7 | ||||
236 | mContinueEvent = event; | 7 | ||||
237 | } | 7 | ||||
239 | return NS_OK; | 7 | ||||
711 | void nsParser::HandleParserContinueEvent(nsParserContinueEvent *ev) | 7 | ||||
714 | if (mContinueEvent != ev) | 7 | ||||
715 | return; | 7 | ||||
717 | mFlags &= ~NS_PARSER_FLAG_PENDING_CONTINUE_EVENT; | 7 | ||||
718 | mContinueEvent = nullptr; | 7 | ||||
720 | NS_ASSERTION(IsOkToProcessNetworkData(), | 7 | ||||
722 | ContinueInterruptedParsing(); | 7 | ||||
1061 | PostContinueEvent(); | 7 |
|
Times Different | |||||
288 | nss_hash_enumerator(PLHashEntry *he, PRIntn index, void *arg) | 10 | ||||
290 | struct arg_str *as = (struct arg_str *)arg; | 10 | ||||
291 | as->fcn(he->key, he->value, as->closure); | 10 | ||||
292 | return HT_ENUMERATE_NEXT; | 10 |
|
Times Different | |||||
264 | PORT_SetError(SEC_ERROR_ADDING_CERT); | 10 | ||||
265 | return SECFailure; /* wasn't a temp cert */ | 10 | ||||
267 | stanNick = nssCertificate_GetNickname(c, NULL); | 10 | ||||
268 | if (stanNick && nickname && strcmp(nickname, stanNick) != 0) { | 10 | ||||
274 | if (!stanNick && nickname) { | 10 | ||||
276 | stanNick = nssUTF8_Duplicate((NSSUTF8 *)nickname, NULL); | 10 | ||||
279 | nssCertificateStore_Lock(context->certStore, &lockTrace); | 10 | ||||
280 | nssCertificateStore_RemoveCertLOCKED(context->certStore, c); | 10 | ||||
281 | nssCertificateStore_Unlock(context->certStore, &lockTrace, &unlockTrace); | 10 | ||||
282 | c->object.cryptoContext = NULL; | 10 | ||||
284 | slot = PK11_GetInternalKeySlot(); | 10 | ||||
285 | internal = PK11Slot_GetNSSToken(slot); | 10 | ||||
286 | permInstance = nssToken_ImportCertificate( | 10 | ||||
287 | internal, NULL, NSSCertificateType_PKIX, &c->id, stanNick, &c->encoding, | 10 | ||||
288 | &c->issuer, &c->subject, &c->serial, cert->emailAddr, PR_TRUE); | 10 | ||||
289 | nss_ZFreeIf(stanNick); | 10 | ||||
290 | stanNick = NULL; | 10 | ||||
291 | PK11_FreeSlot(slot); | 10 | ||||
292 | if (!permInstance) { | 10 | ||||
298 | nssPKIObject_AddInstance(&c->object, permInstance); | 10 | ||||
299 | nssTrustDomain_AddCertsToCache(STAN_GetDefaultTrustDomain(), &c, 1); | 10 | ||||
301 | cert->nssCertificate = NULL; | 10 | ||||
302 | cert = STAN_GetCERTCertificateOrRelease(c); /* should return same pointer */ | 10 | ||||
303 | if (!cert) { | 10 | ||||
307 | CERT_LockCertTempPerm(cert); | 10 | ||||
308 | cert->istemp = PR_FALSE; | 10 | ||||
309 | cert->isperm = PR_TRUE; | 10 | ||||
310 | CERT_UnlockCertTempPerm(cert); | 10 | ||||
311 | if (!trust) { | 10 |
|
Times Different | |||||
221 | newoff = hashp->BSIZE; | 12 |
|
Times Different | |||||
209 | nssCKObject_SetAttributes( | 10 | ||||
217 | void *epv = nssSlot_GetCryptokiEPV(slot); | 10 | ||||
218 | nssSession_EnterMonitor(session); | 10 | ||||
219 | ckrv = CKAPI(epv)->C_SetAttributeValue(session->handle, object, | 10 | ||||
221 | nssSession_ExitMonitor(session); | 10 | ||||
222 | if (ckrv == CKR_OK) { | 10 |
|
Times Different | |||||
493 | NSSSlot *slot = nssToken_GetSlot(tok); | 10 | ||||
494 | nssSession *session = nssSlot_CreateSession(slot, NULL, PR_TRUE); | 10 | ||||
495 | if (!session) { | 10 | ||||
504 | NSS_CK_TEMPLATE_START(cert_tmpl, attr, ctsize); | 10 | ||||
505 | NSS_CK_SET_ATTRIBUTE_NULL(attr, CKA_VALUE); | 10 | ||||
506 | NSS_CK_TEMPLATE_FINISH(cert_tmpl, attr, ctsize); | 10 | ||||
507 | status = nssCKObject_GetAttributes(rvObject->handle, | 10 | ||||
510 | NSS_CK_ATTRIBUTE_TO_ITEM(cert_tmpl, &existingDER); | 10 | ||||
511 | if (status == PR_SUCCESS) { | 10 | ||||
512 | if (!nssItem_Equal(encoding, &existingDER, NULL)) { | 10 | ||||
516 | nss_ZFreeIf(existingDER.data); | 10 | ||||
518 | if (status == PR_FAILURE) { | 10 | ||||
529 | NSS_CK_TEMPLATE_START(cert_tmpl, attr, ctsize); | 10 | ||||
530 | NSS_CK_SET_ATTRIBUTE_ITEM(attr, CKA_ID, id); | 10 | ||||
531 | NSS_CK_SET_ATTRIBUTE_UTF8(attr, CKA_LABEL, nickname); | 10 | ||||
532 | NSS_CK_TEMPLATE_FINISH(cert_tmpl, attr, ctsize); | 10 | ||||
534 | nssCKObject_SetAttributes(rvObject->handle, | 10 | ||||
537 | if (!rvObject->label && nickname) { | 10 | ||||
540 | nssSession_Destroy(session); | 10 | ||||
541 | nssSlot_Destroy(slot); | 10 |
|
Times Different | |||||
77 | nssCryptokiObject_Equal( | 10 | ||||
81 | return (o1->token == o2->token && o1->handle == o2->handle); | 10 |
|
Times Different | |||||
596 | client &= ~(CERTDB_TRUSTED_CA | CERTDB_NS_TRUSTED_CA); | 10 | ||||
597 | rvTrust->sslFlags |= CERTDB_TRUSTED_CLIENT_CA; | 10 |
|
Times Different | |||||
171 | if (nssCryptokiObject_Equal(object->instances[i], instance)) { | 10 | ||||
176 | if (found) { | 10 | ||||
182 | nss_ZFreeIf(object->instances[i]->label); | 10 | ||||
183 | object->instances[i]->label = instance->label; | 10 | ||||
184 | nssPKIObject_Unlock(object); | 10 | ||||
185 | instance->label = NULL; | 10 | ||||
186 | nssCryptokiObject_Destroy(instance); | 10 | ||||
187 | return PR_SUCCESS; | 10 |
|
Times Different | |||||
391 | match_nickname(const void *k, void *v, void *a) | 10 | ||||
396 | nssList *subjectList = (nssList *)v; | 10 | ||||
397 | struct nickname_template_str *nt = (struct nickname_template_str *)a; | 10 | ||||
398 | nssrv = nssList_GetArray(subjectList, (void **)&c, 1); | 10 | ||||
399 | nickname = nssCertificate_GetNickname(c, NULL); | 10 | ||||
400 | if (nssrv == PR_SUCCESS && nickname && | 10 | ||||
404 | nss_ZFreeIf(nickname); | 10 | ||||
405 | } | 10 |
|
Times Different | |||||
675 | merge_object_instances( | 10 | ||||
681 | SECStatus rv = SECSuccess; | 10 | ||||
683 | instances = nssPKIObject_GetInstances(from); | 10 | ||||
684 | if (instances == NULL) { | 10 | ||||
687 | for (ci = instances, i = 0; *ci; ci++, i++) { | 10 | ||||
688 | nssCryptokiObject *instance = nssCryptokiObject_Clone(*ci); | 10 | ||||
689 | if (instance) { | 10 | ||||
690 | if (nssPKIObject_AddInstance(to, instance) == PR_SUCCESS) { | 10 | ||||
691 | continue; | 10 | ||||
699 | nssCryptokiObjectArray_Destroy(instances); | 10 | ||||
700 | return rv; | 10 | ||||
720 | ce->hits++; | 10 | ||||
721 | ce->lastHit = PR_Now(); | 10 | ||||
722 | rvCert = nssCertificate_AddRef(ce->entry.cert); | 10 | ||||
726 | PZ_Unlock(td->cache->lock); | 10 | ||||
727 | nss_ZFreeIf(certNickname); | 10 | ||||
732 | if (merge_object_instances(&rvCert->object, &cert->object) != SECSuccess) { | 10 | ||||
736 | STAN_ForceCERTCertificateUpdate(rvCert); | 10 | ||||
737 | nssCertificate_Destroy(cert); | 10 |
|
Times Different | |||||
1133 | return lg_ULongAttribute(attribute, type, | 10 | ||||
1140 | return lg_ULongAttribute(attribute, type, | 10 | ||||
1246 | return LG_CLONE_ATTR(attribute, type, lg_StaticTrueAttr); | 10 | ||||
1456 | lg_SetCertAttribute(LGObjectCache *obj, CK_ATTRIBUTE_TYPE type, | 10 | ||||
1461 | char *nickname = NULL; | 10 | ||||
1467 | if (type == CKA_NSS_EMAIL) { | 10 | ||||
1471 | certHandle = lg_getCertDB(obj->sdb); | 10 | ||||
1472 | if (certHandle == NULL) { | 10 | ||||
1477 | if ((type != CKA_LABEL) && (type != CKA_ID)) { | 10 | ||||
1482 | cert = lg_getCert(obj, certHandle); | 10 | ||||
1483 | if (cert == NULL) { | 10 | ||||
1491 | if (type == CKA_ID) { | 10 | ||||
1492 | if (((cert->trust->sslFlags & CERTDB_USER) == 0) && | 10 | ||||
1493 | ((cert->trust->emailFlags & CERTDB_USER) == 0) && | 10 | ||||
1494 | ((cert->trust->objectSigningFlags & CERTDB_USER) == 0)) { | 10 | ||||
1497 | keyHandle = lg_getKeyDB(obj->sdb); | 10 | ||||
1498 | if (keyHandle) { | 10 | ||||
1499 | if (nsslowkey_KeyForCertExists(keyHandle, cert)) { | 10 | ||||
1513 | if (value != NULL) { | 10 | ||||
1514 | nickname = PORT_ZAlloc(len + 1); | 10 | ||||
1515 | if (nickname == NULL) { | 10 | ||||
1519 | PORT_Memcpy(nickname, value, len); | 10 | ||||
1520 | nickname[len] = 0; | 10 | ||||
1522 | rv = nsslowcert_AddPermNickname(certHandle, cert, nickname); | 10 | ||||
1523 | crv = (rv == SECSuccess) ? CKR_OK : CKR_DEVICE_ERROR; | 10 | ||||
1526 | if (nickname) { | 10 | ||||
1527 | PORT_Free(nickname); | 10 | ||||
1529 | return crv; | 10 | ||||
1729 | crv = lg_SetCertAttribute(obj, attr->type, | 10 | ||||
1730 | attr->pValue, attr->ulValueLen); | 10 | ||||
1731 | break; | 10 |
|
Times Different | |||||
1468 | DecodeDBNicknameEntry(certDBEntryNickname *entry, SECItem *dbentry, | 10 | ||||
1474 | if (dbentry->len < DB_NICKNAME_ENTRY_HEADER_LEN) { | 10 | ||||
1480 | entry->subjectName.len = ((dbentry->data[0] << 8) | dbentry->data[1]); | 10 | ||||
1481 | lenDiff = dbentry->len - | 10 | ||||
1483 | if (lenDiff) { | 10 | ||||
1493 | entry->subjectName.data = | 10 | ||||
1494 | (unsigned char *)PORT_ArenaAlloc(entry->common.arena, | 10 | ||||
1495 | entry->subjectName.len); | 10 | ||||
1496 | if (entry->subjectName.data == NULL) { | 10 | ||||
1500 | PORT_Memcpy(entry->subjectName.data, | 10 | ||||
1501 | &dbentry->data[DB_NICKNAME_ENTRY_HEADER_LEN], | 10 | ||||
1502 | entry->subjectName.len); | 10 | ||||
1503 | entry->subjectName.type = siBuffer; | 10 | ||||
1505 | entry->nickname = (char *)PORT_ArenaAlloc(entry->common.arena, | 10 | ||||
1506 | PORT_Strlen(nickname) + 1); | 10 | ||||
1507 | if (entry->nickname) { | 10 | ||||
1508 | PORT_Strcpy(entry->nickname, nickname); | 10 | ||||
1656 | if (dbentry.len < DB_NICKNAME_ENTRY_HEADER_LEN) { | 10 | ||||
1661 | rv = DecodeDBNicknameEntry(entry, &dbentry, nickname); | 10 | ||||
1662 | if (rv != SECSuccess) { | 10 | ||||
1666 | PORT_FreeArena(tmparena, PR_FALSE); | 10 | ||||
1667 | return (entry); | 10 | ||||
3191 | AddNicknameToPermCert(NSSLOWCERTCertDBHandle *dbhandle, | 10 | ||||
3197 | entry = cert->dbEntry; | 10 | ||||
3198 | PORT_Assert(entry != NULL); | 10 | ||||
3199 | if (entry == NULL) { | 10 | ||||
3203 | pkcs11_freeNickname(entry->nickname, entry->nicknameSpace); | 10 | ||||
3204 | entry->nickname = NULL; | 10 | ||||
3205 | entry->nickname = pkcs11_copyNickname(nickname, entry->nicknameSpace, | 10 | ||||
3208 | rv = WriteDBCertEntry(dbhandle, entry); | 10 | ||||
3209 | if (rv) { | 10 | ||||
3213 | pkcs11_freeNickname(cert->nickname, cert->nicknameSpace); | 10 | ||||
3214 | cert->nickname = NULL; | 10 | ||||
3215 | cert->nickname = pkcs11_copyNickname(nickname, cert->nicknameSpace, | 10 | ||||
3218 | return (SECSuccess); | 10 | ||||
3229 | nsslowcert_AddPermNickname(NSSLOWCERTCertDBHandle *dbhandle, | 10 | ||||
3232 | SECStatus rv = SECFailure; | 10 | ||||
3233 | certDBEntrySubject *entry = NULL; | 10 | ||||
3234 | certDBEntryNickname *nicknameEntry = NULL; | 10 | ||||
3236 | nsslowcert_LockDB(dbhandle); | 10 | ||||
3238 | entry = ReadDBSubjectEntry(dbhandle, &cert->derSubject); | 10 | ||||
3239 | if (entry == NULL) | 10 | ||||
3242 | if (entry->nickname == NULL) { | 10 | ||||
3264 | rv = AddNicknameToPermCert(dbhandle, cert, entry->nickname); | 10 | ||||
3265 | if (rv != SECSuccess) { | 10 | ||||
3270 | nicknameEntry = ReadDBNicknameEntry(dbhandle, entry->nickname); | 10 | ||||
3271 | if (nicknameEntry == NULL) { | 10 | ||||
3287 | if (entry) { | 10 | ||||
3288 | DestroyDBEntry((certDBEntry *)entry); | 10 | ||||
3290 | if (nicknameEntry) { | 10 | ||||
3291 | DestroyDBEntry((certDBEntry *)nicknameEntry); | 10 | ||||
3293 | nsslowcert_UnlockDB(dbhandle); | 10 | ||||
3294 | return (rv); | 10 |
|
Times Different | |||||
1941 | object->refLock = PZ_NewLock(nssILockRefLock); | 10 |
|
Times Different | |||||
894 | } else if ((attr2 == NULL) || ((CK_LONG)attr2->ulValueLen <= 0)) { | 10 | ||||
898 | subject.type = CKA_SUBJECT; | 10 | ||||
899 | subject.pValue = NULL; | 10 | ||||
900 | subject.ulValueLen = 0; | 10 | ||||
901 | crv = (*db->sdb_GetAttributeValue)(db, sourceID, &subject, 1); | 10 | ||||
902 | if (crv != CKR_OK) { | 10 | ||||
905 | if ((CK_LONG)subject.ulValueLen < 0) { | 10 | ||||
909 | temp1 = subject.pValue = PORT_Alloc(++subject.ulValueLen); | 10 | ||||
910 | if (temp1 == NULL) { | 10 | ||||
914 | crv = (*db->sdb_GetAttributeValue)(db, sourceID, &subject, 1); | 10 | ||||
915 | if (crv != CKR_OK) { | 10 |
|
Times Different | |||||
150 | nsIEventTarget *target = mDBConnection->getAsyncExecutionTarget(); | 4 | ||||
151 | if (target) { | 4 | ||||
153 | new LastDitchSqliteStatementFinalizer(mDBConnection, mAsyncStatement); | 4 | ||||
154 | (void)target->Dispatch(event, NS_DISPATCH_NORMAL); | 4 |
|
Times Different | |||||
305 | rv = notifyResults(); | 2 | ||||
306 | if (NS_FAILED(rv)) | 2 | ||||
310 | mIntervalStart = now; | 2 |
|
Times Different | |||||
1152 | nsDependentCString statementString(::sqlite3_sql(aStatement)); | 4 | ||||
1154 | duration.ToMilliseconds()); | 4 | ||||
1238 | nsDependentCString statementString(aSqlString); | 5 | ||||
1240 | duration.ToMilliseconds()); | 5 |
|
Times Different | |||||
585 | CodedOutputStream::CodedOutputStream(ZeroCopyOutputStream* output) | 9 | ||||
591 | aliasing_enabled_(false) { | 9 | ||||
593 | Refresh(); | 9 | ||||
597 | had_error_ = false; | 9 | ||||
598 | } | 9 | ||||
600 | CodedOutputStream::~CodedOutputStream() { | 9 | ||||
601 | if (buffer_size_ > 0) { | 9 | ||||
604 | } | 9 | ||||
626 | void CodedOutputStream::WriteRaw(const void* data, int size) { | 9 | ||||
627 | while (buffer_size_ < size) { | 9 | ||||
631 | if (!Refresh()) return; | 9 | ||||
634 | memcpy(buffer_, data, size); | 9 | ||||
635 | Advance(size); | 9 | ||||
694 | target[0] = static_cast |
9 | ||||
695 | if (value >= (1 << 7)) { | 9 | ||||
717 | target[0] &= 0x7F; | 9 | ||||
718 | return target + 1; | 9 | ||||
722 | void CodedOutputStream::WriteVarint32(uint32 value) { | 9 | ||||
723 | if (buffer_size_ >= kMaxVarint32Bytes) { | 9 | ||||
726 | uint8* target = buffer_; | 9 | ||||
727 | uint8* end = WriteVarint32FallbackToArrayInline(value, target); | 9 | ||||
728 | int size = end - target; | 9 | ||||
729 | Advance(size); | 9 | ||||
735 | while (value > 0x7F) { | 9 | ||||
739 | bytes[size++] = static_cast |
9 | ||||
740 | WriteRaw(bytes, size); | 9 | ||||
742 | } | 9 | ||||
849 | bool CodedOutputStream::Refresh() { | 9 | ||||
851 | if (output_->Next(&void_buffer, &buffer_size_)) { | 9 | ||||
852 | buffer_ = reinterpret_cast |
9 | ||||
853 | total_bytes_ += buffer_size_; | 9 | ||||
854 | return true; | 9 |
|
Times Different | |||||
44 | ZeroCopyOutputStream::~ZeroCopyOutputStream() {} | 9 |
|
Times Different | |||||
110 | ArrayOutputStream::ArrayOutputStream(void* data, int size, int block_size) | 9 | ||||
115 | last_returned_size_(0) { | 9 | ||||
116 | } | 9 | ||||
118 | ArrayOutputStream::~ArrayOutputStream() { | 9 | ||||
119 | } | 9 | ||||
121 | bool ArrayOutputStream::Next(void** data, int* size) { | 9 | ||||
122 | if (position_ < size_) { | 9 | ||||
123 | last_returned_size_ = min(block_size_, size_ - position_); | 9 | ||||
124 | *data = data_ + position_; | 9 | ||||
125 | *size = last_returned_size_; | 9 | ||||
126 | position_ += last_returned_size_; | 9 | ||||
127 | return true; | 9 |
|
Times Different | |||||
217 | uint8* MessageLite::SerializeWithCachedSizesToArray(uint8* target) const { | 9 | ||||
220 | int size = GetCachedSize(); | 9 | ||||
221 | io::ArrayOutputStream out(target, size); | 9 | ||||
222 | io::CodedOutputStream coded_out(&out); | 9 | ||||
223 | SerializeWithCachedSizes(&coded_out); | 9 | ||||
224 | GOOGLE_CHECK(!coded_out.HadError()); | 9 | ||||
225 | return target + size; | 9 | ||||
272 | bool MessageLite::AppendToString(string* output) const { | 9 | ||||
273 | GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this); | 9 | ||||
274 | return AppendPartialToString(output); | 9 | ||||
277 | bool MessageLite::AppendPartialToString(string* output) const { | 9 | ||||
278 | int old_size = output->size(); | 9 | ||||
279 | int byte_size = ByteSize(); | 9 | ||||
280 | STLStringResizeUninitialized(output, old_size + byte_size); | 9 | ||||
282 | reinterpret_cast |
9 | ||||
283 | uint8* end = SerializeWithCachedSizesToArray(start); | 9 | ||||
284 | if (end - start != byte_size) { | 9 | ||||
287 | return true; | 9 | ||||
290 | bool MessageLite::SerializeToString(string* output) const { | 9 | ||||
291 | output->clear(); | 9 | ||||
292 | return AppendToString(output); | 9 |
|
Times Different | |||||
367 | void WireFormatLite::WriteEnum(int field_number, int value, | 9 | ||||
371 | } | 9 | ||||
381 | void WireFormatLite::WriteStringMaybeAliased( | 9 | ||||
386 | GOOGLE_CHECK(value.size() <= kint32max); | 9 | ||||
387 | output->WriteVarint32(value.size()); | 9 | ||||
388 | output->WriteRawMaybeAliased(value.data(), value.size()); | 9 | ||||
389 | } | 9 | ||||
415 | void WireFormatLite::WriteMessage(int field_number, | 9 | ||||
419 | const int size = value.GetCachedSize(); | 9 | ||||
420 | output->WriteVarint32(size); | 9 | ||||
421 | value.SerializeWithCachedSizes(output); | 9 | ||||
422 | } | 9 |
|
Times Different | |||||
268 | const char16_t* filename = aOb.Filename(); | 5 | ||||
271 | if (!filename) { | 5 | ||||
779 | TelemetryImpl::ReflectSQL(const SlowSQLEntryType *entry, | 7 | ||||
784 | if (stat->hitCount == 0) | 7 | ||||
787 | const nsACString &sql = entry->GetKey(); | 7 | ||||
789 | JS::Rooted |
7 | ||||
790 | if (!arrayObj) { | 7 | ||||
793 | return (JS_DefineElement(cx, arrayObj, 0, stat->hitCount, JSPROP_ENUMERATE) | 7 | ||||
794 | && JS_DefineElement(cx, arrayObj, 1, stat->totalTime, JSPROP_ENUMERATE) | 7 | ||||
795 | && JS_DefineProperty(cx, obj, sql.BeginReading(), arrayObj, | 7 | ||||
796 | JSPROP_ENUMERATE)); | 7 | ||||
800 | TelemetryImpl::ReflectMainThreadSQL(SlowSQLEntryType *entry, JSContext *cx, | 7 | ||||
803 | return ReflectSQL(entry, &entry->mData.mainThread, cx, obj); | 7 | ||||
807 | TelemetryImpl::ReflectOtherThreadsSQL(SlowSQLEntryType *entry, JSContext *cx, | 7 | ||||
810 | return ReflectSQL(entry, &entry->mData.otherThreads, cx, obj); | 7 | ||||
1571 | TelemetryImpl::StoreSlowSQL(const nsACString &sql, uint32_t delay, | 7 | ||||
1574 | AutoHashtable |
7 | ||||
1575 | if (state == Sanitized) | 7 | ||||
1576 | slowSQLMap = &(sTelemetry->mSanitizedSQL); | 7 | ||||
1578 | slowSQLMap = &(sTelemetry->mPrivateSQL); | 7 | ||||
1580 | MutexAutoLock hashMutex(sTelemetry->mHashMutex); | 7 | ||||
1582 | SlowSQLEntryType *entry = slowSQLMap->GetEntry(sql); | 7 | ||||
1583 | if (!entry) { | 7 | ||||
1584 | entry = slowSQLMap->PutEntry(sql); | 7 | ||||
1585 | if (MOZ_UNLIKELY(!entry)) | 7 | ||||
1587 | entry->mData.mainThread.hitCount = 0; | 7 | ||||
1588 | entry->mData.mainThread.totalTime = 0; | 7 | ||||
1589 | entry->mData.otherThreads.hitCount = 0; | 7 | ||||
1590 | entry->mData.otherThreads.totalTime = 0; | 7 | ||||
1593 | if (NS_IsMainThread()) { | 7 | ||||
1594 | entry->mData.mainThread.hitCount++; | 5 | ||||
1595 | entry->mData.mainThread.totalTime += delay; | 5 | ||||
1597 | entry->mData.otherThreads.hitCount++; | 4 | ||||
1598 | entry->mData.otherThreads.totalTime += delay; | 4 | ||||
1599 | } | 7 | ||||
1646 | TelemetryImpl::SanitizeSQL(const nsACString &sql) { | 7 | ||||
1648 | int length = sql.Length(); | 7 | ||||
1658 | State state = NORMAL; | 7 | ||||
1659 | int fragmentStart = 0; | 7 | ||||
1660 | for (int i = 0; i < length; i++) { | 7 | ||||
1661 | char character = sql[i]; | 7 | ||||
1662 | char nextCharacter = (i + 1 < length) ? sql[i + 1] : '\0'; | 7 | ||||
1664 | switch (character) { | 7 | ||||
1667 | if (state == NORMAL) { | 2 | ||||
1668 | state = (character == '\'') ? SINGLE_QUOTE : DOUBLE_QUOTE; | 2 | ||||
1669 | output += nsDependentCSubstring(sql, fragmentStart, i - fragmentStart); | 2 | ||||
1670 | output += ":private"; | 2 | ||||
1671 | fragmentStart = -1; | 2 | ||||
1672 | } else if ((state == SINGLE_QUOTE && character == '\'') || | 2 | ||||
1674 | if (nextCharacter == character) { | 2 | ||||
1678 | state = NORMAL; | 2 | ||||
1679 | fragmentStart = i + 1; | 2 | ||||
1692 | if (state == DASH_COMMENT) { | 4 | ||||
1716 | if ((fragmentStart >= 0) && fragmentStart < length) | 7 | ||||
1717 | output += nsDependentCSubstring(sql, fragmentStart, length - fragmentStart); | 7 | ||||
1719 | return output; | 7 | ||||
1779 | TelemetryImpl::RecordSlowStatement(const nsACString &sql, | 7 | ||||
1783 | MOZ_ASSERT(!sql.IsEmpty()); | 7 | ||||
1784 | MOZ_ASSERT(!dbName.IsEmpty()); | 7 | ||||
1786 | if (!sTelemetry || !TelemetryHistogram::CanRecordExtended()) | 7 | ||||
1791 | for (const TrackedDBEntry& nameEntry : kTrackedDBs) { | 7 | ||||
1792 | MOZ_ASSERT(nameEntry.mNameLength); | 7 | ||||
1793 | const nsDependentCString name(nameEntry.mName, nameEntry.mNameLength); | 7 | ||||
1794 | if (dbName == name) { | 7 | ||||
1795 | recordStatement = true; | 7 | ||||
1800 | if (!recordStatement) { | 7 | ||||
1801 | for (const TrackedDBEntry& prefixEntry : kTrackedDBPrefixes) { | 2 | ||||
1802 | MOZ_ASSERT(prefixEntry.mNameLength); | 2 | ||||
1804 | prefixEntry.mNameLength); | 2 | ||||
1805 | if (StringBeginsWith(dbName, prefix)) { | 2 | ||||
1806 | recordStatement = true; | 2 | ||||
1812 | if (recordStatement) { | 7 | ||||
1813 | nsAutoCString sanitizedSQL(SanitizeSQL(sql)); | 7 | ||||
1814 | if (sanitizedSQL.Length() > kMaxSlowStatementLength) { | 7 | ||||
1818 | sanitizedSQL.AppendPrintf(" /* %s */", nsPromiseFlatCString(dbName).get()); | 7 | ||||
1819 | StoreSlowSQL(sanitizedSQL, delay, Sanitized); | 7 | ||||
1822 | nsAutoCString aggregate; | 2 | ||||
1824 | nsPromiseFlatCString(dbName).get()); | 2 | ||||
1825 | StoreSlowSQL(aggregate, delay, Sanitized); | 2 | ||||
1828 | nsAutoCString fullSQL; | 7 | ||||
1831 | nsPromiseFlatCString(dbName).get()); | 7 | ||||
1832 | StoreSlowSQL(fullSQL, delay, Unsanitized); | 7 | ||||
2294 | RecordSlowSQLStatement(const nsACString &statement, | 7 | ||||
2298 | TelemetryImpl::RecordSlowStatement(statement, dbName, delay); | 7 | ||||
2299 | } | 7 |
|
Times Different | |||||
1941 | TelemetryHistogram::CanRecordExtended() { | 7 | ||||
1942 | StaticMutexAutoLock locker(gTelemetryHistogramMutex); | 7 | ||||
1943 | return internal_CanRecordExtended(); | 7 |
|
Times Different | |||||
384 | aResult = mTableRequestResult; | 9 | ||||
1577 | LoadMetadata(file, aResult); | 2 | ||||
1578 | continue; | 2 |
|
Times Different | |||||
2080 | LOG(("The previous update observer hasn't been notified.")); | 2 |
|
Times Different | |||||
167 | nsCOMPtr |
9 | ||||
168 | NS_ENSURE_SUCCESS(rv, rv); | 9 | ||||
170 | rv = httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("X-HTTP-Method-Override"), | 9 | ||||
172 | false); | 9 | ||||
173 | NS_ENSURE_SUCCESS(rv, rv); | 9 | ||||
252 | updateUrl.AppendPrintf("&$req=%s", nsCString(aRequestPayload).get()); | 9 | ||||
323 | LOG(("Service busy, already updating, queuing update %s from %s", | 2 | ||||
324 | aRequestPayload.Data(), aUpdateUrl.Data())); | 2 | ||||
325 | *_retval = false; | 2 | ||||
326 | PendingRequest *request = mPendingRequests.AppendElement(); | 2 | ||||
327 | request->mTables = aRequestTables; | 2 | ||||
328 | request->mRequestPayload = aRequestPayload; | 2 | ||||
329 | request->mIsPostRequest = aIsPostRequest; | 2 | ||||
330 | request->mUrl = aUpdateUrl; | 2 | ||||
331 | request->mSuccessCallback = aSuccessCallback; | 2 | ||||
332 | request->mUpdateErrorCallback = aUpdateErrorCallback; | 2 | ||||
333 | request->mDownloadErrorCallback = aDownloadErrorCallback; | 2 | ||||
338 | mFetchNextRequestTimer = do_CreateInstance("@mozilla.org/timer;1", &rv); | 2 | ||||
339 | if (NS_SUCCEEDED(rv)) { | 2 | ||||
340 | rv = mFetchNextRequestTimer->InitWithCallback(this, | 2 | ||||
342 | nsITimer::TYPE_ONE_SHOT); | 2 | ||||
439 | PendingRequest request = mPendingRequests[0]; | 2 | ||||
440 | mPendingRequests.RemoveElementAt(0); | 2 | ||||
441 | LOG(("Stream updater: fetching next request: %s, %s", | 2 | ||||
442 | request.mTables.get(), request.mUrl.get())); | 2 | ||||
452 | &dummy); | 2 | ||||
453 | return NS_OK; | 2 | ||||
934 | nsUrlClassifierStreamUpdater::Notify(nsITimer *timer) | 2 | ||||
936 | LOG(("nsUrlClassifierStreamUpdater::Notify [%p]", this)); | 2 | ||||
938 | if (timer == mFetchNextRequestTimer) { | 2 | ||||
939 | mFetchNextRequestTimer = nullptr; | 2 | ||||
940 | FetchNextRequest(); | 2 | ||||
941 | return NS_OK; | 2 |
|
Times Different | |||||
105 | struct PendingRequest { | 2 |
|
Times Different | |||||
104 | InitListUpdateRequest(ThreatType aThreatType, | 9 | ||||
108 | aListUpdateRequest->set_threat_type(aThreatType); | 9 | ||||
109 | aListUpdateRequest->set_platform_type(GetPlatformType()); | 9 | ||||
110 | aListUpdateRequest->set_threat_entry_type(URL); | 9 | ||||
112 | Constraints* contraints = new Constraints(); | 9 | ||||
113 | contraints->add_supported_compressions(RICE); | 9 | ||||
114 | aListUpdateRequest->set_allocated_constraints(contraints); | 9 | ||||
117 | if (aStateBase64[0] != '\0') { | 9 | ||||
124 | } | 9 | ||||
127 | CreateClientInfo() | 9 | ||||
129 | ClientInfo* c = new ClientInfo(); | 9 | ||||
132 | do_GetService(NS_PREFSERVICE_CONTRACTID); | 9 | ||||
134 | nsXPIDLCString clientId; | 9 | ||||
135 | nsresult rv = prefBranch->GetCharPref("browser.safebrowsing.id", | 9 | ||||
136 | getter_Copies(clientId)); | 9 | ||||
138 | if (NS_FAILED(rv)) { | 9 | ||||
142 | c->set_client_id(clientId.get()); | 9 | ||||
144 | return c; | 9 | ||||
261 | nsUrlClassifierUtils::ConvertListNameToThreatType(const nsACString& aListName, | 9 | ||||
264 | for (uint32_t i = 0; i < ArrayLength(THREAT_TYPE_CONV_TABLE); i++) { | 9 | ||||
265 | if (aListName.EqualsASCII(THREAT_TYPE_CONV_TABLE[i].mListName)) { | 9 | ||||
266 | *aThreatType = THREAT_TYPE_CONV_TABLE[i].mThreatType; | 9 | ||||
267 | return NS_OK; | 9 | ||||
330 | nsUrlClassifierUtils::MakeUpdateRequestV4(const char** aListNames, | 9 | ||||
337 | FetchThreatListUpdatesRequest r; | 9 | ||||
338 | r.set_allocated_client(CreateClientInfo()); | 9 | ||||
340 | for (uint32_t i = 0; i < aCount; i++) { | 9 | ||||
341 | nsCString listName(aListNames[i]); | 9 | ||||
343 | nsresult rv = ConvertListNameToThreatType(listName, &threatType); | 9 | ||||
344 | if (NS_FAILED(rv)) { | 9 | ||||
347 | auto lur = r.mutable_list_update_requests()->Add(); | 9 | ||||
348 | InitListUpdateRequest(static_cast |
9 | ||||
352 | std::string s; | 9 | ||||
353 | r.SerializeToString(&s); | 9 | ||||
357 | (const uint8_t*)s.c_str(), | 9 | ||||
359 | out); | 9 | ||||
360 | NS_ENSURE_SUCCESS(rv, rv); | 9 | ||||
364 | return NS_OK; | 9 |
|
Times Different | |||||
129 | bool ThreatType_IsValid(int value) { | 9 | ||||
149 | bool PlatformType_IsValid(int value) { | 9 | ||||
150 | switch(value) { | 9 | ||||
166 | bool CompressionType_IsValid(int value) { | 9 | ||||
167 | switch(value) { | 9 | ||||
177 | bool ThreatEntryType_IsValid(int value) { | 9 | ||||
178 | switch(value) { | 9 | ||||
1401 | FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() { | 9 | ||||
1403 | SharedDtor(); | 9 | ||||
1404 | } | 9 | ||||
1406 | void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedDtor() { | 9 | ||||
1407 | if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { | 9 | ||||
1416 | } | 9 | ||||
1571 | void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SerializeWithCachedSizes( | 9 | ||||
1575 | if (has_max_update_entries()) { | 9 | ||||
1580 | if (has_max_database_entries()) { | 9 | ||||
1585 | if (has_region()) { | 9 | ||||
1591 | for (int i = 0; i < this->supported_compressions_size(); i++) { | 9 | ||||
1593 | 4, this->supported_compressions(i), output); | 9 | ||||
1596 | output->WriteRaw(unknown_fields().data(), | 9 | ||||
1597 | unknown_fields().size()); | 9 | ||||
1599 | } | 9 | ||||
1601 | int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::ByteSize() const { | 9 | ||||
1602 | int total_size = 0; | 9 | ||||
1604 | if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { | 9 | ||||
1629 | int data_size = 0; | 9 | ||||
1630 | for (int i = 0; i < this->supported_compressions_size(); i++) { | 9 | ||||
1632 | this->supported_compressions(i)); | 9 | ||||
1634 | total_size += 1 * this->supported_compressions_size() + data_size; | 9 | ||||
1637 | total_size += unknown_fields().size(); | 9 | ||||
1640 | _cached_size_ = total_size; | 9 | ||||
1642 | return total_size; | 9 | ||||
1738 | FetchThreatListUpdatesRequest_ListUpdateRequest::~FetchThreatListUpdatesRequest_ListUpdateRequest() { | 9 | ||||
1740 | SharedDtor(); | 9 | ||||
1741 | } | 9 | ||||
1743 | void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedDtor() { | 9 | ||||
1744 | if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { | 9 | ||||
1750 | if (this != default_instance_) { | 9 | ||||
1752 | delete constraints_; | 9 | ||||
1754 | } | 9 | ||||
1931 | void FetchThreatListUpdatesRequest_ListUpdateRequest::SerializeWithCachedSizes( | 9 | ||||
1935 | if (has_threat_type()) { | 9 | ||||
1937 | 1, this->threat_type(), output); | 9 | ||||
1941 | if (has_platform_type()) { | 9 | ||||
1943 | 2, this->platform_type(), output); | 9 | ||||
1947 | if (has_state()) { | 9 | ||||
1953 | if (has_constraints()) { | 9 | ||||
1955 | 4, this->constraints(), output); | 9 | ||||
1959 | if (has_threat_entry_type()) { | 9 | ||||
1961 | 5, this->threat_entry_type(), output); | 9 | ||||
1964 | output->WriteRaw(unknown_fields().data(), | 9 | ||||
1965 | unknown_fields().size()); | 9 | ||||
1967 | } | 9 | ||||
1969 | int FetchThreatListUpdatesRequest_ListUpdateRequest::ByteSize() const { | 9 | ||||
1970 | int total_size = 0; | 9 | ||||
1972 | if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { | 9 | ||||
1974 | if (has_threat_type()) { | 9 | ||||
1976 | ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type()); | 9 | ||||
1980 | if (has_platform_type()) { | 9 | ||||
1982 | ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type()); | 9 | ||||
1986 | if (has_threat_entry_type()) { | 9 | ||||
1988 | ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type()); | 9 | ||||
1992 | if (has_state()) { | 9 | ||||
1999 | if (has_constraints()) { | 9 | ||||
2002 | this->constraints()); | 9 | ||||
2006 | total_size += unknown_fields().size(); | 9 | ||||
2009 | _cached_size_ = total_size; | 9 | ||||
2011 | return total_size; | 9 | ||||
2113 | FetchThreatListUpdatesRequest::~FetchThreatListUpdatesRequest() { | 9 | ||||
2115 | SharedDtor(); | 9 | ||||
2116 | } | 9 | ||||
2118 | void FetchThreatListUpdatesRequest::SharedDtor() { | 9 | ||||
2122 | if (this != default_instance_) { | 9 | ||||
2124 | delete client_; | 9 | ||||
2125 | delete chrome_client_info_; | 9 | ||||
2127 | } | 9 | ||||
2238 | void FetchThreatListUpdatesRequest::SerializeWithCachedSizes( | 9 | ||||
2242 | if (has_client()) { | 9 | ||||
2244 | 1, this->client(), output); | 9 | ||||
2248 | for (int i = 0; i < this->list_update_requests_size(); i++) { | 9 | ||||
2250 | 3, this->list_update_requests(i), output); | 9 | ||||
2254 | if (has_chrome_client_info()) { | 9 | ||||
2259 | output->WriteRaw(unknown_fields().data(), | 9 | ||||
2260 | unknown_fields().size()); | 9 | ||||
2262 | } | 9 | ||||
2264 | int FetchThreatListUpdatesRequest::ByteSize() const { | 9 | ||||
2265 | int total_size = 0; | 9 | ||||
2267 | if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { | 9 | ||||
2269 | if (has_client()) { | 9 | ||||
2272 | this->client()); | 9 | ||||
2276 | if (has_chrome_client_info()) { | 9 | ||||
2284 | total_size += 1 * this->list_update_requests_size(); | 9 | ||||
2285 | for (int i = 0; i < this->list_update_requests_size(); i++) { | 9 | ||||
2288 | this->list_update_requests(i)); | 9 | ||||
2291 | total_size += unknown_fields().size(); | 9 | ||||
2294 | _cached_size_ = total_size; | 9 | ||||
2296 | return total_size; | 9 | ||||
2324 | bool FetchThreatListUpdatesRequest::IsInitialized() const { | 9 | ||||
2326 | return true; | 9 | ||||
4322 | ClientInfo::~ClientInfo() { | 9 | ||||
4324 | SharedDtor(); | 9 | ||||
4325 | } | 9 | ||||
4327 | void ClientInfo::SharedDtor() { | 9 | ||||
4328 | if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { | 9 | ||||
4329 | delete client_id_; | 9 | ||||
4331 | if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) { | 9 | ||||
4340 | } | 9 | ||||
4440 | void ClientInfo::SerializeWithCachedSizes( | 9 | ||||
4444 | if (has_client_id()) { | 9 | ||||
4446 | 1, this->client_id(), output); | 9 | ||||
4450 | if (has_client_version()) { | 9 | ||||
4455 | output->WriteRaw(unknown_fields().data(), | 9 | ||||
4456 | unknown_fields().size()); | 9 | ||||
4458 | } | 9 | ||||
4460 | int ClientInfo::ByteSize() const { | 9 | ||||
4461 | int total_size = 0; | 9 | ||||
4463 | if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { | 9 | ||||
4465 | if (has_client_id()) { | 9 | ||||
4468 | this->client_id()); | 9 | ||||
4472 | if (has_client_version()) { | 9 | ||||
4479 | total_size += unknown_fields().size(); | 9 | ||||
4482 | _cached_size_ = total_size; | 9 | ||||
4484 | return total_size; | 9 |
|
Times Different | |||||
158 | return; | 11 | ||||
209 | *aDelta = 0; | 2 | ||||
213 | isNewer = true; | 11 | ||||
214 | *aDelta = timeDelta - timeStampDelta; | 11 |
|
Times Different | |||||
985 | do { | 1 | ||||
1003 | TimeStamp now = TimeStamp::Now(); | 1 | ||||
1005 | tv.tv_sec = 0; | 1 | ||||
1007 | kClipboardTimeout - (now - start).ToMicroseconds()); | 1 | ||||
1008 | select_result = select(cnumber, &select_set, nullptr, nullptr, &tv); | 1 |
|
Times Different | |||||
2105 | GetLayerManager()->ScheduleComposite(); | 2 | ||||
2106 | GetLayerManager()->SetNeedsComposite(false); | 2 | ||||
2356 | CheckForRollup(0, 0, false, true); | 2 |
|
Times Different | |||||
299 | DispatchDummyEvent(thr); | 4 | ||||
306 | nsBaseAppShell::DispatchDummyEvent(nsIThread* aTarget) | 4 | ||||
308 | NS_ASSERTION(NS_IsMainThread(), "Wrong thread!"); | 4 | ||||
310 | if (!mDummyEvent) | 4 | ||||
311 | mDummyEvent = new mozilla::Runnable("DummyEvent"); | 4 | ||||
313 | return NS_SUCCEEDED(aTarget->Dispatch(mDummyEvent, NS_DISPATCH_NORMAL)); | 4 |
|
Times Different | |||||
1206 | DispatchEvent(aEvent, status); | 10 | ||||
1207 | return status; | 10 |
|
Times Different | |||||
1362 | nsresult rv = NS_DispatchToCurrentThread(this); | 8 | ||||
1363 | if (NS_FAILED(rv)) { | 8 |
|
Times Different | |||||
913 | CCGraph::FindNode(void* aPtr) | 8 | ||||
915 | PtrToNodeEntry* e = FindNodeEntry(aPtr); | 8 | ||||
916 | return e ? e->mNode : nullptr; | 8 | ||||
2773 | nsCycleCollector_dispatchDeferredDeletion(true); | 10 | ||||
2790 | SnowWhiteKiller::Visit(aBuffer, aEntry); | 10 | ||||
2892 | timeLog.Checkpoint("MarkRoots()"); | 9 | ||||
2970 | FloodBlackNode(mWhiteNodeCount, failed, wm->mKey); | 6 | ||||
2971 | anyChanged = true; | 6 | ||||
2975 | FloodBlackNode(mWhiteNodeCount, failed, wm->mVal); | 6 | ||||
2976 | anyChanged = true; | 6 | ||||
2998 | Visit(nsPurpleBuffer& aBuffer, nsPurpleBufferEntry* aEntry) | 8 | ||||
3000 | MOZ_ASSERT(aEntry->mObject, | 8 | ||||
3002 | MOZ_ASSERT(aEntry->mRefCnt->get() != 0, | 8 | ||||
3005 | void* obj = aEntry->mObject; | 8 | ||||
3006 | if (!aEntry->mParticipant) { | 8 | ||||
3007 | obj = CanonicalizeXPCOMParticipant(static_cast |
8 | ||||
3008 | MOZ_ASSERT(obj, "Don't add objects that don't participate in collection!"); | 8 | ||||
3011 | PtrInfo* pi = mGraph.FindNode(obj); | 8 | ||||
3012 | if (!pi) { | 8 | ||||
3015 | MOZ_ASSERT(pi->mParticipant, "No dead objects should be in the purple buffer."); | 8 | ||||
3016 | if (MOZ_UNLIKELY(mLogger)) { | 8 | ||||
3019 | if (pi->mColor == black) { | 8 | ||||
3022 | FloodBlackNode(mCount, mFailed, pi); | 8 | ||||
3023 | return true; | 8 | ||||
3144 | MOZ_ASSERT(!aFullySynchGraphBuild, | 8 | ||||
3153 | MOZ_ASSERT(!pi->mParticipant, "Live nodes should all have been traversed"); | 8 | ||||
3528 | mResults.mForcedGC = true; | 2 | ||||
3745 | FinishAnyCurrentCollection(); | 6 | ||||
3749 | nsCycleCollector::FinishAnyCurrentCollection() | 6 | ||||
3751 | if (IsIdle()) { | 6 | ||||
3756 | PrintPhase("FinishAnyCurrentCollection"); | 6 | ||||
3758 | Collect(SliceCC, unlimitedBudget, nullptr); | 6 | ||||
3764 | MOZ_ASSERT(IsIdle() || | 6 |
|
Times Different | |||||
98 | virtual const char16_t* Filename() { return nullptr; } | 5 |
|
Times Different | |||||
1419 | if (pendingPRThread == currentPRThread) { | 5 | ||||
1424 | SafeMutexAutoUnlock unlockPending(mLock); | 5 | ||||
1426 | if (!currentThread) { | 5 | ||||
1427 | currentThread = NS_GetCurrentThread(); | 5 | ||||
1428 | MOZ_ASSERT(currentThread, "This should never be null!"); | 5 | ||||
1433 | if (!NS_ProcessNextEvent(currentThread, false)) { | 5 | ||||
1434 | PR_Sleep(PR_INTERVAL_NO_WAIT); | 9 | ||||
1436 | } | 5 | ||||
1441 | lock.Unlock(); | 5 | ||||
1442 | return entry->mServiceObject->QueryInterface(aIID, aResult); | 5 |
|
Times Different | |||||
640 | *base64++ = kBase64URLAlphabet[aBinary[index] >> 2]; | 9 | ||||
641 | *base64++ = kBase64URLAlphabet[((aBinary[index] & 0x3) << 4) | | 9 | ||||
642 | (aBinary[index + 1] >> 4)]; | 9 | ||||
643 | *base64++ = kBase64URLAlphabet[((aBinary[index + 1] & 0xf) << 2)]; | 9 | ||||
648 | if (length % 4 == 2) { | 9 | ||||
652 | } else if (length % 4 == 3) { | 9 | ||||
653 | *base64++ = '='; | 9 | ||||
654 | length += 1; | 9 |
|
Times Different | |||||
108 | case nsXPTType::T_U64: dp->val.u64 = (uint64_t) value; break; | 4 |
|
Times Different | |||||
94 | size_type minNewCapacity = curCapacity + (curCapacity >> 3); // multiply by 1.125 | 3 | ||||
95 | temp = XPCOM_MAX(aCapacity, minNewCapacity) + neededExtraSpace; | 3 | ||||
100 | const size_t MiB = 1 << 20; | 3 | ||||
101 | temp = (MiB * ((temp + MiB - 1) / MiB)) - neededExtraSpace; | 3 |
|
Times Different | |||||
197 | return; | 2 |