Framelet Prototype 2016 using Mojo IPC

content/browser/browser_plugin/browser_plugin_guest.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_guest.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 72 matching lines @@
                                        WebContentsImpl* web_contents,
                                        BrowserPluginGuestDelegate* delegate)
     : WebContentsObserver(web_contents),
       owner_web_contents_(nullptr),
       attached_(false),
       has_attached_since_surface_set_(false),
       browser_plugin_instance_id_(browser_plugin::kInstanceIDNone),
       focused_(false),
       mouse_locked_(false),
       pending_lock_request_(false),
-      guest_visible_(false),
+      container_visible_(false),
       embedder_visible_(true),
       is_full_page_plugin_(false),
       has_render_view_(has_render_view),
       is_in_destruction_(false),
       initialized_(false),
       guest_proxy_routing_id_(MSG_ROUTING_NONE),
       last_drag_status_(blink::WebDragStatusUnknown),
       seen_embedder_system_drag_ended_(false),
       seen_embedder_drag_source_ended_at_(false),
       delegate_(delegate),
@@ skipping 34 matching lines @@
         owner_site_instance->GetProcess()->GetID(), proxy_routing_id)
             ->GetRenderViewHost()->GetRoutingID();
   } else {
     guest_proxy_routing_id_ =
         GetWebContents()->CreateSwappedOutRenderView(owner_site_instance);
   }
 
   return guest_proxy_routing_id_;
 }
 
+void BrowserPluginGuest::Attach(int element_instance_id,
+                                WebContents* embedder_web_contents,
+                                const GuestAttachParams& attach_params) {
+  browser_plugin_instance_id_ = element_instance_id;
+  // If a guest is detaching from one container and attaching to another
+  // container, then late arriving ACKs may be lost if the mapping from
+  // |browser_plugin_instance_id| to |guest_instance_id| changes. Thus we
+  // ensure that we always get new frames on attachment by ACKing the pending
+  // frame if it's still waiting on the ACK.
+  if (last_pending_frame_) {
+    cc::CompositorFrameAck ack;
+    RenderWidgetHostImpl::SendSwapCompositorFrameAck(
+        last_pending_frame_->producing_route_id,
+        last_pending_frame_->output_surface_id,
+        last_pending_frame_->producing_host_id, ack);
+    last_pending_frame_.reset();
+  }
+
+  // The guest is owned by the embedder. Attach is queued up so we cannot
+  // change embedders before attach completes. If the embedder goes away,
+  // so does the guest and so we will never call WillAttachComplete because
+  // we have a weak ptr.
+  delegate_->WillAttach(
+      embedder_web_contents, element_instance_id, attach_params.is_full_page,
+      base::Bind(&BrowserPluginGuest::OnWillAttachComplete,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 static_cast<WebContentsImpl*>(embedder_web_contents),
+                 attach_params));
+}
+
 int BrowserPluginGuest::LoadURLWithParams(
     const NavigationController::LoadURLParams& load_params) {
   GetWebContents()->GetController().LoadURLWithParams(load_params);
   return GetGuestProxyRoutingID();
 }
 
 void BrowserPluginGuest::GuestResizeDueToAutoResize(const gfx::Size& new_size) {
   if (last_seen_view_size_ != new_size) {
     delegate_->GuestSizeChanged(new_size);
     last_seen_view_size_ = new_size;
   }
 }
 
+void BrowserPluginGuest::SetContainerVisible(bool visible) {
+  container_visible_ = visible;
+  UpdateVisibility();
+}
+
+void BrowserPluginGuest::SetFocus(bool focused,
+                                  blink::WebFocusType focus_type) {
+  RenderWidgetHostView* rwhv = web_contents()->GetRenderWidgetHostView();
+  RenderWidgetHost* rwh = rwhv ? rwhv->GetRenderWidgetHost() : nullptr;
+  SetFocusForRenderWidgetHost(rwh, focused, focus_type);
+}
+
 void BrowserPluginGuest::SizeContents(const gfx::Size& new_size) {
   GetWebContents()->GetView()->SizeContents(new_size);
 }
 
