cc: Removed LCD text settings from the impl side.

Now that the SkPicture is recorded with the correct LCD setting, there
is no need to have any LCD text related setting on the impl side.

BUG=368513

Review URL: https://codereview.chromium.org/324483003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@276918 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 17 insertions, 249 deletions

diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 2ff92a5..5cd1cb5 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -62,7 +62,6 @@ PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl, int id)
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
       was_animating_transform_to_screen_(false),
-      is_using_lcd_text_(tree_impl->settings().can_use_lcd_text),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
@@ -122,8 +121,6 @@ void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
   layer_impl->raster_source_scale_ = raster_source_scale_;
   layer_impl->raster_contents_scale_ = raster_contents_scale_;
   layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_;
-
-  layer_impl->UpdateLCDTextStatus(is_using_lcd_text_);
   layer_impl->needs_post_commit_initialization_ = false;
 
   // The invalidation on this soon-to-be-recycled layer must be cleared to
@@ -402,8 +399,6 @@ void PictureLayerImpl::UpdateTilePriorities() {
   if (!tiling_needs_update)
     return;
 
-  UpdateLCDTextStatus(can_use_lcd_text());
-
   // Use visible_content_rect, unless it's empty. If it's empty, then
   // try to inverse project the viewport into layer space and use that.
   gfx::Rect visible_rect_in_content_space = visible_rect_for_tile_priority_;
@@ -541,9 +536,6 @@ scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
     return scoped_refptr<Tile>();
 
   int flags = 0;
-  if (is_using_lcd_text_)
-    flags |= Tile::USE_LCD_TEXT;
-
   // We analyze picture before rasterization to detect solid-color tiles.
   // If the tile is detected as such there is no need to raster or upload.
   // It is drawn directly as a solid-color quad saving memory, raster and upload
@@ -678,8 +670,6 @@ void PictureLayerImpl::SyncFromActiveLayer(const PictureLayerImpl* other) {
   DCHECK(!other->needs_post_commit_initialization_);
   DCHECK(other->tilings_);
 
-  UpdateLCDTextStatus(other->is_using_lcd_text_);
-
   if (!DrawsContent()) {
     RemoveAllTilings();
     return;
@@ -1285,18 +1275,6 @@ float PictureLayerImpl::MinimumContentsScale() const {
   return std::max(1.f / min_dimension, setting_min);
 }
 
-void PictureLayerImpl::UpdateLCDTextStatus(bool new_status) {
-  // Once this layer is not using lcd text, don't switch back.
-  if (!is_using_lcd_text_)
-    return;
-
-  if (is_using_lcd_text_ == new_status)
-    return;
-
-  is_using_lcd_text_ = new_status;
-  tilings_->SetCanUseLCDText(is_using_lcd_text_);
-}
-
 void PictureLayerImpl::ResetRasterScale() {
   raster_page_scale_ = 0.f;
   raster_device_scale_ = 0.f;
@@ -1373,7 +1351,6 @@ void PictureLayerImpl::AsValueInto(base::DictionaryValue* state) const {
     coverage_tiles->Append(tile_data.release());
   }
   state->Set("coverage_tiles", coverage_tiles.release());
-  state->SetBoolean("is_using_lcd_text", is_using_lcd_text_);
 }
 
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index be1ee34..00c06b1 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -156,7 +156,6 @@ class CC_EXPORT PictureLayerImpl
       std::vector<PictureLayerTiling*> used_tilings);
   float MinimumContentsScale() const;
   float SnappedContentsScale(float new_contents_scale);
-  void UpdateLCDTextStatus(bool new_status);
   void ResetRasterScale();
   void MarkVisibleResourcesAsRequired() const;
   bool MarkVisibleTilesAsRequired(
@@ -201,7 +200,6 @@ class CC_EXPORT PictureLayerImpl
 
   bool raster_source_scale_is_fixed_;
   bool was_animating_transform_to_screen_;
-  bool is_using_lcd_text_;
   bool needs_post_commit_initialization_;
   // A sanity state check to make sure UpdateTilePriorities only gets called
   // after a CalculateContentsScale/ManageTilings.
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index e25cc12..cb4486b 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -1568,8 +1568,8 @@ TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   // by a sync from the active layer.  This could happen because if the
   // pending layer has not been post-commit initialized it will attempt
   // to sync from the active layer.
-  bool default_lcd_text_setting = pending_layer_->is_using_lcd_text();
-  pending_layer_->force_set_lcd_text(!default_lcd_text_setting);
+  float raster_page_scale = 10.f * pending_layer_->raster_page_scale();
+  pending_layer_->set_raster_page_scale(raster_page_scale);
   EXPECT_TRUE(pending_layer_->needs_post_commit_initialization());
 
   host_impl_.ActivatePendingTree();
@@ -1578,7 +1578,7 @@ TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
       host_impl_.active_tree()->LayerById(id_));
 
   EXPECT_EQ(0u, active_layer_->num_tilings());
-  EXPECT_EQ(!default_lcd_text_setting, active_layer_->is_using_lcd_text());
+  EXPECT_EQ(raster_page_scale, active_layer_->raster_page_scale());
   EXPECT_FALSE(active_layer_->needs_post_commit_initialization());
 }
 
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 9ab2cf5..5a41951 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -122,11 +122,6 @@ Tile* PictureLayerTiling::CreateTile(int i,
   return tile.get();
 }
 
-void PictureLayerTiling::SetCanUseLCDText(bool can_use_lcd_text) {
-  for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    it->second->set_can_use_lcd_text(can_use_lcd_text);
-}
-
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   bool include_borders = true;
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index 131e338..fc7505c 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -129,8 +129,6 @@ class CC_EXPORT PictureLayerTiling {
   void RemoveTilesInRegion(const Region& layer_region);
   void CreateMissingTilesInLiveTilesRect();
 
-  void SetCanUseLCDText(bool can_use_lcd_text);
-
   void SetClient(PictureLayerTilingClient* client);
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
diff --git a/cc/resources/picture_layer_tiling_set.cc b/cc/resources/picture_layer_tiling_set.cc
index 9967868..fa76fc1 100644
--- a/cc/resources/picture_layer_tiling_set.cc
+++ b/cc/resources/picture_layer_tiling_set.cc
@@ -103,11 +103,6 @@ void PictureLayerTilingSet::RemoveTilesInRegion(const Region& region) {
     tilings_[i]->RemoveTilesInRegion(region);
 }
 
-void PictureLayerTilingSet::SetCanUseLCDText(bool can_use_lcd_text) {
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->SetCanUseLCDText(can_use_lcd_text);
-}
-
 PictureLayerTiling* PictureLayerTilingSet::AddTiling(float contents_scale) {
   for (size_t i = 0; i < tilings_.size(); ++i)
     DCHECK_NE(tilings_[i]->contents_scale(), contents_scale);
diff --git a/cc/resources/picture_layer_tiling_set.h b/cc/resources/picture_layer_tiling_set.h
index db1e4ef..53de7ce 100644
--- a/cc/resources/picture_layer_tiling_set.h
+++ b/cc/resources/picture_layer_tiling_set.h
@@ -35,8 +35,6 @@ class CC_EXPORT PictureLayerTilingSet {
 
   gfx::Size layer_bounds() const { return layer_bounds_; }
 
-  void SetCanUseLCDText(bool can_use_lcd_text);
-
   PictureLayerTiling* AddTiling(float contents_scale);
   size_t num_tilings() const { return tilings_.size(); }
   int NumHighResTilings() const;
diff --git a/cc/resources/prioritized_tile_set_unittest.cc b/cc/resources/prioritized_tile_set_unittest.cc
index 69fef52..f0a01d2 100644
--- a/cc/resources/prioritized_tile_set_unittest.cc
+++ b/cc/resources/prioritized_tile_set_unittest.cc
@@ -75,7 +75,7 @@ class PrioritizedTileSetTest : public testing::Test {
                                      1.0,
                                      0,
                                      0,
-                                     Tile::USE_LCD_TEXT);
+                                     0);
   }
 
  private:
diff --git a/cc/resources/raster_mode.cc b/cc/resources/raster_mode.cc
index 61375c2..5da8ee7 100644
--- a/cc/resources/raster_mode.cc
+++ b/cc/resources/raster_mode.cc
@@ -12,9 +12,6 @@ namespace cc {
 
 scoped_ptr<base::Value> RasterModeAsValue(RasterMode raster_mode) {
   switch (raster_mode) {
-    case HIGH_QUALITY_NO_LCD_RASTER_MODE:
-      return scoped_ptr<base::Value>(
-          new base::StringValue("HIGH_QUALITY_NO_LCD_RASTER_MODE"));
     case HIGH_QUALITY_RASTER_MODE:
       return scoped_ptr<base::Value>(
           new base::StringValue("HIGH_QUALITY_RASTER_MODE"));
diff --git a/cc/resources/raster_mode.h b/cc/resources/raster_mode.h
index 9868059..0a2b4c9 100644
--- a/cc/resources/raster_mode.h
+++ b/cc/resources/raster_mode.h
@@ -13,15 +13,12 @@ class Value;
 
 namespace cc {
 
-// Low quality implies no lcd test;
-// high quality implies lcd text.
 // Note that the order of these matters, from "better" to "worse" in terms of
 // quality.
 enum RasterMode {
-  HIGH_QUALITY_NO_LCD_RASTER_MODE = 0,
-  HIGH_QUALITY_RASTER_MODE = 1,
-  LOW_QUALITY_RASTER_MODE = 2,
-  NUM_RASTER_MODES = 3
+  HIGH_QUALITY_RASTER_MODE = 0,
+  LOW_QUALITY_RASTER_MODE = 1,
+  NUM_RASTER_MODES = 2
 };
 
 scoped_ptr<base::Value> RasterModeAsValue(RasterMode mode);
diff --git a/cc/resources/tile.cc b/cc/resources/tile.cc
index 485e230..d59dc02 100644
--- a/cc/resources/tile.cc
+++ b/cc/resources/tile.cc
@@ -71,7 +71,6 @@ scoped_ptr<base::Value> Tile::AsValue() const {
   res->Set("active_priority", priority_[ACTIVE_TREE].AsValue().release());
   res->Set("pending_priority", priority_[PENDING_TREE].AsValue().release());
   res->Set("managed_state", managed_state_.AsValue().release());
-  res->SetBoolean("can_use_lcd_text", can_use_lcd_text());
   res->SetBoolean("use_picture_analysis", use_picture_analysis());
   return res.PassAs<base::Value>();
 }
@@ -94,15 +93,9 @@ RasterMode Tile::DetermineOverallRasterMode() const {
 RasterMode Tile::DetermineRasterModeForResolution(
     TileResolution resolution) const {
   RasterMode current_mode = managed_state_.raster_mode;
-  RasterMode raster_mode = HIGH_QUALITY_RASTER_MODE;
-  if (resolution == LOW_RESOLUTION)
-    raster_mode = LOW_QUALITY_RASTER_MODE;
-  else if (can_use_lcd_text())
-    raster_mode = HIGH_QUALITY_RASTER_MODE;
-  else if (managed_state_.tile_versions[current_mode].has_text_ ||
-           !managed_state_.tile_versions[current_mode].IsReadyToDraw())
-    raster_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
-
+  RasterMode raster_mode = resolution == LOW_RESOLUTION
+                               ? LOW_QUALITY_RASTER_MODE
+                               : HIGH_QUALITY_RASTER_MODE;
   return std::min(raster_mode, current_mode);
 }
 
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index d7cb16b..f231155 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -20,7 +20,7 @@ namespace cc {
 
 class CC_EXPORT Tile : public RefCountedManaged<Tile> {
  public:
-  enum TileRasterFlags { USE_LCD_TEXT = 1 << 0, USE_PICTURE_ANALYSIS = 1 << 1 };
+  enum TileRasterFlags { USE_PICTURE_ANALYSIS = 1 << 0 };
 
   typedef uint64 Id;
 
@@ -66,17 +66,6 @@ class CC_EXPORT Tile : public RefCountedManaged<Tile> {
     return priority_[PENDING_TREE].required_for_activation;
   }
 
-  void set_can_use_lcd_text(bool can_use_lcd_text) {
-    if (can_use_lcd_text)
-      flags_ |= USE_LCD_TEXT;
-    else
-      flags_ &= ~USE_LCD_TEXT;
-  }
-
-  bool can_use_lcd_text() const {
-    return !!(flags_ & USE_LCD_TEXT);
-  }
-
   bool use_picture_analysis() const {
     return !!(flags_ & USE_PICTURE_ANALYSIS);
   }
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index c96b5e2..e569410 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -30,18 +30,6 @@ namespace {
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
-class DisableLCDTextFilter : public SkDrawFilter {
- public:
-  // SkDrawFilter interface.
-  virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
-    if (type != SkDrawFilter::kText_Type)
-      return true;
-
-    paint->setLCDRenderText(false);
-    return true;
-  }
-};
-
 class RasterTaskImpl : public RasterTask {
  public:
   RasterTaskImpl(
@@ -146,9 +134,6 @@ class RasterTaskImpl : public RasterTask {
       case LOW_QUALITY_RASTER_MODE:
         draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
         break;
-      case HIGH_QUALITY_NO_LCD_RASTER_MODE:
-        draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
-        break;
       case HIGH_QUALITY_RASTER_MODE:
         break;
       case NUM_RASTER_MODES:
@@ -969,7 +954,7 @@ void TileManager::FreeResourcesForTile(Tile* tile) {
 void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
   DCHECK(tile->IsReadyToDraw());
   ManagedTileState& mts = tile->managed_state();
-  RasterMode used_mode = HIGH_QUALITY_NO_LCD_RASTER_MODE;
+  RasterMode used_mode = LOW_QUALITY_RASTER_MODE;
   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
     if (mts.tile_versions[mode].IsReadyToDraw()) {
       used_mode = static_cast<RasterMode>(mode);
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index b36a6b4..30f4730 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -202,7 +202,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
     for (size_t i = 0; i < tiles.size(); ++i) {
       ManagedTileState& mts = tiles[i]->managed_state();
       ManagedTileState::TileVersion& tile_version =
-          mts.tile_versions[HIGH_QUALITY_NO_LCD_RASTER_MODE];
+          mts.tile_versions[HIGH_QUALITY_RASTER_MODE];
 
       tile_version.resource_ = resource_pool_->AcquireResource(gfx::Size(1, 1));
 
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index eccfb31..4beae8f 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -102,7 +102,7 @@ class TileManagerTest : public testing::TestWithParam<bool>,
                                                            1.0,
                                                            0,
                                                            0,
-                                                           Tile::USE_LCD_TEXT);
+                                                           0);
       tile->SetPriority(ACTIVE_TREE, active_priority);
       tile->SetPriority(PENDING_TREE, pending_priority);
       tiles.push_back(tile);
@@ -129,16 +129,6 @@ class TileManagerTest : public testing::TestWithParam<bool>,
     return has_memory_count;
   }
 
-  int TilesWithLCDCount(const TileVector& tiles) {
-    int has_lcd_count = 0;
-    for (TileVector::const_iterator it = tiles.begin(); it != tiles.end();
-         ++it) {
-      if ((*it)->GetRasterModeForTesting() == HIGH_QUALITY_RASTER_MODE)
-        ++has_lcd_count;
-    }
-    return has_lcd_count;
-  }
-
   bool ready_to_activate() const { return ready_to_activate_; }
 
   // The parametrization specifies whether the max tile limit should
@@ -428,150 +418,6 @@ TEST_P(TileManagerTest, TotalOOMMemoryToNewContent) {
   EXPECT_EQ(10, AssignedMemoryCount(pending_tree_tiles));
 }
 
-TEST_P(TileManagerTest, RasterAsLCD) {
-  Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
-  TileVector active_tree_tiles =
-      CreateTiles(5, TilePriorityForNowBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles));
-}
-
-TEST_P(TileManagerTest, RasterAsNoLCD) {
-  Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
-  TileVector active_tree_tiles =
-      CreateTiles(5, TilePriorityForNowBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
-
-  for (TileVector::iterator it = active_tree_tiles.begin();
-       it != active_tree_tiles.end();
-       ++it) {
-    (*it)->set_can_use_lcd_text(false);
-  }
-  for (TileVector::iterator it = pending_tree_tiles.begin();
-       it != pending_tree_tiles.end();
-       ++it) {
-    (*it)->set_can_use_lcd_text(false);
-  }
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(0, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(0, TilesWithLCDCount(pending_tree_tiles));
-}
-
-TEST_P(TileManagerTest, ReRasterAsNoLCD) {
-  Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
-  TileVector active_tree_tiles =
-      CreateTiles(5, TilePriorityForNowBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles));
-
-  for (TileVector::iterator it = active_tree_tiles.begin();
-       it != active_tree_tiles.end();
-       ++it) {
-    (*it)->set_can_use_lcd_text(false);
-  }
-  for (TileVector::iterator it = pending_tree_tiles.begin();
-       it != pending_tree_tiles.end();
-       ++it) {
-    (*it)->set_can_use_lcd_text(false);
-  }
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(0, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(0, TilesWithLCDCount(pending_tree_tiles));
-}
-
-TEST_P(TileManagerTest, NoTextDontReRasterAsNoLCD) {
-  Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
-  TileVector active_tree_tiles =
-      CreateTiles(5, TilePriorityForNowBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles));
-
-  for (TileVector::iterator it = active_tree_tiles.begin();
-       it != active_tree_tiles.end();
-       ++it) {
-    ManagedTileState::TileVersion& tile_version =
-        (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE);
-    tile_version.SetSolidColorForTesting(SkColorSetARGB(0, 0, 0, 0));
-    (*it)->set_can_use_lcd_text(false);
-    EXPECT_TRUE((*it)->IsReadyToDraw());
-  }
-  for (TileVector::iterator it = pending_tree_tiles.begin();
-       it != pending_tree_tiles.end();
-       ++it) {
-    ManagedTileState::TileVersion& tile_version =
-        (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE);
-    tile_version.SetSolidColorForTesting(SkColorSetARGB(0, 0, 0, 0));
-    (*it)->set_can_use_lcd_text(false);
-    EXPECT_TRUE((*it)->IsReadyToDraw());
-  }
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles));
-}
-
-TEST_P(TileManagerTest, TextReRasterAsNoLCD) {
-  Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
-  TileVector active_tree_tiles =
-      CreateTiles(5, TilePriorityForNowBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles));
-
-  for (TileVector::iterator it = active_tree_tiles.begin();
-       it != active_tree_tiles.end();
-       ++it) {
-    ManagedTileState::TileVersion& tile_version =
-        (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE);
-    tile_version.SetSolidColorForTesting(SkColorSetARGB(0, 0, 0, 0));
-    tile_version.SetHasTextForTesting(true);
-    (*it)->set_can_use_lcd_text(false);
-
-    EXPECT_TRUE((*it)->IsReadyToDraw());
-  }
-  for (TileVector::iterator it = pending_tree_tiles.begin();
-       it != pending_tree_tiles.end();
-       ++it) {
-    ManagedTileState::TileVersion& tile_version =
-        (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE);
-    tile_version.SetSolidColorForTesting(SkColorSetARGB(0, 0, 0, 0));
-    tile_version.SetHasTextForTesting(true);
-    (*it)->set_can_use_lcd_text(false);
-
-    EXPECT_TRUE((*it)->IsReadyToDraw());
-  }
-
-  tile_manager()->AssignMemoryToTiles(global_state_);
-
-  EXPECT_EQ(0, TilesWithLCDCount(active_tree_tiles));
-  EXPECT_EQ(0, TilesWithLCDCount(pending_tree_tiles));
-}
-
 TEST_P(TileManagerTest, RespectMemoryLimit) {
   if (UsingResourceLimit())
     return;
diff --git a/cc/test/fake_picture_layer_impl.h b/cc/test/fake_picture_layer_impl.h
index 9ce0283..ae8f202 100644
--- a/cc/test/fake_picture_layer_impl.h
+++ b/cc/test/fake_picture_layer_impl.h
@@ -56,8 +56,8 @@ class FakePictureLayerImpl : public PictureLayerImpl {
     return needs_post_commit_initialization_;
   }
 
-  bool is_using_lcd_text() const { return is_using_lcd_text_; }
-  void force_set_lcd_text(bool enabled) { is_using_lcd_text_ = enabled; }
+  float raster_page_scale() const { return raster_page_scale_; }
+  void set_raster_page_scale(float scale) { raster_page_scale_ = scale; }
 
   PictureLayerTiling* HighResTiling() const;
   PictureLayerTiling* LowResTiling() const;
diff --git a/cc/test/fake_picture_layer_tiling_client.cc b/cc/test/fake_picture_layer_tiling_client.cc
index 0c0fce6..dd64ac2 100644
--- a/cc/test/fake_picture_layer_tiling_client.cc
+++ b/cc/test/fake_picture_layer_tiling_client.cc
@@ -41,7 +41,7 @@ scoped_refptr<Tile> FakePictureLayerTilingClient::CreateTile(
   if (!allow_create_tile_)
     return scoped_refptr<Tile>();
   return tile_manager_->CreateTile(
-      pile_.get(), tile_size_, rect, gfx::Rect(), 1, 0, 0, Tile::USE_LCD_TEXT);
+      pile_.get(), tile_size_, rect, gfx::Rect(), 1, 0, 0, 0);
 }
 
 void FakePictureLayerTilingClient::SetTileSize(const gfx::Size& tile_size) {