cc/output/gl_renderer_unittest.cc - Issue 1533773002: Delete CC.

Side by Side Diff: cc/output/gl_renderer_unittest.cc

Issue 1533773002: Delete CC. (Closed) Base URL: git@github.com:domokit/mojo.git@cl-2e

Patch Set: rebase Created 5 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 // Copyright 2012 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 "cc/output/gl_renderer.h"

6

7 #include <set>

8

9 #include "cc/base/math_util.h"

10 #include "cc/output/compositor_frame_metadata.h"

11 #include "cc/resources/resource_provider.h"

12 #include "cc/test/fake_impl_proxy.h"

13 #include "cc/test/fake_layer_tree_host_impl.h"

14 #include "cc/test/fake_output_surface.h"

15 #include "cc/test/fake_output_surface_client.h"

16 #include "cc/test/fake_renderer_client.h"

17 #include "cc/test/pixel_test.h"

18 #include "cc/test/render_pass_test_common.h"

19 #include "cc/test/render_pass_test_utils.h"

20 #include "cc/test/test_shared_bitmap_manager.h"

21 #include "cc/test/test_web_graphics_context_3d.h"

22 #include "gpu/GLES2/gl2extchromium.h"

23 #include "gpu/command_buffer/client/context_support.h"

24 #include "testing/gmock/include/gmock/gmock.h"

25 #include "testing/gtest/include/gtest/gtest.h"

26 #include "third_party/skia/include/core/SkImageFilter.h"

27 #include "third_party/skia/include/core/SkMatrix.h"

28 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h"

29 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"

30 #include "ui/gfx/transform.h"

31

32 using testing::_;

33 using testing::AnyNumber;

34 using testing::Args;

35 using testing::AtLeast;

36 using testing::ElementsAre;

37 using testing::Expectation;

38 using testing::InSequence;

39 using testing::Mock;

40 using testing::Return;

41 using testing::StrictMock;

42

43 namespace cc {

44

45 class GLRendererTest : public testing::Test {

46 protected:

47 RenderPass* root_render_pass() { return render_passes_in_draw_order_.back(); }

48

49 RenderPassList render_passes_in_draw_order_;

50 };

51

52 #define EXPECT_PROGRAM_VALID(program_binding) \

53 do { \

54 EXPECT_TRUE((program_binding)->program()); \

55 EXPECT_TRUE((program_binding)->initialized()); \

56 } while (false)

57

58 static inline SkXfermode::Mode BlendModeToSkXfermode(BlendMode blend_mode) {

59 switch (blend_mode) {

60 case BLEND_MODE_NONE:

61 case BLEND_MODE_NORMAL:

62 return SkXfermode::kSrcOver_Mode;

63 case BLEND_MODE_SCREEN:

64 return SkXfermode::kScreen_Mode;

65 case BLEND_MODE_OVERLAY:

66 return SkXfermode::kOverlay_Mode;

67 case BLEND_MODE_DARKEN:

68 return SkXfermode::kDarken_Mode;

69 case BLEND_MODE_LIGHTEN:

70 return SkXfermode::kLighten_Mode;

71 case BLEND_MODE_COLOR_DODGE:

72 return SkXfermode::kColorDodge_Mode;

73 case BLEND_MODE_COLOR_BURN:

74 return SkXfermode::kColorBurn_Mode;

75 case BLEND_MODE_HARD_LIGHT:

76 return SkXfermode::kHardLight_Mode;

77 case BLEND_MODE_SOFT_LIGHT:

78 return SkXfermode::kSoftLight_Mode;

79 case BLEND_MODE_DIFFERENCE:

80 return SkXfermode::kDifference_Mode;

81 case BLEND_MODE_EXCLUSION:

82 return SkXfermode::kExclusion_Mode;

83 case BLEND_MODE_MULTIPLY:

84 return SkXfermode::kMultiply_Mode;

85 case BLEND_MODE_HUE:

86 return SkXfermode::kHue_Mode;

87 case BLEND_MODE_SATURATION:

88 return SkXfermode::kSaturation_Mode;

89 case BLEND_MODE_COLOR:

90 return SkXfermode::kColor_Mode;

91 case BLEND_MODE_LUMINOSITY:

92 return SkXfermode::kLuminosity_Mode;

93 }

94 return SkXfermode::kSrcOver_Mode;

95 }

96

97 // Explicitly named to be a friend in GLRenderer for shader access.

98 class GLRendererShaderPixelTest : public GLRendererPixelTest {

99 public:

100 void SetUp() override {

101 GLRendererPixelTest::SetUp();

102 ASSERT_FALSE(renderer()->IsContextLost());

103 }

104

105 void TearDown() override {

106 GLRendererPixelTest::TearDown();

107 ASSERT_FALSE(renderer()->IsContextLost());

108 }

109

110 void TestBasicShaders() {

111 EXPECT_PROGRAM_VALID(renderer()->GetTileCheckerboardProgram());

112 EXPECT_PROGRAM_VALID(renderer()->GetDebugBorderProgram());

113 EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgram());

114 EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgramAA());

115 }

116

117 void TestShadersWithPrecision(TexCoordPrecision precision) {

118 EXPECT_PROGRAM_VALID(renderer()->GetTextureProgram(precision));

119 EXPECT_PROGRAM_VALID(

120 renderer()->GetNonPremultipliedTextureProgram(precision));

121 EXPECT_PROGRAM_VALID(renderer()->GetTextureBackgroundProgram(precision));

122 EXPECT_PROGRAM_VALID(

123 renderer()->GetNonPremultipliedTextureBackgroundProgram(precision));

124 EXPECT_PROGRAM_VALID(renderer()->GetTextureIOSurfaceProgram(precision));

125 EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVProgram(precision));

126 EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVAProgram(precision));

127 if (renderer()->Capabilities().using_egl_image)

128 EXPECT_PROGRAM_VALID(renderer()->GetVideoStreamTextureProgram(precision));

129 else

130 EXPECT_FALSE(renderer()->GetVideoStreamTextureProgram(precision));

131 }

132

133 void TestShadersWithPrecisionAndBlend(TexCoordPrecision precision,

134 BlendMode blend_mode) {

135 EXPECT_PROGRAM_VALID(

136 renderer()->GetRenderPassProgram(precision, blend_mode));

137 EXPECT_PROGRAM_VALID(

138 renderer()->GetRenderPassProgramAA(precision, blend_mode));

139 }

140

141 void TestShadersWithPrecisionAndSampler(TexCoordPrecision precision,

142 SamplerType sampler) {

143 if (!renderer()->Capabilities().using_egl_image &&

144 sampler == SAMPLER_TYPE_EXTERNAL_OES) {

145 // This will likely be hit in tests due to usage of osmesa.

146 return;

147 }

148

149 EXPECT_PROGRAM_VALID(renderer()->GetTileProgram(precision, sampler));

150 EXPECT_PROGRAM_VALID(renderer()->GetTileProgramOpaque(precision, sampler));

151 EXPECT_PROGRAM_VALID(renderer()->GetTileProgramAA(precision, sampler));

152 EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzle(precision, sampler));

153 EXPECT_PROGRAM_VALID(

154 renderer()->GetTileProgramSwizzleOpaque(precision, sampler));

155 EXPECT_PROGRAM_VALID(

156 renderer()->GetTileProgramSwizzleAA(precision, sampler));

157 }

158

159 void TestShadersWithMasks(TexCoordPrecision precision,

160 SamplerType sampler,

161 BlendMode blend_mode,

162 bool mask_for_background) {

163 if (!renderer()->Capabilities().using_egl_image &&

164 sampler == SAMPLER_TYPE_EXTERNAL_OES) {

165 // This will likely be hit in tests due to usage of osmesa.

166 return;

167 }

168

169 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgram(

170 precision, sampler, blend_mode, mask_for_background));

171 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(

172 precision, sampler, blend_mode, mask_for_background));

173 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(

174 precision, sampler, blend_mode, mask_for_background));

175 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgram(

176 precision, sampler, blend_mode, mask_for_background));

177 }

178 };

179

