Browser Plugin: Implement BrowserPluginObserver.

content/renderer/browser_plugin/browser_plugin_bindings.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_bindings.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/utf_string_conversions.h"
-#include "content/renderer/browser_plugin/browser_plugin.h"
+#include "content/public/renderer/browser_plugin/browser_plugin_method_binding.h"
+#include "content/public/renderer/browser_plugin/browser_plugin_property_binding.h"
 #include "content/renderer/browser_plugin/browser_plugin_constants.h"
-#include "third_party/npapi/bindings/npapi.h"
+#include "content/renderer/browser_plugin/browser_plugin_impl.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDOMMessageEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "v8/include/v8.h"
 
@@ skipping 35 matching lines @@
   NPUTF8 *chars = static_cast<NPUTF8 *>(malloc(length));
   if (!chars) {
     VOID_TO_NPVARIANT(*variant);
     return false;
   }
   memcpy(chars, in.c_str(), length);
   STRINGN_TO_NPVARIANT(chars, length, *variant);
   return true;
 }
 
+bool MatchesName(const std::string& value, NPIdentifier name) {
+  return WebKit::WebBindings::getStringIdentifier(value.c_str()) == name;
+}
+
 //------------------------------------------------------------------------------
 // Implementations of NPClass functions.  These are here to:
 // - Implement src attribute.
 //------------------------------------------------------------------------------
 NPObject* BrowserPluginBindingsAllocate(NPP npp, NPClass* the_class) {
   return new BrowserPluginBindings::BrowserPluginNPObject;
 }
 
 void BrowserPluginBindingsDeallocate(NPObject* object) {
   BrowserPluginBindings::BrowserPluginNPObject* instance =
@@ skipping 96 matching lines @@
   &BrowserPluginBindingsInvokeDefault,
   &BrowserPluginBindingsHasProperty,
   &BrowserPluginBindingsGetProperty,
   &BrowserPluginBindingsSetProperty,
   NULL,
   &BrowserPluginBindingsEnumerate,
 };
 
 }  // namespace
 
-// BrowserPluginMethodBinding --------------------------------------------------
+// Method Bindings ------------------------------------------------------------
 
