cc: Remove all impl-side caps from RendererCapabilitiesImpl.

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 127 matching lines @@
 
   void TestBasicShaders() {
     EXPECT_PROGRAM_VALID(renderer()->GetDebugBorderProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgramAA());
   }
 
   void TestShadersWithPrecision(TexCoordPrecision precision) {
     // This program uses external textures and sampler, so it won't compile
     // everywhere.
-    if (renderer()->Capabilities().using_egl_image)
+    if (context_provider()->ContextCapabilities().egl_image_external)
       EXPECT_PROGRAM_VALID(renderer()->GetVideoStreamTextureProgram(precision));
   }
 
   void TestShadersWithPrecisionAndBlend(TexCoordPrecision precision,
                                         BlendMode blend_mode) {
     EXPECT_PROGRAM_VALID(
         renderer()->GetRenderPassProgram(precision, blend_mode));
     EXPECT_PROGRAM_VALID(
         renderer()->GetRenderPassProgramAA(precision, blend_mode));
   }
 
   void TestShadersWithPrecisionAndSampler(TexCoordPrecision precision,
                                           SamplerType sampler) {
-    if (!renderer()->Capabilities().using_egl_image &&
+    if (!context_provider()->ContextCapabilities().egl_image_external &&
         sampler == SAMPLER_TYPE_EXTERNAL_OES) {
       // This will likely be hit in tests due to usage of osmesa.
       return;
     }
 
     EXPECT_PROGRAM_VALID(renderer()->GetTextureProgram(precision, sampler));
     EXPECT_PROGRAM_VALID(
         renderer()->GetNonPremultipliedTextureProgram(precision, sampler));
     EXPECT_PROGRAM_VALID(
         renderer()->GetTextureBackgroundProgram(precision, sampler));
@@ skipping 16 matching lines @@
               renderer()->GetVideoYUVProgram(precision, sampler, j, k, l));
         }
       }
     }
   }
 
   void TestShadersWithMasks(TexCoordPrecision precision,
                             SamplerType sampler,
                             BlendMode blend_mode,
                             bool mask_for_background) {
-    if (!renderer()->Capabilities().using_egl_image &&
+    if (!context_provider()->ContextCapabilities().egl_image_external &&
         sampler == SAMPLER_TYPE_EXTERNAL_OES) {
       // This will likely be hit in tests due to usage of osmesa.
       return;
     }
 
     EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgram(
         precision, sampler, blend_mode, mask_for_background));
     EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(
         precision, sampler, blend_mode, mask_for_background));
     EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(
@@ skipping 137 matching lines @@
   GLRendererWithDefaultHarnessTest() {
     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(
         &settings_, output_surface_.get(), resource_provider_.get()));
+    renderer_->Initialize();
     renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
 // Closing the namespace here so that GLRendererShaderTest can take advantage
 // of the friend relationship with GLRenderer and all of the mock classes
 // declared above it.
 }  // namespace
 
 class GLRendererShaderTest : public GLRendererTest {
  protected:
   GLRendererShaderTest() {
     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(&settings_, output_surface_.get(),
                                        resource_provider_.get()));
+    renderer_->Initialize();
     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 278 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
+  renderer.Initialize();
   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.
@@ skipping 20 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
+  renderer.Initialize();
   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);
@@ skipping 13 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
+  renderer.Initialize();
   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)))
@@ skipping 37 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
+  renderer.Initialize();
   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),
@@ skipping 62 matching lines @@
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.should_clear_root_render_pass = false;
 
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
+  renderer.Initialize();
   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);
 
@@ skipping 63 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
-  EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+  renderer.Initialize();
+  EXPECT_FALSE(renderer.use_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 68 matching lines @@
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
-  EXPECT_TRUE(renderer.Capabilities().using_partial_swap);
+  renderer.Initialize();

[enne (OOO), 2016/08/17 17:48:42]

Now that there's a required initialize, can there be dchecks at least in like
draw or swap that initialize has occurred?

[danakj, 2016/08/17 18:16:41]

Ya I did that to find all the places that need it, I can leave it in. Since you
can't DrawAndSwap without SetVisible(true), I think dchecking init in SetVisible
should work out.

+  EXPECT_TRUE(renderer.use_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,
@@ skipping 111 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
-  EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+  renderer.Initialize();
+  EXPECT_FALSE(renderer.use_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());
@@ skipping 16 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
-  EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+  renderer.Initialize();
+  EXPECT_FALSE(renderer.use_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());
@@ skipping 362 matching lines @@
   virtual void SetUp() {
     FakeOutputSurfaceClient output_surface_client_;
     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(&settings_, &output_surface_,
                                        resource_provider_.get()));
+    renderer_->Initialize();
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).Times(1);
     renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   void DrawFrame(float device_scale_factor,
                  const gfx::Rect& device_viewport_rect,
                  bool transparent) {
@@ skipping 139 matching lines @@
       new TestSharedBitmapManager());
   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;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
+  renderer.Initialize();
   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());
 
@@ skipping 138 matching lines @@
       new TestSharedBitmapManager());
   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;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
+  renderer.Initialize();
   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),
@@ skipping 58 matching lines @@
         FakeOutputSurface::Create3d(std::move(gl_owned)));
     CHECK(output_surface->BindToClient(&output_surface_client));
 
     std::unique_ptr<ResourceProvider> resource_provider =
         FakeResourceProvider::Create(output_surface.get(), nullptr);
 
     RendererSettings settings;
     settings.partial_swap_enabled = partial_swap;
     FakeRendererGL renderer(&settings, output_surface.get(),
                             resource_provider.get());
-    EXPECT_EQ(partial_swap, renderer.Capabilities().using_partial_swap);
+    renderer.Initialize();
+    EXPECT_EQ(partial_swap, renderer.use_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());
@@ skipping 68 matching lines @@
     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::MakeUnique<GLRenderer>(&settings_, output_surface_.get(),
                                      resource_provider_.get(), nullptr, 0);
+    renderer_->Initialize();
   }
 
   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<GLRenderer> renderer_;
 };
@@ skipping 14 matching lines @@
   EXPECT_CALL(*context_support_ptr_, AnyClientsVisible())
       .WillOnce(Return(false));
   EXPECT_CALL(*context_provider_, DeleteCachedResources());
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc