Deliver IPC messages together with SwapCompositorFrame

content/renderer/queue_message_swap_promise_unittest.cc

+// Copyright 2014 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/renderer/queue_message_swap_promise.h"
+
+#include <vector>
+
+#include "base/memory/scoped_vector.h"
+#include "cc/base/swap_promise.h"
+#include "content/renderer/gpu/frame_swap_message_queue.h"
+#include "content/renderer/gpu/render_widget_compositor.h"
+#include "content/renderer/render_widget.h"
+#include "content/test/mock_render_process.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_sync_message_filter.h"
+#include "ipc/ipc_test_sink.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+class TestRenderWidget : public RenderWidget {
+ public:
+  using RenderWidget::QueueMessageImpl;
+};
+
+class TestSyncMessageFilter : public IPC::SyncMessageFilter {
+ public:
+  TestSyncMessageFilter() : IPC::SyncMessageFilter(NULL) {}
+  virtual bool Send(IPC::Message* message) OVERRIDE {
+    messages_.push_back(message);
+    return true;
+  }

[piman, 2014/06/24 19:35:53]

nit: blank lines between methods.
(also 'git cl format' can help).

[mkosiba (inactive), 2014/06/25 18:40:38]

Done. clang-format seems to not care about this.

+  ScopedVector<IPC::Message>& messages() {
+    return messages_;
+  }
+ private:
+  ScopedVector<IPC::Message> messages_;
+};
+
+class QueueMessageSwapPromiseTest : public testing::Test {
+ public:
+  QueueMessageSwapPromiseTest()
+      : frame_swap_message_queue_(new FrameSwapMessageQueue()),
+        sync_message_filter_(new TestSyncMessageFilter()),
+        message_(42, 0, IPC::Message::PRIORITY_NORMAL) {}
+  virtual ~QueueMessageSwapPromiseTest() {}
+
+  scoped_ptr<cc::SwapPromise> QueueMessageImpl(
+      IPC::Message* msg,
+      MessageDeliveryPolicy policy,
+      bool commit_requested,
+      int source_frame_number) {
+    return TestRenderWidget::QueueMessageImpl(msg,
+                                              policy,
+                                              frame_swap_message_queue_,
+                                              sync_message_filter_,
+                                              commit_requested,
+                                              source_frame_number).Pass();
+  }
+  ScopedVector<IPC::Message>& DirectSendMessages() {
+    return sync_message_filter_->messages();
+  }
+  bool NextSwapHasMessage() {
+    ScopedVector<IPC::Message> messages;
+    scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
+        frame_swap_message_queue_->AcquireSendMessageScope();
+    frame_swap_message_queue_->DrainMessages(&messages);
+    return !messages.empty() &&
+           messages.front()->routing_id() == message_.routing_id();
+  }
+
+ protected:
+  scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue_;
+  scoped_refptr<TestSyncMessageFilter> sync_message_filter_;
+  IPC::Message message_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(QueueMessageSwapPromiseTest);
+};
+
+
+TEST_F(QueueMessageSwapPromiseTest, NextSwapPolicy) {
+  scoped_ptr<cc::SwapPromise> swap_promise =
+      QueueMessageImpl(new IPC::Message(message_),
+                       MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+                       false, /* commit_requested */
+                       1 /* source_frame_number */);
+  ASSERT_FALSE(swap_promise);
+  ASSERT_TRUE(DirectSendMessages().empty());
+  ASSERT_FALSE(frame_swap_message_queue_->Empty());
+  ASSERT_TRUE(NextSwapHasMessage());
+}
+
+TEST_F(QueueMessageSwapPromiseTest, VisualStateFastPath) {
+  scoped_ptr<cc::SwapPromise> swap_promise =
+      QueueMessageImpl(new IPC::Message(message_),
+                       MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+                       false, /* commit_requested */
+                       1 /* source_frame_number */);
+  ASSERT_FALSE(swap_promise);
+  ASSERT_FALSE(DirectSendMessages().empty());
+  ASSERT_TRUE(frame_swap_message_queue_->Empty());
+  ASSERT_FALSE(NextSwapHasMessage());
+}
+
+TEST_F(QueueMessageSwapPromiseTest, VisualStateWhenCommitRequested) {
+  scoped_ptr<cc::SwapPromise> swap_promise =
+      QueueMessageImpl(new IPC::Message(message_),
+                       MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+                       true, /* commit_requested */
+                       1 /* source_frame_number */);
+  ASSERT_TRUE(swap_promise);
+  ASSERT_TRUE(DirectSendMessages().empty());
+  ASSERT_FALSE(frame_swap_message_queue_->Empty());
+  ASSERT_FALSE(NextSwapHasMessage());
+
+  swap_promise->DidSwap(NULL);
+}

[mkosiba (inactive), 2014/06/24 18:29:54]

I'll add more tests in a subsequent iteration.

+
+}  // namespace content