+void BrowserPluginGuest::ForwardInputEvent(const blink::WebInputEvent* event) {
+  RenderWidgetHostImpl* embedder_host =
+      embedder_web_contents()->GetMainFrame()->GetRenderWidgetHost();
+  RenderWidgetHostView* rwhv = web_contents()->GetRenderWidgetHostView();
+  RenderWidgetHostImpl* host = static_cast<RenderWidgetHostImpl*>(
+      rwhv ? rwhv->GetRenderWidgetHost() : nullptr);
+  if (!host)
+    return;
+
+  if (blink::WebInputEvent::isMouseEventType(event->type)) {
+    host->ForwardMouseEvent(*static_cast<const blink::WebMouseEvent*>(event));
+  } else if (event->type == blink::WebInputEvent::MouseWheel) {
+    host->ForwardWheelEvent(
+        *static_cast<const blink::WebMouseWheelEvent*>(event));
+  } else if (blink::WebInputEvent::isGestureEventType(event->type)) {
+    host->ForwardGestureEvent(
+        *static_cast<const blink::WebGestureEvent*>(event));
+  } else if (blink::WebInputEvent::isKeyboardEventType(event->type)) {
+    if (!embedder_host->GetLastKeyboardEvent())
+      return;
+    NativeWebKeyboardEvent keyboard_event(
+        *embedder_host->GetLastKeyboardEvent());
+    host->ForwardKeyboardEvent(keyboard_event);
+  } else if (blink::WebInputEvent::isTouchEventType(event->type)) {
+    if (event->type == blink::WebInputEvent::TouchStart &&
+        !embedder_host->GetView()->HasFocus()) {
+      embedder_host->GetView()->Focus();
+    }
+    host->ForwardTouchEventWithLatencyInfo(
+        *static_cast<const blink::WebTouchEvent*>(event), ui::LatencyInfo());
+  }
+}
+
 void BrowserPluginGuest::WillDestroy() {
   is_in_destruction_ = true;
   owner_web_contents_ = nullptr;
   attached_ = false;
 }
 
 void BrowserPluginGuest::Init() {
   if (initialized_)
     return;
   initialized_ = true;
 
   // TODO(fsamuel): Initiailization prior to attachment should be behind a
   // command line flag once we introduce experimental guest types that rely on
   // this functionality.
   if (!delegate_->CanRunInDetachedState())
     return;
 
   WebContentsImpl* owner_web_contents = static_cast<WebContentsImpl*>(
       delegate_->GetOwnerWebContents());
   owner_web_contents->CreateBrowserPluginEmbedderIfNecessary();
-  InitInternal(BrowserPluginHostMsg_Attach_Params(), owner_web_contents);
+  InitInternal(GuestAttachParams(), owner_web_contents);
 }
 
 base::WeakPtr<BrowserPluginGuest> BrowserPluginGuest::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-void BrowserPluginGuest::SetFocus(RenderWidgetHost* rwh,
-                                  bool focused,
-                                  blink::WebFocusType focus_type) {
+void BrowserPluginGuest::SetFocusForRenderWidgetHost(
+    RenderWidgetHost* rwh,
+    bool focused,
+    blink::WebFocusType focus_type) {
   focused_ = focused;
   if (!rwh)
     return;
 
   if ((focus_type == blink::WebFocusTypeForward) ||
       (focus_type == blink::WebFocusTypeBackward)) {
     static_cast<RenderViewHostImpl*>(RenderViewHost::From(rwh))->
         SetInitialFocus(focus_type == blink::WebFocusTypeBackward);
   }
   rwh->Send(new InputMsg_SetFocus(rwh->GetRoutingID(), focused));
@@ skipping 67 matching lines @@
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetVisibility, OnSetVisibility)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UnlockMouse_ACK, OnUnlockMouseAck)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateGeometry, OnUpdateGeometry)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SatisfySequence, OnSatisfySequence)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_RequireSequence, OnRequireSequence)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void BrowserPluginGuest::InitInternal(
-    const BrowserPluginHostMsg_Attach_Params& params,
-    WebContentsImpl* owner_web_contents) {
-  focused_ = params.focused;
-  OnSetFocus(browser_plugin::kInstanceIDNone,
-             focused_,
-             blink::WebFocusTypeNone);
+void BrowserPluginGuest::InitInternal(const GuestAttachParams& params,
+                                      WebContentsImpl* owner_web_contents) {
+  SetContainerVisible(params.visible);
+  SetFocus(params.focused, blink::WebFocusTypeNone);
 
-  guest_visible_ = params.visible;
-  UpdateVisibility();
-
-  is_full_page_plugin_ = params.is_full_page_plugin;
+  is_full_page_plugin_ = params.is_full_page;
   guest_window_rect_ = params.view_rect;
 
   if (owner_web_contents_ != owner_web_contents) {
     WebContentsViewGuest* new_view = nullptr;
     if (!BrowserPluginGuestMode::UseCrossProcessFramesForGuests()) {
       new_view =
           static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
     }
 
     if (owner_web_contents_ && new_view)
@@ skipping 35 matching lines @@
   // Initialize the device scale factor by calling |NotifyScreenInfoChanged|.
   auto render_widget_host = RenderWidgetHostImpl::From(
       GetWebContents()->GetRenderViewHost()->GetWidget());
   render_widget_host->NotifyScreenInfoChanged();
 
   // TODO(chrishtr): this code is wrong. The navigate_on_drag_drop field will
   // be reset again the next time preferences are updated.
   WebPreferences prefs =
       GetWebContents()->GetRenderViewHost()->GetWebkitPreferences();
   prefs.navigate_on_drag_drop = false;
+  prefs.viewport_enabled = false;
+  prefs.viewport_meta_enabled = false;
   GetWebContents()->GetRenderViewHost()->UpdateWebkitPreferences(prefs);
 }
 
 BrowserPluginGuest::~BrowserPluginGuest() {
 }
 
 // static
 BrowserPluginGuest* BrowserPluginGuest::Create(
     WebContentsImpl* web_contents,
     BrowserPluginGuestDelegate* delegate) {
@@ skipping 13 matching lines @@
           render_view_host)));
 }
 
 RenderWidgetHostView* BrowserPluginGuest::GetOwnerRenderWidgetHostView() {
   if (!owner_web_contents_)
     return nullptr;
   return owner_web_contents_->GetRenderWidgetHostView();
 }
 
 void BrowserPluginGuest::UpdateVisibility() {
-  OnSetVisibility(browser_plugin_instance_id(), visible());
+  if (embedder_visible_ && container_visible_)
+    GetWebContents()->WasShown();
+  else
+    GetWebContents()->WasHidden();
 }
 
 BrowserPluginGuestManager*
 BrowserPluginGuest::GetBrowserPluginGuestManager() const {
   return GetWebContents()->GetBrowserContext()->GetGuestManager();
 }
 
 void BrowserPluginGuest::EmbedderVisibilityChanged(bool visible) {
   embedder_visible_ = visible;
   UpdateVisibility();
@@ skipping 21 matching lines @@
       new BrowserPluginMsg_CompositorFrameSwapped(
           browser_plugin_instance_id(), *last_pending_frame_));
 }
 
 void BrowserPluginGuest::SetChildFrameSurface(
     const cc::SurfaceId& surface_id,
     const gfx::Size& frame_size,
     float scale_factor,
     const cc::SurfaceSequence& sequence) {
   has_attached_since_surface_set_ = false;
+  if (delegate_->SetChildFrameSurface(surface_id, frame_size, scale_factor,
+                                      sequence)) {
+    return;
+  }
   SendMessageToEmbedder(new BrowserPluginMsg_SetChildFrameSurface(
       browser_plugin_instance_id(), surface_id, frame_size, scale_factor,
       sequence));
 }
 
 void BrowserPluginGuest::OnSatisfySequence(
     int instance_id,
     const cc::SurfaceSequence& sequence) {
   std::vector<uint32_t> sequences;
   sequences.push_back(sequence.sequence);
@@ skipping 256 matching lines @@
 
 bool BrowserPluginGuest::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   // In --site-per-process, we do not need most of BrowserPluginGuest to drive
   // inner WebContents.
   // Right now InputHostMsg_ImeCompositionRangeChanged hits NOTREACHED() in
   // RWHVChildFrame, so we're disabling message handling entirely here.
   // TODO(lazyboy): Fix this as part of http://crbug.com/330264. The required
   // parts of code from this class should be extracted to a separate class for
   // --site-per-process.
-  if (BrowserPluginGuestMode::UseCrossProcessFramesForGuests()) {
+  if (BrowserPluginGuestMode::UseCrossProcessFramesForGuests())
     return false;
-  }
 
   IPC_BEGIN_MESSAGE_MAP(BrowserPluginGuest, message)
     IPC_MESSAGE_HANDLER(InputHostMsg_ImeCancelComposition,
                         OnImeCancelComposition)
 #if defined(OS_MACOSX) || defined(USE_AURA)
     IPC_MESSAGE_HANDLER(InputHostMsg_ImeCompositionRangeChanged,
                         OnImeCompositionRangeChanged)
 #endif
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
@@ skipping 31 matching lines @@
   return handled;
 #else
   return false;
 #endif
 }
 
 void BrowserPluginGuest::Attach(
     int browser_plugin_instance_id,
     WebContentsImpl* embedder_web_contents,
     const BrowserPluginHostMsg_Attach_Params& params) {
-  browser_plugin_instance_id_ = browser_plugin_instance_id;
-  // If a guest is detaching from one container and attaching to another
-  // container, then late arriving ACKs may be lost if the mapping from
-  // |browser_plugin_instance_id| to |guest_instance_id| changes. Thus we
-  // ensure that we always get new frames on attachment by ACKing the pending
-  // frame if it's still waiting on the ACK.
-  if (last_pending_frame_) {
-    cc::CompositorFrameAck ack;
-    RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-        last_pending_frame_->producing_route_id,
-        last_pending_frame_->output_surface_id,
-        last_pending_frame_->producing_host_id,
-        ack);
-    last_pending_frame_.reset();
-  }
-
-  // The guest is owned by the embedder. Attach is queued up so we cannot
-  // change embedders before attach completes. If the embedder goes away,
-  // so does the guest and so we will never call WillAttachComplete because
-  // we have a weak ptr.
-  delegate_->WillAttach(embedder_web_contents, browser_plugin_instance_id,
-                        params.is_full_page_plugin,
-                        base::Bind(&BrowserPluginGuest::OnWillAttachComplete,
-                                   weak_ptr_factory_.GetWeakPtr(),
-                                   embedder_web_contents, params));
+  GuestAttachParams attach_params;
+  attach_params.focused = params.focused;
+  attach_params.visible = params.visible;
+  attach_params.view_rect = params.view_rect;
+  attach_params.is_full_page = params.is_full_page_plugin;
+  Attach(browser_plugin_instance_id, embedder_web_contents, attach_params);
 }
 
 void BrowserPluginGuest::OnWillAttachComplete(
     WebContentsImpl* embedder_web_contents,
-    const BrowserPluginHostMsg_Attach_Params& params) {
+    const GuestAttachParams& params) {
   bool use_cross_process_frames =
       BrowserPluginGuestMode::UseCrossProcessFramesForGuests();
   // If a RenderView has already been created for this new window, then we need
   // to initialize the browser-side state now so that the RenderFrameHostManager
   // does not create a new RenderView on navigation.
   if (!use_cross_process_frames && has_render_view_) {
     // This will trigger a callback to RenderViewReady after a round-trip IPC.
     static_cast<RenderViewHostImpl*>(GetWebContents()->GetRenderViewHost())
         ->GetWidget()
         ->Init();
@@ skipping 158 matching lines @@
                                         bool succeeded) {
   Send(new ViewMsg_LockMouse_ACK(routing_id(), succeeded));
   pending_lock_request_ = false;
   if (succeeded)
     mouse_locked_ = true;
 }
 
 void BrowserPluginGuest::OnSetFocus(int browser_plugin_instance_id,
                                     bool focused,
                                     blink::WebFocusType focus_type) {
-  RenderWidgetHostView* rwhv = web_contents()->GetRenderWidgetHostView();
-  RenderWidgetHost* rwh = rwhv ? rwhv->GetRenderWidgetHost() : nullptr;
-  SetFocus(rwh, focused, focus_type);
+  SetFocus(focused, focus_type);
 }
 
 void BrowserPluginGuest::OnSetEditCommandsForNextKeyEvent(
     int browser_plugin_instance_id,
     const std::vector<EditCommand>& edit_commands) {
   Send(new InputMsg_SetEditCommandsForNextKeyEvent(routing_id(),
                                                    edit_commands));
 }
 
 void BrowserPluginGuest::OnSetVisibility(int browser_plugin_instance_id,
                                          bool visible) {
-  guest_visible_ = visible;
-  if (embedder_visible_ && guest_visible_)
-    GetWebContents()->WasShown();
-  else
-    GetWebContents()->WasHidden();
+  SetContainerVisible(visible);
 }
 
 void BrowserPluginGuest::OnUnlockMouse() {
   SendMessageToEmbedder(
       new BrowserPluginMsg_SetMouseLock(browser_plugin_instance_id(), false));
 }
 
 void BrowserPluginGuest::OnUnlockMouseAck(int browser_plugin_instance_id) {
   // mouse_locked_ could be false here if the lock attempt was cancelled due
   // to window focus, or for various other reasons before the guest was informed
@@ skipping 72 matching lines @@
           range, character_bounds);
 }
 #endif
 
 void BrowserPluginGuest::SetContextMenuPosition(const gfx::Point& position) {
   if (delegate_)
     delegate_->SetContextMenuPosition(position);
 }
 
 }  // namespace content