-class BrowserPluginMethodBinding {
+class BrowserPluginMethodBindingImpl : public BrowserPluginMethodBinding {
  public:
-  BrowserPluginMethodBinding(const char name[], uint32 arg_count)
-      : name_(name),
+  BrowserPluginMethodBindingImpl(BrowserPluginImpl* browser_plugin,
+                                 const char name[],
+                                 uint32 arg_count)
+      : browser_plugin_(browser_plugin),
+        name_(name),
         arg_count_(arg_count) {
   }
 
-  virtual ~BrowserPluginMethodBinding() {}
+  virtual ~BrowserPluginMethodBindingImpl() {}
 
-  bool MatchesName(NPIdentifier name) const {
-    return WebBindings::getStringIdentifier(name_.c_str()) == name;
+  BrowserPluginImpl* browser_plugin() const { return browser_plugin_; }
+
+  virtual const std::string& GetName() const OVERRIDE {
+    return name_;
   }
-
-  uint32 arg_count() const { return arg_count_; }
-
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) = 0;
+  virtual uint32 GetArgCount() const OVERRIDE { return arg_count_; }
 
  private:
+  BrowserPluginImpl* browser_plugin_;
   std::string name_;
   uint32 arg_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(BrowserPluginMethodBinding);
+  DISALLOW_COPY_AND_ASSIGN(BrowserPluginMethodBindingImpl);
 };
 
-class BrowserPluginBindingBack : public BrowserPluginMethodBinding {
+class BrowserPluginBindingBack : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingBack()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodBack, 0) {
+  BrowserPluginBindingBack(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodBack, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    bindings->instance()->Back();
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    browser_plugin()->Back();
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingBack);
 };
 
-class BrowserPluginBindingCanGoBack : public BrowserPluginMethodBinding {
+class BrowserPluginBindingCanGoBack : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingCanGoBack()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodCanGoBack, 0) {
+  BrowserPluginBindingCanGoBack(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodCanGoBack, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    BOOLEAN_TO_NPVARIANT(bindings->instance()->CanGoBack(), *result);
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    BOOLEAN_TO_NPVARIANT(browser_plugin()->CanGoBack(), *result);
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingCanGoBack);
 };
 
-class BrowserPluginBindingCanGoForward : public BrowserPluginMethodBinding {
+class BrowserPluginBindingCanGoForward : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingCanGoForward()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodCanGoForward, 0) {
+  BrowserPluginBindingCanGoForward(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodCanGoForward, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    BOOLEAN_TO_NPVARIANT(bindings->instance()->CanGoForward(), *result);
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    BOOLEAN_TO_NPVARIANT(browser_plugin()->CanGoForward(), *result);
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingCanGoForward);
 };
 
-class BrowserPluginBindingForward : public BrowserPluginMethodBinding {
+class BrowserPluginBindingForward : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingForward()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodForward, 0) {
+  BrowserPluginBindingForward(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodForward, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    bindings->instance()->Forward();
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    browser_plugin()->Forward();
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingForward);
 };
 
 // Note: This is a method that is used internally by the <webview> shim only.
 // This should not be exposed to developers.
-class BrowserPluginBindingGetRouteID : public BrowserPluginMethodBinding {
+class BrowserPluginBindingGetRouteID : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingGetRouteID()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodGetRouteId, 0) {
+  BrowserPluginBindingGetRouteID(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodGetRouteId, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    int route_id = bindings->instance()->guest_route_id();
-    INT32_TO_NPVARIANT(route_id, *result);
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    INT32_TO_NPVARIANT(browser_plugin()->guest_route_id(), *result);
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingGetRouteID);
 };
 
-class BrowserPluginBindingGetProcessID : public BrowserPluginMethodBinding {
+class BrowserPluginBindingGetProcessID :
+    public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingGetProcessID()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodGetProcessId, 0) {
+  BrowserPluginBindingGetProcessID(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodGetProcessId, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    int process_id = bindings->instance()->guest_process_id();
-    INT32_TO_NPVARIANT(process_id, *result);
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    INT32_TO_NPVARIANT(browser_plugin()->guest_process_id(), *result);
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingGetProcessID);
 };
 
-class BrowserPluginBindingGo : public BrowserPluginMethodBinding {
+class BrowserPluginBindingGo : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingGo()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodGo, 1) {
+  BrowserPluginBindingGo(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodGo, 1) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    bindings->instance()->Go(Int32FromNPVariant(args[0]));
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    browser_plugin()->Go(Int32FromNPVariant(args[0]));
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingGo);
 };
 
-class BrowserPluginBindingReload : public BrowserPluginMethodBinding {
+class BrowserPluginBindingReload : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingReload()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodReload, 0) {
+  BrowserPluginBindingReload(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodReload, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    bindings->instance()->Reload();
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    browser_plugin()->Reload();
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingReload);
 };
 
-class BrowserPluginBindingStop : public BrowserPluginMethodBinding {
+class BrowserPluginBindingStop : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingStop()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodStop, 0) {
+  BrowserPluginBindingStop(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodStop, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    bindings->instance()->Stop();
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    browser_plugin()->Stop();
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingStop);
 };
 
