snapshot_aura_unittest.cc revision c2db58bd994c04d98e4ee2cd7565b71548655fe3 
1// Copyright (c) 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "ui/snapshot/snapshot.h"
6
7#include "testing/gtest/include/gtest/gtest.h"
8#include "ui/aura/root_window.h"
9#include "ui/aura/test/aura_test_helper.h"
10#include "ui/aura/test/test_screen.h"
11#include "ui/aura/test/test_window_delegate.h"
12#include "ui/aura/test/test_windows.h"
13#include "ui/aura/window.h"
14#include "ui/compositor/layer.h"
15#include "ui/gfx/canvas.h"
16#include "ui/gfx/gfx_paths.h"
17#include "ui/gfx/image/image.h"
18#include "ui/gfx/rect.h"
19#include "ui/gfx/size_conversions.h"
20#include "ui/gfx/transform.h"
21#include "ui/gl/gl_implementation.h"
22
23namespace ui {
24namespace {
25const SkColor kPaintColor = SK_ColorRED;
26
27// Paint simple rectangle on the specified aura window.
28class TestPaintingWindowDelegate : public aura::test::TestWindowDelegate {
29 public:
30  explicit TestPaintingWindowDelegate(const gfx::Size& window_size)
31      : window_size_(window_size) {
32  }
33
34  virtual ~TestPaintingWindowDelegate() {
35  }
36
37  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
38    canvas->FillRect(gfx::Rect(window_size_), kPaintColor);
39  }
40
41 private:
42  gfx::Size window_size_;
43
44  DISALLOW_COPY_AND_ASSIGN(TestPaintingWindowDelegate);
45};
46
47size_t GetFailedPixelsCount(const gfx::Image& image) {
48  const SkBitmap* bitmap = image.ToSkBitmap();
49  uint32* bitmap_data = reinterpret_cast<uint32*>(
50      bitmap->pixelRef()->pixels());
51  size_t result = 0;
52  for (int i = 0; i < bitmap->width() * bitmap->height(); ++i) {
53    if (static_cast<SkColor>(bitmap_data[i]) != kPaintColor)
54      ++result;
55  }
56  return result;
57}
58
59}  // namespace
60
61class SnapshotAuraTest : public testing::Test {
62 public:
63  SnapshotAuraTest() {}
64  virtual ~SnapshotAuraTest() {}
65
66  virtual void SetUp() OVERRIDE {
67    testing::Test::SetUp();
68    helper_.reset(
69        new aura::test::AuraTestHelper(base::MessageLoopForUI::current()));
70    helper_->SetUp();
71  }
72
73  virtual void TearDown() OVERRIDE {
74    test_window_.reset();
75    delegate_.reset();
76    helper_->RunAllPendingInMessageLoop();
77    helper_->TearDown();
78    testing::Test::TearDown();
79  }
80
81 protected:
82  aura::Window* test_window() { return test_window_.get(); }
83  aura::RootWindow* root_window() { return helper_->root_window(); }
84  aura::TestScreen* test_screen() { return helper_->test_screen(); }
85
86  void WaitForDraw() {
87    root_window()->compositor()->ScheduleDraw();
88    ui::DrawWaiterForTest::Wait(root_window()->compositor());
89  }
90
91  void SetupTestWindow(const gfx::Rect& window_bounds) {
92    delegate_.reset(new TestPaintingWindowDelegate(window_bounds.size()));
93    test_window_.reset(aura::test::CreateTestWindowWithDelegate(
94        delegate_.get(), 0, window_bounds, root_window()));
95  }
96
97  gfx::Image GrabSnapshotForTestWindow() {
98    std::vector<unsigned char> png_representation;
99    gfx::Rect local_bounds(test_window_->bounds().size());
100    ui::GrabWindowSnapshot(test_window(), &png_representation, local_bounds);
101    return gfx::Image::CreateFrom1xPNGBytes(
102      &(png_representation[0]), png_representation.size());
103  }
104
105 private:
106  scoped_ptr<aura::test::AuraTestHelper> helper_;
107  scoped_ptr<aura::Window> test_window_;
108  scoped_ptr<TestPaintingWindowDelegate> delegate_;
109  std::vector<unsigned char> png_representation_;
110
111  DISALLOW_COPY_AND_ASSIGN(SnapshotAuraTest);
112};
113
114TEST_F(SnapshotAuraTest, FullScreenWindow) {
115  SetupTestWindow(root_window()->bounds());
116  WaitForDraw();
117
118  gfx::Image snapshot = GrabSnapshotForTestWindow();
119  EXPECT_EQ(test_window()->bounds().size().ToString(),
120            snapshot.Size().ToString());
121  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
122}
123
124TEST_F(SnapshotAuraTest, PartialBounds) {
125  gfx::Rect test_bounds(100, 100, 300, 200);
126  SetupTestWindow(test_bounds);
127  WaitForDraw();
128
129  gfx::Image snapshot = GrabSnapshotForTestWindow();
130  EXPECT_EQ(test_bounds.size().ToString(),
131            snapshot.Size().ToString());
132  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
133}
134
135TEST_F(SnapshotAuraTest, Rotated) {
136  test_screen()->SetDisplayRotation(gfx::Display::ROTATE_90);
137
138  gfx::Rect test_bounds(100, 100, 300, 200);
139  SetupTestWindow(test_bounds);
140  WaitForDraw();
141
142  gfx::Image snapshot = GrabSnapshotForTestWindow();
143  EXPECT_EQ(test_bounds.size().ToString(),
144            snapshot.Size().ToString());
145  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
146}
147
148TEST_F(SnapshotAuraTest, UIScale) {
149  const float kUIScale = 1.25f;
150  test_screen()->SetUIScale(kUIScale);
151
152  gfx::Rect test_bounds(100, 100, 300, 200);
153  SetupTestWindow(test_bounds);
154  WaitForDraw();
155
156  // Snapshot always captures the physical pixels.
157  gfx::SizeF snapshot_size(test_bounds.size());
158  snapshot_size.Scale(1.0f / kUIScale);
159
160  gfx::Image snapshot = GrabSnapshotForTestWindow();
161  EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
162            snapshot.Size().ToString());
163  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
164}
165
166TEST_F(SnapshotAuraTest, DeviceScaleFactor) {
167  test_screen()->SetDeviceScaleFactor(2.0f);
168
169  gfx::Rect test_bounds(100, 100, 150, 100);
170  SetupTestWindow(test_bounds);
171  WaitForDraw();
172
173  // Snapshot always captures the physical pixels.
174  gfx::SizeF snapshot_size(test_bounds.size());
175  snapshot_size.Scale(2.0f);
176
177  gfx::Image snapshot = GrabSnapshotForTestWindow();
178  EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
179            snapshot.Size().ToString());
180  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
181}
182
183TEST_F(SnapshotAuraTest, RotateAndUIScale) {
184  const float kUIScale = 1.25f;
185  test_screen()->SetUIScale(kUIScale);
186  test_screen()->SetDisplayRotation(gfx::Display::ROTATE_90);
187
188  gfx::Rect test_bounds(100, 100, 300, 200);
189  SetupTestWindow(test_bounds);
190  WaitForDraw();
191
192  // Snapshot always captures the physical pixels.
193  gfx::SizeF snapshot_size(test_bounds.size());
194  snapshot_size.Scale(1.0f / kUIScale);
195
196  gfx::Image snapshot = GrabSnapshotForTestWindow();
197  EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
198            snapshot.Size().ToString());
199  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
200}
201
202TEST_F(SnapshotAuraTest, RotateAndUIScaleAndScaleFactor) {
203  test_screen()->SetDeviceScaleFactor(2.0f);
204  const float kUIScale = 1.25f;
205  test_screen()->SetUIScale(kUIScale);
206  test_screen()->SetDisplayRotation(gfx::Display::ROTATE_90);
207
208  gfx::Rect test_bounds(20, 30, 150, 100);
209  SetupTestWindow(test_bounds);
210  WaitForDraw();
211
212  // Snapshot always captures the physical pixels.
213  gfx::SizeF snapshot_size(test_bounds.size());
214  snapshot_size.Scale(2.0f / kUIScale);
215
216  gfx::Image snapshot = GrabSnapshotForTestWindow();
217  EXPECT_EQ(gfx::ToRoundedSize(snapshot_size).ToString(),
218            snapshot.Size().ToString());
219  EXPECT_EQ(0u, GetFailedPixelsCount(snapshot));
220}
221
222}  // namespace ui
223