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 47 matching lines @@
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       delegate_(NULL),
       web_layer_(NULL),
       scale_content_(true),
-      device_scale_factor_(1.0f) {
+      device_scale_factor_(1.0f),
+      device_scale_factor_for_texture_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
       opacity_(1.0f),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       delegate_(NULL),
       scale_content_(true),
-      device_scale_factor_(1.0f) {
+      device_scale_factor_(1.0f),
+      device_scale_factor_for_texture_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::~Layer() {
   // Destroying the animator may cause observers to use the layer (and
   // indirectly the WebLayer). Destroy the animator first so that the WebLayer
   // is still around.
   animator_.reset();
   if (compositor_)
     compositor_->SetRootLayer(NULL);
@@ skipping 270 matching lines @@
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
   web_layer_->setOpaque(fills_bounds_opaquely);
   RecomputeDebugBorderColor();
 }
 
 void Layer::SetExternalTexture(Texture* texture) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   layer_updated_externally_ = !!texture;
   texture_ = texture;
+  device_scale_factor_for_texture_ = device_scale_factor_;

[piman, 2012/09/20 23:20:07]

mmh, that may solve the problem in a given case, but not the general problem.
If you have one layer tree that's on screen1 with a device ratio R1, and one
layer tree that's on screen2 with device ratio R2, and you want to put the same
texture in both, this won't work.
What you really want is to have a per-texture device pixel ratio. There's no
reason we can't extend Texture for that - and they're only created in 2 places,
both in ImageTransportFactory, only called from RenderWidgetHostViewAura, which
incidentally is what knows the pixel ratio for the texture.

[Jun Mukai, 2012/09/21 00:53:55]

hmm, then added the device_scale_factor to ui::Texture itself.  please take
another look, again.

   if (web_layer_is_accelerated_ != layer_updated_externally_) {
     // Switch to a different type of layer.
     web_layer_->removeAllChildren();
     scoped_ptr<WebKit::WebContentLayer> old_content_layer(
         content_layer_.release());
     scoped_ptr<WebKit::WebSolidColorLayer> old_solid_layer(
         solid_color_layer_.release());
     scoped_ptr<WebKit::WebExternalTextureLayer> old_texture_layer(
         texture_layer_.release());
     WebKit::WebLayer* new_layer = NULL;
@@ skipping 351 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 {
+      texture_size =
+          texture_->size().Scale(1.0f / device_scale_factor_for_texture_);
+    }
 
     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