Allow a bit of wiggle room in highlight's bounding box

tools/telemetry/telemetry/core/tab.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.
 
 from telemetry.core import bitmap
 from telemetry.core import web_contents
 
 DEFAULT_TAB_TIMEOUT = 60
 
 
@@ skipping 124 matching lines @@
 
     Args:
       min_bitrate_mbps: The minimum caputre bitrate in MegaBits Per Second.
           The platform is free to deliver a higher bitrate if it can do so
           without increasing overhead.
     """
     self.Highlight(bitmap.WEB_PAGE_TEST_ORANGE)
     self.browser.platform.StartVideoCapture(min_bitrate_mbps)
     self.ClearHighlight(bitmap.WEB_PAGE_TEST_ORANGE)
 
-  def _FindHighlightBoundingBox(self, bmp, color):
+  def _FindHighlightBoundingBox(self, bmp, color, bounds_tolerance=4,
+      color_tolerance=8):
     """Returns the bounding box of the content highlight of the given color.
 
     Raises:
       BoundingBoxNotFoundException if the hightlight could not be found.
     """
-    content_box, pixel_count = bmp.GetBoundingBox(color, tolerance=8)
+    content_box, pixel_count = bmp.GetBoundingBox(color,
+        tolerance=color_tolerance)
 
     if not content_box:
-      raise BoundingBoxNotFoundException('Failed to find tab contents.')
+      return None
 
     # We assume arbitrarily that tabs are all larger than 200x200. If this
     # fails it either means that assumption has changed or something is
     # awry with our bounding box calculation.
     if content_box[2] < 200 or content_box[3] < 200:
       raise BoundingBoxNotFoundException('Unexpectedly small tab contents.')
 
     # TODO(tonyg): Can this threshold be increased?
     if pixel_count < 0.9 * content_box[2] * content_box[3]:
       raise BoundingBoxNotFoundException(
           'Low count of pixels in tab contents matching expected color.')
 
     # Since Telemetry doesn't know how to resize the window, we assume
     # that we should always get the same content box for a tab. If this
     # fails, it means either that assumption has changed or something is
     # awry with our bounding box calculation. If this assumption changes,
     # this can be removed.
     #
     # TODO(tonyg): This assert doesn't seem to work.
     if (self._previous_tab_contents_bounding_box and
         self._previous_tab_contents_bounding_box != content_box):
-      raise BoundingBoxNotFoundException(
-          'Unexpected change in tab contents box.')
+      # Check if there's just a minor variation on the bounding box. If it's
+      # just a few pixels, we can assume it's probably due to
+      # compression artifacts.
+      for i in xrange(len(content_box)):
+        bounds_difference = abs(content_box[i] -
+            self._previous_tab_contents_bounding_box[i])
+        if bounds_difference > bounds_tolerance:
+          raise BoundingBoxNotFoundException(
+              'Unexpected change in tab contents box.')
     self._previous_tab_contents_bounding_box = content_box
 
     return content_box
 
   def StopVideoCapture(self):
     """Stops recording video of the tab's contents.
 
     This looks for the initial color flash in the first frame to establish the
     tab content boundaries and then omits all frames displaying the flash.
 
     Yields:
       (time_ms, bitmap) tuples representing each video keyframe. Only the first
       frame in a run of sequential duplicate bitmaps is typically included.
         time_ms is milliseconds since navigationStart.
         bitmap is a telemetry.core.Bitmap.
     """
     frame_generator = self.browser.platform.StopVideoCapture()
 
     # Flip through frames until we find the initial tab contents flash.
     content_box = None
     for _, bmp in frame_generator:
-      try:
-        content_box = self._FindHighlightBoundingBox(
-            bmp, bitmap.WEB_PAGE_TEST_ORANGE)
+      content_box = self._FindHighlightBoundingBox(
+          bmp, bitmap.WEB_PAGE_TEST_ORANGE)
+      if content_box:
         break
-      except BoundingBoxNotFoundException:
-        pass
 
     if not content_box:
       raise BoundingBoxNotFoundException(
           'Failed to identify tab contents in video capture.')
 
     # Flip through frames until the flash goes away and emit that as frame 0.
     timestamp = 0
     for timestamp, bmp in frame_generator:
-      try:
-        self._FindHighlightBoundingBox(bmp, bitmap.WEB_PAGE_TEST_ORANGE)
-      except BoundingBoxNotFoundException:
+      if not self._FindHighlightBoundingBox(bmp, bitmap.WEB_PAGE_TEST_ORANGE):
         yield 0, bmp.Crop(*content_box)
         break
 
     start_time = timestamp
     for timestamp, bmp in frame_generator:
       yield timestamp - start_time, bmp.Crop(*content_box)
 
   def PerformActionAndWaitForNavigate(
       self, action_function, timeout=DEFAULT_TAB_TIMEOUT):
     """Executes action_function, and waits for the navigation to complete.
@@ skipping 18 matching lines @@
   def GetCookieByName(self, name, timeout=DEFAULT_TAB_TIMEOUT):
     """Returns the value of the cookie by the given |name|."""
     return self._inspector_backend.GetCookieByName(name, timeout)
 
   def CollectGarbage(self):
     self._inspector_backend.CollectGarbage()
 
   def ClearCache(self):
     """Clears the browser's HTTP disk cache and the tab's HTTP memory cache."""
     self._inspector_backend.ClearCache()