Browser Plugin: Implement BrowserPluginObserver.

content/renderer/browser_plugin/browser_plugin_impl.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/renderer/browser_plugin/browser_plugin.h"
+#include "content/renderer/browser_plugin/browser_plugin_impl.h"
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/common/browser_plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_client.h"
+#include "content/public/renderer/browser_plugin/browser_plugin_observer.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/browser_plugin/browser_plugin_bindings.h"
 #include "content/renderer/browser_plugin/browser_plugin_compositing_helper.h"
 #include "content/renderer/browser_plugin/browser_plugin_constants.h"
 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/v8_value_converter_impl.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
@@ skipping 40 matching lines @@
   }
   NOTREACHED() << "Unknown Termination Status.";
   return "unknown";
 }
 
 static std::string GetInternalEventName(const char* event_name) {
   return base::StringPrintf("-internal-%s", event_name);
 }
 }  // namespace
 
-BrowserPlugin::BrowserPlugin(
+BrowserPluginImpl::BrowserPluginImpl(
     RenderViewImpl* render_view,
     WebKit::WebFrame* frame,
     const WebPluginParams& params)
     : instance_id_(browser_plugin::kInstanceIDNone),
       render_view_(render_view->AsWeakPtr()),
       render_view_routing_id_(render_view->GetRoutingID()),
       container_(NULL),
       damage_buffer_sequence_id_(0),
       resize_ack_received_(true),
       sad_guest_(NULL),
       guest_crashed_(false),
       navigate_src_sent_(false),
       auto_size_ack_pending_(false),
       guest_process_id_(-1),
       guest_route_id_(-1),
       persist_storage_(false),
       valid_partition_id_(true),
       content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       visible_(true),
       size_changed_in_flight_(false),
       allocate_instance_id_sent_(false),
       browser_plugin_manager_(render_view->browser_plugin_manager()),
       current_nav_entry_index_(0),
       nav_entry_count_(0),
       compositing_enabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           weak_ptr_factory_(this)) {
+  GetContentClient()->renderer()->BrowserPluginCreated(this);
 }
 
-BrowserPlugin::~BrowserPlugin() {
+BrowserPluginImpl::~BrowserPluginImpl() {
   // 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 (!navigate_src_sent_)
     return;
   browser_plugin_manager()->RemoveBrowserPlugin(instance_id_);
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_PluginDestroyed(render_view_routing_id_,
                                                instance_id_));
 }
 
-bool BrowserPlugin::OnMessageReceived(const IPC::Message& message) {
+void BrowserPluginImpl::AddObserver(BrowserPluginObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void BrowserPluginImpl::RemoveObserver(BrowserPluginObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+bool BrowserPluginImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(BrowserPlugin, message)
+  IPC_BEGIN_MESSAGE_MAP(BrowserPluginImpl, message)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_AdvanceFocus, OnAdvanceFocus)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_BuffersSwapped, OnBuffersSwapped)
+    IPC_MESSAGE_HANDLER(BrowserPluginMsg_ForwardMessage, OnForwardMessage)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestContentWindowReady,
                         OnGuestContentWindowReady)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestGone, OnGuestGone)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestResponsive, OnGuestResponsive)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestUnresponsive, OnGuestUnresponsive)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadAbort, OnLoadAbort)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadCommit, OnLoadCommit)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadRedirect, OnLoadRedirect)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadStart, OnLoadStart)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadStop, OnLoadStop)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_RequestPermission, OnRequestPermission)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetCursor, OnSetCursor)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_ShouldAcceptTouchEvents,
                         OnShouldAcceptTouchEvents)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_UpdatedName, OnUpdatedName)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_UpdateRect, OnUpdateRect)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void BrowserPlugin::UpdateDOMAttribute(const std::string& attribute_name,
-                                       const std::string& attribute_value) {
-  if (!container())
-    return;
-
-  WebKit::WebElement element = container()->element();
-  WebKit::WebString web_attribute_name =
-      WebKit::WebString::fromUTF8(attribute_name);
-  if (!HasDOMAttribute(attribute_name) ||
-      (std::string(element.getAttribute(web_attribute_name).utf8()) !=
-          attribute_value)) {
-    element.setAttribute(web_attribute_name,
-        WebKit::WebString::fromUTF8(attribute_value));
-  }
-}
-
-void BrowserPlugin::RemoveDOMAttribute(const std::string& attribute_name) {
-  if (!container())
-    return;
-
-  container()->element().removeAttribute(
-      WebKit::WebString::fromUTF8(attribute_name));
-}
-
-std::string BrowserPlugin::GetDOMAttributeValue(
-    const std::string& attribute_name) const {
-  if (!container())
-    return "";
-
-  return container()->element().getAttribute(
-      WebKit::WebString::fromUTF8(attribute_name)).utf8();
-}
-
-bool BrowserPlugin::HasDOMAttribute(const std::string& attribute_name) const {
-  if (!container())
-    return false;
-
-  return container()->element().hasAttribute(
-      WebKit::WebString::fromUTF8(attribute_name));
-}
-
-std::string BrowserPlugin::GetNameAttribute() const {
+std::string BrowserPluginImpl::GetNameAttribute() const {
   return GetDOMAttributeValue(browser_plugin::kAttributeName);
 }
 
-std::string BrowserPlugin::GetSrcAttribute() const {
+std::string BrowserPluginImpl::GetSrcAttribute() const {
   return GetDOMAttributeValue(browser_plugin::kAttributeSrc);
 }
 
-bool BrowserPlugin::GetAutoSizeAttribute() const {
+bool BrowserPluginImpl::GetAutoSizeAttribute() const {
   return HasDOMAttribute(browser_plugin::kAttributeAutoSize);
 }
 
-int BrowserPlugin::GetMaxHeightAttribute() const {
+int BrowserPluginImpl::GetMaxHeightAttribute() const {
   int max_height;
   base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMaxHeight),
                     &max_height);
   return max_height;
 }
 
-int BrowserPlugin::GetMaxWidthAttribute() const {
+int BrowserPluginImpl::GetMaxWidthAttribute() const {
   int max_width;
   base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMaxWidth),
                     &max_width);
   return max_width;
 }
 
-int BrowserPlugin::GetMinHeightAttribute() const {
+int BrowserPluginImpl::GetMinHeightAttribute() const {
   int min_height;
   base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMinHeight),
                     &min_height);
   return min_height;
 }
 
-int BrowserPlugin::GetMinWidthAttribute() const {
+int BrowserPluginImpl::GetMinWidthAttribute() const {
   int min_width;
   base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMinWidth),
                     &min_width);
   return min_width;
 }
 
