Add fixed raster scale use counter histograms.

cc/layers/layer.cc

 // Copyright 2010 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/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 62 matching lines @@
       masks_to_bounds_(false),
       contents_opaque_(false),
       double_sided_(true),
       should_flatten_transform_(true),
       use_parent_backface_visibility_(false),
       use_local_transform_for_backface_visibility_(false),
       should_check_backface_visibility_(false),
       force_render_surface_for_testing_(false),
       has_render_surface_(false),
       subtree_property_changed_(false),
+      has_will_change_transform_hint_(false),
       background_color_(0),
       safe_opaque_background_color_(0),
       opacity_(1.f),
       blend_mode_(SkXfermode::kSrcOver_Mode),
       draw_blend_mode_(SkXfermode::kSrcOver_Mode),
       scroll_parent_(nullptr),
       clip_parent_(nullptr),
       replica_layer_(nullptr),
       client_(nullptr),
       num_unclipped_descendants_(0) {}
@@ skipping 1110 matching lines @@
     layer->PassCopyRequests(&main_thread_copy_requests);
   }
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
+  layer->SetHasWillChangeTransformHint(has_will_change_transform_hint());
+
   // Reset any state that should be cleared for the next update.
   subtree_property_changed_ = false;
   update_rect_ = gfx::Rect();
 
   layer_tree_host()->RemoveLayerShouldPushProperties(this);
 }
 
 void Layer::SetTypeForProtoSerialization(proto::LayerNode* proto) const {
   proto->set_type(proto::LayerNode::LAYER);
 }
@@ skipping 182 matching lines @@
 
   // TODO(nyquist): Figure out what to do with CopyRequests.
   // See crbug.com/570374.
 
   RectToProto(update_rect_, base->mutable_update_rect());
 
   // TODO(nyquist): Figure out what to do with ElementAnimations.
   // See crbug.com/570376.
 
   update_rect_ = gfx::Rect();
+
+  base->set_has_will_change_transform_hint(has_will_change_transform_hint_);
 }
 
 void Layer::FromLayerSpecificPropertiesProto(
     const proto::LayerProperties& proto) {
   DCHECK(proto.has_base());
   DCHECK(layer_tree_host_);
   const proto::BaseLayerProperties& base = proto.base();
 
   transform_origin_ = ProtoToPoint3F(base.transform_origin());
   background_color_ = base.background_color();
@@ skipping 72 matching lines @@
     clip_children_.reset(new std::set<Layer*>);
   for (int i = 0; i < base.clip_children_ids_size(); ++i) {
     int child_id = base.clip_children_ids(i);
     scoped_refptr<Layer> child = layer_tree_host_->LayerById(child_id);
     clip_children_->insert(child.get());
   }
 
   scroll_offset_ = ProtoToScrollOffset(base.scroll_offset());
 
   update_rect_.Union(ProtoToRect(base.update_rect()));
+
+  has_will_change_transform_hint_ = base.has_will_change_transform_hint();
 }
 
 std::unique_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 bool Layer::DrawsContent() const {
   return draws_content_;
 }
 
@@ skipping 149 matching lines @@
     }
     transform_tree.set_needs_update(true);
   }
 }
 
 bool Layer::HasActiveAnimationForTesting() const {
   return layer_tree_host_ ? layer_tree_host_->HasActiveAnimationForTesting(this)
                           : false;
 }
 
+void Layer::SetHasWillChangeTransformHint(bool has_will_change) {
+  if (has_will_change_transform_hint_ == has_will_change)
+    return;
+  has_will_change_transform_hint_ = has_will_change;
+  SetNeedsCommit();
+}
+
 ScrollbarLayerInterface* Layer::ToScrollbarLayer() {
   return nullptr;
 }
 
 RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
   return layer_tree_host_->rendering_stats_instrumentation();
 }
 
 void Layer::RemoveFromScrollTree() {
   if (scroll_children_.get()) {
@@ skipping 67 matching lines @@
       ->data.num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc