[cc] Add nearest neighbor filtering for PictureLayer.

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 70 matching lines @@
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
       was_screen_space_transform_animating_(false),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false),
       only_used_low_res_last_append_quads_(false),
-      is_mask_(false) {
+      is_mask_(false),
+      nearest_neighbor_(false) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
   if (twin_layer_)
     twin_layer_->twin_layer_ = nullptr;
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 scoped_ptr<TilingSetEvictionQueue> PictureLayerImpl::CreateEvictionQueue(
@@ skipping 25 matching lines @@
   DCHECK_IMPLIES(twin_layer_, twin_layer_ == layer_impl);
   DCHECK_IMPLIES(twin_layer_, layer_impl->twin_layer_ == this);
   // The twin relationship does not need to exist before the first
   // PushPropertiesTo from pending to active layer since before that the active
   // layer can not have a pile or tilings, it has only been created and inserted
   // into the tree at that point.
   twin_layer_ = layer_impl;
   layer_impl->twin_layer_ = this;
 
   layer_impl->set_is_mask(is_mask_);
+  layer_impl->SetNearestNeighbor(nearest_neighbor_);
   layer_impl->UpdateRasterSource(raster_source_);
 
   DCHECK_IMPLIES(raster_source_->IsSolidColor(), tilings_->num_tilings() == 0);
   // Tilings would be expensive to push, so we swap.
   layer_impl->tilings_.swap(tilings_);
   layer_impl->tilings_->SetClient(layer_impl);
   if (tilings_)
     tilings_->SetClient(this);
 
   // Ensure that the recycle tree doesn't have any unshared tiles.
@@ skipping 96 matching lines @@
     if (visible_geometry_rect.IsEmpty())
       return;
 
     gfx::Size texture_size = scaled_visible_content_rect.size();
     gfx::RectF texture_rect = gfx::RectF(texture_size);
     gfx::Rect quad_content_rect = scaled_visible_content_rect;
 
     PictureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
     quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
-                 visible_geometry_rect, texture_rect, texture_size, RGBA_8888,
-                 quad_content_rect, max_contents_scale, raster_source_);
+                 visible_geometry_rect, texture_rect, texture_size,
+                 nearest_neighbor_, RGBA_8888, quad_content_rect,
+                 max_contents_scale, raster_source_);
     return;
   }
 
   AppendDebugBorderQuad(
       render_pass, scaled_content_bounds, shared_quad_state, append_quads_data);
 
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::CoverageIterator iter(
              tilings_.get(),
              max_contents_scale,
@@ skipping 91 matching lines @@
 
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        opaque_rect,
                        visible_geometry_rect,
                        draw_info.get_resource_id(),
                        texture_rect,
                        iter.texture_size(),
-                       draw_info.contents_swizzled());
+                       draw_info.contents_swizzled(),
+                       nearest_neighbor_);
           has_draw_quad = true;
           break;
         }
         case ManagedTileState::DrawInfo::PICTURE_PILE_MODE: {
           if (!layer_tree_impl()
                    ->GetRendererCapabilities()
                    .allow_rasterize_on_demand) {
             ++on_demand_missing_tile_count;
             break;
           }
 
           gfx::RectF texture_rect = iter.texture_rect();
 
           ResourceProvider* resource_provider =
               layer_tree_impl()->resource_provider();
           ResourceFormat format =
               resource_provider->memory_efficient_texture_format();
           PictureDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
                        visible_geometry_rect, texture_rect, iter.texture_size(),
-                       format, iter->content_rect(), iter->contents_scale(),
-                       raster_source_);
+                       nearest_neighbor_, format, iter->content_rect(),
+                       iter->contents_scale(), raster_source_);
           has_draw_quad = true;
           break;
         }
         case ManagedTileState::DrawInfo::SOLID_COLOR_MODE: {
           SolidColorDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        visible_geometry_rect,
                        draw_info.get_solid_color(),
@@ skipping 454 matching lines @@
   if (!draw_info.IsReadyToDraw() ||
       draw_info.mode() != ManagedTileState::DrawInfo::RESOURCE_MODE) {
     *resource_id = 0;
     return;
   }
 
   *resource_id = draw_info.get_resource_id();
   *resource_size = iter.texture_size();
 }
 
+void PictureLayerImpl::SetNearestNeighbor(bool nearest_neighbor) {
+  if (nearest_neighbor_ != nearest_neighbor) {

[danakj, 2014/12/09 19:44:45]

if == return

[jackhou1, 2014/12/10 01:04:15]

Done.

+    nearest_neighbor_ = nearest_neighbor;
+    SetNeedsPushProperties();

[danakj, 2014/12/09 19:44:45]

NoteLayerPropertyChanged instead

[jackhou1, 2014/12/10 01:04:15]

Done.

+  }
+}
+
 void PictureLayerImpl::DoPostCommitInitialization() {
   DCHECK(needs_post_commit_initialization_);
   DCHECK(layer_tree_impl()->IsPendingTree());
 
   if (!tilings_)
     tilings_ = PictureLayerTilingSet::Create(this);
 
   PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
   if (twin_layer) {
     // If the twin has never been pushed to, do not sync from it.
@@ skipping 607 matching lines @@
     IteratorType index = stages_[current_stage_].iterator_type;
     TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type;
 
     if (iterators_[index] && iterators_[index].get_type() == tile_type)
       break;
     ++current_stage_;
   }
 }
 
 }  // namespace cc