180 namespace {

181

182 #if !defined(OS_ANDROID) && !defined(OS_WIN)

183 static const TexCoordPrecision kPrecisionList[] = {TEX_COORD_PRECISION_MEDIUM,

184 TEX_COORD_PRECISION_HIGH};

185

186 static const BlendMode kBlendModeList[LAST_BLEND_MODE + 1] = {

187 BLEND_MODE_NONE,

188 BLEND_MODE_NORMAL,

189 BLEND_MODE_SCREEN,

190 BLEND_MODE_OVERLAY,

191 BLEND_MODE_DARKEN,

192 BLEND_MODE_LIGHTEN,

193 BLEND_MODE_COLOR_DODGE,

194 BLEND_MODE_COLOR_BURN,

195 BLEND_MODE_HARD_LIGHT,

196 BLEND_MODE_SOFT_LIGHT,

197 BLEND_MODE_DIFFERENCE,

198 BLEND_MODE_EXCLUSION,

199 BLEND_MODE_MULTIPLY,

200 BLEND_MODE_HUE,

201 BLEND_MODE_SATURATION,

202 BLEND_MODE_COLOR,

203 BLEND_MODE_LUMINOSITY,

204 };

205

206 static const SamplerType kSamplerList[] = {

207 SAMPLER_TYPE_2D,

208 SAMPLER_TYPE_2D_RECT,

209 SAMPLER_TYPE_EXTERNAL_OES,

210 };

211

212 TEST_F(GLRendererShaderPixelTest, BasicShadersCompile) {

213 TestBasicShaders();

214 }

215

216 class PrecisionShaderPixelTest

217 : public GLRendererShaderPixelTest,

218 public ::testing::WithParamInterface<TexCoordPrecision> {};

219

220 TEST_P(PrecisionShaderPixelTest, ShadersCompile) {

221 TestShadersWithPrecision(GetParam());

222 }

223

224 INSTANTIATE_TEST_CASE_P(PrecisionShadersCompile,

225 PrecisionShaderPixelTest,

226 ::testing::ValuesIn(kPrecisionList));

227

228 class PrecisionBlendShaderPixelTest

229 : public GLRendererShaderPixelTest,

230 public ::testing::WithParamInterface<

231 std::tr1::tuple<TexCoordPrecision, BlendMode>> {};

232

233 TEST_P(PrecisionBlendShaderPixelTest, ShadersCompile) {

234 TestShadersWithPrecisionAndBlend(std::tr1::get<0>(GetParam()),

235 std::tr1::get<1>(GetParam()));

236 }

237

238 INSTANTIATE_TEST_CASE_P(

239 PrecisionBlendShadersCompile,

240 PrecisionBlendShaderPixelTest,

241 ::testing::Combine(::testing::ValuesIn(kPrecisionList),

242 ::testing::ValuesIn(kBlendModeList)));

243

244 class PrecisionSamplerShaderPixelTest

245 : public GLRendererShaderPixelTest,

246 public ::testing::WithParamInterface<

247 std::tr1::tuple<TexCoordPrecision, SamplerType>> {};

248

249 TEST_P(PrecisionSamplerShaderPixelTest, ShadersCompile) {

250 TestShadersWithPrecisionAndSampler(std::tr1::get<0>(GetParam()),

251 std::tr1::get<1>(GetParam()));

252 }

253

254 INSTANTIATE_TEST_CASE_P(PrecisionSamplerShadersCompile,

255 PrecisionSamplerShaderPixelTest,

256 ::testing::Combine(::testing::ValuesIn(kPrecisionList),

257 ::testing::ValuesIn(kSamplerList)));

258

259 class MaskShaderPixelTest

260 : public GLRendererShaderPixelTest,

261 public ::testing::WithParamInterface<

262 std::tr1::tuple<TexCoordPrecision, SamplerType, BlendMode, bool>> {};

263

264 TEST_P(MaskShaderPixelTest, ShadersCompile) {

265 TestShadersWithMasks(

266 std::tr1::get<0>(GetParam()), std::tr1::get<1>(GetParam()),

267 std::tr1::get<2>(GetParam()), std::tr1::get<3>(GetParam()));

268 }

269

270 INSTANTIATE_TEST_CASE_P(MaskShadersCompile,

271 MaskShaderPixelTest,

272 ::testing::Combine(::testing::ValuesIn(kPrecisionList),

273 ::testing::ValuesIn(kSamplerList),

274 ::testing::ValuesIn(kBlendModeList),

275 ::testing::Bool()));

276

277 #endif

278

279 class FakeRendererGL : public GLRenderer {

280 public:

281 FakeRendererGL(RendererClient* client,

282 const RendererSettings* settings,

283 OutputSurface* output_surface,

284 ResourceProvider* resource_provider)

285 : GLRenderer(client,

286 settings,

287 output_surface,

288 resource_provider,

289 NULL,

290 0) {}

291

292 // GLRenderer methods.

293

294 // Changing visibility to public.

295 using GLRenderer::IsBackbufferDiscarded;

296 using GLRenderer::DoDrawQuad;

297 using GLRenderer::BeginDrawingFrame;

298 using GLRenderer::FinishDrawingQuadList;

299 using GLRenderer::stencil_enabled;

300 };

301

302 class GLRendererWithDefaultHarnessTest : public GLRendererTest {

303 protected:

304 GLRendererWithDefaultHarnessTest() {

305 output_surface_ =

306 FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create()).Pass();

307 CHECK(output_surface_->BindToClient(&output_surface_client_));

308

309 shared_bitmap_manager_.reset(new TestSharedBitmapManager());

310 resource_provider_ = ResourceProvider::Create(output_surface_.get(),

311 shared_bitmap_manager_.get(),

312 NULL,

313 NULL,

314 0,

315 false,

316 1).Pass();

317 renderer_ = make_scoped_ptr(new FakeRendererGL(&renderer_client_,

318 &settings_,

319 output_surface_.get(),

320 resource_provider_.get()));

321 }

322

323 void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }

324

325 RendererSettings settings_;

326 FakeOutputSurfaceClient output_surface_client_;

327 scoped_ptr<FakeOutputSurface> output_surface_;

328 FakeRendererClient renderer_client_;

329 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;

330 scoped_ptr<ResourceProvider> resource_provider_;

331 scoped_ptr<FakeRendererGL> renderer_;

332 };

333

334 // Closing the namespace here so that GLRendererShaderTest can take advantage

335 // of the friend relationship with GLRenderer and all of the mock classes

336 // declared above it.

337 } // namespace

338

339 class GLRendererShaderTest : public GLRendererTest {

340 protected:

341 GLRendererShaderTest() {

342 output_surface_ = FakeOutputSurface::Create3d().Pass();

343 CHECK(output_surface_->BindToClient(&output_surface_client_));

344

345 shared_bitmap_manager_.reset(new TestSharedBitmapManager());

346 resource_provider_ = ResourceProvider::Create(output_surface_.get(),

347 shared_bitmap_manager_.get(),

348 NULL,

349 NULL,

350 0,

351 false,

352 1).Pass();

353 renderer_.reset(new FakeRendererGL(&renderer_client_,

354 &settings_,

355 output_surface_.get(),

356 resource_provider_.get()));

357 }

358

359 void TestRenderPassProgram(TexCoordPrecision precision,

360 BlendMode blend_mode) {

361 EXPECT_PROGRAM_VALID(

362 &renderer_->render_pass_program_[precision][blend_mode]);

363 EXPECT_EQ(renderer_->render_pass_program_[precision][blend_mode].program(),

364 renderer_->program_shadow_);

365 }

366

367 void TestRenderPassColorMatrixProgram(TexCoordPrecision precision,

368 BlendMode blend_mode) {

369 EXPECT_PROGRAM_VALID(

370 &renderer_->render_pass_color_matrix_program_[precision][blend_mode]);

371 EXPECT_EQ(

372 renderer_->render_pass_color_matrix_program_[precision][blend_mode]

373 .program(),

374 renderer_->program_shadow_);

375 }

376

377 void TestRenderPassMaskProgram(TexCoordPrecision precision,

378 SamplerType sampler,

379 BlendMode blend_mode) {

380 EXPECT_PROGRAM_VALID(

381 &renderer_->render_pass_mask_program_[precision]

382 [sampler]

383 [blend_mode]

384 [NO_MASK]);

385 EXPECT_EQ(

386 renderer_->render_pass_mask_program_[precision]

387 [sampler]

388 [blend_mode]

389 [NO_MASK].program(),

390 renderer_->program_shadow_);

391 }

392

393 void TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision,

394 SamplerType sampler,

395 BlendMode blend_mode) {

396 EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_

397 [precision][sampler][blend_mode][NO_MASK]);

398 EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_

399 [precision][sampler][blend_mode][NO_MASK].program(),

400 renderer_->program_shadow_);

401 }

402

403 void TestRenderPassProgramAA(TexCoordPrecision precision,

404 BlendMode blend_mode) {

405 EXPECT_PROGRAM_VALID(

406 &renderer_->render_pass_program_aa_[precision][blend_mode]);

407 EXPECT_EQ(

408 renderer_->render_pass_program_aa_[precision][blend_mode].program(),

409 renderer_->program_shadow_);

410 }

411

412 void TestRenderPassColorMatrixProgramAA(TexCoordPrecision precision,

413 BlendMode blend_mode) {

414 EXPECT_PROGRAM_VALID(

415 &renderer_

416 ->render_pass_color_matrix_program_aa_[precision][blend_mode]);

417 EXPECT_EQ(

418 renderer_->render_pass_color_matrix_program_aa_[precision][blend_mode]

419 .program(),

420 renderer_->program_shadow_);

421 }

422

423 void TestRenderPassMaskProgramAA(TexCoordPrecision precision,

424 SamplerType sampler,

425 BlendMode blend_mode) {

426 EXPECT_PROGRAM_VALID(

427 &renderer_

428 ->render_pass_mask_program_aa_

429 [precision][sampler][blend_mode][NO_MASK]);

430 EXPECT_EQ(

431 renderer_->render_pass_mask_program_aa_[precision][sampler][blend_mode]

432 [NO_MASK].program(),

433 renderer_->program_shadow_);

434 }

435

436 void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,

437 SamplerType sampler,

438 BlendMode blend_mode) {

439 EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_aa_

440 [precision][sampler][blend_mode][NO_MASK]);

441 EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_

442 [precision][sampler][blend_mode][NO_MASK].program(),

443 renderer_->program_shadow_);

444 }

445

446 void TestSolidColorProgramAA() {

447 EXPECT_PROGRAM_VALID(&renderer_->solid_color_program_aa_);

448 EXPECT_EQ(renderer_->solid_color_program_aa_.program(),

449 renderer_->program_shadow_);

450 }

451

452 RendererSettings settings_;

453 FakeOutputSurfaceClient output_surface_client_;

454 scoped_ptr<FakeOutputSurface> output_surface_;

455 FakeRendererClient renderer_client_;

456 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;

457 scoped_ptr<ResourceProvider> resource_provider_;

458 scoped_ptr<FakeRendererGL> renderer_;

459 };

460

