Add glue between the client and engine for Blimp

blimp/engine/browser/host_render_widget_message_processor.cc

Index: blimp/engine/browser/host_render_widget_message_processor.cc
diff --git a/blimp/engine/browser/host_render_widget_message_processor.cc b/blimp/engine/browser/host_render_widget_message_processor.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a12c42c8fb2c93de204b40880da0b70308012210
--- /dev/null
+++ b/blimp/engine/browser/host_render_widget_message_processor.cc
@@ -0,0 +1,131 @@
+// 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/numerics/safe_conversions.h"
+#include "blimp/common/proto/blimp_message.pb.h"
+#include "blimp/common/proto/compositor.pb.h"
+#include "blimp/common/proto/input.pb.h"
+#include "blimp/common/proto/render_widget.pb.h"
+#include "net/base/net_errors.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+
+namespace blimp {
+
+HostRenderWidgetMessageProcessor::HostRenderWidgetMessageProcessor(
+    BlimpMessageProcessor* outgoing_message_processor)
+    : outgoing_message_processor_(outgoing_message_processor) {
+  // TODO(dtrainor): Register as a BlimpMessageProcessor for
+  // BlimpMessage::INPUT and BlimpMessage::COMPOSITOR messages.
+}
+
+HostRenderWidgetMessageProcessor::~HostRenderWidgetMessageProcessor() {
+  // TODO(dtrainor): Unregister as a BlimpMessageProcessor for
+  // BlimpMessage::INPUT and BlimpMessage::COMPOSITOR messages.
+}
+
+void HostRenderWidgetMessageProcessor::OnRenderWidgetInitialized(
+    const int tab_id) {
+  render_widget_ids_[tab_id] = GetRenderWidgetId(tab_id) + 1;
+
+  scoped_ptr<BlimpMessage> blimp_message(new BlimpMessage);
+  blimp_message->set_type(BlimpMessage::RENDER_WIDGET);
+  blimp_message->set_target_tab_id(tab_id);
+
+  RenderWidgetMessage* render_widget_message =
+      blimp_message->mutable_render_widget();
+
+  render_widget_message->set_type(RenderWidgetMessage::INITIALIZE);
+  render_widget_message->set_render_widget_id(GetRenderWidgetId(tab_id));
+
+  outgoing_message_processor_->ProcessMessage(blimp_message.Pass(),
+                                              net::CompletionCallback());
+}
+
+void HostRenderWidgetMessageProcessor::SendCompositorMessage(
+    const int tab_id,
+    const std::vector<uint8_t>& message) {
+  scoped_ptr<BlimpMessage> blimp_message(new BlimpMessage);
+  blimp_message->set_type(BlimpMessage::COMPOSITOR);
+  blimp_message->set_target_tab_id(tab_id);
+
+  CompositorMessage* compositor_message = blimp_message->mutable_compositor();
+  compositor_message->set_render_widget_id(GetRenderWidgetId(tab_id));
+  compositor_message->set_payload(message.data(),
+                                  base::checked_cast<int>(message.size()));
+
+  outgoing_message_processor_->ProcessMessage(blimp_message.Pass(),
+                                              net::CompletionCallback());
+}
+
+void HostRenderWidgetMessageProcessor::SetDelegate(
+    const int tab_id, RenderWidgetMessageDelegate* delegate) {
+  DCHECK(!FindDelegate(tab_id));
+  delegates_[tab_id] = delegate;
+}
+
+void HostRenderWidgetMessageProcessor::RemoveDelegate(const int tab_id) {
+  DelegateMap::iterator it = delegates_.find(tab_id);
+  if (it != delegates_.end())
+    delegates_.erase(it);
+}
+
+void HostRenderWidgetMessageProcessor::ProcessMessage(
+    scoped_ptr<BlimpMessage> message,
+    const net::CompletionCallback& callback) {
+  DCHECK(message->type() == BlimpMessage::INPUT ||
+         message->type() == BlimpMessage::COMPOSITOR);
+
+  int target_tab_id = message->target_tab_id();
+  uint32_t render_widget_id = GetRenderWidgetId(target_tab_id);
+  DCHECK_GT(render_widget_id, 0U);
+
+  RenderWidgetMessageDelegate* delegate = FindDelegate(target_tab_id);
+  DCHECK(delegate);
+
+  switch (message->type()) {
+    case BlimpMessage::INPUT:
+      if (message->input().render_widget_id() == render_widget_id) {
+        scoped_ptr<blink::WebInputEvent> event =
+            input_message_processor_.ProcessMessage(message->input());
+        if (event)
+          delegate->OnWebInputEvent(event.Pass());
+      }
+      break;
+    case BlimpMessage::COMPOSITOR:
+      if (message->compositor().render_widget_id() == render_widget_id) {
+        std::vector<uint8_t> payload(message->compositor().payload().size());
+        memcpy(payload.data(),
+               message->compositor().payload().data(),
+               payload.size());
+        delegate->OnCompositorMessageReceived(payload);
+      }
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  if (!callback.is_null()) {
+    callback.Run(net::OK);
+  }
+}
+
+HostRenderWidgetMessageProcessor::RenderWidgetMessageDelegate*
+HostRenderWidgetMessageProcessor::FindDelegate(
+    const int tab_id) {
+  DelegateMap::const_iterator it = delegates_.find(tab_id);
+  if (it != delegates_.end())
+    return it->second;
+  return nullptr;
+}
+
+uint32_t HostRenderWidgetMessageProcessor::GetRenderWidgetId(const int tab_id) {
+  RenderWidgetIdMap::const_iterator it = render_widget_ids_.find(tab_id);
+  if (it != render_widget_ids_.end())
+    return it->second;
+  return 0U;
+}
+
+}  // namespace blimp