Initialize BrowserPluginGuest to attach to the View hierarchy

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 <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
@@ skipping 54 matching lines @@
  private:
   BrowserPluginGuest* browser_plugin_guest_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedderVisibilityObserver);
 };
 
 BrowserPluginGuest::BrowserPluginGuest(bool has_render_view,
                                        WebContentsImpl* web_contents,
                                        BrowserPluginGuestDelegate* delegate)
     : WebContentsObserver(web_contents),
-      owner_web_contents_(NULL),
+      owner_web_contents_(nullptr),
       attached_(false),
       browser_plugin_instance_id_(browser_plugin::kInstanceIDNone),
       guest_device_scale_factor_(1.0f),
       focused_(false),
       mouse_locked_(false),
       pending_lock_request_(false),
       guest_visible_(false),
       embedder_visible_(true),
       is_full_page_plugin_(false),
       has_render_view_(has_render_view),
       is_in_destruction_(false),
+      initialized_(false),
       last_text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       last_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       last_input_flags_(0),
       last_can_compose_inline_(true),
       guest_proxy_routing_id_(MSG_ROUTING_NONE),
       delegate_(delegate),
       weak_ptr_factory_(this) {
   DCHECK(web_contents);
   DCHECK(delegate);
   RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Create"));
   web_contents->SetBrowserPluginGuest(this);
   delegate->RegisterDestructionCallback(
       base::Bind(&BrowserPluginGuest::WillDestroy, AsWeakPtr()));
 }
 
+void BrowserPluginGuest::Init() {
+  if (initialized_)
+    return;
+  initialized_ = true;
+
+  // TODO(fsamuel): This 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());
+  InitInternal(BrowserPluginHostMsg_Attach_Params(), owner_web_contents);
+}
+
 void BrowserPluginGuest::WillDestroy() {
   is_in_destruction_ = true;
   owner_web_contents_ = NULL;
   attached_ = false;
 }
 
 base::WeakPtr<BrowserPluginGuest> BrowserPluginGuest::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
