[telemetry] Create BrowserTestCase to reuse the browser for browser_unittest.

This brings browser_unittest's run time from 21s to 7s on a Z620 Linux, one of our fastest
configurations. (We still need 3 browser launches to test browser options and profile loading.)

Add BrowserTestCase as the new parent class of TabTestCase. The separation is very clean :)
Also add helper method UrlOfUnittestFile - many tests are using http_server.UrlOf incorrectly,
and this helper ensures the HTTP server is running and we're pointing to the right file.
Also move page_test_test_case from testing/ to unittest/ and remove testing/.


BUG=388256
TEST=tools/telemetry/run_tests

Review URL: https://codereview.chromium.org/469593002

Cr-Commit-Position: refs/heads/master@{#289247}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@289247 0039d316-1c4b-4281-b951-d872f2087c98

tools/perf/measurements/loading_trace_unittest.py

@@ -4,8 +4,8 @@
 
 from measurements import loading_trace
 from telemetry.core import wpr_modes
-from telemetry.testing import page_test_test_case
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 
 class LoadingTraceUnitTest(page_test_test_case.PageTestTestCase):
   def setUp(self):

tools/perf/measurements/rasterize_and_record_micro_unittest.py

@@ -7,9 +7,9 @@ import logging
 from measurements import rasterize_and_record_micro
 from telemetry.core import wpr_modes
 from telemetry.page import page_test
-from telemetry.testing import page_test_test_case
-from telemetry.unittest import test
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
+from telemetry.unittest import test
 
 
 class RasterizeAndRecordMicroUnitTest(page_test_test_case.PageTestTestCase):

tools/perf/measurements/record_per_area_unittest.py

@@ -4,9 +4,9 @@
 
 from measurements import record_per_area
 from telemetry.core import wpr_modes
-from telemetry.testing import page_test_test_case
-from telemetry.unittest import test
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
+from telemetry.unittest import test
 
 
 class RecordPerAreaUnitTest(page_test_test_case.PageTestTestCase):

tools/perf/measurements/repaint_unittest.py

@@ -5,8 +5,8 @@
 from measurements import repaint
 from telemetry.core import wpr_modes
 from telemetry.page import page as page_module
-from telemetry.testing import page_test_test_case
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 from telemetry.unittest import test
 
 

tools/perf/measurements/screenshot_unittest.py

@@ -9,8 +9,8 @@ import tempfile
 from measurements import screenshot
 from telemetry import benchmark
 from telemetry.page import page_test
-from telemetry.testing import page_test_test_case
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 
 
 class ScreenshotUnitTest(page_test_test_case.PageTestTestCase):

tools/perf/measurements/skpicture_printer_unittest.py

@@ -6,8 +6,8 @@ import shutil
 import tempfile
 
 from measurements import skpicture_printer
-from telemetry.testing import page_test_test_case
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 from telemetry.unittest import test
 
 

tools/perf/measurements/smoothness_unittest.py

@@ -9,8 +9,8 @@ from telemetry.core import exceptions
 from telemetry.core import wpr_modes
 from telemetry.page import page
 from telemetry.page import page_test
-from telemetry.testing import page_test_test_case
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 
 class FakePlatform(object):
   def IsRawDisplayFrameRateSupported(self):

tools/perf/measurements/thread_times_unittest.py

@@ -6,8 +6,8 @@ from measurements import thread_times
 from measurements import smoothness_unittest
 from metrics import timeline
 from telemetry.core import wpr_modes
-from telemetry.testing import page_test_test_case
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 from telemetry.unittest import test
 
 

tools/telemetry/telemetry/core/backends/chrome/tracing_backend_unittest.py

@@ -8,8 +8,8 @@ import logging
 import unittest
 
 from telemetry.core import util
+from telemetry.timeline import model
 from telemetry.timeline import tracing_timeline_data
-from telemetry.timeline.model import TimelineModel
 from telemetry.unittest import tab_test_case
 
 
@@ -83,5 +83,5 @@ class ChromeTraceResultTest(unittest.TestCase):
         '{"name": "thread_name",'
         '"args": {"name": "CrBrowserMain"},'
         '"pid": 5, "tid": 32578, "ph": "M"}']))
