Allows arbitrary scale factor in ImageSkia.

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 <algorithm>
 #include <cmath>
 #include <limits>
 
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
+#include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/skia_util.h"
+#include "ui/gfx/switches.h"
 
 namespace gfx {
 namespace {
 
 // static
 gfx::ImageSkiaRep& NullImageRep() {
   CR_DEFINE_STATIC_LOCAL(ImageSkiaRep, null_image_rep, ());
   return null_image_rep;
 }
 
 std::vector<float>* g_supported_scales = NULL;
+
+bool IsImageSkiaScaling() {

[oshima, 2014/05/06 18:52:27]

how about IsDSFScalingInImageSkiaEnabled ?

[Jun Mukai, 2014/05/06 19:56:49]

Done.

+#if defined(OS_WIN)
+  return true;
+#else
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kAllowArbitraryScaleFactorInImageSkia);
+#endif
+}
+
 }  // namespace
 
 namespace internal {
 namespace {
 
 class Matcher {
  public:
   explicit Matcher(float scale) : scale_(scale) {
   }
 
@@ skipping 92 matching lines @@
       if (diff < smallest_diff && !it->is_null()) {
         closest_iter = it;
         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 = source_->GetImageForScale(scale);
+      ImageSkiaRep image;
+      if (IsImageSkiaScaling() && scale != 1.0f && scale != 2.0f) {

[oshima, 2014/05/06 18:52:27]

can you use g_supported_scales?

[Jun Mukai, 2014/05/06 19:56:49]

Well, that's still unclear to me. What is g_supported_scales?  Isn't it the DSFs
supported by ImageSkia?  Then, it sounds like it should contain 1.25 or
something.

Here means the scale factor supported by the resource bundle (more strictly
ImageSkiaSource but that doesn't matter right now), right? How does it come?

[Jun Mukai, 2014/05/06 20:42:42]

Chatted offline and I was wrong. g_supported_scales is the scale factors of
resources.  Changed the code to look up g_supported_scales.
Also revised the test.

+        std::vector<ImageSkiaRep>::iterator iter =
+            non_const->FindRepresentation(
+                (scale < 1.0f) ? 1.0f : 2.0f, fetch_new_image);
+
+        DCHECK(iter != non_const->image_reps().end());
+        SkBitmap scaled_image;
+        gfx::Size unscaled_size(iter->pixel_width(), iter->pixel_height());
+        gfx::Size scaled_size = ToCeiledSize(
+            gfx::ScaleSize(unscaled_size, scale / iter->scale()));
+
+        image = ImageSkiaRep(skia::ImageOperations::Resize(
+            iter->sk_bitmap(),
+            skia::ImageOperations::RESIZE_LANCZOS3,
+            scaled_size.width(),
+            scaled_size.height()), scale);
+        DCHECK_EQ(image.pixel_width(), scaled_size.width());
+        DCHECK_EQ(image.pixel_height(), scaled_size.height());
+      } else {
+        image = source_->GetImageForScale(scale);
+      }
 
       // If the source returned the new image, store it.
       if (!image.is_null() &&
           std::find_if(image_reps_.begin(), image_reps_.end(),
                        Matcher(image.scale())) == image_reps_.end()) {
         non_const->image_reps().push_back(image);
       }
 
       // If the result image's scale isn't same as the expected scale, create
       // null ImageSkiaRep with the |scale| so that the next lookup will
@@ skipping 263 matching lines @@
 bool ImageSkia::CanModify() const {
   return !storage_.get() || storage_->CanModify();
 }
 
 void ImageSkia::DetachStorageFromThread() {
   if (storage_.get())
     storage_->DetachFromThread();
 }
 
 }  // namespace gfx