Fix message routing for BrowserPlugin in iframe

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 40 matching lines @@
 BrowserPlugin* BrowserPlugin::GetFromNode(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;
 }
 
-BrowserPlugin::BrowserPlugin(RenderViewImpl* render_view,
-                             blink::WebFrame* frame,
+BrowserPlugin::BrowserPlugin(RenderFrame* render_frame,
                              scoped_ptr<BrowserPluginDelegate> delegate)
     : attached_(false),
-      render_view_(render_view->AsWeakPtr()),
-      render_view_routing_id_(render_view->GetRoutingID()),
+      render_view_routing_id_(render_frame->GetRenderView()->GetRoutingID()),
       container_(NULL),
       last_device_scale_factor_(GetDeviceScaleFactor()),
       sad_guest_(NULL),
       guest_crashed_(false),
       plugin_focused_(false),
       visible_(true),
       mouse_locked_(false),
       ready_(false),
-      browser_plugin_manager_(render_view->GetBrowserPluginManager()),
       browser_plugin_instance_id_(browser_plugin::kInstanceIDNone),
       contents_opaque_(true),
       delegate_(delegate.Pass()),
       weak_ptr_factory_(this) {
-  browser_plugin_instance_id_ = browser_plugin_manager()->GetNextInstanceID();
+  browser_plugin_instance_id_ =
+      BrowserPluginManager::Get()->GetNextInstanceID();
 
   if (delegate_)
     delegate_->SetElementInstanceID(browser_plugin_instance_id_);
 }
 
 BrowserPlugin::~BrowserPlugin() {
   if (compositing_helper_.get())
     compositing_helper_->OnContainerDestroy();
 
-  browser_plugin_manager()->RemoveBrowserPlugin(browser_plugin_instance_id_);
+  BrowserPluginManager::Get()->RemoveBrowserPlugin(browser_plugin_instance_id_);
 }
 
 bool BrowserPlugin::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPlugin, message)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_AdvanceFocus, OnAdvanceFocus)
     IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginMsg_CompositorFrameSwapped,
                                 OnCompositorFrameSwapped(message))
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestGone, OnGuestGone)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetContentsOpaque, OnSetContentsOpaque)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetCursor, OnSetCursor)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetMouseLock, OnSetMouseLock)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetTooltipText, OnSetTooltipText)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_ShouldAcceptTouchEvents,
                         OnShouldAcceptTouchEvents)
-    IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_MESSAGE_UNHANDLED(
+        handled = delegate_ && delegate_->OnMessageReceived(message))
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BrowserPlugin::UpdateDOMAttribute(const std::string& attribute_name,
                                        const base::string16& attribute_value) {
   if (!container())
     return;
 
   blink::WebElement element = container()->element();
@@ skipping 14 matching lines @@
   if (container()) {
     blink::WebLocalFrame* frame = container()->element().document().frame();
     attach_params.is_full_page_plugin =
         frame->view()->mainFrame()->document().isPluginDocument();
   }
   gfx::Size view_size(width(), height());
   if (!view_size.IsEmpty()) {
     PopulateResizeGuestParameters(view_size,
                                   &attach_params.resize_guest_params);
   }
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_Attach(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_Attach(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       attach_params));
 
   attached_ = true;
 }
 
 void BrowserPlugin::Detach() {
   if (!attached())
     return;
 
   attached_ = false;
   guest_crashed_ = false;
   EnableCompositing(false);
   if (compositing_helper_.get()) {
     compositing_helper_->OnContainerDestroy();
     compositing_helper_ = NULL;
   }
 
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_Detach(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_Detach(
       render_view_routing_id_, browser_plugin_instance_id_));
 }
 
 void BrowserPlugin::DidCommitCompositorFrame() {
   if (compositing_helper_.get())
     compositing_helper_->DidCommitCompositorFrame();
 }
 
 void BrowserPlugin::OnAdvanceFocus(int browser_plugin_instance_id,
                                    bool reverse) {
-  DCHECK(render_view_);
-  render_view_->GetWebView()->advanceFocus(reverse);
+  RenderViewImpl* render_view =
+      RenderViewImpl::FromRoutingID(render_view_routing_id());
+  if (!render_view)
+    return;
+  render_view->GetWebView()->advanceFocus(reverse);
 }
 
 void BrowserPlugin::OnCompositorFrameSwapped(const IPC::Message& message) {
   if (!attached())
     return;
 
   BrowserPluginMsg_CompositorFrameSwapped::Param param;
   if (!BrowserPluginMsg_CompositorFrameSwapped::Read(&message, &param))
     return;
   // Note that there is no need to send ACK for this message.
@@ skipping 37 matching lines @@
     compositing_helper_->SetContentsOpaque(opaque);
 }
 
 void BrowserPlugin::OnSetCursor(int browser_plugin_instance_id,
                                 const WebCursor& cursor) {
   cursor_ = cursor;
 }
 
 void BrowserPlugin::OnSetMouseLock(int browser_plugin_instance_id,
                                    bool enable) {
+  RenderViewImpl* render_view =
+      RenderViewImpl::FromRoutingID(render_view_routing_id());
   if (enable) {
-    if (mouse_locked_)
+    if (mouse_locked_ || !render_view)
       return;
-    render_view_->mouse_lock_dispatcher()->LockMouse(this);
+    render_view->mouse_lock_dispatcher()->LockMouse(this);
   } else {
     if (!mouse_locked_) {
       OnLockMouseACK(false);
       return;
     }
-    render_view_->mouse_lock_dispatcher()->UnlockMouse(this);
+    if (!render_view)
+      return;
+    render_view->mouse_lock_dispatcher()->UnlockMouse(this);
   }
 }
 
 void BrowserPlugin::OnSetTooltipText(int instance_id,
                                      const base::string16& tooltip_text) {
   // Show tooltip text by setting the BrowserPlugin's |title| attribute.
   UpdateDOMAttribute("title", tooltip_text);
 }
 
 void BrowserPlugin::OnShouldAcceptTouchEvents(int browser_plugin_instance_id,
                                               bool accept) {
   if (container()) {
     container()->requestTouchEventType(
         accept ? WebPluginContainer::TouchEventRequestTypeRaw
                : WebPluginContainer::TouchEventRequestTypeNone);
   }
 }
 
 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_)
