Browser Plugin: New Implementation (Browser Side)

content/browser/browser_plugin/browser_plugin_host_helper.cc

+// Copyright (c) 2012 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/browser/browser_plugin/browser_plugin_host_helper.h"
+
+#include "base/time.h"
+#include "content/browser/browser_plugin/browser_plugin_host.h"
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/common/browser_plugin_messages.h"
+#include "content/common/view_messages.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "ui/gfx/size.h"
+
+namespace content {
+
+BrowserPluginHostHelper::BrowserPluginHostHelper(
+    BrowserPluginHost* browser_plugin_host,
+    RenderViewHost* render_view_host)
+    : RenderViewHostObserver(render_view_host),
+      browser_plugin_host_(browser_plugin_host) {
+}
+
+BrowserPluginHostHelper::~BrowserPluginHostHelper() {
+}
+
+bool BrowserPluginHostHelper::Send(IPC::Message* message) {
+  return RenderViewHostObserver::Send(message);
+}
+
+bool BrowserPluginHostHelper::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(BrowserPluginHostHelper, message)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_NavigateGuest,
+                        OnNavigateGuest)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_ResizeGuest, OnResizeGuest)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateRect_ACK, OnUpdateRectACK)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetFocus, OnSetFocus)
+    IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_HandleInputEvent,
+        OnHandleInputEvent(*static_cast<const IPC::SyncMessage*>(&message),
+                           &handled))
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_PluginDestroyed, OnPluginDestroyed)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  // We want to intercept certain messages if they are guests.
+  if (!browser_plugin_host_->embedder_render_process_host())
+    return handled;
+
+  handled = true;
+  IPC_BEGIN_MESSAGE_MAP(BrowserPluginHostHelper, message)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateRect, OnUpdateRect)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_HandleInputEvent_ACK,
+                        OnHandleInputEventAck)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_TakeFocus, OnTakeFocus)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_ShowWidget, OnShowWidget)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_SetCursor, OnSetCursor)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  return handled;
+}
+
+void BrowserPluginHostHelper::OnNavigateGuest(
+    int instance_id,
+    long long frame_id,
+    const std::string& src,
+    const gfx::Size& size) {
+  browser_plugin_host_->NavigateGuest(
+      render_view_host(),
+      instance_id,
+      frame_id,
+      src,
+      size);
+}
+
+void BrowserPluginHostHelper::OnResizeGuest(
+    int instance_id,
+    const BrowserPluginHostMsg_ResizeGuest_Params& params) {
+  TransportDIB* damage_buffer = NULL;
+#if defined(OS_WIN)
+  // On Windows we need to duplicate the handle from the remote process
+  HANDLE section;
+  DuplicateHandle(GetHandle(),
+                  params.damage_buffer_id.handle,
+                  GetCurrentProcess(),
+                  &section,
+                  STANDARD_RIGHTS_REQUIRED | FILE_MAP_READ | FILE_MAP_WRITE,
+                  FALSE, 0);
+  damage_buffer = TransportDIB::Map(section);
+#elif defined(OS_MACOSX)
+  // On OSX, the browser allocates all DIBs and keeps a file descriptor around
+  // for each.
+  damage_buffer = widget_helper_->MapTransportDIB(params.damage_buffer_id);
+#elif defined(OS_ANDROID)
+  damage_buffer = TransportDIB::Map(params.damage_buffer_id);
+#elif defined(OS_POSIX)
+  damage_buffer = TransportDIB::Map(params.damage_buffer_id.shmkey);
+#endif  // defined(OS_POSIX)
+  DCHECK(damage_buffer);
+  // TODO(fsamuel): Schedule this later so that we don't stall the embedder for
+  // too long.
+  browser_plugin_host_->ResizeGuest(instance_id,
+                                    damage_buffer,
+                                    params.width,
+                                    params.height,
+                                    params.resize_pending,
+                                    params.scale_factor);
+}
+
+void BrowserPluginHostHelper::OnUpdateRect(
+    const ViewHostMsg_UpdateRect_Params& params) {
+  RenderWidgetHostImpl* render_widget_host =
+      RenderWidgetHostImpl::From(render_view_host());
+  render_widget_host->ResetFlags();
+  browser_plugin_host_->UpdateRect(render_view_host(), params);
+}
+
+void BrowserPluginHostHelper::OnHandleInputEventAck(
+    WebKit::WebInputEvent::Type event_type,
+    bool processed) {
+  browser_plugin_host_->HandleInputEventAck(render_view_host(), processed);
+}
+
+void BrowserPluginHostHelper::OnTakeFocus(bool reverse) {
+  browser_plugin_host_->TakeFocus(reverse);
+}
+
+void BrowserPluginHostHelper::OnShowWidget(
+    int route_id,
+    const gfx::Rect& initial_pos) {
+  browser_plugin_host_->ShowWidget(render_view_host(), route_id, initial_pos);
+}
+
+void BrowserPluginHostHelper::OnSetCursor(const WebCursor& cursor) {
+  browser_plugin_host_->SetCursor(cursor);
+}
+
+void BrowserPluginHostHelper::OnUpdateRectACK(int instance_id,
+                                              int message_id,
+                                              const gfx::Size& size) {
+
+  BrowserPluginHost* guest = browser_plugin_host_->
+      GetGuestByInstanceID(instance_id);
+  guest->UpdateRectACK(message_id, size);
+}
+
+void BrowserPluginHostHelper::OnHandleInputEvent(
+    const IPC::SyncMessage& message,
+    bool* handled) {
+  *handled = true;
+  PickleIterator iter(message);
+
+  // TODO(fsamuel): This appears to be a monotonically increasing value.
+  int instance_id = -1;
+  const char* guest_rect_data = NULL;
+  int guest_rect_data_length = -1;
+  const char* input_event_data = NULL;
+  int input_event_data_length = -1;
+  if (!iter.SkipBytes(4) ||
+      !message.ReadInt(&iter, &instance_id) ||
+      !message.ReadData(&iter, &guest_rect_data, &guest_rect_data_length) ||
+      !message.ReadData(&iter, &input_event_data, &input_event_data_length)) {
+    *handled = false;
+    return;
+  }
+  const gfx::Rect* guest_rect =
+      reinterpret_cast<const gfx::Rect*>(guest_rect_data);
+  const WebKit::WebInputEvent* input_event =
+      reinterpret_cast<const WebKit::WebInputEvent*>(input_event_data);
+  RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
+      render_view_host());
+
+  // Convert the window coordinates into screen coordinates.
+  gfx::Rect guest_screen_rect(*guest_rect);
+  if (rvh->GetView())
+    guest_screen_rect.Offset(
+        rvh->GetView()->GetViewBounds().origin());
+
+  IPC::Message* reply_message =
+      IPC::SyncMessage::GenerateReply(&message);
+  BrowserPluginHost* guest = browser_plugin_host_->
+      GetGuestByInstanceID(instance_id);
+  guest->HandleInputEvent(rvh,
+                          guest_screen_rect,
+                          *input_event,
+                          reply_message);
+}
+
+void BrowserPluginHostHelper::OnSetFocus(int instance_id,
+                                         bool focused) {
+  BrowserPluginHost* guest = browser_plugin_host_->
+      GetGuestByInstanceID(instance_id);
+  if (guest)
+    guest->SetFocus(focused);
+}
+
+void BrowserPluginHostHelper::OnPluginDestroyed(int instance_id) {
+  browser_plugin_host_->DestroyGuestByInstanceID(instance_id);
+}
+
+}  // namespace content