Make View::Paint use ui::PaintRecorder to access PaintContext's 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>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
+#include "ui/compositor/paint_context.h"
+#include "ui/compositor/paint_recorder.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
@@ skipping 688 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 PaintContext& parent_context) {
+void View::Paint(const ui::PaintContext& parent_context) {
   if (!visible_)
     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_IMPLIES(!parent(), bounds().origin() == gfx::Point());
     offset_to_parent = GetMirroredPosition().OffsetFromOrigin();
   }
-  PaintContext context = parent_context.CloneWithPaintOffset(offset_to_parent);
+  ui::PaintContext context =
+      parent_context.CloneWithPaintOffset(offset_to_parent);
 
   if (context.CanCheckInvalidated()) {
 #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();
     }
     // 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.
     if (!context.IsRectInvalidated(GetLocalBounds()))
       return;
   }
 
   TRACE_EVENT1("views", "View::Paint", "class", GetClassName());
 
-  gfx::Canvas* canvas = context.canvas();
-  gfx::ScopedCanvas scoped_canvas(canvas);
-
   // If the view is backed by a layer, it should paint with itself as the origin
   // rather than relative to its parent.
-  if (!layer()) {
-    // Set the clip rect to the bounds of this View and translating the origin
-    // to the local bounds' top left point.
-    //
-    // Note that the X (or left) position we pass to ClipRectInt takes into
-    // consideration whether or not the view uses a right-to-left layout so that
-    // we paint our view in its mirrored position if need be.
+  bool paint_relative_to_parent = !layer();
+  if (paint_relative_to_parent) {
+    // Set the clip rect to the bounds of this View. 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.
+    ui::PaintRecorder recorder(context);
+    gfx::Canvas* canvas = recorder.canvas();
+    canvas->Save();
+
     gfx::Rect clip_rect = bounds();
     clip_rect.Inset(clip_insets_);
     if (parent_)
       clip_rect.set_x(parent_->GetMirroredXForRect(clip_rect));
     canvas->ClipRect(clip_rect);
-    if (canvas->IsClipEmpty())
-      return;
 
-    // Non-empty clip, translate the graphics such that 0,0 corresponds to where
-    // this view is located (related to its parent).
+    // Translate the graphics such that 0,0 corresponds to where
+    // this View is located relative to its parent.
     canvas->Translate(GetMirroredPosition().OffsetFromOrigin());
     canvas->Transform(GetTransform());
   }
 
   {
+    ui::PaintRecorder recorder(context);
+    gfx::Canvas* canvas = recorder.canvas();
+    gfx::ScopedCanvas scoped_canvas(canvas);
+
     // If the View we are about to paint requested the canvas to be flipped, we
     // should change the transform appropriately.
     // The canvas mirroring is undone once the View is done painting so that we
     // don't pass the canvas with the mirrored transform to Views that didn't
     // request the canvas to be flipped.
-    gfx::ScopedCanvas scoped(canvas);
     if (FlipCanvasOnPaintForRTLUI()) {
       canvas->Translate(gfx::Vector2d(width(), 0));
       canvas->Scale(-1, 1);
     }
 
     // Delegate painting the contents of the View to the virtual OnPaint method.
     OnPaint(canvas);
   }
 
+  // View::Paint recursion over the subtree.
   PaintChildren(context);
+
+  if (paint_relative_to_parent) {
+    ui::PaintRecorder recorder(context);

[sky, 2015/04/02 23:43:09]

Why do you need this logic?

[danakj, 2015/04/03 00:27:36]

This matches the save on l.788. We can't use ScopedCanvas because recordings can
not be nested.

[sky, 2015/04/03 14:53:59]

Tricky, but error prone. How about a scoped_ptr<ScopedCanvas> defined on 780,
but set on 786 (where you have it now). I believe that would mean you can nuke
824-827.

[danakj, 2015/04/03 16:15:35]

The Canvas* here and at l786 are going to be different. Each scope of
PaintRecorder will have a different Canvas*.

One thing we could do is use a new RAII object that points at the paint context,
and makes a PaintRecorder and save/restores into it. But we need to cache the
display items in the correct order.. I think to do that, we need a longer lived
RAII object outside the scope of each PaintRecorder, and a ScopedSaveRestore
points at that. Nesting gets trickier than.

I agree it's more tricky with save/restore not on scope, but solutions around
this seem more complex than the problem. The issue is that the save and restore
have to be separate displayitems because there will be other displayitems in
between from children.

+    recorder.canvas()->Restore();
+  }
 }
 
 void View::set_background(Background* b) {
   background_.reset(b);
 }
 
 void View::SetBorder(scoped_ptr<Border> b) { border_ = b.Pass(); }
 
 ui::ThemeProvider* View::GetThemeProvider() const {
   const Widget* widget = GetWidget();
@@ skipping 504 matching lines @@
   if (accelerator_focus_manager_ != focus_manager) {
     UnregisterAccelerators(true);
 
     if (focus_manager)
       RegisterPendingAccelerators();
   }
 }
 
 // Painting --------------------------------------------------------------------
 
-void View::PaintChildren(const PaintContext& context) {
+void View::PaintChildren(const ui::PaintContext& context) {
   TRACE_EVENT1("views", "View::PaintChildren", "class", GetClassName());
   for (int i = 0, count = child_count(); i < count; ++i)
     if (!child_at(i)->layer())
       child_at(i)->Paint(context);
 }
 
 void View::OnPaint(gfx::Canvas* canvas) {
   TRACE_EVENT1("views", "View::OnPaint", "class", GetClassName());
   OnPaintBackground(canvas);
   OnPaintBorder(canvas);
@@ skipping 89 matching lines @@
     SetLayerBounds(GetLocalBounds() + offset);
   } else {
     for (int i = 0, count = child_count(); i < count; ++i) {
       View* child = child_at(i);
       child->UpdateChildLayerBounds(
           offset + gfx::Vector2d(child->GetMirroredX(), child->y()));
     }
   }
 }
 
-void View::OnPaintLayer(gfx::Canvas* canvas) {
+void View::OnPaintLayer(const ui::PaintContext& context) {
   if (!layer()->fills_bounds_opaquely())
-    canvas->DrawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
+    context.canvas()->DrawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
   if (!visible_)
     return;
-  Paint(PaintContext(canvas, layer()->PaintRect()));
+  Paint(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 890 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