461 namespace {

462

463 // Test GLRenderer DiscardBackbuffer functionality:

464 // Suggest discarding framebuffer when one exists and the renderer is not

465 // visible.

466 // Expected: it is discarded and damage tracker is reset.

467 TEST_F(

468 GLRendererWithDefaultHarnessTest,

469 SuggestBackbufferNoShouldDiscardBackbufferAndDamageRootLayerIfNotVisible) {

470 renderer_->SetVisible(false);

471 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());

472 EXPECT_TRUE(renderer_->IsBackbufferDiscarded());

473 }

474

475 // Test GLRenderer DiscardBackbuffer functionality:

476 // Suggest discarding framebuffer when one exists and the renderer is visible.

477 // Expected: the allocation is ignored.

478 TEST_F(GLRendererWithDefaultHarnessTest,

479 SuggestBackbufferNoDoNothingWhenVisible) {

480 renderer_->SetVisible(true);

481 EXPECT_EQ(0, renderer_client_.set_full_root_layer_damage_count());

482 EXPECT_FALSE(renderer_->IsBackbufferDiscarded());

483 }

484

485 // Test GLRenderer DiscardBackbuffer functionality:

486 // Suggest discarding framebuffer when one does not exist.

487 // Expected: it does nothing.

488 TEST_F(GLRendererWithDefaultHarnessTest,

489 SuggestBackbufferNoWhenItDoesntExistShouldDoNothing) {

490 renderer_->SetVisible(false);

491 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());

492 EXPECT_TRUE(renderer_->IsBackbufferDiscarded());

493

494 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());

495 EXPECT_TRUE(renderer_->IsBackbufferDiscarded());

496 }

497

498 // Test GLRenderer DiscardBackbuffer functionality:

499 // Begin drawing a frame while a framebuffer is discarded.

500 // Expected: will recreate framebuffer.

501 TEST_F(GLRendererWithDefaultHarnessTest,

502 DiscardedBackbufferIsRecreatedForScopeDuration) {

503 gfx::Rect viewport_rect(1, 1);

504 renderer_->SetVisible(false);

505 EXPECT_TRUE(renderer_->IsBackbufferDiscarded());

506 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());

507

508 AddRenderPass(&render_passes_in_draw_order_,

509 RenderPassId(1, 0),

510 viewport_rect,

511 gfx::Transform());

512

513 renderer_->SetVisible(true);

514 renderer_->DrawFrame(&render_passes_in_draw_order_,

515 1.f,

516 viewport_rect,

517 viewport_rect,

518 false);

519 EXPECT_FALSE(renderer_->IsBackbufferDiscarded());

520

521 SwapBuffers();

522 EXPECT_EQ(1u, output_surface_->num_sent_frames());

523 }

524

525 TEST_F(GLRendererWithDefaultHarnessTest, ExternalStencil) {

526 gfx::Rect viewport_rect(1, 1);

527 EXPECT_FALSE(renderer_->stencil_enabled());

528

529 output_surface_->set_has_external_stencil_test(true);

530

531 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

532 RenderPassId(1, 0),

533 viewport_rect,

534 gfx::Transform());

535 root_pass->has_transparent_background = false;

536

537 renderer_->DrawFrame(&render_passes_in_draw_order_,

538 1.f,

539 viewport_rect,

540 viewport_rect,

541 false);

542 EXPECT_TRUE(renderer_->stencil_enabled());

543 }

544

545 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {

546 public:

547 ForbidSynchronousCallContext() {}

548

549 void getAttachedShaders(GLuint program,

550 GLsizei max_count,

551 GLsizei* count,

552 GLuint* shaders) override {

553 ADD_FAILURE();

554 }

555 GLint getAttribLocation(GLuint program, const GLchar* name) override {

556 ADD_FAILURE();

557 return 0;

558 }

559 void getBooleanv(GLenum pname, GLboolean* value) override { ADD_FAILURE(); }

560 void getBufferParameteriv(GLenum target,

561 GLenum pname,

562 GLint* value) override {

563 ADD_FAILURE();

564 }

565 GLenum getError() override {

566 ADD_FAILURE();

567 return GL_NO_ERROR;

568 }

569 void getFloatv(GLenum pname, GLfloat* value) override { ADD_FAILURE(); }

570 void getFramebufferAttachmentParameteriv(GLenum target,

571 GLenum attachment,

572 GLenum pname,

573 GLint* value) override {

574 ADD_FAILURE();

575 }

576 void getIntegerv(GLenum pname, GLint* value) override {

577 if (pname == GL_MAX_TEXTURE_SIZE) {

578 // MAX_TEXTURE_SIZE is cached client side, so it's OK to query.

579 *value = 1024;

580 } else {

581 ADD_FAILURE();

582 }

583 }

584

585 // We allow querying the shader compilation and program link status in debug

586 // mode, but not release.

587 void getProgramiv(GLuint program, GLenum pname, GLint* value) override {

588 #ifndef NDEBUG

589 *value = 1;

590 #else

591 ADD_FAILURE();

592 #endif

593 }

594

595 void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {

596 #ifndef NDEBUG

597 *value = 1;

598 #else

599 ADD_FAILURE();

600 #endif

601 }

602

603 void getRenderbufferParameteriv(GLenum target,

604 GLenum pname,

605 GLint* value) override {

606 ADD_FAILURE();

607 }

608

609 void getShaderPrecisionFormat(GLenum shadertype,

610 GLenum precisiontype,

611 GLint* range,

612 GLint* precision) override {

613 ADD_FAILURE();

614 }

615 void getTexParameterfv(GLenum target, GLenum pname, GLfloat* value) override {

616 ADD_FAILURE();

617 }

618 void getTexParameteriv(GLenum target, GLenum pname, GLint* value) override {

619 ADD_FAILURE();

620 }

621 void getUniformfv(GLuint program, GLint location, GLfloat* value) override {

622 ADD_FAILURE();

623 }

624 void getUniformiv(GLuint program, GLint location, GLint* value) override {

625 ADD_FAILURE();

626 }

627 GLint getUniformLocation(GLuint program, const GLchar* name) override {

628 ADD_FAILURE();

629 return 0;

630 }

631 void getVertexAttribfv(GLuint index, GLenum pname, GLfloat* value) override {

632 ADD_FAILURE();

633 }

634 void getVertexAttribiv(GLuint index, GLenum pname, GLint* value) override {

635 ADD_FAILURE();

636 }

637 GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname) override {

638 ADD_FAILURE();

639 return 0;

640 }

641 };

642 TEST_F(GLRendererTest, InitializationDoesNotMakeSynchronousCalls) {

643 FakeOutputSurfaceClient output_surface_client;

644 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(

645 scoped_ptr<TestWebGraphicsContext3D>(new ForbidSynchronousCallContext)));

646 CHECK(output_surface->BindToClient(&output_surface_client));

647

648 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

649 new TestSharedBitmapManager());

650 scoped_ptr<ResourceProvider> resource_provider(

651 ResourceProvider::Create(output_surface.get(),

652 shared_bitmap_manager.get(),

653 NULL,

654 NULL,

655 0,

656 false,

657 1));

658

659 RendererSettings settings;

660 FakeRendererClient renderer_client;

661 FakeRendererGL renderer(&renderer_client,

662 &settings,

663 output_surface.get(),

664 resource_provider.get());

665 }

666

667 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {

668 public:

669 LoseContextOnFirstGetContext() {}

670

671 void getProgramiv(GLuint program, GLenum pname, GLint* value) override {

672 context_lost_ = true;

673 *value = 0;

674 }

675

676 void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {

677 context_lost_ = true;

678 *value = 0;

679 }

680 };

681

682 TEST_F(GLRendererTest, InitializationWithQuicklyLostContextDoesNotAssert) {

683 FakeOutputSurfaceClient output_surface_client;

684 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(

685 scoped_ptr<TestWebGraphicsContext3D>(new LoseContextOnFirstGetContext)));

686 CHECK(output_surface->BindToClient(&output_surface_client));

687

688 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

689 new TestSharedBitmapManager());

690 scoped_ptr<ResourceProvider> resource_provider(

691 ResourceProvider::Create(output_surface.get(),

692 shared_bitmap_manager.get(),

693 NULL,

694 NULL,

695 0,

696 false,

697 1));

698

699 RendererSettings settings;

700 FakeRendererClient renderer_client;

701 FakeRendererGL renderer(&renderer_client,

702 &settings,

703 output_surface.get(),

704 resource_provider.get());

705 }

706

707 class ClearCountingContext : public TestWebGraphicsContext3D {

708 public:

709 ClearCountingContext() { test_capabilities_.gpu.discard_framebuffer = true; }

710

711 MOCK_METHOD3(discardFramebufferEXT,

712 void(GLenum target,

713 GLsizei numAttachments,

714 const GLenum* attachments));

715 MOCK_METHOD1(clear, void(GLbitfield mask));

716 };

717

718 TEST_F(GLRendererTest, OpaqueBackground) {

719 scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext);

720 ClearCountingContext* context = context_owned.get();

721

722 FakeOutputSurfaceClient output_surface_client;

723 scoped_ptr<OutputSurface> output_surface(

724 FakeOutputSurface::Create3d(context_owned.Pass()));

725 CHECK(output_surface->BindToClient(&output_surface_client));

726

727 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

728 new TestSharedBitmapManager());

729 scoped_ptr<ResourceProvider> resource_provider(

730 ResourceProvider::Create(output_surface.get(),

731 shared_bitmap_manager.get(),

732 NULL,

733 NULL,

734 0,

735 false,

736 1));

737

738 RendererSettings settings;

739 FakeRendererClient renderer_client;

740 FakeRendererGL renderer(&renderer_client,

741 &settings,

742 output_surface.get(),

743 resource_provider.get());

744

745 gfx::Rect viewport_rect(1, 1);

746 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

747 RenderPassId(1, 0),

