More polish in prep for CrOS support

tools/gpu/gpu_tools/multi_page_benchmark.py

 # Copyright (c) 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 csv
 import logging
 import os
 import sys
 import time
 import unittest
 
 import chrome_remote_control
 import chrome_remote_control.browser_options
-import file_server
 import page_set
 
 class MeasurementFailure(Exception):
   """Exception that can be thrown from MeasurePage to indicate an undisired but
   designed-for problem."""
   pass
 
 class MultiPageBenchmark(object):
   """Glue code for running a benchmark across a set of pages.
 
@@ skipping 57 matching lines @@
     Put together:
 
        def MeasurePage(self, page, tab):
          res = tab.runtime.Evaluate("2+2");
          if res != 4:
             raise Exception("Oh, wow.")
          return {"two_plus_two": res}
     """
     raise Exception('Should never be called')
 
-  def Run(self, results_writer, possible_browser, options, ps):
+  def Run(self, results_writer, browser, options, ps):
     """Runs the actual benchmark, starting the browser using outputting results
     to results_writer.
 
     If args is not specified, sys.argv[1:] is used.
     """
     self.options = options
     self.field_names = None
 
-    with possible_browser.Create() as b:
-      with b.ConnectToNthTab(0) as tab:
-        for page in ps.pages:
-          self._RunPage(results_writer, page, tab)
+    with browser.ConnectToNthTab(0) as tab:
+      for page in ps.pages:
+        self._RunPage(results_writer, page, tab)
     self.options = None
     self.field_names = None
 
   def _RunPage(self, results_writer, page, tab):
     # Load the page.
     try:
       logging.debug('Loading %s...', page.url)
       tab.page.Navigate(page.url)
 
       # TODO(dtu): Detect HTTP redirects.
       time.sleep(2)  # Wait for unpredictable redirects.
       tab.WaitForDocumentReadyStateToBeInteractiveOrBetter()
     except chrome_remote_control.TimeoutException, ex:
       logging.warning('Timed out while loading: %s', page.url)
       self.page_failures.append({"page": page,
                                  "exception": ex})
       return
 
     # Measure the page.
     try:
       results = self.MeasurePage(page, tab)
-    except MeasurementFailure, ex:
-      logging.warning("%s failed: %s:", page.url, str(ex))
+    except Exception, ex:
+      if isinstance(ex, MeasurementFailure):
+        logging.info("%s failed: %s:", page.url, str(ex))
+      else:
+        import traceback; traceback.print_exc()
+        logging.warning("%s had unexpected failure: %s:", page.url, str(ex))
+
       self.page_failures.append({"page": page,
                                  "exception": ex})
       return
-    except Exception, ex:
-      import traceback; traceback.print_exc()
-      logging.warning("%s had unexpected failure: %s:", page.url, str(ex))
-      self.page_failures.append({"page": page,
-                                 "exception": ex})
-      return
 
     # Output.
     assert 'url' not in results
 
     if not self.field_names:
       self.field_names = list(results.keys())
       self.field_names.sort()
       self.field_names.insert(0, 'url')
       results_writer.writerow(self.field_names)
 
@@ skipping 34 matching lines @@
     ps.LoadFromFile(args[0])
 
     benchmark.CustomizeBrowserOptions(options)
     possible_browser = chrome_remote_control.FindBrowser(options)
     if possible_browser == None:
       sys.stderr.write(
         "No browser found.\n" +
         "Use --browser=list to figure out which are available.\n")
       sys.exit(1)
 
-    res = benchmark.Run(csv.writer(sys.stdout),
-                        possible_browser,
-                        options,
-                        ps)
+    with possible_browser.Create() as browser:
+      res = benchmark.Run(csv.writer(sys.stdout),
+                          browser,
+                          options,
+                          ps)
 
     if len(benchmark.page_failures):
       logging.warning("Failed pages: %s", '\n'.join(
           [failure["page"].url for failure in benchmark.page_failures]))
     return len(benchmark.page_failures)
 
 
 class MultiPageBenchmarkUnitTest(unittest.TestCase):
   """unittest.TestCase-derived class to help in the construction of unit tests
   for a benchmark."""
@@ skipping 14 matching lines @@
 
   def RunBenchmark(self, benchmark, ps):
     """Runs a benchmark against a pageset, returning the rows its outputs."""
     rows = []
     class LocalWriter(object):
       def writerow(self, row):
         rows.append(row)
 
     assert chrome_remote_control.browser_options.options_for_unittests
 
-    with file_server.FileServer(self.unittest_data_dir) as server:
-      for page in ps.pages:
-        page.url = '%s/%s' % (server.url, page.url)
-      options = (
-        chrome_remote_control.browser_options.options_for_unittests.Copy())
-      benchmark.CustomizeBrowserOptions(options)
-      possible_browser = chrome_remote_control.FindBrowser(options)
-      benchmark.Run(LocalWriter(), possible_browser, options, ps)
-
+    options = (
+      chrome_remote_control.browser_options.options_for_unittests.Copy())
+    benchmark.CustomizeBrowserOptions(options)
+    possible_browser = chrome_remote_control.FindBrowser(options)
+    with possible_browser.Create() as browser:
+      with browser.CreateTemporaryHTTPServer(self.unittest_data_dir) as server:
+        for page in ps.pages:
+          page.url = '%s/%s' % (server.url, page.url)
+        benchmark.Run(LocalWriter(), browser, options, ps)
     return rows