-    model = TimelineModel(ri)
-    self.assertEquals(model.browser_process.pid, 5)
+    timeline_model = model.TimelineModel(ri)
+    self.assertEquals(timeline_model.browser_process.pid, 5)

tools/telemetry/telemetry/core/browser_unittest.py

@@ -3,138 +3,82 @@
 # found in the LICENSE file.
 
 import logging
-import unittest
 
 from telemetry import benchmark
-from telemetry.core import browser_finder
 from telemetry.core import gpu_device
 from telemetry.core import gpu_info
 from telemetry.core import system_info
-from telemetry.core import util
-from telemetry.unittest import options_for_unittests
+from telemetry.unittest import browser_test_case
 
 
-class BrowserTest(unittest.TestCase):
-  def setUp(self):
-    self._browser = None
-
-  def CreateBrowser(self,
-                    extra_browser_args=None,
-                    profile_type=None):
-    assert not self._browser
-
-    options = options_for_unittests.GetCopy()
-
-    if profile_type:
-      options.browser_options.profile_type = profile_type
-
-    if extra_browser_args:
-      options.AppendExtraBrowserArgs(extra_browser_args)
-
-    browser_to_create = browser_finder.FindBrowser(options)
-    if not browser_to_create:
-      raise Exception('No browser found, cannot continue test.')
-    self._browser = browser_to_create.Create()
-    self._browser.Start()
-
-    self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
-
-    return self._browser
-
-  def tearDown(self):
-    if self._browser:
-      self._browser.Close()
-
+class BrowserTest(browser_test_case.BrowserTestCase):
   def testBrowserCreation(self):
-    b = self.CreateBrowser()
-    self.assertEquals(1, len(b.tabs))
+    self.assertEquals(1, len(self._browser.tabs))
 
     # Different browsers boot up to different things.
-    assert b.tabs[0].url
-
-  def testCommandLineOverriding(self):
-    # This test starts the browser with --user-agent=telemetry. This tests
-    # whether the user agent is then set.
-    flag1 = '--user-agent=telemetry'
-    b = self.CreateBrowser(extra_browser_args=[flag1])
-    t = b.tabs[0]
-    t.Navigate(b.http_server.UrlOf('blank.html'))
-    t.WaitForDocumentReadyStateToBeInteractiveOrBetter()
-    self.assertEquals(t.EvaluateJavaScript('navigator.userAgent'),
-                      'telemetry')
+    assert self._browser.tabs[0].url
 
   def testVersionDetection(self):
-    b = self.CreateBrowser()
-    v = b._browser_backend.chrome_branch_number # pylint: disable=W0212
+    # pylint: disable=W0212
+    v = self._browser._browser_backend.chrome_branch_number
     self.assertTrue(v > 0)
 
   @benchmark.Enabled('has tabs')
   def testNewCloseTab(self):
-    b = self.CreateBrowser()
-    existing_tab = b.tabs[0]
-    self.assertEquals(1, len(b.tabs))
+    existing_tab = self._browser.tabs[0]
+    self.assertEquals(1, len(self._browser.tabs))
     existing_tab_url = existing_tab.url
 
-    new_tab = b.tabs.New()
-    self.assertEquals(2, len(b.tabs))
+    new_tab = self._browser.tabs.New()
+    self.assertEquals(2, len(self._browser.tabs))
     self.assertEquals(existing_tab.url, existing_tab_url)
     self.assertEquals(new_tab.url, 'about:blank')
 
     new_tab.Close()
-    self.assertEquals(1, len(b.tabs))
+    self.assertEquals(1, len(self._browser.tabs))
     self.assertEquals(existing_tab.url, existing_tab_url)
 
   def testMultipleTabCalls(self):
-    b = self.CreateBrowser()
-    b.tabs[0].Navigate(b.http_server.UrlOf('blank.html'))
-    b.tabs[0].WaitForDocumentReadyStateToBeInteractiveOrBetter()
+    self._browser.tabs[0].Navigate(self.UrlOfUnittestFile('blank.html'))
+    self._browser.tabs[0].WaitForDocumentReadyStateToBeInteractiveOrBetter()
 
   def testTabCallByReference(self):
