Remove BrowserPlugin's -internal-attach method

content/renderer/browser_plugin/browser_plugin.cc

 // Copyright 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/renderer/browser_plugin/browser_plugin.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 22 matching lines @@
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using blink::WebCanvas;
 using blink::WebPluginContainer;
 using blink::WebPluginParams;
 using blink::WebPoint;
 using blink::WebRect;
 using blink::WebURL;
 using blink::WebVector;
 
+namespace {
+typedef std::map<blink::WebPluginContainer*, content::BrowserPlugin*>
+    PluginContainerMap;
+static base::LazyInstance<PluginContainerMap> g_plugin_container_map =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
 namespace content {
 
 BrowserPlugin::BrowserPlugin(RenderViewImpl* render_view,
                              blink::WebFrame* frame,
                              bool auto_navigate)
     : guest_instance_id_(browser_plugin::kInstanceIDNone),
       attached_(false),
+      attach_pending_(false),
       render_view_(render_view->AsWeakPtr()),
       render_view_routing_id_(render_view->GetRoutingID()),
       container_(NULL),
       paint_ack_received_(true),
       last_device_scale_factor_(GetDeviceScaleFactor()),
       sad_guest_(NULL),
       guest_crashed_(false),
       is_auto_size_state_dirty_(false),
       content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       visible_(true),
       auto_navigate_(auto_navigate),
       mouse_locked_(false),
       browser_plugin_manager_(render_view->GetBrowserPluginManager()),
+      in_render_tree_(false),
       weak_ptr_factory_(this) {
 }
 
 BrowserPlugin::~BrowserPlugin() {
+  if (in_render_tree_) {
+    browser_plugin_manager()->RemoveBrowserPluginInternal(instance_id_);
+  }
   // If the BrowserPlugin has never navigated then the browser process and
   // BrowserPluginManager don't know about it and so there is nothing to do
   // here.
-  if (!HasGuestInstanceID())
+  if (!attached())
     return;
   browser_plugin_manager()->RemoveBrowserPlugin(guest_instance_id_);
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_PluginDestroyed(render_view_routing_id_,
                                                guest_instance_id_));
 }
 
 bool BrowserPlugin::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPlugin, message)
@@ skipping 116 matching lines @@
 int BrowserPlugin::GetAdjustedMinWidth() const {
   int min_width = GetMinWidthAttribute();
   // FrameView.cpp does not allow this value to be <= 0, so when the value is
   // unset (or set to 0), we set it to the container size.
   min_width = min_width ? min_width : width();
   // For autosize, minWidth should not be bigger than maxWidth.
   return std::min(min_width, GetAdjustedMaxWidth());
 }
 
 void BrowserPlugin::ParseAllowTransparencyAttribute() {
-  if (!HasGuestInstanceID())
+  if (!attached())
     return;
 
   bool opaque = !GetAllowTransparencyAttribute();
 
   if (compositing_helper_)
     compositing_helper_->SetContentsOpaque(opaque);
 
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetContentsOpaque(
         render_view_routing_id_,
         guest_instance_id_,
@@ skipping 20 matching lines @@
     max_auto_size_ = params->max_size;
   } else {
     max_auto_size_ = gfx::Size();
   }
 }
 
 void BrowserPlugin::UpdateGuestAutoSizeState(bool auto_size_enabled) {
   // If we haven't yet heard back from the guest about the last resize request,
   // then we don't issue another request until we do in
   // BrowserPlugin::OnUpdateRect.
-  if (!HasGuestInstanceID() || !paint_ack_received_)
+  if (!attached() || !paint_ack_received_)
     return;
 
   BrowserPluginHostMsg_AutoSize_Params auto_size_params;
   BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
   if (auto_size_enabled) {
     GetSizeParams(&auto_size_params, &resize_guest_params, true);
   } else {
     GetSizeParams(NULL, &resize_guest_params, true);
   }
   paint_ack_received_ = false;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_SetAutoSize(render_view_routing_id_,
                                            guest_instance_id_,
                                            auto_size_params,
                                            resize_guest_params));
 }
 
