Expose synthetic delays through the GPU benchmarking extension

content/renderer/render_widget.h

 // 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.
 
 #ifndef CONTENT_RENDERER_RENDER_WIDGET_H_
 #define CONTENT_RENDERER_RENDER_WIDGET_H_
 
 #include <deque>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/debug/trace_event_synthetic_delay.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "content/common/browser_rendering_stats.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/renderer/paint_aggregator.h"
@@ skipping 41 matching lines @@
 }
 
 namespace content {
 class ExternalPopupMenu;
 class PepperPluginInstanceImpl;
 class RenderWidgetCompositor;
 class RenderWidgetTest;
 class ResizingModeSelector;
 struct ContextMenuParams;
 struct GpuRenderingStats;
+struct SyntheticDelayConfiguration;
 struct WebPluginGeometry;
 
 // RenderWidget provides a communication bridge between a WebWidget and
 // a RenderWidgetHost, the latter of which lives in a different process.
 class CONTENT_EXPORT RenderWidget
     : public IPC::Listener,
       public IPC::Sender,
       NON_EXPORTED_BASE(virtual public blink::WebWidgetClient),
       public base::RefCounted<RenderWidget> {
  public:
@@ skipping 94 matching lines @@
 
   // Callback for use with synthetic gestures (e.g. BeginSmoothScroll).
   typedef base::Callback<void()> SyntheticGestureCompletionCallback;
 
   // Send a synthetic gesture to the browser to be queued to the synthetic
   // gesture controller.
   void QueueSyntheticGesture(
       scoped_ptr<SyntheticGestureParams> gesture_params,
       const SyntheticGestureCompletionCallback& callback);
 
+  // Configure synthetic delays across all processes. Once all processes have
+  // acknowledged the new delay configuration, |callback| will be called back.
+  typedef base::Callback<void()> SyntheticDelayConfigurationCallback;
+  void ConfigureSyntheticDelays(
+      const std::vector<content::SyntheticDelayConfiguration>& delays,
+      const SyntheticDelayConfigurationCallback& callback);
+
   // Close the underlying WebWidget.
   virtual void Close();
 
   // Notifies about a compositor frame commit operation having finished.
   virtual void DidCommitCompositorFrame();
 
   float filtered_time_per_frame() const {
     return filtered_time_per_frame_;
   }
 
@@ skipping 140 matching lines @@
       int selection_end);
   virtual void OnImeConfirmComposition(const string16& text,
                                        const gfx::Range& replacement_range,
                                        bool keep_selection);
   void OnPaintAtSize(const TransportDIB::Handle& dib_id,
                      int tag,
                      const gfx::Size& page_size,
                      const gfx::Size& desired_size);
   void OnRepaint(gfx::Size size_to_paint);
   void OnSyntheticGestureCompleted();
+  void OnConfigureSyntheticDelaysAck();
   void OnSetTextDirection(blink::WebTextDirection direction);
   void OnGetFPS();
   void OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
                            const gfx::Rect& window_screen_rect);
 #if defined(OS_ANDROID)
   void OnShowImeIfNeeded();
 
   // Whenever an IME event that needs an acknowledgement is sent to the browser,
   // the number of outstanding IME events that needs acknowledgement should be
   // incremented. All IME events will be dropped until we receive an ack from
@@ skipping 382 matching lines @@
   // The device scale factor. This value is computed from the DPI entries in
   // |screen_info_| on some platforms, and defaults to 1 on other platforms.
   float device_scale_factor_;
 
   // State associated with synthetic gestures. Synthetic gestures are processed
   // in-order, so a queue is sufficient to identify the correct state for a
   // completed gesture.
   std::queue<SyntheticGestureCompletionCallback>
       pending_synthetic_gesture_callbacks_;
 
+  SyntheticDelayConfigurationCallback pending_delay_configuration_;
+
   // Specified whether the compositor will run in its own thread.
   bool is_threaded_compositing_enabled_;
 
   // The last set of rendering stats received from the browser. This is only
   // received when using the --enable-gpu-benchmarking flag.
   BrowserRenderingStats browser_rendering_stats_;
 
   // The latency information for any current non-accelerated-compositing
   // frame.
   ui::LatencyInfo latency_info_;
@@ skipping 16 matching lines @@
   float popup_origin_scale_for_emulation_;
 
   scoped_ptr<ResizingModeSelector> resizing_mode_selector_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidget);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_WIDGET_H_