Makes the browser send pixels to the GPU process where it should

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 35 matching lines @@
 
 Layer::Layer()
     : type_(LAYER_TEXTURED),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL),
-      scale_canvas_(true),
+      scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL),
-      scale_canvas_(true),
+      scale_content_(true),
       device_scale_factor_(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_)
@@ skipping 252 matching lines @@
   if (delegate_ && !damaged_region_.isEmpty()) {
     for (SkRegion::Iterator iter(damaged_region_);
          !iter.done(); iter.next()) {
       const SkIRect& sk_damaged = iter.rect();
       gfx::Rect damaged(
           sk_damaged.x(),
           sk_damaged.y(),
           sk_damaged.width(),
           sk_damaged.height());
 
-      // TODO(pkotwicz): Remove this once we are no longer linearly upscaling
-      // web contents when DIP is enabled (crbug.com/127455).
-      if (web_layer_is_accelerated_) {
+      if (scale_content_ && web_layer_is_accelerated_) {
         damaged.Inset(-1, -1);
         damaged = damaged.Intersect(bounds_);
       }
 
       gfx::Rect damaged_in_pixel = ConvertRectToPixel(this, damaged);
       WebKit::WebFloatRect web_rect(
           damaged_in_pixel.x(),
           damaged_in_pixel.y(),
           damaged_in_pixel.width(),
           damaged_in_pixel.height());
@@ skipping 27 matching lines @@
   if (delegate_)
     delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
 void Layer::paintContents(WebKit::WebCanvas* web_canvas,
                           const WebKit::WebRect& clip) {
   TRACE_EVENT0("ui", "Layer::paintContents");
   gfx::Canvas canvas(web_canvas);
-  bool scale_canvas = scale_canvas_;
-  if (scale_canvas) {
+  bool scale_content = scale_content_;
+  if (scale_content) {
     canvas.sk_canvas()->scale(SkFloatToScalar(device_scale_factor_),
                               SkFloatToScalar(device_scale_factor_));
   }
   if (delegate_)
     delegate_->OnPaintLayer(&canvas);
-  if (scale_canvas)
+  if (scale_content)
     canvas.Restore();
 }
 
 float Layer::GetCombinedOpacity() const {
   float opacity = opacity_;
   Layer* current = this->parent_;
   while (current) {
     opacity *= current->opacity_;
     current = current->parent_;
   }
@@ skipping 173 matching lines @@
   if (!web_layer_is_accelerated_) {
     if (type_ != LAYER_SOLID_COLOR)
       web_layer_.to<WebKit::WebContentLayer>().setDrawsContent(should_draw);
     web_layer_.setBounds(ConvertSizeToPixel(this, bounds_.size()));
   } else {
     DCHECK(texture_);
     unsigned int texture_id = texture_->texture_id();
     WebKit::WebExternalTextureLayer texture_layer =
         web_layer_.to<WebKit::WebExternalTextureLayer>();
     texture_layer.setTextureId(should_draw ? texture_id : 0);
-    gfx::Size texture_size = texture_->size();
 
-    // As WebKit does not support DIP, WebKit is told of coordinates in DIP
-    // as if they were pixel coordinates. The texture is scaled here via
-    // the setBounds call.
-    // TODO(pkotwicz): Fix this code to take in account textures with pixel
-    // sizes once WebKit understands DIP. http://crbug.com/127455
+    gfx::Size texture_size;
+    if (scale_content_)
+      texture_size = texture_->size();
+    else
+      texture_size = ConvertSizeToDIP(this, texture_->size());
+
     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