-class BrowserPluginBindingTerminate : public BrowserPluginMethodBinding {
+class BrowserPluginBindingTerminate : public BrowserPluginMethodBindingImpl {
  public:
-  BrowserPluginBindingTerminate()
-      : BrowserPluginMethodBinding(browser_plugin::kMethodTerminate, 0) {
+  BrowserPluginBindingTerminate(BrowserPluginImpl* browser_plugin)
+      : BrowserPluginMethodBindingImpl(browser_plugin,
+                                       browser_plugin::kMethodTerminate, 0) {
   }
 
-  virtual bool Invoke(BrowserPluginBindings* bindings,
-                      const NPVariant* args,
-                      NPVariant* result) OVERRIDE {
-    bindings->instance()->TerminateGuest();
+  virtual bool Invoke(const NPVariant* args, NPVariant* result) OVERRIDE {
+    browser_plugin()->TerminateGuest();
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingTerminate);
 };
 
-// BrowserPluginPropertyBinding ------------------------------------------------
+// Property Bindings ----------------------------------------------------------
 
-class BrowserPluginPropertyBinding {
+class BrowserPluginPropertyBindingImpl : public BrowserPluginPropertyBinding {
  public:
-  explicit BrowserPluginPropertyBinding(const char name[]) : name_(name) {}
-  virtual ~BrowserPluginPropertyBinding() {}
-  const std::string& name() const { return name_; }
-  bool MatchesName(NPIdentifier name) const {
-    return WebBindings::getStringIdentifier(name_.c_str()) == name;
+  BrowserPluginPropertyBindingImpl(BrowserPluginImpl* browser_plugin,
+                                   const char name[])
+      : browser_plugin_(browser_plugin),
+        name_(name) {}
+
+  virtual ~BrowserPluginPropertyBindingImpl() {}
+
+  BrowserPluginImpl* browser_plugin() const {
+    return browser_plugin_;
   }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) = 0;
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
-                           const NPVariant* variant) = 0;
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) = 0;
+
+  // BrowserPluginPropertyBinding implementation.
+  virtual const std::string& GetName() const OVERRIDE {
+    return name_;
+  }
   // Updates the DOM Attribute value with the current property value.
-  void UpdateDOMAttribute(BrowserPluginBindings* bindings,
-                          std::string new_value) {
-    bindings->instance()->UpdateDOMAttribute(name(), new_value);
+  void UpdateDOMAttribute(std::string new_value) {
+    browser_plugin_->UpdateDOMAttribute(name_, new_value);
   }
  protected:
   // Depending on where the attribute comes from it could be a string, int32,
   // or a double. Javascript tends to produce an Int32 or a String, but setting
   // the value from the developer tools console may also produce a Double...
   int IntFromNPVariant(const NPVariant* variant) {
     int value;
     switch (variant->type) {
       case NPVariantType_Double:
       case NPVariantType_Int32:
         value = Int32FromNPVariant(*variant);
         break;
       case NPVariantType_String:
         base::StringToInt(StringFromNPVariant(*variant), &value);
         break;
       default:
         value = 0;
         break;
     }
     return value;
   }
- private:
+
+ private:
+  BrowserPluginImpl* browser_plugin_;
   std::string name_;
 
-  DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBinding);
+  DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingImpl);
 };
 
 class BrowserPluginPropertyBindingAutoSize
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingAutoSize()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeAutoSize) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    bool auto_size = bindings->instance()->GetAutoSizeAttribute();
-    BOOLEAN_TO_NPVARIANT(auto_size, *result);
-    return true;
-  }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingAutoSize(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributeAutoSize) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    BOOLEAN_TO_NPVARIANT(browser_plugin()->GetAutoSizeAttribute(), *result);
+    return true;
+  }
+  virtual bool SetProperty(NPObject* np_obj,
                            const NPVariant* variant) OVERRIDE {
     std::string value = StringFromNPVariant(*variant);
-    if (!bindings->instance()->HasDOMAttribute(name())) {
-      UpdateDOMAttribute(bindings, value);
-      bindings->instance()->ParseAutoSizeAttribute();
+    if (!browser_plugin()->HasDOMAttribute(GetName())) {
+      UpdateDOMAttribute(value);
+      browser_plugin()->ParseAutoSizeAttribute();
     } else {
-      UpdateDOMAttribute(bindings, value);
-    }
-    return true;
-  }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
-    bindings->instance()->RemoveDOMAttribute(name());
-    bindings->instance()->ParseAutoSizeAttribute();
+      UpdateDOMAttribute(value);
+    }
+    return true;
+  }
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
+    browser_plugin()->RemoveDOMAttribute(GetName());
+    browser_plugin()->ParseAutoSizeAttribute();
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingAutoSize);
 };
 
 class BrowserPluginPropertyBindingContentWindow
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingContentWindow()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeContentWindow) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    NPObject* obj = bindings->instance()->GetContentWindow();
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingContentWindow(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(
+          browser_plugin,
+          browser_plugin::kAttributeContentWindow) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    NPObject* obj = browser_plugin()->GetContentWindow();
     if (obj) {
       result->type = NPVariantType_Object;
       result->value.objectValue = WebBindings::retainObject(obj);
     }
     return true;
   }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
