Add glue between the client and engine for Blimp

blimp/client/compositor/render_widget_message_processor.cc

+// 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/client/compositor/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 "cc/proto/compositor_message.pb.h"
+#include "net/base/net_errors.h"
+
+namespace blimp {
+
+RenderWidgetMessageProcessor::RenderWidgetMessageProcessor(
+    BlimpMessageProcessor* input_message_processor,
+    BlimpMessageProcessor* compositor_message_processor)
+    : input_message_processor_(input_message_processor),
+      compositor_message_processor_(compositor_message_processor) {
+  // TODO(dtrainor): Register as a BlimpMessageProcessor for
+  // BlimpMessage::RENDER_WIDGET and BlimpMessage::COMPOSITOR messages.
+}
+
+RenderWidgetMessageProcessor::~RenderWidgetMessageProcessor() {
+  // TODO(dtrainor): Unregister as a BlimpMessageProcessor for
+  // BlimpMessage::RENDER_WIDGET and BlimpMessage::COMPOSITOR messages.
+}
+
+void RenderWidgetMessageProcessor::SendInputEvent(
+    const int tab_id, const blink::WebInputEvent& event) {
+  scoped_ptr<BlimpMessage> blimp_message =
+      input_message_generator_.GenerateMessage(event);
+
+  // Don't send unsupported WebInputEvents.
+  if (!blimp_message)
+    return;
+
+  blimp_message->set_target_tab_id(tab_id);
+  blimp_message->mutable_input()->set_render_widget_id(
+      GetRenderWidgetId(tab_id));
+
+  input_message_processor_->ProcessMessage(std::move(blimp_message),
+                                           net::CompletionCallback());
+}
+
+void RenderWidgetMessageProcessor::SendCompositorMessage(
+    const int tab_id,
+    const cc::proto::CompositorMessage& message) {
+  scoped_ptr<BlimpMessage> blimp_message(new BlimpMessage);
+  blimp_message->set_target_tab_id(tab_id);
+
+  CompositorMessage* compositor_message = blimp_message->mutable_compositor();
+  uint32_t render_widget_id = GetRenderWidgetId(tab_id);
+  DCHECK_LT(0U, render_widget_id);
+  compositor_message->set_render_widget_id(render_widget_id);
+  compositor_message->mutable_payload()->resize(
+      base::checked_cast<size_t>(message.ByteSize()));
+  if (message.SerializeToString(compositor_message->mutable_payload())) {
+    compositor_message_processor_->ProcessMessage(std::move(blimp_message),
+                                                  net::CompletionCallback());
+  } else {
+    LOG(ERROR) << "Unable to serialize compositor proto.";
+  }
+}
+
+void RenderWidgetMessageProcessor::SetDelegate(
+    const int tab_id, RenderWidgetMessageDelegate* delegate) {
+  DCHECK(!FindDelegate(tab_id));
+  delegates_[tab_id] = delegate;
+}
+
+void RenderWidgetMessageProcessor::RemoveDelegate(const int tab_id) {
+  DelegateMap::iterator it = delegates_.find(tab_id);
+  if (it != delegates_.end())
+    delegates_.erase(it);
+}
+
+void RenderWidgetMessageProcessor::ProcessMessage(
+    scoped_ptr<BlimpMessage> message,
+    const net::CompletionCallback& callback) {
+  DCHECK(message->type() == BlimpMessage::RENDER_WIDGET ||
+         message->type() == BlimpMessage::COMPOSITOR);
+
+  int target_tab_id = message->target_tab_id();
+  RenderWidgetMessageDelegate* delegate = FindDelegate(target_tab_id);
+  DCHECK(delegate);
+
+  switch (message->type()) {
+    case BlimpMessage::RENDER_WIDGET:
+      if (message->render_widget().type() == RenderWidgetMessage::INITIALIZE) {
+        render_widget_ids_[target_tab_id] =
+            message->render_widget().render_widget_id();
+        delegate->OnRenderWidgetInitialized();
+      }
+      break;
+    case BlimpMessage::COMPOSITOR:
+      {
+        DCHECK_EQ(message->compositor().render_widget_id(),
+                  GetRenderWidgetId(target_tab_id));
+        scoped_ptr<cc::proto::CompositorMessage> payload(
+            new cc::proto::CompositorMessage);
+        if (payload->ParseFromString(message->compositor().payload())) {
+          delegate->OnCompositorMessageReceived(std::move(payload));
+        }
+      }
+      break;
+    default:
+      NOTIMPLEMENTED();
+  }
+
+  if (!callback.is_null()) {
+    callback.Run(net::OK);
+  }
+}
+
+RenderWidgetMessageProcessor::RenderWidgetMessageDelegate*
+RenderWidgetMessageProcessor::FindDelegate(
+    const int tab_id) {
+  DelegateMap::const_iterator it = delegates_.find(tab_id);
+  if (it != delegates_.end())
+    return it->second;
+  return nullptr;
+}
+
+uint32_t RenderWidgetMessageProcessor::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