Change the scale factor of texture_size from the layer's one to an estimation.

ui/compositor/layer.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/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 733 matching lines @@
   bool should_draw = type_ != LAYER_NOT_DRAWN;
   if (!web_layer_is_accelerated_) {
     if (type_ != LAYER_SOLID_COLOR) {
       web_layer_->setDrawsContent(should_draw);
     }
     web_layer_->setBounds(ConvertSizeToPixel(this, bounds_.size()));
   } else {
     DCHECK(texture_);
 
     gfx::Size texture_size;
-    if (scale_content_)
+    if (scale_content_) {
       texture_size = texture_->size();
-    else
-      texture_size = ConvertSizeToDIP(this, texture_->size());
+    } else {
+      // Scale the texture's size but the layer's scale factor can be different
+      // from the one of the texture in some cases. Thus estimate the scale
+      // factor from the size of the texture and the layer.
+      // TODO(mukai): add tests.
+      float scale_factor =
+          static_cast<float>(bounds().width()) / texture_->size().width();

[piman, 2012/09/19 23:08:48]

This will entirely defeat the purpose of computing the UV rect below (to avoid
resizing the texture when resizing windows if it doesn't match). And you may
generate non-integer scaling factors which will produce bad artifacts.

What you have here is a texture with a device pixel ratio that doesn't match the
layer's device pixel ratio. So to properly fix it you'd need to override the
layer's pixel ratio for mapping the content.
Alternatively, when creating the texture (RecreateLayer I guess?) you could set
the texture size in DIPs, and set the scale_content_ flag on the layer.

[Jun Mukai, 2012/09/20 22:00:31]

Thanks for comments.  Then I introduced another field for the scale factor for
the textures.  Please take another look at this.

+      texture_size = texture_->size().Scale(scale_factor);
+    }
 
     gfx::Size size(std::min(bounds().width(), texture_size.width()),
                    std::min(bounds().height(), texture_size.height()));
     WebKit::WebFloatRect rect(
         0,
         0,
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUVRect(rect);
 
     gfx::Size size_in_pixel = ConvertSizeToPixel(this, size);
     web_layer_->setBounds(size_in_pixel);
   }
 }
 
 void Layer::RecomputeDebugBorderColor() {
   if (!show_debug_borders_)
     return;
   unsigned int color = 0xFF000000;
   color |= web_layer_is_accelerated_ ? 0x0000FF00 : 0x00FF0000;
   bool opaque = fills_bounds_opaquely_ && (GetCombinedOpacity() == 1.f);
   if (!opaque)
     color |= 0xFF;
   web_layer_->setDebugBorderColor(color);
 }
 
 }  // namespace ui