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"
+#include "ui/gfx/transform.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(

[danakj, 2017/06/27 16:28:36]

It is weird to me that this context has a size now. A context is a pipe into
which we put recording commands. A recording doesn't have a size, it has a list
of commands. The layer has a size, the view has a size, the recording doesn't.

[malaykeshav, 2017/07/07 22:57:09]

Agreed on the fact that the PaintContext does not have a size. A better name
that reflects
what it represents would be paint_recording_bounds. The PaintContext would be
the correct 
place for it.

The concept of recording bounds only exists during Paint, so it cannot be a part
of views or layers.

OTOH |bounds_| can be removed, as they represent the bounds of a layer/view.

Adding paint_recording_bounds and paint_recording_scale would also make the
terminologies 
consistent with the cc side changes for recording_scale_factor. This also
removes the concept of 
pixels from PaintContext which was also confusing.

+          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) {
 #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::ScaleToCornerScaledPixelSize(
+    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::Transform PaintContext::TransformToParentPixelSpace() const {
+  gfx::Transform to_parent_pixel_space;
+  if (IsPixelCanvas()) {
+    // This is just an optimization to prevent the computation of effective
+    // scale factors which would return 1.f if the Pixel Canvas is disabled.
+    to_parent_pixel_space.Scale(SkFloatToScalar(effective_scale_factor_x()),
+                                SkFloatToScalar(effective_scale_factor_y()));
+  }
+  to_parent_pixel_space.Translate(pixel_bounds().OffsetFromOrigin());
+  return to_parent_pixel_space;
+}
+
+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