content/renderer/browser_plugin/browser_plugin_bindings.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/browser_plugin/browser_plugin_bindings.h"
   6
   7 #include <cstdlib>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "base/message_loop.h"
  12 #include "base/string16.h"
  13 #include "base/string_number_conversions.h"
  14 #include "base/string_split.h"
  15 #include "base/utf_string_conversions.h"
  16 #include "content/renderer/browser_plugin/browser_plugin.h"
  17 #include "third_party/npapi/bindings/npapi.h"
  18 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
  19 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
  20 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDOMMessageEvent.h"
  21 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
  22 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
  23 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
  24 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
  25 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
  26 #include "v8/include/v8.h"
  27
  28 using WebKit::WebBindings;
  29 using WebKit::WebElement;
  30 using WebKit::WebDOMEvent;
  31 using WebKit::WebDOMMessageEvent;
  32 using WebKit::WebPluginContainer;
  33 using WebKit::WebString;
  34
  35 namespace content {
  36
  37 namespace {
  38
  39 // Method bindings.
  40 const char kMethodBack[] = "back";
  41 const char kMethodCanGoBack[] = "canGoBack";
  42 const char kMethodCanGoForward[] = "canGoForward";
  43 const char kMethodForward[] = "forward";
  44 const char kMethodGetProcessId[] = "getProcessId";
  45 const char kMethodGo[] = "go";
  46 const char kMethodReload[] = "reload";
  47 const char kMethodStop[] = "stop";
  48 const char kMethodTerminate[] = "terminate";
  49
  50 // Attributes.
  51 const char kAttributeAutoSize[] = "autoSize";
  52 const char kAttributeContentWindow[] = "contentWindow";
  53 const char kAttributeMaxHeight[] = "maxHeight";
  54 const char kAttributeMaxWidth[] = "maxWidth";
  55 const char kAttributeMinHeight[] = "minHeight";
  56 const char kAttributeMinWidth[] = "minWidth";
  57 const char kAttributePartition[] = "partition";
  58 const char kAttributeSrc[] = "src";
  59
  60 BrowserPluginBindings* GetBindings(NPObject* object) {
  61   return static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(object)->
  62       message_channel;
  63 }
  64
  65 int Int32FromNPVariant(const NPVariant& variant) {
  66   if (NPVARIANT_IS_INT32(variant))
  67     return NPVARIANT_TO_INT32(variant);
  68
  69   if (NPVARIANT_IS_DOUBLE(variant))
  70     return NPVARIANT_TO_DOUBLE(variant);
  71
  72   return 0;
  73 }
  74
  75 std::string StringFromNPVariant(const NPVariant& variant) {
  76   if (!NPVARIANT_IS_STRING(variant))
  77     return std::string();
  78   const NPString& np_string = NPVARIANT_TO_STRING(variant);
  79   return std::string(np_string.UTF8Characters, np_string.UTF8Length);
  80 }
  81
  82 bool StringToNPVariant(const std::string &in, NPVariant *variant) {
  83   size_t length = in.size();
  84   NPUTF8 *chars = static_cast<NPUTF8 *>(malloc(length));
  85   if (!chars) {
  86     VOID_TO_NPVARIANT(*variant);
  87     return false;
  88   }
  89   memcpy(chars, in.c_str(), length);
  90   STRINGN_TO_NPVARIANT(chars, length, *variant);
  91   return true;
  92 }
  93
  94 //------------------------------------------------------------------------------
  95 // Implementations of NPClass functions.  These are here to:
  96 // - Implement src attribute.
  97 //------------------------------------------------------------------------------
  98 NPObject* BrowserPluginBindingsAllocate(NPP npp, NPClass* the_class) {
  99   return new BrowserPluginBindings::BrowserPluginNPObject;
 100 }
 101
 102 void BrowserPluginBindingsDeallocate(NPObject* object) {
 103   BrowserPluginBindings::BrowserPluginNPObject* instance =
 104       static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(object);
 105   delete instance;
 106 }
 107
 108 bool BrowserPluginBindingsHasMethod(NPObject* np_obj, NPIdentifier name) {
 109   if (!np_obj)
 110     return false;
 111
 112   BrowserPluginBindings* bindings = GetBindings(np_obj);
 113   if (!bindings)
 114     return false;
 115
 116   return bindings->HasMethod(name);
 117 }
 118
 119 bool BrowserPluginBindingsInvoke(NPObject* np_obj, NPIdentifier name,
 120                                  const NPVariant* args, uint32 arg_count,
 121                                  NPVariant* result) {
 122   if (!np_obj)
 123     return false;
 124
 125   BrowserPluginBindings* bindings = GetBindings(np_obj);
 126   if (!bindings)
 127     return false;
 128
 129   return bindings->InvokeMethod(name, args, arg_count, result);
 130 }
 131
 132 bool BrowserPluginBindingsInvokeDefault(NPObject* np_obj,
 133                                         const NPVariant* args,
 134                                         uint32 arg_count,
 135                                         NPVariant* result) {
 136   NOTIMPLEMENTED();
 137   return false;
 138 }
 139
 140 bool BrowserPluginBindingsHasProperty(NPObject* np_obj, NPIdentifier name) {
 141   if (!np_obj)
 142     return false;
 143
 144   BrowserPluginBindings* bindings = GetBindings(np_obj);
 145   if (!bindings)
 146     return false;
 147
 148   return bindings->HasProperty(name);
 149 }
 150
 151 bool BrowserPluginBindingsGetProperty(NPObject* np_obj, NPIdentifier name,
 152                                       NPVariant* result) {
 153   if (!np_obj)
 154     return false;
 155
 156   if (!result)
 157     return false;
 158
 159   // All attributes from here on rely on the bindings, so retrieve it once and
 160   // return on failure.
 161   BrowserPluginBindings* bindings = GetBindings(np_obj);
 162   if (!bindings)
 163     return false;
 164
 165   return bindings->GetProperty(name, result);
 166 }
 167
 168 bool BrowserPluginBindingsSetProperty(NPObject* np_obj, NPIdentifier name,
 169                                       const NPVariant* variant) {
 170   if (!np_obj)
 171     return false;
 172   if (!variant)
 173     return false;
 174
 175   // All attributes from here on rely on the bindings, so retrieve it once and
 176   // return on failure.
 177   BrowserPluginBindings* bindings = GetBindings(np_obj);
 178   if (!bindings)
 179     return false;
 180
 181   return bindings->SetProperty(np_obj, name, variant);
 182 }
 183
 184 bool BrowserPluginBindingsEnumerate(NPObject *np_obj, NPIdentifier **value,
 185                                     uint32_t *count) {
 186   NOTIMPLEMENTED();
 187   return true;
 188 }
 189
 190 NPClass browser_plugin_message_class = {
 191   NP_CLASS_STRUCT_VERSION,
 192   &BrowserPluginBindingsAllocate,
 193   &BrowserPluginBindingsDeallocate,
 194   NULL,
 195   &BrowserPluginBindingsHasMethod,
 196   &BrowserPluginBindingsInvoke,
 197   &BrowserPluginBindingsInvokeDefault,
 198   &BrowserPluginBindingsHasProperty,
 199   &BrowserPluginBindingsGetProperty,
 200   &BrowserPluginBindingsSetProperty,
 201   NULL,
 202   &BrowserPluginBindingsEnumerate,
 203 };
 204
 205 }  // namespace
 206
 207 // BrowserPluginMethodBinding --------------------------------------------------
 208
 209 class BrowserPluginMethodBinding {
 210  public:
 211   BrowserPluginMethodBinding(const char name[], uint32 arg_count)
 212       : name_(name),
 213         arg_count_(arg_count) {
 214   }
 215
 216   virtual ~BrowserPluginMethodBinding() {}
 217
 218   bool MatchesName(NPIdentifier name) const {
 219     return WebBindings::getStringIdentifier(name_.c_str()) == name;
 220   }
 221
 222   uint32 arg_count() const { return arg_count_; }
 223
 224   virtual bool Invoke(BrowserPluginBindings* bindings,
 225                       const NPVariant* args,
 226                       NPVariant* result) = 0;
 227
 228  private:
 229   std::string name_;
 230   uint32 arg_count_;
 231
 232   DISALLOW_COPY_AND_ASSIGN(BrowserPluginMethodBinding);
 233 };
 234
 235 class BrowserPluginBindingBack : public BrowserPluginMethodBinding {
 236  public:
 237   BrowserPluginBindingBack()
 238       : BrowserPluginMethodBinding(kMethodBack, 0) {
 239   }
 240
 241   virtual bool Invoke(BrowserPluginBindings* bindings,
 242                       const NPVariant* args,
 243                       NPVariant* result) OVERRIDE {
 244     bindings->instance()->Back();
 245     return true;
 246   }
 247
 248  private:
 249   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingBack);
 250 };
 251
 252 class BrowserPluginBindingCanGoBack : public BrowserPluginMethodBinding {
 253  public:
 254   BrowserPluginBindingCanGoBack()
 255       : BrowserPluginMethodBinding(kMethodCanGoBack, 0) {
 256   }
 257
 258   virtual bool Invoke(BrowserPluginBindings* bindings,
 259                       const NPVariant* args,
 260                       NPVariant* result) OVERRIDE {
 261     BOOLEAN_TO_NPVARIANT(bindings->instance()->CanGoBack(), *result);
 262     return true;
 263   }
 264
 265  private:
 266   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingCanGoBack);
 267 };
 268
 269 class BrowserPluginBindingCanGoForward : public BrowserPluginMethodBinding {
 270  public:
 271   BrowserPluginBindingCanGoForward()
 272       : BrowserPluginMethodBinding(kMethodCanGoForward, 0) {
 273   }
 274
 275   virtual bool Invoke(BrowserPluginBindings* bindings,
 276                       const NPVariant* args,
 277                       NPVariant* result) OVERRIDE {
 278     BOOLEAN_TO_NPVARIANT(bindings->instance()->CanGoForward(), *result);
 279     return true;
 280   }
 281
 282  private:
 283   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingCanGoForward);
 284 };
 285
 286 class BrowserPluginBindingForward : public BrowserPluginMethodBinding {
 287  public:
 288   BrowserPluginBindingForward()
 289       : BrowserPluginMethodBinding(kMethodForward, 0) {
 290   }
 291
 292   virtual bool Invoke(BrowserPluginBindings* bindings,
 293                       const NPVariant* args,
 294                       NPVariant* result) OVERRIDE {
 295     bindings->instance()->Forward();
 296     return true;
 297   }
 298
 299  private:
 300   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingForward);
 301 };
 302
 303 class BrowserPluginBindingGetProcessID : public BrowserPluginMethodBinding {
 304  public:
 305   BrowserPluginBindingGetProcessID()
 306       : BrowserPluginMethodBinding(kMethodGetProcessId, 0) {
 307   }
 308
 309   virtual bool Invoke(BrowserPluginBindings* bindings,
 310                       const NPVariant* args,
 311                       NPVariant* result) OVERRIDE {
 312     int process_id = bindings->instance()->process_id();
 313     INT32_TO_NPVARIANT(process_id, *result);
 314     return true;
 315   }
 316
 317  private:
 318   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingGetProcessID);
 319 };
 320
 321 class BrowserPluginBindingGo : public BrowserPluginMethodBinding {
 322  public:
 323   BrowserPluginBindingGo()
 324       : BrowserPluginMethodBinding(kMethodGo, 1) {
 325   }
 326
 327   virtual bool Invoke(BrowserPluginBindings* bindings,
 328                       const NPVariant* args,
 329                       NPVariant* result) OVERRIDE {
 330     bindings->instance()->Go(Int32FromNPVariant(args[0]));
 331     return true;
 332   }
 333
 334  private:
 335   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingGo);
 336 };
 337
 338 class BrowserPluginBindingReload : public BrowserPluginMethodBinding {
 339  public:
 340   BrowserPluginBindingReload()
 341       : BrowserPluginMethodBinding(kMethodReload, 0) {
 342   }
 343
 344   virtual bool Invoke(BrowserPluginBindings* bindings,
 345                       const NPVariant* args,
 346                       NPVariant* result) OVERRIDE {
 347     bindings->instance()->Reload();
 348     return true;
 349   }
 350
 351  private:
 352   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingReload);
 353 };
 354
 355 class BrowserPluginBindingStop : public BrowserPluginMethodBinding {
 356  public:
 357   BrowserPluginBindingStop()
 358       : BrowserPluginMethodBinding(kMethodStop, 0) {
 359   }
 360
 361   virtual bool Invoke(BrowserPluginBindings* bindings,
 362                       const NPVariant* args,
 363                       NPVariant* result) OVERRIDE {
 364     bindings->instance()->Stop();
 365     return true;
 366   }
 367
 368  private:
 369   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingStop);
 370 };
 371
 372 class BrowserPluginBindingTerminate : public BrowserPluginMethodBinding {
 373  public:
 374   BrowserPluginBindingTerminate()
 375       : BrowserPluginMethodBinding(kMethodTerminate, 0) {
 376   }
 377
 378   virtual bool Invoke(BrowserPluginBindings* bindings,
 379                       const NPVariant* args,
 380                       NPVariant* result) OVERRIDE {
 381     bindings->instance()->TerminateGuest();
 382     return true;
 383   }
 384
 385  private:
 386   DISALLOW_COPY_AND_ASSIGN(BrowserPluginBindingTerminate);
 387 };
 388
 389 // BrowserPluginPropertyBinding ------------------------------------------------
 390
 391 class BrowserPluginPropertyBinding {
 392  public:
 393   explicit BrowserPluginPropertyBinding(const char name[]) : name_(name) {
 394   }
 395   virtual ~BrowserPluginPropertyBinding() {}
 396   const std::string& name() const { return name_; }
 397   bool MatchesName(NPIdentifier name) const {
 398     return WebBindings::getStringIdentifier(name_.c_str()) == name;
 399   }
 400   virtual bool GetProperty(BrowserPluginBindings* bindings,
 401                            NPVariant* result) = 0;
 402   virtual bool SetProperty(BrowserPluginBindings* bindings,
 403                            NPObject* np_obj,
 404                            const NPVariant* variant) = 0;
 405   virtual std::string GetDOMAttributeValue(BrowserPlugin* browser_plugin) = 0;
 406   // Updates the DOM Attribute value with the current property value.
 407   void UpdateDOMAttribute(BrowserPluginBindings* bindings) {
 408     bindings->instance()->UpdateDOMAttribute(name(),
 409         GetDOMAttributeValue(bindings->instance()));
 410   }
 411  private:
 412   std::string name_;
 413
 414   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBinding);
 415 };
 416
 417 class BrowserPluginPropertyBindingAutoSize
 418     : public BrowserPluginPropertyBinding {
 419  public:
 420   BrowserPluginPropertyBindingAutoSize() :
 421       BrowserPluginPropertyBinding(kAttributeAutoSize) {
 422   }
 423   virtual bool GetProperty(BrowserPluginBindings* bindings,
 424                            NPVariant* result) OVERRIDE {
 425     bool auto_size = bindings->instance()->auto_size_attribute();
 426     BOOLEAN_TO_NPVARIANT(auto_size, *result);
 427     return true;
 428   }
 429   virtual bool SetProperty(BrowserPluginBindings* bindings,
 430                            NPObject* np_obj,
 431                            const NPVariant* variant) OVERRIDE {
 432     bool auto_size = NPVARIANT_TO_BOOLEAN(*variant);
 433     bindings->instance()->SetAutoSizeAttribute(auto_size);
 434     return true;
 435   }
 436   virtual std::string GetDOMAttributeValue(
 437       BrowserPlugin* browser_plugin) OVERRIDE {
 438     return browser_plugin->auto_size_attribute() ? "true" : "false";
 439   }
 440  private:
 441   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingAutoSize);
 442 };
 443
 444 class BrowserPluginPropertyBindingContentWindow
 445     : public BrowserPluginPropertyBinding {
 446  public:
 447   BrowserPluginPropertyBindingContentWindow() :
 448       BrowserPluginPropertyBinding(kAttributeContentWindow) {
 449   }
 450   virtual bool GetProperty(BrowserPluginBindings* bindings,
 451                            NPVariant* result) OVERRIDE {
 452     NPObject* obj = bindings->instance()->GetContentWindow();
 453     if (obj) {
 454       result->type = NPVariantType_Object;
 455       result->value.objectValue = WebBindings::retainObject(obj);
 456     }
 457     return true;
 458   }
 459   virtual bool SetProperty(BrowserPluginBindings* bindings,
 460                            NPObject* np_obj,
 461                            const NPVariant* variant) OVERRIDE {
 462     return false;
 463   }
 464   virtual std::string GetDOMAttributeValue(BrowserPlugin* browser_plugin) {
 465     return std::string();
 466   }
 467  private:
 468   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingContentWindow);
 469 };
 470
 471 class BrowserPluginPropertyBindingMaxHeight
 472     : public BrowserPluginPropertyBinding {
 473  public:
 474   BrowserPluginPropertyBindingMaxHeight() :
 475       BrowserPluginPropertyBinding(kAttributeMaxHeight) {
 476   }
 477   virtual bool GetProperty(BrowserPluginBindings* bindings,
 478                            NPVariant* result) OVERRIDE {
 479     int max_height = bindings->instance()->max_height_attribute();
 480     INT32_TO_NPVARIANT(max_height, *result);
 481     return true;
 482   }
 483   virtual bool SetProperty(BrowserPluginBindings* bindings,
 484                            NPObject* np_obj,
 485                            const NPVariant* variant) OVERRIDE {
 486     int max_height = Int32FromNPVariant(*variant);
 487     bindings->instance()->SetMaxHeightAttribute(max_height);
 488     return true;
 489   }
 490   virtual std::string GetDOMAttributeValue(
 491       BrowserPlugin* browser_plugin) OVERRIDE {
 492     return base::IntToString(browser_plugin->max_height_attribute());
 493   }
 494  private:
 495   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMaxHeight);
 496 };
 497
 498 class BrowserPluginPropertyBindingMaxWidth
 499     : public BrowserPluginPropertyBinding {
 500  public:
 501   BrowserPluginPropertyBindingMaxWidth() :
 502       BrowserPluginPropertyBinding(kAttributeMaxWidth) {
 503   }
 504   virtual bool GetProperty(BrowserPluginBindings* bindings,
 505                            NPVariant* result) OVERRIDE {
 506     int max_width = bindings->instance()->max_width_attribute();
 507     INT32_TO_NPVARIANT(max_width, *result);
 508     return true;
 509   }
 510   virtual bool SetProperty(BrowserPluginBindings* bindings,
 511                            NPObject* np_obj,
 512                            const NPVariant* variant) OVERRIDE {
 513     int max_width = Int32FromNPVariant(*variant);
 514     bindings->instance()->SetMaxWidthAttribute(max_width);
 515     return true;
 516   }
 517   virtual std::string GetDOMAttributeValue(
 518       BrowserPlugin* browser_plugin) OVERRIDE {
 519     return base::IntToString(browser_plugin->max_width_attribute());
 520   }
 521  private:
 522   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMaxWidth);
 523 };
 524
 525 class BrowserPluginPropertyBindingMinHeight
 526     : public BrowserPluginPropertyBinding {
 527  public:
 528   BrowserPluginPropertyBindingMinHeight() :
 529       BrowserPluginPropertyBinding(kAttributeMinHeight) {
 530   }
 531   virtual bool GetProperty(BrowserPluginBindings* bindings,
 532                            NPVariant* result) OVERRIDE {
 533     int min_height = bindings->instance()->min_height_attribute();
 534     INT32_TO_NPVARIANT(min_height, *result);
 535     return true;
 536   }
 537   virtual bool SetProperty(BrowserPluginBindings* bindings,
 538                            NPObject* np_obj,
 539                            const NPVariant* variant) OVERRIDE {
 540     int min_height = Int32FromNPVariant(*variant);
 541     bindings->instance()->SetMinHeightAttribute(min_height);
 542     return true;
 543   }
 544   virtual std::string GetDOMAttributeValue(
 545       BrowserPlugin* browser_plugin) OVERRIDE {
 546     return base::IntToString(browser_plugin->min_height_attribute());
 547   }
 548  private:
 549   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMinHeight);
 550 };
 551
 552 class BrowserPluginPropertyBindingMinWidth
 553     : public BrowserPluginPropertyBinding {
 554  public:
 555   BrowserPluginPropertyBindingMinWidth() :
 556       BrowserPluginPropertyBinding(kAttributeMinWidth) {
 557   }
 558   virtual bool GetProperty(BrowserPluginBindings* bindings,
 559                            NPVariant* result) OVERRIDE {
 560     int min_width = bindings->instance()->min_width_attribute();
 561     INT32_TO_NPVARIANT(min_width, *result);
 562     return true;
 563   }
 564   virtual bool SetProperty(BrowserPluginBindings* bindings,
 565                            NPObject* np_obj,
 566                            const NPVariant* variant) OVERRIDE {
 567     int min_width = Int32FromNPVariant(*variant);
 568     bindings->instance()->SetMinWidthAttribute(min_width);
 569     return true;
 570   }
 571   virtual std::string GetDOMAttributeValue(
 572       BrowserPlugin* browser_plugin) OVERRIDE {
 573     return base::IntToString(browser_plugin->min_width_attribute());
 574   }
 575  private:
 576   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingMinWidth);
 577 };
 578
 579 class BrowserPluginPropertyBindingPartition
 580     : public BrowserPluginPropertyBinding {
 581  public:
 582   BrowserPluginPropertyBindingPartition() :
 583       BrowserPluginPropertyBinding(kAttributePartition) {
 584   }
 585   virtual bool GetProperty(BrowserPluginBindings* bindings,
 586                            NPVariant* result) OVERRIDE {
 587     std::string partition_id = bindings->instance()->GetPartitionAttribute();
 588     return StringToNPVariant(partition_id, result);
 589   }
 590   virtual bool SetProperty(BrowserPluginBindings* bindings,
 591                            NPObject* np_obj,
 592                            const NPVariant* variant) OVERRIDE {
 593     std::string partition_id = StringFromNPVariant(*variant);
 594     std::string error_message;
 595     if (!bindings->instance()->SetPartitionAttribute(partition_id,
 596                                                      &error_message)) {
 597       WebBindings::setException(
 598           np_obj, static_cast<const NPUTF8 *>(error_message.c_str()));
 599       return false;
 600     }
 601     return true;
 602   }
 603   virtual std::string GetDOMAttributeValue(
 604       BrowserPlugin* browser_plugin) OVERRIDE {
 605     return browser_plugin->GetPartitionAttribute();
 606   }
 607  private:
 608   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingPartition);
 609 };
 610
 611 class BrowserPluginPropertyBindingSrc : public BrowserPluginPropertyBinding {
 612  public:
 613   BrowserPluginPropertyBindingSrc() :
 614       BrowserPluginPropertyBinding(kAttributeSrc) {
 615   }
 616   virtual bool GetProperty(BrowserPluginBindings* bindings,
 617                            NPVariant* result) OVERRIDE {
 618     std::string src = bindings->instance()->src_attribute();
 619     return StringToNPVariant(src, result);
 620   }
 621   virtual bool SetProperty(BrowserPluginBindings* bindings,
 622                            NPObject* np_obj,
 623                            const NPVariant* variant) OVERRIDE {
 624     std::string src = StringFromNPVariant(*variant);
 625     std::string error_message;
 626     if (!bindings->instance()->SetSrcAttribute(src, &error_message)) {
 627       WebBindings::setException(
 628           np_obj, static_cast<const NPUTF8 *>(error_message.c_str()));
 629       return false;
 630     }
 631     return true;
 632   }
 633   virtual std::string GetDOMAttributeValue(
 634       BrowserPlugin* browser_plugin) OVERRIDE {
 635     return browser_plugin->src_attribute();
 636   }
 637  private:
 638   DISALLOW_COPY_AND_ASSIGN(BrowserPluginPropertyBindingSrc);
 639 };
 640
 641
 642 // BrowserPluginBindings ------------------------------------------------------
 643
 644 BrowserPluginBindings::BrowserPluginNPObject::BrowserPluginNPObject() {
 645 }
 646
 647 BrowserPluginBindings::BrowserPluginNPObject::~BrowserPluginNPObject() {
 648 }
 649
 650 BrowserPluginBindings::BrowserPluginBindings(BrowserPlugin* instance)
 651     : instance_(instance),
 652       np_object_(NULL),
 653       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 654   NPObject* obj =
 655       WebBindings::createObject(NULL, &browser_plugin_message_class);
 656   np_object_ = static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(obj);
 657   np_object_->message_channel = weak_ptr_factory_.GetWeakPtr();
 658
 659   method_bindings_.push_back(new BrowserPluginBindingBack);
 660   method_bindings_.push_back(new BrowserPluginBindingCanGoBack);
 661   method_bindings_.push_back(new BrowserPluginBindingCanGoForward);
 662   method_bindings_.push_back(new BrowserPluginBindingForward);
 663   method_bindings_.push_back(new BrowserPluginBindingGetProcessID);
 664   method_bindings_.push_back(new BrowserPluginBindingGo);
 665   method_bindings_.push_back(new BrowserPluginBindingReload);
 666   method_bindings_.push_back(new BrowserPluginBindingStop);
 667   method_bindings_.push_back(new BrowserPluginBindingTerminate);
 668
 669   property_bindings_.push_back(new BrowserPluginPropertyBindingAutoSize);
 670   property_bindings_.push_back(new BrowserPluginPropertyBindingContentWindow);
 671   property_bindings_.push_back(new BrowserPluginPropertyBindingMaxHeight);
 672   property_bindings_.push_back(new BrowserPluginPropertyBindingMaxWidth);
 673   property_bindings_.push_back(new BrowserPluginPropertyBindingMinHeight);
 674   property_bindings_.push_back(new BrowserPluginPropertyBindingMinWidth);
 675   property_bindings_.push_back(new BrowserPluginPropertyBindingPartition);
 676   property_bindings_.push_back(new BrowserPluginPropertyBindingSrc);
 677 }
 678
 679 BrowserPluginBindings::~BrowserPluginBindings() {
 680   WebBindings::releaseObject(np_object_);
 681 }
 682
 683 bool BrowserPluginBindings::HasMethod(NPIdentifier name) const {
 684   for (BindingList::const_iterator iter = method_bindings_.begin();
 685        iter != method_bindings_.end();
 686        ++iter) {
 687     if ((*iter)->MatchesName(name))
 688       return true;
 689   }
 690   return false;
 691 }
 692
 693 bool BrowserPluginBindings::InvokeMethod(NPIdentifier name,
 694                                          const NPVariant* args,
 695                                          uint32 arg_count,
 696                                          NPVariant* result) {
 697   for (BindingList::iterator iter = method_bindings_.begin();
 698        iter != method_bindings_.end();
 699        ++iter) {
 700     if ((*iter)->MatchesName(name) && (*iter)->arg_count() == arg_count)
 701       return (*iter)->Invoke(this, args, result);
 702   }
 703   return false;
 704 }
 705
 706 bool BrowserPluginBindings::HasProperty(NPIdentifier name) const {
 707   for (PropertyBindingList::const_iterator iter = property_bindings_.begin();
 708        iter != property_bindings_.end();
 709        ++iter) {
 710     if ((*iter)->MatchesName(name))
 711       return true;
 712   }
 713   return false;
 714 }
 715
 716 bool BrowserPluginBindings::SetProperty(NPObject* np_obj,
 717                                         NPIdentifier name,
 718                                         const NPVariant* variant) {
 719   for (PropertyBindingList::iterator iter = property_bindings_.begin();
 720        iter != property_bindings_.end();
 721        ++iter) {
 722     if ((*iter)->MatchesName(name)) {
 723       if ((*iter)->SetProperty(this, np_obj, variant)) {
 724         (*iter)->UpdateDOMAttribute(this);
 725         return true;
 726       }
 727       break;
 728     }
 729   }
 730   return false;
 731 }
 732
 733 bool BrowserPluginBindings::GetProperty(NPIdentifier name, NPVariant* result) {
 734   for (PropertyBindingList::iterator iter = property_bindings_.begin();
 735        iter != property_bindings_.end();
 736        ++iter) {
 737     if ((*iter)->MatchesName(name))
 738       return (*iter)->GetProperty(this, result);
 739   }
 740   return false;
 741 }
 742
 743 }  // namespace content