Make View::Paint use ui::PaintRecorder to access PaintContext's canvas

ui/views/view.h

 // 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.
 
 #ifndef UI_VIEWS_VIEW_H_
 #define UI_VIEWS_VIEW_H_
 
 #include <algorithm>
 #include <map>
 #include <set>
@@ skipping 33 matching lines @@
 class Insets;
 class Path;
 class Transform;
 }
 
 namespace ui {
 struct AXViewState;
 class Compositor;
 class Layer;
 class NativeTheme;
+class PaintContext;
 class TextInputClient;
 class Texture;
 class ThemeProvider;
 }
 
 namespace views {
 
 class Background;
 class Border;
 class ContextMenuController;
@@ skipping 420 matching lines @@
 
   // Mark all or part of the View's bounds as dirty (needing repaint).
   // |r| is in the View's coordinates.
   // Rectangle |r| should be in the view's coordinate system. The
   // transformations are applied to it to convert it into the parent coordinate
   // system before propagating SchedulePaint up the view hierarchy.
   // TODO(beng): Make protected.
   virtual void SchedulePaint();
   virtual void SchedulePaintInRect(const gfx::Rect& r);
 
-  class PaintContext {
-   public:
-    explicit PaintContext(gfx::Canvas* canvas)
-        : PaintContext(canvas, gfx::Rect()) {}
-    PaintContext(gfx::Canvas* canvas, const gfx::Rect& invalidation)
-        : canvas_(canvas), invalidation_(invalidation) {
-#if DCHECK_IS_ON()
-      root_visited_ = nullptr;
-#endif
-    }
-
-    // TODO(danakj): Remove this once everything is painting to display lists.
-    gfx::Canvas* canvas() const { return canvas_; }
-
-    bool CanCheckInvalidated() const { return !invalidation_.IsEmpty(); }
-
-    // When true, the |bounds| touches an invalidated area, so should be
-    // re-painted. When false, re-painting can be skipped. Bounds should be in
-    // the local space with offsets up to the painting root in the PaintContext.
-    bool IsRectInvalidated(const gfx::Rect& bounds) const {
-      DCHECK(CanCheckInvalidated());
-      return invalidation_.Intersects(bounds + offset_);
-    }
-
-    PaintContext CloneWithPaintOffset(const gfx::Vector2d& offset) const {
-      return PaintContext(*this, offset);
-    }
-
-    PaintContext CloneWithoutInvalidation() const {
-      return PaintContext(canvas_, gfx::Rect());
-    }
-
-#if DCHECK_IS_ON()
-    void Visited(void* visited) const {
-      if (!root_visited_)
-        root_visited_ = visited;
-    }
-    void* RootVisited() const { return root_visited_; }
-    const gfx::Vector2d& PaintOffset() const { return offset_; }
-#endif
-
-   private:
-    PaintContext(const PaintContext& other, const gfx::Vector2d& offset)
-        : canvas_(other.canvas_),
-          invalidation_(other.invalidation_),
-          offset_(other.offset_ + offset) {
-#if DCHECK_IS_ON()
-      root_visited_ = other.root_visited_;
-#endif
-    }
-
-    gfx::Canvas* canvas_;
-    // Invalidation in the space of the paint root (ie the space of the layer
-    // backing the paint taking place).
-    gfx::Rect invalidation_;
-    // Offset from the PaintContext to the space of the paint root and the
-    // |invalidation_|.
-    gfx::Vector2d offset_;
-
-#if DCHECK_IS_ON()
-    // Used to verify that the |invalidation_| is only used to compare against
-    // rects in the same space.
-    mutable void* root_visited_;
-#endif
-  };
-
   // Called by the framework to paint a View. Performs translation and clipping
   // for View coordinates and language direction as required, allows the View
   // to paint itself via the various OnPaint*() event handlers and then paints
   // the hierarchy beneath it.
-  void Paint(const PaintContext& parent_context);
+  void Paint(const ui::PaintContext& parent_context);
 
   // The background object is owned by this object and may be NULL.
   void set_background(Background* b);
   const Background* background() const { return background_.get(); }
   Background* background() { return background_.get(); }
 
   // The border object is owned by this object and may be NULL.
   virtual void SetBorder(scoped_ptr<Border> b);
   const Border* border() const { return border_.get(); }
   Border* border() { return border_.get(); }
@@ skipping 555 matching lines @@
   // ViewHierarchyChanged() is called when the parent NativeView of the widget
   // that the view is attached to is changed as a result of changing the view
   // hierarchy. Overriding this method is useful for tracking which
   // FocusManager manages this view.
   virtual void NativeViewHierarchyChanged();
 
   // Painting ------------------------------------------------------------------
 
   // Responsible for calling Paint() on child Views. Override to control the
   // order child Views are painted.
-  virtual void PaintChildren(const PaintContext& context);
+  virtual void PaintChildren(const ui::PaintContext& context);
 
   // Override to provide rendering in any part of the View's bounds. Typically
   // this is the "contents" of the view. If you override this method you will
   // have to call the subsequent OnPaint*() methods manually.
   virtual void OnPaint(gfx::Canvas* canvas);
 
   // Override to paint a background before any content is drawn. Typically this
   // is done if you are satisfied with a default OnPaint handler but wish to
   // supply a different background.
   virtual void OnPaintBackground(gfx::Canvas* canvas);
@@ skipping 18 matching lines @@
   // recurses through all children. This is used when adding a layer to an
   // existing view to make sure all descendants that have layers are parented to
   // the right layer.
   void MoveLayerToParent(ui::Layer* parent_layer, const gfx::Point& point);
 
   // Called to update the bounds of any child layers within this View's
   // hierarchy when something happens to the hierarchy.
   void UpdateChildLayerBounds(const gfx::Vector2d& offset);
 
   // Overridden from ui::LayerDelegate:
-  void OnPaintLayer(gfx::Canvas* canvas) override;
+  void OnPaintLayer(const ui::PaintContext& context) override;
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override;
   void OnDeviceScaleFactorChanged(float device_scale_factor) override;
   base::Closure PrepareForLayerBoundsChange() override;
 
   // Finds the layer that this view paints to (it may belong to an ancestor
   // view), then reorders the immediate children of that layer to match the
   // order of the view tree.
   virtual void ReorderLayers();
 
   // This reorders the immediate children of |*parent_layer| to match the
@@ skipping 439 matching lines @@
   // Belongs to this view, but it's reference-counted on some platforms
   // so we can't use a scoped_ptr. It's dereferenced in the destructor.
   NativeViewAccessibility* native_view_accessibility_;
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_VIEW_H_