Add --draw-view-bounds-rects to draw bounds rects for all views.

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>
 #include <memory>
 #include <utility>
 
+#include "base/command_line.h"
 #include "base/containers/adapters.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
@@ skipping 23 matching lines @@
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/accessibility/native_view_accessibility.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/layout/layout_manager.h"
 #include "ui/views/view_observer.h"
 #include "ui/views/views_delegate.h"
+#include "ui/views/views_switches.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #include "ui/native_theme/native_theme_win.h"
 #endif
 
@@ skipping 768 matching lines @@
   if (layer()) {
     layer()->SchedulePaint(rect);
   } 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 (!visible_)
-    return;
-  if (size().IsEmpty())
+  if (!ShouldPaint())
     return;
 
-  gfx::Vector2d 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().OffsetFromOrigin();
-  }
-  ui::PaintContext context(parent_context, offset_to_parent);
+  ui::PaintContext context(parent_context, GetPaintContextOffset());
 
   bool is_invalidated = true;
   if (context.CanCheckInvalid()) {
 #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();
@@ skipping 11 matching lines @@
 
     // If the View wasn't invalidated, don't waste time painting it, the output
     // would be culled.
     is_invalidated = context.IsRectInvalid(GetLocalBounds());
   }
 
   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.
-  bool paint_relative_to_parent = !layer();
-
   // 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 (paint_relative_to_parent) {
+  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());
     } else {
       gfx::Path clip_path_in_parent = clip_path_;
       clip_path_in_parent.offset(GetMirroredX(), y());
       clip_recorder.ClipPathWithAntiAliasing(clip_path_in_parent);
     }
   }
 
   ui::TransformRecorder transform_recorder(context);
-  if (paint_relative_to_parent) {
-    // 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());
-    transform_recorder.Transform(transform_from_parent);
-  }
+  SetupTransformRecorderForPainting(&transform_recorder);
 
   // 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_);
     gfx::Canvas* canvas = recorder.canvas();
     gfx::ScopedRTLFlipCanvas scoped_canvas(canvas, width(),
                                            flip_canvas_on_paint_for_rtl_ui_);
 
@@ skipping 584 matching lines @@
 }
 
 void View::AddedToWidget() {}
 
 void View::RemovedFromWidget() {}
 
 // Painting --------------------------------------------------------------------
 
 void View::PaintChildren(const ui::PaintContext& context) {
   TRACE_EVENT1("views", "View::PaintChildren", "class", GetClassName());
-  View::Views children = GetChildrenInZOrder();
-  DCHECK_EQ(child_count(), static_cast<int>(children.size()));
-  for (auto* child : children) {
-    if (!child->layer())
-      child->Paint(context);
-  }
+  RecursivePaintHelper(&View::Paint, context);
 }
 
 void View::OnPaint(gfx::Canvas* canvas) {
   TRACE_EVENT1("views", "View::OnPaint", "class", GetClassName());
   OnPaintBackground(canvas);
   OnPaintBorder(canvas);
 }
 
 void View::OnPaintBackground(gfx::Canvas* canvas) {
   if (background_.get()) {
@@ skipping 82 matching lines @@
   } else {
     internal::ScopedChildrenLock lock(this);
     for (auto* child : children_) {
       child->UpdateChildLayerBounds(
           offset + gfx::Vector2d(child->GetMirroredX(), child->y()));
     }
   }
 }
 
 void View::OnPaintLayer(const ui::PaintContext& context) {
-  Paint(context);
+  PaintRoot(context);
 }
 
 void View::OnDelegatedFrameDamage(
     const gfx::Rect& damage_rect_in_dip) {
 }
 
 void View::OnDeviceScaleFactorChanged(float device_scale_factor) {
   snap_layer_to_pixel_boundary_ =
       (device_scale_factor - std::floor(device_scale_factor)) != 0.0f;
   SnapLayerToPixelBoundary();
@@ skipping 572 matching lines @@
 }
 
 bool View::ConvertRectFromAncestor(const View* ancestor,
                                    gfx::RectF* rect) const {
   gfx::Transform trans;
   bool result = GetTransformRelativeTo(ancestor, &trans);
   trans.TransformRectReverse(rect);
   return result;
 }
 
+// Painting --------------------------------------------------------------------
+
+bool View::ShouldPaint() const {
+  return visible_ && !size().IsEmpty();
+}
+
+gfx::Vector2d View::GetPaintContextOffset() 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();
+}
+
+void View::SetupTransformRecorderForPainting(
+    ui::TransformRecorder* recorder) 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();
+  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::PaintRoot(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::TransformRecorder transform_recorder(context);
+  SetupTransformRecorderForPainting(&transform_recorder);
+
+  RecursivePaintHelper(&View::PaintDebugRects, context);
+
+  // Draw outline rects for debugging.
+  ui::PaintRecorder recorder(context, size());
+  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);
+}
+
 // Accelerated painting --------------------------------------------------------
 
 void View::CreateLayer(ui::LayerType layer_type) {
   // A new layer is being created for the view. So all the layers of the
   // sub-tree can inherit the visibility of the corresponding view.
   {
     internal::ScopedChildrenLock lock(this);
     for (auto* child : children_)
       child->UpdateChildLayerVisibility(true);
   }
@@ skipping 328 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