Plumb SetVisible from ui::Compositor to the DirectRenderer.

cc/output/gl_renderer_unittest.cc

 // Copyright 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 "cc/output/gl_renderer.h"
 
 #include <stdint.h>
 
 #include <set>
 
@@ skipping 347 matching lines @@
     output_surface_ =
         FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create());
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get());
     renderer_ = base::WrapUnique(
         new FakeRendererGL(&renderer_client_, &settings_, output_surface_.get(),
                            resource_provider_.get()));
+    renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   FakeRendererClient renderer_client_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
@@ skipping 11 matching lines @@
     output_surface_ = FakeOutputSurface::Create3d();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get());
     renderer_.reset(new FakeRendererGL(&renderer_client_,
                                        &settings_,
                                        output_surface_.get(),
                                        resource_provider_.get()));
+    renderer_->SetVisible(true);
   }
 
   void TestRenderPassProgram(TexCoordPrecision precision,
                              BlendMode blend_mode) {
     EXPECT_PROGRAM_VALID(
         &renderer_->render_pass_program_[precision][blend_mode]);
     EXPECT_EQ(renderer_->render_pass_program_[precision][blend_mode].program(),
               renderer_->program_shadow_);
   }
 
@@ skipping 345 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
+  renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                     viewport_rect, gfx::Transform());
   root_pass->has_transparent_background = false;
 
   // On DEBUG builds, render passes with opaque background clear to blue to
   // easily see regions that were not drawn on the screen.
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
@@ skipping 22 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
+  renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                     viewport_rect, gfx::Transform());
   root_pass->has_transparent_background = true;
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1);
   EXPECT_CALL(*context, clear(_)).Times(1);
   DrawFrame(&renderer, viewport_rect);
@@ skipping 15 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
+  renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
   AddRenderPass(&render_passes_in_draw_order_,
                 RenderPassId(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
       .With(Args<2, 1>(ElementsAre(GL_COLOR_ATTACHMENT0)))
       .Times(1);
@@ skipping 39 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
+  renderer.SetVisible(true);
 
   // During initialization we are allowed to set any texture parameters.
   EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());
 
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 1),
                     gfx::Rect(100, 100), gfx::Transform());
   gpu::SyncToken mailbox_sync_token;
   AddOneOfEveryQuadType(root_pass, resource_provider.get(), RenderPassId(0, 0),
                         &mailbox_sync_token);
@@ skipping 64 matching lines @@
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.should_clear_root_render_pass = false;
 
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
+  renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(10, 10);
 
   RenderPassId child_pass_id(2, 0);
   RenderPass* child_pass =
       AddRenderPass(&render_passes_in_draw_order_, child_pass_id, viewport_rect,
                     gfx::Transform());
   AddQuad(child_pass, viewport_rect, SK_ColorBLUE);
 
   RenderPassId root_pass_id(1, 0);
@@ skipping 66 matching lines @@
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+  renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect grand_child_rect(25, 25);
   RenderPassId grand_child_pass_id(3, 0);
   RenderPass* grand_child_pass =
       AddRenderPass(&render_passes_in_draw_order_, grand_child_pass_id,
                     grand_child_rect, gfx::Transform());
   AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
@@ skipping 71 matching lines @@
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_TRUE(renderer.Capabilities().using_partial_swap);
+  renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(100, 100);
   gfx::Rect clip_rect(100, 100);
 
   {
     // Partial frame, should not discard.
     RenderPassId root_pass_id(1, 0);
     RenderPass* root_pass =
         AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
                       viewport_rect, gfx::Transform());
@@ skipping 114 matching lines @@
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+  renderer.SetVisible(true);
 
   gfx::Rect device_viewport_rect(10, 10, 100, 100);
   gfx::Rect viewport_rect(device_viewport_rect.size());
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
 
   RenderPassId root_pass_id(1, 0);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, root_pass_id, viewport_rect,
                     gfx::Transform());
   AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
@@ skipping 17 matching lines @@
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+  renderer.SetVisible(true);
 
   gfx::Rect device_viewport_rect(0, 0, 100, 100);
   gfx::Rect viewport_rect(device_viewport_rect.size());
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
 
   RenderPassId root_pass_id(1, 0);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, root_pass_id, viewport_rect,
                     gfx::Transform());
   AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
@@ skipping 363 matching lines @@
     CHECK(output_surface_.BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         &output_surface_, shared_bitmap_manager_.get());
 
     renderer_.reset(new FakeRendererGL(&renderer_client_,
                                        &settings_,
                                        &output_surface_,
                                        resource_provider_.get()));
