SV Test

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 76 matching lines @@
 const int kDefaultVerticalDragThreshold = 8;
 
 // Returns the top view in |view|'s hierarchy.
 const View* GetHierarchyRoot(const View* view) {
   const View* root = view;
   while (root && root->parent())
     root = root->parent();
   return root;
 }
 
+/*
+gfx::Rect GetPixelBounds(const ui::PaintContext& parent_context,
+                         const gfx::Vector2d& child_origin,
+                         const gfx::Size& child_size,
+                         const gfx::Size& parent_pixel_size,
+                         const gfx::Rect& parent_bounds) {
+  float dsf = parent_context.device_scale_factor();
+
+  int right = child_origin.x() + child_size.width();
+  int bottom = child_origin.y() + child_size.height();
+
+  int new_x = std::round(child_origin.x() * dsf);
+  int new_y = std::round(child_origin.y() * dsf);
+
+  int new_right;
+  int new_bottom;
+
+  if (right == parent_bounds.width()) {
+    new_right = parent_pixel_size.width();
+  } else {
+    new_right = std::round(right * dsf);
+  }
+  if (bottom == parent_bounds.height()) {
+    new_bottom = parent_pixel_size.height();
+  } else {
+    new_bottom = std::round(bottom * dsf);
+  }
+  return gfx::Rect(new_x, new_y, new_right - new_x, new_bottom - new_y);
+}
+*/
+
 }  // namespace
 
 namespace internal {
 
 #if DCHECK_IS_ON()
   class ScopedChildrenLock {
    public:
     explicit ScopedChildrenLock(const View* view)
         : reset_(&view->iterating_, true) {}
     ~ScopedChildrenLock() {}
@@ skipping 714 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;
+  gfx::Vector2dF scale = parent_context.CanvasScale();
 
-  ui::PaintContext context(parent_context, GetPaintContextOffset());
+  gfx::Point offset_to_parent;
+  if (!layer()) {
+    // 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(parent() || origin() == gfx::Point());
+    offset_to_parent = GetMirroredPosition();
+  }
+
+  gfx::Rect pixel_bounds =
+      parent_context.GetPixelBounds(gfx::Rect(offset_to_parent, size()));
+  /*
+  LOG(ERROR) << "ParentPixelSize:"
+             << "parent bounds=" << parent_bounds.ToString()
+             << ", parent pixel=" << parent_pixel_size.ToString()
+             << ", my size=" << size().ToString()
+             << ", m pixel=" << pixel_bounds.ToString();
+  */
+
+  ui::PaintContext context(parent_context, GetPaintContextOffset(pixel_bounds));
+  context.UpdateSizeAndDSF(pixel_bounds.size(), size());
 
   bool is_invalidated = true;
   if (context.CanCheckInvalid()) {
-#if DCHECK_IS_ON()
+#if DCHECK_IS_ON() && 0
     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);
 #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.IsRectInvalid(gfx::Rect(pixel_bounds.size()));
   }
 
   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(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(scale.x()),
+          SkFloatToScalar(scale.y())));
       clip_recorder.ClipPathWithAntiAliasing(clip_path_in_parent);
     }
   }
 
   ui::TransformRecorder transform_recorder(context);
-  SetupTransformRecorderForPainting(&transform_recorder);
+  SetupTransformRecorderForPainting(&transform_recorder,
+                                    GetPaintContextOffset(pixel_bounds));
 
   // 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, pixel_bounds.size())) {
+    ui::PaintRecorder recorder(context, pixel_bounds.size(), &paint_cache_,
+                               true);
     gfx::Canvas* canvas = recorder.canvas();
-    gfx::ScopedRTLFlipCanvas scoped_canvas(canvas, width(),
+    gfx::ScopedRTLFlipCanvas scoped_canvas(canvas, pixel_bounds.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 1036 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::Vector2d View::GetPaintContextOffset(const gfx::Rect& pixel_bounds) 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();
+  if (layer())
+    return gfx::Vector2d();
+  int mirrored_x = GetMirroredXForRect(pixel_bounds);
+  return gfx::Vector2d(mirrored_x, pixel_bounds.y());
 }
 
 void View::SetupTransformRecorderForPainting(
-    ui::TransformRecorder* recorder) const {
+    ui::TransformRecorder* recorder,
+    gfx::Vector2d offset_from_parent) const {
   // If the view is backed by a layer, it should paint with itself as the origin
-  // rather than relative to its parent.
+  // rather than relative to its parent.2
   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();
   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());
+  //const gfx::Size& parent_pixel_size = parent_context.pixel_size();
+  //const gfx::Rect parent_bounds = parent() ? parent()->bounds() : bounds();
+  gfx::Point offset_to_parent;
+  if (!layer()) {
+    // 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(parent() || origin() == gfx::Point());
+    offset_to_parent = GetMirroredPosition();
+  }
+  gfx::Rect pixel_bounds = parent_context.GetPixelBounds(gfx::Rect(offset_to_parent, size()));
+  ui::PaintContext context(parent_context, GetPaintContextOffset(pixel_bounds));
+  context.UpdateSizeAndDSF(pixel_bounds.size(), size());
+
   ui::TransformRecorder transform_recorder(context);
-  SetupTransformRecorderForPainting(&transform_recorder);
+  SetupTransformRecorderForPainting(&transform_recorder,
+                                    pixel_bounds.OffsetFromOrigin());
 
   RecursivePaintHelper(&View::PaintDebugRects, context);
 
   // Draw outline rects for debugging.
-  ui::PaintRecorder recorder(context, size());
+  ui::PaintRecorder recorder(context, pixel_bounds.size(), &paint_cache_, true);
   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 654 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