Send FrameSwapMessageQueue's messages with a separate IPC

content/browser/renderer_host/render_widget_host_impl.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_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 644 matching lines @@
       const ViewHostMsg_SelectionBounds_Params& params);
   void OnSetNeedsBeginFrames(bool needs_begin_frames);
   void OnHittestData(const FrameHostMsg_HittestData_Params& params);
   void OnFocusedNodeTouched(bool editable);
   void OnStartDragging(const DropData& drop_data,
                        blink::WebDragOperationsMask operations_allowed,
                        const SkBitmap& bitmap,
                        const gfx::Vector2d& bitmap_offset_in_dip,
                        const DragEventSourceInfo& event_info);
   void OnUpdateDragCursor(blink::WebDragOperation current_op);
+  void OnFrameSwapMessagesReceived(uint32_t frame_token,
+                                   std::vector<IPC::Message> messages);
 
   // Called (either immediately or asynchronously) after we're done with our
   // BackingStore and can send an ACK to the renderer so it can paint onto it
   // again.
   void DidUpdateBackingStore(const ViewHostMsg_UpdateRect_Params& params,
                              const base::TimeTicks& paint_start);
 
   // Give key press listeners a chance to handle this key press. This allow
   // widgets that don't have focus to still handle key presses.
   bool KeyPressListenersHandleEvent(const NativeWebKeyboardEvent& event);
@@ skipping 54 matching lines @@
   void StartHangMonitorTimeout(base::TimeDelta delay,
                                blink::WebInputEvent::Type event_type);
 
   // Stops all existing hang monitor timeouts and assumes the renderer is
   // responsive.
   void StopHangMonitorTimeout();
 
   // Used for UMA logging how long the renderer was unresponsive.
   void LogHangMonitorUnresponsive();
 
+  // Signals that a frame with token |frame_token| was finished processing. If
+  // there are any queued messages belonging to it, they will be processed.
+  void DidProcessFrame(uint32_t frame_token);
+
+  // Once both the frame and its swap messages arrive, we call this method to
+  // process the messages. Virtual for tests.
+  virtual void ProcessSwapMessages(std::vector<IPC::Message> messages);
+
   // true if a renderer has once been valid. We use this flag to display a sad
   // tab only when we lose our renderer and not if a paint occurs during
   // initialization.
   bool renderer_initialized_;
 
   // True if |Destroy()| has been called.
   bool destroyed_;
 
   // Our delegate, which wants to know mainly about keyboard events.
   // It will remain non-NULL until DetachDelegate() is called.
@@ skipping 192 matching lines @@
   // factor change, a new LocalSurfaceId must be created.
   cc::LocalSurfaceId last_local_surface_id_;
   gfx::Size last_frame_size_;
   float last_device_scale_factor_;
 
   // Each instance of RendererCompositorFrameSink has an ID that we keep track
   // of so we can tell when a new instance has been created for the purpose of
   // not returning stale resources.
   uint32_t last_compositor_frame_sink_id_ = 0;
 
+  // Last non-zero frame token received from the renderer. Any swap messsages
+  // having a token less than or equal to this value will be processed.
+  uint32_t last_received_frame_token_ = 0;
+
+  // List of all swap messages that their corresponding frames have not arrived.
+  // Sorted by frame token.
+  std::queue<std::pair<uint32_t, std::vector<IPC::Message>>> queued_messages_;
+
   base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_