+  RenderViewImpl* render_view =
+      RenderViewImpl::FromRoutingID(render_view_routing_id());
+  if (!render_view)
     return 1.0f;
-  return render_view_->GetWebView()->deviceScaleFactor();
+  return render_view->GetWebView()->deviceScaleFactor();
 }
 
 void BrowserPlugin::UpdateDeviceScaleFactor() {
   if (last_device_scale_factor_ == GetDeviceScaleFactor())
     return;
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
   PopulateResizeGuestParameters(plugin_size(), &params);
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       params));
 }
 
 void BrowserPlugin::UpdateGuestFocusState() {
   if (!attached())
     return;
   bool should_be_focused = ShouldGuestBeFocused();
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetFocus(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetFocus(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       should_be_focused));
 }
 
 bool BrowserPlugin::ShouldGuestBeFocused() const {
   bool embedder_focused = false;
-  if (render_view_)
-    embedder_focused = render_view_->has_focus();
+  RenderViewImpl* render_view =
+      RenderViewImpl::FromRoutingID(render_view_routing_id());
+  if (render_view)
+    embedder_focused = render_view->has_focus();
   return plugin_focused_ && embedder_focused;
 }
 
 WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   if (!container)
     return false;
 
   container_ = container;
   container_->setWantsWheelEvents(true);
 
   g_plugin_container_map.Get().insert(std::make_pair(container_, this));
 
-  browser_plugin_manager()->AddBrowserPlugin(browser_plugin_instance_id_, this);
+  BrowserPluginManager::Get()->AddBrowserPlugin(
+      browser_plugin_instance_id_, this);
 
   // This is a way to notify observers of our attributes that this plugin is
   // available in render tree.
   // TODO(lazyboy): This should be done through the delegate instead. Perhaps
   // by firing an event from there.
   UpdateDOMAttribute(
       "internalinstanceid",
       base::UTF8ToUTF16(base::IntToString(browser_plugin_instance_id_)));
 
   return true;
