Move DIP translation from ui/aura to ui/compositor

ui/gfx/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/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebContentLayer.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebExternalTextureLayer.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperation.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFilterOperations.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFloatPoint.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFloatRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSolidColorLayer.h"
 #include "ui/base/animation/animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/compositor_switches.h"
+#include "ui/gfx/compositor/dip_util.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/point3.h"
 
 namespace {
 
 const float EPSILON = 1e-3f;
 
 bool IsApproximateMultipleOf(float value, float base) {
   float remainder = fmod(fabs(value), base);
   return remainder < EPSILON || base - remainder < EPSILON;
 }
 
 const ui::Layer* GetRoot(const ui::Layer* layer) {
   return layer->parent() ? GetRoot(layer->parent()) : layer;
 }
 
+float GetScale(const ui::Compositor* compositor) {
+  if (!ui::IsDIPEnabled())
+    return 1.0f;
+  return compositor ? compositor->device_scale_factor() : 1.0f;
+}
+
 }  // namespace
 
 namespace ui {
 
 Layer::Layer()
     : type_(LAYER_TEXTURED),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
       opacity_(1.0f),
-      delegate_(NULL) {
+      delegate_(NULL),
+      scale_canvas_(true) {
   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) {
+      delegate_(NULL),
+      scale_canvas_(true) {
   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 17 matching lines @@
   compositor_ = compositor;
 }
 
 void Layer::Add(Layer* child) {
   DCHECK(!child->compositor_);
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
   web_layer_.addChild(child->web_layer_);
+  child->UpdateLayerSize(GetCompositor());
 }
 
 void Layer::Remove(Layer* child) {
   std::vector<Layer*>::iterator i =
       std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->parent_ = NULL;
   child->web_layer_.removeFromParent();
 }
@@ skipping 114 matching lines @@
 // static
 void Layer::ConvertPointToLayer(const Layer* source,
                                 const Layer* target,
                                 gfx::Point* point) {
   if (source == target)
     return;
 
   const Layer* root_layer = GetRoot(source);
   CHECK_EQ(root_layer, GetRoot(target));
 
+  // TODO(oshima): We probably need to handle source's root != target's root
+  // case under multi monitor environment.
   if (source != root_layer)
     source->ConvertPointForAncestor(root_layer, point);
   if (target != root_layer)
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   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;
+  const Compositor* compositor = GetCompositor();
   if (web_layer_is_accelerated_ != layer_updated_externally_) {
     // Switch to a different type of layer.
     web_layer_.removeAllChildren();
     WebKit::WebLayer new_layer;
     if (layer_updated_externally_) {
       WebKit::WebExternalTextureLayer texture_layer =
           WebKit::WebExternalTextureLayer::create();
       texture_layer.setFlipped(texture_->flipped());
       new_layer = texture_layer;
     } else {
       new_layer = WebKit::WebContentLayer::create(this);
     }
     if (parent_) {
       DCHECK(!parent_->web_layer_.isNull());
       parent_->web_layer_.replaceChild(web_layer_, new_layer);
     }
     web_layer_ = new_layer;
     web_layer_is_accelerated_ = layer_updated_externally_;
     for (size_t i = 0; i < children_.size(); ++i) {
       DCHECK(!children_[i]->web_layer_.isNull());
       web_layer_.addChild(children_[i]->web_layer_);
     }
     web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
     web_layer_.setOpaque(fills_bounds_opaquely_);
     web_layer_.setOpacity(visible_ ? opacity_ : 0.f);
     web_layer_.setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
-    RecomputeTransform();
+    RecomputeTransform(compositor);
     RecomputeDebugBorderColor();
   }
-  RecomputeDrawsContentAndUVRect();
+  RecomputeDrawsContentAndUVRect(compositor);
 }
 
 void Layer::SetColor(SkColor color) {
   DCHECK_EQ(type_, LAYER_SOLID_COLOR);
   // WebColor is equivalent to SkColor, per WebColor.h.
   web_layer_.to<WebKit::WebSolidColorLayer>().setBackgroundColor(
       static_cast<WebKit::WebColor>(color));
   SetFillsBoundsOpaquely(SkColorGetA(color) == 0xFF);
 }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   if (type_ == LAYER_SOLID_COLOR || !delegate_)
     return false;
-  damaged_region_.op(invalid_rect.x(),
-                     invalid_rect.y(),
-                     invalid_rect.right(),
-                     invalid_rect.bottom(),
+  gfx::Rect invalid_rect_in_pixel = ConvertRectToPixel(this, invalid_rect);
+  damaged_region_.op(invalid_rect_in_pixel.x(),
+                     invalid_rect_in_pixel.y(),
+                     invalid_rect_in_pixel.right(),
+                     invalid_rect_in_pixel.bottom(),
                      SkRegion::kUnion_Op);
   ScheduleDraw();
   return true;
 }
 
 void Layer::ScheduleDraw() {
   Compositor* compositor = GetCompositor();
   if (compositor)
     compositor->ScheduleDraw();
 }
@@ skipping 21 matching lines @@
 }
 
 void Layer::SuppressPaint() {
   if (!delegate_)
     return;
   delegate_ = NULL;
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SuppressPaint();
 }
 
+void Layer::UpdateLayerSize(const Compositor* compositor) {
+  RecomputeTransform(compositor);
+  RecomputeDrawsContentAndUVRect(compositor);
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->UpdateLayerSize(compositor);
+}
+
 void Layer::paintContents(WebKit::WebCanvas* web_canvas,
                           const WebKit::WebRect& clip) {
   TRACE_EVENT0("ui", "Layer::paintContents");
   gfx::Canvas canvas(web_canvas);
+  bool scale_canvas = IsDIPEnabled() && scale_canvas_;
+  if (scale_canvas) {
+    float scale = GetDeviceScaleFactor(this);
+    canvas.sk_canvas()->scale(SkFloatToScalar(scale), SkFloatToScalar(scale));
+  }
   if (delegate_)
     delegate_->OnPaintLayer(&canvas);
+  if (scale_canvas)
+    canvas.Restore();
 }
 
 float Layer::GetCombinedOpacity() const {
   float opacity = opacity_;
   Layer* current = this->parent_;
   while (current) {
     opacity *= current->opacity_;
     current = current->parent_;
   }
   return opacity;
@@ skipping 50 matching lines @@
       transform->ConcatTransform(p->transform());
     transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
                                static_cast<float>(p->bounds().y()));
   }
   return p == ancestor;
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   if (bounds == bounds_)
     return;
+  Compositor* compositor = GetCompositor();
 
   bool was_move = bounds_.size() == bounds.size();
   bounds_ = bounds;
   if (IsDrawn()) {
     if (was_move)
-      ScheduleDraw();
+      ScheduleDraw(compositor);
     else
-      SchedulePaint(gfx::Rect(bounds.size()));
+      SchedulePaint(compositor, gfx::Rect(bounds.size()));
   }
-
-  RecomputeTransform();
-  RecomputeDrawsContentAndUVRect();
+  RecomputeTransform(compositor);
+  RecomputeDrawsContentAndUVRect(compositor);
 }
 
 void Layer::SetTransformImmediately(const ui::Transform& transform) {
   transform_ = transform;
 
-  RecomputeTransform();
+  RecomputeTransform(GetCompositor());
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
   bool schedule_draw = (opacity != opacity_ && IsDrawn());
   opacity_ = opacity;
 
   if (visible_)
     web_layer_.setOpacity(opacity);
   RecomputeDebugBorderColor();
   if (schedule_draw)
@@ skipping 49 matching lines @@
   if (type_ == LAYER_SOLID_COLOR)
     web_layer_ = WebKit::WebSolidColorLayer::create();
   else
     web_layer_ = WebKit::WebContentLayer::create(this);
   web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
   web_layer_.setOpaque(true);
   web_layer_is_accelerated_ = false;
   show_debug_borders_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUIShowLayerBorders);
   web_layer_.setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