-void BrowserPlugin::Attach(int guest_instance_id,
-                           scoped_ptr<base::DictionaryValue> extra_params) {
-  CHECK(guest_instance_id != browser_plugin::kInstanceIDNone);
+void BrowserPlugin::Attach() {
+  if (attach_pending_)
+    return;
 
   // If this BrowserPlugin is already attached to a guest, then kill the guest.
-  if (HasGuestInstanceID()) {
-    if (guest_instance_id == guest_instance_id_)
-      return;
+  if (attached()) {
     guest_crashed_ = false;
     EnableCompositing(false);
     if (compositing_helper_) {
       compositing_helper_->OnContainerDestroy();
       compositing_helper_ = NULL;
     }
     browser_plugin_manager()->RemoveBrowserPlugin(guest_instance_id_);
     browser_plugin_manager()->Send(new BrowserPluginHostMsg_PluginDestroyed(
         render_view_routing_id_, guest_instance_id_));
   }
 
-  // This API may be called directly without setting the src attribute.
-  // In that case, we need to make sure we don't allocate another instance ID.
-  guest_instance_id_ = guest_instance_id;
-  browser_plugin_manager()->AddBrowserPlugin(guest_instance_id, this);
-
   BrowserPluginHostMsg_Attach_Params attach_params;
   attach_params.focused = ShouldGuestBeFocused();
   attach_params.visible = visible_;
   attach_params.opaque = !GetAllowTransparencyAttribute();
   attach_params.origin = plugin_rect().origin();
   GetSizeParams(&attach_params.auto_size_params,
                 &attach_params.resize_guest_params,
                 false);
 
-  browser_plugin_manager()->Send(
-      new BrowserPluginHostMsg_Attach(render_view_routing_id_,
-                                      guest_instance_id_, attach_params,
-                                      *extra_params));
+  browser_plugin_manager()->Send(new BrowserPluginHostMsg_Attach(
+      render_view_routing_id_,
+      instance_id_,
+      attach_params));
+
+  attach_pending_ = true;
 }
 
 void BrowserPlugin::DidCommitCompositorFrame() {
   if (compositing_helper_.get())
     compositing_helper_->DidCommitCompositorFrame();
 }
 
 void BrowserPlugin::OnAdvanceFocus(int guest_instance_id, bool reverse) {
   DCHECK(render_view_.get());
   render_view_->GetWebView()->advanceFocus(reverse);
 }
 
-void BrowserPlugin::OnAttachACK(int guest_instance_id) {
+void BrowserPlugin::OnAttachACK(int browser_plugin_instance_id,
+                                int guest_instance_id) {
+  DCHECK(!attached());
+  guest_instance_id_ = guest_instance_id;
+  browser_plugin_manager()->AddBrowserPlugin(guest_instance_id, this);
   attached_ = true;
+  attach_pending_ = false;
 }
 
 void BrowserPlugin::OnBuffersSwapped(
     int instance_id,
     const FrameMsg_BuffersSwapped_Params& params) {
   EnableCompositing(true);
 
   compositing_helper_->OnBuffersSwapped(params.size,
                                         params.mailbox,
                                         params.gpu_route_id,
@@ skipping 72 matching lines @@
       OnLockMouseACK(false);
       return;
     }
     render_view_->mouse_lock_dispatcher()->UnlockMouse(this);
   }
 }
 
 void BrowserPlugin::OnShouldAcceptTouchEvents(int guest_instance_id,
                                               bool accept) {
   if (container()) {
-    container()->requestTouchEventType(accept ?
-        blink::WebPluginContainer::TouchEventRequestTypeRaw :
-        blink::WebPluginContainer::TouchEventRequestTypeNone);
+    container()->requestTouchEventType(
+        accept ? WebPluginContainer::TouchEventRequestTypeRaw
+               : WebPluginContainer::TouchEventRequestTypeNone);
   }
 }
 
 void BrowserPlugin::OnUpdateRect(
     int guest_instance_id,
     const BrowserPluginMsg_UpdateRect_Params& params) {
   // Note that there is no need to send ACK for this message.
   // If the guest has updated pixels then it is no longer crashed.
   guest_crashed_ = false;
 
@@ skipping 50 matching lines @@
   if (content_window_routing_id_ == MSG_ROUTING_NONE)
     return NULL;
   RenderViewImpl* guest_render_view = RenderViewImpl::FromRoutingID(
       content_window_routing_id_);
   if (!guest_render_view)
     return NULL;
   blink::WebFrame* guest_frame = guest_render_view->GetWebView()->mainFrame();
   return guest_frame->windowObject();
 }
 
-bool BrowserPlugin::HasGuestInstanceID() const {
-  return guest_instance_id_ != browser_plugin::kInstanceIDNone;
-}
-
 void BrowserPlugin::ShowSadGraphic() {
   // If the BrowserPlugin is scheduled to be deleted, then container_ will be
   // NULL so we shouldn't attempt to access it.
   if (container_)
     container_->invalidate();
 }
 
 float BrowserPlugin::GetDeviceScaleFactor() const {
   if (!render_view_.get())
     return 1.0f;
   return render_view_->GetWebView()->deviceScaleFactor();
 }
 
 void BrowserPlugin::UpdateDeviceScaleFactor(float device_scale_factor) {
   if (last_device_scale_factor_ == device_scale_factor || !paint_ack_received_)
     return;
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
   PopulateResizeGuestParameters(&params, plugin_size(), true);
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       guest_instance_id_,
       params));
 }
 
 void BrowserPlugin::UpdateGuestFocusState() {
-  if (!HasGuestInstanceID())
+  if (!attached())
     return;
   bool should_be_focused = ShouldGuestBeFocused();
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetFocus(
       render_view_routing_id_,
       guest_instance_id_,
       should_be_focused));
 }
 
 bool BrowserPlugin::ShouldGuestBeFocused() const {
   bool embedder_focused = false;
   if (render_view_.get())
     embedder_focused = render_view_->has_focus();
   return plugin_focused_ && embedder_focused;
 }
 
