Implements core logic for Pixel Canvas

ui/views/view.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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
@@ skipping 820 matching lines @@
   } else if (parent_) {
     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
     parent_->SchedulePaintInRect(ConvertRectToParent(rect));
   }
 }
 
 void View::Paint(const ui::PaintContext& parent_context) {
   if (!ShouldPaint())
     return;
-
-  ui::PaintContext context(parent_context, GetPaintContextOffset());
+  ui::PaintContext context(parent_context, GetPaintContextBounds(),
+                           GetContextScaleType());
 
   bool is_invalidated = true;
-  if (context.CanCheckInvalid()) {
+  if (context.CanCheckRepaint()) {
 #if DCHECK_IS_ON()
-    gfx::Vector2d offset;
-    context.Visited(this);
-    View* view = this;
-    while (view->parent() && !view->layer()) {
-      DCHECK(view->GetTransform().IsIdentity());
-      offset += view->GetMirroredPosition().OffsetFromOrigin();
-      view = view->parent();
+    if (!context.IsPixelCanvas()) {
+      gfx::Vector2d offset;
+      context.Visited(this);
+      View* view = this;
+      while (view->parent() && !view->layer()) {
+        DCHECK(view->GetTransform().IsIdentity());
+        offset += view->GetMirroredPosition().OffsetFromOrigin();
+        view = view->parent();
+      }
+      // The offset in the PaintContext should be the offset up to the paint
+      // root, which we compute and verify here.
+      DCHECK_EQ(context.PaintOffset().x(), offset.x());
+      DCHECK_EQ(context.PaintOffset().y(), offset.y());
+      // The above loop will stop when |view| is the paint root, which should be
+      // the root of the current paint walk, as verified by storing the root in
+      // the PaintContext.
+      DCHECK_EQ(context.RootVisited(), view);
     }
-    // The offset in the PaintContext should be the offset up to the paint root,
-    // which we compute and verify here.
-    DCHECK_EQ(context.PaintOffset().x(), offset.x());
-    DCHECK_EQ(context.PaintOffset().y(), offset.y());
-    // The above loop will stop when |view| is the paint root, which should be
-    // the root of the current paint walk, as verified by storing the root in
-    // the PaintContext.
-    DCHECK_EQ(context.RootVisited(), view);
 #endif
 
     // If the View wasn't invalidated, don't waste time painting it, the output
     // would be culled.
-    is_invalidated = context.IsRectInvalid(GetLocalBounds());
+    is_invalidated = context.ShouldRepaint();
   }
 
   TRACE_EVENT1("views", "View::Paint", "class", GetClassName());
 
   // If the view is backed by a layer, it should paint with itself as the origin
   // rather than relative to its parent.
   // TODO(danakj): Rework clip and transform recorder usage here to use
   // std::optional once we can do so.
   ui::ClipRecorder clip_recorder(parent_context);
   if (!layer()) {
     // Set the clip rect to the bounds of this View, or |clip_path_| if it's
     // been set. Note that the X (or left) position we pass to ClipRect takes
     // into consideration whether or not the View uses a right-to-left layout so
     // that we paint the View in its mirrored position if need be.
     if (clip_path_.isEmpty()) {
-      clip_recorder.ClipRect(GetMirroredBounds());
+      clip_recorder.ClipRect(context.pixel_bounds());
     } else {
       gfx::Path clip_path_in_parent = clip_path_;
-      clip_path_in_parent.offset(GetMirroredX(), y());
+      clip_path_in_parent.transform(SkMatrix::MakeScale(
+          SkFloatToScalar(context.effective_scale_factor_x()),
+          SkFloatToScalar(context.effective_scale_factor_y())));
+      clip_path_in_parent.offset(context.pixel_bounds().OffsetFromOrigin().x(),
+                                 context.pixel_bounds().OffsetFromOrigin().y());

[oshima, 2017/06/22 15:24:11]

can we move the clipping function to context as well? We should try to hide API
that may return pixel or dip as it's confusing.

[malaykeshav, 2017/06/22 21:02:53]

Done

       clip_recorder.ClipPathWithAntiAliasing(clip_path_in_parent);
     }
   }
 
   ui::TransformRecorder transform_recorder(context);
-  SetupTransformRecorderForPainting(&transform_recorder);
+  SetupTransformRecorderForPainting(&transform_recorder, context);
 
   // Note that the cache is not aware of the offset of the view
   // relative to the parent since painting is always done relative to
   // the top left of the individual view.
-  if (is_invalidated || !paint_cache_.UseCache(context, size())) {
-    ui::PaintRecorder recorder(context, size(), &paint_cache_);
+  if (is_invalidated || !paint_cache_.UseCache(context, context.pixel_size())) {
+    ui::PaintRecorder recorder(context, context.pixel_size(), &paint_cache_);

[oshima, 2017/06/22 15:24:11]

same here. I'm still not convinced that extra argument, which can be derived
from the argument already passed, is useful unless it has usage.

[malaykeshav, 2017/06/22 21:02:53]

A lot of files are calling the PaintRecorder's second constructor so adding a
TODO for now and we can change this in subsequent CLs.

[oshima, 2017/06/23 18:42:32]

You can keep the second ctr. 

There are only 3~4 places that are using this ctr, and they are already in this
CL.

[malaykeshav, 2017/06/23 18:53:21]

The second constructor needs this constructor to have the size argument.

     gfx::Canvas* canvas = recorder.canvas();
     gfx::ScopedRTLFlipCanvas scoped_canvas(canvas, width(),
                                            flip_canvas_on_paint_for_rtl_ui_);
 
     // Delegate painting the contents of the View to the virtual OnPaint method.
     OnPaint(canvas);
   }
 
   // View::Paint() recursion over the subtree.
   PaintChildren(context);
@@ skipping 891 matching lines @@
   // and for different display density.
   return kDefaultHorizontalDragThreshold;
 }
 
 int View::GetVerticalDragThreshold() {
   // TODO(jennyz): This value may need to be adjusted for different platforms
   // and for different display density.
   return kDefaultVerticalDragThreshold;
 }
 
+int View::GetContextScaleType() const {
+  return ui::PaintContext::SCALE_TO_FIT;
+}
+
 // Debugging -------------------------------------------------------------------
 
 #if !defined(NDEBUG)
 
 std::string View::PrintViewGraph(bool first) {
   return DoPrintViewGraph(first, this);
 }
 
 std::string View::DoPrintViewGraph(bool first, View* view_with_children) {
   // 64-bit pointer = 16 bytes of hex + "0x" + '\0' = 19.
@@ skipping 132 matching lines @@
     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
     parent_->SchedulePaintInRect(ConvertRectToParent(GetLocalBounds()));
   }
 }
 
 bool View::ShouldPaint() const {
   return visible_ && !size().IsEmpty();
 }
 
-gfx::Vector2d View::GetPaintContextOffset() const {
+gfx::Rect View::GetPaintContextBounds() const {
   // If the View has a layer() then it is a paint root. Otherwise, we need to
   // add the offset from the parent into the total offset from the paint root.
   DCHECK(layer() || parent() || origin() == gfx::Point());
-  return layer() ? gfx::Vector2d() : GetMirroredPosition().OffsetFromOrigin();
+  return layer() ? GetLocalBounds() : GetMirroredBounds();
 }
 
 void View::SetupTransformRecorderForPainting(
-    ui::TransformRecorder* recorder) const {
+    ui::TransformRecorder* recorder,
+    const ui::PaintContext& context) const {
   // If the view is backed by a layer, it should paint with itself as the origin
   // rather than relative to its parent.
   if (layer())
     return;
 
   // Translate the graphics such that 0,0 corresponds to where this View is
   // located relative to its parent.
   gfx::Transform transform_from_parent;
-  gfx::Vector2d offset_from_parent = GetMirroredPosition().OffsetFromOrigin();
+  gfx::Vector2d offset_from_parent = context.pixel_bounds().OffsetFromOrigin();
   transform_from_parent.Translate(offset_from_parent.x(),
                                   offset_from_parent.y());
-  transform_from_parent.PreconcatTransform(GetTransform());
   recorder->Transform(transform_from_parent);
 }
 
 void View::RecursivePaintHelper(void (View::*func)(const ui::PaintContext&),
                                 const ui::PaintContext& context) {
   View::Views children = GetChildrenInZOrder();
   DCHECK_EQ(child_count(), static_cast<int>(children.size()));
   for (auto* child : children) {
     if (!child->layer())
       (child->*func)(context);
   }
 }
 
 void View::PaintFromPaintRoot(const ui::PaintContext& parent_context) {
   Paint(parent_context);
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDrawViewBoundsRects))
     PaintDebugRects(parent_context);
 }
 
 void View::PaintDebugRects(const ui::PaintContext& parent_context) {
   if (!ShouldPaint())
     return;
 
-  ui::PaintContext context(parent_context, GetPaintContextOffset());
+  ui::PaintContext context(parent_context, GetPaintContextBounds(),
+                           GetContextScaleType());
   ui::TransformRecorder transform_recorder(context);
-  SetupTransformRecorderForPainting(&transform_recorder);
+  SetupTransformRecorderForPainting(&transform_recorder, context);
 
   RecursivePaintHelper(&View::PaintDebugRects, context);
 
   // Draw outline rects for debugging.
-  ui::PaintRecorder recorder(context, size());
+  ui::PaintRecorder recorder(context, context.pixel_size(), &paint_cache_);
   gfx::Canvas* canvas = recorder.canvas();
   const float scale = canvas->UndoDeviceScaleFactor();
   gfx::RectF outline_rect(ScaleToEnclosedRect(GetLocalBounds(), scale));
   outline_rect.Inset(0.5f, 0.5f);
   const SkColor color = SkColorSetARGB(0x30, 0xff, 0, 0);
   canvas->DrawRect(outline_rect, color);
 }
 
 // Tree operations -------------------------------------------------------------
 
@@ skipping 643 matching lines @@
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
   // WARNING: we may have been deleted.
   return true;
 }
 
 }  // namespace views