-    b = self.CreateBrowser()
-    tab = b.tabs[0]
-    tab.Navigate(b.http_server.UrlOf('blank.html'))
-    b.tabs[0].WaitForDocumentReadyStateToBeInteractiveOrBetter()
+    tab = self._browser.tabs[0]
+    tab.Navigate(self.UrlOfUnittestFile('blank.html'))
+    self._browser.tabs[0].WaitForDocumentReadyStateToBeInteractiveOrBetter()
 
   @benchmark.Enabled('has tabs')
   @benchmark.Disabled('win')  # crbug.com/321527
   def testCloseReferencedTab(self):
-    b = self.CreateBrowser()
-    b.tabs.New()
-    tab = b.tabs[0]
-    tab.Navigate(b.http_server.UrlOf('blank.html'))
+    self._browser.tabs.New()
+    tab = self._browser.tabs[0]
+    tab.Navigate(self.UrlOfUnittestFile('blank.html'))
     tab.Close()
-    self.assertEquals(1, len(b.tabs))
+    self.assertEquals(1, len(self._browser.tabs))
 
   @benchmark.Enabled('has tabs')
   def testForegroundTab(self):
-    b = self.CreateBrowser()
     # Should be only one tab at this stage, so that must be the foreground tab
-    original_tab = b.tabs[0]
-    self.assertEqual(b.foreground_tab, original_tab)
-    new_tab = b.tabs.New()
+    original_tab = self._browser.tabs[0]
+    self.assertEqual(self._browser.foreground_tab, original_tab)
+    new_tab = self._browser.tabs.New()
     # New tab shouls be foreground tab
-    self.assertEqual(b.foreground_tab, new_tab)
+    self.assertEqual(self._browser.foreground_tab, new_tab)
     # Make sure that activating the background tab makes it the foreground tab
     original_tab.Activate()
-    self.assertEqual(b.foreground_tab, original_tab)
+    self.assertEqual(self._browser.foreground_tab, original_tab)
     # Closing the current foreground tab should switch the foreground tab to the
     # other tab
     original_tab.Close()
-    self.assertEqual(b.foreground_tab, new_tab)
-
-  @benchmark.Disabled('chromeos')  # crbug.com/243912
-  def testDirtyProfileCreation(self):
-    b = self.CreateBrowser(profile_type='small_profile')
-    self.assertEquals(1, len(b.tabs))
+    self.assertEqual(self._browser.foreground_tab, new_tab)
 
   def testGetSystemInfo(self):
-    b = self.CreateBrowser()
-    if not b.supports_system_info:
+    if not self._browser.supports_system_info:
       logging.warning(
           'Browser does not support getting system info, skipping test.')
       return
 
-    info = b.GetSystemInfo()
+    info = self._browser.GetSystemInfo()
 
     self.assertTrue(isinstance(info, system_info.SystemInfo))
     self.assertTrue(hasattr(info, 'model_name'))
@@ -146,26 +90,47 @@ class BrowserTest(unittest.TestCase):
       self.assertTrue(isinstance(g, gpu_device.GPUDevice))
 
   def testGetSystemInfoNotCachedObject(self):
-    b = self.CreateBrowser()
-    if not b.supports_system_info:
+    if not self._browser.supports_system_info:
       logging.warning(
           'Browser does not support getting system info, skipping test.')
       return
 
-    info_a = b.GetSystemInfo()
-    info_b = b.GetSystemInfo()
+    info_a = self._browser.GetSystemInfo()
+    info_b = self._browser.GetSystemInfo()
     self.assertFalse(info_a is info_b)
 
   def testGetSystemTotalMemory(self):
-    b = self.CreateBrowser()
-    self.assertTrue(b.memory_stats['SystemTotalPhysicalMemory'] > 0)
+    self.assertTrue(self._browser.memory_stats['SystemTotalPhysicalMemory'] > 0)
 
   def testIsTracingRunning(self):
-    b = self.CreateBrowser()
-    if not b.supports_tracing:
+    if not self._browser.supports_tracing:
       return
