cc: Use highp precision for texture coords if available and needed

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 "cc/output/compositor_frame_metadata.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 48 matching lines @@
  public:
   void TestShaders() {
     ASSERT_FALSE(renderer_->IsContextLost());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramOpaque());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramAA());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzle());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzleOpaque());
     EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzleAA());
     EXPECT_PROGRAM_VALID(renderer_->GetTileCheckerboardProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgramAA());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgramAA());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassColorMatrixProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskColorMatrixProgramAA());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassColorMatrixProgramAA());
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskColorMatrixProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetTextureProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetTextureProgramFlip());
-    EXPECT_PROGRAM_VALID(renderer_->GetTextureIOSurfaceProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetVideoYUVProgram());
-    // This is unlikely to be ever true in tests due to usage of osmesa.
-    if (renderer_->Capabilities().using_egl_image)
-      EXPECT_PROGRAM_VALID(renderer_->GetVideoStreamTextureProgram());
-    else
-      EXPECT_FALSE(renderer_->GetVideoStreamTextureProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetDebugBorderProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetSolidColorProgram());
     EXPECT_PROGRAM_VALID(renderer_->GetSolidColorProgramAA());
+    //TestShadersWithTexCoordPrecision(TexCoordPrecisionMedium);
+    TestShadersWithTexCoordPrecision(TexCoordPrecisionHigh);
     ASSERT_FALSE(renderer_->IsContextLost());
   }
+
+  void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) {
+    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgramAA(precision));
+    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgramAA(precision));
+    EXPECT_PROGRAM_VALID(
+        renderer_->GetRenderPassColorMatrixProgram(precision));
+    EXPECT_PROGRAM_VALID(
+        renderer_->GetRenderPassMaskColorMatrixProgramAA(precision));
+    EXPECT_PROGRAM_VALID(
+        renderer_->GetRenderPassColorMatrixProgramAA(precision));
+    EXPECT_PROGRAM_VALID(
+        renderer_->GetRenderPassMaskColorMatrixProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer_->GetTextureProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer_->GetTextureProgramFlip(precision));
+    EXPECT_PROGRAM_VALID(renderer_->GetTextureIOSurfaceProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer_->GetVideoYUVProgram(precision));
+    // This is unlikely to be ever true in tests due to usage of osmesa.
+    if (renderer_->Capabilities().using_egl_image)
+      EXPECT_PROGRAM_VALID(renderer_->GetVideoStreamTextureProgram(precision));
+    else
+      EXPECT_FALSE(renderer_->GetVideoStreamTextureProgram(precision));
+  }
 };
 
 namespace {
 
 #if !defined(OS_ANDROID)
 TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); }
 #endif
 
 class FrameCountingMemoryAllocationSettingContext
     : public TestWebGraphicsContext3D {
@@ skipping 101 matching lines @@
   scoped_ptr<LayerImpl> root_layer_;
   RenderPassList render_passes_in_draw_order_;
   size_t memory_allocation_limit_bytes_;
 };
 
 class FakeRendererGL : public GLRenderer {
  public:
   FakeRendererGL(RendererClient* client,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider)
-      : GLRenderer(client, output_surface, resource_provider) {}
+      : GLRenderer(client, output_surface, resource_provider, 0) {}
 
   // GLRenderer methods.
 
   // Changing visibility to public.
   using GLRenderer::Initialize;
   using GLRenderer::IsBackbufferDiscarded;
   using GLRenderer::DoDrawQuad;
   using GLRenderer::BeginDrawingFrame;
   using GLRenderer::FinishDrawingQuadList;
 };
 
 class GLRendererTest : public testing::Test {
  protected:
   GLRendererTest()
       : suggest_have_backbuffer_yes_(1, true),
         suggest_have_backbuffer_no_(1, false),
         output_surface_(FakeOutputSurface::Create3d(
             scoped_ptr<WebKit::WebGraphicsContext3D>(
                 new FrameCountingMemoryAllocationSettingContext()))),
-        resource_provider_(ResourceProvider::Create(output_surface_.get())),
+        resource_provider_(ResourceProvider::Create(output_surface_.get(), 0)),
         renderer_(&mock_client_,
                   output_surface_.get(),
                   resource_provider_.get()) {}
 
   virtual void SetUp() { renderer_.Initialize(); }
 
   void SwapBuffers() { renderer_.SwapBuffers(); }
 
   FrameCountingMemoryAllocationSettingContext* context() {
     return static_cast<FrameCountingMemoryAllocationSettingContext*>(
@@ skipping 11 matching lines @@
 
 // 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 testing::Test {
  protected:
   GLRendererShaderTest()
       : output_surface_(FakeOutputSurface::Create3d()),
-        resource_provider_(ResourceProvider::Create(output_surface_.get())),
+        resource_provider_(ResourceProvider::Create(output_surface_.get(), 0)),
         renderer_(GLRenderer::Create(&mock_client_, output_surface_.get(),
-                                     resource_provider_.get())) {
+                                     resource_provider_.get(), 0)) {
   }
 
   void TestRenderPassProgram() {
     EXPECT_PROGRAM_VALID(renderer_->render_pass_program_);
     EXPECT_TRUE(renderer_->program_shadow_ ==
         renderer_->render_pass_program_->program());
   }
 
   void TestRenderPassColorMatrixProgram() {
     EXPECT_PROGRAM_VALID(renderer_->render_pass_color_matrix_program_);
@@ skipping 277 matching lines @@
 };
 
 // This test isn't using the same fixture as GLRendererTest, and you can't mix
 // TEST() and TEST_F() with the same name, Hence LRC2.
 TEST(GLRendererTest2, InitializationDoesNotMakeSynchronousCalls) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new ForbidSynchronousCallContext)));
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   EXPECT_TRUE(renderer.Initialize());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
   LoseContextOnFirstGetContext() : context_lost_(false) {}
 