-int BrowserPlugin::GetAdjustedMaxHeight() const {
+int BrowserPluginImpl::GetAdjustedMaxHeight() const {
   int max_height = GetMaxHeightAttribute();
   return max_height ? max_height : height();
 }
 
-int BrowserPlugin::GetAdjustedMaxWidth() const {
+int BrowserPluginImpl::GetAdjustedMaxWidth() const {
   int max_width = GetMaxWidthAttribute();
   return max_width ? max_width : width();
 }
 
-int BrowserPlugin::GetAdjustedMinHeight() const {
+int BrowserPluginImpl::GetAdjustedMinHeight() const {
   int min_height = GetMinHeightAttribute();
   // 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_height = min_height ? min_height : height();
   // For autosize, minHeight should not be bigger than maxHeight.
   return std::min(min_height, GetAdjustedMaxHeight());
 }
 
-int BrowserPlugin::GetAdjustedMinWidth() const {
+int BrowserPluginImpl::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());
 }
 
-std::string BrowserPlugin::GetPartitionAttribute() const {
+std::string BrowserPluginImpl::GetPartitionAttribute() const {
   return GetDOMAttributeValue(browser_plugin::kAttributePartition);
 }
 
-void BrowserPlugin::ParseNameAttribute() {
+void BrowserPluginImpl::ParseNameAttribute() {
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_SetName(render_view_routing_id_,
                                        instance_id_,
                                        GetNameAttribute()));
 }
 
-bool BrowserPlugin::ParseSrcAttribute(std::string* error_message) {
+bool BrowserPluginImpl::ParseSrcAttribute(std::string* error_message) {
   if (!valid_partition_id_) {
     *error_message = browser_plugin::kErrorInvalidPartition;
     return false;
   }
   std::string src = GetSrcAttribute();
   if (src.empty())
     return true;
 
   // If we haven't created the guest yet, do so now. We will navigate it right
   // after creation. If |src| is empty, we can delay the creation until we
@@ skipping 15 matching lines @@
     return true;
   }
 
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_NavigateGuest(render_view_routing_id_,
                                              instance_id_,
                                              src));
   return true;
 }
 
-void BrowserPlugin::ParseAutoSizeAttribute() {
+void BrowserPluginImpl::ParseAutoSizeAttribute() {
   auto_size_ack_pending_ = true;
   last_view_size_ = plugin_rect_.size();
   UpdateGuestAutoSizeState(GetAutoSizeAttribute());
 }
 
-void BrowserPlugin::PopulateAutoSizeParameters(
+void BrowserPluginImpl::PopulateAutoSizeParameters(
     BrowserPluginHostMsg_AutoSize_Params* params, bool current_auto_size) {
   params->enable = current_auto_size;
   // No need to populate the params if autosize is off.
   if (current_auto_size) {
     params->max_size = gfx::Size(GetAdjustedMaxWidth(), GetAdjustedMaxHeight());
     params->min_size = gfx::Size(GetAdjustedMinWidth(), GetAdjustedMinHeight());
   }
 }
 
-void BrowserPlugin::UpdateGuestAutoSizeState(bool current_auto_size) {
+void BrowserPluginImpl::UpdateGuestAutoSizeState(bool current_auto_size) {
   // 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::UpdateRect.
+  // BrowserPluginImpl::UpdateRect.
   if (!navigate_src_sent_ || !resize_ack_received_)
     return;
   BrowserPluginHostMsg_AutoSize_Params auto_size_params;
   BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
   if (current_auto_size) {
     GetDamageBufferWithSizeParams(&auto_size_params, &resize_guest_params);
   } else {
     GetDamageBufferWithSizeParams(NULL, &resize_guest_params);
   }
   resize_ack_received_ = false;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_SetAutoSize(render_view_routing_id_,
                                            instance_id_,
                                            auto_size_params,
                                            resize_guest_params));
 }
 
-void BrowserPlugin::SizeChangedDueToAutoSize(const gfx::Size& old_view_size) {
+void BrowserPluginImpl::SizeChangedDueToAutoSize(
+    const gfx::Size& old_view_size) {
   size_changed_in_flight_ = false;
 
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kOldHeight] =
       new base::FundamentalValue(old_view_size.height());
   props[browser_plugin::kOldWidth] =
       new base::FundamentalValue(old_view_size.width());
   props[browser_plugin::kNewHeight] =
       new base::FundamentalValue(last_view_size_.height());
   props[browser_plugin::kNewWidth] =
       new base::FundamentalValue(last_view_size_.width());
   TriggerEvent(browser_plugin::kEventSizeChanged, &props);
 }
 
 // static
-bool BrowserPlugin::UsesDamageBuffer(
+bool BrowserPluginImpl::UsesDamageBuffer(
     const BrowserPluginMsg_UpdateRect_Params& params) {
   return params.damage_buffer_sequence_id != 0 || params.needs_ack;
 }
 
-bool BrowserPlugin::UsesPendingDamageBuffer(
+bool BrowserPluginImpl::UsesPendingDamageBuffer(
     const BrowserPluginMsg_UpdateRect_Params& params) {
   if (!pending_damage_buffer_.get())
     return false;
   return damage_buffer_sequence_id_ == params.damage_buffer_sequence_id;
 }
 
-void BrowserPlugin::SetInstanceID(int instance_id) {
+void BrowserPluginImpl::SetInstanceID(int instance_id) {
   CHECK(instance_id != browser_plugin::kInstanceIDNone);
   instance_id_ = instance_id;
   browser_plugin_manager()->AddBrowserPlugin(instance_id, this);
 
   BrowserPluginHostMsg_CreateGuest_Params create_guest_params;
   create_guest_params.storage_partition_id = storage_partition_id_;
   create_guest_params.persist_storage = persist_storage_;
   create_guest_params.focused = ShouldGuestBeFocused();
   create_guest_params.visible = visible_;
   create_guest_params.name = GetNameAttribute();
   create_guest_params.src = GetSrcAttribute();
   GetDamageBufferWithSizeParams(&create_guest_params.auto_size_params,
                                 &create_guest_params.resize_guest_params);
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_CreateGuest(render_view_routing_id_,
                                            instance_id_,
                                            create_guest_params));
 
   // Record that we sent a navigation request to the browser process.
   // Once this instance has navigated, the storage partition cannot be changed,
   // so this value is used for enforcing this.
   navigate_src_sent_ = true;
 }
 
-void BrowserPlugin::OnAdvanceFocus(int instance_id, bool reverse) {
+void BrowserPluginImpl::OnAdvanceFocus(int instance_id, bool reverse) {
   DCHECK(render_view_);
   render_view_->GetWebView()->advanceFocus(reverse);
 }
 
-void BrowserPlugin::OnBuffersSwapped(int instance_id,
-                                     const gfx::Size& size,
-                                     std::string mailbox_name,
-                                     int gpu_route_id,
-                                     int gpu_host_id) {
+void BrowserPluginImpl::OnBuffersSwapped(int instance_id,
+                                         const gfx::Size& size,
+                                         std::string mailbox_name,
+                                         int gpu_route_id,
+                                         int gpu_host_id) {
   DCHECK(instance_id == instance_id_);
   EnableCompositing(true);
 
   compositing_helper_->OnBuffersSwapped(size,
                                         mailbox_name,
                                         gpu_route_id,
                                         gpu_host_id);
 }
 
-void BrowserPlugin::OnGuestContentWindowReady(int instance_id,
-                                            int content_window_routing_id) {
+void BrowserPluginImpl::OnForwardMessage(int instance_id,
+                                         const IPC::Message& msg) {
+  if (!observers_.might_have_observers())
+    return;
+  ObserverListBase<BrowserPluginObserver>::Iterator it(observers_);
+  BrowserPluginObserver* observer;
+  while ((observer = it.GetNext()) != NULL) {
+    if (observer->OnMessageReceived(msg))
+      return;
+  }
+}
+
+void BrowserPluginImpl::OnGuestContentWindowReady(
+    int instance_id,
+    int content_window_routing_id) {
   DCHECK(content_window_routing_id != MSG_ROUTING_NONE);
   content_window_routing_id_ = content_window_routing_id;
 }
 
-void BrowserPlugin::OnGuestGone(int instance_id, int process_id, int status) {
+void BrowserPluginImpl::OnGuestGone(int instance_id,
+                                    int process_id,
+                                    int status) {
   // Set the BrowserPlugin in a crashed state before firing event listeners so
   // that operations on the BrowserPlugin within listeners are aware that
   // BrowserPlugin is in a crashed state.
   guest_crashed_ = true;
 
   // We fire the event listeners before painting the sad graphic to give the
   // developer an opportunity to display an alternative overlay image on crash.
   std::string termination_status = TerminationStatusToString(
       static_cast<base::TerminationStatus>(status));
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kProcessId] = new base::FundamentalValue(process_id);
   props[browser_plugin::kReason] = new base::StringValue(termination_status);
 
   // Event listeners may remove the BrowserPlugin from the document. If that
   // happens, the BrowserPlugin will be scheduled for later deletion (see
-  // BrowserPlugin::destroy()). That will clear the container_ reference,
+  // BrowserPluginImpl::destroy()). That will clear the container_ reference,
   // but leave other member variables valid below.
   TriggerEvent(browser_plugin::kEventExit, &props);
 
   // We won't paint the contents of the current backing store again so we might
   // as well toss it out and save memory.
   backing_store_.reset();
   // 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();
   // Turn off compositing so we can display the sad graphic.
   EnableCompositing(false);
 }
 
-void BrowserPlugin::OnGuestResponsive(int instance_id, int process_id) {
+void BrowserPluginImpl::OnGuestResponsive(int instance_id, int process_id) {
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kProcessId] = new base::FundamentalValue(process_id);
   TriggerEvent(browser_plugin::kEventResponsive, &props);
 }
 
-void BrowserPlugin::OnGuestUnresponsive(int instance_id, int process_id) {
+void BrowserPluginImpl::OnGuestUnresponsive(int instance_id, int process_id) {
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kProcessId] = new base::FundamentalValue(process_id);
   TriggerEvent(browser_plugin::kEventUnresponsive, &props);
 }
 
-void BrowserPlugin::OnLoadAbort(int instance_id,
-                                const GURL& url,
-                                bool is_top_level,
-                                const std::string& type) {
+void BrowserPluginImpl::OnLoadAbort(int instance_id,
+                                    const GURL& url,
+                                    bool is_top_level,
+                                    const std::string& type) {
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kURL] = new base::StringValue(url.spec());
   props[browser_plugin::kIsTopLevel] = new base::FundamentalValue(is_top_level);
   props[browser_plugin::kReason] = new base::StringValue(type);
   TriggerEvent(browser_plugin::kEventLoadAbort, &props);
 }
 
-void BrowserPlugin::OnLoadCommit(
+void BrowserPluginImpl::OnLoadCommit(
     int instance_id,
     const BrowserPluginMsg_LoadCommit_Params& params) {
   // If the guest has just committed a new navigation then it is no longer
   // crashed.
   guest_crashed_ = false;
   if (params.is_top_level)
     UpdateDOMAttribute(browser_plugin::kAttributeSrc, params.url.spec());
 
   guest_process_id_ = params.process_id;
   guest_route_id_ = params.route_id;
   current_nav_entry_index_ = params.current_entry_index;
   nav_entry_count_ = params.entry_count;
 
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kURL] = new base::StringValue(params.url.spec());
   props[browser_plugin::kIsTopLevel] =
       new base::FundamentalValue(params.is_top_level);
   TriggerEvent(browser_plugin::kEventLoadCommit, &props);
 }
 
-void BrowserPlugin::OnLoadRedirect(int instance_id,
-                                   const GURL& old_url,
-                                   const GURL& new_url,
-                                   bool is_top_level) {
+void BrowserPluginImpl::OnLoadRedirect(int instance_id,
+                                       const GURL& old_url,
+                                       const GURL& new_url,
+                                       bool is_top_level) {
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kOldURL] = new base::StringValue(old_url.spec());
   props[browser_plugin::kNewURL] = new base::StringValue(new_url.spec());
   props[browser_plugin::kIsTopLevel] = new base::FundamentalValue(is_top_level);
   TriggerEvent(browser_plugin::kEventLoadRedirect, &props);
 }
 
-void BrowserPlugin::OnLoadStart(int instance_id,
-                                const GURL& url,
-                                bool is_top_level) {
+void BrowserPluginImpl::OnLoadStart(int instance_id,
+                                    const GURL& url,
+                                    bool is_top_level) {
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kURL] = new base::StringValue(url.spec());
   props[browser_plugin::kIsTopLevel] = new base::FundamentalValue(is_top_level);
 
   TriggerEvent(browser_plugin::kEventLoadStart, &props);
 }
 
-void BrowserPlugin::OnLoadStop(int instance_id) {
+void BrowserPluginImpl::OnLoadStop(int instance_id) {
   TriggerEvent(browser_plugin::kEventLoadStop, NULL);
 }
 
-void BrowserPlugin::OnRequestPermission(
+void BrowserPluginImpl::OnRequestPermission(
     int instance_id,
     BrowserPluginPermissionType permission_type,
     int request_id,
     const base::DictionaryValue& request_info) {
   if (permission_type == BrowserPluginPermissionTypeMedia)
     RequestMediaPermission(request_id, request_info);
 }
 
-void BrowserPlugin::OnSetCursor(int instance_id, const WebCursor& cursor) {
+void BrowserPluginImpl::OnSetCursor(int instance_id, const WebCursor& cursor) {
   cursor_ = cursor;
 }
 
-void BrowserPlugin::OnShouldAcceptTouchEvents(int instance_id, bool accept) {
+void BrowserPluginImpl::OnShouldAcceptTouchEvents(int instance_id,
+                                                  bool accept) {
   if (container()) {
     container()->requestTouchEventType(accept ?
         WebKit::WebPluginContainer::TouchEventRequestTypeRaw :
         WebKit::WebPluginContainer::TouchEventRequestTypeNone);
   }
 }
 
-void BrowserPlugin::OnUpdatedName(int instance_id, const std::string& name) {
+void BrowserPluginImpl::OnUpdatedName(int instance_id,
+                                      const std::string& name) {
   UpdateDOMAttribute(browser_plugin::kAttributeName, name);
 }
 
-void BrowserPlugin::RequestMediaPermission(
+void BrowserPluginImpl::RequestMediaPermission(
     int request_id, const base::DictionaryValue& request_info) {
   if (!HasEventListeners(browser_plugin::kEventRequestPermission)) {
     // Automatically deny the request if there are no event listeners for
     // permissionrequest.
     RespondPermission(
         BrowserPluginPermissionTypeMedia, request_id, false /* allow */);
     return;
   }
   DCHECK(!pending_permission_requests_.count(request_id));
   pending_permission_requests_.insert(
       std::make_pair(request_id,
                      std::make_pair(request_id,
                                     BrowserPluginPermissionTypeMedia)));
 
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kPermission] =
       base::Value::CreateStringValue(browser_plugin::kPermissionTypeMedia);
   props[browser_plugin::kRequestId] =
       base::Value::CreateIntegerValue(request_id);
 
   // Fill in the info provided by the browser.
   for (DictionaryValue::Iterator iter(request_info); !iter.IsAtEnd();
            iter.Advance()) {
     props[iter.key()] = iter.value().DeepCopy();
   }
   TriggerEvent(browser_plugin::kEventRequestPermission, &props);
 }
 
-bool BrowserPlugin::HasEventListeners(const std::string& event_name) {
+bool BrowserPluginImpl::HasEventListeners(const std::string& event_name) {
   if (!container())
     return false;
 
   WebKit::WebNode node = container()->element();
   // Escape the <webview> shim if this BrowserPlugin has one.
   WebKit::WebElement shim = node.shadowHost();
   if (!shim.isNull())
     node = shim;
 
   const WebKit::WebString& web_event_name =
       WebKit::WebString::fromUTF8(event_name);
   while (!node.isNull()) {
     if (node.hasEventListeners(web_event_name))
       return true;
     node = node.parentNode();
   }
   return false;
 }
 
-void BrowserPlugin::OnUpdateRect(
+void BrowserPluginImpl::OnUpdateRect(
     int instance_id,
     const BrowserPluginMsg_UpdateRect_Params& params) {
   bool use_new_damage_buffer = !backing_store_;
   BrowserPluginHostMsg_AutoSize_Params auto_size_params;
   BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
   // If we have a pending damage buffer, and the guest has begun to use the
   // damage buffer then we know the guest will no longer use the current
   // damage buffer. At this point, we drop the current damage buffer, and
   // mark the pending damage buffer as the current damage buffer.
   if (UsesPendingDamageBuffer(params)) {
@@ skipping 56 matching lines @@
     // resize to avoid flicker. |size_changed_in_flight_| acts as a form of
     // flow control for SizeChanged events. If the guest's view size is changing
     // rapidly before a SizeChanged event fires, then we avoid scheduling
     // another SizeChanged event. SizeChanged reads the new size from
     // |last_view_size_| so we can be sure that it always fires an event
     // with the last seen view size.
     if (container_ && !size_changed_in_flight_) {
       size_changed_in_flight_ = true;
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&BrowserPlugin::SizeChangedDueToAutoSize,
+          base::Bind(&BrowserPluginImpl::SizeChangedDueToAutoSize,
                      base::Unretained(this),
                      old_view_size));
     }
   }
 
   // No more work to do since the guest is no longer using a damage buffer.
   if (!UsesDamageBuffer(params))
     return;
 
   // If we are seeing damage buffers, HW compositing should be turned off.
@@ skipping 30 matching lines @@
     container_->invalidate();
   if (auto_size)
     PopulateAutoSizeParameters(&auto_size_params, auto_size);
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
       render_view_routing_id_,
       instance_id_,
       auto_size_params,
       resize_guest_params));
 }
 
-void BrowserPlugin::ParseSizeContraintsChanged() {
+void BrowserPluginImpl::ParseSizeContraintsChanged() {
   bool auto_size = GetAutoSizeAttribute();
   if (auto_size)
     UpdateGuestAutoSizeState(true);
 }
 
-bool BrowserPlugin::InAutoSizeBounds(const gfx::Size& size) const {
+bool BrowserPluginImpl::InAutoSizeBounds(const gfx::Size& size) const {
   return size.width() <= GetAdjustedMaxWidth() &&
       size.height() <= GetAdjustedMaxHeight();
 }
 
-NPObject* BrowserPlugin::GetContentWindow() const {
+NPObject* BrowserPluginImpl::GetContentWindow() const {
   if (content_window_routing_id_ == MSG_ROUTING_NONE)
     return NULL;
   RenderViewImpl* guest_render_view = static_cast<RenderViewImpl*>(
       ChildThread::current()->ResolveRoute(content_window_routing_id_));
   if (!guest_render_view)
     return NULL;
   WebKit::WebFrame* guest_frame = guest_render_view->GetWebView()->mainFrame();
   return guest_frame->windowObject();
 }
 
-bool BrowserPlugin::CanGoBack() const {
+bool BrowserPluginImpl::CanGoBack() const {
   return nav_entry_count_ > 1 && current_nav_entry_index_ > 0;
 }
 
-bool BrowserPlugin::CanGoForward() const {
+bool BrowserPluginImpl::CanGoForward() const {
   return current_nav_entry_index_ >= 0 &&
       current_nav_entry_index_ < (nav_entry_count_ - 1);
 }
 
-bool BrowserPlugin::ParsePartitionAttribute(std::string* error_message) {
+bool BrowserPluginImpl::ParsePartitionAttribute(std::string* error_message) {
   if (allocate_instance_id_sent_) {
     *error_message = browser_plugin::kErrorAlreadyNavigated;
     return false;
   }
 
   std::string input = GetPartitionAttribute();
 
   // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
   // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
   // remove the prefix without splicing in the middle of a multi-byte codepoint.
@@ skipping 11 matching lines @@
     persist_storage_ = true;
   } else {
     persist_storage_ = false;
   }
 
   valid_partition_id_ = true;
   storage_partition_id_ = input;
   return true;
 }
 
-bool BrowserPlugin::CanRemovePartitionAttribute(std::string* error_message) {
+bool BrowserPluginImpl::CanRemovePartitionAttribute(
+    std::string* error_message) {
   if (navigate_src_sent_)
     *error_message = browser_plugin::kErrorCannotRemovePartition;
   return !navigate_src_sent_;
 }
 
-void BrowserPlugin::ParseAttributes() {
+void BrowserPluginImpl::ParseAttributes() {
   // TODO(mthiesse): Handle errors here?
   std::string error;
   ParsePartitionAttribute(&error);
 
   // Parse the 'src' attribute last, as it will set the has_navigated_ flag to
   // true, which prevents changing the 'partition' attribute.
   ParseSrcAttribute(&error);
 }
 
-float BrowserPlugin::GetDeviceScaleFactor() const {
+float BrowserPluginImpl::GetDeviceScaleFactor() const {
   if (!render_view_)
     return 1.0f;
   return render_view_->GetWebView()->deviceScaleFactor();
 }
 
-void BrowserPlugin::TriggerEvent(const std::string& event_name,
-                                 std::map<std::string, base::Value*>* props) {
-  if (!container() || !container()->element().document().frame())
-    return;
-  v8::HandleScope handle_scope;
-  std::string json_string;
-  if (props) {
-    base::DictionaryValue dict;
-    for (std::map<std::string, base::Value*>::iterator iter = props->begin(),
-             end = props->end(); iter != end; ++iter) {
-      dict.Set(iter->first, iter->second);
-    }
-
-    JSONStringValueSerializer serializer(&json_string);
-    if (!serializer.Serialize(dict))
-      return;
-  }
-
-  WebKit::WebFrame* frame = container()->element().document().frame();
-  WebKit::WebDOMEvent dom_event = frame->document().createEvent("CustomEvent");
-  WebKit::WebDOMCustomEvent event = dom_event.to<WebKit::WebDOMCustomEvent>();
-
-  // The events triggered directly from the plugin <object> are internal events
-  // whose implementation details can (and likely will) change over time. The
-  // wrapper/shim (e.g. <webview> tag) should receive these events, and expose a
-  // more appropriate (and stable) event to the consumers as part of the API.
-  event.initCustomEvent(
-      WebKit::WebString::fromUTF8(GetInternalEventName(event_name.c_str())),
-      false, false,
-      WebKit::WebSerializedScriptValue::serialize(
-          v8::String::New(json_string.c_str(), json_string.size())));
-  container()->element().dispatchEvent(event);
-}
-
-void BrowserPlugin::OnRequestObjectGarbageCollected(int request_id) {
+void BrowserPluginImpl::OnRequestObjectGarbageCollected(int request_id) {
   // Remove from alive objects.
   std::map<int, AliveV8PermissionRequestItem*>::iterator iter =
       alive_v8_permission_request_objects_.find(request_id);
   if (iter != alive_v8_permission_request_objects_.end())
     alive_v8_permission_request_objects_.erase(iter);
 
   // If a decision has not been made for this request yet, deny it.
   RespondPermissionIfRequestIsPending(request_id, false /*allow*/);
 }
 
-void BrowserPlugin::PersistRequestObject(
+void BrowserPluginImpl::PersistRequestObject(
     const NPVariant* request, const std::string& type, int id) {
   CHECK(alive_v8_permission_request_objects_.find(id) ==
         alive_v8_permission_request_objects_.end());
   if (pending_permission_requests_.find(id) ==
       pending_permission_requests_.end()) {
     return;
   }
 
   v8::Persistent<v8::Value> weak_request =
       v8::Persistent<v8::Value>::New(WebKit::WebBindings::toV8Value(request));
 
   AliveV8PermissionRequestItem* new_item =
-      new std::pair<int, base::WeakPtr<BrowserPlugin> >(
+      new std::pair<int, base::WeakPtr<BrowserPluginImpl> >(
           id, weak_ptr_factory_.GetWeakPtr());
 
   std::pair<std::map<int, AliveV8PermissionRequestItem*>::iterator, bool>
       result = alive_v8_permission_request_objects_.insert(
           std::make_pair(id, new_item));
   CHECK(result.second);  // Inserted in the map.
   AliveV8PermissionRequestItem* request_item = result.first->second;
   weak_request.MakeWeak(request_item, WeakCallbackForPersistObject);
 }
 
 // static
-void BrowserPlugin::WeakCallbackForPersistObject(
+void BrowserPluginImpl::WeakCallbackForPersistObject(
     v8::Persistent<v8::Value> object, void* param) {
   v8::Persistent<v8::Object> persistent_object =
       v8::Persistent<v8::Object>::Cast(object);
 
   AliveV8PermissionRequestItem* item_ptr =
       static_cast<AliveV8PermissionRequestItem*>(param);
   int request_id = item_ptr->first;
-  base::WeakPtr<BrowserPlugin> plugin = item_ptr->second;
+  base::WeakPtr<BrowserPluginImpl> plugin = item_ptr->second;
   delete item_ptr;
 
   persistent_object.Dispose();
   persistent_object.Clear();
 
   if (plugin) {
     // Asynchronously remove item from |alive_v8_permission_request_objects_|.
     // Note that we are using weak pointer for the following PostTask, so we
     // don't need to worry about BrowserPlugin going away.
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&BrowserPlugin::OnRequestObjectGarbageCollected,
+        base::Bind(&BrowserPluginImpl::OnRequestObjectGarbageCollected,
                    plugin, request_id));
   }
 }
 
-void BrowserPlugin::Back() {
+void BrowserPluginImpl::Back() {
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Go(render_view_routing_id_,
                                   instance_id_, -1));
 }
 
-void BrowserPlugin::Forward() {
+void BrowserPluginImpl::Forward() {
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Go(render_view_routing_id_,
                                   instance_id_, 1));
 }
 
-void BrowserPlugin::Go(int relative_index) {
+void BrowserPluginImpl::Go(int relative_index) {
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Go(render_view_routing_id_,
                                   instance_id_,
                                   relative_index));
 }
 
-void BrowserPlugin::TerminateGuest() {
+void BrowserPluginImpl::TerminateGuest() {
   if (!navigate_src_sent_ || guest_crashed_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_TerminateGuest(render_view_routing_id_,
                                               instance_id_));
 }
 
-void BrowserPlugin::Stop() {
+void BrowserPluginImpl::Stop() {
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Stop(render_view_routing_id_,
                                     instance_id_));
 }
 
-void BrowserPlugin::Reload() {
+void BrowserPluginImpl::Reload() {
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Reload(render_view_routing_id_,
                                       instance_id_));
 }
 
-void BrowserPlugin::UpdateGuestFocusState() {
+void BrowserPluginImpl::UpdateGuestFocusState() {
   if (!navigate_src_sent_)
     return;
   bool should_be_focused = ShouldGuestBeFocused();
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetFocus(
       render_view_routing_id_,
       instance_id_,
       should_be_focused));
 }
 
-bool BrowserPlugin::ShouldGuestBeFocused() const {
+bool BrowserPluginImpl::ShouldGuestBeFocused() const {
   bool embedder_focused = false;
   if (render_view_)
     embedder_focused = render_view_->has_focus();
   return plugin_focused_ && embedder_focused;
 }
 
-WebKit::WebPluginContainer* BrowserPlugin::container() const {
+WebKit::WebPluginContainer* BrowserPluginImpl::container() const {
   return container_;
 }
 
-void BrowserPlugin::RespondPermission(
+void BrowserPluginImpl::RespondPermission(
     BrowserPluginPermissionType permission_type, int request_id, bool allow) {
   switch (permission_type) {
     case BrowserPluginPermissionTypeMedia:
       browser_plugin_manager()->Send(
           new BrowserPluginHostMsg_RespondPermission(
               render_view_->GetRoutingID(), instance_id_,
               BrowserPluginPermissionTypeMedia, request_id, allow));
       break;
     case BrowserPluginPermissionTypeUnknown:
     default:
       // Not a valid permission type.
       NOTREACHED();
       break;
   }
 }
 
-void BrowserPlugin::RespondPermissionIfRequestIsPending(
+void BrowserPluginImpl::RespondPermissionIfRequestIsPending(
     int request_id, bool allow) {
   PendingPermissionRequests::iterator iter =
       pending_permission_requests_.find(request_id);
   if (iter == pending_permission_requests_.end())
     return;
 
   BrowserPluginPermissionType permission_type = iter->second.second;
   pending_permission_requests_.erase(iter);
   RespondPermission(permission_type, request_id, allow);
 }
 
-void BrowserPlugin::OnEmbedderDecidedPermission(int request_id, bool allow) {
+void BrowserPluginImpl::OnEmbedderDecidedPermission(int request_id,
+                                                    bool allow) {
   RespondPermissionIfRequestIsPending(request_id, allow);
 }
 
-bool BrowserPlugin::initialize(WebPluginContainer* container) {
+bool BrowserPluginImpl::initialize(WebPluginContainer* container) {
   if (!container)
     return false;
 
   if (!GetContentClient()->renderer()->AllowBrowserPlugin(container))
     return false;
 
   bindings_.reset(new BrowserPluginBindings(this));
   container_ = container;
   container_->setWantsWheelEvents(true);
   ParseAttributes();
   return true;
 }
 
-void BrowserPlugin::EnableCompositing(bool enable) {
+void BrowserPluginImpl::EnableCompositing(bool enable) {
   if (compositing_enabled_ == enable)
     return;
 
   compositing_enabled_ = enable;
   if (enable) {
     // No need to keep the backing store and damage buffer around if we're now
     // compositing.
     backing_store_.reset();
     current_damage_buffer_.reset();
     if (!compositing_helper_) {
@@ skipping 13 matching lines @@
     params.repaint = true;
     resize_ack_received_ = false;
     browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
         render_view_routing_id_,
         instance_id_,
         params));
   }
   compositing_helper_->EnableCompositing(enable);
 }
 
-void BrowserPlugin::destroy() {
+void BrowserPluginImpl::destroy() {
   // The BrowserPlugin's WebPluginContainer is deleted immediately after this
   // call returns, so let's not keep a reference to it around.
   container_ = NULL;
+  // BrowserPluginObservers might create additional bindings. These bindings
+  // might refer back to the observers that created them. In order to ensure
+  // that bindings can always refer to valid observers, we get rid of bindings
+  // prior to cleaning up observers.
+  bindings_.reset();
+  FOR_EACH_OBSERVER(BrowserPluginObserver, observers_, BrowserPluginGone());
+  FOR_EACH_OBSERVER(BrowserPluginObserver, observers_, OnDestruct());
   if (compositing_helper_)
     compositing_helper_->OnContainerDestroy();
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
-NPObject* BrowserPlugin::scriptableObject() {
+NPObject* BrowserPluginImpl::scriptableObject() {
   if (!bindings_.get())
     return NULL;
 
   NPObject* browser_plugin_np_object(bindings_->np_object());
   // The object is expected to be retained before it is returned.
   WebKit::WebBindings::retainObject(browser_plugin_np_object);
   return browser_plugin_np_object;
 }
 
-bool BrowserPlugin::supportsKeyboardFocus() const {
+bool BrowserPluginImpl::supportsKeyboardFocus() const {
   return true;
 }
 
-bool BrowserPlugin::canProcessDrag() const {
+bool BrowserPluginImpl::canProcessDrag() const {
   return true;
 }
 
-void BrowserPlugin::paint(WebCanvas* canvas, const WebRect& rect) {
+void BrowserPluginImpl::paint(WebCanvas* canvas, const WebRect& rect) {
   if (guest_crashed_) {
     if (!sad_guest_)  // Lazily initialize bitmap.
-      sad_guest_ = content::GetContentClient()->renderer()->
-          GetSadWebViewBitmap();
+      sad_guest_ = GetContentClient()->renderer()->GetSadWebViewBitmap();
     // content_shell does not have the sad plugin bitmap, so we'll paint black
     // instead to make it clear that something went wrong.
     if (sad_guest_) {
       webkit::PaintSadPlugin(canvas, plugin_rect_, *sad_guest_);
       return;
     }
   }
   SkAutoCanvasRestore auto_restore(canvas, true);
   canvas->translate(plugin_rect_.x(), plugin_rect_.y());
   SkRect image_data_rect = SkRect::MakeXYWH(
@@ skipping 10 matching lines @@
   canvas->drawRect(image_data_rect, paint);
   // Stay a solid color if we have never set a non-empty src, or we don't have a
   // backing store.
   if (!backing_store_.get() || !navigate_src_sent_)
     return;
   float inverse_scale_factor =  1.0f / backing_store_->GetScaleFactor();
   canvas->scale(inverse_scale_factor, inverse_scale_factor);
   canvas->drawBitmap(backing_store_->GetBitmap(), 0, 0);
 }
 
-bool BrowserPlugin::InBounds(const gfx::Point& position) const {
+bool BrowserPluginImpl::InBounds(const gfx::Point& position) const {
   // Note that even for plugins that are rotated using rotate transformations,
   // we use the the |plugin_rect_| provided by updateGeometry, which means we
   // will be off if |position| is within the plugin rect but does not fall
   // within the actual plugin boundary. Not supporting such edge case is OK
   // since this function should not be used for making security-sensitive
   // decisions.
   // This also does not take overlapping plugins into account.
   bool result = position.x() >= plugin_rect_.x() &&
       position.x() < plugin_rect_.x() + plugin_rect_.width() &&
       position.y() >= plugin_rect_.y() &&
       position.y() < plugin_rect_.y() + plugin_rect_.height();
   return result;
 }
 
-gfx::Point BrowserPlugin::ToLocalCoordinates(const gfx::Point& point) const {
+RenderView* BrowserPluginImpl::GetRenderView() const {
+  return render_view_.get();
+}
+
+WebKit::WebPluginContainer* BrowserPluginImpl::GetContainer() const {
+  return container();
+}
+
+void BrowserPluginImpl::AddMethodBinding(
+    BrowserPluginMethodBinding* method_binding) {
+  bindings_->AddMethodBinding(method_binding);
+}
+
+void BrowserPluginImpl::AddPropertyBinding(
+    BrowserPluginPropertyBinding* method_binding) {
+  bindings_->AddPropertyBinding(method_binding);
+}
+
+void BrowserPluginImpl::TriggerEvent(
+    const std::string& event_name,
+    std::map<std::string, base::Value*>* props) {
+  if (!container() || !container()->element().document().frame())
+    return;
+  v8::HandleScope handle_scope;
+  std::string json_string;
+  if (props) {
+    base::DictionaryValue dict;
+    for (std::map<std::string, base::Value*>::iterator iter = props->begin(),
+             end = props->end(); iter != end; ++iter) {
+      dict.Set(iter->first, iter->second);
+    }
+
+    JSONStringValueSerializer serializer(&json_string);
+    if (!serializer.Serialize(dict))
+      return;
+  }
+
+  WebKit::WebFrame* frame = container()->element().document().frame();
+  WebKit::WebDOMEvent dom_event = frame->document().createEvent("CustomEvent");
+  WebKit::WebDOMCustomEvent event = dom_event.to<WebKit::WebDOMCustomEvent>();
+
+  // The events triggered directly from the plugin <object> are internal events
+  // whose implementation details can (and likely will) change over time. The
+  // wrapper/shim (e.g. <webview> tag) should receive these events, and expose a
+  // more appropriate (and stable) event to the consumers as part of the API.
+  event.initCustomEvent(
+      WebKit::WebString::fromUTF8(GetInternalEventName(event_name.c_str())),
+      false, false,
+      WebKit::WebSerializedScriptValue::serialize(
+          v8::String::New(json_string.c_str(), json_string.size())));
+  container()->element().dispatchEvent(event);
+}
+
+void BrowserPluginImpl::UpdateDOMAttribute(const std::string& attribute_name,
+                                           const std::string& attribute_value) {
+  if (!container())
+    return;
+
+  WebKit::WebElement element = container()->element();
+  WebKit::WebString web_attribute_name =
+      WebKit::WebString::fromUTF8(attribute_name);
+  if (!HasDOMAttribute(attribute_name) ||
+      (std::string(element.getAttribute(web_attribute_name).utf8()) !=
+          attribute_value)) {
+    element.setAttribute(web_attribute_name,
+        WebKit::WebString::fromUTF8(attribute_value));
+  }
+}
+void BrowserPluginImpl::RemoveDOMAttribute(const std::string& attribute_name) {
+  if (!container())
+    return;
+
+  container()->element().removeAttribute(
+      WebKit::WebString::fromUTF8(attribute_name));
+}
+
+std::string BrowserPluginImpl::GetDOMAttributeValue(
+    const std::string& attribute_name) const {
+  if (!container())
+    return "";
+
+  return container()->element().getAttribute(
+      WebKit::WebString::fromUTF8(attribute_name)).utf8();
+}
+
+bool BrowserPluginImpl::HasDOMAttribute(
+    const std::string& attribute_name) const {
+  if (!container())
+    return false;
+
+  return container()->element().hasAttribute(
+      WebKit::WebString::fromUTF8(attribute_name));
+}
+
+bool BrowserPluginImpl::HasNavigated() const {
+  return navigate_src_sent_;
+}
+
+bool BrowserPluginImpl::Send(IPC::Message* message) {
+  IPC::Message* wrapper_msg =
+      new BrowserPluginHostMsg_ForwardMessage(
+          render_view_routing_id_, instance_id_, *message);
+  delete message;
+  return browser_plugin_manager()->Send(wrapper_msg);
+}
+
+gfx::Point BrowserPluginImpl::ToLocalCoordinates(
+    const gfx::Point& point) const {
   if (container_)
     return container_->windowToLocalPoint(WebKit::WebPoint(point));
   return gfx::Point(point.x() - plugin_rect_.x(), point.y() - plugin_rect_.y());
 }
 
-void BrowserPlugin::updateGeometry(
+void BrowserPluginImpl::updateGeometry(
     const WebRect& window_rect,
     const WebRect& clip_rect,
     const WebVector<WebRect>& cut_outs_rects,
     bool is_visible) {
   int old_width = width();
   int old_height = height();
   plugin_rect_ = window_rect;
   // In AutoSize mode, guests don't care when the BrowserPlugin container is
   // resized. If |!resize_ack_received_|, then we are still waiting on a
   // previous resize to be ACK'ed and so we don't issue additional resizes
   // until the previous one is ACK'ed.
   // TODO(mthiesse): Assess the performance of calling GetAutoSizeAttribute() on
   // resize.
   if (!navigate_src_sent_ ||
       !resize_ack_received_ ||
       (old_width == window_rect.width && old_height == window_rect.height) ||
       GetAutoSizeAttribute()) {
     return;
   }
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
   PopulateResizeGuestParameters(&params, gfx::Size(width(), height()));
   resize_ack_received_ = false;
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       instance_id_,
       params));
 }
 
-void BrowserPlugin::SwapDamageBuffers() {
+void BrowserPluginImpl::SwapDamageBuffers() {
   current_damage_buffer_.reset(pending_damage_buffer_.release());
   resize_ack_received_ = true;
 }
 
-void BrowserPlugin::PopulateResizeGuestParameters(
+void BrowserPluginImpl::PopulateResizeGuestParameters(
     BrowserPluginHostMsg_ResizeGuest_Params* params,
     const gfx::Size& view_size) {
   params->view_size = view_size;
   params->scale_factor = GetDeviceScaleFactor();
 
   // In HW compositing mode, we do not need a damage buffer.
   if (compositing_enabled_)
     return;
 
   const size_t stride = skia::PlatformCanvasStrideForWidth(view_size.width());
   // Make sure the size of the damage buffer is at least four bytes so that we
   // can fit in a magic word to verify that the memory is shared correctly.
   size_t size =
       std::max(sizeof(unsigned int),
                static_cast<size_t>(view_size.height() *
                                    stride *
                                    GetDeviceScaleFactor() *
                                    GetDeviceScaleFactor()));
 
   params->damage_buffer_size = size;
   pending_damage_buffer_.reset(
       CreateDamageBuffer(size, &params->damage_buffer_handle));
   if (!pending_damage_buffer_.get())
     NOTREACHED();
   params->damage_buffer_sequence_id = ++damage_buffer_sequence_id_;
 }
 
-void BrowserPlugin::GetDamageBufferWithSizeParams(
+void BrowserPluginImpl::GetDamageBufferWithSizeParams(
     BrowserPluginHostMsg_AutoSize_Params* auto_size_params,
     BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params) {
   if (auto_size_params)
     PopulateAutoSizeParameters(auto_size_params, GetAutoSizeAttribute());
   gfx::Size view_size = (auto_size_params && auto_size_params->enable) ?
       auto_size_params->max_size : gfx::Size(width(), height());
   if (view_size.IsEmpty())
     return;
   resize_ack_received_ = false;
   PopulateResizeGuestParameters(resize_guest_params, view_size);
 }
 
 #if defined(OS_POSIX)
-base::SharedMemory* BrowserPlugin::CreateDamageBuffer(
+base::SharedMemory* BrowserPluginImpl::CreateDamageBuffer(
     const size_t size,
     base::SharedMemoryHandle* damage_buffer_handle) {
   scoped_ptr<base::SharedMemory> shared_buf(
       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(
           size).release());
 
   if (shared_buf.get()) {
     if (shared_buf->Map(size)) {
       // Insert the magic word.
       *static_cast<unsigned int*>(shared_buf->memory()) = 0xdeadbeef;
       shared_buf->ShareToProcess(base::GetCurrentProcessHandle(),
                                  damage_buffer_handle);
       return shared_buf.release();
     }
   }
   NOTREACHED();
   return NULL;
 }
 #elif defined(OS_WIN)
-base::SharedMemory* BrowserPlugin::CreateDamageBuffer(
+base::SharedMemory* BrowserPluginImpl::CreateDamageBuffer(
     const size_t size,
     base::SharedMemoryHandle* damage_buffer_handle) {
   scoped_ptr<base::SharedMemory> shared_buf(new base::SharedMemory());
 
   if (!shared_buf->CreateAndMapAnonymous(size)) {
     NOTREACHED() << "Buffer allocation failed";
     return NULL;
   }
-
   // Insert the magic word.
   *static_cast<unsigned int*>(shared_buf->memory()) = 0xdeadbeef;
   if (shared_buf->ShareToProcess(base::GetCurrentProcessHandle(),
                                  damage_buffer_handle))
     return shared_buf.release();
   NOTREACHED();
   return NULL;
 }
 #endif
 
-void BrowserPlugin::updateFocus(bool focused) {
+void BrowserPluginImpl::updateFocus(bool focused) {
   if (plugin_focused_ == focused)
     return;
 
   bool old_guest_focus_state = ShouldGuestBeFocused();
   plugin_focused_ = focused;
 
   if (ShouldGuestBeFocused() != old_guest_focus_state)
     UpdateGuestFocusState();
 }
 
-void BrowserPlugin::updateVisibility(bool visible) {
+void BrowserPluginImpl::updateVisibility(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   if (!navigate_src_sent_)
     return;
 
   if (compositing_helper_)
     compositing_helper_->UpdateVisibility(visible);
 
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetVisibility(
       render_view_routing_id_,
       instance_id_,
       visible));
 }
 
-bool BrowserPlugin::acceptsInputEvents() {
+bool BrowserPluginImpl::acceptsInputEvents() {
   return true;
 }
 
-bool BrowserPlugin::handleInputEvent(const WebKit::WebInputEvent& event,
-                                     WebKit::WebCursorInfo& cursor_info) {
+bool BrowserPluginImpl::handleInputEvent(const WebKit::WebInputEvent& event,
+                                         WebKit::WebCursorInfo& cursor_info) {
   if (guest_crashed_ || !navigate_src_sent_ ||
       event.type == WebKit::WebInputEvent::ContextMenu)
     return false;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 instance_id_,
                                                 plugin_rect_,
                                                 &event));
   cursor_.GetCursorInfo(&cursor_info);
   return true;
 }
 
-bool BrowserPlugin::handleDragStatusUpdate(WebKit::WebDragStatus drag_status,
-                                           const WebKit::WebDragData& drag_data,
-                                           WebKit::WebDragOperationsMask mask,
-                                           const WebKit::WebPoint& position,
-                                           const WebKit::WebPoint& screen) {
+bool BrowserPluginImpl::handleDragStatusUpdate(
+    WebKit::WebDragStatus drag_status,
+    const WebKit::WebDragData& drag_data,
+    WebKit::WebDragOperationsMask mask,
+    const WebKit::WebPoint& position,
+    const WebKit::WebPoint& screen) {
   if (guest_crashed_ || !navigate_src_sent_)
     return false;
-  browser_plugin_manager()->Send(
-      new BrowserPluginHostMsg_DragStatusUpdate(
-        render_view_routing_id_,
-        instance_id_,
-        drag_status,
-        WebDropData(drag_data),
-        mask,
-        position));
+  browser_plugin_manager()->Send(new BrowserPluginHostMsg_DragStatusUpdate(
+      render_view_routing_id_,
+      instance_id_,
+      drag_status,
+      WebDropData(drag_data),
+      mask,
+      position));
   return false;
 }
 
-void BrowserPlugin::didReceiveResponse(
+void BrowserPluginImpl::didReceiveResponse(
     const WebKit::WebURLResponse& response) {
 }
 
-void BrowserPlugin::didReceiveData(const char* data, int data_length) {
+void BrowserPluginImpl::didReceiveData(const char* data, int data_length) {
 }
 
-void BrowserPlugin::didFinishLoading() {
+void BrowserPluginImpl::didFinishLoading() {
 }
 
-void BrowserPlugin::didFailLoading(const WebKit::WebURLError& error) {
+void BrowserPluginImpl::didFailLoading(const WebKit::WebURLError& error) {
 }
 
-void BrowserPlugin::didFinishLoadingFrameRequest(const WebKit::WebURL& url,
-                                                 void* notify_data) {
+void BrowserPluginImpl::didFinishLoadingFrameRequest(const WebKit::WebURL& url,
+                                                     void* notify_data) {
 }
 
-void BrowserPlugin::didFailLoadingFrameRequest(
+void BrowserPluginImpl::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content