views: Remove View::PaintCommon, merge it into View::Paint.

This unifies the painting code path between Views that are and are not
backed by layers, they all go through View::Paint now.

View::Paint will only translate the canvas relative to the parent when
layer() is false, keeping the origin at the origin of the view when it
is backed by a layer().

R=sky
BUG=466426

Review URL: https://codereview.chromium.org/1035833002

Cr-Commit-Position: refs/heads/master@{#322394}

ui/views/view.cc

@@ -775,9 +775,11 @@ void View::Paint(gfx::Canvas* canvas, const CullSet& cull_set) {
 
   gfx::ScopedCanvas scoped_canvas(canvas);
 
-  // Paint this View and its children, setting the clip rect to the bounds
-  // of this View and translating the origin to the local bounds' top left
-  // point.
+  // 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
@@ -794,10 +796,37 @@ void View::Paint(gfx::Canvas* canvas, const CullSet& cull_set) {
     // this view is located (related to its parent).
     canvas->Translate(GetMirroredPosition().OffsetFromOrigin());
     canvas->Transform(GetTransform());
+  }
 
-  // If we are a paint root, we need to construct our own CullSet object for
-  // propagation to our children.
-  if (IsPaintRoot()) {
+  {
+    // 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);
+  }
+
+  // If the view is not a paint root, it should come with a CullSet already
+  // constructed for use.
+  // TODO(danakj): However, if it is a paint root but is also backed by a
+  // layer(), we are unable to construct a CullSet because the bounds() do not
+  // match the position we will be painting at and UpdateRootBounds() does the
+  // wrong thing.
+  if (!IsPaintRoot() || layer()) {
+    PaintChildren(canvas, cull_set);
+    return;
+  }
+
+  // We are a paint root, so we construct our own CullSet object for propagation
+  // to our children.
   if (!bounds_tree_)
     bounds_tree_.reset(new BoundsTree(2, 5));
 
@@ -806,25 +835,16 @@ void View::Paint(gfx::Canvas* canvas, const CullSet& cull_set) {
 
   // Grab the clip rect from the supplied canvas to use as the query rect.
   gfx::Rect canvas_bounds;
-    if (!canvas->GetClipBounds(&canvas_bounds)) {
-      NOTREACHED() << "Failed to get clip bounds from the canvas!";
-      return;
-    }
+  bool got_clip = canvas->GetClipBounds(&canvas_bounds);
+  DCHECK(got_clip) << "Failed to get clip bounds from the canvas!";
 
   // Now query our bounds_tree_ for a set of damaged views that intersect
   // our canvas bounds.
   scoped_ptr<base::hash_set<intptr_t>> damaged_views(
-        new base::hash_set<intptr_t>());
+      new base::hash_set<intptr_t>);
   bounds_tree_->AppendIntersectingRecords(canvas_bounds, damaged_views.get());
-    // Construct a CullSet to wrap the damaged views set, it will delete it
-    // for us on scope exit.
   CullSet paint_root_cull_set(damaged_views.Pass());
-    // Paint all descendents using our new cull set.
-    PaintCommon(canvas, paint_root_cull_set);
-  } else {
-    // Not a paint root, so we can proceed as normal.
-    PaintCommon(canvas, cull_set);
-  }
+  PaintChildren(canvas, paint_root_cull_set);
 }
 
 void View::set_background(Background* b) {
@@ -1464,11 +1484,11 @@ void View::UpdateChildLayerBounds(const gfx::Vector2d& offset) {
 }
 
 void View::OnPaintLayer(gfx::Canvas* canvas) {
-  if (!layer() || !layer()->fills_bounds_opaquely())
+  if (!layer()->fills_bounds_opaquely())
     canvas->DrawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
   if (!visible_)
     return;
-  PaintCommon(canvas, CullSet());
+  Paint(canvas, CullSet());
 }
 
 void View::OnDelegatedFrameDamage(
@@ -1751,25 +1771,6 @@ void View::SchedulePaintBoundsChanged(SchedulePaintType type) {
   }
 }
 
-void View::PaintCommon(gfx::Canvas* canvas, const CullSet& cull_set) {
-  {
-    // 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);
-    }
-
-    OnPaint(canvas);
-  }
-
-  PaintChildren(canvas, cull_set);
-}
-
 // Tree operations -------------------------------------------------------------
 
 void View::DoRemoveChildView(View* view,

ui/views/view.h

@@ -1244,10 +1244,6 @@ class VIEWS_EXPORT View : public ui::LayerDelegate,
   // 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, const CullSet& cull_set);
-
   // Tree operations -----------------------------------------------------------
 
   // Removes |view| from the hierarchy tree.  If |update_focus_cycle| is true,