Use nearest neighbor filtering for non-translated quads

cc/tiled_layer_impl_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 "config.h"
 
 #include "cc/tiled_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/mock_quad_culler.h"
 #include "cc/tile_draw_quad.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/khronos/GLES2/gl2.h"
+#include <public/WebTransformationMatrix.h>
 
 using namespace cc;
 using namespace LayerTestCommon;
+using namespace WebKit;

[jamesr, 2012/11/09 18:40:09]

using statements aren't style guide compliant (neither are the other two, but
we'll have to fix those). add using declarations for the types you need

[Sami, 2012/11/11 16:56:27]

Done.

 
 namespace {
 
 // Create a default tiled layer with textures for all tiles and a default
 // visibility of the entire layer size.
 static scoped_ptr<TiledLayerImpl> createLayer(const gfx::Size& tileSize, const gfx::Size& layerSize, LayerTilingData::BorderTexelOption borderTexels)
 {
     scoped_ptr<TiledLayerImpl> layer = TiledLayerImpl::create(1);
     scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(tileSize, borderTexels);
     tiler->setBounds(layerSize);
@@ skipping 97 matching lines @@
         MockQuadCuller quadCuller;
         AppendQuadsData data;
         layer->appendQuads(quadCuller, data);
         EXPECT_TRUE(data.hadMissingTiles);
         EXPECT_EQ(quadCuller.quadList().size(), 4u);
         for (size_t i = 0; i < quadCuller.quadList().size(); ++i)
             EXPECT_NE(quadCuller.quadList()[i]->material(), DrawQuad::TiledContent);
     }
 }
 
-static void getQuads(QuadList& quads, SharedQuadStateList& sharedStates, gfx::Size tileSize, const gfx::Size& layerSize, LayerTilingData::BorderTexelOption borderTexelOption, const gfx::Rect& visibleContentRect)
+static void getQuads(QuadList& quads, SharedQuadStateList& sharedStates, gfx::Size tileSize, const gfx::Size& layerSize, LayerTilingData::BorderTexelOption borderTexelOption, const gfx::Rect& visibleContentRect, const WebTransformationMatrix drawTransform = WebTransformationMatrix())
 {
     scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, borderTexelOption);
     layer->setVisibleContentRect(visibleContentRect);
     layer->setBounds(layerSize);
+    layer->setDrawTransform(drawTransform);
 
     MockQuadCuller quadCuller(quads, sharedStates);
     AppendQuadsData data;
     layer->appendQuads(quadCuller, data);
 }
 
 // Test with both border texels and without.
 #define WITH_AND_WITHOUT_BORDER_TEST(testFixtureName)       \
     TEST(TiledLayerImplTest, testFixtureName##NoBorders)  \
     {                                                       \
@@ skipping 68 matching lines @@
     getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::NoBorderTexels, gfx::Rect(gfx::Point(), layerSize));
 
     for (size_t i = 0; i < quads.size(); ++i) {
         ASSERT_EQ(quads[i]->material(), DrawQuad::TiledContent) << quadString << i;
         TileDrawQuad* quad = static_cast<TileDrawQuad*>(quads[i]);
 
         EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
     }
 }
 
+TEST(TiledLayerImplTest, nearestFilteringForTranslatedQuads)
+{
+    gfx::Size tileSize(50, 50);
+    gfx::Size layerSize(250, 250);
+    QuadList quads;
+    SharedQuadStateList sharedStates;
+    getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::HasBorderTexels, gfx::Rect(gfx::Point(), layerSize));
+
+    for (size_t i = 0; i < quads.size(); ++i) {
+        ASSERT_EQ(quads[i]->material(), DrawQuad::TiledContent) << quadString << i;
+        TileDrawQuad* quad = static_cast<TileDrawQuad*>(quads[i]);
+
+        EXPECT_EQ(GL_NEAREST, quad->textureFilter()) << quadString << i;
+    }
+}
+
+TEST(TiledLayerImplTest, linearFilteringForScaledQuads)
+{
+    gfx::Size tileSize(50, 50);
+    gfx::Size layerSize(250, 250);
+    QuadList quads;
+    SharedQuadStateList sharedStates;
+    WebTransformationMatrix drawTransform;
+
+    drawTransform.scale(2);
+    getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::HasBorderTexels, gfx::Rect(gfx::Point(), layerSize), drawTransform);
+
+    for (size_t i = 0; i < quads.size(); ++i) {
+        ASSERT_EQ(quads[i]->material(), DrawQuad::TiledContent) << quadString << i;
+        TileDrawQuad* quad = static_cast<TileDrawQuad*>(quads[i]);
+
+        EXPECT_EQ(GL_LINEAR, quad->textureFilter()) << quadString << i;
+    }
+}
+
+TEST(TiledLayerImplTest, linearFilteringForTransformedQuads)
+{
+    gfx::Size tileSize(50, 50);
+    gfx::Size layerSize(250, 250);
+    QuadList quads;
+    SharedQuadStateList sharedStates;
+    WebTransformationMatrix drawTransform;
+
+    drawTransform.rotate3d(15, 30, 45);
+    getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::HasBorderTexels, gfx::Rect(gfx::Point(), layerSize), drawTransform);
+
+    for (size_t i = 0; i < quads.size(); ++i) {
+        ASSERT_EQ(quads[i]->material(), DrawQuad::TiledContent) << quadString << i;
+        TileDrawQuad* quad = static_cast<TileDrawQuad*>(quads[i]);
+
+        EXPECT_EQ(GL_LINEAR, quad->textureFilter()) << quadString << i;
+    }
+}
+
 }  // anonymous namespace