Remove GuestWebContentsCreated

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/strings/utf_string_conversions.h"
@@ skipping 50 matching lines @@
 
  private:
   BrowserPluginGuest* browser_plugin_guest_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedderWebContentsObserver);
 };
 
 BrowserPluginGuest::BrowserPluginGuest(
     int instance_id,
     bool has_render_view,
-    WebContentsImpl* web_contents)
+    WebContentsImpl* web_contents,
+    BrowserPluginGuestDelegate* delegate)
     : WebContentsObserver(web_contents),
       embedder_web_contents_(NULL),
       instance_id_(instance_id),
       guest_device_scale_factor_(1.0f),
       focused_(false),
       mouse_locked_(false),
       pending_lock_request_(false),
       guest_visible_(false),
       guest_opaque_(true),
       embedder_visible_(true),
       auto_size_enabled_(false),
       copy_request_id_(0),
       has_render_view_(has_render_view),
       last_seen_auto_size_enabled_(false),
       is_in_destruction_(false),
       last_text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       last_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       last_can_compose_inline_(true),
-      delegate_(NULL),
+      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::WillDestroy() {
   is_in_destruction_ = true;
   embedder_web_contents_ = NULL;
-  delegate_ = NULL;
 }
 
 base::WeakPtr<BrowserPluginGuest> BrowserPluginGuest::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 bool BrowserPluginGuest::LockMouse(bool allowed) {
   if (!attached() || (mouse_locked_ == allowed))
     return false;
 
   return embedder_web_contents()->GotResponseToLockMouseRequest(allowed);
 }
 
 void BrowserPluginGuest::Destroy() {
-  if (!delegate_)
-    return;
   delegate_->Destroy();
 }
 
+WebContentsImpl* BrowserPluginGuest::CreateNewGuestWindow(
+    const WebContents::CreateParams& params) {
+  WebContentsImpl* new_contents =
+      static_cast<WebContentsImpl*>(delegate_->CreateNewGuestWindow(params));
+  DCHECK(new_contents);
+  return new_contents;
+}
+
 bool BrowserPluginGuest::OnMessageReceivedFromEmbedder(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPluginGuest, message)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_CompositorFrameSwappedACK,
                         OnCompositorFrameSwappedACK)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_CopyFromCompositingSurfaceAck,
                         OnCopyFromCompositingSurfaceAck)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_DragStatusUpdate,
                         OnDragStatusUpdate)
@@ skipping 92 matching lines @@
   if (static_cast<RenderViewHostImpl*>(
       embedder_web_contents_->GetRenderViewHost())->input_method_active()) {
     RenderViewHostImpl* guest_rvh = static_cast<RenderViewHostImpl*>(
         GetWebContents()->GetRenderViewHost());
     guest_rvh->SetInputMethodActive(true);
   }
 
   // Inform the embedder of the guest's attachment.
   SendMessageToEmbedder(new BrowserPluginMsg_Attach_ACK(instance_id_));
 
-  if (delegate_) {
-    delegate_->DidAttach(embedder_web_contents, extra_params);
-    has_render_view_ = true;
-  }
+  delegate_->DidAttach(embedder_web_contents, extra_params);
+  has_render_view_ = true;
 }
 
 BrowserPluginGuest::~BrowserPluginGuest() {
 }
 
 // static
 BrowserPluginGuest* BrowserPluginGuest::Create(
     int instance_id,
-    SiteInstance* guest_site_instance,
     WebContentsImpl* web_contents,
-    scoped_ptr<base::DictionaryValue> extra_params,
-    BrowserPluginGuest* opener) {
-  RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Create"));
-  BrowserPluginGuest* guest = new BrowserPluginGuest(
-      instance_id, web_contents->opener() != NULL, web_contents);
-  web_contents->SetBrowserPluginGuest(guest);
-  WebContents* opener_web_contents = NULL;
-  if (opener) {
-    opener_web_contents = opener->GetWebContents();
-    guest_site_instance = opener_web_contents->GetSiteInstance();
-  }
-  BrowserPluginGuestDelegate* delegate = NULL;
-  GetContentClient()->browser()->GuestWebContentsCreated(
-      instance_id,
-      guest_site_instance,
-      web_contents,
-      opener_web_contents,
-      &delegate,
-      extra_params.Pass());
-  if (delegate) {
-    delegate->RegisterDestructionCallback(
-        base::Bind(&BrowserPluginGuest::WillDestroy,
-                   base::Unretained(guest)));
-    guest->set_delegate(delegate);
-  }
-  return guest;
+    BrowserPluginGuestDelegate* delegate) {
+  return new BrowserPluginGuest(
+      instance_id, web_contents->opener() != NULL, web_contents, delegate);
 }
 
 // static
 bool BrowserPluginGuest::IsGuest(WebContentsImpl* web_contents) {
   return web_contents && web_contents->GetBrowserPluginGuest();
 }
 
 // static
 bool BrowserPluginGuest::IsGuest(RenderViewHostImpl* render_view_host) {
   return render_view_host && IsGuest(
@@ skipping 365 matching lines @@
 void BrowserPluginGuest::OnLockMouse(bool user_gesture,
                                      bool last_unlocked_by_target,
                                      bool privileged) {
   if (pending_lock_request_) {
     // Immediately reject the lock because only one pointerLock may be active
     // at a time.
     Send(new ViewMsg_LockMouse_ACK(routing_id(), false));
     return;
   }
 
-  if (!delegate_)
-    return;
-
   pending_lock_request_ = true;
 
   delegate_->RequestPointerLockPermission(
       user_gesture,
       last_unlocked_by_target,
       base::Bind(&BrowserPluginGuest::PointerLockPermissionResponse,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BrowserPluginGuest::OnLockMouseAck(int instance_id, bool succeeded) {
@@ skipping 22 matching lines @@
     render_widget_host->ResetSizeAndRepaintPendingFlags();
 
     if (guest_device_scale_factor_ != params.scale_factor) {
       guest_device_scale_factor_ = params.scale_factor;
       render_widget_host->NotifyScreenInfoChanged();
     }
   }
   // When autosize is turned off and as a result there is a layout change, we
   // send a sizechanged event.
   if (!auto_size_enabled_ && last_seen_auto_size_enabled_ &&
-      !params.view_size.IsEmpty() && delegate_) {
+      !params.view_size.IsEmpty()) {
     delegate_->SizeChanged(last_seen_view_size_, params.view_size);
     last_seen_auto_size_enabled_ = false;
   }
   // Just resize the WebContents and repaint if needed.
   full_size_ = params.view_size;
   if (!params.view_size.IsEmpty())
     GetWebContents()->GetView()->SizeContents(params.view_size);
   if (params.repaint)
     Send(new ViewMsg_Repaint(routing_id(), params.view_size));
 }
@@ skipping 147 matching lines @@
   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);
 
   bool size_changed = last_seen_view_size_ != params.view_size;
   gfx::Size old_size = last_seen_view_size_;
   last_seen_view_size_ = params.view_size;
 
   if ((auto_size_enabled_ || last_seen_auto_size_enabled_) &&
-      size_changed && delegate_) {
+      size_changed) {
     delegate_->SizeChanged(old_size, last_seen_view_size_);
   }
   last_seen_auto_size_enabled_ = auto_size_enabled_;
 
   SendMessageToEmbedder(
       new BrowserPluginMsg_UpdateRect(instance_id(), relay_params));
 }
 
 void BrowserPluginGuest::OnTextInputStateChanged(
     const ViewHostMsg_TextInputState_Params& params) {
@@ skipping 15 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