ui: Make compositor unittests access the canvas through PaintRecorder.

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"
@@ skipping 10 matching lines @@
 #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/paint_recorder.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 16 matching lines @@
   explicit ColoredLayer(SkColor color)
       : Layer(LAYER_TEXTURED),
         color_(color) {
     set_delegate(this);
   }
 
   ~ColoredLayer() override {}
 
   // Overridden from LayerDelegate:
   void OnPaintLayer(const ui::PaintContext& context) override {
-    context.canvas()->DrawColor(color_);
+    ui::PaintRecorder recorder(context);
+    recorder.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();
   }
 
@@ skipping 144 matching lines @@
   }
 
   int color_index() const { return color_index_; }
 
   float device_scale_factor() const {
     return device_scale_factor_;
   }
 
   // Overridden from LayerDelegate:
   void OnPaintLayer(const ui::PaintContext& context) override {
-    context.canvas()->DrawColor(colors_[color_index_]);
+    ui::PaintRecorder recorder(context);
+    recorder.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 22 matching lines @@
   void Reset() {
     painted_ = false;
   }
 
   bool painted() const { return painted_; }
 
  private:
   // Overridden from LayerDelegate:
   void OnPaintLayer(const ui::PaintContext& context) override {
     painted_ = true;
-    context.canvas()->DrawColor(SK_ColorWHITE);
+    ui::PaintRecorder recorder(context);
+    recorder.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);
@@ skipping 913 matching lines @@
   void SetSchedulePaintRect(const gfx::Rect& rect) {
     schedule_paint_rect_ = rect;
   }
 
   int GetPaintCountAndClear() {
     int value = paint_count_;
     paint_count_ = 0;
     return value;
   }
 
-  const gfx::RectF& last_clip_rect() const { return last_clip_rect_; }
+  const gfx::Rect& last_clip_rect() const { return last_clip_rect_; }
 
  private:
   // Overridden from LayerDelegate:
   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);
+    last_clip_rect_ = context.InvalidationForTesting();
   }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
   base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
   int paint_count_;
   Layer* layer_;
   gfx::Rect schedule_paint_rect_;
-  gfx::RectF last_clip_rect_;
+  gfx::Rect last_clip_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulePaintLayerDelegate);
 };
 
 }  // namespace
 
 // Verifies that if SchedulePaint is invoked during painting the layer is still
 // marked dirty.
 TEST_F(LayerWithDelegateTest, SchedulePaintFromOnPaintLayer) {
   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorRED,
@@ skipping 482 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