cc: Add frame timing request plumbing through the layers.

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 <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/debug/trace_event.h"
@@ skipping 61 matching lines @@
       transform_is_invertible_(true),
       has_render_surface_(false),
       clear_impl_scroll_delta_(false),
       background_color_(0),
       opacity_(1.f),
       blend_mode_(SkXfermode::kSrcOver_Mode),
       scroll_parent_(nullptr),
       clip_parent_(nullptr),
       replica_layer_(nullptr),
       raster_scale_(0.f),
-      client_(nullptr) {
+      client_(nullptr),
+      frame_timing_requests_dirty_(false) {
   layer_animation_controller_ = LayerAnimationController::Create(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
   layer_animation_controller_->set_value_provider(this);
 }
 
 Layer::~Layer() {
   // Our parent should be holding a reference to us so there should be no
   // way for us to be destroyed while we still have a parent.
   DCHECK(!parent());
   // Similarly we shouldn't have a layer tree host since it also keeps a
@@ skipping 916 matching lines @@
   // 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->SetStackingOrderChanged(stacking_order_changed_);
 
   layer_animation_controller_->PushAnimationUpdatesTo(
       layer->layer_animation_controller());
 
+  if (frame_timing_requests_dirty_) {

[danakj, 2015/01/23 18:08:45]

what's the reason for these dirty flags?

in case we commit twice in a row before consuming the requests on the other end?
we could do that if dirty was true twice too.

[vmpstr, 2015/01/23 18:41:57]

It's just so we don't keep copying the same vector. Once we set some requests,
those requests are in effect until something else is set, so this avoids
propagating the same thing on each commit/activation.

[danakj, 2015/01/23 18:43:29]

I see, you need them to stick around for multiple frames? Do you need them to
stick around on all of the layers? Could you just swap() them thru to the active
layer?

[vmpstr, 2015/01/23 18:45:58]

They really only need to be on the active layer.. Swapping would only work with
the dirty flag, since otherwise we'd swap back the next time, but other than
that it could work. Any suggestions for a function name? Liek
layer->TakeFrameTimingRequests(&frame_timing_requests_) or something?

+    layer->SetFrameTimingRequests(frame_timing_requests_);
+    frame_timing_requests_dirty_ = false;
+  }
+
   // Reset any state that should be cleared for the next update.
   stacking_order_changed_ = false;
   update_rect_ = gfx::Rect();
 
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
 scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_);
@@ skipping 258 matching lines @@
   if (transform_tree_index() >= 0) {
     const TransformNode* node = tree.Node(transform_tree_index());
     gfx::Transform ssxform;
     tree.ComputeTransform(node->id, node->data.target_id, &ssxform);
     xform.ConcatTransform(ssxform);
   }
   xform.Scale(1.0 / contents_scale_x(), 1.0 / contents_scale_y());
   return xform;
 }
 
+void Layer::SetFrameTimingRequests(
+    const std::vector<FrameTimingRequest>& requests) {
+  frame_timing_requests_ = requests;
+  frame_timing_requests_dirty_ = true;
+  SetNeedsCommit();
+}
+
 }  // namespace cc