748 viewport_rect,

749 gfx::Transform());

750 root_pass->has_transparent_background = false;

751

752 // On DEBUG builds, render passes with opaque background clear to blue to

753 // easily see regions that were not drawn on the screen.

754 EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))

755 .With(Args<2, 1>(ElementsAre(GL_COLOR_EXT)))

756 .Times(1);

757 #ifdef NDEBUG

758 EXPECT_CALL(*context, clear(_)).Times(0);

759 #else

760 EXPECT_CALL(*context, clear(_)).Times(1);

761 #endif

762 renderer.DrawFrame(&render_passes_in_draw_order_,

763 1.f,

764 viewport_rect,

765 viewport_rect,

766 false);

767 Mock::VerifyAndClearExpectations(context);

768 }

769

770 TEST_F(GLRendererTest, TransparentBackground) {

771 scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext);

772 ClearCountingContext* context = context_owned.get();

773

774 FakeOutputSurfaceClient output_surface_client;

775 scoped_ptr<OutputSurface> output_surface(

776 FakeOutputSurface::Create3d(context_owned.Pass()));

777 CHECK(output_surface->BindToClient(&output_surface_client));

778

779 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

780 new TestSharedBitmapManager());

781 scoped_ptr<ResourceProvider> resource_provider(

782 ResourceProvider::Create(output_surface.get(),

783 shared_bitmap_manager.get(),

784 NULL,

785 NULL,

786 0,

787 false,

788 1));

789

790 RendererSettings settings;

791 FakeRendererClient renderer_client;

792 FakeRendererGL renderer(&renderer_client,

793 &settings,

794 output_surface.get(),

795 resource_provider.get());

796

797 gfx::Rect viewport_rect(1, 1);

798 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

799 RenderPassId(1, 0),

800 viewport_rect,

801 gfx::Transform());

802 root_pass->has_transparent_background = true;

803

804 EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1);

805 EXPECT_CALL(*context, clear(_)).Times(1);

806 renderer.DrawFrame(&render_passes_in_draw_order_,

807 1.f,

808 viewport_rect,

809 viewport_rect,

810 false);

811

812 Mock::VerifyAndClearExpectations(context);

813 }

814

815 TEST_F(GLRendererTest, OffscreenOutputSurface) {

816 scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext);

817 ClearCountingContext* context = context_owned.get();

818

819 FakeOutputSurfaceClient output_surface_client;

820 scoped_ptr<OutputSurface> output_surface(

821 FakeOutputSurface::CreateOffscreen(context_owned.Pass()));

822 CHECK(output_surface->BindToClient(&output_surface_client));

823

824 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

825 new TestSharedBitmapManager());

826 scoped_ptr<ResourceProvider> resource_provider(

827 ResourceProvider::Create(output_surface.get(),

828 shared_bitmap_manager.get(),

829 NULL,

830 NULL,

831 0,

832 false,

833 1));

834

835 RendererSettings settings;

836 FakeRendererClient renderer_client;

837 FakeRendererGL renderer(&renderer_client,

838 &settings,

839 output_surface.get(),

840 resource_provider.get());

841

842 gfx::Rect viewport_rect(1, 1);

843 AddRenderPass(&render_passes_in_draw_order_,

844 RenderPassId(1, 0),

845 viewport_rect,

846 gfx::Transform());

847

848 EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))

849 .With(Args<2, 1>(ElementsAre(GL_COLOR_ATTACHMENT0)))

850 .Times(1);

851 EXPECT_CALL(*context, clear(_)).Times(AnyNumber());

852 renderer.DrawFrame(&render_passes_in_draw_order_,

853 1.f,

854 viewport_rect,

855 viewport_rect,

856 false);

857 Mock::VerifyAndClearExpectations(context);

858 }

859

860 class VisibilityChangeIsLastCallTrackingContext

861 : public TestWebGraphicsContext3D {

862 public:

863 VisibilityChangeIsLastCallTrackingContext()

864 : last_call_was_set_visibility_(false) {}

865

866 // TestWebGraphicsContext3D methods.

867 void flush() override { last_call_was_set_visibility_ = false; }

868 void deleteTexture(GLuint) override { last_call_was_set_visibility_ = false; }

869 void deleteFramebuffer(GLuint) override {

870 last_call_was_set_visibility_ = false;

871 }

872 void deleteQueryEXT(GLuint) override {

873 last_call_was_set_visibility_ = false;

874 }

875 void deleteRenderbuffer(GLuint) override {

876 last_call_was_set_visibility_ = false;

877 }

878

879 // Methods added for test.

880 void set_last_call_was_visibility(bool visible) {

881 DCHECK(last_call_was_set_visibility_ == false);

882 last_call_was_set_visibility_ = true;

883 }

884 bool last_call_was_set_visibility() const {

885 return last_call_was_set_visibility_;

886 }

887

888 private:

889 bool last_call_was_set_visibility_;

890 };

891

892 TEST_F(GLRendererTest, VisibilityChangeIsLastCall) {

893 scoped_ptr<VisibilityChangeIsLastCallTrackingContext> context_owned(

894 new VisibilityChangeIsLastCallTrackingContext);

895 VisibilityChangeIsLastCallTrackingContext* context = context_owned.get();

896

897 scoped_refptr<TestContextProvider> provider =

898 TestContextProvider::Create(context_owned.Pass());

899

900 provider->support()->SetSurfaceVisibleCallback(base::Bind(

901 &VisibilityChangeIsLastCallTrackingContext::set_last_call_was_visibility,

902 base::Unretained(context)));

903

904 FakeOutputSurfaceClient output_surface_client;

905 scoped_ptr<OutputSurface> output_surface(

906 FakeOutputSurface::Create3d(provider));

907 CHECK(output_surface->BindToClient(&output_surface_client));

908

909 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

910 new TestSharedBitmapManager());

911 scoped_ptr<ResourceProvider> resource_provider(

912 ResourceProvider::Create(output_surface.get(),

913 shared_bitmap_manager.get(),

914 NULL,

915 NULL,

916 0,

917 false,

918 1));

919

920 RendererSettings settings;

921 FakeRendererClient renderer_client;

922 FakeRendererGL renderer(&renderer_client,

923 &settings,

924 output_surface.get(),

925 resource_provider.get());

926

927 gfx::Rect viewport_rect(1, 1);

928 AddRenderPass(&render_passes_in_draw_order_,

929 RenderPassId(1, 0),

930 viewport_rect,

931 gfx::Transform());

932

933 // Ensure that the call to SetSurfaceVisible is the last call issue to the

934 // GPU process, after glFlush is called, and after the RendererClient's

935 // SetManagedMemoryPolicy is called. Plumb this tracking between both the

936 // RenderClient and the Context by giving them both a pointer to a variable on

937 // the stack.

938 renderer.SetVisible(true);

939 renderer.DrawFrame(&render_passes_in_draw_order_,

940 1.f,

941 viewport_rect,

942 viewport_rect,

943 false);

944 renderer.SetVisible(false);

945 EXPECT_TRUE(context->last_call_was_set_visibility());

946 }

947

948 class TextureStateTrackingContext : public TestWebGraphicsContext3D {

949 public:

950 TextureStateTrackingContext() : active_texture_(GL_INVALID_ENUM) {

951 test_capabilities_.gpu.egl_image_external = true;

952 }

953

954 MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point));

955 MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param));

956 MOCK_METHOD4(drawElements,

957 void(GLenum mode, GLsizei count, GLenum type, GLintptr offset));

958

959 virtual void activeTexture(GLenum texture) {

960 EXPECT_NE(texture, active_texture_);

961 active_texture_ = texture;

962 }

963

964 GLenum active_texture() const { return active_texture_; }

965

966 private:

967 GLenum active_texture_;

968 };

969

970 TEST_F(GLRendererTest, ActiveTextureState) {

971 scoped_ptr<TextureStateTrackingContext> context_owned(

972 new TextureStateTrackingContext);

973 TextureStateTrackingContext* context = context_owned.get();

974

975 FakeOutputSurfaceClient output_surface_client;

976 scoped_ptr<OutputSurface> output_surface(

977 FakeOutputSurface::Create3d(context_owned.Pass()));

978 CHECK(output_surface->BindToClient(&output_surface_client));

979

980 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

981 new TestSharedBitmapManager());

982 scoped_ptr<ResourceProvider> resource_provider(

983 ResourceProvider::Create(output_surface.get(),

984 shared_bitmap_manager.get(),

985 NULL,

986 NULL,

987 0,

988 false,

989 1));

990

991 RendererSettings settings;

992 FakeRendererClient renderer_client;

993 FakeRendererGL renderer(&renderer_client,

994 &settings,

995 output_surface.get(),

996 resource_provider.get());

997

998 // During initialization we are allowed to set any texture parameters.

999 EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());

1000

1001 RenderPassId id(1, 1);

1002 TestRenderPass* root_pass = AddRenderPass(

1003 &render_passes_in_draw_order_, id, gfx::Rect(100, 100), gfx::Transform());

1004 root_pass->AppendOneOfEveryQuadType(resource_provider.get(),

1005 RenderPassId(2, 1));

1006

1007 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1008

1009 // Set up expected texture filter state transitions that match the quads

1010 // created in AppendOneOfEveryQuadType().

1011 Mock::VerifyAndClearExpectations(context);

1012 {

1013 InSequence sequence;

1014

1015 // The sync points for all quads are waited on first. This sync point is

1016 // for a texture quad drawn later in the frame.

1017 EXPECT_CALL(*context,

1018 waitSyncPoint(TestRenderPass::kSyncPointForMailboxTextureQuad))

1019 .Times(1);

1020

1021 // yuv_quad is drawn with the default linear filter.

1022 EXPECT_CALL(*context, drawElements(_, _, _, _));

1023

1024 // tile_quad is drawn with GL_NEAREST because it is not transformed or

1025 // scaled.

1026 EXPECT_CALL(

1027 *context,

1028 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));