-  RecomputeDrawsContentAndUVRect();
-  RecomputeDebugBorderColor();
 }
 
-void Layer::RecomputeTransform() {
-  ui::Transform transform = transform_;
-  transform.ConcatTranslate(bounds_.x(), bounds_.y());
-  web_layer_.setTransform(transform.matrix());
+void Layer::RecomputeTransform(const Compositor* compositor) {
+  Transform t;
+  if (compositor && IsDIPEnabled()) {
+    t = compositor->GetTranslateTransform(transform_, bounds_.origin());
+  } else {
+    t = transform_;
+    t.ConcatTranslate(bounds_.x(), bounds_.y());
+  }
+  web_layer_.setTransform(t.matrix());
 }
 
-void Layer::RecomputeDrawsContentAndUVRect() {
+void Layer::RecomputeDrawsContentAndUVRect(const Compositor* compositor) {
   DCHECK(!web_layer_.isNull());
+  float device_scale_factor = GetScale(compositor);
   bool should_draw = type_ != LAYER_NOT_DRAWN;
   if (!web_layer_is_accelerated_) {
     if (type_ != LAYER_SOLID_COLOR)
       web_layer_.to<WebKit::WebContentLayer>().setDrawsContent(should_draw);
-    web_layer_.setBounds(bounds_.size());
+    web_layer_.setBounds(bounds_.size().Scale(device_scale_factor));
   } 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::Rect bounds_in_pixel = bounds().Scale(device_scale_factor);
     gfx::Size texture_size = texture_->size();
-    gfx::Size size(std::min(bounds_.width(), texture_size.width()),
-                   std::min(bounds_.height(), texture_size.height()));
+    gfx::Size size(std::min(bounds_in_pixel.width(), texture_size.width()),
+                   std::min(bounds_in_pixel.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);
     web_layer_.setBounds(size);
   }
 }
 
 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);
 }
 
+void Layer::ScheduleDraw(Compositor* compositor) {
+  if (compositor)
+    compositor->ScheduleDraw();
+}
+
+bool Layer::SchedulePaint(Compositor* compositor,
+                          const gfx::Rect& invalid_rect) {
+  if (type_ == LAYER_SOLID_COLOR || !delegate_)
+    return false;
+  gfx::Rect invalid_rect_in_pixel =
+      invalid_rect.Scale(GetScale(compositor));
+  damaged_region_.op(invalid_rect_in_pixel.x(),
+                     invalid_rect_in_pixel.y(),
+                     invalid_rect_in_pixel.right(),
+                     invalid_rect_in_pixel.bottom(),
+                     SkRegion::kUnion_Op);
+  ScheduleDraw(compositor);
+  return true;
+}
+
+
 }  // namespace ui