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 303 matching lines @@
 #endif
 #if defined(OS_ANDROID)
     ui::SetScreenAndroid();  // calls display::Screen::SetScreenInstance().
 #endif
 #if defined(USE_AURA)
     screen_.reset(aura::TestScreen::Create(gfx::Size()));
     display::Screen::SetScreenInstance(screen_.get());
 #endif
     host_.reset(new MockRenderWidgetHost(delegate_.get(), process_,
                                          process_->GetNextRoutingID()));
-    view_.reset(new TestView(host_.get()));
-    ConfigureView(view_.get());
-    host_->SetView(view_.get());
+    view_ = new TestView(host_.get());
+    ConfigureView(view_);
+    host_->SetView(view_);
     SetInitialRenderSizeParams();
     host_->Init();
     host_->DisableGestureDebounce();
   }
 
   void TearDown() override {
-    view_.reset();
     host_.reset();
     delegate_.reset();
     process_ = NULL;
     browser_context_.reset();
 
 #if defined(USE_AURA)
     display::Screen::SetScreenInstance(nullptr);
     screen_.reset();
 #endif
 #if defined(USE_AURA) || defined(OS_MACOSX)
@@ skipping 137 matching lines @@
     int data_length;
     if (!iter.ReadData(&data, &data_length))
       return NULL;
     return reinterpret_cast<const WebInputEvent*>(data);
   }
 
   std::unique_ptr<TestBrowserContext> browser_context_;
   RenderWidgetHostProcess* process_;  // Deleted automatically by the widget.
   std::unique_ptr<MockRenderWidgetHostDelegate> delegate_;
   std::unique_ptr<MockRenderWidgetHost> host_;
-  std::unique_ptr<TestView> view_;
+  TestView* view_;
   std::unique_ptr<display::Screen> screen_;
   bool handle_key_press_event_;
   bool handle_mouse_event_;
   double last_simulated_event_time_seconds_;
   double simulated_event_time_delta_seconds_;
   IPC::TestSink* sink_;
 
  private:
   SyntheticWebTouchEvent touch_event_;
 
@@ skipping 191 matching lines @@
 
   // Simulate a renderer crash before the update message.  Ensure all the
   // resize ack logic is cleared.  Must clear the view first so it doesn't get
   // deleted.
   host_->SetView(NULL);
   host_->RendererExited(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
   EXPECT_FALSE(host_->resize_ack_pending_);
   EXPECT_EQ(gfx::Size(), host_->old_resize_params_->new_size);
 
   // Reset the view so we can exit the test cleanly.
-  host_->SetView(view_.get());
+  host_->SetView(view_);
 }
 
 // Unable to include render_widget_host_view_mac.h and compile.
 #if !defined(OS_MACOSX)
 // Tests setting background transparency.
 TEST_F(RenderWidgetHostTest, Background) {
   std::unique_ptr<RenderWidgetHostViewBase> view;
 #if defined(USE_AURA)
   view.reset(new RenderWidgetHostViewAura(host_.get(), false));
   // TODO(derat): Call this on all platforms: http://crbug.com/102450.
@@ skipping 989 matching lines @@
 TEST_F(RenderWidgetHostTest, CompositorFrameSinkIdChanges) {
   const gfx::Size frame_size(50, 50);
   const cc::LocalSurfaceId local_surface_id(1,
                                             base::UnguessableToken::Create());
 
   // Ignore any IPC message sent so far.
   sink_->ClearMessages();
 
   // Submit a frame with compositor_frame_sink_id=1
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
-  host_->OnMessageReceived(ViewHostMsg_SwapCompositorFrame(
-      0, 1, local_surface_id, frame, std::vector<IPC::Message>()));
+  host_->OnMessageReceived(
+      ViewHostMsg_SwapCompositorFrame(0, 1, local_surface_id, frame));
 
   // Send an ack. The right compositor_frame_sink_id must be sent.
   host_->SendReclaimCompositorResources(true /* is_swap_ack */,
                                         cc::ReturnedResourceArray());
   ASSERT_EQ(1u, sink_->message_count());
   {
     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(1u, std::get<0>(params));  // compositor_frame_sink_id
   }
   sink_->ClearMessages();
 
   // Submit a frame with compositor_frame_sink_id=2. Verify that view_ is
   // notified of the change in id.
   view_->reset_did_change_compositor_frame_sink();
   frame = MakeCompositorFrame(1.f, frame_size);
-  host_->OnMessageReceived(ViewHostMsg_SwapCompositorFrame(
-      2, 2, local_surface_id, frame, std::vector<IPC::Message>()));
+  host_->OnMessageReceived(
+      ViewHostMsg_SwapCompositorFrame(2, 2, local_surface_id, frame));
   EXPECT_TRUE(view_->did_change_compositor_frame_sink());
 
   // Send an ack. The right compositor_frame_sink_id must be sent.
   host_->SendReclaimCompositorResources(true /* is_swap_ack */,
                                         cc::ReturnedResourceArray());
   ASSERT_EQ(1u, sink_->message_count());
   {
     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();
 }
 
+// Check that if messages of a frame arrive earlier than the frame itself, we
+// queue the messages until the frame arrives and then process them.
+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());
+}
+
+// Check that if a frame arrives earlier than its messages, we process the
+// messages immedtiately.
+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());
+}
+
+// Check that if messages of multiple frames arrive before the frames, we
+// process each message once it frame arrives.
+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());
+}
+
+// Check that if multiple frames arrive before their messages, each message is
+// processed immediately as soon as it arrives.
+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());
+}
+
+// Check that if one frame is lost but its messages arrive, we process the
+// messages on the arrival of the next frame.
+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(2u, host_->processed_frame_messages_count());
+}
+
+// Check that if the renderer crashes, we process all queued messages and allow
+// smaller frame tokens to be sent by the renderer.
+TEST_F(RenderWidgetHostTest, FrameToken_RendererCrash) {
+  const uint32_t frame_token1 = 99;
+  const uint32_t frame_token2 = 50;
+  const uint32_t frame_token3 = 30;
+  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> messages3;
+  messages1.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(5));
+  messages3.push_back(ViewHostMsg_DidFirstVisuallyNonEmptyPaint(6));
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token1, messages1));
+  EXPECT_EQ(1u, host_->queued_messages_.size());
+  EXPECT_EQ(0u, host_->processed_frame_messages_count());
+
+  host_->RendererExited(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(1u, host_->processed_frame_messages_count());
+  host_->Init();
+
+  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());
+
+  host_->RendererExited(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(1u, host_->processed_frame_messages_count());
+  host_->Init();
+
+  host_->OnMessageReceived(
+      ViewHostMsg_FrameSwapMessages(0, frame_token3, messages3));
+  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_token3;
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame));
+  EXPECT_EQ(0u, host_->queued_messages_.size());
+  EXPECT_EQ(2u, host_->processed_frame_messages_count());
+}
+
 }  // namespace content