[cc] Add nearest neighbor filtering for TextureLayer.

cc/output/direct_renderer.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/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "cc/base/math_util.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 static gfx::Transform OrthoProjectionMatrix(float left,
                                             float right,
                                             float bottom,
                                             float top) {
   // Use the standard formula to map the clipping frustum to the cube from
   // [-1, -1, -1] to [1, 1, 1].
   float delta_x = right - left;
@@ skipping 99 matching lines @@
 
 DirectRenderer::DirectRenderer(RendererClient* client,
                                const LayerTreeSettings* settings,
                                OutputSurface* output_surface,
                                ResourceProvider* resource_provider)
     : Renderer(client, settings),
       output_surface_(output_surface),
       resource_provider_(resource_provider),
       overlay_processor_(
           new OverlayProcessor(output_surface, resource_provider)) {
+  //printf("DirectRenderer %p\n", this);
   overlay_processor_->Initialize();
 }
 
 DirectRenderer::~DirectRenderer() {}
 
 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
     const gfx::Vector2d& amount) {
   enlarge_pass_texture_amount_ = amount;
 }
 
@@ skipping 44 matching lines @@
                               texture.Pass());
     }
   }
 }
 
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
                                float device_scale_factor,
                                const gfx::Rect& device_viewport_rect,
                                const gfx::Rect& device_clip_rect,
                                bool disable_picture_quad_image_filtering) {
+  /*for (auto* render_pass : *render_passes_in_draw_order) {
+    for (auto& quad : render_pass->quad_list) {
+      if (quad.material == DrawQuad::TEXTURE_CONTENT) {
+        TextureDrawQuad& tq = static_cast<TextureDrawQuad&>(quad);
+        printf("DirectRenderer::DrawFrame texture quad %d %d\n", tq.nearest_neighbor, tq.resource_id);
+      }
+    }
+  }*/
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
                        render_passes_in_draw_order->size());
 
   const RenderPass* root_render_pass = render_passes_in_draw_order->back();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.render_passes_in_draw_order = render_passes_in_draw_order;
   frame.root_render_pass = root_render_pass;
@@ skipping 164 matching lines @@
     const DrawQuad& quad = *it;
     bool should_skip_quad = false;
 
     if (using_scissor_as_optimization) {
       SetScissorStateForQuadWithRenderPassScissor(
           frame, quad, render_pass_scissor, &should_skip_quad);
     } else {
       SetScissorStateForQuad(frame, quad);
     }
 
+    /*if (quad.material == DrawQuad::TEXTURE_CONTENT) {
+      const TextureDrawQuad& tquad = static_cast<const TextureDrawQuad&>(quad);
+      printf("DirectRenderer::DrawRenderPass %d %d\n", tquad.nearest_neighbor, tquad.resource_id);
+    }*/
     if (!should_skip_quad)
       DoDrawQuad(frame, &quad);
   }
   FinishDrawingQuadList();
 }
 
 bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
                                    const RenderPass* render_pass) {
   frame->current_render_pass = render_pass;
   frame->current_texture = NULL;
@@ skipping 25 matching lines @@
   ScopedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc