Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

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 <cmath>
 #include <limits>
 #include <set>
@@ skipping 207 matching lines @@
              tilings_.get(), max_contents_scale,
              shared_quad_state->visible_content_rect, ideal_contents_scale_);
          iter; ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->IsReadyToDraw()) {
         TileDrawInfo::Mode mode = iter->draw_info().mode();
         if (mode == TileDrawInfo::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
-        } else if (mode == TileDrawInfo::OOM_MODE) {
-          color = DebugColors::OOMTileBorderColor();
-          width = DebugColors::OOMTileBorderWidth(layer_tree_impl());
+        } else if (mode == TileDrawInfo::PICTURE_PILE_MODE) {
+          color = DebugColors::PictureTileBorderColor();
+          width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
         } else if (iter->contents_scale() > max_contents_scale) {
           color = DebugColors::ExtraHighResTileBorderColor();
           width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
         } else {
@@ skipping 65 matching lines @@
 
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
                        visible_geometry_rect, draw_info.resource_id(),
                        texture_rect, draw_info.resource_size(),
                        draw_info.contents_swizzled(), nearest_neighbor_);
           has_draw_quad = true;
           break;
         }
+        case TileDrawInfo::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->desired_texture_size(), nearest_neighbor_, format,
+                       iter->content_rect(), iter->contents_scale(),
+                       raster_source_);
+          has_draw_quad = true;
+          break;
+        }
         case TileDrawInfo::SOLID_COLOR_MODE: {
           SolidColorDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, visible_geometry_rect,
                        draw_info.solid_color(), false);
           has_draw_quad = true;
           break;
         }
-        case TileDrawInfo::OOM_MODE:
-          break;  // Checkerboard.
       }
     }
 
     if (!has_draw_quad) {
       if (draw_checkerboard_for_missing_tiles()) {
         CheckerboardDrawQuad* quad =
             render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
         SkColor color = DebugColors::DefaultCheckerboardColor();
         quad->SetNew(
             shared_quad_state, geometry_rect, visible_geometry_rect, color);
@@ skipping 200 matching lines @@
   }
 
   // We could do this after doing UpdateTiles, which would avoid doing this for
   // tilings that are going to disappear on the pending tree (if scale changed).
   // But that would also be more complicated, so we just do it here for now.
   tilings_->UpdateTilingsToCurrentRasterSource(
       raster_source_, pending_set, invalidation_, MinimumContentsScale(),
       MaximumContentsScale());
 }
 
-void PictureLayerImpl::UpdateCanUseLCDTextAfterCommit() {
-  // This function is only allowed to be called after commit, due to it not
-  // being smart about sharing tiles and because otherwise it would cause
-  // flashes by switching out tiles in place that may be currently on screen.
-  DCHECK(layer_tree_impl()->IsSyncTree());
-
-  // Don't allow the LCD text state to change once disabled.
-  if (!RasterSourceUsesLCDText())
-    return;
-  if (can_use_lcd_text() == RasterSourceUsesLCDText())
-    return;
-
-  // Raster sources are considered const, so in order to update the state
-  // a new one must be created and all tiles recreated.
-  scoped_refptr<RasterSource> new_raster_source =
-      raster_source_->CreateCloneWithoutLCDText();
-  // Synthetically invalidate everything.
-  gfx::Rect bounds_rect(bounds());
-  Region invalidation(bounds_rect);
-  UpdateRasterSource(new_raster_source, &invalidation, nullptr);
-  SetUpdateRect(bounds_rect);
-
-  DCHECK(!RasterSourceUsesLCDText());
-}
-
-bool PictureLayerImpl::RasterSourceUsesLCDText() const {
-  return raster_source_ ? raster_source_->CanUseLCDText()
-                        : layer_tree_impl()->settings().can_use_lcd_text;
-}
-
 void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
   if (layer_tree_impl()->IsActiveTree()) {
     gfx::RectF layer_damage_rect =
         gfx::ScaleRect(tile->content_rect(), 1.f / tile->contents_scale());
     AddDamageRect(layer_damage_rect);
   }
 }
 
 void PictureLayerImpl::DidBeginTracing() {
   raster_source_->DidBeginTracing();
@@ skipping 633 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc