cc: Calculate "can use lcd text" on the compositor thread

cc/trees/layer_tree_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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 63 matching lines @@
   gfx::ScrollOffset last_set_scroll_offset_;
 };
 
 LayerTreeImpl::LayerTreeImpl(
     LayerTreeHostImpl* layer_tree_host_impl,
     scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor,
     scoped_refptr<SyncedTopControls> top_controls_shown_ratio,
     scoped_refptr<SyncedElasticOverscroll> elastic_overscroll)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
+      last_update_draw_properties_frame_number_(-1),
       hud_layer_(0),
       currently_scrolling_layer_(NULL),
       root_layer_scroll_offset_delegate_(NULL),
       background_color_(0),
       has_transparent_background_(false),
       overscroll_elasticity_layer_(NULL),
       page_scale_layer_(NULL),
       inner_viewport_scroll_layer_(NULL),
       outer_viewport_scroll_layer_(NULL),
       page_scale_factor_(page_scale_factor),
@@ skipping 546 matching lines @@
         }
       }
 
       occlusion_tracker.LeaveLayer(it);
     }
 
     unoccluded_screen_space_region_ =
         occlusion_tracker.ComputeVisibleRegionInScreen();
   }
 
+  // It'd be ideal if this could be done earlier, but when the raster source
+  // is updated from the main thread during push properties, update draw
+  // properties has not occurred yet and so it's not clear whether or not the
+  // layer can or cannot use lcd text.  So, this is the cleanup pass to
+  // determine if the raster source needs to be replaced with a non-lcd
+  // raster source due to draw properties.
+  //
+  // TODO(enne): Make LTHI::sync_tree return this value.
+  LayerTreeImpl* sync_tree =
+      layer_tree_host_impl_->proxy()->CommitToActiveTree()
+          ? layer_tree_host_impl_->active_tree()
+          : layer_tree_host_impl_->pending_tree();
+  if (this == sync_tree &&
+      source_frame_number_ != last_update_draw_properties_frame_number_) {

[danakj, 2015/02/18 19:54:47]

Mmmmmmh. What if we instead pass a bool to UDP() to do this walk and only pass
true from
https://code.google.com/p/chromium/codesearch#chromium/src/cc/trees/layer_tre...
? Would that be slightly more obvious?

[enne (OOO), 2015/02/18 19:59:05]

Since there's UDP called at different times on different trees, I think it seems
safer to keep the frame number on the tree itself.

I also think "last_foo_frame_number" is a well-trodden pattern?

+    for (const auto& layer : picture_layers_)
+      layer->UpdateCanUseLCDTextAfterCommit();
+  }
+  last_update_draw_properties_frame_number_ = source_frame_number_;
+
   {
     TRACE_EVENT_BEGIN2("cc", "LayerTreeImpl::UpdateDrawProperties::UpdateTiles",
                        "IsActive", IsActiveTree(), "SourceFrameNumber",
                        source_frame_number_);
     const bool resourceless_software_draw =
         (layer_tree_host_impl_->GetDrawMode() ==
          DRAW_MODE_RESOURCELESS_SOFTWARE);
     size_t layers_updated_count = 0;
     bool tile_priorities_updated = false;
     for (PictureLayerImpl* layer : picture_layers_) {
@@ skipping 192 matching lines @@
 }
 
 bool LayerTreeImpl::IsPendingTree() const {
   return layer_tree_host_impl_->pending_tree() == this;
 }
 
 bool LayerTreeImpl::IsRecycleTree() const {
   return layer_tree_host_impl_->recycle_tree() == this;
 }
 
+bool LayerTreeImpl::IsSyncTree() const {
+  return layer_tree_host_impl_->sync_tree() == this;
+}
+
 LayerImpl* LayerTreeImpl::FindActiveTreeLayerById(int id) {
   LayerTreeImpl* tree = layer_tree_host_impl_->active_tree();
   if (!tree)
     return NULL;
   return tree->LayerById(id);
 }
 
 LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
   LayerTreeImpl* tree = layer_tree_host_impl_->pending_tree();
   if (!tree)
@@ skipping 749 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc