[cc] Add nearest neighbor filtering for TextureLayer.

cc/resources/resource_provider_unittest.cc

Index: cc/resources/resource_provider_unittest.cc
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index e507ad67a93558d64c805a6edc69db2be348791a..9346c620122544b5a982c7f527b2f320319312ba 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -2603,89 +2603,130 @@ TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) {
   EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
 }
 
-TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D) {
-  // Mailboxing is only supported for GL textures.
-  if (GetParam() != ResourceProvider::GLTexture)
-    return;
+class ResourceProviderTestTextureMailboxGLFilters
+    : public ResourceProviderTest {
+ public:
+  static void RunTest(TestSharedBitmapManager* shared_bitmap_manager,
+                      TestGpuMemoryBufferManager* gpu_memory_buffer_manager,
+                      BlockingTaskRunner* main_thread_task_runner,
+                      bool mailbox_nearest_neighbor,
+                      GLenum sampler_filter) {
+    scoped_ptr<TextureStateTrackingContext> context_owned(
+        new TextureStateTrackingContext);
+    TextureStateTrackingContext* context = context_owned.get();
 
-  scoped_ptr<TextureStateTrackingContext> context_owned(
-      new TextureStateTrackingContext);
-  TextureStateTrackingContext* context = context_owned.get();
+    FakeOutputSurfaceClient output_surface_client;
+    scoped_ptr<OutputSurface> output_surface(
+        FakeOutputSurface::Create3d(context_owned.Pass()));
+    CHECK(output_surface->BindToClient(&output_surface_client));
 
-  FakeOutputSurfaceClient output_surface_client;
-  scoped_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(context_owned.Pass()));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+    scoped_ptr<ResourceProvider> resource_provider(
+        ResourceProvider::Create(output_surface.get(),
+                                 shared_bitmap_manager,
+                                 gpu_memory_buffer_manager,
+                                 main_thread_task_runner,
+                                 0,
+                                 false,
+                                 1));
 
-  scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(output_surface.get(),
-                               shared_bitmap_manager_.get(),
-                               gpu_memory_buffer_manager_.get(),
-                               main_thread_task_runner_.get(),
-                               0,
-                               false,
-                               1));
+    unsigned texture_id = 1;
+    uint32 sync_point = 30;
+    unsigned target = GL_TEXTURE_2D;
 
-  unsigned texture_id = 1;
-  uint32 sync_point = 30;
-  unsigned target = GL_TEXTURE_2D;
+    EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
+    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+    EXPECT_CALL(*context, insertSyncPoint()).Times(0);
+    EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
+    EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
 
-  EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-  EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
-  EXPECT_CALL(*context, insertSyncPoint()).Times(0);
-  EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
-  EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
+    gpu::Mailbox gpu_mailbox;
+    memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
+    uint32 release_sync_point = 0;
+    bool lost_resource = false;
+    BlockingTaskRunner* mailbox_task_runner = NULL;
+    scoped_ptr<SingleReleaseCallbackImpl> callback =
+        SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
+                                                     &release_sync_point,
+                                                     &lost_resource,
+                                                     &mailbox_task_runner));
 
-  gpu::Mailbox gpu_mailbox;
-  memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
-  uint32 release_sync_point = 0;
-  bool lost_resource = false;
-  BlockingTaskRunner* main_thread_task_runner = NULL;
-  scoped_ptr<SingleReleaseCallbackImpl> callback =
-      SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
-                                                   &release_sync_point,
-                                                   &lost_resource,
-                                                   &main_thread_task_runner));
+    TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+    mailbox.set_nearest_neighbor(mailbox_nearest_neighbor);
 
-  TextureMailbox mailbox(gpu_mailbox, target, sync_point);
+    ResourceProvider::ResourceId id =
+        resource_provider->CreateResourceFromTextureMailbox(mailbox,
+                                                            callback.Pass());
+    EXPECT_NE(0u, id);
 
-  ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(
-          mailbox, callback.Pass());
-  EXPECT_NE(0u, id);
+    Mock::VerifyAndClearExpectations(context);
 