+  virtual bool SetProperty(NPObject* np_obj,
                            const NPVariant* variant) OVERRIDE {
     return false;
   }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {}
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {}
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingContentWindow);
 };
 
 class BrowserPluginPropertyBindingMaxHeight
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingMaxHeight()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeMaxHeight) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    int max_height = bindings->instance()->GetMaxHeightAttribute();
-    INT32_TO_NPVARIANT(max_height, *result);
-    return true;
-  }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
-                           const NPVariant* variant) OVERRIDE {
-    int new_value = IntFromNPVariant(variant);
-    if (bindings->instance()->GetMaxHeightAttribute() != new_value) {
-      UpdateDOMAttribute(bindings, base::IntToString(new_value));
-      bindings->instance()->ParseSizeContraintsChanged();
-    }
-    return true;
-  }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
-    bindings->instance()->RemoveDOMAttribute(name());
-    bindings->instance()->ParseSizeContraintsChanged();
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingMaxHeight(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributeMaxHeight) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    INT32_TO_NPVARIANT(browser_plugin()->GetMaxHeightAttribute(), *result);
+    return true;
+  }
+  virtual bool SetProperty(NPObject* np_obj,
+                           const NPVariant* variant) OVERRIDE {
+    int new_value = IntFromNPVariant(variant);
+    if (browser_plugin()->GetMaxHeightAttribute() != new_value) {
+      UpdateDOMAttribute(base::IntToString(new_value));
+      browser_plugin()->ParseSizeContraintsChanged();
+    }
+    return true;
+  }
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
+    browser_plugin()->RemoveDOMAttribute(GetName());
+    browser_plugin()->ParseSizeContraintsChanged();
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMaxHeight);
 };
 
 class BrowserPluginPropertyBindingMaxWidth
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingMaxWidth()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeMaxWidth) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    int max_width = bindings->instance()->GetMaxWidthAttribute();
-    INT32_TO_NPVARIANT(max_width, *result);
-    return true;
-  }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
-                           const NPVariant* variant) OVERRIDE {
-    int new_value = IntFromNPVariant(variant);
-    if (bindings->instance()->GetMaxWidthAttribute() != new_value) {
-      UpdateDOMAttribute(bindings, base::IntToString(new_value));
-      bindings->instance()->ParseSizeContraintsChanged();
-    }
-    return true;
-  }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
-    bindings->instance()->RemoveDOMAttribute(name());
-    bindings->instance()->ParseSizeContraintsChanged();
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingMaxWidth(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributeMaxWidth) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    INT32_TO_NPVARIANT(browser_plugin()->GetMaxWidthAttribute(), *result);
+    return true;
+  }
+  virtual bool SetProperty(NPObject* np_obj,
+                           const NPVariant* variant) OVERRIDE {
+    int new_value = IntFromNPVariant(variant);
+    if (browser_plugin()->GetMaxWidthAttribute() != new_value) {
+      UpdateDOMAttribute(base::IntToString(new_value));
+      browser_plugin()->ParseSizeContraintsChanged();
+    }
+    return true;
+  }
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
+    browser_plugin()->RemoveDOMAttribute(GetName());
+    browser_plugin()->ParseSizeContraintsChanged();
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMaxWidth);
 };
 
 class BrowserPluginPropertyBindingMinHeight
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingMinHeight()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeMinHeight) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    int min_height = bindings->instance()->GetMinHeightAttribute();
-    INT32_TO_NPVARIANT(min_height, *result);
-    return true;
-  }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
-                           const NPVariant* variant) OVERRIDE {
-    int new_value = IntFromNPVariant(variant);
-    if (bindings->instance()->GetMinHeightAttribute() != new_value) {
-      UpdateDOMAttribute(bindings, base::IntToString(new_value));
-      bindings->instance()->ParseSizeContraintsChanged();
-    }
-    return true;
-  }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
-    bindings->instance()->RemoveDOMAttribute(name());
-    bindings->instance()->ParseSizeContraintsChanged();
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingMinHeight(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributeMinHeight) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    INT32_TO_NPVARIANT(browser_plugin()->GetMinHeightAttribute(), *result);
+    return true;
+  }
+  virtual bool SetProperty(NPObject* np_obj,
+                           const NPVariant* variant) OVERRIDE {
+    int new_value = IntFromNPVariant(variant);
+    if (browser_plugin()->GetMinHeightAttribute() != new_value) {
+      UpdateDOMAttribute(base::IntToString(new_value));
+      browser_plugin()->ParseSizeContraintsChanged();
+    }
+    return true;
+  }
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
+    browser_plugin()->RemoveDOMAttribute(GetName());
+    browser_plugin()->ParseSizeContraintsChanged();
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMinHeight);
 };
 
 class BrowserPluginPropertyBindingMinWidth
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingMinWidth()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeMinWidth) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    int min_width = bindings->instance()->GetMinWidthAttribute();
-    INT32_TO_NPVARIANT(min_width, *result);
-    return true;
-  }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
-                           const NPVariant* variant) OVERRIDE {
-    int new_value = IntFromNPVariant(variant);
-    if (bindings->instance()->GetMinWidthAttribute() != new_value) {
-      UpdateDOMAttribute(bindings, base::IntToString(new_value));
-      bindings->instance()->ParseSizeContraintsChanged();
-    }
-    return true;
-  }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
-    bindings->instance()->RemoveDOMAttribute(name());
-    bindings->instance()->ParseSizeContraintsChanged();
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingMinWidth(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributeMinWidth) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    INT32_TO_NPVARIANT(browser_plugin()->GetMinWidthAttribute(), *result);
+    return true;
+  }
+  virtual bool SetProperty(NPObject* np_obj,
+                           const NPVariant* variant) OVERRIDE {
+    int new_value = IntFromNPVariant(variant);
+    if (browser_plugin()->GetMinWidthAttribute() != new_value) {
+      UpdateDOMAttribute(base::IntToString(new_value));
+      browser_plugin()->ParseSizeContraintsChanged();
+    }
+    return true;
+  }
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
+    browser_plugin()->RemoveDOMAttribute(GetName());
+    browser_plugin()->ParseSizeContraintsChanged();
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMinWidth);
 };
 
 class BrowserPluginPropertyBindingName
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingName()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeName) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    std::string name = bindings->instance()->GetNameAttribute();
-    return StringToNPVariant(name, result);
-    return true;
-  }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingName(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributeName) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    StringToNPVariant(browser_plugin()->GetNameAttribute(), result);
+    return true;
+  }
+  virtual bool SetProperty(NPObject* np_obj,
                            const NPVariant* variant) OVERRIDE {
     std::string new_value = StringFromNPVariant(*variant);
-    if (bindings->instance()->GetNameAttribute() != new_value) {
-      UpdateDOMAttribute(bindings, new_value);
-      bindings->instance()->ParseNameAttribute();
-    }
-    return true;
-  }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
-    bindings->instance()->RemoveDOMAttribute(name());
-    bindings->instance()->ParseNameAttribute();
+    if (browser_plugin()->GetNameAttribute() != new_value) {
+      UpdateDOMAttribute(new_value);
+      browser_plugin()->ParseNameAttribute();
+    }
+    return true;
+  }
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
+    browser_plugin()->RemoveDOMAttribute(GetName());
+    browser_plugin()->ParseNameAttribute();
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingName);
 };
 
 class BrowserPluginPropertyBindingPartition
