diff --git a/variability/variability_index.html b/variability/variability_index.html new file mode 100644 index 0000000..c6925bc --- /dev/null +++ b/variability/variability_index.html @@ -0,0 +1,33515 @@ + + + + + + + + +
+

Variability Analysis

+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
db/sqlite3/src/sqlite3.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
docshell/base/nsDocShell.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
2457 obs->Reflow(aStart, aEnd); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
docshell/shistory/nsSHistory.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/animation/AnimationEffectReadOnly.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/animation/DocumentTimeline.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
222 aDriver->RemoveRefreshObserver(this, FlushType::Style); 4
223 mIsObservingRefreshDriver = false; 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/animation/EffectCompositor.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
343 bool& postedRestyle = iter.Data(); 6
344 if (postedRestyle) { 6
350 cascadeLevel); 2
351 postedRestyle = true; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/animation/KeyframeEffectReadOnly.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
725 KeyframeEffectReadOnly::IsRunningOnCompositor() const 2
731 for (const AnimationProperty& property : mProperties) { 2
732 if (property.mIsRunningOnCompositor) { 2
736 return false; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/FragmentOrElement.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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(root)); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/TimeoutManager.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsCCUncollectableMarker.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
138 static_cast(et)->MarkForCC(); 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 child; 6
250 int32_t i = 0; 6
251 while (NS_SUCCEEDED(aSHEntry->ChildShellAt(i++, getter_AddRefs(child))) && 6
256 nsCOMPtr shCont = do_QueryInterface(aSHEntry); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsContentList.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsContentPolicy.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
189 nsCOMPtr topWindow = window->GetScriptableTop(); 10
190 isTopLevel = topWindow == window; 10
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsContentSink.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
241 if (mDeferredFlushTags) { 2
244 if (mDeferredLayoutStart) { 2
251 StartLayout(false); 2
255 ScrollToRef(); 2
1321 mDeferredFlushTags = true; 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsGenericDOMDataNode.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsGlobalWindow.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsInProcessTabChildGlobal.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
119 nsInProcessTabChildGlobal::MarkForCC() 6
121 MarkScopesForCC(); 6
122 return mMessageManager ? mMessageManager->MarkForCC() : false; 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsJSEnvironment.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsTextFragment.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
414 buff = static_cast(malloc(length.value())); 4
415 if (!buff) { 4
419 memcpy(buff, m1b, mState.mLength); 4
420 mState.mInHeap = true; 4
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsWindowMemoryReporter.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
657 mCheckTimerWaitingForCCEnd = true; 2
658 return; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/base/nsWrapperCacheInlines.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
22 const_cast(this)->ClearWrapper(); 4
23 return nullptr; 4
56 *hasGrayObjects = true; 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/bindings/BindingUtils.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
600 TErrorResult::NoteJSContextException(JSContext* aCx) 2
602 AssertInOwningThread(); 2
603 if (JS_IsExceptionPending(aCx)) { 2
606 mResult = NS_ERROR_UNCATCHABLE_EXCEPTION; 2
608 } 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/events/CustomEvent.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/events/DOMEventTargetHelper.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/events/Event.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
dom/events/EventListenerManager.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
1318 aEvent->mFlags.mExceptionWasRaised = true; 2
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/events/EventStateManager.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
4262 targetElement = mDocument->GetRootElement(); 6
4746 mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(content)); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/events/IMEContentObserver.cpp
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
dom/events/JSEventHandler.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
217 return rv.StealNSResult(); 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
dom/html/nsGenericHTMLElement.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
2849 if (aRead && !history->HasStates()) { 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/indexedDB/ActorsParent.cpp
Hg Link
Variability-index: 0.14285714285714285
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/script/ScriptLoader.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
2420 &ScriptLoader::ProcessPendingRequests); 7
2421 if (mDocument) { 7
2422 mDocument->Dispatch("ScriptLoader", TaskCategory::Other, task.forget()); 7
2425 } 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/script/ScriptSettings.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/svg/SVGUseElement.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
399 nsIPresShell *presShell = doc->GetShell(); 8
400 if (!presShell) 8
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/workers/RuntimeService.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/workers/WorkerPrivate.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/workers/WorkerPrivate.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
354 Cancel() 4
356 return Notify(Canceling); 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/xhr/XMLHttpRequestMainThread.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/xml/nsXMLContentSink.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
765 ++mInNotification; 4
769 --mInNotification; 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
dom/xul/nsXULPopupListener.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
gcc/include/c++/4.9.4/bits/stl_algo.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
gcc/include/c++/4.9.4/functional
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
gfx/2d/DrawTargetSkia.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
530 return Rect(); 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/2d/Point.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
81 static IntPointTyped Round(float aX, float aY) { 12
82 return IntPointTyped(int32_t(floorf(aX + 0.5)), int32_t(floorf(aY + 0.5))); 12
189 IntPointTyped::Round(const PointTyped& aPoint) 12
191 return IntPointTyped::Round(aPoint.x, aPoint.y); 12
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
gfx/2d/Rect.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
237 RectTyped() : Super() {} 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/cairo/cairo/src/cairo-hash.c
Hg Link
Variability-index: 0.23809523809523808
Total Files Compared: 21
+
+ 		Times Different
223 step = 1; 5
329 step = 1; 4
460 step = 1; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/cairo/libpixman/src/pixman-implementation.c
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/cairo/libpixman/src/pixman-region.c
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/BufferTexture.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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 srcSurf = aSurface->GetDataSurface(); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ImageContainer.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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& aImages) 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& aImages) 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& aImages) 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* aImages, 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 textureClient; 12
827 RefPtr surface = GetAsSourceSurface(); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ImageContainer.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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 GetAsSourceSurface() override 12
936 RefPtr surface(mSourceSurface); 12
937 return surface.forget(); 12
943 virtual gfx::IntSize GetSize() override { return mSize; } 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ImageLayers.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ImageLayers.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/LayerTreeInvalidation.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
593 static ImageHost* GetImageHost(Layer* aLayer) 12
595 HostLayer* compositor = aLayer->AsHostLayer(); 12
596 if (compositor) { 12
597 return static_cast(compositor->GetCompositableHost()); 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(mLayer.get()); 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(static_cast(aRoot), aIsMask); 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/Layers.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
161 LayerManager::CreateImageContainer(ImageContainer::Mode flag) 12
163 RefPtr container = new ImageContainer(flag); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/RotatedBuffer.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/basic/BasicCompositor.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
354 BasicCompositor::SupportsEffect(EffectTypes aEffect) 12
356 return aEffect != EffectTypes::YCBCR && aEffect != EffectTypes::COMPONENT_ALPHA; 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/client/ClientImageLayer.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/client/ClientLayerManager.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
493 ClientLayerManager::ScheduleComposite() 2
495 mForwarder->Composite(); 2
496 } 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/client/ImageClient.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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 images; 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 textures; 12
207 for (auto& img : images) { 12
208 Image* image = img.mImage; 12
210 RefPtr texture = image->GetTextureClient(GetForwarder()); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/client/ImageClient.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
49 virtual ~ImageClient() {} 12
87 class ImageClientSingle : public ImageClient 12
109 struct Buffer { 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/client/TextureClient.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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 client = CreateForDrawing(aAllocator, aSurface->GetFormat(), size, 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/CompositableHost.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/ImageComposite.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/ImageHost.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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& aTextures) 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/ImageHost.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
46 virtual CompositableType GetType() override { return mTextureInfo.mCompositableType; } 12
93 struct RenderInfo { 12
98 RenderInfo() : imageIndex(-1), img(nullptr) 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/ImageLayerComposite.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
32 ImageLayerComposite::ImageLayerComposite(LayerManagerComposite* aManager) 12
35 , mImageHost(nullptr) 12
37 MOZ_COUNT_CTOR(ImageLayerComposite); 12
38 mImplData = static_cast(this); 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(aHost); 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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/ImageLayerComposite.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
57 virtual HostLayer* AsHostLayer() override { return this; } 12
59 virtual const char* Name() const override { return "ImageLayerComposite"; } 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/LayerManagerComposite.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
1339 LayerManagerComposite::CreateImageLayer() 12
1341 if (mDestroyed) { 12
1345 return RefPtr(new ImageLayerComposite(this)).forget(); 12
1450 LayerComposite::Destroy() 12
1452 if (!mDestroyed) { 12
1453 mDestroyed = true; 12
1454 CleanupResources(); 12
1456 } 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/composite/TextureHost.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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(aActor)->RecvDestroy(); 6
1253 } 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ipc/CompositableTransactionParent.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
144 const OpRemoveTexture& op = aEdit.detail().get_OpRemoveTexture(); 9
146 RefPtr tex = TextureHost::AsTextureHost(op.textureParent()); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ipc/CompositorBridgeParent.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
1274 CompositorBridgeParent::ForceComposite(LayerTransactionParent* aLayerTree) 2
1276 ScheduleComposition(); 2
1277 } 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ipc/LayerTransactionParent.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
125 mLayerTransaction->DestroyActor(op); 6
211 MOZ_LAYERS_LOG(("[ParentSide] CreateImageLayer")); 12
213 RefPtr layer = layer_manager()->CreateImageLayer(); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/layers/ipc/ShadowLayers.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
291 ShadowLayerForwarder::CreatedImageLayer(ShadowableLayer* aImage) 12
293 CreatedLayer(mTxn, aImage); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/include/core/../private/../private/../private/SkOnce.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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(args)...); 7
38 return fState.store(Done, std::memory_order_release); 7
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/include/core/SkPixmap.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
168 return const_cast(this->addr8(x, y)); 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkAAClip.cpp
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkAlphaRuns.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
29 void SkAlphaRuns::assertValid(int y, int maxStep) const { 9
42 } 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkAntiRun.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkBitmapProcState.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
447 colors += n; 2
448 ix = 0; 2
449 } 2
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkBitmapProcState_matrixProcs.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
196 static inline U16CPU int_repeat(int x, int n) { 7
197 return sk_int_mod(x, n); 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkBlitter.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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(device, *paint, shaderContext); 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkBlitter_A8.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkBlitter_ARGB32.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
356 if (fXfermode->asMode(&mode)) { 7
357 if (SkXfermode::kSrc_Mode == mode) { 7
358 fShadeDirectlyIntoDevice = true; 7
359 fProc32Blend = blend_srcmode; 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkRegion.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkRegionPriv.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkScan_AAAPath.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkScan_AntiPath.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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(fRunsBuffer) + fCurrentRun * kRunsSz); 9
143 fRuns.fAlpha = reinterpret_cast(fRuns.fRuns + fWidth + 1); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkXfermode.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkXfermodeInterpretation.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkXfermodePriv.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
169 SkASSERT(!xfer->unique()); 7
170 return xfer.get(); 7
286 SkXfermode() {} 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/core/SkXfermode_proccoeff.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/effects/gradients/SkLinearGradient.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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 void ramp(SkPMColor dstC[], int n, const Sk4f& c, const Sk4f& dc, 7
772 Sk4f dc2 = dc + dc; 7
773 Sk4f dc4 = dc2 + dc2; 7
774 Sk4f cd0 = pre_bias(c , dither0); 7
775 Sk4f cd1 = pre_bias(c + dc, dither1); 7
776 Sk4f cd2 = cd0 + dc2; 7
777 Sk4f cd3 = cd1 + dc2; 7
778 while (n >= 4) { 7
783 *dstC++ = trunc_from_255(cd0, dither0); 7
784 *dstC++ = trunc_from_255(cd1, dither1); 7
785 *dstC++ = trunc_from_255(cd2, dither0); 7
786 *dstC++ = trunc_from_255(cd3, dither1); 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(cd0, dither0); 11
796 *dstC++ = trunc_from_255(cd1, dither1); 11
797 cd0 = cd0 + dc2; 11
799 if (n & 1) { 7
800 *dstC++ = trunc_from_255(cd0, dither0); 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(dstC, n, c, dc, dither0, dither1); 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(dstC, count, fx, dx, invDx, dither); 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
gfx/skia/skia/src/opts/SkXfermode_opts.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/FrameAnimator.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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 nextFrameTimeout = GetTimeoutForFrame(aState, aFrames, nextFrameIndex); 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 currentFrameEndTime = GetCurrentImgFrameEndTime(aState, aFrames); 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 newFrame = new imgFrame; 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/FrameAnimator.h
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/FrameTimeout.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
89 uint32_t AsMilliseconds() const 6
91 if (*this == Forever()) { 6
96 return uint32_t(mTimeout); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/Image.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
image/ProgressTracker.cpp
Hg Link
Variability-index: 0.14285714285714285
Total Files Compared: 21
+
+ 		Times Different
108 status |= imgIRequest::STATUS_IS_ANIMATED; 3
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/RasterImage.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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 image = new layers::SourceSurfaceImage(surface); 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 container = mImageContainer.get(); 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 image; 12
662 Tie(drawResult, image) = GetCurrentImage(container, aFlags); 12
663 if (!image) { 12
670 AutoTArray imageList; 12
673 mImageProducerID)); 12
674 container->SetCurrentImagesInTransaction(imageList); 12
676 mLastImageContainerDrawResult = drawResult; 12
677 mImageContainer = container; 12
679 return container.forget(); 12
693 RefPtr image; 6
694 Tie(drawResult, image) = GetCurrentImage(container, FLAG_NONE); 6
695 if (!image) { 6
699 mLastImageContainerDrawResult = drawResult; 6
700 AutoTArray imageList; 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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
image/SourceBuffer.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
541 return; 8
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/imgFrame.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/imgFrame.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
117 nsresult InitForAnimator(const nsIntSize& aSize, 9
121 aFormat, 0, false, true); 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
image/imgRequestProxy.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
306 LOG_SCOPE(gImgLog, "imgRequestProxy::Cancel"); 6
308 mCanceled = true; 6
310 nsCOMPtr ev = new imgCancelRunnable(this, status); 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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
ipc/chromium/src/base/message_loop.cc
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
601 if (delayed_run_time > other.delayed_run_time) 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
ipc/chromium/src/chrome/common/ipc_channel_posix.cc
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
ipc/glue/MessageChannel.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/builtin/RegExp.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/ds/Bitmap.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/ds/Bitmap.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
45 uintptr_t& word(size_t i) { return data[i]; } 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/dtoa.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/frontend/BytecodeEmitter.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
8181 return false; 2
8186 return false; 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/frontend/Parser.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
3170 return false; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/frontend/TokenStream.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
1359 hadUnicodeEscape = false; 7
1360 goto identifier; 7
1915 reportError(JSMSG_ILLEGAL_CHARACTER); 1
1967 ungetCharIgnoreEOL(c); 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/Allocator.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
344 maybeLock.emplace(rt); 9
397 arena->setNextAllocDuringSweep(arenasAllocatedDuringSweep); 9
398 arenasAllocatedDuringSweep = arena; 9
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/AtomMarking.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
144 zone->markedAtoms().bitwiseOrInto(markedUnion); 6
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/Barrier.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
81 CurrentThreadIsIonCompilingSafeForMinorGC() 9
83 return TlsContext.get()->ionCompilingSafeForMinorGC; 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/FindSCCs.h
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/GCRuntime.h
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		Times Different
759 helperState.waitBackgroundSweepEnd(); 7
760 allocTask.cancel(GCParallelTask::CancelAndWait); 7
791 bool isShrinkingGC() const { return invocationKind == GC_SHRINK; } 11
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/Heap.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
701 Arena* getNextAllocDuringSweep() const { 9
702 MOZ_ASSERT(allocatedDuringIncremental); 9
703 return reinterpret_cast(auxNextLink << ArenaShift); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/Marking.cpp
Hg Link
Variability-index: 0.6190476190476191
Total Files Compared: 21
+
+ 		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(ptr()); 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(gcmarker, arena); 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(mover, arena, cells); 9
2781 break; 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/RootMarking.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/Statistics.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/Statistics.h
Hg Link
Variability-index: 0.6190476190476191
Total Files Compared: 21
+
+ 		Times Different
404 : stats(stats), phaseKind(phaseKind), enabled(condition) 13
406 if (enabled) 13
407 stats.beginPhase(phaseKind); 13
411 if (enabled) 13
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/StoreBuffer.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
141 zone->group()->storeBuffer().setAboutToOverflow(); 10
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/gc/Zone.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
138 MOZ_ASSERT(isGCSweepingOrCompacting()); 6
139 for (auto iter = cellIter(); !iter.done(); iter.next()) { 6
140 JSScript* script = iter; 6
141 if (!script->hasAnyBreakpointsOrStepMode()) 6
142 continue; 6
319 if (!r.front()->debuggeeIsBeingCollected(rt->gc.majorGCCount())) { 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/irregexp/RegExpEngine.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/irregexp/RegExpInterpreter.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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(pc) & 3) == 0); 6
107 return *reinterpret_cast(pc); 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 registers; 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/irregexp/RegExpMacroAssembler.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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(buffer_ + fixup); 6
170 *reinterpret_cast(buffer_ + fixup) = pc_; 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(buffer_ + pc_) = word; 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(buffer_ + pc_) = word; 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/irregexp/RegExpMacroAssembler.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BacktrackingAllocator.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BaselineCacheIRCompiler.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BaselineCompiler.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BaselineDebugModeOSR.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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(iter.fp())->maybeStubPtr(); 6
242 break; 6
264 if (needsRecompileHandler) { 6
850 if (!CollectJitStackScripts(cx, obs, iter, entries)) 6
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BaselineFrame.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
49 TraceRoot(trc, returnValue().address(), "baseline-rval"); 2
55 TraceRoot(trc, &argsObj_, "baseline-args-obj"); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BaselineFrame.h
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
353 jsbytecode* overridePc() const { 10
354 MOZ_ASSERT(hasOverridePc()); 10
355 return script()->offsetToPC(overrideOffset_); 10
360 return overridePc(); 10
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BaselineIC.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
553 return extra_ & (1u << UNOPTIMIZABLE_ACCESS_BIT); 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/BaselineInspector.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
926 size_t offset = reader.stubOffset(); 4
928 &stub->stubInfo()->getStubField(stub, offset)->as(); 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().lastProperty() != objShape) { 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/CacheIR.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
1340 JSRope* rope = &str->asRope(); 4
1343 if (size_t(index) >= rope->leftChild()->length()) 4
1346 str = rope->leftChild(); 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/CodeGenerator.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/ICState.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
76 void setInvalid() { invalid_ = true; } 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/Ion.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/IonAnalysis.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/IonBuilder.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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() && !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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/IonCacheIRCompiler.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/IonIC.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
71 trace(zone->barrierTracer()); 2
306 if (!FetchName(cx, obj, holder, name, prop, res)) 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/IonTypes.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
211 return "Bailout_NonObjectInput"; 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/JitFrames.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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(ref), "ion-gc-slot"); 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(spill), "ion-gc-spill"); 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(argBase), "ion-vm-args"); 2
1420 break; 2
1509 TraceIonJSFrame(trc, frames); 12
1510 break; 12
1545 UpdateIonJSFrameForMinorGC(trc, frames); 12
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/JitFrames.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
395 calleeToken_ = calleeToken; 12
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/LIR.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
598 for (size_t i = 0; i < moves_.length(); i++) { 2
599 if (to == moves_[i].to()) { 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/Linker.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
57 cx->zone()->group()->storeBuffer().putWholeCell(code); 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/Lowering.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/MCallOptimize.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
3347 MInstruction* ins = MIsConstructing::New(alloc()); 2
3348 current->add(ins); 2
3349 current->push(ins); 2
3350 return InliningStatus_Inlined; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/MIR.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/MIR.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/MIRGraph.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
256 if ((*returnAccumulator_)[i] == block) 2
257 returnAccumulator_->erase(returnAccumulator_->begin() + i); 2
259 i++; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/MacroAssembler.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/MacroAssembler.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
1688 store8(value, dest); 2
1689 break; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/RangeAnalysis.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/RangeAnalysis.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
520 bool isBoolean() const { 2
521 return lower() >= 0 && upper() <= 1 && 2
522 !canHaveFractionalPart_ && 2
523 !canBeNegativeZero_; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/Recover.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/Recover.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
328 RINSTRUCTION_HEADER_NUM_OP_(Not, 1) 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/Safepoints.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/Safepoints.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
98 return LiveGeneralRegisterSet(gcSpills_); 12
101 return LiveGeneralRegisterSet(slotsOrElementsSpills_); 12
104 return LiveGeneralRegisterSet(valueSpills_); 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/ScalarReplacement.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/SharedIC.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/SharedIC.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
774 state_.setInvalid(); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/TypePolicy.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/VMFunctions.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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 genObj, 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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/shared/Assembler-shared.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
485 return &patchAt_; 2
488 return &target_; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/shared/CodeGenerator-shared-inl.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/shared/LIR-shared.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/shared/Lowering-shared-inl.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x64/Lowering-x64.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
39 LIRGeneratorX64::useByteOpRegisterOrNonDoubleConstant(MDefinition* mir) 2
41 return useRegisterOrNonDoubleConstant(mir); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x64/MacroAssembler-x64.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x64/SharedIC-x64.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x64/Trampoline-x64.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
760 MOZ_CRASH("NYI: x64 callVM should not be used with 128bits values."); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/Assembler-x86-shared.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/Assembler-x86-shared.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/BaseAssembler-x86-shared.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/CodeGenerator-x86-shared.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/CodeGenerator-x86-shared.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/LIR-x86-shared.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/Lowering-x86-shared.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
23 LIRGeneratorX86Shared::newLTableSwitch(const LAllocation& in, const LDefinition& inputCopy, 2
26 return new(alloc()) LTableSwitch(in, inputCopy, temp(), tableswitch); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
218 MacroAssembler::sub32(const Address& src, Register dest) 2
220 subl(Operand(src), dest); 2
221 } 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/MacroAssembler-x86-shared.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
163 void cmp32(const Address& lhs, Imm32 rhs) { 2
164 cmp32(Operand(lhs), rhs); 2
165 } 2
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jit/x86-shared/MoveEmitter-x86-shared.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
126 inCycle_ = false; 4
127 continue; 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsapi.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jsarray.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
3740 } 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsatom.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jscntxt.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
304 CallWarningReporter(cx, reportp); 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jscompartment.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
1459 cx_->compartment()->objectMetadataState = prevState_; 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsdtoa.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsexn.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsgc.cpp
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsgc.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jshashutil.h
Hg Link
Variability-index: 0.23809523809523808
Total Files Compared: 21
+
+ 		Times Different
67 addPtr = table.lookupForAdd(key); 5
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsobj.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
1743 a->traceChildren(zone->barrierTracer()); 6
1744 b->traceChildren(zone->barrierTracer()); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsopcode.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jsscript.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
1976 return; 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/jsstr.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
4466 if (u != 0) { 4
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/jsweakmap.h
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
319 bool findZoneEdges() override { 10
321 return true; 10
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/ArrayBufferObject.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
1273 dst.setSlot(DATA_SLOT, PrivateValue(dst.inlineDataPointer())); 4
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Compression.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
59 MOZ_ASSERT(ret == Z_DATA_ERROR); 2
60 MOZ_ASSERT(!finished); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Debugger.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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(cell); 6
5466 "Debugger.Script script referent"); 6
5467 obj->as().setPrivateUnbarriered(script); 6
7158 "Debugger.Source referent"); 6
7159 obj->as().setPrivateUnbarriered(referent); 6
9023 "Debugger.Object referent"); 6
9024 obj->as().setPrivateUnbarriered(referent); 6
11976 if (dbg->enabled && 6
11977 dbg->observedGC(data->majorGCNumber()) && 6
11978 dbg->getHook(Debugger::OnGarbageCollection)) 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Debugger.h
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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(this)); !e.empty(); e.popFront()) { 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/ErrorReporting.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/HelperThreads.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Interpreter-inl.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Interpreter.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/NativeObject-inl.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
234 dst->set(this, HeapSlot::Element, dst - elements_ + numShifted, *src); 4
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/NativeObject.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
1328 void** pprivate = &privateRef(numFixedSlots()); 6
1329 *pprivate = data; 6
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/ObjectGroup.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
775 if (group != type.groupNoBarrier()) 6
1179 return true; 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/RegExpObject.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Runtime.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Runtime.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
868 return gc.atomsZone; 2
1063 MOZ_ASSERT(rt->stackFormat_ == js::StackFormat::Default); 2
1064 rt = rt->parentRuntime; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/Shape.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/String.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
664 CopyAndInflateChars(twoByteBuf + leftLen, rightLinear->latin1Chars(nogc), rightLen); 10
989 base = base->asDependent().base(); 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/TaggedProto.h
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
56 TraceManuallyBarrieredEdge(trc, &proto, "TaggedProto"); 10
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/TypeInference-inl.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
970 constraint->newPropertyState(cx, this); 6
971 constraint = constraint->next(); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/TypeInference.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/TypeInference.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
642 oom = true; 4
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/src/vm/TypedArrayObject.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
194 if (oldObj->hasInlineElements()) 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/xpconnect/src/XPCConvert.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
1601 case nsXPTType::T_CHAR_STR : POPULATE(fr, char*); break; 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/xpconnect/src/XPCJSContext.cpp
Hg Link
Variability-index: 0.6190476190476191
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
js/xpconnect/src/XPCJSRuntime.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
js/xpconnect/src/XPCWrappedNative.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
882 cache->UpdateWrapper(obj, old); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/PresShell.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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(aClosure); 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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/base/RestyleManager.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
112 cur = cur->GetPreviousSibling()) { 2
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/RestyleTracker.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
248 LOG_RESTYLE("skipping, already restyled"); 7
249 continue; 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/nsCSSFrameConstructor.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/base/nsLayoutHistoryState.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
140 nsLayoutHistoryState::HasStates() 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/nsLayoutUtils.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/nsPresArena.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
76 void* ptr = iter.Key(); 2
77 ArenaObjectID id = iter.UserData(); 2
78 ClearArenaRefPtrWithoutDeregistering(ptr, id); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/nsPresContext.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
2434 aTimeStamp = mozilla::TimeStamp::Now(); 7
3384 nsAutoScriptBlocker blockScripts; 7
3385 self->NotifyDidPaintForSubtree(aTransactionId); 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/nsRefreshDriver.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
190 if (mRootRefreshDrivers.Contains(aDriver)) { 2
193 NS_ASSERTION(mContentRefreshDrivers.Contains(aDriver), 2
195 mContentRefreshDrivers.RemoveElement(aDriver); 2
1080 return static_cast(delay); 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 imagesToRefresh(mRequests.Count()); 6
2010 for (auto iter = mRequests.Iter(); !iter.Done(); iter.Next()) { 6
2011 nsISupportsHashKey* entry = iter.Get(); 6
2012 auto req = static_cast(entry->GetKey()); 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(iter.Get()->GetKey()); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/base/nsRefreshDriver.h
Hg Link
Variability-index: 0.14285714285714285
Total Files Compared: 21
+
+ 		Times Different
360 struct ImageStartData { 3
361 ImageStartData() 3
362 { 3
363 } 3
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/forms/nsGfxButtonControlFrame.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
86 nsGfxButtonControlFrame::GetDefaultLabel(nsXPIDLString& aString) const 7
88 nsCOMPtr form = do_QueryInterface(mContent); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/generic/ReflowInput.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsBlockFrame.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsFrame.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsInlineFrame.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsLineBox.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
319 frame = frame->GetNextSibling(); 7
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsLineLayout.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
226 mDirtyNextLine = true; 7
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsSubDocumentFrame.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
229 !(aFlags & IGNORE_PAINT_SUPPRESSION))) { 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsTextFrame.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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(aTextRun->GetUserData()); 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(userData + 1); 7
2474 userDataToDestroy = userData; 7
9730 aStatus.SetInlineLineBreakAfter(); 7
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/generic/nsTextFrame.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
237 bool IsSelfEmpty() override { return IsEmpty(); } 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/painting/DisplayItemClip.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/painting/FrameLayerBuilder.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
2188 ContainerState::CreateOrRecycleImageLayer(PaintedLayer *aPainted) 12
2191 static_cast(aPainted->GetUserData(&gPaintedDisplayItemLayerUserData)); 12
2192 RefPtr layer = data->mImageLayer; 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 imageLayer = CreateOrRecycleImageLayer(aData->mLayer); 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(ScaleToNearestPixels(aData->mItemClip.GetClipRect())); 12
3102 clip.MoveBy(ViewAs(mParameters.mOffset)); 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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/painting/FrameLayerBuilder.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
264 return LayerIntPoint::FromUnknownPoint(mOffset); 12
744 void SetLayerTreeCompressionMode() { mInLayerTreeCompressionMode = true; } 8
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/painting/nsDisplayList.cpp
Hg Link
Variability-index: 0.6190476190476191
Total Files Compared: 21
+
+ 		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 image = GetImage(); 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 image = GetImage(); 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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/painting/nsDisplayList.h
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		Times Different
629 void SetInTransform(bool aInTransform) { mInTransform = aInTransform; } 11
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/style/AnimationCommon.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
242 return a.mTimeStamp.IsNull(); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/style/StyleAnimationValue.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
328 AppendCSSShadowValue(const nsCSSShadowItem *aShadow, 7
332 MOZ_ASSERT(aShadow, "shadow expected"); 7
335 RefPtr arr = nsCSSValue::Array::Create(6); 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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/style/nsComputedDOMStyle.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
290 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsComputedDOMStyle) 6
291 return tmp->HasKnownLiveWrapper(); 6
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/style/nsDOMCSSAttrDeclaration.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
layout/style/nsStyleSet.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
1689 ruleWalker.CurrentNode()->SetIsAnimationRule(); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/style/nsStyleStruct.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/style/nsStyleStruct.h
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/style/nsTransitionManager.cpp
Hg Link
Variability-index: 0.6666666666666666
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/tables/BasicTableLayoutStrategy.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
510 BasicTableLayoutStrategy::MarkIntrinsicISizesDirty() 4
516 } 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/tables/nsTableFrame.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
layout/xul/nsImageBoxFrame.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
509 nsDisplayXULImage::GetDestRect() 6
512 return static_cast(mFrame)->GetDestRect(ToReferenceFrame(), anchorPoint); 6
706 return OnImageIsAnimated(aRequest); 3
767 nsImageBoxFrame::OnImageIsAnimated(imgIRequest* aRequest) 3
771 &mRequestRegistered); 3
773 return NS_OK; 3
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
mfbt/double-conversion/source/fast-dtoa.cc
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		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(divisor) << -one.e(), unit); 11
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
mozglue/misc/Printf.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
147 if (width > cvtwidth) { 6
336 if (i > 0) 2
337 MOZ_CRASH("Bad format string"); 2
860 MOZ_ASSERT(0); 2
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
mozglue/misc/TimeStamp.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
77 if (aIsInconsistent) { 2
80 ts = sInitOnce.mFirstTimeStamp; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/base/nsChannelClassifier.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
netwerk/base/nsInputStreamPump.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
458 NS_ASSERTION(NS_SUCCEEDED(mStatus), 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/base/nsLoadGroup.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
272 firstError = rv; 2
787 auto e = static_cast(iter.Get()); 2
788 RescheduleRequest(e->mKey, aDelta); 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
netwerk/base/nsSocketTransport2.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
1133 dnsFlags |= nsIDNSService::RESOLVE_DISABLE_IPV6; 9
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/base/nsSocketTransportService2.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
338 mActiveList[index] = mActiveList[mActiveCount-1]; 2
339 mPollList[index+1] = mPollList[mActiveCount]; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/cache/nsCacheService.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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 branch = do_QueryInterface(subject, &rv); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/cache2/CacheFileIOManager.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
67 nsCOMPtr ioTarget = CacheFileIOManager::IOTarget(); 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(_retval))[i/2] = value << 4; 8
3774 (reinterpret_cast(_retval))[i/2] += value; 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((avail10MBs - 2500)*.005); 8
4221 avail10MBs = 2500; 8
4224 if (avail10MBs > 700) { 8
4225 sz10MBs += static_cast((avail10MBs - 700)*.01); 8
4226 avail10MBs = 700; 8
4229 if (avail10MBs > 50) { 8
4230 sz10MBs += static_cast((avail10MBs - 50)*.05); 8
4231 avail10MBs = 50; 8
4243 sz10MBs += std::max(5, static_cast(avail10MBs * .4)); 8
4246 return std::min(maxSize, sz10MBs * 10 * 1024); 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(aFreeSpace / 1024) + 8
4290 cacheUsage); 8
4292 if (smartSize == (CacheObserver::DiskCacheCapacity() >> 10)) { 8
4297 CacheObserver::SetDiskCacheCapacity(smartSize << 10); 8
4299 return NS_OK; 8
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/cache2/CacheHashUtils.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/cache2/CacheIOThread.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/cache2/CacheIndex.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		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 event; 8
370 event = NewRunnableMethod("net::CacheIndex::PreShutdownInternal", 8
372 &CacheIndex::PreShutdownInternal); 8
374 nsCOMPtr ioTarget = CacheFileIOManager::IOTarget(); 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 index = gInstance; 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 ioThread = CacheFileIOManager::IOThread(); 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 enumerator; 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/cache2/CacheIndex.h
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
296 void Log() const { 8
297 LOG(("CacheIndexEntry::Log() [this=%p, hash=%08x%08x%08x%08x%08x, fresh=%u," 8
305 } 8
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/cache2/CacheObserver.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
netwerk/protocol/http/NullHttpTransaction.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
119 LOG(("NulHttpTransaction::NullHttpTransaction() " 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/protocol/http/nsHttp.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
47 NewHeapAtom(const char *value) { 9
48 int len = strlen(value); 9
51 reinterpret_cast(malloc(sizeof(*a) + len)); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/protocol/http/nsHttpActivityDistributor.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/protocol/http/nsHttpChannel.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
749 mTransactionPump->Suspend(); 2
7916 return CallQueryInterface(mCacheEntry, token); 2
8884 rvTransaction = mTransactionPump->Resume(); 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
netwerk/protocol/http/nsHttpConnectionMgr.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
3713 tmpFlags |= nsISocketTransport::DISABLE_IPV6; 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
netwerk/protocol/http/nsHttpTransaction.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
nsprpub/pr/src/pthreads/ptthread.c
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
189 thred->id = id; 8
190 thred->idSet = PR_TRUE; 8
521 PR_ASSERT(pthread_equal(thred->id, id)); 8
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/CompositableHost.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/ImageContainer.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/ImageLayers.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/Units.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/google/protobuf/io/coded_stream.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/google/protobuf/io/zero_copy_stream.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/google/protobuf/repeated_field.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/google/protobuf/wire_format_lite.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/google/protobuf/wire_format_lite_inl.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/imgRequestProxy.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/js/Value.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/EnumeratedArray.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/FrameTypeList.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/PresShell.h
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/Tuple.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/Vector.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/dom/FragmentOrElement.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/dom/TimeoutHandler.h
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/dom/TimeoutManager.h
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/dom/WorkerPrivate.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/gfx/Matrix.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/layers/APZThreadUtils.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/layers/Effects.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/layers/ImageClient.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/layers/ImageComposite.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/layers/LayerManagerComposite.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/mozilla/layers/TextureHost.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/nsAutoRef.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/nsTArray.h
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/nsWrapperCache.h
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dist/include/safebrowsing.pb.h
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/EventHandlerBinding.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/FocusEventBinding.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/HTMLButtonElementBinding.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/HTMLElementBinding.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/HTMLInputElementBinding.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/IDBDatabaseBinding.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/IDBOpenDBRequestBinding.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/IDBRequestBinding.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/IDBTransactionBinding.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/NavigatorBinding.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/ProgressEventBinding.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/UIEventBinding.cpp
Hg Link
Variability-index: 0.2857142857142857
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/XMLHttpRequestBinding.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/dom/bindings/XULDocumentBinding.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/ipc/ipdl/IPCMessageTypeName.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/ipc/ipdl/LayersMessages.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/ipc/ipdl/PCompositorManagerParent.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/ipc/ipdl/PLayerTransaction.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/ipc/ipdl/PLayerTransactionChild.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/ipc/ipdl/PLayerTransactionParent.cpp
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + +
+
+ + + + + +
obj-firefox/ipc/ipdl/_ipdlheaders/mozilla/layers/LayersMessages.h
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
Error: Couldn't find the file in hg.
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
parser/expat/lib/xmlparse.c
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
parser/htmlparser/nsParser.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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 event = new nsParserContinueEvent(this); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/base/hash.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/certdb/stanpcertdb.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/dbm/src/h_page.c
Hg Link
Variability-index: 0.5714285714285714
Total Files Compared: 21
+
+ 		Times Different
221 newoff = hashp->BSIZE; 12
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/dev/ckhelper.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/dev/devtoken.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/dev/devutil.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
77 nssCryptokiObject_Equal( 10
81 return (o1->token == o2->token && o1->handle == o2->handle); 10
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/pki/pki3hack.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
596 client &= ~(CERTDB_TRUSTED_CA | CERTDB_NS_TRUSTED_CA); 10
597 rvTrust->sslFlags |= CERTDB_TRUSTED_CLIENT_CA; 10
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/pki/pkibase.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/pki/pkistore.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/pki/tdcache.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/softoken/legacydb/lgattr.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/softoken/legacydb/pcertdb.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/softoken/pkcs11u.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
1941 object->refLock = PZ_NewLock(nssILockRefLock); 10
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
security/nss/lib/softoken/sftkdb.c
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
storage/StorageBaseStatementInternal.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
storage/mozStorageAsyncStatementExecution.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
305 rv = notifyResults(); 2
306 if (NS_FAILED(rv)) 2
310 mIntervalStart = now; 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
storage/mozStorageConnection.cpp
Hg Link
Variability-index: 0.23809523809523808
Total Files Compared: 21
+
+ 		Times Different
1152 nsDependentCString statementString(::sqlite3_sql(aStatement)); 4
1154 duration.ToMilliseconds()); 4
1238 nsDependentCString statementString(aSqlString); 5
1240 duration.ToMilliseconds()); 5
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/protobuf/src/google/protobuf/io/coded_stream.cc
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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(value | 0x80); 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(value) & 0x7F; 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(void_buffer); 9
853 total_bytes_ += buffer_size_; 9
854 return true; 9
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/protobuf/src/google/protobuf/io/zero_copy_stream.cc
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
44 ZeroCopyOutputStream::~ZeroCopyOutputStream() {} 9
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/protobuf/src/google/protobuf/message_lite.cc
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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(io::mutable_string_data(output) + old_size); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/protobuf/src/google/protobuf/wire_format_lite.cc
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/telemetry/Telemetry.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		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 arrayObj(cx, JS_NewArrayObject(cx, 0)); 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* slowSQLMap = nullptr; 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/telemetry/TelemetryHistogram.cpp
Hg Link
Variability-index: 0.3333333333333333
Total Files Compared: 21
+
+ 		Times Different
1941 TelemetryHistogram::CanRecordExtended() { 7
1942 StaticMutexAutoLock locker(gTelemetryHistogramMutex); 7
1943 return internal_CanRecordExtended(); 7
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/url-classifier/Classifier.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
384 aResult = mTableRequestResult; 9
1577 LoadMetadata(file, aResult); 2
1578 continue; 2
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
2080 LOG(("The previous update observer hasn't been notified.")); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/url-classifier/nsUrlClassifierStreamUpdater.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		Times Different
167 nsCOMPtr httpChannel = do_QueryInterface(mChannel, &rv); 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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/url-classifier/nsUrlClassifierStreamUpdater.h
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
105 struct PendingRequest { 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/url-classifier/nsUrlClassifierUtils.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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(threatType), aStatesBase64[i], lur); 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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
widget/SystemTimeConverter.h
Hg Link
Variability-index: 0.5238095238095238
Total Files Compared: 21
+
+ 		Times Different
158 return; 11
209 *aDelta = 0; 2
213 isNewer = true; 11
214 *aDelta = timeDelta - timeStampDelta; 11
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
widget/gtk/nsClipboard.cpp
Hg Link
Variability-index: 0.047619047619047616
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
widget/gtk/nsWindow.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
2105 GetLayerManager()->ScheduleComposite(); 2
2106 GetLayerManager()->SetNeedsComposite(false); 2
2356 CheckForRollup(0, 0, false, true); 2
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
widget/nsBaseAppShell.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
widget/nsBaseWidget.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		Times Different
1206 DispatchEvent(aEvent, status); 10
1207 return status; 10
+
+ +
+ + + + + + + + + + + + + + + + + + +
+
+ + + + + +
xpcom/base/CycleCollectedJSRuntime.cpp
Hg Link
Variability-index: 0.38095238095238093
Total Files Compared: 21
+
+ 		Times Different
1362 nsresult rv = NS_DispatchToCurrentThread(this); 8
1363 if (NS_FAILED(rv)) { 8
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
xpcom/base/nsCycleCollector.cpp
Hg Link
Variability-index: 0.47619047619047616
Total Files Compared: 21
+
+ 		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(obj)); 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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
xpcom/build/IOInterposer.h
Hg Link
Variability-index: 0.23809523809523808
Total Files Compared: 21
+
+ 		Times Different
98 virtual const char16_t* Filename() { return nullptr; } 5
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
xpcom/components/nsComponentManager.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
xpcom/io/Base64.cpp
Hg Link
Variability-index: 0.42857142857142855
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
xpcom/reflect/xptcall/md/unix/xptcstubs_x86_64_linux.cpp
Hg Link
Variability-index: 0.19047619047619047
Total Files Compared: 21
+
+ 		Times Different
108 case nsXPTType::T_U64: dp->val.u64 = (uint64_t) value; break; 4
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + +
xpcom/string/nsTSubstring.cpp
Hg Link
Variability-index: 0.14285714285714285
Total Files Compared: 21
+
+ 		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
+
+ +
+ + + + + + + + + + + + +
+
+ + + + + +
xpcom/threads/SchedulerGroup.cpp
Hg Link
Variability-index: 0.09523809523809523
Total Files Compared: 21
+
+ 		Times Different
197 return; 2
+
+ + + + \ No newline at end of file