Add compositor support for the LatencyInfo.

cc/trees/layer_tree_host.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_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 235 matching lines @@
   proxy_->MainThreadHasStoppedFlinging();
 }
 
 void LayerTreeHost::Layout() {
   client_->Layout();
 }
 
 void LayerTreeHost::BeginCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   DCHECK(proxy_->IsImplThread());
   TRACE_EVENT0("cc", "LayerTreeHost::CommitTo");
+  host_impl->SetLatencyInfo(latency_info_);

[jamesr, 2013/04/17 23:15:21]

To make this work in impl-side painting you want to associate the latency
information with a LayerTreeImpl, not with a LayerTreeHostImpl.  Impl-side
painting works by doing this:

LayerTreeHost pushes info to the LayerTreeHostImpl::pending_tree_, which is a
LayerTreeImpl
then when the pending tree has rasterized enough
LayerTreeHostImpl pushes the pending_tree_ into its active_tree_

LayerTreeHostImpl always draws (swaps) from its active_tree_.

I think it's easy enough to put this information on the LayerTreeImpl from the
start, so can we do that in this patch?  See the 'sync_tree_' in
FinishCommitOnImplThread() below

+  latency_info_.Clear();
 }
 
 // This function commits the LayerTreeHost to an impl tree. When modifying
 // this function, keep in mind that the function *runs* on the impl thread! Any
 // code that is logically a main thread operation, e.g. deletion of a Layer,
 // should be delayed until the LayerTreeHost::CommitComplete, which will run
 // after the commit, but on the main thread.
 void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   DCHECK(proxy_->IsImplThread());
 
@@ skipping 402 matching lines @@
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   proxy_->SetVisible(visible);
 }
 
+void LayerTreeHost::SetLatencyInfo(const LatencyInfo& latency_info) {
+  latency_info_.MergeWith(latency_info);
+}
+
 void LayerTreeHost::StartPageScaleAnimation(gfx::Vector2d target_offset,
                                             bool use_anchor,
                                             float scale,
                                             base::TimeDelta duration) {
   pending_page_scale_animation_.reset(new PendingPageScaleAnimation);
   pending_page_scale_animation_->target_offset = target_offset;
   pending_page_scale_animation_->use_anchor = use_anchor;
   pending_page_scale_animation_->scale = scale;
   pending_page_scale_animation_->duration = duration;
 
@@ skipping 392 matching lines @@
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc