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

Unified Diff: content/browser/browser_plugin/browser_plugin_guest.cc

Issue 10868012: Browser Plugin: New Implementation (Browser Side) (Closed) Base URL: http://git.chromium.org/chromium/src.git@master-trial-obrowser
Patch Set: Disable BrowserPluginHostTest.NavigateGuest on win, flaking. Created 8 years, 3 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
Index: content/browser/browser_plugin/browser_plugin_guest.cc
diff --git a/content/browser/browser_plugin/browser_plugin_guest.cc b/content/browser/browser_plugin/browser_plugin_guest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..374deec1ecc28b5ac3ede27f9ac94a7a8ef00eda
--- /dev/null
+++ b/content/browser/browser_plugin/browser_plugin_guest.cc
@@ -0,0 +1,280 @@
+// 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_guest.h"
+
+#include <algorithm>
+
+#include "content/browser/browser_plugin/browser_plugin_guest_helper.h"
+#include "content/browser/browser_plugin/browser_plugin_host_factory.h"
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/web_contents/web_contents_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_widget_host_view.h"
+#include "content/public/common/result_codes.h"
+#include "content/browser/browser_plugin/browser_plugin_host_factory.h"
+#include "ui/surface/transport_dib.h"
+
+namespace content {
+
+// static
+BrowserPluginHostFactory* BrowserPluginGuest::factory_ = NULL;
+
+namespace {
+const int kGuestHangTimeoutMs = 5000;
+}
+
+BrowserPluginGuest::BrowserPluginGuest(int instance_id,
+ WebContentsImpl* web_contents,
+ RenderViewHost* render_view_host)
+ : WebContentsObserver(web_contents),
+ embedder_render_process_host_(NULL),
+ instance_id_(instance_id),
+#if defined(OS_WIN)
+ damage_buffer_size_(0),
+#endif
+ pending_update_counter_(0),
+ guest_hang_timeout_(
+ base::TimeDelta::FromMilliseconds(kGuestHangTimeoutMs)) {
+ DCHECK(web_contents);
+ // |render_view_host| manages the ownership of this BrowserPluginGuestHelper.
+ new BrowserPluginGuestHelper(this, render_view_host);
+}
+
+BrowserPluginGuest::~BrowserPluginGuest() {
+}
+
+// static
+BrowserPluginGuest* BrowserPluginGuest::Create(
+ int instance_id,
+ WebContentsImpl* web_contents,
+ content::RenderViewHost* render_view_host) {
+ if (factory_) {
+ return factory_->CreateBrowserPluginGuest(instance_id,
+ web_contents,
+ render_view_host);
+ }
+ return new BrowserPluginGuest(instance_id, web_contents, render_view_host);
+}
+
+bool BrowserPluginGuest::ViewTakeFocus(bool reverse) {
+ SendMessageToEmbedder(
+ new BrowserPluginMsg_AdvanceFocus(instance_id(), reverse));
+ return true;
+}
+
+void BrowserPluginGuest::RendererUnresponsive(WebContents* source) {
+ base::ProcessHandle process_handle =
+ web_contents()->GetRenderProcessHost()->GetHandle();
+ base::KillProcess(process_handle, RESULT_CODE_HUNG, false);
+}
+
+void BrowserPluginGuest::SetDamageBuffer(
+ TransportDIB* damage_buffer,
+#if defined(OS_WIN)
+ int damage_buffer_size,
+#endif
+ const gfx::Size& damage_view_size,
+ float scale_factor) {
+ // Sanity check: Verify that we've correctly shared the damage buffer memory
+ // between the embedder and browser processes.
+ DCHECK(*static_cast<unsigned int*>(damage_buffer->memory()) == 0xdeadbeef);
+ damage_buffer_.reset(damage_buffer);
+#if defined(OS_WIN)
+ damage_buffer_size_ = damage_buffer_size;
+#endif
+ damage_view_size_ = damage_view_size;
+ damage_buffer_scale_factor_ = scale_factor;
+}
+
+void BrowserPluginGuest::UpdateRect(
+ RenderViewHost* render_view_host,
+ const ViewHostMsg_UpdateRect_Params& params) {
+ RenderWidgetHostImpl* render_widget_host =
+ RenderWidgetHostImpl::From(render_view_host);
+ render_widget_host->ResetSizeAndRepaintPendingFlags();
+ // This handler is only of interest to us for the 2D software rendering path.
+ // needs_ack should always be true for the 2D path.
+ // TODO(fsamuel): Do we need to do something different in the 3D case?
+ if (!params.needs_ack)
+ return;
+
+ // Only copy damage if the guest's view size is equal to the damage buffer's
+ // size and the guest's scale factor is equal to the damage buffer's scale
+ // factor.
+ // The scaling change can happen due to asynchronous updates of the DPI on a
+ // resolution change.
+ if (params.view_size.width() == damage_view_size().width() &&
+ params.view_size.height() == damage_view_size().height() &&
+ params.scale_factor == damage_buffer_scale_factor()) {
+ TransportDIB* dib = render_view_host->GetProcess()->
+ GetTransportDIB(params.bitmap);
+ if (dib) {
+#if defined(OS_WIN)
+ size_t guest_damage_buffer_size = params.bitmap_rect.width() *
+ params.bitmap_rect.height() * 4;
+ size_t embedder_damage_buffer_size = damage_buffer_size_;
+#else
+ size_t guest_damage_buffer_size = dib->size();
+ size_t embedder_damage_buffer_size = damage_buffer_->size();
+#endif
+ void* guest_memory = dib->memory();
+ void* embedder_memory = damage_buffer_->memory();
+ size_t size = std::min(guest_damage_buffer_size,
+ embedder_damage_buffer_size);
+ memcpy(embedder_memory, guest_memory, size);
+ }
+ }
+ DCHECK(embedder_render_process_host());
+ BrowserPluginMsg_UpdateRect_Params relay_params;
+ relay_params.bitmap_rect = params.bitmap_rect;
+ relay_params.dx = params.dx;
+ relay_params.dy = params.dy;
+ relay_params.scroll_rect = params.scroll_rect;
+ relay_params.copy_rects = params.copy_rects;
+ relay_params.view_size = params.view_size;
+ relay_params.scale_factor = params.scale_factor;
+ relay_params.is_resize_ack = ViewHostMsg_UpdateRect_Flags::is_resize_ack(
+ params.flags);
+
+ // We need to send the ACK to the same render_view_host that issued
+ // the UpdateRect. We keep track of this correspondence via a message_id.
+ int message_id = pending_update_counter_++;
+ pending_updates_.AddWithID(render_view_host, message_id);
+
+ gfx::Size param_size = gfx::Size(params.view_size.width(),
+ params.view_size.height());
+
+ SendMessageToEmbedder(new BrowserPluginMsg_UpdateRect(instance_id(),
+ message_id,
+ relay_params));
+}
+
+void BrowserPluginGuest::UpdateRectACK(int message_id, const gfx::Size& size) {
+ RenderViewHost* render_view_host = pending_updates_.Lookup(message_id);
+ // If the guest has crashed since it sent the initial ViewHostMsg_UpdateRect
+ // then the pending_updates_ map will have been cleared.
+ if (!render_view_host)
+ return;
+ pending_updates_.Remove(message_id);
+ render_view_host->Send(
+ new ViewMsg_UpdateRect_ACK(render_view_host->GetRoutingID()));
+ if (!size.IsEmpty())
+ render_view_host->GetView()->SetSize(size);
+}
+
+void BrowserPluginGuest::HandleInputEvent(RenderViewHost* render_view_host,
+ const gfx::Rect& guest_rect,
+ const WebKit::WebInputEvent& event,
+ IPC::Message* reply_message) {
+ DCHECK(!pending_input_event_reply_.get());
+ guest_rect_ = guest_rect;
+ RenderViewHostImpl* guest_rvh = static_cast<RenderViewHostImpl*>(
+ web_contents()->GetRenderViewHost());
+ IPC::Message* message = new ViewMsg_HandleInputEvent(
+ guest_rvh->GetRoutingID());
+
+ // Copy the WebInputEvent and modify the event type. The guest expects
+ // WebInputEvent::RawKeyDowns and not KeyDowns.
+ scoped_array<char> input_buffer(new char[event.size]);
+ memcpy(input_buffer.get(), &event, event.size);
+ WebKit::WebInputEvent* input_event =
+ reinterpret_cast<WebKit::WebInputEvent*>(input_buffer.get());
+ if (event.type == WebKit::WebInputEvent::KeyDown)
+ input_event->type = WebKit::WebInputEvent::RawKeyDown;
+
+ message->WriteData(input_buffer.get(), event.size);
+ // TODO(fsamuel): What do we need to do here? This is for keyboard shortcuts.
+ if (input_event->type == WebKit::WebInputEvent::RawKeyDown)
+ message->WriteBool(false);
+ bool sent = guest_rvh->Send(message);
+ if (!sent) {
+ // If the embedder is waiting for a previous input ack, a new input message
+ // won't get sent to the guest. Reply immediately with handled = false so
+ // embedder doesn't hang.
+ BrowserPluginHostMsg_HandleInputEvent::WriteReplyParams(
+ reply_message, false /* handled */, cursor_);
+ embedder_render_process_host()->Send(reply_message);
+ return;
+ }
+
+ pending_input_event_reply_.reset(reply_message);
+ // Input events are handled synchronously, meaning it blocks the embedder. We
+ // set a hang monitor here that will kill the guest process (5s timeout) if we
+ // don't receive an ack. This will kill all the guests that are running in the
+ // same process (undesired behavior).
+ // TODO(fsamuel,lazyboy): Find a way to get rid of guest process kill
+ // behavior. http://crbug.com/147272.
+ guest_rvh->StartHangMonitorTimeout(guest_hang_timeout_);
+}
+
+void BrowserPluginGuest::HandleInputEventAck(RenderViewHost* render_view_host,
+ bool handled) {
+ RenderViewHostImpl* guest_rvh =
+ static_cast<RenderViewHostImpl*>(render_view_host);
+ guest_rvh->StopHangMonitorTimeout();
+ DCHECK(pending_input_event_reply_.get());
+ IPC::Message* reply_message = pending_input_event_reply_.release();
+ BrowserPluginHostMsg_HandleInputEvent::WriteReplyParams(reply_message,
+ handled,
+ cursor_);
+ SendMessageToEmbedder(reply_message);
+}
+
+void BrowserPluginGuest::SetFocus(bool focused) {
+ RenderViewHost* render_view_host = web_contents()->GetRenderViewHost();
+ render_view_host->Send(
+ new ViewMsg_SetFocus(render_view_host->GetRoutingID(), focused));
+}
+
+void BrowserPluginGuest::ShowWidget(RenderViewHost* render_view_host,
+ int route_id,
+ const gfx::Rect& initial_pos) {
+ gfx::Rect screen_pos(initial_pos);
+ screen_pos.Offset(guest_rect_.origin());
+ static_cast<WebContentsImpl*>(web_contents())->ShowCreatedWidget(route_id,
+ screen_pos);
+}
+
+void BrowserPluginGuest::SetCursor(const WebCursor& cursor) {
+ cursor_ = cursor;
+}
+
+void BrowserPluginGuest::DidCommitProvisionalLoadForFrame(
+ int64 frame_id,
+ bool is_main_frame,
+ const GURL& url,
+ PageTransition transition_type,
+ RenderViewHost* render_view_host) {
+ // Inform its embedder of the updated URL.
+ DCHECK(embedder_render_process_host());
+ if (is_main_frame)
+ SendMessageToEmbedder(new BrowserPluginMsg_DidNavigate(instance_id(), url));
+}
+
+void BrowserPluginGuest::RenderViewGone(base::TerminationStatus status) {
+ DCHECK(embedder_render_process_host());
+ if (pending_input_event_reply_.get()) {
+ IPC::Message* reply_message = pending_input_event_reply_.release();
+ BrowserPluginHostMsg_HandleInputEvent::WriteReplyParams(reply_message,
+ false,
+ cursor_);
+ SendMessageToEmbedder(reply_message);
+ }
+ SendMessageToEmbedder(new BrowserPluginMsg_GuestCrashed(instance_id()));
+ IDMap<RenderViewHost>::const_iterator iter(&pending_updates_);
+ while (!iter.IsAtEnd()) {
+ pending_updates_.Remove(iter.GetCurrentKey());
+ iter.Advance();
+ }
+}
+
+void BrowserPluginGuest::SendMessageToEmbedder(IPC::Message* msg) {
+ embedder_render_process_host()->Send(msg);
+}
+
+} // namespace content
« no previous file with comments | « content/browser/browser_plugin/browser_plugin_guest.h ('k') | content/browser/browser_plugin/browser_plugin_guest_helper.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698