1029 EXPECT_CALL(

1030 *context,

1031 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));

1032 EXPECT_CALL(*context, drawElements(_, _, _, _));

1033

1034 // transformed_tile_quad uses GL_LINEAR.

1035 EXPECT_CALL(*context, drawElements(_, _, _, _));

1036

1037 // scaled_tile_quad also uses GL_LINEAR.

1038 EXPECT_CALL(*context, drawElements(_, _, _, _));

1039

1040 // The remaining quads also use GL_LINEAR because nearest neighbor

1041 // filtering is currently only used with tile quads.

1042 EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(7);

1043 }

1044

1045 gfx::Rect viewport_rect(100, 100);

1046 renderer.DrawFrame(&render_passes_in_draw_order_,

1047 1.f,

1048 viewport_rect,

1049 viewport_rect,

1050 false);

1051 Mock::VerifyAndClearExpectations(context);

1052 }

1053

1054 class NoClearRootRenderPassMockContext : public TestWebGraphicsContext3D {

1055 public:

1056 MOCK_METHOD1(clear, void(GLbitfield mask));

1057 MOCK_METHOD4(drawElements,

1058 void(GLenum mode, GLsizei count, GLenum type, GLintptr offset));

1059 };

1060

1061 TEST_F(GLRendererTest, ShouldClearRootRenderPass) {

1062 scoped_ptr<NoClearRootRenderPassMockContext> mock_context_owned(

1063 new NoClearRootRenderPassMockContext);

1064 NoClearRootRenderPassMockContext* mock_context = mock_context_owned.get();

1065

1066 FakeOutputSurfaceClient output_surface_client;

1067 scoped_ptr<OutputSurface> output_surface(

1068 FakeOutputSurface::Create3d(mock_context_owned.Pass()));

1069 CHECK(output_surface->BindToClient(&output_surface_client));

1070

1071 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

1072 new TestSharedBitmapManager());

1073 scoped_ptr<ResourceProvider> resource_provider(

1074 ResourceProvider::Create(output_surface.get(),

1075 shared_bitmap_manager.get(),

1076 NULL,

1077 NULL,

1078 0,

1079 false,

1080 1));

1081

1082 RendererSettings settings;

1083 settings.should_clear_root_render_pass = false;

1084

1085 FakeRendererClient renderer_client;

1086 FakeRendererGL renderer(&renderer_client,

1087 &settings,

1088 output_surface.get(),

1089 resource_provider.get());

1090

1091 gfx::Rect viewport_rect(10, 10);

1092

1093 RenderPassId root_pass_id(1, 0);

1094 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1095 root_pass_id,

1096 viewport_rect,

1097 gfx::Transform());

1098 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1099

1100 RenderPassId child_pass_id(2, 0);

1101 TestRenderPass* child_pass = AddRenderPass(&render_passes_in_draw_order_,

1102 child_pass_id,

1103 viewport_rect,

1104 gfx::Transform());

1105 AddQuad(child_pass, viewport_rect, SK_ColorBLUE);

1106

1107 AddRenderPassQuad(root_pass, child_pass);

1108

1109 #ifdef NDEBUG

1110 GLint clear_bits = GL_COLOR_BUFFER_BIT;

1111 #else

1112 GLint clear_bits = GL_COLOR_BUFFER_BIT \| GL_STENCIL_BUFFER_BIT;

1113 #endif

1114

1115 // First render pass is not the root one, clearing should happen.

1116 EXPECT_CALL(*mock_context, clear(clear_bits)).Times(AtLeast(1));

1117

1118 Expectation first_render_pass =

1119 EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(1);

1120

1121 // The second render pass is the root one, clearing should be prevented.

1122 EXPECT_CALL(*mock_context, clear(clear_bits)).Times(0).After(

1123 first_render_pass);

1124

1125 EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(AnyNumber()).After(

1126 first_render_pass);

1127

1128 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1129 renderer.DrawFrame(&render_passes_in_draw_order_,

1130 1.f,

1131 viewport_rect,

1132 viewport_rect,

1133 false);

1134

1135 // In multiple render passes all but the root pass should clear the

1136 // framebuffer.

1137 Mock::VerifyAndClearExpectations(&mock_context);

1138 }

1139

1140 class ScissorTestOnClearCheckingContext : public TestWebGraphicsContext3D {

1141 public:

1142 ScissorTestOnClearCheckingContext() : scissor_enabled_(false) {}

1143

1144 void clear(GLbitfield) override { EXPECT_FALSE(scissor_enabled_); }

1145

1146 void enable(GLenum cap) override {

1147 if (cap == GL_SCISSOR_TEST)

1148 scissor_enabled_ = true;

1149 }

1150

1151 void disable(GLenum cap) override {

1152 if (cap == GL_SCISSOR_TEST)

1153 scissor_enabled_ = false;

1154 }

1155

1156 private:

1157 bool scissor_enabled_;

1158 };

1159

1160 TEST_F(GLRendererTest, ScissorTestWhenClearing) {

1161 scoped_ptr<ScissorTestOnClearCheckingContext> context_owned(

1162 new ScissorTestOnClearCheckingContext);

1163

1164 FakeOutputSurfaceClient output_surface_client;

1165 scoped_ptr<OutputSurface> output_surface(

1166 FakeOutputSurface::Create3d(context_owned.Pass()));

1167 CHECK(output_surface->BindToClient(&output_surface_client));

1168

1169 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

1170 new TestSharedBitmapManager());

1171 scoped_ptr<ResourceProvider> resource_provider(

1172 ResourceProvider::Create(output_surface.get(),

1173 shared_bitmap_manager.get(),

1174 NULL,

1175 NULL,

1176 0,

1177 false,

1178 1));

1179

1180 RendererSettings settings;

1181 FakeRendererClient renderer_client;

1182 FakeRendererGL renderer(&renderer_client,

1183 &settings,

1184 output_surface.get(),

1185 resource_provider.get());

1186 EXPECT_FALSE(renderer.Capabilities().using_partial_swap);

1187

1188 gfx::Rect viewport_rect(1, 1);

1189

1190 gfx::Rect grand_child_rect(25, 25);

1191 RenderPassId grand_child_pass_id(3, 0);

1192 TestRenderPass* grand_child_pass =

1193 AddRenderPass(&render_passes_in_draw_order_,

1194 grand_child_pass_id,

1195 grand_child_rect,

1196 gfx::Transform());

1197 AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);

1198

1199 gfx::Rect child_rect(50, 50);

1200 RenderPassId child_pass_id(2, 0);

1201 TestRenderPass* child_pass = AddRenderPass(&render_passes_in_draw_order_,

1202 child_pass_id,

1203 child_rect,

1204 gfx::Transform());

1205 AddQuad(child_pass, child_rect, SK_ColorBLUE);

1206

1207 RenderPassId root_pass_id(1, 0);

1208 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1209 root_pass_id,

1210 viewport_rect,

1211 gfx::Transform());

1212 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1213

1214 AddRenderPassQuad(root_pass, child_pass);

1215 AddRenderPassQuad(child_pass, grand_child_pass);

1216

1217 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1218 renderer.DrawFrame(&render_passes_in_draw_order_,

1219 1.f,

1220 viewport_rect,

1221 viewport_rect,

1222 false);

1223 }

1224

1225 class DiscardCheckingContext : public TestWebGraphicsContext3D {

1226 public:

1227 DiscardCheckingContext() : discarded_(0) {

1228 set_have_post_sub_buffer(true);

1229 set_have_discard_framebuffer(true);

1230 }

1231

1232 void discardFramebufferEXT(GLenum target,

1233 GLsizei numAttachments,

1234 const GLenum* attachments) override {

1235 ++discarded_;

1236 }

1237

1238 int discarded() const { return discarded_; }

1239 void reset() { discarded_ = 0; }

1240

1241 private:

1242 int discarded_;

1243 };

1244

1245 class NonReshapableOutputSurface : public FakeOutputSurface {

1246 public:

1247 explicit NonReshapableOutputSurface(

1248 scoped_ptr<TestWebGraphicsContext3D> context3d)

1249 : FakeOutputSurface(TestContextProvider::Create(context3d.Pass()),

1250 false) {

1251 surface_size_ = gfx::Size(500, 500);

1252 }

1253 void Reshape(const gfx::Size& size, float scale_factor) override {}

1254 void set_fixed_size(const gfx::Size& size) { surface_size_ = size; }

1255 };

1256

1257 TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) {

1258 scoped_ptr<DiscardCheckingContext> context_owned(new DiscardCheckingContext);

1259 DiscardCheckingContext* context = context_owned.get();

1260

1261 FakeOutputSurfaceClient output_surface_client;

1262 scoped_ptr<NonReshapableOutputSurface> output_surface(

1263 new NonReshapableOutputSurface(context_owned.Pass()));

1264 CHECK(output_surface->BindToClient(&output_surface_client));

1265 output_surface->set_fixed_size(gfx::Size(100, 100));

1266

1267 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

1268 new TestSharedBitmapManager());

1269 scoped_ptr<ResourceProvider> resource_provider(

1270 ResourceProvider::Create(output_surface.get(),

1271 shared_bitmap_manager.get(),

1272 NULL,

1273 NULL,

1274 0,

1275 false,

1276 1));

1277

1278 RendererSettings settings;

1279 settings.partial_swap_enabled = true;

1280 FakeRendererClient renderer_client;

