Update Maps pixel test.

content/test/gpu/gpu_tests/cloud_storage_test_base.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.
 
 """Base classes for a test and validator which upload results
 (reference images, error images) to cloud storage."""
 
+import logging
 import os
 import re
 import tempfile
 
 from catapult_base import cloud_storage
 from telemetry.page import page_test
 from telemetry.util import image_util
 from telemetry.util import rgba_color
 
 from gpu_tests import gpu_test_base
 
 test_data_dir = os.path.abspath(os.path.join(
     os.path.dirname(__file__), '..', '..', 'data', 'gpu'))
 
 default_generated_data_dir = os.path.join(test_data_dir, 'generated')
 
 error_image_cloud_storage_bucket = 'chromium-browser-gpu-tests'
 
-def _CompareScreenshotSamples(screenshot, expectations, device_pixel_ratio):
+def _CompareScreenshotSamples(screenshot, expectations, device_pixel_ratio,
+                              test_machine_name):
+  # First scan through the expectations and see if there are any scale
+  # factor overrides that would preempt the device pixel ratio. This
+  # is mainly a workaround for complex tests like the Maps test.
+  if test_machine_name:
+    for expectation in expectations:
+      if "scale_factor_overrides" in expectation:
+        for override in expectation["scale_factor_overrides"]:
+          if override["machine_name"] in test_machine_name:
+            logging.warning('Overriding device_pixel_ratio ' +
+                            str(device_pixel_ratio) + ' with scale factor ' +
+                            str(override["scale_factor"]))
+            device_pixel_ratio = override["scale_factor"]
+            break
+        break
   for expectation in expectations:
+    if "scale_factor_overrides" in expectation:
+      continue
     location = expectation["location"]
     size = expectation["size"]
     x0 = int(location[0] * device_pixel_ratio)
     x1 = int((location[0] + size[0]) * device_pixel_ratio)
     y0 = int(location[1] * device_pixel_ratio)
     y1 = int((location[1] + size[1]) * device_pixel_ratio)
     for x in range(x0, x1):
       for y in range(y0, y1):
         if (x < 0 or y < 0 or x >= image_util.Width(screenshot) or
             y >= image_util.Height(screenshot)):
           raise page_test.Failure(
               ('Expected pixel location [%d, %d] is out of range on ' +
                '[%d, %d] image') %
               (x, y, image_util.Width(screenshot),
                image_util.Height(screenshot)))
 
         actual_color = image_util.GetPixelColor(screenshot, x, y)
         expected_color = rgba_color.RgbaColor(
             expectation["color"][0],
             expectation["color"][1],
             expectation["color"][2])
         if not actual_color.IsEqual(expected_color, expectation["tolerance"]):
           raise page_test.Failure('Expected pixel at ' + str(location) +
+              ' (actual pixel (' + str(x) + ', ' + str(y) + ')) ' +
               ' to be ' +
               str(expectation["color"]) + " but got [" +
               str(actual_color.r) + ", " +
               str(actual_color.g) + ", " +
               str(actual_color.b) + "]")
 
 class ValidatorBase(gpu_test_base.ValidatorBase):
   def __init__(self):
     super(ValidatorBase, self).__init__()
     # Parameters for cloud storage reference images.
@@ skipping 151 matching lines @@
       error_image_cloud_storage_bucket, upload_dir)
 
   def _ValidateScreenshotSamples(self, url,
                                  screenshot, expectations, device_pixel_ratio):
     """Samples the given screenshot and verifies pixel color values.
        The sample locations and expected color values are given in expectations.
        In case any of the samples do not match the expected color, it raises
        a Failure and dumps the screenshot locally or cloud storage depending on
        what machine the test is being run."""
     try:
-      _CompareScreenshotSamples(screenshot, expectations, device_pixel_ratio)
+      _CompareScreenshotSamples(screenshot, expectations, device_pixel_ratio,
+                                self.options.test_machine_name)
     except page_test.Failure:
       image_name = self._UrlToImageName(url)
       if self.options.test_machine_name:
         self._UploadErrorImagesToCloudStorage(image_name, screenshot, None)
       else:
         self._WriteErrorImages(self.options.generated_dir, image_name,
                                screenshot, None)
       raise
 
 
@@ skipping 25 matching lines @@
         default='')
     group.add_option('--test-machine-name',
         help='Name of the test machine. Specifying this argument causes this '
         'script to upload failure images and diffs to cloud storage directly, '
         'instead of relying on the archive_gpu_pixel_test_results.py script.',
         default='')
     group.add_option('--generated-dir',
         help='Overrides the default on-disk location for generated test images '
         '(only used for local testing without a cloud storage account)',
         default=default_generated_data_dir)