src/tools/telemetry/telemetry/core/tab_unittest.py

   1 # Copyright 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import logging
   6 import tempfile
   7
   8 from telemetry import benchmark
   9 from telemetry.core import bitmap
  10 from telemetry.core import exceptions
  11 from telemetry.core import util
  12 from telemetry.core import video
  13 from telemetry.core.platform import tracing_category_filter
  14 from telemetry.core.platform import tracing_options
  15 from telemetry.timeline import model
  16 from telemetry.unittest import tab_test_case
  17
  18
  19 def _IsDocumentVisible(tab):
  20   return not tab.EvaluateJavaScript('document.hidden || document.webkitHidden')
  21
  22
  23 class FakePlatformBackend(object):
  24   def __init__(self):
  25     self.platform = FakePlatform()
  26
  27   def DidStartBrowser(self, _, _2):
  28     pass
  29
  30   def WillCloseBrowser(self, _, _2):
  31     pass
  32
  33
  34 class FakePlatform(object):
  35   def __init__(self):
  36     self._is_video_capture_running = False
  37
  38   #pylint: disable=W0613
  39   def StartVideoCapture(self, min_bitrate_mbps):
  40     self._is_video_capture_running = True
  41
  42   def StopVideoCapture(self):
  43     self._is_video_capture_running = False
  44     return video.Video(tempfile.NamedTemporaryFile())
  45
  46   @property
  47   def is_video_capture_running(self):
  48     return self._is_video_capture_running
  49
  50
  51 class TabTest(tab_test_case.TabTestCase):
  52   def testNavigateAndWaitForCompleteState(self):
  53     self._tab.Navigate(self.UrlOfUnittestFile('blank.html'))
  54     self._tab.WaitForDocumentReadyStateToBeComplete()
  55
  56   def testNavigateAndWaitForInteractiveState(self):
  57     self._tab.Navigate(self.UrlOfUnittestFile('blank.html'))
  58     self._tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
  59
  60   def testTabBrowserIsRightBrowser(self):
  61     self.assertEquals(self._tab.browser, self._browser)
  62
  63   def testRendererCrash(self):
  64     self.assertRaises(exceptions.TabCrashException,
  65                       lambda: self._tab.Navigate('chrome://crash',
  66                                                  timeout=5))
  67
  68   @benchmark.Enabled('has tabs')
  69   def testActivateTab(self):
  70     util.WaitFor(lambda: _IsDocumentVisible(self._tab), timeout=5)
  71     new_tab = self._browser.tabs.New()
  72     new_tab.Navigate('about:blank')
  73     util.WaitFor(lambda: _IsDocumentVisible(new_tab), timeout=5)
  74     self.assertFalse(_IsDocumentVisible(self._tab))
  75     self._tab.Activate()
  76     util.WaitFor(lambda: _IsDocumentVisible(self._tab), timeout=5)
  77     self.assertFalse(_IsDocumentVisible(new_tab))
  78
  79   def testTabUrl(self):
  80     self.assertEquals(self._tab.url, 'about:blank')
  81     url = self.UrlOfUnittestFile('blank.html')
  82     self._tab.Navigate(url)
  83     self.assertEquals(self._tab.url, url)
  84
  85   def testIsTimelineRecordingRunningTab(self):
  86     self.assertFalse(self._tab.is_timeline_recording_running)
  87     self._tab.StartTimelineRecording()
  88     self.assertTrue(self._tab.is_timeline_recording_running)
  89     self._tab.StopTimelineRecording()
  90     self.assertFalse(self._tab.is_timeline_recording_running)
  91
  92   #pylint: disable=W0212
  93   def testIsVideoCaptureRunning(self):
  94     original_platform_backend = self._tab.browser._platform_backend
  95     try:
  96       self._tab.browser._platform_backend = FakePlatformBackend()
  97       self.assertFalse(self._tab.is_video_capture_running)
  98       self._tab.StartVideoCapture(min_bitrate_mbps=2)
  99       self.assertTrue(self._tab.is_video_capture_running)
 100       self.assertIsNotNone(self._tab.StopVideoCapture())
 101       self.assertFalse(self._tab.is_video_capture_running)
 102     finally:
 103       self._tab.browser._platform_backend = original_platform_backend
 104
 105   @benchmark.Disabled('chromeos') # crbug.com/412713.
 106   def testHighlight(self):
 107     self.assertEquals(self._tab.url, 'about:blank')
 108     options = tracing_options.TracingOptions()
 109     options.enable_chrome_trace = True
 110     self._browser.platform.tracing_controller.Start(
 111         options, tracing_category_filter.CreateNoOverheadFilter())
 112     self._tab.Highlight(bitmap.WEB_PAGE_TEST_ORANGE)
 113     self._tab.ClearHighlight(bitmap.WEB_PAGE_TEST_ORANGE)
 114     trace_data = self._browser.platform.tracing_controller.Stop()
 115     timeline_model = model.TimelineModel(trace_data)
 116     renderer_thread = timeline_model.GetRendererThreadFromTabId(
 117         self._tab.id)
 118     found_video_start_event = False
 119     for event in renderer_thread.async_slices:
 120       if event.name == '__ClearHighlight.video_capture_start':
 121         found_video_start_event = True
 122         break
 123     self.assertTrue(found_video_start_event)
 124
 125   @benchmark.Enabled('has tabs')
 126   @benchmark.Disabled('chromeos') # crbug.com/412713.
 127   def testGetRendererThreadFromTabId(self):
 128     self.assertEquals(self._tab.url, 'about:blank')
 129     # Create 3 tabs. The third tab is closed before we call
 130     # tracing_controller.Start.
 131     first_tab = self._tab
 132     second_tab = self._browser.tabs.New()
 133     second_tab.Navigate('about:blank')
 134     second_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
 135     third_tab = self._browser.tabs.New()
 136     third_tab.Navigate('about:blank')
 137     third_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
 138     third_tab.Close()
 139     options = tracing_options.TracingOptions()
 140     options.enable_chrome_trace = True
 141     self._browser.platform.tracing_controller.Start(
 142         options, tracing_category_filter.CreateNoOverheadFilter())
 143     first_tab.ExecuteJavaScript('console.time("first-tab-marker");')
 144     first_tab.ExecuteJavaScript('console.timeEnd("first-tab-marker");')
 145     second_tab.ExecuteJavaScript('console.time("second-tab-marker");')
 146     second_tab.ExecuteJavaScript('console.timeEnd("second-tab-marker");')
 147     trace_data = self._browser.platform.tracing_controller.Stop()
 148     timeline_model = model.TimelineModel(trace_data)
 149
 150     # Assert that the renderer_thread of the first tab contains
 151     # 'first-tab-marker'.
 152     renderer_thread = timeline_model.GetRendererThreadFromTabId(
 153         first_tab.id)
 154     first_tab_markers = [
 155         renderer_thread.IterAllSlicesOfName('first-tab-marker')]
 156     self.assertEquals(1, len(first_tab_markers))
 157
 158     # Close second tab and assert that the renderer_thread of the second tab
 159     # contains 'second-tab-marker'.
 160     second_tab.Close()
 161     renderer_thread = timeline_model.GetRendererThreadFromTabId(
 162         second_tab.id)
 163     second_tab_markers = [
 164         renderer_thread.IterAllSlicesOfName('second-tab-marker')]
 165     self.assertEquals(1, len(second_tab_markers))
 166
 167     # Third tab wasn't available when we start tracing, so there is no
 168     # renderer_thread corresponding to it in the the trace.
 169     self.assertIs(None, timeline_model.GetRendererThreadFromTabId(third_tab.id))
 170
 171
 172 class GpuTabTest(tab_test_case.TabTestCase):
 173   @classmethod
 174   def CustomizeBrowserOptions(cls, options):
 175     options.AppendExtraBrowserArgs('--enable-gpu-benchmarking')
 176
 177   # Test flaky on mac: http://crbug.com/358664
 178   @benchmark.Disabled('android', 'mac')
 179   def testScreenshot(self):
 180     if not self._tab.screenshot_supported:
 181       logging.warning('Browser does not support screenshots, skipping test.')
 182       return
 183
 184     self.Navigate('green_rect.html')
 185     pixel_ratio = self._tab.EvaluateJavaScript('window.devicePixelRatio || 1')
 186
 187     screenshot = self._tab.Screenshot(5)
 188     assert screenshot
 189     screenshot.GetPixelColor(0 * pixel_ratio, 0 * pixel_ratio).AssertIsRGB(
 190         0, 255, 0, tolerance=2)
 191     screenshot.GetPixelColor(31 * pixel_ratio, 31 * pixel_ratio).AssertIsRGB(
 192         0, 255, 0, tolerance=2)
 193     screenshot.GetPixelColor(32 * pixel_ratio, 32 * pixel_ratio).AssertIsRGB(
 194         255, 255, 255, tolerance=2)