Add glue between the client and engine for Blimp

blimp/engine/browser/host_render_widget_message_processor_unittest.cc

Index: blimp/engine/browser/host_render_widget_message_processor_unittest.cc
diff --git a/blimp/engine/browser/host_render_widget_message_processor_unittest.cc b/blimp/engine/browser/host_render_widget_message_processor_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..02ac3e48ea852a7b14544e9a27a38ca613c4f88d
--- /dev/null
+++ b/blimp/engine/browser/host_render_widget_message_processor_unittest.cc
@@ -0,0 +1,180 @@
+// Copyright 2015 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 "blimp/engine/browser/host_render_widget_message_processor.h"
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "blimp/common/proto/blimp_message.pb.h"
+#include "blimp/common/proto/compositor.pb.h"
+#include "blimp/common/proto/render_widget.pb.h"
+#include "blimp/net/input_message_generator.h"
+#include "net/base/net_errors.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+
+using testing::_;
+using testing::InvokeArgument;
+using testing::Ref;
+using testing::Return;
+using testing::SaveArg;
+
+namespace blimp {
+
+namespace {
+class MockBlimpMessageProcessor : public BlimpMessageProcessor {

[haibinlu, 2015/11/19 19:21:17]

ditto. use test_common.h

+ public:
+  MockBlimpMessageProcessor() {}
+
+  ~MockBlimpMessageProcessor() override {}
+
+  // Adapts calls from ProcessMessage to MockableProcessMessage by
+  // unboxing the |message| scoped_ptr for GMock compatibility.
+  void ProcessMessage(scoped_ptr<BlimpMessage> message,
+                      const net::CompletionCallback& callback) {
+    MockableProcessMessage(*message);
+    if (!callback.is_null())
+      callback.Run(net::OK);
+  }
+
+  MOCK_METHOD1(MockableProcessMessage,
+               void(const BlimpMessage& message));
+};
+
+class MockHostRenderWidgetMessageDelegate
+    : public HostRenderWidgetMessageProcessor::RenderWidgetMessageDelegate {
+ public:
+  // HostRenderWidgetMessageProcessor implementation.
+  void OnWebInputEvent(scoped_ptr<blink::WebInputEvent> event) override {
+    MockableOnWebInputEvent();
+  }
+
+  void OnCompositorMessageReceived(
+      const std::vector<uint8_t>& message) override {
+    MockableOnCompositorMessageReceived();
+  }
+
+  MOCK_METHOD0(MockableOnWebInputEvent, void());
+  MOCK_METHOD0(MockableOnCompositorMessageReceived, void());
+};
+
+MATCHER_P2(RenderWidgetMessageEquals, tab_id, rw_id, "") {
+  return arg.render_widget().render_widget_id() == rw_id &&
+      arg.target_tab_id() == tab_id;
+}
+
+MATCHER_P2(CompositorMessageEquals, tab_id, rw_id, "") {
+  return arg.compositor().render_widget_id() == rw_id &&
+      arg.target_tab_id() == tab_id;
+}
+
+void SendInputMessage(BlimpMessageProcessor* processor,
+                             int tab_id,
+                             uint32_t rw_id) {
+  scoped_ptr<BlimpMessage> message(new BlimpMessage);
+  message->set_type(BlimpMessage::INPUT);
+  message->set_target_tab_id(tab_id);
+
+  InputMessage* details = message->mutable_input();
+  details->set_render_widget_id(rw_id);
+
+  blink::WebGestureEvent input_event;
+  input_event.type = blink::WebInputEvent::Type::GestureTap;
+  InputMessageGenerator generator;
+  generator.GenerateMessage(&input_event, details);
+
+  processor->ProcessMessage(message.Pass(),
+                            net::CompletionCallback());
+}
+
+void SendCompositorMessage(BlimpMessageProcessor* processor,
+                             int tab_id,
+                             uint32_t rw_id) {
+  scoped_ptr<BlimpMessage> message(new BlimpMessage);
+  message->set_type(BlimpMessage::COMPOSITOR);
+  message->set_target_tab_id(tab_id);
+
+  CompositorMessage* details = message->mutable_compositor();
+  details->set_render_widget_id(rw_id);
+  processor->ProcessMessage(message.Pass(),
+                            net::CompletionCallback());
+}
+
+}  // namespace
+
+class HostRenderWidgetMessageProcessorTest : public testing::Test {
+ public:
+  HostRenderWidgetMessageProcessorTest()
+      : processor_(&out_processor_) {}
+
+  void SetUp() override {
+    processor_.SetDelegate(1, &delegate1_);
+    processor_.SetDelegate(2, &delegate2_);
+
+    processor_.OnRenderWidgetInitialized(1);
+    processor_.OnRenderWidgetInitialized(2);
+  }
+
+ protected:
+  MockBlimpMessageProcessor out_processor_;
+  MockHostRenderWidgetMessageDelegate delegate1_;
+  MockHostRenderWidgetMessageDelegate delegate2_;
+  HostRenderWidgetMessageProcessor processor_;
+};
+
+TEST_F(HostRenderWidgetMessageProcessorTest, DelegateCallsOK) {
+  EXPECT_CALL(delegate1_, MockableOnCompositorMessageReceived()).Times(1);

[haibinlu, 2015/11/19 19:21:17]

add a test case to check the correct payload is received.

[David Trainor- moved to gerrit, 2015/11/20 17:58:53]

Good point.  I baked this into the expected results for all of the tests that
call the method.

+  SendCompositorMessage(&processor_, 1, 1U);
+
+  EXPECT_CALL(delegate1_, MockableOnWebInputEvent()).Times(1);
+  SendInputMessage(&processor_, 1, 1U);
+
+  EXPECT_CALL(delegate2_, MockableOnCompositorMessageReceived()).Times(1);
+  SendCompositorMessage(&processor_, 2, 1U);
+
+  EXPECT_CALL(delegate2_, MockableOnWebInputEvent()).Times(1);
+  SendInputMessage(&processor_, 2, 1U);
+}
+
+TEST_F(HostRenderWidgetMessageProcessorTest, DropsStaleMessages) {
+  EXPECT_CALL(delegate1_, MockableOnCompositorMessageReceived()).Times(1);
+  SendCompositorMessage(&processor_, 1, 1U);
+
+  EXPECT_CALL(out_processor_,
+              MockableProcessMessage(RenderWidgetMessageEquals(1, 2U)))
+      .Times(1);
+  processor_.OnRenderWidgetInitialized(1);
+
+  EXPECT_CALL(delegate1_, MockableOnCompositorMessageReceived()).Times(0);
+  SendCompositorMessage(&processor_, 1, 1U);
+
+  EXPECT_CALL(delegate1_, MockableOnWebInputEvent()).Times(0);
+  SendInputMessage(&processor_, 1, 1U);
+
+  EXPECT_CALL(delegate1_, MockableOnCompositorMessageReceived()).Times(1);
+  SendCompositorMessage(&processor_, 1, 2U);
+
+  EXPECT_CALL(delegate1_, MockableOnWebInputEvent()).Times(1);
+  SendInputMessage(&processor_, 1, 2U);
+}
+
+TEST_F(HostRenderWidgetMessageProcessorTest, RepliesHaveCorrectRenderWidgetId) {
+  EXPECT_CALL(out_processor_,
+              MockableProcessMessage(RenderWidgetMessageEquals(1, 2U)))
+      .Times(1);
+  processor_.OnRenderWidgetInitialized(1);
+
+  EXPECT_CALL(out_processor_,
+              MockableProcessMessage(RenderWidgetMessageEquals(2, 2U)))
+      .Times(1);
+  processor_.OnRenderWidgetInitialized(2);
+
+  EXPECT_CALL(out_processor_,
+              MockableProcessMessage(CompositorMessageEquals(1, 2U))).Times(1);
+  processor_.SendCompositorMessage(1, std::vector<uint8_t>());
+}
+
+
+}  // namespace blimp