1281 FakeRendererGL renderer(&renderer_client,

1282 &settings,

1283 output_surface.get(),

1284 resource_provider.get());

1285 EXPECT_TRUE(renderer.Capabilities().using_partial_swap);

1286

1287 gfx::Rect viewport_rect(100, 100);

1288 gfx::Rect clip_rect(100, 100);

1289

1290 {

1291 // Partial frame, should not discard.

1292 RenderPassId root_pass_id(1, 0);

1293 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1294 root_pass_id,

1295 viewport_rect,

1296 gfx::Transform());

1297 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1298 root_pass->damage_rect = gfx::Rect(2, 2, 3, 3);

1299

1300 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1301 renderer.DrawFrame(&render_passes_in_draw_order_,

1302 1.f,

1303 viewport_rect,

1304 clip_rect,

1305 false);

1306 EXPECT_EQ(0, context->discarded());

1307 context->reset();

1308 }

1309 {

1310 // Full frame, should discard.

1311 RenderPassId root_pass_id(1, 0);

1312 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1313 root_pass_id,

1314 viewport_rect,

1315 gfx::Transform());

1316 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1317 root_pass->damage_rect = root_pass->output_rect;

1318

1319 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1320 renderer.DrawFrame(&render_passes_in_draw_order_,

1321 1.f,

1322 viewport_rect,

1323 clip_rect,

1324 false);

1325 EXPECT_EQ(1, context->discarded());

1326 context->reset();

1327 }

1328 {

1329 // Full frame, external scissor is set, should not discard.

1330 output_surface->set_has_external_stencil_test(true);

1331 RenderPassId root_pass_id(1, 0);

1332 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1333 root_pass_id,

1334 viewport_rect,

1335 gfx::Transform());

1336 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1337 root_pass->damage_rect = root_pass->output_rect;

1338 root_pass->has_transparent_background = false;

1339

1340 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1341 renderer.DrawFrame(&render_passes_in_draw_order_,

1342 1.f,

1343 viewport_rect,

1344 clip_rect,

1345 false);

1346 EXPECT_EQ(0, context->discarded());

1347 context->reset();

1348 output_surface->set_has_external_stencil_test(false);

1349 }

1350 {

1351 // Full frame, clipped, should not discard.

1352 clip_rect = gfx::Rect(10, 10, 10, 10);

1353 RenderPassId root_pass_id(1, 0);

1354 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1355 root_pass_id,

1356 viewport_rect,

1357 gfx::Transform());

1358 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1359 root_pass->damage_rect = root_pass->output_rect;

1360

1361 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1362 renderer.DrawFrame(&render_passes_in_draw_order_,

1363 1.f,

1364 viewport_rect,

1365 clip_rect,

1366 false);

1367 EXPECT_EQ(0, context->discarded());

1368 context->reset();

1369 }

1370 {

1371 // Full frame, doesn't cover the surface, should not discard.

1372 viewport_rect = gfx::Rect(10, 10, 10, 10);

1373 RenderPassId root_pass_id(1, 0);

1374 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1375 root_pass_id,

1376 viewport_rect,

1377 gfx::Transform());

1378 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1379 root_pass->damage_rect = root_pass->output_rect;

1380

1381 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1382 renderer.DrawFrame(&render_passes_in_draw_order_,

1383 1.f,

1384 viewport_rect,

1385 clip_rect,

1386 false);

1387 EXPECT_EQ(0, context->discarded());

1388 context->reset();

1389 }

1390 {

1391 // Full frame, doesn't cover the surface (no offset), should not discard.

1392 clip_rect = gfx::Rect(100, 100);

1393 viewport_rect = gfx::Rect(50, 50);

1394 RenderPassId root_pass_id(1, 0);

1395 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1396 root_pass_id,

1397 viewport_rect,

1398 gfx::Transform());

1399 AddQuad(root_pass, viewport_rect, SK_ColorGREEN);

1400 root_pass->damage_rect = root_pass->output_rect;

1401

1402 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1403 renderer.DrawFrame(&render_passes_in_draw_order_,

1404 1.f,

1405 viewport_rect,

1406 clip_rect,

1407 false);

1408 EXPECT_EQ(0, context->discarded());

1409 context->reset();

1410 }

1411 }

1412

1413 class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {

1414 public:

1415 MOCK_METHOD4(viewport, void(GLint x, GLint y, GLsizei width, GLsizei height));

1416 MOCK_METHOD4(scissor, void(GLint x, GLint y, GLsizei width, GLsizei height));

1417 };

1418

1419 TEST_F(GLRendererTest, ScissorAndViewportWithinNonreshapableSurface) {

1420 // In Android WebView, the OutputSurface is unable to respect reshape() calls

1421 // and maintains a fixed size. This test verifies that glViewport and

1422 // glScissor's Y coordinate is flipped correctly in this environment, and that

1423 // the glViewport can be at a nonzero origin within the surface.

1424 scoped_ptr<FlippedScissorAndViewportContext> context_owned(

1425 new FlippedScissorAndViewportContext);

1426

1427 // We expect exactly one call to viewport on this context and exactly two

1428 // to scissor (one to scissor the clear, one to scissor the quad draw).

1429 EXPECT_CALL(*context_owned, viewport(10, 390, 100, 100));

1430 EXPECT_CALL(*context_owned, scissor(10, 390, 100, 100));

1431 EXPECT_CALL(*context_owned, scissor(30, 450, 20, 20));

1432

1433 FakeOutputSurfaceClient output_surface_client;

1434 scoped_ptr<OutputSurface> output_surface(

1435 new NonReshapableOutputSurface(context_owned.Pass()));

1436 CHECK(output_surface->BindToClient(&output_surface_client));

1437

1438 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

1439 new TestSharedBitmapManager());

1440 scoped_ptr<ResourceProvider> resource_provider(

1441 ResourceProvider::Create(output_surface.get(),

1442 shared_bitmap_manager.get(),

1443 NULL,

1444 NULL,

1445 0,

1446 false,

1447 1));

1448

1449 RendererSettings settings;

1450 FakeRendererClient renderer_client;

1451 FakeRendererGL renderer(&renderer_client,

1452 &settings,

1453 output_surface.get(),

1454 resource_provider.get());

1455 EXPECT_FALSE(renderer.Capabilities().using_partial_swap);

1456

1457 gfx::Rect device_viewport_rect(10, 10, 100, 100);

1458 gfx::Rect viewport_rect(device_viewport_rect.size());

1459 gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);

1460

1461 RenderPassId root_pass_id(1, 0);

1462 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,

1463 root_pass_id,

1464 viewport_rect,

1465 gfx::Transform());

1466 AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);

1467

1468 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1469 renderer.DrawFrame(&render_passes_in_draw_order_,

1470 1.f,

1471 device_viewport_rect,

1472 device_viewport_rect,

1473 false);

1474 }

1475

1476 TEST_F(GLRendererTest, DrawFramePreservesFramebuffer) {

1477 // When using render-to-FBO to display the surface, all rendering is done

1478 // to a non-zero FBO. Make sure that the framebuffer is always restored to

1479 // the correct framebuffer during rendering, if changed.

1480 // Note: there is one path that will set it to 0, but that is after the render

1481 // has finished.

1482 FakeOutputSurfaceClient output_surface_client;

1483 scoped_ptr<FakeOutputSurface> output_surface(

1484 FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create().Pass()));

1485 CHECK(output_surface->BindToClient(&output_surface_client));

1486

1487 scoped_ptr<SharedBitmapManager> shared_bitmap_manager(

1488 new TestSharedBitmapManager());

1489 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(

1490 output_surface.get(), shared_bitmap_manager.get(), NULL, NULL, 0, false,

1491 1));

1492

1493 RendererSettings settings;

1494 FakeRendererClient renderer_client;

1495 FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),

1496 resource_provider.get());

1497 EXPECT_FALSE(renderer.Capabilities().using_partial_swap);

1498

1499 gfx::Rect device_viewport_rect(0, 0, 100, 100);

1500 gfx::Rect viewport_rect(device_viewport_rect.size());

1501 gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);

1502

1503 RenderPassId root_pass_id(1, 0);

1504 TestRenderPass* root_pass =

1505 AddRenderPass(&render_passes_in_draw_order_, root_pass_id, viewport_rect,

1506 gfx::Transform());

1507 AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);

1508

1509 unsigned fbo;

1510 gpu::gles2::GLES2Interface* gl =

1511 output_surface->context_provider()->ContextGL();

1512 gl->GenFramebuffers(1, &fbo);

1513 output_surface->set_framebuffer(fbo);

1514

1515 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1516 renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, device_viewport_rect,

1517 device_viewport_rect, false);

1518

1519 int bound_fbo;

1520 gl->GetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo);

1521 EXPECT_EQ(static_cast<int>(fbo), bound_fbo);

1522 }

1523