-blink::WebPluginContainer* BrowserPlugin::container() const {
+WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   if (!container)
     return false;
 
   // Tell |container| to allow this plugin to use script objects.
   npp_.reset(new NPP_t);
   container->allowScriptObjects();
 
   bindings_.reset(new BrowserPluginBindings(this));
   container_ = container;
   container_->setWantsWheelEvents(true);
-  // This is a way to notify observers of our attributes that we have the
-  // bindings ready. This also means that this plugin is available in render
-  // tree.
-  UpdateDOMAttribute("internalbindings", "true");
+
+  g_plugin_container_map.Get().insert(std::make_pair(container_, this));
+
+  // This is a way to notify observers of our attributes that this plugin is
+  // available in render tree.
+  const int next_instance_id = browser_plugin_manager()->GetNextInstanceID();
+  instance_id_ = next_instance_id;
+  UpdateDOMAttribute("internalinstanceid",
+                     base::StringPrintf("%d", next_instance_id));
+  in_render_tree_ = true;
+
+  browser_plugin_manager()->AddBrowserPluginInternal(instance_id_, this);
   return true;
 }
 
 void BrowserPlugin::EnableCompositing(bool enable) {
   bool enabled = !!compositing_helper_;
   if (enabled == enable)
     return;
 
   if (enable) {
     DCHECK(!compositing_helper_.get());
@@ skipping 12 matching lines @@
   }
 }
 
 void BrowserPlugin::destroy() {
   // If the plugin was initialized then it has a valid |npp_| identifier, and
   // the |container_| must clear references to the plugin's script objects.
   DCHECK(!npp_ || container_);
   if (container_)
     container_->clearScriptObjects();
 
+  // The BrowserPlugin's WebPluginContainer is deleted immediately after this
+  // call returns, so let's not keep a reference to it around.
+  g_plugin_container_map.Get().erase(container_);
+
   if (compositing_helper_.get())
     compositing_helper_->OnContainerDestroy();
   container_ = NULL;
   // Will be a no-op if the mouse is not currently locked.
   if (render_view_.get())
     render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(this);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 NPObject* BrowserPlugin::scriptableObject() {
@@ skipping 47 matching lines @@
       SkIntToScalar(plugin_rect_.height()));
   canvas->clipRect(image_data_rect);
   // Paint black or white in case we have nothing in our backing store or we
   // need to show a gutter.
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(guest_crashed_ ? SK_ColorBLACK : SK_ColorWHITE);
   canvas->drawRect(image_data_rect, paint);
 }
 