@@ skipping 18 matching lines @@
  private:
   bool context_lost_;
 };
 
 TEST(GLRendererTest2, InitializationWithQuicklyLostContextDoesNotAssert) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new LoseContextOnFirstGetContext)));
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   renderer.Initialize();
 }
 
 class ContextThatDoesNotSupportMemoryManagmentExtensions
     : public TestWebGraphicsContext3D {
  public:
   ContextThatDoesNotSupportMemoryManagmentExtensions() {}
 
   // WebGraphicsContext3D methods.
 
   // This method would normally do a glSwapBuffers under the hood.
   virtual void prepareTexture() {}
   virtual void setMemoryAllocationChangedCallbackCHROMIUM(
       WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* callback) {}
   virtual WebString getString(WebKit::WGC3Denum name) { return WebString(); }
 };
 
 TEST(
     GLRendererTest2,
     InitWithoutGpuMemManagerExtensionSupportShouldDefaultToNonZeroAllocation) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new ContextThatDoesNotSupportMemoryManagmentExtensions)));
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   renderer.Initialize();
 
   EXPECT_GT(mock_client.memory_allocation_limit_bytes(), 0ul);
 }
 
 class ClearCountingContext : public TestWebGraphicsContext3D {
  public:
   ClearCountingContext() : clear_(0) {}
 
   virtual void clear(WGC3Dbitfield) { clear_++; }
 
   int clear_count() const { return clear_; }
 
  private:
   int clear_;
 };
 
 TEST(GLRendererTest2, OpaqueBackground) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<WebKit::WebGraphicsContext3D>(new ClearCountingContext)));
   ClearCountingContext* context =
       static_cast<ClearCountingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   mock_client.root_render_pass()->has_transparent_background = false;
 
   EXPECT_TRUE(renderer.Initialize());
 
   renderer.DrawFrame(mock_client.render_passes_in_draw_order());
 
 // On DEBUG builds, render passes with opaque background clear to blue to
 // easily see regions that were not drawn on the screen.
 #ifdef NDEBUG
   EXPECT_EQ(0, context->clear_count());
 #else
   EXPECT_EQ(1, context->clear_count());
 #endif
 }
 
 TEST(GLRendererTest2, TransparentBackground) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<WebKit::WebGraphicsContext3D>(new ClearCountingContext)));
   ClearCountingContext* context =
       static_cast<ClearCountingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   mock_client.root_render_pass()->has_transparent_background = true;
 
   EXPECT_TRUE(renderer.Initialize());
 
   renderer.DrawFrame(mock_client.render_passes_in_draw_order());
 
   EXPECT_EQ(1, context->clear_count());
