-# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Copyright 2012 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 logging
+import tempfile
-from telemetry.core import util
+from telemetry import benchmark
+from telemetry.core import bitmap
from telemetry.core import exceptions
+from telemetry.core import util
+from telemetry.core import video
+from telemetry.core.platform import tracing_category_filter
+from telemetry.timeline import model
from telemetry.unittest import tab_test_case
return not tab.EvaluateJavaScript('document.hidden || document.webkitHidden')
+class FakePlatformBackend(object):
+ def __init__(self):
+ self.platform = FakePlatform()
+
+ def DidStartBrowser(self, _, _2):
+ pass
+
+ def WillCloseBrowser(self, _, _2):
+ pass
+
+
class FakePlatform(object):
def __init__(self):
self._is_video_capture_running = False
def StopVideoCapture(self):
self._is_video_capture_running = False
- return []
-
- def SetFullPerformanceModeEnabled(self, enabled):
- pass
+ return video.Video(tempfile.NamedTemporaryFile())
@property
def is_video_capture_running(self):
class TabTest(tab_test_case.TabTestCase):
- def testNavigateAndWaitToForCompleteState(self):
- self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
- self._tab.Navigate(self._browser.http_server.UrlOf('blank.html'))
+ def testNavigateAndWaitForCompleteState(self):
+ self._tab.Navigate(self.UrlOfUnittestFile('blank.html'))
self._tab.WaitForDocumentReadyStateToBeComplete()
- def testNavigateAndWaitToForInteractiveState(self):
- self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
- self._tab.Navigate(self._browser.http_server.UrlOf('blank.html'))
+ def testNavigateAndWaitForInteractiveState(self):
+ self._tab.Navigate(self.UrlOfUnittestFile('blank.html'))
self._tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
def testTabBrowserIsRightBrowser(self):
lambda: self._tab.Navigate('chrome://crash',
timeout=5))
+ @benchmark.Enabled('has tabs')
def testActivateTab(self):
- if not self._browser.supports_tab_control:
- logging.warning('Browser does not support tab control, skipping test.')
- return
-
- self.assertTrue(_IsDocumentVisible(self._tab))
+ util.WaitFor(lambda: _IsDocumentVisible(self._tab), timeout=5)
new_tab = self._browser.tabs.New()
new_tab.Navigate('about:blank')
util.WaitFor(lambda: _IsDocumentVisible(new_tab), timeout=5)
util.WaitFor(lambda: _IsDocumentVisible(self._tab), timeout=5)
self.assertFalse(_IsDocumentVisible(new_tab))
+ def testTabUrl(self):
+ self.assertEquals(self._tab.url, 'about:blank')
+ url = self.UrlOfUnittestFile('blank.html')
+ self._tab.Navigate(url)
+ self.assertEquals(self._tab.url, url)
+
def testIsTimelineRecordingRunningTab(self):
self.assertFalse(self._tab.is_timeline_recording_running)
self._tab.StartTimelineRecording()
#pylint: disable=W0212
def testIsVideoCaptureRunning(self):
- original_platform = self._tab.browser._platform
- self._tab.browser._platform = FakePlatform()
- self.assertFalse(self._tab.is_video_capture_running)
- self._tab.StartVideoCapture(min_bitrate_mbps=2)
- self.assertTrue(self._tab.is_video_capture_running)
+ original_platform_backend = self._tab.browser._platform_backend
try:
- self._tab.StopVideoCapture().next()
- except Exception:
- pass
- self.assertFalse(self._tab.is_video_capture_running)
- self._tab.browser._platform = original_platform
+ self._tab.browser._platform_backend = FakePlatformBackend()
+ self.assertFalse(self._tab.is_video_capture_running)
+ self._tab.StartVideoCapture(min_bitrate_mbps=2)
+ self.assertTrue(self._tab.is_video_capture_running)
+ self.assertIsNotNone(self._tab.StopVideoCapture())
+ self.assertFalse(self._tab.is_video_capture_running)
+ finally:
+ self._tab.browser._platform_backend = original_platform_backend
+
+ def testHighlight(self):
+ self.assertEquals(self._tab.url, 'about:blank')
+ self._browser.StartTracing()
+ self._tab.Highlight(bitmap.WEB_PAGE_TEST_ORANGE)
+ self._tab.ClearHighlight(bitmap.WEB_PAGE_TEST_ORANGE)
+ trace_data = self._browser.StopTracing()
+ timeline_model = model.TimelineModel(trace_data)
+ renderer_thread = timeline_model.GetRendererThreadFromTabId(
+ self._tab.id)
+ found_video_start_event = False
+ for event in renderer_thread.async_slices:
+ if event.name == '__ClearHighlight.video_capture_start':
+ found_video_start_event = True
+ break
+ self.assertTrue(found_video_start_event)
+
+ @benchmark.Enabled('has tabs')
+ def testGetRendererThreadFromTabId(self):
+ self.assertEquals(self._tab.url, 'about:blank')
+ # Create 3 tabs. The third tab is closed before we call StartTracing.
+ first_tab = self._tab
+ second_tab = self._browser.tabs.New()
+ second_tab.Navigate('about:blank')
+ second_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
+ third_tab = self._browser.tabs.New()
+ third_tab.Navigate('about:blank')
+ third_tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
+ third_tab.Close()
+
+ self._browser.StartTracing(
+ tracing_category_filter.CreateNoOverheadFilter())
+ first_tab.ExecuteJavaScript('console.time("first-tab-marker");')
+ first_tab.ExecuteJavaScript('console.timeEnd("first-tab-marker");')
+ second_tab.ExecuteJavaScript('console.time("second-tab-marker");')
+ second_tab.ExecuteJavaScript('console.timeEnd("second-tab-marker");')
+ trace_data = self._browser.StopTracing()
+ timeline_model = model.TimelineModel(trace_data)
+
+ # Assert that the renderer_thread of the first tab contains
+ # 'first-tab-marker'.
+ renderer_thread = timeline_model.GetRendererThreadFromTabId(
+ first_tab.id)
+ first_tab_markers = [
+ renderer_thread.IterAllSlicesOfName('first-tab-marker')]
+ self.assertEquals(1, len(first_tab_markers))
+
+ # Close second tab and assert that the renderer_thread of the second tab
+ # contains 'second-tab-marker'.
+ second_tab.Close()
+ renderer_thread = timeline_model.GetRendererThreadFromTabId(
+ second_tab.id)
+ second_tab_markers = [
+ renderer_thread.IterAllSlicesOfName('second-tab-marker')]
+ self.assertEquals(1, len(second_tab_markers))
+
+ # Third tab wasn't available when we start tracing, so there is no
+ # renderer_thread corresponding to it in the the trace.
+ self.assertIs(None, timeline_model.GetRendererThreadFromTabId(third_tab.id))
class GpuTabTest(tab_test_case.TabTestCase):
- def setUp(self):
- self._extra_browser_args = ['--enable-gpu-benchmarking']
- super(GpuTabTest, self).setUp()
+ @classmethod
+ def CustomizeBrowserOptions(cls, options):
+ options.AppendExtraBrowserArgs('--enable-gpu-benchmarking')
+ # Test flaky on mac: http://crbug.com/358664
+ @benchmark.Disabled('android', 'mac')
def testScreenshot(self):
if not self._tab.screenshot_supported:
logging.warning('Browser does not support screenshots, skipping test.')
projects / platform / framework / web / crosswalk.git / blobdiff