-    : public BrowserPluginPropertyBinding {
- public:
-  BrowserPluginPropertyBindingPartition()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributePartition) {
-  }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    std::string partition_id = bindings->instance()->GetPartitionAttribute();
-    return StringToNPVariant(partition_id, result);
-  }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
+    : public BrowserPluginPropertyBindingImpl {
+ public:
+  BrowserPluginPropertyBindingPartition(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributePartition) {
+  }
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    return StringToNPVariant(browser_plugin()->GetPartitionAttribute(), result);
+  }
+  virtual bool SetProperty(NPObject* np_obj,
                            const NPVariant* variant) OVERRIDE {
     std::string new_value = StringFromNPVariant(*variant);
-    std::string old_value = bindings->instance()->GetPartitionAttribute();
+    std::string old_value = browser_plugin()->GetPartitionAttribute();
     if (old_value != new_value) {
-      UpdateDOMAttribute(bindings, new_value);
+      UpdateDOMAttribute(new_value);
       std::string error_message;
-      if (!bindings->instance()->ParsePartitionAttribute(&error_message)) {
+      if (!browser_plugin()->ParsePartitionAttribute(&error_message)) {
         WebBindings::setException(
             np_obj, static_cast<const NPUTF8 *>(error_message.c_str()));
         // Reset to old value on error.
-        UpdateDOMAttribute(bindings, old_value);
+        UpdateDOMAttribute(old_value);
         return false;
       }
     }
     return true;
   }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
     std::string error_message;
-    if (bindings->instance()->CanRemovePartitionAttribute(&error_message)) {
-      bindings->instance()->RemoveDOMAttribute(name());
+    if (browser_plugin()->CanRemovePartitionAttribute(&error_message)) {
+      browser_plugin()->RemoveDOMAttribute(GetName());
     } else {
       WebBindings::setException(
           np_obj, static_cast<const NPUTF8 *>(error_message.c_str()));
     }
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingPartition);
 };
 
