patch from issue 218843002

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>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer_delegate.h"
 #include "ui/compositor/layer_owner.h"
 #include "ui/events/event.h"
 #include "ui/events/event_target.h"
 #include "ui/events/event_targeter.h"
+#include "ui/gfx/geometry/r_tree.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
+#include "ui/views/cull_set.h"
 #include "ui/views/views_export.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_comptr.h"
 #endif
 
 using ui::OSExchangeData;
 
 namespace gfx {
 class Canvas;
@@ skipping 451 matching lines @@
   // 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);
 
   // 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.
-  virtual void Paint(gfx::Canvas* canvas);
+  virtual void Paint(gfx::Canvas* canvas, const CullSet& cull_set);
 
   // 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 553 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(gfx::Canvas* canvas);
+  virtual void PaintChildren(gfx::Canvas* canvas, const CullSet& cull_set);
 
   // 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);
 
   // Override to paint a border not specified by SetBorder().
   virtual void OnPaintBorder(gfx::Canvas* canvas);
 
+  // Returns true if this View is the root for paint events, and should
+  // therefore maintain a |bounds_tree_| member and use it for paint damage rect
+  // calculations.
+  virtual bool IsPaintRoot();
+
   // Accelerated painting ------------------------------------------------------
 
   // Returns the offset from this view to the nearest ancestor with a layer. If
   // |layer_parent| is non-NULL it is set to the nearest ancestor with a layer.
   virtual gfx::Vector2d CalculateOffsetToAncestorWithLayer(
       ui::Layer** layer_parent);
 
   // Updates the view's layer's parent. Called when a view is added to a view
   // hierarchy, responsible for parenting the view's layer to the enclosing
   // layer in the hierarchy.
@@ skipping 140 matching lines @@
     // Indicates the size changed (and possibly the origin).
     SCHEDULE_PAINT_SIZE_CHANGED
   };
 
   // Invoked before and after the bounds change to schedule painting the old and
   // new bounds.
   void SchedulePaintBoundsChanged(SchedulePaintType type);
 
   // Common Paint() code shared by accelerated and non-accelerated code paths to
   // invoke OnPaint() on the View.
-  void PaintCommon(gfx::Canvas* canvas);
+  void PaintCommon(gfx::Canvas* canvas, const CullSet& cull_set);
 
   // Tree operations -----------------------------------------------------------
 
   // Removes |view| from the hierarchy tree.  If |update_focus_cycle| is true,
   // the next and previous focusable views of views pointing to this view are
   // updated.  If |update_tool_tip| is true, the tooltip is updated.  If
   // |delete_removed_view| is true, the view is also deleted (if it is parent
   // owned).  If |new_parent| is not NULL, the remove is the result of
   // AddChildView() to a new parent.  For this case, |new_parent| is the View
   // that |view| is going to be added to after the remove completes.
@@ skipping 48 matching lines @@
   void UnregisterForVisibleBoundsNotification();
 
   // Adds/removes view to the list of descendants that are notified any time
   // this views location and possibly size are changed.
   void AddDescendantToNotify(View* view);
   void RemoveDescendantToNotify(View* view);
 
   // Sets the layer's bounds given in DIP coordinates.
   void SetLayerBounds(const gfx::Rect& bounds_in_dip);
 
+  // Sets the bit indicating that the cached bounds for this object within the
+  // root view bounds tree are no longer valid. If |origin_changed| is true sets
+  // the same bit for all of our children as well.
+  void SetRootBoundsDirty(bool origin_changed);
+
+  // If needed, updates the bounds rectangle in paint root coordinate space
+  // in the supplied RTree. Recurses to children for recomputation as well.
+  void UpdateRootBounds(gfx::RTree* bounds_tree, const gfx::Vector2d& offset);
+
+  // Remove self and all children from the supplied bounds tree. This is used,
+  // for example, when a view gets a layer and therefore becomes paint root. It
+  // needs to remove all references to itself and its children from any previous
+  // paint root that may have been tracking it.
+  void RemoveRootBounds(gfx::RTree* bounds_tree);
+
+  // Traverse up the View hierarchy to the first ancestor that is a paint root
+  // and return a pointer to its |bounds_tree_| or NULL if no tree is found.
+  gfx::RTree* GetBoundsTreeFromPaintRoot();
+
   // Transformations -----------------------------------------------------------
 
   // Returns in |transform| the transform to get from coordinates of |ancestor|
   // to this. Returns true if |ancestor| is found. If |ancestor| is not found,
   // or NULL, |transform| is set to convert from root view coordinates to this.
   bool GetTransformRelativeTo(const View* ancestor,
                               gfx::Transform* transform) const;
 
   // Coordinate conversion -----------------------------------------------------
 
@@ skipping 152 matching lines @@
   // This flag is initialized to false.
   bool notify_enter_exit_on_child_;
 
   // Whether or not RegisterViewForVisibleBoundsNotification on the RootView
   // has been invoked.
   bool registered_for_visible_bounds_notification_;
 
   // List of descendants wanting notification when their visible bounds change.
   scoped_ptr<Views> descendants_to_notify_;
 
+  // True if the bounds on this object have changed since the last time the
+  // paint root view constructed the spatial database.
+  bool root_bounds_dirty_;
+
+  // If this View IsPaintRoot() then this will be a pointer to a spatial data
+  // structure where we will keep the bounding boxes of all our children, for
+  // efficient paint damage rectangle intersection.
+  scoped_ptr<gfx::RTree> bounds_tree_;
+
   // Transformations -----------------------------------------------------------
 
   // Clipping parameters. skia transformation matrix does not give us clipping.
   // So we do it ourselves.
   gfx::Insets clip_insets_;
 
   // Layout --------------------------------------------------------------------
 
   // Whether the view needs to be laid out.
   bool needs_layout_;
@@ skipping 66 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_