-    self.assertFalse(b.is_tracing_running)
-    b.StartTracing()
-    self.assertTrue(b.is_tracing_running)
-    b.StopTracing()
-    self.assertFalse(b.is_tracing_running)
+    self.assertFalse(self._browser.is_tracing_running)
+    self._browser.StartTracing()
+    self.assertTrue(self._browser.is_tracing_running)
+    self._browser.StopTracing()
+    self.assertFalse(self._browser.is_tracing_running)
+
+
+class CommandLineBrowserTest(browser_test_case.BrowserTestCase):
+  @classmethod
+  def CustomizeBrowserOptions(cls, options):
+    options.AppendExtraBrowserArgs('--user-agent=telemetry')
+
+  def testCommandLineOverriding(self):
+    # This test starts the browser with --user-agent=telemetry. This tests
+    # whether the user agent is then set.
+    t = self._browser.tabs[0]
+    t.Navigate(self.UrlOfUnittestFile('blank.html'))
+    t.WaitForDocumentReadyStateToBeInteractiveOrBetter()
+    self.assertEquals(t.EvaluateJavaScript('navigator.userAgent'),
+                      'telemetry')
+
+class DirtyProfileBrowserTest(browser_test_case.BrowserTestCase):
+  @classmethod
+  def CustomizeBrowserOptions(cls, options):
+    options.profile_type = 'small_profile'
+
+  @benchmark.Disabled('chromeos')  # crbug.com/243912
+  def testDirtyProfileCreation(self):
+    self.assertEquals(1, len(self._browser.tabs))

tools/telemetry/telemetry/core/memory_cache_http_server_unittest.py

@@ -11,8 +11,9 @@ from telemetry.unittest import tab_test_case
 class MemoryCacheHTTPServerTest(tab_test_case.TabTestCase):
   def setUp(self):
     super(MemoryCacheHTTPServerTest, self).setUp()
-    self.test_file = os.path.join(util.GetUnittestDataDir(), 'bear.webm')
-    self.test_file_size = os.stat(self.test_file).st_size
+    self._test_filename = 'bear.webm'
+    _test_file = os.path.join(util.GetUnittestDataDir(), 'bear.webm')
+    self._test_file_size = os.stat(_test_file).st_size
 
   def testBasicHostingAndRangeRequests(self):
     self.Navigate('blank.html')
@@ -22,7 +23,7 @@ class MemoryCacheHTTPServerTest(tab_test_case.TabTestCase):
     # Test basic html hosting.
     self.assertEquals(x, 'Hello world')
 
-    file_size = self.test_file_size
+    file_size = self._test_file_size
     last_byte = file_size - 1
     # Test byte range request: no end byte.
     self.CheckContentHeaders('0-', '0-%d' % last_byte, file_size)
@@ -55,13 +56,13 @@ class MemoryCacheHTTPServerTest(tab_test_case.TabTestCase):
         xmlhttp.open('GET', "%s?t=" + Date.now(), true);
         xmlhttp.setRequestHeader('Range', 'bytes=%s');
         xmlhttp.send();
-    """ % (self._browser.http_server.UrlOf(self.test_file),
+    """ % (self.UrlOfUnittestFile(self._test_filename),
            content_range_request))
     self._tab.WaitForJavaScriptExpression('loaded', 5)
     content_range = self._tab.EvaluateJavaScript(
         'xmlhttp.getResponseHeader("Content-Range");')
     content_range_response = 'bytes %s/%d' % (
-        content_range_response, self.test_file_size)
+        content_range_response, self._test_file_size)
     self.assertEquals(content_range, content_range_response)
     content_length = self._tab.EvaluateJavaScript(
         'xmlhttp.getResponseHeader("Content-Length");')

tools/telemetry/telemetry/core/tab_unittest.py

@@ -48,14 +48,12 @@ class FakePlatform(object):
 
 
 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):
@@ -79,8 +77,9 @@ class TabTest(tab_test_case.TabTestCase):
 
   def testTabUrl(self):
     self.assertEquals(self._tab.url, 'about:blank')
-    self.Navigate('blank.html')
-    self.assertEquals(self._tab.url, self.test_url)
+    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)
@@ -164,9 +163,8 @@ class TabTest(tab_test_case.TabTestCase):
 
 class GpuTabTest(tab_test_case.TabTestCase):
   @classmethod