-class BrowserPluginPropertyBindingSrc : public BrowserPluginPropertyBinding {
+class BrowserPluginPropertyBindingSrc :
+    public BrowserPluginPropertyBindingImpl {
  public:
-  BrowserPluginPropertyBindingSrc()
-      : BrowserPluginPropertyBinding(browser_plugin::kAttributeSrc) {
+  BrowserPluginPropertyBindingSrc(BrowserPluginImpl* browser_plugin) :
+      BrowserPluginPropertyBindingImpl(browser_plugin,
+                                       browser_plugin::kAttributeSrc) {
   }
-  virtual bool GetProperty(BrowserPluginBindings* bindings,
-                           NPVariant* result) OVERRIDE {
-    std::string src = bindings->instance()->GetSrcAttribute();
-    return StringToNPVariant(src, result);
+  virtual bool GetProperty(NPVariant* result) OVERRIDE {
+    return StringToNPVariant(browser_plugin()->GetSrcAttribute(), result);
   }
-  virtual bool SetProperty(BrowserPluginBindings* bindings,
-                           NPObject* np_obj,
+  virtual bool SetProperty(NPObject* np_obj,
                            const NPVariant* variant) OVERRIDE {
     std::string new_value = StringFromNPVariant(*variant);
     // We should not be issuing navigation IPCs if we attempt to set the
     // src property to the empty string. Instead, we want to simply restore
     // the src attribute back to its old value.
     if (new_value.empty()) {
-      RemoveProperty(bindings, np_obj);
+      RemoveProperty(np_obj);
       return true;
     }
-    std::string old_value = bindings->instance()->GetSrcAttribute();
-    bool guest_crashed = bindings->instance()->guest_crashed();
+    std::string old_value = browser_plugin()->GetSrcAttribute();
+    bool guest_crashed = browser_plugin()->guest_crashed();
     if ((old_value != new_value) || guest_crashed) {
       // If the new value was empty then we're effectively resetting the
       // attribute to the old value here. This will be picked up by <webview>'s
       // mutation observer and will restore the src attribute after it has been
       // removed.
-      UpdateDOMAttribute(bindings, new_value);
+      UpdateDOMAttribute(new_value);
       std::string error_message;
-      if (!bindings->instance()->ParseSrcAttribute(&error_message)) {
+      if (!browser_plugin()->ParseSrcAttribute(&error_message)) {
         WebBindings::setException(
             np_obj, static_cast<const NPUTF8 *>(error_message.c_str()));
         // Reset to old value on error.
-        UpdateDOMAttribute(bindings, old_value);
+        UpdateDOMAttribute(old_value);
         return false;
       }
     }
     return true;
   }
-  virtual void RemoveProperty(BrowserPluginBindings* bindings,
-                              NPObject* np_obj) OVERRIDE {
-    std::string old_value = bindings->instance()->GetSrcAttribute();
+  virtual void RemoveProperty(NPObject* np_obj) OVERRIDE {
+    std::string old_value = browser_plugin()->GetSrcAttribute();
     // Remove the DOM attribute to trigger the mutation observer when it is
     // restored to its original value again.
-    bindings->instance()->RemoveDOMAttribute(name());
-    UpdateDOMAttribute(bindings, old_value);
+    browser_plugin()->RemoveDOMAttribute(GetName());
+    UpdateDOMAttribute(old_value);
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingSrc);
 };
 
 
 // BrowserPluginBindings ------------------------------------------------------
 
 BrowserPluginBindings::BrowserPluginNPObject::BrowserPluginNPObject() {
 }
 
 BrowserPluginBindings::BrowserPluginNPObject::~BrowserPluginNPObject() {
 }
 
-BrowserPluginBindings::BrowserPluginBindings(BrowserPlugin* instance)
+BrowserPluginBindings::BrowserPluginBindings(BrowserPluginImpl* instance)
     : instance_(instance),
       np_object_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   NPObject* obj =
       WebBindings::createObject(NULL, &browser_plugin_message_class);
   np_object_ = static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(obj);
   np_object_->message_channel = weak_ptr_factory_.GetWeakPtr();
 
-  method_bindings_.push_back(new BrowserPluginBindingBack);
-  method_bindings_.push_back(new BrowserPluginBindingCanGoBack);
-  method_bindings_.push_back(new BrowserPluginBindingCanGoForward);
-  method_bindings_.push_back(new BrowserPluginBindingForward);
-  method_bindings_.push_back(new BrowserPluginBindingGetProcessID);
-  method_bindings_.push_back(new BrowserPluginBindingGetRouteID);
-  method_bindings_.push_back(new BrowserPluginBindingGo);
-  method_bindings_.push_back(new BrowserPluginBindingReload);
-  method_bindings_.push_back(new BrowserPluginBindingStop);
-  method_bindings_.push_back(new BrowserPluginBindingTerminate);
+  method_bindings_.push_back(new BrowserPluginBindingBack(instance));
+  method_bindings_.push_back(new BrowserPluginBindingCanGoBack(instance));
+  method_bindings_.push_back(new BrowserPluginBindingCanGoForward(instance));
+  method_bindings_.push_back(new BrowserPluginBindingForward(instance));
+  method_bindings_.push_back(new BrowserPluginBindingGetProcessID(instance));
+  method_bindings_.push_back(new BrowserPluginBindingGetRouteID(instance));
+  method_bindings_.push_back(new BrowserPluginBindingGo(instance));
+  method_bindings_.push_back(new BrowserPluginBindingReload(instance));
+  method_bindings_.push_back(new BrowserPluginBindingStop(instance));
+  method_bindings_.push_back(new BrowserPluginBindingTerminate(instance));
 
-  property_bindings_.push_back(new BrowserPluginPropertyBindingAutoSize);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingContentWindow);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingMaxHeight);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingMaxWidth);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingMinHeight);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingMinWidth);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingName);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingPartition);
-  property_bindings_.push_back(new BrowserPluginPropertyBindingSrc);
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingAutoSize(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingContentWindow(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingMaxHeight(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingMaxWidth(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingMinHeight(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingMinWidth(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingName(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingPartition(instance));
+  property_bindings_.push_back(
+      new BrowserPluginPropertyBindingSrc(instance));
 }
 
 BrowserPluginBindings::~BrowserPluginBindings() {
   WebBindings::releaseObject(np_object_);
 }
 
 bool BrowserPluginBindings::HasMethod(NPIdentifier name) const {
   for (BindingList::const_iterator iter = method_bindings_.begin();
        iter != method_bindings_.end();
        ++iter) {
-    if ((*iter)->MatchesName(name))
+    BrowserPluginMethodBinding* method = *iter;
+    if (MatchesName(method->GetName(), name))
       return true;
   }
   return false;
 }
 
 bool BrowserPluginBindings::InvokeMethod(NPIdentifier name,
                                          const NPVariant* args,
                                          uint32 arg_count,
                                          NPVariant* result) {
   for (BindingList::iterator iter = method_bindings_.begin();
        iter != method_bindings_.end();
        ++iter) {
-    if ((*iter)->MatchesName(name) && (*iter)->arg_count() == arg_count)
-      return (*iter)->Invoke(this, args, result);
+    BrowserPluginMethodBinding* method = *iter;
+    if (MatchesName(method->GetName(), name) &&
+        method->GetArgCount() == arg_count)
+      return method->Invoke(args, result);
   }
   return false;
 }
 
 bool BrowserPluginBindings::HasProperty(NPIdentifier name) const {
   for (PropertyBindingList::const_iterator iter = property_bindings_.begin();
        iter != property_bindings_.end();
        ++iter) {
-    if ((*iter)->MatchesName(name))
+    BrowserPluginPropertyBinding* property = *iter;
+    if (MatchesName(property->GetName(), name))
       return true;
   }
   return false;
 }
 
 bool BrowserPluginBindings::SetProperty(NPObject* np_obj,
                                         NPIdentifier name,
                                         const NPVariant* variant) {
   for (PropertyBindingList::iterator iter = property_bindings_.begin();
        iter != property_bindings_.end();
        ++iter) {
-    if ((*iter)->MatchesName(name)) {
-      if ((*iter)->SetProperty(this, np_obj, variant)) {
+    BrowserPluginPropertyBinding* property = *iter;
+    if (MatchesName(property->GetName(), name)) {
+      if (property->SetProperty(np_obj, variant))
         return true;
-      }
       break;
     }
   }
   return false;
 }
 
 bool BrowserPluginBindings::RemoveProperty(NPObject* np_obj,
                                            NPIdentifier name) {
   for (PropertyBindingList::iterator iter = property_bindings_.begin();
        iter != property_bindings_.end();
        ++iter) {
-    if ((*iter)->MatchesName(name)) {
-      (*iter)->RemoveProperty(this, np_obj);
+    BrowserPluginPropertyBinding* property = *iter;
+    if (MatchesName(property->GetName(), name)) {
+      property->RemoveProperty(np_obj);
       return true;
     }
   }
   return false;
 }
 
 bool BrowserPluginBindings::GetProperty(NPIdentifier name, NPVariant* result) {
   for (PropertyBindingList::iterator iter = property_bindings_.begin();
        iter != property_bindings_.end();
        ++iter) {
-    if ((*iter)->MatchesName(name))
-      return (*iter)->GetProperty(this, result);
+    BrowserPluginPropertyBinding* property = *iter;
+    if (MatchesName(property->GetName(), name))
+      return property->GetProperty(result);
   }
   return false;
 }
 
+void BrowserPluginBindings::AddMethodBinding(
+    BrowserPluginMethodBinding* method_binding) {
+  method_bindings_.push_back(method_binding);
+}
+
+void BrowserPluginBindings::AddPropertyBinding(
+    BrowserPluginPropertyBinding* property_binding) {
+  property_bindings_.push_back(property_binding);
+}
+
 }  // namespace content