+    renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   void DrawFrame(float device_scale_factor,
                  const gfx::Rect& device_viewport_rect,
                  bool transparent) {
     RenderPassId render_pass_id(1, 0);
     RenderPass* render_pass =
         AddRenderPass(&render_passes_in_draw_order_, render_pass_id,
@@ skipping 129 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
   std::unique_ptr<TextureMailboxDeleter> mailbox_deleter(
       new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
+  renderer.SetVisible(true);
 
   TestOverlayProcessor* processor =
       new TestOverlayProcessor(output_surface.get());
   processor->Initialize();
   renderer.SetOverlayProcessor(processor);
   std::unique_ptr<TestOverlayProcessor::Validator> validator(
       new TestOverlayProcessor::Validator);
   output_surface->SetOverlayCandidateValidator(validator.get());
 
   gfx::Rect viewport_rect(1, 1);
@@ skipping 138 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
   std::unique_ptr<TextureMailboxDeleter> mailbox_deleter(
       new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
 
   RendererSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
+  renderer.SetVisible(true);
 
   SingleOverlayOnTopProcessor* processor =
       new SingleOverlayOnTopProcessor(output_surface.get());
   processor->Initialize();
   renderer.SetOverlayProcessor(processor);
 
   gfx::Rect viewport_rect(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                     viewport_rect, gfx::Transform());
@@ skipping 59 matching lines @@
 
     std::unique_ptr<ResourceProvider> resource_provider =
         FakeResourceProvider::Create(output_surface.get(), nullptr);
 
     RendererSettings settings;
     settings.partial_swap_enabled = partial_swap;
     FakeRendererClient renderer_client;
     FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                             resource_provider.get());
     EXPECT_EQ(partial_swap, renderer.Capabilities().using_partial_swap);
+    renderer.SetVisible(true);
 
     gfx::Rect viewport_rect(100, 100);
     gfx::Rect clip_rect(100, 100);
 
     {
       RenderPassId root_pass_id(1, 0);
       RenderPass* root_pass =
           AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
                         viewport_rect, gfx::Transform());
       AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
@@ skipping 57 matching lines @@
   class MockContextSupport : public TestContextSupport {
    public:
     MockContextSupport() {}
     MOCK_METHOD1(SetAggressivelyFreeResources,
                  void(bool aggressively_free_resources));
     MOCK_METHOD2(SetClientVisible, void(int client_id, bool is_visible));
     MOCK_CONST_METHOD0(AnyClientsVisible, bool());
   };
 
   void SetUp() override {
-    auto context_support = base::WrapUnique(new MockContextSupport());
+    auto context_support = base::MakeUnique<MockContextSupport>();
     context_support_ptr_ = context_support.get();
     context_provider_ = new MockContextProvider(std::move(context_support));
     output_surface_ = FakeOutputSurface::Create3d(context_provider_);
     output_surface_->BindToClient(&output_surface_client_);
     resource_provider_ =
         FakeResourceProvider::Create(output_surface_.get(), nullptr);
-    renderer_ = base::WrapUnique(new GLRenderer(
-        &renderer_client_, &tree_settings_, output_surface_.get(),
-        resource_provider_.get(), NULL, 0));
+    renderer_ = base::MakeUnique<GLRenderer>(
+        &renderer_client_, &settings_, output_surface_.get(),
+        resource_provider_.get(), nullptr, 0);
   }
 
   FakeRendererClient renderer_client_;
-  RendererSettings tree_settings_;
+  RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   MockContextSupport* context_support_ptr_;
   scoped_refptr<MockContextProvider> context_provider_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<Renderer> renderer_;
 };
 
 TEST_F(GLRendererWithMockContextTest,
        ContextPurgedWhenRendererBecomesInvisible) {
-  EXPECT_TRUE(renderer_->visible());
-
   // Ensure our expectations run in order.
   ::testing::InSequence s;
 
-  EXPECT_CALL(*(context_support_ptr_), SetClientVisible(0, false));
-  EXPECT_CALL(*(context_support_ptr_), AnyClientsVisible())
+  EXPECT_CALL(*context_support_ptr_, SetClientVisible(0, true));
+  EXPECT_CALL(*context_support_ptr_, AnyClientsVisible())
+      .WillOnce(Return(true));
+  EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(false));
+  renderer_->SetVisible(true);
+  Mock::VerifyAndClearExpectations(context_support_ptr_);
+
+  EXPECT_TRUE(renderer_->visible());
+
+  EXPECT_CALL(*context_support_ptr_, SetClientVisible(0, false));
+  EXPECT_CALL(*context_support_ptr_, AnyClientsVisible())
       .WillOnce(Return(false));
-  EXPECT_CALL(*(context_provider_.get()), DeleteCachedResources());
-  EXPECT_CALL(*(context_support_ptr_), SetAggressivelyFreeResources(true));
+  EXPECT_CALL(*context_provider_, DeleteCachedResources());
+  EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
-
-  // Ensure all expectations have been satisfied after the call to SetVisible.
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 
   EXPECT_FALSE(renderer_->visible());
 }
 
 }  // namespace
 }  // namespace cc