[cc] Add nearest neighbor filtering for TextureLayer.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 688 matching lines @@
         false,
         gfx::PointF(
             screen_space_rect.x() / overhang_resource_scaled_size.width(),
             screen_space_rect.y() / overhang_resource_scaled_size.height()),
         gfx::PointF(
             screen_space_rect.right() / overhang_resource_scaled_size.width(),
             screen_space_rect.bottom() /
                 overhang_resource_scaled_size.height()),
         screen_background_color,
         vertex_opacity,
+        false,
         false);
   }
 }
 
 DrawResult LayerTreeHostImpl::CalculateRenderPasses(
     FrameData* frame) {
+  //printf("LayerTreeHostImpl::CalculateRenderPasses\n");
   DCHECK(frame->render_passes.empty());
   DCHECK(CanDraw());
   DCHECK(active_tree_->root_layer());
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
 
   // If the root render surface has no visible damage, then don't generate a
   // frame at all.
   RenderSurfaceImpl* root_surface =
@@ skipping 117 matching lines @@
                                        &append_quads_data);
     } else if (it.represents_itself() &&
                !it->visible_content_rect().IsEmpty()) {
       bool occluded =
           occlusion_tracker.GetCurrentOcclusionForLayer(it->draw_transform())
               .IsOccluded(it->visible_content_rect());
       if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
         DCHECK_EQ(active_tree_, it->layer_tree_impl());
 
         frame->will_draw_layers.push_back(*it);
+        //printf("frame->will_draw_layers %p\n", *it);
 
         if (it->HasContributingDelegatedRenderPasses()) {
+          //printf("HasContributingDelegatedRenderPasses\n");
           RenderPassId contributing_render_pass_id =
               it->FirstContributingRenderPassId();
           while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
                  frame->render_passes_by_id.end()) {
             RenderPass* render_pass =
                 frame->render_passes_by_id[contributing_render_pass_id];
 
             AppendQuadsData append_quads_data(render_pass->id);
             AppendQuadsForLayer(render_pass,
                                 *it,
                                 occlusion_tracker,
                                 &append_quads_data);
 
             contributing_render_pass_id =
                 it->NextContributingRenderPassId(contributing_render_pass_id);
           }
         }
 
         AppendQuadsForLayer(target_render_pass,
                             *it,
                             occlusion_tracker,
                             &append_quads_data);
       }
 
       ++layers_drawn;
     }
 
+    /*for (auto& quad : target_render_pass->quad_list) {
+      if (quad.material == DrawQuad::TEXTURE_CONTENT) {
+        TextureDrawQuad tq = static_cast<TextureDrawQuad&>(quad);
+        printf("LayerTreeHostImpl::CalculateRenderPasses texture quad %d %d\n", tq.nearest_neighbor, tq.resource_id);
+      }
+    }*/
+
     rendering_stats_instrumentation_->AddVisibleContentArea(
         append_quads_data.visible_content_area);
     rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
         append_quads_data.approximated_visible_content_area);
 
     num_missing_tiles += append_quads_data.num_missing_tiles;
     num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
 
     if (append_quads_data.num_missing_tiles) {
       bool layer_has_animating_transform =
@@ skipping 62 matching lines @@
     UMA_HISTOGRAM_COUNTS_100(
         "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
         num_incomplete_tiles);
   }
 
   // Should only have one render pass in resourceless software mode.
   DCHECK(draw_mode != DRAW_MODE_RESOURCELESS_SOFTWARE ||
          frame->render_passes.size() == 1u)
       << frame->render_passes.size();
 
+  //printf("LayerTreeHostImpl::CalculateRenderPasses %d\n", (draw_result == DRAW_SUCCESS));
   return draw_result;
 }
 
 void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
   if (input_handler_client_)
     input_handler_client_->MainThreadHasStoppedFlinging();
 }
 
 void LayerTreeHostImpl::UpdateBackgroundAnimateTicking(
     bool should_background_tick) {
@@ skipping 526 matching lines @@
 
   return metadata;
 }
 
 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
   layer->DidBeginTracing();
 }
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
+  /*printf("LayerTreeHostImpl::DrawLayers start\n");
+  for (auto* render_pass : frame->render_passes) {
+    for (auto& quad : render_pass->quad_list) {
+      if (quad.material == DrawQuad::TEXTURE_CONTENT) {
+        TextureDrawQuad& tq = static_cast<TextureDrawQuad&>(quad);
+        printf("LayerTreeHostImpl::DrawLayers texture quad %d %d\n", tq.nearest_neighbor, tq.resource_id);
+      }
+    }
+  }
+  for (LayerImpl* li : frame->will_draw_layers) {
+    printf("LayerTreeHostImpl::DrawLayers %p\n", li);
+  }*/
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
 
   if (frame->has_no_damage) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
+    //printf("LayerTreeHostImpl::DrawFrame no damage\n");
     return;
   }
 
   DCHECK(!frame->render_passes.empty());
 
   fps_counter_->SaveTimeStamp(frame_begin_time,
                               !output_surface_->context_provider());
   rendering_stats_instrumentation_->IncrementFrameCount(1);
 
   if (tile_manager_) {
@@ skipping 57 matching lines @@
         IsActivelyScrolling() || needs_animate_layers();
 
     scoped_ptr<SoftwareRenderer> temp_software_renderer =
         SoftwareRenderer::Create(this, &settings_, output_surface_.get(), NULL);
     temp_software_renderer->DrawFrame(&frame->render_passes,
                                       device_scale_factor_,
                                       DeviceViewport(),
                                       DeviceClip(),
                                       disable_picture_quad_image_filtering);
   } else {
+    //printf("LayerTreeHostImpl::DrawLayers DrawFrame %p\n", renderer_.get());
     renderer_->DrawFrame(&frame->render_passes,
                          device_scale_factor_,
                          DeviceViewport(),
                          DeviceClip(),
                          false);
   }
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
   frame->render_passes_by_id.clear();
 
   // The next frame should start by assuming nothing has changed, and changes
   // are noted as they occur.
   // TODO(boliu): If we did a temporary software renderer frame, propogate the
   // damage forward to the next frame.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
 
   active_tree_->set_has_ever_been_drawn(true);
   devtools_instrumentation::DidDrawFrame(id_);
   benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
       rendering_stats_instrumentation_->impl_thread_rendering_stats());
   rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
+  //printf("LayerTreeHostImpl::DrawLayers done\n");
 }
 
 void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
   for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
     frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
 
   // Once all layers have been drawn, pending texture uploads should no
   // longer block future uploads.
   resource_provider_->MarkPendingUploadsAsNonBlocking();
 }
@@ skipping 1844 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc