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

ui/compositor/layer_unittest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/test/pixel_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
+#include "ui/compositor/paint_context.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
 #include "ui/compositor/test/test_compositor_host.h"
 #include "ui/compositor/test/test_layers.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/gfx_paths.h"
 #include "ui/gfx/skia_util.h"
 
 using cc::MatchesPNGFile;
@@ skipping 15 matching lines @@
  public:
   explicit ColoredLayer(SkColor color)
       : Layer(LAYER_TEXTURED),
         color_(color) {
     set_delegate(this);
   }
 
   ~ColoredLayer() override {}
 
   // Overridden from LayerDelegate:
-  void OnPaintLayer(gfx::Canvas* canvas) override { canvas->DrawColor(color_); }
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    context.canvas()->DrawColor(color_);
+  }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
   base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
  private:
@@ skipping 142 matching lines @@
     colors_.push_back(color);
   }
 
   int color_index() const { return color_index_; }
 
   float device_scale_factor() const {
     return device_scale_factor_;
   }
 
   // Overridden from LayerDelegate:
-  void OnPaintLayer(gfx::Canvas* canvas) override {
-    canvas->DrawColor(colors_[color_index_]);
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    context.canvas()->DrawColor(colors_[color_index_]);
     color_index_ = (color_index_ + 1) % static_cast<int>(colors_.size());
   }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {
     device_scale_factor_ = device_scale_factor;
   }
 
   base::Closure PrepareForLayerBoundsChange() override {
@@ skipping 20 matching lines @@
   ~DrawTreeLayerDelegate() override {}
 
   void Reset() {
     painted_ = false;
   }
 
   bool painted() const { return painted_; }
 
  private:
   // Overridden from LayerDelegate:
-  void OnPaintLayer(gfx::Canvas* canvas) override {
+  void OnPaintLayer(const ui::PaintContext& context) override {
     painted_ = true;
-    canvas->DrawColor(SK_ColorWHITE);
+    context.canvas()->DrawColor(SK_ColorWHITE);
   }
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
   base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
   bool painted_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawTreeLayerDelegate);
 };
 
 // The simplest possible layer delegate. Does nothing.
 class NullLayerDelegate : public LayerDelegate {
  public:
   NullLayerDelegate() {}
   ~NullLayerDelegate() override {}
 
  private:
   // Overridden from LayerDelegate:
-  void OnPaintLayer(gfx::Canvas* canvas) override {}
+  void OnPaintLayer(const ui::PaintContext& context) override {}
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
   base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
 
 // Remembers if it has been notified.
@@ skipping 896 matching lines @@
   int GetPaintCountAndClear() {
     int value = paint_count_;
     paint_count_ = 0;
     return value;
   }
 
   const gfx::RectF& last_clip_rect() const { return last_clip_rect_; }
 
  private:
   // Overridden from LayerDelegate:
-  void OnPaintLayer(gfx::Canvas* canvas) override {
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    gfx::Canvas* canvas = context.canvas();
     paint_count_++;
     if (!schedule_paint_rect_.IsEmpty()) {
       layer_->SchedulePaint(schedule_paint_rect_);
       schedule_paint_rect_ = gfx::Rect();
     }
     SkRect sk_clip_rect;
     if (canvas->sk_canvas()->getClipBounds(&sk_clip_rect))
       last_clip_rect_ = gfx::SkRectToRectF(sk_clip_rect);
   }
 
@@ skipping 504 matching lines @@
                                      MakeFrameData(gfx::Size(10, 10))));
   layer->SetShowDelegatedContent(frame_provider.get(), gfx::Size(10, 10));
 
   EXPECT_FALSE(delegate.delegated_frame_damage_called());
   layer->OnDelegatedFrameDamage(damage_rect);
   EXPECT_TRUE(delegate.delegated_frame_damage_called());
   EXPECT_EQ(damage_rect, delegate.delegated_frame_damage_rect());
 }
 
 }  // namespace ui