-  def setUpClass(cls):
-    cls._extra_browser_args = ['--enable-gpu-benchmarking']
-    super(GpuTabTest, cls).setUpClass()
+  def CustomizeBrowserOptions(cls, options):
+    options.AppendExtraBrowserArgs('--enable-gpu-benchmarking')
 
   # Test flaky on mac: http://crbug.com/358664
   @benchmark.Disabled('android', 'mac')

tools/telemetry/telemetry/page/actions/navigate_unittest.py

@@ -2,22 +2,13 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-from telemetry.page import page as page_module
 from telemetry.page.actions import navigate
 from telemetry.unittest import tab_test_case
 
 
 class NavigateActionTest(tab_test_case.TabTestCase):
-  def CreatePageFromUnittestDataDir(self, filename):
-    self.Navigate(filename)
-    return page_module.Page(
-        self._browser.http_server.UrlOf(self.test_file_path),
-        None  # In this test, we don't need a page set.
-    )
-
   def testNavigateAction(self):
-    page = self.CreatePageFromUnittestDataDir('blank.html')
-    i = navigate.NavigateAction(url=page.url)
+    i = navigate.NavigateAction(url=self.UrlOfUnittestFile('blank.html'))
     i.RunAction(self._tab)
     self.assertEquals(
         self._tab.EvaluateJavaScript('document.location.pathname;'),

tools/telemetry/telemetry/page/actions/scroll_unittest.py

@@ -4,30 +4,16 @@
 
 import os
 
-from telemetry.core import util
-from telemetry.page import page as page_module
 from telemetry.page.actions import scroll
 from telemetry.unittest import tab_test_case
 from telemetry.unittest import test
 
 
 class ScrollActionTest(tab_test_case.TabTestCase):
-  def CreateAndNavigateToPageFromUnittestDataDir(
-    self, filename):
-    self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
-    page = page_module.Page(
-      self._browser.http_server.UrlOf(filename),
-      None) # In this test, we don't need a page set.
-
-    self._tab.Navigate(page.url)
-    self._tab.WaitForDocumentReadyStateToBeComplete()
-
-    return page
-
   @test.Disabled  # Disabled due to flakiness: crbug.com/330544
   def testScrollAction(self):
-    page = self.CreateAndNavigateToPageFromUnittestDataDir("blank.html")
-    setattr(page, 'smoothness', {"action": "scroll"})
+    self.Navigate('blank.html')
+
     # Make page bigger than window so it's scrollable.
     self._tab.ExecuteJavaScript("""document.body.style.height =
                               (2 * window.innerHeight + 1) + 'px';""")
@@ -62,7 +48,8 @@ class ScrollActionTest(tab_test_case.TabTestCase):
                             (scroll_position, scroll_height))
 
   def testBoundingClientRect(self):
-    self.CreateAndNavigateToPageFromUnittestDataDir('blank.html')
+    self.Navigate('blank.html')
+
     with open(os.path.join(os.path.dirname(__file__),
                            'gesture_common.js')) as f:
       js = f.read()

tools/telemetry/telemetry/page/page_test_unittest.py

@@ -12,8 +12,8 @@ from telemetry.page import page as page_module
 from telemetry.page import page_set
 from telemetry.page import page_set_archive_info
 from telemetry.page import page_test
-from telemetry.testing import page_test_test_case
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 from telemetry.value import scalar
 
 

tools/telemetry/telemetry/page/record_wpr_unittest.py

@@ -93,9 +93,7 @@ class RecordWprUnitTests(tab_test_case.TabTestCase):
   def setUpClass(cls):
     sys.path.extend([cls._base_dir, cls._test_data_dir])
     super(RecordWprUnitTests, cls).setUpClass()
-    cls._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
-    blank_html_path = os.path.join(util.GetUnittestDataDir(), 'blank.html')
-    cls._url = cls._browser.http_server.UrlOf(blank_html_path)
+    cls._url = cls.UrlOfUnittestFile('blank.html')
 
   # When the RecorderPageTest is created from a PageSet, we do not have a
   # PageTest to use. In this case, we will record every available action.

tools/telemetry/telemetry/testing/__init__.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.