-  Mock::VerifyAndClearExpectations(context);
+    {
+      // Mailbox sync point WaitSyncPoint before using the texture.
+      EXPECT_CALL(*context, waitSyncPoint(sync_point));
+      resource_provider->WaitSyncPointIfNeeded(id);
+      Mock::VerifyAndClearExpectations(context);
 
-  {
-    // Mailbox sync point WaitSyncPoint before using the texture.
-    EXPECT_CALL(*context, waitSyncPoint(sync_point));
-    resource_provider->WaitSyncPointIfNeeded(id);
-    Mock::VerifyAndClearExpectations(context);
+      // Using the texture does a consume of the mailbox.
+      EXPECT_CALL(*context, bindTexture(target, texture_id)).Times(2);
+      EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
 
-    // Using the texture does a consume of the mailbox.
-    EXPECT_CALL(*context, bindTexture(target, texture_id));
-    EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
+      EXPECT_CALL(*context, insertSyncPoint()).Times(0);
+      EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
 
-    EXPECT_CALL(*context, insertSyncPoint()).Times(0);
-    EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
+      // The sampler will reset these because |nearest_neighbor| was set on the

[danakj, 2014/11/18 16:17:05]

These expectations will differ depending on nearest_neighbour| though, no?

[jackhou1, 2014/11/19 03:33:17]

Updated the comment.

At the moment the tests are set up so that the filter always changes, so these
get called either way. If you like, I can add the NearestToNearest and
LinearToLinear cases, but I'm not sure if there's much benefit to that.

[danakj, 2014/11/19 16:01:56]

Ah right I missed the sampler part, thanks for the comment.

Do we have any test that shows we don't redundantly set the texParameters with
every texture lock if it's not needed? I think that's something we want to
maintain (which the test used to test) so it's worth testing to not regress.

+      // mailbox.
+      EXPECT_CALL(
+          *context,
+          texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, sampler_filter));
+      EXPECT_CALL(
+          *context,
+          texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, sampler_filter));
 
-    ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
-    Mock::VerifyAndClearExpectations(context);
+      ResourceProvider::ScopedSamplerGL lock(
+          resource_provider.get(), id, sampler_filter);
+      Mock::VerifyAndClearExpectations(context);
 
-    // When done with it, a sync point should be inserted, but no produce is
-    // necessary.
-    EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-    EXPECT_CALL(*context, insertSyncPoint());
-    EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
+      // When done with it, a sync point should be inserted, but no produce is
+      // necessary.
+      EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
+      EXPECT_CALL(*context, insertSyncPoint());
+      EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
 
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
-    EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
+      EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+      EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
+    }
+
+    resource_provider->DeleteResource(id);
+    EXPECT_EQ(0u, release_sync_point);
+    EXPECT_FALSE(lost_resource);
+    EXPECT_EQ(main_thread_task_runner, mailbox_task_runner);
   }
+};
 
-  resource_provider->DeleteResource(id);
-  EXPECT_EQ(0u, release_sync_point);
-  EXPECT_FALSE(lost_resource);
-  EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
+TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_NearestToLinear) {
+  // Mailboxing is only supported for GL textures.
+  if (GetParam() != ResourceProvider::GLTexture)
+    return;
+
+  ResourceProviderTestTextureMailboxGLFilters::RunTest(
+      shared_bitmap_manager_.get(),
+      gpu_memory_buffer_manager_.get(),
+      main_thread_task_runner_.get(),
+      true,
+      GL_LINEAR);
+}
+
+TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_LinearToNearest) {
+  // Mailboxing is only supported for GL textures.
+  if (GetParam() != ResourceProvider::GLTexture)
+    return;
+
+  ResourceProviderTestTextureMailboxGLFilters::RunTest(
+      shared_bitmap_manager_.get(),
+      gpu_memory_buffer_manager_.get(),
+      main_thread_task_runner_.get(),
+      false,
+      GL_NEAREST);
 }
 
 TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {