ui: Cache the output of View::OnPaint when the View isn't invalid.

ui/compositor/paint_context.h

 // Copyright 2015 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_COMPOSITOR_PAINT_CONTEXT_H_
 #define UI_COMPOSITOR_PAINT_CONTEXT_H_
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/compositor/compositor_export.h"
@@ skipping 38 matching lines @@
   // Clone a PaintContext with an additional |offset|.
   PaintContext CloneWithPaintOffset(const gfx::Vector2d& offset) const {
     return PaintContext(*this, offset);
   }
 
   // Clone a PaintContext that has no consideration for invalidation.
   PaintContext CloneWithoutInvalidation() const {
     return PaintContext(canvas_);
   }
 
-  // When true, IsRectInvalidated() can be called, otherwise its result would be
+  // When true, IsRectInvalid() can be called, otherwise its result would be
   // invalid.
-  bool CanCheckInvalidated() const { return !invalidation_.IsEmpty(); }
+  bool CanCheckInvalid() const { return !invalidation_.IsEmpty(); }
+
+  // When true, if a thing is not invalidated it does not need to paint itself.
+  // When false, everything should provide an output when painting regardless of
+  // being invalidated in order to remain visible.
+  bool EarlyOutOfPaintingWhenValid() const { return !!canvas_; }

[sky, 2015/04/23 16:43:31]

Nit: ShouldEarlyOut...?

[danakj, 2015/04/23 16:46:14]

Ya!

 
   // 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());
+  bool IsRectInvalid(const gfx::Rect& bounds) const {
+    DCHECK(CanCheckInvalid());
     return invalidation_.Intersects(bounds + offset_);
   }
 
 #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
 
   const gfx::Rect& InvalidationForTesting() const { return invalidation_; }
 
  private:
   // The Recorder classes need access to the internal canvas and friends, but we
   // don't want to expose them on this class so that people must go through the
   // recorders to access them.
   friend class ClipTransformRecorder;
   friend class CompositingRecorder;
   friend class PaintRecorder;
+  // The Cache class also needs to access the DisplayItemList to append its
+  // cache contents.
+  friend class PaintCache;
 
   PaintContext& operator=(const PaintContext& other) = delete;
 
   // Clone a PaintContext with an additional |offset|.
   PaintContext(const PaintContext& other, const gfx::Vector2d& offset);
 
   gfx::Canvas* canvas_;
   cc::DisplayItemList* list_;
   scoped_ptr<SkPictureRecorder> recorder_;
   // The device scale of the frame being painted. Used to determine which bitmap
@@ skipping 15 matching lines @@
   mutable void* root_visited_;
   // Used to verify that paint recorders are not nested. True while a paint
   // recorder is active.
   mutable bool inside_paint_recorder_;
 #endif
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_PAINT_CONTEXT_H_