1524 TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {

1525 gfx::Rect viewport_rect(1, 1);

1526

1527 gfx::Rect child_rect(50, 50);

1528 RenderPassId child_pass_id(2, 0);

1529 TestRenderPass* child_pass;

1530

1531 RenderPassId root_pass_id(1, 0);

1532 TestRenderPass* root_pass;

1533

1534 ResourceProvider::ResourceId mask = resource_provider_->CreateResource(

1535 gfx::Size(20, 12), GL_CLAMP_TO_EDGE,

1536 ResourceProvider::TEXTURE_HINT_IMMUTABLE,

1537 resource_provider_->best_texture_format());

1538 resource_provider_->AllocateForTesting(mask);

1539

1540 SkScalar matrix[20];

1541 float amount = 0.5f;

1542 matrix[0] = 0.213f + 0.787f * amount;

1543 matrix[1] = 0.715f - 0.715f * amount;

1544 matrix[2] = 1.f - (matrix[0] + matrix[1]);

1545 matrix[3] = matrix[4] = 0;

1546 matrix[5] = 0.213f - 0.213f * amount;

1547 matrix[6] = 0.715f + 0.285f * amount;

1548 matrix[7] = 1.f - (matrix[5] + matrix[6]);

1549 matrix[8] = matrix[9] = 0;

1550 matrix[10] = 0.213f - 0.213f * amount;

1551 matrix[11] = 0.715f - 0.715f * amount;

1552 matrix[12] = 1.f - (matrix[10] + matrix[11]);

1553 matrix[13] = matrix[14] = 0;

1554 matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;

1555 matrix[18] = 1;

1556 skia::RefPtr<SkColorFilter> color_filter(

1557 skia::AdoptRef(SkColorMatrixFilter::Create(matrix)));

1558 skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(

1559 SkColorFilterImageFilter::Create(color_filter.get(), NULL));

1560 FilterOperations filters;

1561 filters.Append(FilterOperation::CreateReferenceFilter(filter));

1562

1563 gfx::Transform transform_causing_aa;

1564 transform_causing_aa.Rotate(20.0);

1565

1566 for (int i = 0; i <= LAST_BLEND_MODE; ++i) {

1567 BlendMode blend_mode = static_cast<BlendMode>(i);

1568 SkXfermode::Mode xfer_mode = BlendModeToSkXfermode(blend_mode);

1569 settings_.force_blending_with_shaders = (blend_mode != BLEND_MODE_NONE);

1570 // RenderPassProgram

1571 render_passes_in_draw_order_.clear();

1572 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1573 child_pass_id,

1574 child_rect,

1575 gfx::Transform());

1576

1577 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1578 root_pass_id,

1579 viewport_rect,

1580 gfx::Transform());

1581

1582 AddRenderPassQuad(root_pass,

1583 child_pass,

1584 0,

1585 FilterOperations(),

1586 gfx::Transform(),

1587 xfer_mode);

1588

1589 renderer_->DecideRenderPassAllocationsForFrame(

1590 render_passes_in_draw_order_);

1591 renderer_->DrawFrame(&render_passes_in_draw_order_,

1592 1.f,

1593 viewport_rect,

1594 viewport_rect,

1595 false);

1596 TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);

1597

1598 // RenderPassColorMatrixProgram

1599 render_passes_in_draw_order_.clear();

1600

1601 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1602 child_pass_id,

1603 child_rect,

1604 transform_causing_aa);

1605

1606 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1607 root_pass_id,

1608 viewport_rect,

1609 gfx::Transform());

1610

1611 AddRenderPassQuad(

1612 root_pass, child_pass, 0, filters, gfx::Transform(), xfer_mode);

1613

1614 renderer_->DecideRenderPassAllocationsForFrame(

1615 render_passes_in_draw_order_);

1616 renderer_->DrawFrame(&render_passes_in_draw_order_,

1617 1.f,

1618 viewport_rect,

1619 viewport_rect,

1620 false);

1621 TestRenderPassColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);

1622

1623 // RenderPassMaskProgram

1624 render_passes_in_draw_order_.clear();

1625

1626 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1627 child_pass_id,

1628 child_rect,

1629 gfx::Transform());

1630

1631 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1632 root_pass_id,

1633 viewport_rect,

1634 gfx::Transform());

1635

1636 AddRenderPassQuad(root_pass,

1637 child_pass,

1638 mask,

1639 FilterOperations(),

1640 gfx::Transform(),

1641 xfer_mode);

1642

1643 renderer_->DecideRenderPassAllocationsForFrame(

1644 render_passes_in_draw_order_);

1645 renderer_->DrawFrame(&render_passes_in_draw_order_,

1646 1.f,

1647 viewport_rect,

1648 viewport_rect,

1649 false);

1650 TestRenderPassMaskProgram(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,

1651 blend_mode);

1652

1653 // RenderPassMaskColorMatrixProgram

1654 render_passes_in_draw_order_.clear();

1655

1656 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1657 child_pass_id,

1658 child_rect,

1659 gfx::Transform());

1660

1661 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1662 root_pass_id,

1663 viewport_rect,

1664 gfx::Transform());

1665

1666 AddRenderPassQuad(

1667 root_pass, child_pass, mask, filters, gfx::Transform(), xfer_mode);

1668

1669 renderer_->DecideRenderPassAllocationsForFrame(

1670 render_passes_in_draw_order_);

1671 renderer_->DrawFrame(&render_passes_in_draw_order_,

1672 1.f,

1673 viewport_rect,

1674 viewport_rect,

1675 false);

1676 TestRenderPassMaskColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM,

1677 SAMPLER_TYPE_2D, blend_mode);

1678

1679 // RenderPassProgramAA

1680 render_passes_in_draw_order_.clear();

1681

1682 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1683 child_pass_id,

1684 child_rect,

1685 transform_causing_aa);

1686

1687 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1688 root_pass_id,

1689 viewport_rect,

1690 gfx::Transform());

1691

1692 AddRenderPassQuad(root_pass,

1693 child_pass,

1694 0,

1695 FilterOperations(),

1696 transform_causing_aa,

1697 xfer_mode);

1698

1699 renderer_->DecideRenderPassAllocationsForFrame(

1700 render_passes_in_draw_order_);

1701 renderer_->DrawFrame(&render_passes_in_draw_order_,

1702 1.f,

1703 viewport_rect,

1704 viewport_rect,

1705 false);

1706 TestRenderPassProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);

1707

1708 // RenderPassColorMatrixProgramAA

1709 render_passes_in_draw_order_.clear();

1710

1711 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1712 child_pass_id,

1713 child_rect,

1714 transform_causing_aa);

1715

1716 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1717 root_pass_id,

1718 viewport_rect,

1719 gfx::Transform());

1720

1721 AddRenderPassQuad(

1722 root_pass, child_pass, 0, filters, transform_causing_aa, xfer_mode);

1723

1724 renderer_->DecideRenderPassAllocationsForFrame(

1725 render_passes_in_draw_order_);

1726 renderer_->DrawFrame(&render_passes_in_draw_order_,

1727 1.f,

1728 viewport_rect,

1729 viewport_rect,

1730 false);

1731 TestRenderPassColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);

1732

1733 // RenderPassMaskProgramAA

1734 render_passes_in_draw_order_.clear();

1735

1736 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1737 child_pass_id,

1738 child_rect,

1739 transform_causing_aa);

1740

1741 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1742 root_pass_id,

1743 viewport_rect,

1744 gfx::Transform());

1745

1746 AddRenderPassQuad(root_pass,

1747 child_pass,

1748 mask,

1749 FilterOperations(),

1750 transform_causing_aa,

1751 xfer_mode);

1752

1753 renderer_->DecideRenderPassAllocationsForFrame(

1754 render_passes_in_draw_order_);

1755 renderer_->DrawFrame(&render_passes_in_draw_order_,

1756 1.f,

1757 viewport_rect,

1758 viewport_rect,

1759 false);

1760 TestRenderPassMaskProgramAA(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,

1761 blend_mode);

1762

1763 // RenderPassMaskColorMatrixProgramAA

1764 render_passes_in_draw_order_.clear();

1765

1766 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1767 child_pass_id,

1768 child_rect,

1769 transform_causing_aa);

1770

1771 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1772 root_pass_id,

1773 viewport_rect,

1774 transform_causing_aa);

1775

1776 AddRenderPassQuad(

1777 root_pass, child_pass, mask, filters, transform_causing_aa, xfer_mode);

1778

1779 renderer_->DecideRenderPassAllocationsForFrame(

1780 render_passes_in_draw_order_);

1781 renderer_->DrawFrame(&render_passes_in_draw_order_,

1782 1.f,

1783 viewport_rect,

1784 viewport_rect,

1785 false);

1786 TestRenderPassMaskColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM,

1787 SAMPLER_TYPE_2D, blend_mode);

1788 }

1789 }

1790

1791 // At this time, the AA code path cannot be taken if the surface's rect would

1792 // project incorrectly by the given transform, because of w<0 clipping.

1793 TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {

1794 gfx::Rect child_rect(50, 50);

1795 RenderPassId child_pass_id(2, 0);

1796 TestRenderPass* child_pass;

1797

1798 gfx::Rect viewport_rect(1, 1);

1799 RenderPassId root_pass_id(1, 0);

1800 TestRenderPass* root_pass;

1801

1802 gfx::Transform transform_preventing_aa;

1803 transform_preventing_aa.ApplyPerspectiveDepth(40.0);

1804 transform_preventing_aa.RotateAboutYAxis(-20.0);

1805 transform_preventing_aa.Scale(30.0, 1.0);

1806

1807 // Verify that the test transform and test rect actually do cause the clipped

1808 // flag to trigger. Otherwise we are not testing the intended scenario.

1809 bool clipped = false;

1810 MathUtil::MapQuad(transform_preventing_aa, gfx::QuadF(child_rect), &clipped);

1811 ASSERT_TRUE(clipped);

1812

1813 child_pass = AddRenderPass(&render_passes_in_draw_order_,

1814 child_pass_id,

1815 child_rect,

1816 transform_preventing_aa);

1817

1818 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1819 root_pass_id,

1820 viewport_rect,

1821 gfx::Transform());

1822

1823 AddRenderPassQuad(root_pass,

1824 child_pass,

1825 0,

1826 FilterOperations(),

1827 transform_preventing_aa,

1828 SkXfermode::kSrcOver_Mode);

1829

1830 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1831 renderer_->DrawFrame(&render_passes_in_draw_order_,

1832 1.f,

1833 viewport_rect,

1834 viewport_rect,

1835 false);

