Make View::Paint use ui::PaintRecorder to access PaintContext's canvas

ui/aura/window.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.
 
 #include "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 12 matching lines @@
 #include "ui/aura/client/window_stacking_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/paint_context.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 namespace {
 
@@ skipping 909 matching lines @@
   if (delegate_)
     delegate_->OnWindowTargetVisibilityChanged(visible);
 
   NotifyWindowVisibilityChanged(this, visible);
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
-void Window::Paint(gfx::Canvas* canvas) {
+void Window::Paint(const ui::PaintContext& context) {
   if (delegate_)
-    delegate_->OnPaint(canvas);
-  PaintLayerlessChildren(canvas);
+    delegate_->OnPaint(context);
+  PaintLayerlessChildren(context);
 }
 
-void Window::PaintLayerlessChildren(gfx::Canvas* canvas) {
+void Window::PaintLayerlessChildren(const ui::PaintContext& context) {
   for (size_t i = 0, count = children_.size(); i < count; ++i) {
     Window* child = children_[i];
     if (!child->layer() && child->visible_) {
+      gfx::Canvas* canvas = context.canvas();
       gfx::ScopedCanvas scoped_canvas(canvas);
       canvas->ClipRect(child->bounds());
       if (!canvas->IsClipEmpty()) {
         canvas->Translate(child->bounds().OffsetFromOrigin());
-        child->Paint(canvas);
+        child->Paint(context);
       }
     }
   }
 }
 
 Window* Window::GetWindowForPoint(const gfx::Point& local_point,
                                   bool return_tightest,
                                   bool for_event_handling) {
   if (!IsVisible())
     return NULL;
@@ skipping 383 matching lines @@
   state_modified |=
       ui::GestureRecognizer::Get()->CleanupStateForConsumer(this);
   for (Window::Windows::iterator iter = children_.begin();
        iter != children_.end();
        ++iter) {
     state_modified |= (*iter)->CleanupGestureState();
   }
   return state_modified;
 }
 
-void Window::OnPaintLayer(gfx::Canvas* canvas) {
-  Paint(canvas);
+void Window::OnPaintLayer(const ui::PaintContext& context) {
+  Paint(context);
 }
 
 void Window::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
   DCHECK(layer());
   FOR_EACH_OBSERVER(WindowObserver,
                     observers_,
                     OnDelegatedFrameDamage(this, damage_rect_in_dip));
 }
 
 base::Closure Window::PrepareForLayerBoundsChange() {
@@ skipping 72 matching lines @@
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura