Implements core logic for Pixel 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 <stddef.h>
 
 #include <algorithm>
@@ skipping 19 matching lines @@
 #include "ui/compositor/layer_owner.h"
 #include "ui/compositor/paint_cache.h"
 #include "ui/events/event.h"
 #include "ui/events/event_target.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/path.h"
+#include "ui/views/paint_info.h"
 #include "ui/views/view_targeter.h"
 #include "ui/views/views_export.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_comptr.h"
 #endif
 
 using ui::OSExchangeData;
 
 namespace gfx {
@@ skipping 486 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.
   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.
-  void Paint(const ui::PaintContext& parent_context);
+  void Paint(const PaintInfo& parent_paint_info);
 
   // The background object may be null.
   void SetBackground(std::unique_ptr<Background> b);
   const Background* background() const { return background_.get(); }
   Background* background() { return background_.get(); }
 
   // The border object may be null.
   virtual void SetBorder(std::unique_ptr<Border> b);
   const Border* border() const { return border_.get(); }
   Border* border() { return border_.get(); }
@@ skipping 588 matching lines @@
   virtual void AddedToWidget();
 
   // This method is invoked for a view when it is removed from a hierarchy with
   // a widget or moved to a different widget.
   virtual void RemovedFromWidget();
 
   // Painting ------------------------------------------------------------------
 
   // Responsible for calling Paint() on child Views. Override to control the
   // order child Views are painted.
-  virtual void PaintChildren(const ui::PaintContext& context);
+  virtual void PaintChildren(const PaintInfo& info);
 
   // 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 98 matching lines @@
   static int GetHorizontalDragThreshold();
   static int GetVerticalDragThreshold();
 
   // NativeTheme ---------------------------------------------------------------
 
   // Invoked when the NativeTheme associated with this View changes, including
   // when one first becomes available (after the view is added to a widget
   // hierarchy).
   virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) {}
 
+  // Pixel Canvas --------------------------------------------------------------
+
+  // Returns the type of scaling to be done for this View. Values should be from
+  // PaintInfo::ScaleType.

[sky, 2017/07/26 22:12:12]

Remove second sentence as this is obvious given the return type.

[malaykeshav, 2017/07/28 01:24:38]

Done

+  virtual PaintInfo::ScaleType GetPaintScaleType() const;

[sky, 2017/07/26 22:12:12]

Move this up with the other painting functions. Say line 1170.

[sky, 2017/07/26 22:12:12]

Are we really going to have different scale types for different views? Wouldn't
we do the same scale type for all views?

[malaykeshav, 2017/07/28 01:24:38]

All except the ones that don't want any distortion in scaling. Specifically the
images and icons. There may be other cases as well where we do not want any
distorted scaling.

[malaykeshav, 2017/07/28 01:24:38]

Done.

+
   // Debugging -----------------------------------------------------------------
 
 #if !defined(NDEBUG)
   // Returns string containing a graph of the views hierarchy in graphViz DOT
   // language (http://graphviz.org/). Can be called within debugger and save
   // to a file to compile/view.
   // Note: Assumes initial call made with first = true.
   virtual std::string PrintViewGraph(bool first);
 
   // Some classes may own an object which contains the children to displayed in
   // the views hierarchy. The above function gives the class the flexibility to
   // decide which object should be used to obtain the children, but this
   // function makes the decision explicit.
   std::string DoPrintViewGraph(bool first, View* view_with_children);
 #endif
 
  private:
   friend class internal::PreEventDispatchHandler;
   friend class internal::PostEventDispatchHandler;
   friend class internal::RootView;
   friend class internal::ScopedChildrenLock;
   friend class FocusManager;
   friend class ViewLayerTest;
   friend class Widget;
 
+  FRIEND_TEST_ALL_PREFIXES(ViewTest, PaintWithMovedViewUsesCache);
+  FRIEND_TEST_ALL_PREFIXES(ViewTest, PaintWithMovedViewUsesCacheInRTL);
+  FRIEND_TEST_ALL_PREFIXES(ViewTest, PaintWithUnknownInvalidation);
+
   // Painting  -----------------------------------------------------------------
 
   enum SchedulePaintType {
     // Indicates the size is the same (only the origin changed).
     SCHEDULE_PAINT_SIZE_SAME,
 
     // 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);
 
   // Schedules a paint on the parent View if it exists.
   void SchedulePaintOnParent();
 
   // Returns whether this view is eligible for painting, i.e. is visible and
   // nonempty.  Note that this does not behave like IsDrawn(), since it doesn't
   // check ancestors recursively; rather, it's used to prune subtrees of views
   // during painting.
   bool ShouldPaint() const;
 
-  // Returns the offset that should be used when constructing the paint context
+  // Returns the bounds that should be used when constructing the |PaintInfo|
   // for this view.
-  gfx::Vector2d GetPaintContextOffset() const;
+  gfx::Rect GetPaintRecordingBounds() const;
 
   // Adjusts the transform of |recorder| in advance of painting.
-  void SetupTransformRecorderForPainting(ui::TransformRecorder* recorder) const;
+  void SetupTransformRecorderForPainting(
+      ui::TransformRecorder* recorder,
+      const gfx::Vector2d& offset_from_parent) const;
 
   // Recursively calls the painting method |func| on all non-layered children,
   // in Z order.
-  void RecursivePaintHelper(void (View::*func)(const ui::PaintContext&),
-                            const ui::PaintContext& context);
+  void RecursivePaintHelper(void (View::*func)(const PaintInfo&),
+                            const PaintInfo& info);
 
   // Invokes Paint() and, if necessary, PaintDebugRects().  Should be called
   // only on the root of a widget/layer.  PaintDebugRects() is invoked as a
   // separate pass, instead of being rolled into Paint(), so that siblings will
   // not obscure debug rects.
   void PaintFromPaintRoot(const ui::PaintContext& parent_context);
 
   // Draws a semitransparent rect to indicate the bounds of this view.
   // Recursively does the same for all children.  Invoked only with
   // --draw-view-bounds-rects.
-  void PaintDebugRects(const ui::PaintContext& parent_context);
+  void PaintDebugRects(const PaintInfo& paint_info);
 
   // 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 358 matching lines @@
   // Observers -------------------------------------------------------------
 
   base::ObserverList<ViewObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_VIEW_H_