Add support for parsing a 'partition' attribute on the <browser> tag.

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"
@@ skipping 23 matching lines @@
 using WebKit::WebSerializedScriptValue;
 using WebKit::WebString;
 
 namespace content {
 
 namespace {
 
 const char kAddEventListener[] = "addEventListener";
 const char kRemoveEventListener[] = "removeEventListener";
 const char kSrcAttribute[] = "src";
+const char kPartitionAttribute[] = "partition";
 
 BrowserPluginBindings* GetBindings(NPObject* object) {
   return static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(object)->
       message_channel;
 }
 
 bool IdentifierIsAddEventListener(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kAddEventListener) == identifier;
 }
 
 bool IdentifierIsRemoveEventListener(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kRemoveEventListener) == identifier;
 }
 
 bool IdentifierIsSrcAttribute(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kSrcAttribute) == identifier;
 }
 
+bool IdentifierIsPartitionAttribute(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kPartitionAttribute) == identifier;
+}
+
 std::string StringFromNPVariant(const NPVariant& variant) {
   if (!NPVARIANT_IS_STRING(variant))
     return std::string();
   const NPString& np_string = NPVARIANT_TO_STRING(variant);
   return std::string(np_string.UTF8Characters, np_string.UTF8Length);
 }
 
 string16 String16FromNPVariant(const NPVariant& variant) {
   if (!NPVARIANT_IS_STRING(variant))
     return string16();
@@ skipping 87 matching lines @@
 
 bool BrowserPluginBindingsInvokeDefault(NPObject* np_obj,
                                         const NPVariant* args,
                                         uint32 arg_count,
                                         NPVariant* result) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool BrowserPluginBindingsHasProperty(NPObject* np_obj, NPIdentifier name) {
-  return IdentifierIsSrcAttribute(name);
+  return IdentifierIsSrcAttribute(name) ||
+      IdentifierIsPartitionAttribute(name);
 }
 
 bool BrowserPluginBindingsGetProperty(NPObject* np_obj, NPIdentifier name,
                                       NPVariant* result) {
   if (!np_obj)
     return false;
 
+  if (!result)
+    return false;
+
   if (IdentifierIsAddEventListener(name) ||
       IdentifierIsRemoveEventListener(name))
     return false;
 
+  // All attributes from here on rely on the bindings, so retrieve it once and
+  // return on failure.
+  BrowserPluginBindings* bindings = GetBindings(np_obj);
+  if (!bindings)
+    return false;
+
   if (IdentifierIsSrcAttribute(name)) {
-    BrowserPluginBindings* bindings = GetBindings(np_obj);
-    if (!bindings)
-      return false;
     std::string src = bindings->instance()->GetSrcAttribute();
     return StringToNPVariant(src, result);
   }
 
+  if (IdentifierIsPartitionAttribute(name)) {
+    std::string partition_id = bindings->instance()->GetPartitionAttribute();
+    return StringToNPVariant(partition_id, result);
+  }
+
   return false;
 }
 
 bool BrowserPluginBindingsSetProperty(NPObject* np_obj, NPIdentifier name,
                                       const NPVariant* variant) {
   if (!np_obj)
     return false;
+  if (!variant)
+    return false;
+
+  // All attributes from here on rely on the bindings, so retrieve it once and
+  // return on failure.
+  BrowserPluginBindings* bindings = GetBindings(np_obj);
+  if (!bindings)
+    return false;
 
   if (IdentifierIsSrcAttribute(name)) {
     std::string src = StringFromNPVariant(*variant);
-    BrowserPluginBindings* bindings = GetBindings(np_obj);
-    if (!bindings)
-      return false;
     bindings->instance()->SetSrcAttribute(src);
     return true;
   }
+
+  if (IdentifierIsPartitionAttribute(name)) {
+    std::string partition_id = StringFromNPVariant(*variant);
+    std::string error_message;
+    if (!bindings->instance()->SetPartitionAttribute(partition_id,
+                                                     error_message)) {
+      WebBindings::setException(
+          np_obj, static_cast<const NPUTF8 *>(error_message.c_str()));
+      return false;
+    }
+    return true;
+  }
+
   return false;
 }
 
 bool BrowserPluginBindingsEnumerate(NPObject *np_obj, NPIdentifier **value,
                                     uint32_t *count) {
   NOTIMPLEMENTED();
   return true;
 }
 
 NPClass browser_plugin_message_class = {
@@ skipping 29 matching lines @@
       WebBindings::createObject(NULL, &browser_plugin_message_class);
   np_object_ = static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(obj);
   np_object_->message_channel = weak_ptr_factory_.GetWeakPtr();
 }
 
 BrowserPluginBindings::~BrowserPluginBindings() {
   WebBindings::releaseObject(np_object_);
 }
 
 }  // namespace content