[Telemetry] Migrate bitmap.py from bitmaptools.cc to numpy

tools/perf/metrics/speedindex.py

 # Copyright 2013 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 collections
 
 from metrics import Metric
-from telemetry.core import bitmap
+from telemetry.image_processing import image_util
+from telemetry.image_processing import rgba_color
 from telemetry.value import scalar
 
 
 class SpeedIndexMetric(Metric):
   """The speed index metric is one way of measuring page load speed.
 
   It is meant to approximate user perception of page load speed, and it
   is based on the amount of time that it takes to paint to the visual
   portion of the screen. It includes paint events that occur after the
   onload event, and it doesn't include time loading things off-screen.
@@ skipping 111 matching lines @@
       speed_index += elapsed_time * incompleteness
 
       # Update variables for next iteration.
       prev_completeness = completeness
       prev_time = time
     return int(speed_index)
 
 
 class VideoSpeedIndexImpl(SpeedIndexImpl):
 
-  def __init__(self):
+  def __init__(self, image_util_module=image_util):
+    # Allow image_util to be passed in so we can fake it out for testing.
     super(VideoSpeedIndexImpl, self).__init__()
     self._time_completeness_list = None
+    self._image_util_module = image_util_module
 
   def Start(self, tab):
     assert tab.video_capture_supported
     # Blank out the current page so it doesn't count towards the new page's
     # completeness.
-    tab.Highlight(bitmap.WHITE)
+    tab.Highlight(rgba_color.WHITE)
     # TODO(tonyg): Bitrate is arbitrary here. Experiment with screen capture
     # overhead vs. speed index accuracy and set the bitrate appropriately.
     tab.StartVideoCapture(min_bitrate_mbps=4)
 
   def Stop(self, tab):
     # Ignore white because Chrome may blank out the page during load and we want
     # that to count as 0% complete. Relying on this fact, we also blank out the
     # previous page to white. The tolerance of 8 experimentally does well with
     # video capture at 4mbps. We should keep this as low as possible with
     # supported video compression settings.
     video_capture = tab.StopVideoCapture()
-    histograms = [(time, bmp.ColorHistogram(ignore_color=bitmap.WHITE,
-                                            tolerance=8))
-                  for time, bmp in video_capture.GetVideoFrameIter()]
+    histograms = [(time, self._image_util_module.GetColorHistogram(
+                       image, ignore_color=rgba_color.WHITE, tolerance=8))
+                  for time, image in video_capture.GetVideoFrameIter()]
 
     start_histogram = histograms[0][1]
     final_histogram = histograms[-1][1]
     total_distance = start_histogram.Distance(final_histogram)
 
     def FrameProgress(histogram):
       if total_distance == 0:
         if histogram.Distance(final_histogram) == 0:
           return 1.0
         else:
@@ skipping 141 matching lines @@
     frame = paint_event.args['frameId']
     return (frame,) + GetBox(paint_event.args['data']['clip'])
 
   def _GroupEventByRectangle(self, paint_events):
     """Group all paint events according to the rectangle that they update."""
     result = collections.defaultdict(list)
     for event in paint_events:
       assert event.name == 'Paint'
       result[self._GetRectangle(event)].append(event)
     return result