Skip to content

GitLab

T
tangled
Commit fcb99401 authored by Juan Antonio Navarro Perez's avatar Juan Antonio Navarro Perez Committed by Commit Bot
Browse files
Options

[perf/contrib] Remove oilpan_gc_times.* benchmarks 

These benchmarks no longer work as intended. These have been superceeded
by gcMetric at:
https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/metrics/blink/gc_metric.html

Bug: 1011787
Change-Id: I6f20d4df4491de5c611fb9ff3376d68029c5feef
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1859963Reviewed-by: default avatarMichael Lippautz <mlippautz@chromium.org>
Reviewed-by: default avatarKentaro Hara <haraken@chromium.org>
Commit-Queue: Juan Antonio Navarro Pérez <perezju@chromium.org>
Cr-Commit-Position: refs/heads/master@{#705565}
parent 85d27a9f
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 541 deletions
tools/perf/contrib/oilpan/OWNERS deleted 100644 → 0
View file @ 85d27a9f
haraken@chromium.org
peria@chromium.org
tools/perf/contrib/oilpan/oilpan_benchmarks.py deleted 100644 → 0
View file @ 85d27a9f
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import os
from core import perf_benchmark
from benchmarks import blink_perf
from benchmarks import silk_flags
from telemetry import benchmark
from telemetry import story
import page_sets
from contrib.oilpan import oilpan_gc_times
class OilpanGCTimesBlinkPerfStress(perf_benchmark.PerfBenchmark):
tag = 'blink_perf_stress'
test = oilpan_gc_times.OilpanGCTimesForInternals
@classmethod
def Name(cls):
return 'oilpan_gc_times.blink_perf_stress'
def CreateStorySet(self, options):
path = os.path.join(blink_perf.BLINK_PERF_BASE_DIR, 'blink_gc')
return blink_perf.CreateStorySetFromPath(path, blink_perf.SKIPPED_FILE)
@benchmark.Info(emails=['peria@chromium.org'])
class OilpanGCTimesSmoothnessAnimation(perf_benchmark.PerfBenchmark):
test = oilpan_gc_times.OilpanGCTimesForSmoothness
page_set = page_sets.ToughAnimationCasesPageSet
@classmethod
def Name(cls):
return 'oilpan_gc_times.tough_animation_cases'
class OilpanGCTimesKeySilkCases(perf_benchmark.PerfBenchmark):
test = oilpan_gc_times.OilpanGCTimesForSmoothness
page_set = page_sets.KeySilkCasesPageSet
SUPPORTED_PLATFORMS = [story.expectations.ALL_ANDROID]
@classmethod
def Name(cls):
return 'oilpan_gc_times.key_silk_cases'
class OilpanGCTimesSyncScrollKeyMobileSites(perf_benchmark.PerfBenchmark):
tag = 'sync_scroll'
test = oilpan_gc_times.OilpanGCTimesForSmoothness
page_set = page_sets.KeyMobileSitesSmoothPageSet
SUPPORTED_PLATFORMS = [story.expectations.ALL_ANDROID]
def SetExtraBrowserOptions(self, options):
silk_flags.CustomizeBrowserOptionsForSyncScrolling(options)
@classmethod
def Name(cls):
return 'oilpan_gc_times.sync_scroll.key_mobile_sites_smooth'
tools/perf/contrib/oilpan/oilpan_gc_times.py deleted 100644 → 0
View file @ 85d27a9f
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import os
from telemetry.page import legacy_page_test
from telemetry.timeline.model import TimelineModel
from telemetry.timeline import tracing_config
_CR_RENDERER_MAIN = 'CrRendererMain'
_RUN_SMOOTH_ACTIONS = 'RunSmoothAllActions'
def _AddTracingResults(thread, results):
_GC_REASONS = ['precise', 'conservative', 'idle', 'forced']
_GC_STAGES = ['mark', 'lazy_sweep', 'complete_sweep']
def GetGcReason(event, async_slices):
args = event.args
# Old format
if 'precise' in args:
if args['forced']:
return 'forced'
return 'precise' if args['precise'] else 'conservative'
if args['gcReason'] == 'ConservativeGC':
return 'conservative'
if args['gcReason'] == 'PreciseGC':
return 'precise'
if args['gcReason'] == 'ForcedGCForTesting':
for s in async_slices:
if s.start <= event.start and event.end <= s.end:
return 'forced'
# Ignore this forced GC being out of target ranges
return None
if args['gcReason'] == 'IdleGC':
return 'idle'
return None # Unknown
def DumpMetric(name, values, unit):
if values[name]:
results.AddMeasurement(name, unit, values[name])
results.AddMeasurement(name + '_max', unit, max(values[name]))
results.AddMeasurement(name + '_total', unit, sum(values[name]))
events = thread.all_slices
async_slices = [s for s in thread.async_slices
if s.name == 'BlinkGCTimeMeasurement']
# Prepare
values = {}
for reason in _GC_REASONS:
for stage in _GC_STAGES:
values['oilpan_%s_%s' % (reason, stage)] = []
# Parse trace events
reason = None
mark_time = 0
lazy_sweep_time = 0
complete_sweep_time = 0
for event in events:
duration = event.thread_duration or event.duration
if event.name == 'BlinkGC.AtomicPhaseMarking':
if reason is not None:
values['oilpan_%s_mark' % reason].append(mark_time)
values['oilpan_%s_lazy_sweep' % reason].append(lazy_sweep_time)
values['oilpan_%s_complete_sweep' % reason].append(complete_sweep_time)
reason = GetGcReason(event, async_slices)
mark_time = duration
lazy_sweep_time = 0
complete_sweep_time = 0
continue
if event.name == 'BlinkGC.LazySweepInIdle':
lazy_sweep_time += duration
continue
if event.name == 'BlinkGC.CompleteSweep':
complete_sweep_time += duration
continue
if reason is not None:
values['oilpan_%s_mark' % reason].append(mark_time)
values['oilpan_%s_lazy_sweep' % reason].append(lazy_sweep_time)
values['oilpan_%s_complete_sweep' % reason].append(complete_sweep_time)
unit = 'ms'
# Dump each metric
for reason in _GC_REASONS:
for stage in _GC_STAGES:
DumpMetric('oilpan_%s_%s' % (reason, stage), values, unit)
# Summarize each stage
for stage in _GC_STAGES:
total_time = 0
for reason in _GC_REASONS:
total_time += sum(values['oilpan_%s_%s' % (reason, stage)])
results.AddMeasurement('oilpan_%s' % stage, unit, total_time)
# Summarize sweeping time
total_sweep_time = 0
for stage in ['lazy_sweep', 'complete_sweep']:
sweep_time = 0
for reason in _GC_REASONS:
sweep_time += sum(values['oilpan_%s_%s' % (reason, stage)])
key = 'oilpan_%s' % stage
results.AddMeasurement(key, unit, sweep_time)
total_sweep_time += sweep_time
results.AddMeasurement('oilpan_sweep', unit, total_sweep_time)
gc_time = 0
for key in values:
gc_time += sum(values[key])
results.AddMeasurement('oilpan_gc', unit, gc_time)
class _OilpanGCTimesBase(legacy_page_test.LegacyPageTest):
def WillNavigateToPage(self, page, tab):
del page # unused
# FIXME: Remove webkit.console when blink.console lands in chromium and
# the ref builds are updated. crbug.com/386847
config = tracing_config.TracingConfig()
for c in ['webkit.console', 'blink.console', 'blink_gc']:
config.chrome_trace_config.category_filter.AddIncludedCategory(c)
config.enable_chrome_trace = True
tab.browser.platform.tracing_controller.StartTracing(config, timeout=1000)
def ValidateAndMeasurePage(self, page, tab, results):
del page # unused
timeline_data = tab.browser.platform.tracing_controller.StopTracing()
timeline_model = TimelineModel(timeline_data)
threads = timeline_model.GetAllThreads()
for thread in threads:
if thread.name == _CR_RENDERER_MAIN:
_AddTracingResults(thread, results)
def DidRunPage(self, platform):
if platform.tracing_controller.is_tracing_running:
platform.tracing_controller.StopTracing()
class OilpanGCTimesForSmoothness(_OilpanGCTimesBase):
def __init__(self):
super(OilpanGCTimesForSmoothness, self).__init__()
self._interaction = None
def DidNavigateToPage(self, page, tab):
del page # unused
self._interaction = tab.action_runner.CreateInteraction(_RUN_SMOOTH_ACTIONS)
self._interaction.Begin()
def ValidateAndMeasurePage(self, page, tab, results):
self._interaction.End()
super(OilpanGCTimesForSmoothness, self).ValidateAndMeasurePage(
page, tab, results)
class OilpanGCTimesForBlinkPerf(_OilpanGCTimesBase):
def __init__(self):
super(OilpanGCTimesForBlinkPerf, self).__init__()
with open(os.path.join(os.path.dirname(__file__), '..', '..', 'benchmarks',
'blink_perf.js'), 'r') as f:
self._blink_perf_js = f.read()
def WillNavigateToPage(self, page, tab):
page.script_to_evaluate_on_commit = self._blink_perf_js
super(OilpanGCTimesForBlinkPerf, self).WillNavigateToPage(page, tab)
def ValidateAndMeasurePage(self, page, tab, results):
tab.WaitForJavaScriptCondition('testRunner.isDone', timeout=600)
super(OilpanGCTimesForBlinkPerf, self).ValidateAndMeasurePage(
page, tab, results)
class OilpanGCTimesForInternals(OilpanGCTimesForBlinkPerf):
def __init__(self):
super(OilpanGCTimesForInternals, self).__init__()
@classmethod
def CustomizeBrowserOptions(cls, options):
# 'expose-internals-for-testing' can be enabled on content shell.
assert 'content-shell' in options.browser_type
options.AppendExtraBrowserArgs(['--expose-internals-for-testing',
'--js-flags=--expose-gc'])
tools/perf/contrib/oilpan/oilpan_gc_times_unittest.py deleted 100644 → 0
View file @ 85d27a9f
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import shutil
import tempfile
from contrib.oilpan import oilpan_gc_times
from telemetry import decorators
from telemetry.internal.results import page_test_results
from telemetry.page import page as page_module
from telemetry.testing import options_for_unittests
from telemetry.testing import page_test_test_case
from telemetry.timeline import model
from telemetry.timeline import slice as slice_data
import mock # pylint: disable=import-error
class TestOilpanGCTimesPage(page_module.Page):
def __init__(self, page_set):
super(TestOilpanGCTimesPage, self).__init__(
'file://blank.html', page_set, page_set.base_dir, name='blank.html')
def RunPageInteractions(self, action_runner):
with action_runner.CreateGestureInteraction('ScrollAction'):
action_runner.ScrollPage()
class OilpanGCTimesTestData(object):
def __init__(self, page, thread_name):
self._page = page
self._model = model.TimelineModel()
self._renderer_process = self._model.GetOrCreateProcess(1)
self._renderer_thread = self._renderer_process.GetOrCreateThread(2)
self._renderer_thread.name = thread_name
def AddSlice(self, name, timestamp, duration, args):
new_slice = slice_data.Slice(
None,
'category',
name,
timestamp,
duration,
timestamp,
duration,
args)
self._renderer_thread.all_slices.append(new_slice)
return new_slice
def AddAsyncSlice(self, name, timestamp, duration, args):
new_slice = slice_data.Slice(
None,
'category',
name,
timestamp,
duration,
timestamp,
duration,
args)
self._renderer_thread.async_slices.append(new_slice)
return new_slice
def RunMeasurement(self):
# pylint: disable=protected-access
measurement = oilpan_gc_times._OilpanGCTimesBase()
results = page_test_results.PageTestResults()
tab = mock.MagicMock()
with mock.patch(
'contrib.oilpan.oilpan_gc_times.TimelineModel') as MockTimelineModel:
MockTimelineModel.return_value = self._model
results.WillRunPage(self._page)
try:
measurement.ValidateAndMeasurePage(self._page, tab, results)
finally:
results.DidRunPage(self._page)
return results
class OilpanGCTimesTest(page_test_test_case.PageTestTestCase):
"""Smoke test for Oilpan GC pause time measurements.
Runs OilpanGCTimes measurement on some simple pages and verifies
that all metrics were added to the results. The test is purely functional,
i.e. it only checks if the metrics are present and non-zero.
"""
_KEY_MARK = 'BlinkGC.AtomicPhaseMarking'
_KEY_LAZY_SWEEP = 'BlinkGC.LazySweepInIdle'
_KEY_COMPLETE_SWEEP = 'BlinkGC.CompleteSweep'
_KEY_MEASURE = 'BlinkGCTimeMeasurement'
# Do not add 'forced' in reasons to measure.
_GC_REASONS = ['precise', 'conservative', 'idle']
def setUp(self):
self._options = options_for_unittests.GetRunOptions(
output_dir=tempfile.mkdtemp())
def tearDowmn(self):
shutil.rmtree(self._options.output_dir)
# Disable for accessing private API of _OilpanGCTimesBase.
# pylint: disable=protected-access
@decorators.Disabled('all') # crbug.com/1011787
def testForParsingOldFormat(self):
def getMetric(results, name):
metrics = results.FindAllPageSpecificValuesNamed(name)
self.assertEquals(1, len(metrics))
return metrics[0].values
data = self._GenerateDataForParsingOldFormat()
results = data.RunMeasurement()
self.assertEquals(3, len(getMetric(results, 'oilpan_precise_mark')))
self.assertEquals(3, len(getMetric(results, 'oilpan_precise_lazy_sweep')))
self.assertEquals(3, len(getMetric(results,
'oilpan_precise_complete_sweep')))
self.assertEquals(1, len(getMetric(results, 'oilpan_conservative_mark')))
self.assertEquals(1, len(getMetric(results,
'oilpan_conservative_lazy_sweep')))
self.assertEquals(1, len(getMetric(results,
'oilpan_conservative_complete_sweep')))
self.assertEquals(2, len(getMetric(results, 'oilpan_forced_mark')))
self.assertEquals(2, len(getMetric(results, 'oilpan_forced_lazy_sweep')))
self.assertEquals(2, len(getMetric(results,
'oilpan_forced_complete_sweep')))
# Disable for accessing private API of _OilpanGCTimesBase.
# pylint: disable=protected-access
@decorators.Disabled('all') # crbug.com/1011787
def testForParsing(self):
def getMetric(results, name):
metrics = results.FindAllPageSpecificValuesNamed(name)
self.assertEquals(1, len(metrics))
return metrics[0].values
data = self._GenerateDataForParsing()
results = data.RunMeasurement()
self.assertEquals(4, len(getMetric(results, 'oilpan_precise_mark')))
self.assertEquals(4, len(getMetric(results, 'oilpan_precise_lazy_sweep')))
self.assertEquals(4, len(getMetric(results,
'oilpan_precise_complete_sweep')))
self.assertEquals(5, len(getMetric(results, 'oilpan_conservative_mark')))
self.assertEquals(5, len(getMetric(results,
'oilpan_conservative_lazy_sweep')))
self.assertEquals(5, len(getMetric(results,
'oilpan_conservative_complete_sweep')))
self.assertEquals(1, len(getMetric(results, 'oilpan_forced_mark')))
self.assertEquals(1, len(getMetric(results, 'oilpan_forced_lazy_sweep')))
self.assertEquals(1, len(getMetric(results,
'oilpan_forced_complete_sweep')))
self.assertEquals(2, len(getMetric(results, 'oilpan_idle_mark')))
self.assertEquals(2, len(getMetric(results, 'oilpan_idle_lazy_sweep')))
self.assertEquals(2, len(getMetric(results,
'oilpan_idle_complete_sweep')))
@decorators.Disabled('all')
def testForSmoothness(self):
story_set = self.CreateStorySetFromFileInUnittestDataDir(
'create_many_objects.html')
measurement = oilpan_gc_times.OilpanGCTimesForSmoothness()
results = self.RunMeasurement(
measurement, story_set, run_options=self._options)
self.assertFalse(results.had_failures)
gc_events = []
for gc_reason in self._GC_REASONS:
label = 'oilpan_%s_mark' % gc_reason
gc_events.extend(results.FindAllPageSpecificValuesNamed(label))
self.assertLess(0, len(gc_events))
@decorators.Disabled('all')
def testForBlinkPerf(self):
story_set = self.CreateStorySetFromFileInUnittestDataDir(
'create_many_objects.html')
measurement = oilpan_gc_times.OilpanGCTimesForBlinkPerf()
results = self.RunMeasurement(
measurement, story_set, run_options=self._options)
self.assertFalse(results.had_failures)
gc_events = []
for gc_reason in self._GC_REASONS:
label = 'oilpan_%s_mark' % gc_reason
gc_events.extend(results.FindAllPageSpecificValuesNamed(label))
self.assertLess(0, len(gc_events))
def _GenerateDataForEmptyPageSet(self):
page_set = self.CreateEmptyPageSet()
page = TestOilpanGCTimesPage(page_set)
page_set.AddStory(page)
return OilpanGCTimesTestData(page, 'CrRendererMain')
def _GenerateDataForParsingOldFormat(self):
data = self._GenerateDataForEmptyPageSet()
data.AddSlice(self._KEY_MARK, 1, 1, {'precise': True, 'forced': False})
data.AddSlice(self._KEY_LAZY_SWEEP, 2, 2, {})
data.AddSlice(self._KEY_LAZY_SWEEP, 7, 4, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 16, 6, {})
data.AddSlice(self._KEY_MARK, 22, 7, {'precise': True, 'forced': False})
data.AddSlice(self._KEY_LAZY_SWEEP, 29, 8, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 46, 10, {})
data.AddSlice(self._KEY_MARK, 56, 11, {'precise': False, 'forced': False})
data.AddSlice(self._KEY_LAZY_SWEEP, 67, 12, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 92, 14, {})
data.AddSlice(self._KEY_MARK, 106, 15, {'precise': True, 'forced': False})
data.AddSlice(self._KEY_LAZY_SWEEP, 121, 16, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 154, 18, {})
data.AddSlice(self._KEY_MARK, 172, 19, {'precise': False, 'forced': True})
data.AddSlice(self._KEY_LAZY_SWEEP, 211, 21, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 232, 22, {})
data.AddSlice(self._KEY_MARK, 254, 23, {'precise': True, 'forced': True})
data.AddSlice(self._KEY_LAZY_SWEEP, 301, 25, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 326, 26, {})
return data
def _GenerateDataForParsing(self):
data = self._GenerateDataForEmptyPageSet()
data.AddSlice(self._KEY_MARK, 1, 1,
{'lazySweeping': True, 'gcReason': 'ConservativeGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 2, 2, {})
data.AddSlice(self._KEY_LAZY_SWEEP, 7, 4, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 16, 6, {})
data.AddSlice(self._KEY_MARK, 22, 7,
{'lazySweeping': True, 'gcReason': 'PreciseGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 29, 8, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 46, 10, {})
data.AddSlice(self._KEY_MARK, 56, 11,
{'lazySweeping': False, 'gcReason': 'ConservativeGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 67, 12, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 92, 14, {})
data.AddSlice(self._KEY_MARK, 106, 15,
{'lazySweeping': False, 'gcReason': 'PreciseGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 121, 16, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 154, 18, {})
data.AddSlice(self._KEY_MARK, 172, 19,
{'lazySweeping': False, 'gcReason': 'ForcedGCForTesting'})
data.AddSlice(self._KEY_LAZY_SWEEP, 211, 21, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 232, 22, {})
data.AddSlice(self._KEY_MARK, 254, 23,
{'lazySweeping': False, 'gcReason': 'IdleGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 301, 25, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 326, 26, {})
# Following events are covered with 'BlinkGCTimeMeasurement' event.
first_measure = data.AddSlice(self._KEY_MARK, 352, 27,
{'lazySweeping': False, 'gcReason': 'ConservativeGC'})
data.AddSlice(self._KEY_MARK, 380, 28,
{'lazySweeping': True, 'gcReason': 'ConservativeGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 408, 29, {})
data.AddSlice(self._KEY_LAZY_SWEEP, 437, 30, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 467, 31, {})
data.AddSlice(self._KEY_MARK, 498, 32,
{'lazySweeping': True, 'gcReason': 'PreciseGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 530, 33, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 563, 34, {})
data.AddSlice(self._KEY_MARK, 597, 35,
{'lazySweeping': False, 'gcReason': 'ConservativeGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 632, 36, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 667, 37, {})
data.AddSlice(self._KEY_MARK, 704, 38,
{'lazySweeping': False, 'gcReason': 'PreciseGC'})
data.AddSlice(self._KEY_LAZY_SWEEP, 742, 39, {})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 781, 40, {})
data.AddSlice(self._KEY_MARK, 821, 41,
{'lazySweeping': False, 'gcReason': 'ForcedGCForTesting'})
data.AddSlice(self._KEY_COMPLETE_SWEEP, 862, 42, {})
data.AddSlice(self._KEY_MARK, 904, 43,
{'lazySweeping': False, 'gcReason': 'IdleGC'})
last_measure = data.AddSlice(self._KEY_COMPLETE_SWEEP, 947, 44, {})
# Async event
async_dur = last_measure.end - first_measure.start
data.AddAsyncSlice(self._KEY_MEASURE, first_measure.start, async_dur, {})
return data
tools/perf/expectations.config
View file @ fcb99401
...@@ -219,14 +219,6 @@ crbug.com/865400 [ android-pixel-2 android-webview ] loading.mobile/OLX_3g [ Ski ...@@ -219,14 +219,6 @@ crbug.com/865400 [ android-pixel-2 android-webview ] loading.mobile/OLX_3g [ Ski
crbug.com/865400 [ android-pixel-2 android-webview ] loading.mobile/VoiceMemos_cold_3g [ Skip ] crbug.com/865400 [ android-pixel-2 android-webview ] loading.mobile/VoiceMemos_cold_3g [ Skip ]
crbug.com/919191 [ android-nexus-5x android-webview ] loading.mobile/OLX_3g [ Skip ] crbug.com/919191 [ android-nexus-5x android-webview ] loading.mobile/OLX_3g [ Skip ]
# Benchmark: oilpan_gc_times.key_silk_cases
crbug.com/446332 oilpan_gc_times.key_silk_cases/slide_drawer [ Skip ]
crbug.com/507865 oilpan_gc_times.key_silk_cases/polymer_topeka [ Skip ]
crbug.com/338838 oilpan_gc_times.key_silk_cases/basic_stream [ Skip ]
# Benchmark: oilpan_gc_times.sync_scroll.key_mobile_sites_smooth
crbug.com/756119 oilpan_gc_times.sync_scroll.key_mobile_sites_smooth/digg [ Skip ]
# Benchmark: rendering.desktop # Benchmark: rendering.desktop
crbug.com/755556 [ mac ] rendering.desktop/mix_blend_mode_animation_difference [ Skip ] crbug.com/755556 [ mac ] rendering.desktop/mix_blend_mode_animation_difference [ Skip ]
crbug.com/755556 [ mac ] rendering.desktop/mix_blend_mode_animation_hue [ Skip ] crbug.com/755556 [ mac ] rendering.desktop/mix_blend_mode_animation_hue [ Skip ]
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment