arc: Support non-standard display scale factors.

ui/gfx/image/image_skia.cc

 // 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.
 
 #include "ui/gfx/image/image_skia.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 23 matching lines @@
 }
 
 std::vector<float>* g_supported_scales = NULL;
 
 // The difference to fall back to the smaller scale factor rather than the
 // larger one. For example, assume 1.20 is requested but only 1.0 and 2.0 are
 // supported. In that case, not fall back to 2.0 but 1.0, and then expand
 // the image to 1.25.
 const float kFallbackToSmallerScaleDiff = 0.20f;
 
+// Maps to the closest supported scale. Returns an exact match, a smaller
+// scale within 0.2 units, the nearest larger scale, or the min/max
+// supported scale.
+float MapToSupportedScale(float scale) {
+  for (float supported_scale : *g_supported_scales) {
+    if (supported_scale + kFallbackToSmallerScaleDiff >= scale)
+      return supported_scale;
+  }
+  return g_supported_scales->back();
+}
+
 }  // namespace
 
 namespace internal {
 namespace {
 
 ImageSkiaRep ScaleImageSkiaRep(const ImageSkiaRep& rep, float target_scale) {
   if (rep.is_null() || rep.scale() == target_scale)
     return rep;
 
   gfx::Size scaled_size =
@@ skipping 158 matching lines @@
       smallest_diff = diff;
     }
   }
 
   if (fetch_new_image && source_.get()) {
     DCHECK(CalledOnValidThread())
         << "An ImageSkia with the source must be accessed by the same thread.";
 
     ImageSkiaRep image;
     float resource_scale = scale;
-    if (!HasRepresentationAtAllScales() && g_supported_scales) {
-      if (g_supported_scales->back() <= scale) {
-        resource_scale = g_supported_scales->back();
-      } else {
-        for (size_t i = 0; i < g_supported_scales->size(); ++i) {
-          if ((*g_supported_scales)[i] + kFallbackToSmallerScaleDiff >= scale) {
-            resource_scale = (*g_supported_scales)[i];
-            break;
-          }
-        }
-      }
-    }
+    if (!HasRepresentationAtAllScales() && g_supported_scales)
+      resource_scale = MapToSupportedScale(scale);
     if (scale != resource_scale) {
       std::vector<ImageSkiaRep>::iterator iter =
           FindRepresentation(resource_scale, fetch_new_image);
       CHECK(iter != image_reps_.end());
       image = iter->unscaled() ? (*iter) : ScaleImageSkiaRep(*iter, scale);
     } else {
       image = source_->GetImageForScale(scale);
       // Image may be missing for the specified scale in some cases, such like
       // looking up 2x resources but the 2x resource pack is missing. Fall back
       // to 1x and re-scale it.
@@ skipping 230 matching lines @@
   // Don't check ReadOnly because the source may generate images
   // even for read only ImageSkia. Concurrent access will be protected
   // by |DCHECK(CalledOnValidThread())| in FindRepresentation.
   if (storage_.get() && storage_->has_source()) {
     for (std::vector<float>::const_iterator it = g_supported_scales->begin();
          it != g_supported_scales->end(); ++it)
       storage_->FindRepresentation(*it, true);
   }
 }
 
+void ImageSkia::RemoveUnsupportedRepresentationsForScale(float scale) {
+  for (const ImageSkiaRep& image_rep_to_test : image_reps()) {
+    const float test_scale = image_rep_to_test.scale();
+    if (test_scale != scale && MapToSupportedScale(test_scale) == scale)
+      RemoveRepresentation(test_scale);
+  }
+}
+
 void ImageSkia::Init(const ImageSkiaRep& image_rep) {
   // TODO(pkotwicz): The image should be null whenever image rep is null.
   if (image_rep.sk_bitmap().empty()) {
     storage_ = NULL;
     return;
   }
   storage_ = new internal::ImageSkiaStorage(
       NULL, gfx::Size(image_rep.GetWidth(), image_rep.GetHeight()));
   storage_->image_reps().push_back(image_rep);
 }
@@ skipping 24 matching lines @@
 bool ImageSkia::CanModify() const {
   return !storage_.get() || storage_->CanModify();
 }
 
 void ImageSkia::DetachStorageFromThread() {
   if (storage_.get())
     storage_->DetachFromThread();
 }
 
 }  // namespace gfx