Send FrameSwapMessageQueue's messages with a separate IPC

content/browser/renderer_host/render_widget_host_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <tuple>
 
@@ skipping 164 matching lines @@
 
   // Allow poking at a few private members.
   using RenderWidgetHostImpl::GetResizeParams;
   using RenderWidgetHostImpl::OnUpdateRect;
   using RenderWidgetHostImpl::RendererExited;
   using RenderWidgetHostImpl::SetInitialRenderSizeParams;
   using RenderWidgetHostImpl::old_resize_params_;
   using RenderWidgetHostImpl::is_hidden_;
   using RenderWidgetHostImpl::resize_ack_pending_;
   using RenderWidgetHostImpl::input_router_;
+  using RenderWidgetHostImpl::queued_messages_;
 
   void OnTouchEventAck(const TouchEventWithLatencyInfo& event,
                        InputEventAckState ack_result) override {
     // Sniff touch acks.
     acked_touch_event_type_ = event.event.type();
     RenderWidgetHostImpl::OnTouchEventAck(event, ack_result);
   }
 
   void reset_new_content_rendering_timeout_fired() {
     new_content_rendering_timeout_fired_ = false;
@@ skipping 13 matching lines @@
   }
 
   void SetupForInputRouterTest() {
     input_router_.reset(new MockInputRouter(this));
   }
 
   MockInputRouter* mock_input_router() {
     return static_cast<MockInputRouter*>(input_router_.get());
   }
 
+  uint32_t processed_frame_messages_count() {
+    return processed_frame_messages_count_;
+  }
+
  protected:
   void NotifyNewContentRenderingTimeoutForTesting() override {
     new_content_rendering_timeout_fired_ = true;
   }
 
   bool new_content_rendering_timeout_fired_;
   WebInputEvent::Type acked_touch_event_type_;
 
  private:
+  void ProcessSwapMessages(std::vector<IPC::Message> messages) override {
+    processed_frame_messages_count_++;
+  }
+  uint32_t processed_frame_messages_count_ = 0;
   DISALLOW_COPY_AND_ASSIGN(MockRenderWidgetHost);
 };
 
 namespace  {
 
 cc::CompositorFrame MakeCompositorFrame(float scale_factor, gfx::Size size) {
   cc::CompositorFrame frame;
   frame.metadata.device_scale_factor = scale_factor;
   frame.metadata.begin_frame_ack = cc::BeginFrameAck(0, 1, 1, true);
 
@@ skipping 1730 matching lines @@
   {
     const IPC::Message* msg = sink_->GetMessageAt(0);
     EXPECT_EQ(ViewMsg_ReclaimCompositorResources::ID, msg->type());
     ViewMsg_ReclaimCompositorResources::Param params;
     ViewMsg_ReclaimCompositorResources::Read(msg, &params);
     EXPECT_EQ(2u, std::get<0>(params));  // compositor_frame_sink_id
   }
   sink_->ClearMessages();
 }
 
+TEST_F(RenderWidgetHostTest, FrameToken_MessageThenFrame) {
+  const uint32_t frame_token = 99;
+  const gfx::Size frame_size(50, 50);
+  const cc::LocalSurfaceId local_surface_id(1,
+                                            base::UnguessableToken::Create());
+  std::vector<IPC::Message> messages;
+  messages.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(5));
+
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token, messages));
+  EXPECT_EQ(1u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
+  frame.metadata.frame_token = frame_token;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(1u, host_->processed_frame_messages_count());
+}
+
+TEST_F(RenderWidgetHostTest, FrameToken_FrameThenMessage) {
+  const uint32_t frame_token = 99;
+  const gfx::Size frame_size(50, 50);
+  const cc::LocalSurfaceId local_surface_id(1,
+                                            base::UnguessableToken::Create());
+  std::vector<IPC::Message> messages;
+  messages.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(5));
+
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
+  frame.metadata.frame_token = frame_token;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token, messages));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(1u, host_->processed_frame_messages_count());
+}
+
+TEST_F(RenderWidgetHostTest, FrameToken_MultipleMessagesThenTokens) {
+  const uint32_t frame_token1 = 99;
+  const uint32_t frame_token2 = 100;
+  const gfx::Size frame_size(50, 50);
+  const cc::LocalSurfaceId local_surface_id(1,
+                                            base::UnguessableToken::Create());
+  std::vector<IPC::Message> messages1;
+  std::vector<IPC::Message> messages2;
+  messages1.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(5));
+  messages2.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(6));
+
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token1, messages1));
+  EXPECT_EQ(1u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token2, messages2));
+  EXPECT_EQ(2u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
+  frame.metadata.frame_token = frame_token1;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(1u, host_->queued_messages_.size());
+  EXPECT_EQ(1u, host_->processed_frame_messages_count());
+
+  frame = MakeCompositorFrame(1.f, frame_size);
+  frame.metadata.frame_token = frame_token2;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(2u, host_->processed_frame_messages_count());
+}
+
+TEST_F(RenderWidgetHostTest, FrameToken_MultipleTokensThenMessages) {
+  const uint32_t frame_token1 = 99;
+  const uint32_t frame_token2 = 100;
+  const gfx::Size frame_size(50, 50);
+  const cc::LocalSurfaceId local_surface_id(1,
+                                            base::UnguessableToken::Create());
+  std::vector<IPC::Message> messages1;
+  std::vector<IPC::Message> messages2;
+  messages1.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(5));
+  messages2.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(6));
+
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
+  frame.metadata.frame_token = frame_token1;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  frame = MakeCompositorFrame(1.f, frame_size);
+  frame.metadata.frame_token = frame_token2;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token1, messages1));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(1u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token2, messages2));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(2u, host_->processed_frame_messages_count());
+}
+
+TEST_F(RenderWidgetHostTest, FrameToken_DroppedFrame) {
+  const uint32_t frame_token1 = 99;
+  const uint32_t frame_token2 = 100;
+  const gfx::Size frame_size(50, 50);
+  const cc::LocalSurfaceId local_surface_id(1,
+                                            base::UnguessableToken::Create());
+  std::vector<IPC::Message> messages1;
+  std::vector<IPC::Message> messages2;
+  messages1.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(5));
+  messages2.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(6));
+
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token1, messages1));
+  EXPECT_EQ(1u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token2, messages2));
+  EXPECT_EQ(2u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
+  frame.metadata.frame_token = frame_token2;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(1u, host_->processed_frame_messages_count());
+}
+
 }  // namespace content