@@ skipping 74 matching lines @@
                         OnSetEditCommandsForNextKeyEvent)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetVisibility, OnSetVisibility)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UnlockMouse_ACK, OnUnlockMouseAck)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateGeometry, OnUpdateGeometry)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void BrowserPluginGuest::Initialize(
-    int browser_plugin_instance_id,
+void BrowserPluginGuest::InitInternal(
     const BrowserPluginHostMsg_Attach_Params& params,
-    WebContentsImpl* embedder_web_contents) {
-  browser_plugin_instance_id_ = browser_plugin_instance_id;
+    WebContentsImpl* owner_web_contents) {
   focused_ = params.focused;
+  OnSetFocus(0, focused_);

[lazyboy, 2014/12/04 20:58:45]

s/0/browser_plugin::kInstanceIDNone

+
   guest_visible_ = params.visible;
+  UpdateVisibility();
+
   is_full_page_plugin_ = params.is_full_page_plugin;
   guest_window_rect_ = gfx::Rect(params.origin,
                                  params.resize_guest_params.view_size);
 
-  WebContentsViewGuest* new_view =
-      static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
-  if (attached())
-    new_view->OnGuestDetached(owner_web_contents_->GetView());
+  if (owner_web_contents_ != owner_web_contents) {
+    WebContentsViewGuest* new_view =
+        static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
+    if (owner_web_contents_)
+      new_view->OnGuestDetached(owner_web_contents_->GetView());
 
-  // Once a BrowserPluginGuest has an embedder WebContents, it's considered to
-  // be attached.
-  owner_web_contents_ = embedder_web_contents;
-  new_view->OnGuestAttached(owner_web_contents_->GetView());
+    // Once a BrowserPluginGuest has an embedder WebContents, it's considered to
+    // be attached.
+    owner_web_contents_ = owner_web_contents;
+    new_view->OnGuestAttached(owner_web_contents_->GetView());
+  }
 
   RendererPreferences* renderer_prefs =
       GetWebContents()->GetMutableRendererPrefs();
   std::string guest_user_agent_override = renderer_prefs->user_agent_override;
   // Copy renderer preferences (and nothing else) from the embedder's
   // WebContents to the guest.
   //
   // For GTK and Aura this is necessary to get proper renderer configuration
   // values for caret blinking interval, colors related to selection and
   // focus.
   *renderer_prefs = *owner_web_contents_->GetMutableRendererPrefs();
   renderer_prefs->user_agent_override = guest_user_agent_override;
 
   // We would like the guest to report changes to frame names so that we can
   // update the BrowserPlugin's corresponding 'name' attribute.
   // TODO(fsamuel): Remove this once http://crbug.com/169110 is addressed.
   renderer_prefs->report_frame_name_changes = true;
   // Navigation is disabled in Chrome Apps. We want to make sure guest-initiated
   // navigations still continue to function inside the app.
   renderer_prefs->browser_handles_all_top_level_requests = false;
   // Disable "client blocked" error page for browser plugin.
   renderer_prefs->disable_client_blocked_error_page = true;
 
   embedder_visibility_observer_.reset(new EmbedderVisibilityObserver(this));
 
-  OnResizeGuest(browser_plugin_instance_id_, params.resize_guest_params);
+  // The instance ID does not matter here.
+  OnResizeGuest(browser_plugin::kInstanceIDNone, params.resize_guest_params);
 
   // 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;
   GetWebContents()->GetRenderViewHost()->UpdateWebkitPreferences(prefs);
 
   // Enable input method for guest if it's enabled for the embedder.
   if (static_cast<RenderViewHostImpl*>(
@@ skipping 61 matching lines @@
       frame->delegated_frame_data->render_pass_list.back();
   gfx::Size view_size(gfx::ToFlooredSize(gfx::ScaleSize(
       root_pass->output_rect.size(),
       1.0f / frame->metadata.device_scale_factor)));
 
   if (last_seen_view_size_ != view_size) {
     delegate_->GuestSizeChanged(last_seen_view_size_, view_size);
     last_seen_view_size_ = view_size;
   }
 
-  FrameMsg_CompositorFrameSwapped_Params guest_params;
-  frame->AssignTo(&guest_params.frame);
-  guest_params.output_surface_id = output_surface_id;
-  guest_params.producing_route_id = host_routing_id;
-  guest_params.producing_host_id = host_process_id;
+  pending_frame_.reset(new FrameMsg_CompositorFrameSwapped_Params());
+  frame->AssignTo(&pending_frame_->frame);
+  pending_frame_->output_surface_id = output_surface_id;
+  pending_frame_->producing_route_id = host_routing_id;
+  pending_frame_->producing_host_id = host_process_id;
+
   SendMessageToEmbedder(
       new BrowserPluginMsg_CompositorFrameSwapped(
-          browser_plugin_instance_id(), guest_params));
+          browser_plugin_instance_id(), *pending_frame_));
 }
 
 void BrowserPluginGuest::SetContentsOpaque(bool opaque) {
   SendMessageToEmbedder(
       new BrowserPluginMsg_SetContentsOpaque(
           browser_plugin_instance_id(), opaque));
 }
 
 bool BrowserPluginGuest::Find(int request_id,
                               const base::string16& search_text,
@@ skipping 165 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 in the process of 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 (pending_frame_) {
+    cc::CompositorFrameAck ack;
+    RenderWidgetHostImpl::SendSwapCompositorFrameAck(
+        pending_frame_->producing_route_id,
+        pending_frame_->output_surface_id,
+        pending_frame_->producing_host_id,
+        ack);
+    pending_frame_.reset();
+  }
   delegate_->WillAttach(embedder_web_contents, browser_plugin_instance_id,
                         params.is_full_page_plugin);
 
   // 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 (has_render_view_) {
     // This will trigger a callback to RenderViewReady after a round-trip IPC.
     static_cast<RenderViewHostImpl*>(
         GetWebContents()->GetRenderViewHost())->Init();
     WebContentsViewGuest* web_contents_view =
         static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
     if (!web_contents()->GetRenderViewHost()->GetView()) {
       web_contents_view->CreateViewForWidget(
           web_contents()->GetRenderViewHost(), true);
     }
   }
 
-  Initialize(browser_plugin_instance_id, params, embedder_web_contents);
+  InitInternal(params, embedder_web_contents);
 
   attached_ = true;
   SendQueuedMessages();
 
   // Create a swapped out RenderView for the guest in the embedder render
   // process, so that the embedder can access the guest's window object.
   // On reattachment, we can reuse the same swapped out RenderView because
   // the embedder process will always be the same even if the embedder
   // WebContents changes.
   if (guest_proxy_routing_id_ == MSG_ROUTING_NONE) {
     guest_proxy_routing_id_ =
         GetWebContents()->CreateSwappedOutRenderView(
             owner_web_contents_->GetSiteInstance());
   }
 
   delegate_->DidAttach(guest_proxy_routing_id_);
 
   has_render_view_ = true;
 
   RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Attached"));
 }
 
 void BrowserPluginGuest::OnCompositorFrameSwappedACK(
     int browser_plugin_instance_id,
     const FrameHostMsg_CompositorFrameSwappedACK_Params& params) {
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(params.producing_route_id,
                                                    params.output_surface_id,
                                                    params.producing_host_id,
                                                    params.ack);
+  pending_frame_.reset();
 }
 
 void BrowserPluginGuest::OnDetach(int browser_plugin_instance_id) {
   if (!attached())
     return;
 
   // This tells BrowserPluginGuest to queue up all IPCs to BrowserPlugin until
   // it's attached again.
   attached_ = false;
 
@@ skipping 232 matching lines @@
 void BrowserPluginGuest::OnImeCompositionRangeChanged(
       const gfx::Range& range,
       const std::vector<gfx::Rect>& character_bounds) {
   static_cast<RenderWidgetHostViewBase*>(
       web_contents()->GetRenderWidgetHostView())->ImeCompositionRangeChanged(
           range, character_bounds);
 }
 #endif
 
 }  // namespace content