Fix ineffective --disable-gpu-driver-bug-workarounds

content/test/gpu/page_sets/gpu_process_tests.py

 # 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 sys
 from telemetry.story import story_set as story_set_module
 from telemetry.page import page_test
 
 from gpu_tests import gpu_test_base
 
 class GpuProcessSharedPageState(gpu_test_base.GpuSharedPageState):
@@ skipping 552 matching lines @@
       shared_page_state_class=NoTransparentVisualsShared,
       expectations=expectations,
       expected_workaround='disable_transparent_visuals',
       unexpected_workaround=None)
 
   def Validate(self, tab, results):
     if sys.platform.startswith('linux'):
       super(NoTransparentVisualsGpuProcessPage, self).Validate(tab, results)
 
 
+class OnlyOneWorkaroundSharedPageState(GpuProcessSharedPageState):
+  def __init__(self, test, finder_options, story_set):
+    super(OnlyOneWorkaroundSharedPageState, self).__init__(
+      test, finder_options, story_set)
+
+  # Extra browser args need to be added here. Adding them in RunStory would be
+  # too late.
+  def WillRunStory(self, results):
+    if self._previous_page:
+      options = self._finder_options.browser_options
+      options.AppendExtraBrowserArgs('--disable-gpu-driver-bug-workarounds')
+      options.AppendExtraBrowserArgs('--use_gpu_driver_workaround_for_testing')
+      for workaround in self._previous_page.gpu_workarounds:
+        options.AppendExtraBrowserArgs('--' + workaround)
+    super(OnlyOneWorkaroundSharedPageState, self).WillRunStory(results)
+
+  # self._current_page is None in WillRunStory so do the transfer here.
+  def RunStory(self, results):
+    if self._previous_page:
+      self._current_page.gpu_workarounds = self._previous_page.gpu_workarounds
+    super(OnlyOneWorkaroundSharedPageState, self).RunStory(results)
+
+class OnlyOneWorkaroundPage(gpu_test_base.PageBase):
+  def __init__(self, story_set, expectations):
+    super(OnlyOneWorkaroundPage, self).__init__(
+      url='chrome:gpu',
+      name='GpuProcess.only_one_workaround',
+      page_set=story_set,
+      shared_page_state_class=OnlyOneWorkaroundSharedPageState,
+      expectations=expectations)
+    self.gpu_workarounds = None
+
+  def Validate(self, tab, results):

[Ken Russell (switch to Gerrit), 2016/08/09 21:30:32]

Does this test pass the first time through? If so, why does it? It doesn't look
like use_gpu_driver_workaround_for_testing is set the first time through so it
looks to me like the test should fail, unless it can detect that it should exit
early.

[Julien Isorce Samsung, 2016/08/15 23:29:44]

Yes. 

+    browser_list = tab.EvaluateJavaScript('GetDriverBugWorkarounds()')
+    gpu_list = tab.EvaluateJavaScript( \
+      'chrome.gpuBenchmarking.getGpuDriverBugWorkarounds()')
+
+    diff = set(browser_list).symmetric_difference(set(gpu_list))
+    if len(diff) > 0:
+      print 'Test failed. Printing page contents:'
+      print tab.EvaluateJavaScript('document.body.innerHTML')
+      raise page_test.Failure('Browser and GPU process list of driver bug' \
+        'workarounds are not equal: %s != %s, diff: %s' % \
+        (browser_list, gpu_list, list(diff)))
+
+    if self.gpu_workarounds is None:
+      self.gpu_workarounds = gpu_list
+      return
+
+    self.gpu_workarounds.append('use_gpu_driver_workaround_for_testing')
+    diff = set(self.gpu_workarounds).symmetric_difference(set(gpu_list))
+    if len(diff) > 0:
+      print 'Test failed. Printing page contents:'
+      print tab.EvaluateJavaScript('document.body.innerHTML')
+      raise page_test.Failure('GPU process and expected list of driver bug' \
+        'workarounds are not equal: %s != %s, diff: %s' % \
+        (self.gpu_workarounds, gpu_list, list(diff)))
+
+
 class GpuProcessTestsStorySet(story_set_module.StorySet):
 
   """ Tests that accelerated content triggers the creation of a GPU process """
 
   def __init__(self, expectations, is_platform_android):
     super(GpuProcessTestsStorySet, self).__init__(
       serving_dirs=set(['../../../../content/test/data']))
 
     urls_and_names_list = [
       ('file://../../data/gpu/functional_canvas_demo.html',
@@ skipping 13 matching lines @@
     self.AddStory(SoftwareGpuProcessPage(self, expectations))
     self.AddStory(DriverBugWorkaroundsInGpuProcessPage(self, expectations))
     self.AddStory(IdentifyActiveGpuPage1(self, expectations))
     self.AddStory(IdentifyActiveGpuPage2(self, expectations))
     self.AddStory(IdentifyActiveGpuPage3(self, expectations))
     self.AddStory(IdentifyActiveGpuPage4(self, expectations))
     self.AddStory(ReadbackWebGLGpuProcessPage(self, expectations))
     self.AddStory(DriverBugWorkaroundsUponGLRendererPage(self, expectations))
     self.AddStory(EqualBugWorkaroundsInBrowserAndGpuProcessPage(self,
                                                                 expectations))
+    self.AddStory(OnlyOneWorkaroundPage(self, expectations))

[Ken Russell (switch to Gerrit), 2016/08/09 21:30:32]

If it works correctly to run the same test twice, the first time to gather the
browser's driver bug workarounds and the second time to launch the browser with
them, then please add a comment here indicating why the test's being run twice.

[Julien Isorce Samsung, 2016/08/15 23:29:44]

In patch set 8, I merged the warmup test with existing test
EqualBugWorkaroundsPage since they were doing the same thing essentially.

+    self.AddStory(OnlyOneWorkaroundPage(self, expectations))
+
     if not is_platform_android:
       self.AddStory(SkipGpuProcessPage(self, expectations))
       self.AddStory(HasTransparentVisualsGpuProcessPage(self, expectations))
       self.AddStory(NoTransparentVisualsGpuProcessPage(self, expectations))
 
   @property
   def allow_mixed_story_states(self):
     # Return True here in order to be able to run pages with different browser
     # command line arguments.
     return True