1836

1837 // If use_aa incorrectly ignores clipping, it will use the

1838 // RenderPassProgramAA shader instead of the RenderPassProgram.

1839 TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, BLEND_MODE_NONE);

1840 }

1841

1842 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {

1843 gfx::Rect viewport_rect(1, 1);

1844 RenderPassId root_pass_id(1, 0);

1845 TestRenderPass* root_pass;

1846

1847 gfx::Transform pixel_aligned_transform_causing_aa;

1848 pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f);

1849 pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f);

1850

1851 root_pass = AddRenderPass(&render_passes_in_draw_order_,

1852 root_pass_id,

1853 viewport_rect,

1854 gfx::Transform());

1855 AddTransformedQuad(root_pass,

1856 viewport_rect,

1857 SK_ColorYELLOW,

1858 pixel_aligned_transform_causing_aa);

1859

1860 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);

1861 renderer_->DrawFrame(&render_passes_in_draw_order_,

1862 1.f,

1863 viewport_rect,

1864 viewport_rect,

1865 false);

1866

1867 TestSolidColorProgramAA();

1868 }

1869

1870 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {

1871 public:

1872 OutputSurfaceMockContext() { test_capabilities_.gpu.post_sub_buffer = true; }

1873

1874 // Specifically override methods even if they are unused (used in conjunction

1875 // with StrictMock). We need to make sure that GLRenderer does not issue

1876 // framebuffer-related GLuint calls directly. Instead these are supposed to go

1877 // through the OutputSurface abstraction.

1878 MOCK_METHOD2(bindFramebuffer, void(GLenum target, GLuint framebuffer));

1879 MOCK_METHOD3(reshapeWithScaleFactor,

1880 void(int width, int height, float scale_factor));

1881 MOCK_METHOD4(drawElements,

1882 void(GLenum mode, GLsizei count, GLenum type, GLintptr offset));

1883 };

1884

1885 class MockOutputSurface : public OutputSurface {

1886 public:

1887 MockOutputSurface()

1888 : OutputSurface(

1889 TestContextProvider::Create(scoped_ptr<TestWebGraphicsContext3D>(

1890 new StrictMock<OutputSurfaceMockContext>))) {

1891 surface_size_ = gfx::Size(100, 100);

1892 }

1893 virtual ~MockOutputSurface() {}

1894

1895 MOCK_METHOD0(EnsureBackbuffer, void());

1896 MOCK_METHOD0(DiscardBackbuffer, void());

1897 MOCK_METHOD2(Reshape, void(const gfx::Size& size, float scale_factor));

1898 MOCK_METHOD0(BindFramebuffer, void());

1899 MOCK_METHOD1(SwapBuffers, void(CompositorFrame* frame));

1900 };

1901

1902 class MockOutputSurfaceTest : public GLRendererTest {

1903 protected:

1904 virtual void SetUp() {

1905 FakeOutputSurfaceClient output_surface_client_;

1906 CHECK(output_surface_.BindToClient(&output_surface_client_));

1907

1908 shared_bitmap_manager_.reset(new TestSharedBitmapManager());

1909 resource_provider_ = ResourceProvider::Create(&output_surface_,

1910 shared_bitmap_manager_.get(),

1911 NULL,

1912 NULL,

1913 0,

1914 false,

1915 1).Pass();

1916

1917 renderer_.reset(new FakeRendererGL(&renderer_client_,

1918 &settings_,

1919 &output_surface_,

1920 resource_provider_.get()));

1921 }

1922

1923 void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }

1924

1925 void DrawFrame(float device_scale_factor,

1926 const gfx::Rect& device_viewport_rect) {

1927 RenderPassId render_pass_id(1, 0);

1928 TestRenderPass* render_pass = AddRenderPass(&render_passes_in_draw_order_,

1929 render_pass_id,

1930 device_viewport_rect,

1931 gfx::Transform());

1932 AddQuad(render_pass, device_viewport_rect, SK_ColorGREEN);

1933

1934 EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());

1935

1936 EXPECT_CALL(output_surface_,

1937 Reshape(device_viewport_rect.size(), device_scale_factor))

1938 .Times(1);

1939

1940 EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);

1941

1942 EXPECT_CALL(*Context(), drawElements(_, _, _, _)).Times(1);

1943

1944 renderer_->DecideRenderPassAllocationsForFrame(

1945 render_passes_in_draw_order_);

1946 renderer_->DrawFrame(&render_passes_in_draw_order_,

1947 device_scale_factor,

1948 device_viewport_rect,

1949 device_viewport_rect,

1950 false);

1951 }

1952

1953 OutputSurfaceMockContext* Context() {

1954 return static_cast<OutputSurfaceMockContext*>(

1955 static_cast<TestContextProvider*>(output_surface_.context_provider())

1956 ->TestContext3d());

1957 }

1958

1959 RendererSettings settings_;

1960 FakeOutputSurfaceClient output_surface_client_;

1961 StrictMock<MockOutputSurface> output_surface_;

1962 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;

1963 scoped_ptr<ResourceProvider> resource_provider_;

1964 FakeRendererClient renderer_client_;

1965 scoped_ptr<FakeRendererGL> renderer_;

1966 };

1967

1968 TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) {

1969 gfx::Rect device_viewport_rect(1, 1);

1970 DrawFrame(1.f, device_viewport_rect);

1971

1972 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);

1973 renderer_->SwapBuffers(CompositorFrameMetadata());

1974 }

1975

1976 TEST_F(MockOutputSurfaceTest, DrawFrameAndResizeAndSwap) {

1977 gfx::Rect device_viewport_rect(1, 1);

1978

1979 DrawFrame(1.f, device_viewport_rect);

1980 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);

1981 renderer_->SwapBuffers(CompositorFrameMetadata());

1982

1983 device_viewport_rect = gfx::Rect(2, 2);

1984

1985 DrawFrame(2.f, device_viewport_rect);

1986 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);

1987 renderer_->SwapBuffers(CompositorFrameMetadata());

1988

1989 DrawFrame(2.f, device_viewport_rect);

1990 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);

1991 renderer_->SwapBuffers(CompositorFrameMetadata());

1992

1993 device_viewport_rect = gfx::Rect(1, 1);

1994

1995 DrawFrame(1.f, device_viewport_rect);

1996 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);

1997 renderer_->SwapBuffers(CompositorFrameMetadata());

1998 }

1999

2000 class GLRendererTestSyncPoint : public GLRendererPixelTest {

2001 protected:

2002 static void SyncPointCallback(int* callback_count) {

2003 ++(*callback_count);

2004 base::MessageLoop::current()->QuitWhenIdle();

2005 }

2006

2007 static void OtherCallback(int* callback_count) {

2008 ++(*callback_count);

2009 base::MessageLoop::current()->QuitWhenIdle();

2010 }

2011 };

2012

2013 #if !defined(OS_ANDROID)

2014 TEST_F(GLRendererTestSyncPoint, SignalSyncPointOnLostContext) {

2015 int sync_point_callback_count = 0;

2016 int other_callback_count = 0;

2017 gpu::gles2::GLES2Interface* gl =

2018 output_surface_->context_provider()->ContextGL();

2019 gpu::ContextSupport* context_support =

2020 output_surface_->context_provider()->ContextSupport();

2021

2022 uint32 sync_point = gl->InsertSyncPointCHROMIUM();

2023

2024 gl->LoseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,

2025 GL_INNOCENT_CONTEXT_RESET_ARB);

2026

2027 context_support->SignalSyncPoint(

2028 sync_point, base::Bind(&SyncPointCallback, &sync_point_callback_count));

2029 EXPECT_EQ(0, sync_point_callback_count);

2030 EXPECT_EQ(0, other_callback_count);

2031

2032 // Make the sync point happen.

2033 gl->Finish();

2034 // Post a task after the sync point.

2035 base::MessageLoop::current()->PostTask(

2036 FROM_HERE, base::Bind(&OtherCallback, &other_callback_count));

2037

2038 base::MessageLoop::current()->Run();

2039

2040 // The sync point shouldn't have happened since the context was lost.

2041 EXPECT_EQ(0, sync_point_callback_count);

2042 EXPECT_EQ(1, other_callback_count);

2043 }

2044

2045 TEST_F(GLRendererTestSyncPoint, SignalSyncPoint) {

2046 int sync_point_callback_count = 0;

2047 int other_callback_count = 0;

2048

2049 gpu::gles2::GLES2Interface* gl =

2050 output_surface_->context_provider()->ContextGL();

2051 gpu::ContextSupport* context_support =

2052 output_surface_->context_provider()->ContextSupport();

2053

2054 uint32 sync_point = gl->InsertSyncPointCHROMIUM();

2055

2056 context_support->SignalSyncPoint(

2057 sync_point, base::Bind(&SyncPointCallback, &sync_point_callback_count));

2058 EXPECT_EQ(0, sync_point_callback_count);

2059 EXPECT_EQ(0, other_callback_count);

2060

2061 // Make the sync point happen.

2062 gl->Finish();

2063 // Post a task after the sync point.

2064 base::MessageLoop::current()->PostTask(

2065 FROM_HERE, base::Bind(&OtherCallback, &other_callback_count));

2066

2067 base::MessageLoop::current()->Run();

2068

2069 // The sync point should have happened.

2070 EXPECT_EQ(1, sync_point_callback_count);

2071 EXPECT_EQ(1, other_callback_count);

2072 }

2073 #endif // OS_ANDROID

2074

2075 } // namespace

2076 } // namespace cc

OLD	NEW

« no previous file with comments | « cc/output/gl_renderer_draw_cache.cc ('k') | cc/output/output_surface.h » ('j') | no next file with comments »