Support plumbing LatencyInfo through the old software path.

content/browser/renderer_host/render_widget_host_view_gtk.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_gtk.h"
 
 #include <cairo/cairo.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
@@ skipping 835 matching lines @@
 }
 
 void RenderWidgetHostViewGtk::ImeCompositionRangeChanged(
     const ui::Range& range,
     const std::vector<gfx::Rect>& character_bounds) {
 }
 
 void RenderWidgetHostViewGtk::DidUpdateBackingStore(
     const gfx::Rect& scroll_rect,
     const gfx::Vector2d& scroll_delta,
-    const std::vector<gfx::Rect>& copy_rects) {
+    const std::vector<gfx::Rect>& copy_rects,
+    const ui::LatencyInfo& latency_info) {
   TRACE_EVENT0("ui::gtk", "RenderWidgetHostViewGtk::DidUpdateBackingStore");
+  software_latency_info_.MergeWith(latency_info);
 
   if (is_hidden_)
     return;
 
   // TODO(darin): Implement the equivalent of Win32's ScrollWindowEX.  Can that
   // be done using XCopyArea?  Perhaps similar to
   // BackingStore::ScrollBackingStore?
   if (about_to_validate_and_paint_)
     invalid_rect_.Union(scroll_rect);
   else
@@ skipping 336 matching lines @@
     }
     if (!web_contents_switch_paint_time_.is_null()) {
       base::TimeDelta web_contents_switch_paint_duration =
           base::TimeTicks::Now() - web_contents_switch_paint_time_;
       UMA_HISTOGRAM_TIMES("MPArch.RWH_TabSwitchPaintDuration",
           web_contents_switch_paint_duration);
       // Reset web_contents_switch_paint_time_ to 0 so future tab selections are
       // recorded.
       web_contents_switch_paint_time_ = base::TimeTicks();
     }
+    software_latency_info_.swap_timestamp = base::TimeTicks::HighResNow();
+    render_widget_host->FrameSwapped(software_latency_info_);

[piman, 2013/06/07 02:51:30]

So compared to the hardware path, this can somewhat misleading because this just
sent the command to X but we don't know when it'll be on screen really.
It's probably ok as a first step, but have we measured the delta? so that we can
normalize the typical latency expectation when comparing HW vs SW.

[jbauman, 2013/06/07 07:28:24]

Well, even in the hardware path we don't know when the actual swap to the screen
occurs - particularly when there's an external compositor.

I generally haven't worried too much about the precise amount of latency that we
can't measure, because that's very system-dependent (touchpad controller
latency, compositing window manager vs. not) and there's not that much we can do
about it. However, I think it wouldn't be hard to compare against our
camera-based measurements to see how much is being missed here.

+    software_latency_info_.Clear();
   } else {
     if (window)
       gdk_window_clear(window);
     if (whiteout_start_time_.is_null())
       whiteout_start_time_ = base::TimeTicks::Now();
   }
 }
 
 void RenderWidgetHostViewGtk::ShowCurrentCursor() {
   // The widget may not have a window. If that's the case, abort mission. This
@@ skipping 350 matching lines @@
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.CreatePluginContainer(id);
 }
 
 void RenderWidgetHostViewGtk::OnDestroyPluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.DestroyPluginContainer(id);
 }
 
 }  // namespace content