+// static.
+BrowserPlugin* BrowserPlugin::FromNode(blink::WebNode& node) {
+  blink::WebPluginContainer* container = node.pluginContainer();
+  if (!container)
+    return NULL;
+
+  PluginContainerMap* browser_plugins = g_plugin_container_map.Pointer();
+  PluginContainerMap::iterator it = browser_plugins->find(container);
+  return it == browser_plugins->end() ? NULL : it->second;
+}
+
 // static
 bool BrowserPlugin::ShouldForwardToBrowserPlugin(
     const IPC::Message& message) {
   switch (message.type()) {
     case BrowserPluginMsg_AdvanceFocus::ID:
-    case BrowserPluginMsg_Attach_ACK::ID:
     case BrowserPluginMsg_BuffersSwapped::ID:
     case BrowserPluginMsg_CompositorFrameSwapped::ID:
     case BrowserPluginMsg_CopyFromCompositingSurface::ID:
     case BrowserPluginMsg_GuestContentWindowReady::ID:
     case BrowserPluginMsg_GuestGone::ID:
     case BrowserPluginMsg_SetCursor::ID:
     case BrowserPluginMsg_SetMouseLock::ID:
     case BrowserPluginMsg_ShouldAcceptTouchEvents::ID:
     case BrowserPluginMsg_UpdateRect::ID:
       return true;
@@ skipping 72 matching lines @@
 void BrowserPlugin::updateFocus(bool focused) {
   plugin_focused_ = focused;
   UpdateGuestFocusState();
 }
 
 void BrowserPlugin::updateVisibility(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
-  if (!HasGuestInstanceID())
+  if (!attached())
     return;
 
   if (compositing_helper_.get())
     compositing_helper_->UpdateVisibility(visible);
 
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetVisibility(
       render_view_routing_id_,
       guest_instance_id_,
       visible));
 }
 
 bool BrowserPlugin::acceptsInputEvents() {
   return true;
 }
 
 bool BrowserPlugin::handleInputEvent(const blink::WebInputEvent& event,
                                      blink::WebCursorInfo& cursor_info) {
-  if (guest_crashed_ || !HasGuestInstanceID())
+  if (guest_crashed_ || !attached())
     return false;
 
   if (event.type == blink::WebInputEvent::ContextMenu)
     return true;
 
   const blink::WebInputEvent* modified_event = &event;
   scoped_ptr<blink::WebTouchEvent> touch_event;
   if (blink::WebInputEvent::isTouchEventType(event.type)) {
     const blink::WebTouchEvent* orig_touch_event =
         static_cast<const blink::WebTouchEvent*>(&event);
@@ skipping 52 matching lines @@
                                                 modified_event));
   GetWebKitCursorInfo(cursor_, &cursor_info);
   return true;
 }
 
 bool BrowserPlugin::handleDragStatusUpdate(blink::WebDragStatus drag_status,
                                            const blink::WebDragData& drag_data,
                                            blink::WebDragOperationsMask mask,
                                            const blink::WebPoint& position,
                                            const blink::WebPoint& screen) {
-  if (guest_crashed_ || !HasGuestInstanceID())
+  if (guest_crashed_ || !attached())
     return false;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_DragStatusUpdate(
         render_view_routing_id_,
         guest_instance_id_,
         drag_status,
         DropDataBuilder::Build(drag_data),
         mask,
         position));
   return true;
@@ skipping 45 matching lines @@
   edit_commands_.push_back(EditCommand(name.utf8(), value.utf8()));
   // BrowserPlugin swallows edit commands.
   return true;
 }
 
 bool BrowserPlugin::setComposition(
     const blink::WebString& text,
     const blink::WebVector<blink::WebCompositionUnderline>& underlines,
     int selectionStart,
     int selectionEnd) {
-  if (!HasGuestInstanceID())
+  if (!attached())
     return false;
   std::vector<blink::WebCompositionUnderline> std_underlines;
   for (size_t i = 0; i < underlines.size(); ++i) {
     std_underlines.push_back(underlines[i]);
   }
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ImeSetComposition(
       render_view_routing_id_,
       guest_instance_id_,
       text.utf8(),
       std_underlines,
       selectionStart,
       selectionEnd));
   // TODO(kochi): This assumes the IPC handling always succeeds.
   return true;
 }
 
 bool BrowserPlugin::confirmComposition(
     const blink::WebString& text,
     blink::WebWidget::ConfirmCompositionBehavior selectionBehavior) {
-  if (!HasGuestInstanceID())
+  if (!attached())
     return false;
   bool keep_selection = (selectionBehavior == blink::WebWidget::KeepSelection);
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ImeConfirmComposition(
       render_view_routing_id_,
       guest_instance_id_,
       text.utf8(),
       keep_selection));
   // TODO(kochi): This assumes the IPC handling always succeeds.
   return true;
 }
 
 void BrowserPlugin::extendSelectionAndDelete(int before, int after) {
-  if (!HasGuestInstanceID())
+  if (!attached())
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_ExtendSelectionAndDelete(
           render_view_routing_id_,
           guest_instance_id_,
           before,
           after));
 }
 
 void BrowserPlugin::OnLockMouseACK(bool succeeded) {
@@ skipping 15 matching lines @@
     const blink::WebMouseEvent& event) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 guest_instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content