Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1247)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: content/renderer/gpu/queue_message_swap_promise_unittest.cc

Issue 240163005: Deliver IPC messages together with SwapCompositorFrame (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: introduce a separate queue for with_swap messages Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« content/renderer/gpu/frame_swap_message_queue.cc ('K') | « content/renderer/gpu/queue_message_swap_promise.cc ('k') | content/renderer/gpu/render_widget_compositor.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: content/renderer/gpu/queue_message_swap_promise_unittest.cc
diff --git a/content/renderer/gpu/queue_message_swap_promise_unittest.cc b/content/renderer/gpu/queue_message_swap_promise_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d1ddbe45de789be532c41b93fa006aa4f9db5f4c
--- /dev/null
+++ b/content/renderer/gpu/queue_message_swap_promise_unittest.cc
@@ -0,0 +1,291 @@
+// 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/gpu/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;
+ }
+
+ 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_a_(42, 0, IPC::Message::PRIORITY_NORMAL),
+ message_b_(23, 0, IPC::Message::PRIORITY_NORMAL),
+ message_c_(37, 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();
+ }
+
+ ScopedVector<IPC::Message>& NextSwapMessages() {
+ next_swap_messages_.clear();
+ scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
+ frame_swap_message_queue_->AcquireSendMessageScope();
+ frame_swap_message_queue_->DrainMessages(&next_swap_messages_);
+ return next_swap_messages_;
+ }
+
+ bool ContainsMessage(const ScopedVector<IPC::Message>& messages,
+ const IPC::Message& message) {
+ if (messages.empty())
+ return false;
+ for (ScopedVector<IPC::Message>::const_iterator i = messages.begin();
+ i != messages.end();
+ ++i) {
+ if ((*i)->routing_id() == message.routing_id())
+ return true;
+ }
+ return false;
+ }
+
+ bool NextSwapHasMessage(const IPC::Message& message) {
+ return ContainsMessage(NextSwapMessages(), message);
+ }
+
+ protected:
+ scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue_;
+ scoped_refptr<TestSyncMessageFilter> sync_message_filter_;
+ IPC::Message message_a_;
+ IPC::Message message_b_;
+ IPC::Message message_c_;
+
+ private:
+ ScopedVector<IPC::Message> next_swap_messages_;
+
+ DISALLOW_COPY_AND_ASSIGN(QueueMessageSwapPromiseTest);
+};
+
+TEST_F(QueueMessageSwapPromiseTest, NextSwapPolicySchedulesMessageForNextSwap) {
+ scoped_ptr<cc::SwapPromise> swap_promise =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ ASSERT_TRUE(swap_promise);
+ ASSERT_TRUE(DirectSendMessages().empty());
+ ASSERT_FALSE(frame_swap_message_queue_->Empty());
+ ASSERT_TRUE(NextSwapHasMessage(message_a_));
+
+ swap_promise->DidSwap(NULL);
+}
+
+TEST_F(QueueMessageSwapPromiseTest, NextSwapPolicyNeedsAtMostOnePromise) {
+ scoped_ptr<cc::SwapPromise> swap_promise_a =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ scoped_ptr<cc::SwapPromise> swap_promise_b =
+ QueueMessageImpl(new IPC::Message(message_b_),
+ MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ ASSERT_TRUE(swap_promise_a);
+ ASSERT_FALSE(swap_promise_b);
+
+ swap_promise_a->DidSwap(NULL);
+}
+
+TEST_F(QueueMessageSwapPromiseTest, NextSwapPolicySendsMessageOnNoUpdate) {
+ scoped_ptr<cc::SwapPromise> swap_promise =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ swap_promise->DidNotSwap(cc::SwapPromise::COMMIT_NO_UPDATE);
+ ASSERT_TRUE(ContainsMessage(DirectSendMessages(), message_a_));
+ ASSERT_TRUE(NextSwapMessages().empty());
+ ASSERT_TRUE(frame_swap_message_queue_->Empty());
+}
+
+TEST_F(QueueMessageSwapPromiseTest, NextSwapPolicySendsMessageOnSwapFails) {
+ scoped_ptr<cc::SwapPromise> swap_promise =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ swap_promise->DidNotSwap(cc::SwapPromise::SWAP_FAILS);
+ ASSERT_TRUE(ContainsMessage(DirectSendMessages(), message_a_));
+ ASSERT_TRUE(NextSwapMessages().empty());
+ ASSERT_TRUE(frame_swap_message_queue_->Empty());
+}
+
+TEST_F(QueueMessageSwapPromiseTest, NextSwapPolicyRetainsMessageOnCommitFails) {
+ scoped_ptr<cc::SwapPromise> swap_promise =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ swap_promise->DidNotSwap(cc::SwapPromise::COMMIT_FAILS);
+ ASSERT_TRUE(DirectSendMessages().empty());
+ ASSERT_FALSE(frame_swap_message_queue_->Empty());
+ ASSERT_TRUE(NextSwapHasMessage(message_a_));
+}
+
+TEST_F(QueueMessageSwapPromiseTest, VisualStateDirectSend) {
+ scoped_ptr<cc::SwapPromise> swap_promise =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ 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_TRUE(NextSwapMessages().empty());
+}
+
+TEST_F(QueueMessageSwapPromiseTest,
+ VisualStateQueuesMessageWhenCommitRequested) {
+ scoped_ptr<cc::SwapPromise> swap_promise =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ 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_TRUE(NextSwapMessages().empty());
+
+ swap_promise->DidSwap(NULL);
+}
+
+TEST_F(QueueMessageSwapPromiseTest,
+ VisualStateQueuesMessageWhenOtherMessageAlreadyQueued) {
+ scoped_ptr<cc::SwapPromise> swap_promise_a =
+ QueueMessageImpl(new IPC::Message(),
+ MESSAGE_DELIVERY_POLICY_WITH_NEXT_SWAP,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ scoped_ptr<cc::SwapPromise> swap_promise_b =
+ QueueMessageImpl(new IPC::Message(message_b_),
+ MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ ASSERT_TRUE(DirectSendMessages().empty());
+ ASSERT_FALSE(frame_swap_message_queue_->Empty());
+ ASSERT_FALSE(NextSwapHasMessage(message_b_));
+
+ swap_promise_a->DidSwap(NULL);
+ swap_promise_b->DidSwap(NULL);
+}
+
+TEST_F(QueueMessageSwapPromiseTest, VisalStateSwapPromiseDidSwap) {
+ scoped_ptr<cc::SwapPromise> swap_promise_a =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+ true, /* commit_requested */
+ 1 /* source_frame_number */);
+ scoped_ptr<cc::SwapPromise> swap_promise_b =
+ QueueMessageImpl(new IPC::Message(message_b_),
+ MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ scoped_ptr<cc::SwapPromise> swap_promise_c =
+ QueueMessageImpl(new IPC::Message(message_c_),
+ MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+ false, /* commit_requested */
+ 2 /* source_frame_number */);
+
+ swap_promise_a->DidSwap(NULL);
+ ASSERT_FALSE(swap_promise_b);
+ ScopedVector<IPC::Message> messages;
+ messages.swap(NextSwapMessages());
+ ASSERT_EQ(2u, messages.size());
+ ContainsMessage(messages, message_a_);
+ ContainsMessage(messages, message_b_);
+
+ swap_promise_c->DidSwap(NULL);
+ messages.swap(NextSwapMessages());
+ ASSERT_EQ(1u, messages.size());
+ ContainsMessage(messages, message_c_);
+
+ ASSERT_TRUE(DirectSendMessages().empty());
+ ASSERT_TRUE(NextSwapMessages().empty());
+ ASSERT_TRUE(frame_swap_message_queue_->Empty());
+}
+
+TEST_F(QueueMessageSwapPromiseTest, VisalStateSwapPromiseDidNotSwap) {
+ scoped_ptr<cc::SwapPromise> swap_promise_a =
+ QueueMessageImpl(new IPC::Message(message_a_),
+ MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+ true, /* commit_requested */
+ 1 /* source_frame_number */);
+ scoped_ptr<cc::SwapPromise> swap_promise_b =
+ QueueMessageImpl(new IPC::Message(message_b_),
+ MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+ false, /* commit_requested */
+ 1 /* source_frame_number */);
+ scoped_ptr<cc::SwapPromise> swap_promise_c =
+ QueueMessageImpl(new IPC::Message(message_c_),
+ MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE,
+ false, /* commit_requested */
+ 2 /* source_frame_number */);
+
+ swap_promise_a->DidSwap(NULL);
+ ASSERT_FALSE(swap_promise_b);
+ ScopedVector<IPC::Message> messages;
+ messages.swap(NextSwapMessages());
+ ASSERT_EQ(2u, messages.size());
+ ContainsMessage(messages, message_a_);
+ ContainsMessage(messages, message_b_);
+
+ swap_promise_c->DidSwap(NULL);
+ messages.swap(NextSwapMessages());
+ ASSERT_EQ(1u, messages.size());
+ ContainsMessage(messages, message_c_);
+
+ ASSERT_TRUE(DirectSendMessages().empty());
+ ASSERT_TRUE(NextSwapMessages().empty());
+ ASSERT_TRUE(frame_swap_message_queue_->Empty());
+}
+
+} // namespace content
« content/renderer/gpu/frame_swap_message_queue.cc ('K') | « content/renderer/gpu/queue_message_swap_promise.cc ('k') | content/renderer/gpu/render_widget_compositor.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698