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

tools/telemetry/telemetry/core/browser_unittest.py

Index: tools/telemetry/telemetry/core/browser_unittest.py
diff --git a/tools/telemetry/telemetry/core/browser_unittest.py b/tools/telemetry/telemetry/core/browser_unittest.py
index e0e70cea669baf649ba228b05b654e03caf170ca..a75372d0af53040ea27cf0c1b38e650940aa36ba 100644
--- a/tools/telemetry/telemetry/core/browser_unittest.py
+++ b/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))