Implements core logic for Pixel Canvas

ui/compositor/paint_context.cc

 // Copyright 2015 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/paint_context.h"
 
 #include "ui/gfx/canvas.h"
 
 namespace ui {
+namespace {
+
+// Scales the given |rect| by scaling its corner points.
+gfx::Rect ScaleToCornerScaledRect(gfx::Rect rect,
+                                  float x_scale,
+                                  float y_scale = -1) {
+  y_scale = y_scale < 0 ? x_scale : y_scale;
+  const gfx::Vector2d& origin = rect.OffsetFromOrigin();
+
+  int right = origin.x() + rect.width();
+  int bottom = origin.y() + rect.height();
+
+  int new_x = std::round(origin.x() * x_scale);
+  int new_y = std::round(origin.y() * y_scale);
+
+  return gfx::Rect(new_x, new_y, std::round(right * x_scale) - new_x,
+                   std::round(bottom * y_scale) - new_y);
+}
+
+}  // namespace
 
 PaintContext::PaintContext(cc::DisplayItemList* list,
                            float device_scale_factor,
-                           const gfx::Rect& invalidation)
+                           const gfx::Rect& invalidation,
+                           const gfx::Size& size)
     : list_(list),
       device_scale_factor_(device_scale_factor),
-      invalidation_(invalidation) {
+      invalidation_(gfx::ScaleToEnclosingRect(
+          invalidation,
+          IsPixelCanvas() ? device_scale_factor : 1.f)),
+      bounds_(size),
+      pixel_bounds_(ScaleToCornerScaledRect(
+          bounds_,
+          IsPixelCanvas() ? device_scale_factor : 1.f)) {
 #if DCHECK_IS_ON()
   root_visited_ = nullptr;
   inside_paint_recorder_ = false;
 #endif
 }
 
 PaintContext::PaintContext(const PaintContext& other,
-                           const gfx::Vector2d& offset)
+                           const gfx::Rect& bounds,
+                           int scale_type)
     : list_(other.list_),
       device_scale_factor_(other.device_scale_factor_),
       invalidation_(other.invalidation_),
-      offset_(other.offset_ + offset) {
+      bounds_(bounds),
+      pixel_bounds_(other.GetSnappedPixelBounds(bounds_)),
+      offset_(other.offset_ + pixel_bounds_.OffsetFromOrigin()),
+      scale_type_(scale_type) {

[oshima, 2017/06/17 00:55:47]

I wasn't clear, sorry. Scale type shouldn't be a part of paint context. This
type should be applied only to painting (thus, clipping) logic. 

the scale type should be used inside View::Paint to clip & paint accordingly.

ping me or drop in when you have a chance.

 #if DCHECK_IS_ON()
   root_visited_ = other.root_visited_;
   inside_paint_recorder_ = other.inside_paint_recorder_;
 #endif
 }
 
 PaintContext::PaintContext(const PaintContext& other,
                            CloneWithoutInvalidation c)
     : list_(other.list_),
       device_scale_factor_(other.device_scale_factor_),
       invalidation_(),
+      bounds_(other.bounds_),
+      pixel_bounds_(other.pixel_bounds_),
       offset_(other.offset_) {
 #if DCHECK_IS_ON()
   root_visited_ = other.root_visited_;
   inside_paint_recorder_ = other.inside_paint_recorder_;
 #endif
 }
 
 PaintContext::~PaintContext() {
 }
 
 gfx::Rect PaintContext::ToLayerSpaceBounds(
     const gfx::Size& size_in_context) const {
   return gfx::Rect(size_in_context) + offset_;
 }
 
-gfx::Rect PaintContext::ToLayerSpaceRect(const gfx::Rect& rect) const {
-  return rect + offset_;
+float PaintContext::effective_scale_factor_x() const {
+  if (scale_type_ == SCALE_TO_SCALE_FACTOR || pixel_bounds_.width() == 0)
+    return IsPixelCanvas() ? device_scale_factor_ : 1.f;
+  return static_cast<float>(pixel_bounds_.width()) /
+         static_cast<float>(bounds_.width());
+}
+
+float PaintContext::effective_scale_factor_y() const {
+  if (scale_type_ == SCALE_TO_SCALE_FACTOR || pixel_bounds_.height() == 0)
+    return IsPixelCanvas() ? device_scale_factor_ : 1.f;
+  return static_cast<float>(pixel_bounds_.height()) /
+         static_cast<float>(bounds_.height());
+}
+
+gfx::Size PaintContext::ScaleToCorneredPixelSize(const gfx::Size& size) const {
+  // effective_scale_factor_x/y() would return 1.f value if pixel canvas is
+  // disabled. This early return is only an optimization.
+  if (!IsPixelCanvas())
+    return size;
+  return ScaleToCornerScaledRect(gfx::Rect(size), effective_scale_factor_x(),
+                                 effective_scale_factor_y())
+      .size();
+}
+
+gfx::Rect PaintContext::GetSnappedPixelBounds(
+    const gfx::Rect& child_bounds) const {
+  if (!IsPixelCanvas())
+    return child_bounds;
+
+  const gfx::Vector2d& child_origin = child_bounds.OffsetFromOrigin();
+
+  int right = child_origin.x() + child_bounds.width();
+  int bottom = child_origin.y() + child_bounds.height();
+
+  int new_x = std::round(child_origin.x() * device_scale_factor_);
+  int new_y = std::round(child_origin.y() * device_scale_factor_);
+
+  int new_right;
+  int new_bottom;
+
+  if (right == bounds_.width()) {
+    new_right = pixel_bounds_.width();
+  } else {
+    new_right = std::round(right * device_scale_factor_);
+  }
+
+  if (bottom == bounds_.height()) {
+    new_bottom = pixel_bounds_.height();
+  } else {
+    new_bottom = std::round(bottom * device_scale_factor_);
+  }
+  return gfx::Rect(new_x, new_y, new_right - new_x, new_bottom - new_y);
 }
 
 }  // namespace ui