@@ skipping 23 matching lines @@
 
 void BrowserPlugin::destroy() {
   if (container_) {
     // 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_);
   }
 
   container_ = NULL;
   // Will be a no-op if the mouse is not currently locked.
-  if (render_view_)
-    render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(this);
+  RenderViewImpl* render_view =
+      RenderViewImpl::FromRoutingID(render_view_routing_id());
+  if (render_view)
+    render_view->mouse_lock_dispatcher()->OnLockTargetDestroyed(this);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 bool BrowserPlugin::supportsKeyboardFocus() const {
   return true;
 }
 
 bool BrowserPlugin::supportsEditCommands() const {
   return true;
 }
@@ skipping 64 matching lines @@
   if (!ready_) {
     if (delegate_)
       delegate_->Ready();
     ready_ = true;
   }
   if (!attached())
     return;
 
   if (old_width == window_rect.width && old_height == window_rect.height) {
     // Let the browser know about the updated view rect.
-    browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateGeometry(
+    BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateGeometry(
         render_view_routing_id_, browser_plugin_instance_id_, plugin_rect_));
     return;
   }
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
   PopulateResizeGuestParameters(plugin_size(), &params);
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       params));
 }
 
 void BrowserPlugin::PopulateResizeGuestParameters(
     const gfx::Size& view_size,
     BrowserPluginHostMsg_ResizeGuest_Params* params) {
   params->view_size = view_size;
   params->scale_factor = GetDeviceScaleFactor();
@@ skipping 12 matching lines @@
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   if (!attached())
     return;
 
   if (compositing_helper_.get())
     compositing_helper_->UpdateVisibility(visible);
 
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetVisibility(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetVisibility(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       visible));
 }
 
 bool BrowserPlugin::acceptsInputEvents() {
   return true;
 }
 
 bool BrowserPlugin::handleInputEvent(const blink::WebInputEvent& event,
                                      blink::WebCursorInfo& cursor_info) {
   if (guest_crashed_ || !attached())
     return false;
 
   if (event.type == blink::WebInputEvent::ContextMenu)
     return true;
 
   if (blink::WebInputEvent::isKeyboardEventType(event.type) &&
       !edit_commands_.empty()) {
-    browser_plugin_manager()->Send(
+    BrowserPluginManager::Get()->Send(
         new BrowserPluginHostMsg_SetEditCommandsForNextKeyEvent(
             render_view_routing_id_,
             browser_plugin_instance_id_,
             edit_commands_));
     edit_commands_.clear();
   }
 
-  browser_plugin_manager()->Send(
+  BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 browser_plugin_instance_id_,
                                                 plugin_rect_,
                                                 &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_ || !attached())
     return false;
-  browser_plugin_manager()->Send(
+  BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_DragStatusUpdate(
         render_view_routing_id_,
         browser_plugin_instance_id_,
         drag_status,
         DropDataBuilder::Build(drag_data),
         mask,
         position));
   return true;
 }
 
@@ skipping 18 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const blink::WebURL& url,
     void* notify_data,
     const blink::WebURLError& error) {
 }
 
 bool BrowserPlugin::executeEditCommand(const blink::WebString& name) {
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_ExecuteEditCommand(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ExecuteEditCommand(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       name.utf8()));
 
   // BrowserPlugin swallows edit commands.
   return true;
 }
 
 bool BrowserPlugin::executeEditCommand(const blink::WebString& name,
                                        const blink::WebString& value) {
   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 (!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(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ImeSetComposition(
       render_view_routing_id_,
       browser_plugin_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 (!attached())
     return false;
   bool keep_selection = (selectionBehavior == blink::WebWidget::KeepSelection);
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_ImeConfirmComposition(
-      render_view_routing_id_,
-      browser_plugin_instance_id_,
-      text.utf8(),
-      keep_selection));
+  BrowserPluginManager::Get()->Send(
+      new BrowserPluginHostMsg_ImeConfirmComposition(
+          render_view_routing_id_,
+          browser_plugin_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 (!attached())
     return;
-  browser_plugin_manager()->Send(
+  BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_ExtendSelectionAndDelete(
           render_view_routing_id_,
           browser_plugin_instance_id_,
           before,
           after));
 }
 
 void BrowserPlugin::OnLockMouseACK(bool succeeded) {
   mouse_locked_ = succeeded;
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_LockMouse_ACK(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_LockMouse_ACK(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       succeeded));
 }
 
 void BrowserPlugin::OnMouseLockLost() {
   mouse_locked_ = false;
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_UnlockMouse_ACK(
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UnlockMouse_ACK(
       render_view_routing_id_,
       browser_plugin_instance_id_));
 }
 
 bool BrowserPlugin::HandleMouseLockedInputEvent(
     const blink::WebMouseEvent& event) {
-  browser_plugin_manager()->Send(
+  BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 browser_plugin_instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content