Browser Plugin: Implement autosize (Embedder-side code)

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 18 matching lines @@
 using WebKit::WebDOMEvent;
 using WebKit::WebDOMMessageEvent;
 using WebKit::WebPluginContainer;
 using WebKit::WebString;
 
 namespace content {
 
 namespace {
 
 const char kAddEventListener[] = "addEventListener";
+const char kAutoSizeAttribute[] = "autoSize";
 const char kBackMethod[] = "back";
 const char kCanGoBack[] = "canGoBack";
 const char kCanGoForward[] = "canGoForward";
 const char kContentWindow[] = "contentWindow";
 const char kForwardMethod[] = "forward";
 const char kGetProcessId[] = "getProcessId";
 const char kGoMethod[] = "go";
+const char kMaxHeightAttribute[] = "maxHeight";
+const char kMaxWidthAttribute[] = "maxWidth";
+const char kMinHeightAttribute[] = "minHeight";
+const char kMinWidthAttribute[] = "minWidth";
 const char kPartitionAttribute[] = "partition";
 const char kReloadMethod[] = "reload";
 const char kRemoveEventListener[] = "removeEventListener";
 const char kSrcAttribute[] = "src";
 const char kStopMethod[] = "stop";
 const char kTerminateMethod[] = "terminate";
 
 BrowserPluginBindings* GetBindings(NPObject* object) {
   return static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(object)->
       message_channel;
 }
 
 bool IdentifierIsContentWindow(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kContentWindow) == identifier;
 }
 
 bool IdentifierIsPartitionAttribute(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kPartitionAttribute) == identifier;
 }
 
 bool IdentifierIsSrcAttribute(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kSrcAttribute) == identifier;
 }
 
+bool IdentifierIsMaxHeightAttribute(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kMaxHeightAttribute) == identifier;
+}
+
+bool IdentifierIsMaxWidthAttribute(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kMaxWidthAttribute) == identifier;
+}
+
+bool IdentifierIsMinHeightAttribute(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kMinHeightAttribute) == identifier;
+}
+
+bool IdentifierIsMinWidthAttribute(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kMinWidthAttribute) == identifier;
+}
+
+bool IdentifierIsAutoSizeAttribute(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kAutoSizeAttribute) == identifier;
+}
+
 int Int32FromNPVariant(const NPVariant& variant) {
   if (NPVARIANT_IS_INT32(variant))
     return NPVARIANT_TO_INT32(variant);
 
   if (NPVARIANT_IS_DOUBLE(variant))
     return NPVARIANT_TO_DOUBLE(variant);
 
   return 0;
 }
 
@@ skipping 58 matching lines @@
                                         const NPVariant* args,
                                         uint32 arg_count,
                                         NPVariant* result) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool BrowserPluginBindingsHasProperty(NPObject* np_obj, NPIdentifier name) {
   return IdentifierIsSrcAttribute(name) ||
       IdentifierIsContentWindow(name) ||
-      IdentifierIsPartitionAttribute(name);
+      IdentifierIsPartitionAttribute(name) ||
+      IdentifierIsAutoSizeAttribute(name) ||
+      IdentifierIsMaxHeightAttribute(name) ||
+      IdentifierIsMaxWidthAttribute(name) ||
+      IdentifierIsMinHeightAttribute(name) ||
+      IdentifierIsMinWidthAttribute(name);
 }
 
 bool BrowserPluginBindingsGetProperty(NPObject* np_obj, NPIdentifier name,
                                       NPVariant* result) {
   if (!np_obj)
     return false;
 
   if (!result)
     return false;
 
@@ skipping 10 matching lines @@
 
   if (IdentifierIsContentWindow(name)) {
     NPObject* obj = bindings->instance()->GetContentWindow();
     if (obj) {
       result->type = NPVariantType_Object;
       result->value.objectValue = WebBindings::retainObject(obj);
     }
     return true;
   }
 
+  if (IdentifierIsAutoSizeAttribute(name)) {
+    bool autosize = bindings->instance()->GetAutoSizeAttribute();
+    BOOLEAN_TO_NPVARIANT(autosize, *result);
+    return true;
+  }
+
+  if (IdentifierIsMaxHeightAttribute(name)) {
+    int maxheight = bindings->instance()->GetMaxHeightAttribute();
+    INT32_TO_NPVARIANT(maxheight, *result);
+    return true;
+  }
+
+  if (IdentifierIsMaxWidthAttribute(name)) {
+    int maxwidth = bindings->instance()->GetMaxWidthAttribute();
+    INT32_TO_NPVARIANT(maxwidth, *result);
+    return true;
+  }
+
+  if (IdentifierIsMinHeightAttribute(name)) {
+    int minheight = bindings->instance()->GetMinHeightAttribute();
+    INT32_TO_NPVARIANT(minheight, *result);
+    return true;
+  }
+
+  if (IdentifierIsMinWidthAttribute(name)) {
+    int minwidth = bindings->instance()->GetMinWidthAttribute();
+    INT32_TO_NPVARIANT(minwidth, *result);
+    return true;
+  }
+
   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) {
@@ skipping 19 matching lines @@
     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;
   }
 
+  if (IdentifierIsAutoSizeAttribute(name)) {
+    bool autosize = NPVARIANT_TO_BOOLEAN(*variant);
+    bindings->instance()->SetAutoSizeAttribute(autosize);
+    return true;
+  }
+
+  if (IdentifierIsMaxHeightAttribute(name)) {
+    int maxheight = Int32FromNPVariant(*variant);
+    bindings->instance()->SetMaxHeightAttribute(maxheight);
+    return true;
+  }
+
+  if (IdentifierIsMaxWidthAttribute(name)) {
+    int maxwidth = Int32FromNPVariant(*variant);
+    bindings->instance()->SetMaxWidthAttribute(maxwidth);
+    return true;
+  }
+
+  if (IdentifierIsMinHeightAttribute(name)) {
+    int minheight = Int32FromNPVariant(*variant);

[jam, 2012/11/02 19:11:10]

ditto

[Fady Samuel, 2012/11/02 20:32:23]

Done.

+    bindings->instance()->SetMinHeightAttribute(minheight);
+    return true;
+  }
+
+  if (IdentifierIsMinWidthAttribute(name)) {
+    int minwidth = Int32FromNPVariant(*variant);
+    bindings->instance()->SetMinWidthAttribute(minwidth);
+    return true;
+  }
+
   return false;
 }
 
 bool BrowserPluginBindingsEnumerate(NPObject *np_obj, NPIdentifier **value,
                                     uint32_t *count) {
   NOTIMPLEMENTED();
   return true;
 }
 
 NPClass browser_plugin_message_class = {
@@ skipping 304 matching lines @@
   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);
   }
   return false;
 }
 
 }  // namespace content