Fixes use-of-uninitialized-value MSan error in image_skia_unittest

ui/gfx/image/image_skia_unittest.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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/image/image_skia_source.h"
-#include "ui/gfx/size.h"
 #include "ui/gfx/switches.h"
 
 // Duplicated from base/threading/non_thread_safe.h so that we can be
 // good citizens there and undef the macro.
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
 #define ENABLE_NON_THREAD_SAFE 1
 #else
 #define ENABLE_NON_THREAD_SAFE 0
 #endif
 
@@ skipping 22 matching lines @@
  public:
   DynamicSource(const gfx::Size& size)
       : size_(size),
         last_requested_scale_(0.0f) {}
 
   virtual ~DynamicSource() {
   }
 
   virtual ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
     last_requested_scale_ = scale;
-    return gfx::ImageSkiaRep(size_, scale);

[oshima, 2014/05/15 16:14:13]

this constructor is used in other tests (and only in tests) and they expects the
content is valid (because ImageSkiaRep::bitmap() is const), so probably better
to fix it in the constructor.

You can just call

bitmap_.eraseColor(<color>);

there

[Jun Mukai, 2014/05/16 01:57:33]

Done.

+    // The returned image can be resized in ImageSkiaStorage, so
+    // empty ImageSkiaRep could cause use-of-uninitialized-value.
+    gfx::Canvas canvas(size_, scale, true);
+    canvas.FillRect(Rect(size_), SK_ColorRED);
+    return canvas.ExtractImageRep();
   }
 
   float GetLastRequestedScaleAndReset() {
     float result = last_requested_scale_;
     last_requested_scale_ = 0.0f;
     return result;
   }
 
  private:
   gfx::Size size_;
@@ skipping 429 matching lines @@
 }
 
 TEST_F(ImageSkiaTest, ArbitraryScaleFactorWithMissingResource) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kAllowArbitraryScaleFactorInImageSkia);
 
   // Do not test if the ImageSkia doesn't support arbitrary scale factors.
   if (!ImageSkia::IsDSFScalingInImageSkiaEnabled())
     return;
 
-  ImageSkia image(new FixedSource(
-      ImageSkiaRep(Size(100, 200), 1.0f)), Size(100, 200));
+  Canvas canvas(Size(100, 200), 1.0f, false);
+  canvas.FillRect(Rect(0, 0, 100, 200), SK_ColorRED);
+  ImageSkia image(new FixedSource(canvas.ExtractImageRep()), Size(100, 200));
 
   // Requesting 1.5f -- falls back to 2.0f, but couldn't find. It should
   // look up 1.0f and then rescale it.
   const ImageSkiaRep& rep = image.GetRepresentation(1.5f);
   EXPECT_EQ(1.5f, rep.scale());
   EXPECT_EQ(2U, image.image_reps().size());
   EXPECT_EQ(1.0f, image.image_reps()[0].scale());
   EXPECT_EQ(1.5f, image.image_reps()[1].scale());
 }
 
 TEST_F(ImageSkiaTest, UnscaledImageForArbitraryScaleFactor) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kAllowArbitraryScaleFactorInImageSkia);
 
   // Do not test if the ImageSkia doesn't support arbitrary scale factors.
   if (!ImageSkia::IsDSFScalingInImageSkiaEnabled())
     return;
 
   // 0.0f means unscaled.
+  Canvas canvas(Size(100, 200), 1.0f, false);
+  canvas.FillRect(Rect(0, 0, 100, 200), SK_ColorRED);
+  ImageSkiaRep origin_rep = canvas.ExtractImageRep();
   ImageSkia image(new FixedSource(
-      ImageSkiaRep(Size(100, 200), 0.0f)), Size(100, 200));
+      ImageSkiaRep(origin_rep.sk_bitmap(), 0.0f)), Size(100, 200));
 
   // Requesting 2.0f, which should return 1.0f unscaled image.
   const ImageSkiaRep& rep = image.GetRepresentation(2.0f);
   EXPECT_EQ(1.0f, rep.scale());
   EXPECT_EQ("100x200", rep.pixel_size().ToString());
   EXPECT_TRUE(rep.unscaled());
   EXPECT_EQ(1U, image.image_reps().size());
 
   // Same for any other scale factors.
   const ImageSkiaRep& rep15 = image.GetRepresentation(1.5f);
   EXPECT_EQ(1.0f, rep15.scale());
   EXPECT_EQ("100x200", rep15.pixel_size().ToString());
   EXPECT_TRUE(rep15.unscaled());
   EXPECT_EQ(1U, image.image_reps().size());
 
   const ImageSkiaRep& rep12 = image.GetRepresentation(1.2f);
   EXPECT_EQ(1.0f, rep12.scale());
   EXPECT_EQ("100x200", rep12.pixel_size().ToString());
   EXPECT_TRUE(rep12.unscaled());
   EXPECT_EQ(1U, image.image_reps().size());
 }
 
 }  // namespace gfx