tools/telemetry/telemetry/unittest/browser_test_case.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 os
+import unittest
+
+from telemetry.core import browser_finder
+from telemetry.unittest import options_for_unittests
+from telemetry.util import path
+
+
+class BrowserTestCase(unittest.TestCase):
+  @classmethod
+  def setUpClass(cls):
+    options = options_for_unittests.GetCopy()
+    cls.CustomizeBrowserOptions(options.browser_options)
+    browser_to_create = browser_finder.FindBrowser(options)
+    if not browser_to_create:
+      raise Exception('No browser found, cannot continue test.')
+
+    cls._browser = None
+    try:
+      cls._browser = browser_to_create.Create()
+      cls._browser.Start()
+    except:
+      cls.tearDownClass()
+      raise
+
+  @classmethod
+  def tearDownClass(cls):
+    if cls._browser:
+      cls._browser.Close()
+      cls._browser = None
+
+  @classmethod
+  def CustomizeBrowserOptions(cls, options):
+    """Override to add test-specific options to the BrowserOptions object"""
+    pass
+
+  @classmethod
+  def UrlOfUnittestFile(cls, filename):
+    cls._browser.SetHTTPServerDirectories(path.GetUnittestDataDir())
+    file_path = os.path.join(path.GetUnittestDataDir(), filename)
+    return cls._browser.http_server.UrlOf(file_path)

tools/telemetry/telemetry/unittest/tab_test_case.py

@@ -2,44 +2,17 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import os
-import unittest
+from telemetry.unittest import browser_test_case
 
-from telemetry.core import browser_finder
-from telemetry.core import util
-from telemetry.unittest import options_for_unittests
-
-
-class TabTestCase(unittest.TestCase):
-  _extra_browser_args = []
 
+class TabTestCase(browser_test_case.BrowserTestCase):
   def __init__(self, *args):
     super(TabTestCase, self).__init__(*args)
-
     self._tab = None
-    self.test_file_path = None
-    self.test_url = None
-
-  @classmethod
-  def setUpClass(cls):
-    options = options_for_unittests.GetCopy()
-    cls.CustomizeBrowserOptions(options.browser_options)
-    if cls._extra_browser_args:
-      options.AppendExtraBrowserArgs(cls._extra_browser_args)
-
-    browser_to_create = browser_finder.FindBrowser(options)
-    if not browser_to_create:
-      raise Exception('No browser found, cannot continue test.')
-
-    cls._browser = None
-    try:
-      cls._browser = browser_to_create.Create()
-      cls._browser.Start()
-    except:
-      cls.tearDownClass()
-      raise
 
   def setUp(self):
+    super(TabTestCase, self).setUp()
+
     if self._browser.supports_tab_control:
       self._tab = self._browser.tabs.New()
       while len(self._browser.tabs) > 1:
@@ -52,23 +25,11 @@ class TabTestCase(unittest.TestCase):
     self._tab.Navigate('about:blank')
     self._tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
 
-  @classmethod
-  def tearDownClass(cls):
-    if cls._browser:
-      cls._browser.Close()
-
-  @classmethod
-  def CustomizeBrowserOptions(cls, options):
-    """Override to add test-specific options to the BrowserOptions object"""
-    pass
-
   def Navigate(self, filename, script_to_evaluate_on_commit=None):
     """Navigates |tab| to |filename| in the unittest data directory.
 
     Also sets up http server to point to the unittest data directory.
     """
-    self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
-    self.test_file_path = os.path.join(util.GetUnittestDataDir(), filename)
-    self.test_url = self._browser.http_server.UrlOf(self.test_file_path)
-    self._tab.Navigate(self.test_url, script_to_evaluate_on_commit)
+    url = self.UrlOfUnittestFile(filename)
+    self._tab.Navigate(url, script_to_evaluate_on_commit)
     self._tab.WaitForDocumentReadyStateToBeComplete()

tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py

@@ -10,10 +10,10 @@ from telemetry.core import wpr_modes
 from telemetry.page import page as page_module
 from telemetry.page import page_set
 from telemetry.results import page_test_results
-from telemetry.testing import page_test_test_case
 from telemetry.timeline import model as model_module
 from telemetry.timeline import async_slice
 from telemetry.unittest import options_for_unittests
+from telemetry.unittest import page_test_test_case
 from telemetry.value import scalar
 from telemetry.web_perf import timeline_based_measurement as tbm_module
 from telemetry.web_perf import timeline_interaction_record as tir_module