Further plumb visual rect into cc:DisplayItemList.

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>
@@ skipping 759 matching lines @@
 
     // If the View wasn't invalidated, don't waste time painting it, the output
     // would be culled.
     is_invalidated = context.IsRectInvalid(GetLocalBounds());
   }
 
   TRACE_EVENT1("views", "View::Paint", "class", GetClassName());
 
   // If the view is backed by a layer, it should paint with itself as the origin
   // rather than relative to its parent.
-  ui::ClipTransformRecorder clip_transform_recorder(context);
+  ui::ClipTransformRecorder clip_transform_recorder(context, size());
   if (!layer()) {
     // 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.
     gfx::Rect clip_rect_in_parent = bounds();
     clip_rect_in_parent.Inset(clip_insets_);
     if (parent_)
       clip_rect_in_parent.set_x(
           parent_->GetMirroredXForRect(clip_rect_in_parent));
     clip_transform_recorder.ClipRect(clip_rect_in_parent);
 
     // Translate the graphics such that 0,0 corresponds to where
     // this View is located relative to its parent.
     gfx::Transform transform_from_parent;
     gfx::Vector2d offset_from_parent = GetMirroredPosition().OffsetFromOrigin();
     transform_from_parent.Translate(offset_from_parent.x(),
                                     offset_from_parent.y());
     transform_from_parent.PreconcatTransform(GetTransform());
     clip_transform_recorder.Transform(transform_from_parent);
   }
 
   if (is_invalidated || !paint_cache_.UseCache(context)) {

[danakj, 2015/11/17 22:14:33]

The thing that's going to be weird is that if the view moves around, it will use
the cache, but it cached a different layer bounds. So it's going to be wrong.

Maybe this works out today because we do invalidation by rects, and we probably
invalidate when things move. This would be less true if we invalidated based on
the /contents/ of the view, except now the contents include a visible rect.

How is blink handling this? Does it invalidate its cache of display items when
they move?

Alternately, UseCache() could take a size(), and it could change the bounds on
the cached item when it appends it.

     ui::PaintRecorder recorder(context, size(), &paint_cache_);
     gfx::Canvas* canvas = recorder.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.
     if (FlipCanvasOnPaintForRTLUI()) {
       canvas->Translate(gfx::Vector2d(width(), 0));
@@ skipping 1540 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