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
   7 from telemetry import test
   8 from telemetry.core import bitmap
   9 from telemetry.core import video
  10 from telemetry.core import util
  11 from telemetry.core import exceptions
  12 from telemetry.core.backends.chrome import tracing_backend
  13 from telemetry.timeline import model
  14 from telemetry.unittest import tab_test_case
  15
  16
  17 def _IsDocumentVisible(tab):
  18   return not tab.EvaluateJavaScript('document.hidden || document.webkitHidden')
  19
  20
  21 class FakePlatform(object):
  22   def __init__(self):
  23     self._is_video_capture_running = False
  24
  25   #pylint: disable=W0613
  26   def StartVideoCapture(self, min_bitrate_mbps):
  27     self._is_video_capture_running = True
  28
  29   def StopVideoCapture(self):
  30     self._is_video_capture_running = False
  31     return video.Video(self, None)
  32
  33   def SetFullPerformanceModeEnabled(self, enabled):
  34     pass
  35
  36   @property
  37   def is_video_capture_running(self):
  38     return self._is_video_capture_running
  39
  40
  41 class TabTest(tab_test_case.TabTestCase):
  42   def testNavigateAndWaitToForCompleteState(self):
  43     self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
  44     self._tab.Navigate(self._browser.http_server.UrlOf('blank.html'))
  45     self._tab.WaitForDocumentReadyStateToBeComplete()
  46
  47   def testNavigateAndWaitToForInteractiveState(self):
  48     self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
  49     self._tab.Navigate(self._browser.http_server.UrlOf('blank.html'))
  50     self._tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
  51
  52   def testTabBrowserIsRightBrowser(self):
  53     self.assertEquals(self._tab.browser, self._browser)
  54
  55   def testRendererCrash(self):
  56     self.assertRaises(exceptions.TabCrashException,
  57                       lambda: self._tab.Navigate('chrome://crash',
  58                                                  timeout=5))
  59
  60   def testActivateTab(self):
  61     if not self._browser.supports_tab_control:
  62       logging.warning('Browser does not support tab control, skipping test.')
  63       return
  64
  65     util.WaitFor(lambda: _IsDocumentVisible(self._tab), timeout=5)
  66     new_tab = self._browser.tabs.New()
  67     new_tab.Navigate('about:blank')
  68     util.WaitFor(lambda: _IsDocumentVisible(new_tab), timeout=5)
  69     self.assertFalse(_IsDocumentVisible(self._tab))
  70     self._tab.Activate()
  71     util.WaitFor(lambda: _IsDocumentVisible(self._tab), timeout=5)
  72     self.assertFalse(_IsDocumentVisible(new_tab))
  73
  74   def testTabUrl(self):
  75     self.assertEquals(self._tab.url, 'about:blank')
  76     self.Navigate('blank.html')
  77     self.assertEquals(self._tab.url, self.test_url)
  78
  79   def testIsTimelineRecordingRunningTab(self):
  80     self.assertFalse(self._tab.is_timeline_recording_running)
  81     self._tab.StartTimelineRecording()
  82     self.assertTrue(self._tab.is_timeline_recording_running)
  83     self._tab.StopTimelineRecording()
  84     self.assertFalse(self._tab.is_timeline_recording_running)
  85
  86   #pylint: disable=W0212
  87   def testIsVideoCaptureRunning(self):
  88     original_platform = self._tab.browser._platform
  89     self._tab.browser._platform = FakePlatform()
  90     self.assertFalse(self._tab.is_video_capture_running)
  91     self._tab.StartVideoCapture(min_bitrate_mbps=2)
  92     self.assertTrue(self._tab.is_video_capture_running)
  93     self.assertIsNotNone(self._tab.StopVideoCapture())
  94     self.assertFalse(self._tab.is_video_capture_running)
  95     self._tab.browser._platform = original_platform
  96
  97   def testHighlight(self):
  98     self.assertEquals(self._tab.url, 'about:blank')
  99     self._browser.StartTracing(tracing_backend.DEFAULT_TRACE_CATEGORIES)
 100     self._tab.Highlight(bitmap.WEB_PAGE_TEST_ORANGE)
 101     self._tab.ClearHighlight(bitmap.WEB_PAGE_TEST_ORANGE)
 102     trace_data = self._browser.StopTracing()
 103     timeline_model = model.TimelineModel(trace_data)
 104     renderer_thread = timeline_model.GetRendererThreadFromTabId(
 105         self._tab.id)
 106     found_video_start_event = False
 107     for event in renderer_thread.async_slices:
 108       if event.name == '__ClearHighlight.video_capture_start':
 109         found_video_start_event = True
 110         break
 111     self.assertTrue(found_video_start_event)
 112
 113   def testGetRendererThreadFromTabId(self):
 114     self.assertEquals(self._tab.url, 'about:blank')
 115     # Create 3 tabs. The third tab is closed before we call StartTracing.
 116     first_tab = self._tab
 117     second_tab = self._browser.tabs.New()
 118     second_tab.Navigate('about:blank')
 119     second_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
 120     third_tab = self._browser.tabs.New()
 121     third_tab.Navigate('about:blank')
 122     third_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
 123     third_tab.Close()
 124
 125     self._browser.StartTracing(tracing_backend.MINIMAL_TRACE_CATEGORIES)
 126     first_tab.ExecuteJavaScript('console.time("first-tab-marker");')
 127     first_tab.ExecuteJavaScript('console.timeEnd("first-tab-marker");')
 128     second_tab.ExecuteJavaScript('console.time("second-tab-marker");')
 129     second_tab.ExecuteJavaScript('console.timeEnd("second-tab-marker");')
 130     trace_data = self._browser.StopTracing()
 131     timeline_model = model.TimelineModel(trace_data)
 132
 133     # Assert that the renderer_thread of the first tab contains
 134     # 'first-tab-marker'.
 135     renderer_thread = timeline_model.GetRendererThreadFromTabId(
 136         first_tab.id)
 137     first_tab_markers = [
 138         renderer_thread.IterAllSlicesOfName('first-tab-marker')]
 139     self.assertEquals(1, len(first_tab_markers))
 140
 141     # Close second tab and assert that the renderer_thread of the second tab
 142     # contains 'second-tab-marker'.
 143     second_tab.Close()
 144     renderer_thread = timeline_model.GetRendererThreadFromTabId(
 145         second_tab.id)
 146     second_tab_markers = [
 147         renderer_thread.IterAllSlicesOfName('second-tab-marker')]
 148     self.assertEquals(1, len(second_tab_markers))
 149
 150     # Third tab wasn't available when we start tracing, so there is no
 151     # renderer_thread corresponding to it in the the trace.
 152     self.assertIs(None, timeline_model.GetRendererThreadFromTabId(third_tab.id))
 153
 154
 155 class GpuTabTest(tab_test_case.TabTestCase):
 156   def setUp(self):
 157     self._extra_browser_args = ['--enable-gpu-benchmarking']
 158     super(GpuTabTest, self).setUp()
 159
 160   # Test flaky on mac: http://crbug.com/358664
 161   @test.Disabled('android', 'mac')
 162   def testScreenshot(self):
 163     if not self._tab.screenshot_supported:
 164       logging.warning('Browser does not support screenshots, skipping test.')
 165       return
 166
 167     self.Navigate('green_rect.html')
 168     pixel_ratio = self._tab.EvaluateJavaScript('window.devicePixelRatio || 1')
 169
 170     screenshot = self._tab.Screenshot(5)
 171     assert screenshot
 172     screenshot.GetPixelColor(0 * pixel_ratio, 0 * pixel_ratio).AssertIsRGB(
 173         0, 255, 0, tolerance=2)
 174     screenshot.GetPixelColor(31 * pixel_ratio, 31 * pixel_ratio).AssertIsRGB(
 175         0, 255, 0, tolerance=2)
 176     screenshot.GetPixelColor(32 * pixel_ratio, 32 * pixel_ratio).AssertIsRGB(
 177         255, 255, 255, tolerance=2)