@@ skipping 50 matching lines @@
 
 TEST(GLRendererTest2, VisibilityChangeIsLastCall) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new VisibilityChangeIsLastCallTrackingContext)));
   VisibilityChangeIsLastCallTrackingContext* context =
       static_cast<VisibilityChangeIsLastCallTrackingContext*>(
           output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   EXPECT_TRUE(renderer.Initialize());
 
   bool last_call_was_set_visiblity = false;
   // Ensure that the call to setVisibilityCHROMIUM is the last call issue to the
   // GPU process, after glFlush is called, and after the RendererClient's
   // EnforceManagedMemoryPolicy is called. Plumb this tracking between both the
   // RenderClient and the Context by giving them both a pointer to a variable on
@@ skipping 38 matching lines @@
 };
 
 TEST(GLRendererTest2, ActiveTextureState) {
   FakeRendererClient fake_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new TextureStateTrackingContext)));
   TextureStateTrackingContext* context =
       static_cast<TextureStateTrackingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &fake_client, output_surface.get(), resource_provider.get());
 
   // During initialization we are allowed to set any texture parameters.
   EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());
   EXPECT_TRUE(renderer.Initialize());
 
   cc::RenderPass::Id id(1, 1);
   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
   pass->SetNew(id,
@@ skipping 64 matching lines @@
 
 TEST(GLRendererTest2, ShouldClearRootRenderPass) {
   NoClearRootRenderPassFakeClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new NoClearRootRenderPassMockContext)));
   NoClearRootRenderPassMockContext* mock_context =
       static_cast<NoClearRootRenderPassMockContext*>(
           output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
   EXPECT_TRUE(renderer.Initialize());
 
   gfx::Rect viewport_rect(mock_client.DeviceViewportSize());
   ScopedPtrVector<RenderPass>& render_passes =
       *mock_client.render_passes_in_draw_order();
   render_passes.clear();
 
   RenderPass::Id root_pass_id(1, 0);
@@ skipping 49 matching lines @@
  private:
   bool scissor_enabled_;
 };
 
 TEST(GLRendererTest2, ScissorTestWhenClearing) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new ScissorTestOnClearCheckingContext)));
   scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get()));
+      ResourceProvider::Create(output_surface.get(), 0));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
   EXPECT_TRUE(renderer.Initialize());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect viewport_rect(mock_client.DeviceViewportSize());
   ScopedPtrVector<RenderPass>& render_passes =
       *mock_client.render_passes_in_draw_order();
   render_passes.clear();
 
@@ skipping 294 matching lines @@
   MOCK_METHOD0(DiscardBackbuffer, void());
   MOCK_METHOD1(Reshape, void(gfx::Size size));
   MOCK_METHOD0(BindFramebuffer, void());
   MOCK_METHOD1(PostSubBuffer, void(gfx::Rect rect));
   MOCK_METHOD0(SwapBuffers, void());
 };
 
 class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
  protected:
   MockOutputSurfaceTest()
-      : resource_provider_(ResourceProvider::Create(&output_surface_)),
+      : resource_provider_(ResourceProvider::Create(&output_surface_, 0)),
         renderer_(this, &output_surface_, resource_provider_.get()) {}
 
   virtual void SetUp() { EXPECT_TRUE(renderer_.Initialize()); }
 
   void SwapBuffers() { renderer_.SwapBuffers(); }
 
   void DrawFrame() {
     gfx::Rect viewport_rect(DeviceViewportSize());
     ScopedPtrVector<RenderPass>* render_passes = render_passes_in_draw_order();
     render_passes->clear();
@@ skipping 58 matching lines @@
   }
 };
 
 TEST_F(MockOutputSurfaceTestWithSendCompositorFrame, DrawFrame) {
   EXPECT_CALL(output_surface_, SendFrameToParentCompositor(_)).Times(1);
   DrawFrame();
 }
 
 }  // namespace
 }  // namespace cc