From b628199ee9cc9e8f1a3abe636183dbb9bae59766 Mon Sep 17 00:00:00 2001
From: Chris Bardsley <chrisbmidas@gmail.com>
Date: Wed, 23 Mar 2016 21:17:47 -0700
Subject: [PATCH 1/2] Fix for C# paramArray and refactor on arguments mismatch

---
 CefSharp.Example/Resources/Home.html          |  8 +++++
 .../ScriptedMethodsBoundObject.cs             | 22 ++++++++++++
 CefSharp/CefSharp.csproj                      |  1 +
 CefSharp/Internals/JavascriptMethod.cs        |  4 +++
 .../Internals/JavascriptObjectRepository.cs   | 36 ++++++++++++++++---
 CefSharp/Internals/MethodParameter.cs         | 20 +++++++++++
 NuGet.config                                  |  1 +
 7 files changed, 87 insertions(+), 5 deletions(-)
 create mode 100644 CefSharp/Internals/MethodParameter.cs

diff --git a/CefSharp.Example/Resources/Home.html b/CefSharp.Example/Resources/Home.html
index 0d78795c70..dd8113ee32 100644
--- a/CefSharp.Example/Resources/Home.html
+++ b/CefSharp.Example/Resources/Home.html
@@ -351,6 +351,14 @@ <h3 id="features-javascript-integration">JavaScript integration</h3>
                         objects.
                     </p>
                     <h3>Hooks by which you can modify and/or override certain features of the web browsing</h3>
+                    <p>
+                        A fix to allow params to be used by the .NET methods called by the javascript<br />
+                        <button onclick="boundEvent.methodWithParams('test', 'hello-world')">With 1 Params</button>
+                        <button onclick="boundEvent.methodWithParams('test', 'hello-world', 'chris was here')">With 2 Params</button>
+                        <button onclick="boundEvent.methodWithParams('test')">With no Params</button>
+                        <button onclick="boundEvent.methodWithoutParams('test', 'hello')">Normal Method</button>
+                        <button onclick="boundEvent.methodWithoutAnything()">Normal Method No Params</button>
+                    </p>
                 </div>
                 <div class="bs-docs-section">
                     <div class="page-header">
diff --git a/CefSharp.Example/ScriptedMethodsBoundObject.cs b/CefSharp.Example/ScriptedMethodsBoundObject.cs
index 406e0131dc..d1bff280d5 100644
--- a/CefSharp.Example/ScriptedMethodsBoundObject.cs
+++ b/CefSharp.Example/ScriptedMethodsBoundObject.cs
@@ -2,6 +2,7 @@
 //
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 using System;
+using System.Linq;
 
 namespace CefSharp.Example
 {
@@ -35,5 +36,26 @@ public void RaiseEvent(string eventName, object eventData = null)
                 EventArrived(eventName, eventData);
             }
         }
+
+        /// <summary>
+        /// Demonstrates the use of params as an argument in a bound object
+        /// </summary>
+        /// <param name="name">Dummy Argument</param>
+        /// <param name="args">Params Argument</param>
+        public void MethodWithParams(string name, params object[] args)
+        {
+            var test = args.ElementAtOrDefault(0);
+            var test2 = args.ElementAtOrDefault(1);
+        }
+
+        public void MethodWithoutParams(string name, string arg2)
+        {
+            var test = arg2;
+        }
+
+        public void methodWithoutAnything()
+        {
+            var test = "";
+        }
     }
 }
diff --git a/CefSharp/CefSharp.csproj b/CefSharp/CefSharp.csproj
index 9a156e623d..66542492d9 100644
--- a/CefSharp/CefSharp.csproj
+++ b/CefSharp/CefSharp.csproj
@@ -89,6 +89,7 @@
     <Compile Include="IDomNode.cs" />
     <Compile Include="IFindHandler.cs" />
     <Compile Include="Internals\CommandLineArgsParser.cs" />
+    <Compile Include="Internals\MethodParameter.cs" />
     <Compile Include="IPluginHandler.cs" />
     <Compile Include="IPopupFeatures.cs" />
     <Compile Include="IRenderProcessMessageHandler.cs" />
diff --git a/CefSharp/Internals/JavascriptMethod.cs b/CefSharp/Internals/JavascriptMethod.cs
index d6ee5065b4..8b9738f177 100644
--- a/CefSharp/Internals/JavascriptMethod.cs
+++ b/CefSharp/Internals/JavascriptMethod.cs
@@ -3,6 +3,7 @@
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
 using System;
+using System.Collections.Generic;
 using System.Runtime.Serialization;
 
 namespace CefSharp.Internals
@@ -33,6 +34,9 @@ public class JavascriptMethod
         [DataMember]
         public string JavascriptName { get; set; }
 
+        [DataMember]
+        public List<MethodParameter> MethodParameters { get; set; }
+
         /// <summary>
         /// Number of Params this function exepects
         /// </summary>
diff --git a/CefSharp/Internals/JavascriptObjectRepository.cs b/CefSharp/Internals/JavascriptObjectRepository.cs
index b02bc5743e..17527ffba9 100644
--- a/CefSharp/Internals/JavascriptObjectRepository.cs
+++ b/CefSharp/Internals/JavascriptObjectRepository.cs
@@ -104,15 +104,33 @@ public bool TryCallMethod(long objectId, string name, object[] parameters, out o
 
             try
             {
-                // Do we have enough arguments? Add Type.Missing for any that we don't have incase of optional params
+                //Fix for C# paramArray and refactor on arguments mismatch 03/22/2016
                 var missingParams = method.ParameterCount - parameters.Length;
-                if (missingParams > 0)
+                if (missingParams > 0 || method.MethodParameters.Any(t => t.IsParamArray))
                 {
-                    var paramList = new List<object>(parameters);
+                    var paramList = new List<object>();
 
-                    for (var i = 0; i < missingParams; i++)
+                    for (int i = 0; i < method.MethodParameters.Count; i++)
                     {
-                        paramList.Add(Type.Missing);
+                        object jsParam = parameters.ElementAtOrDefault(i);
+                        if (jsParam == null && !method.MethodParameters[i].IsParamArray)
+                        {
+                            paramList.Add(Type.Missing);
+                        }
+                        else if (method.MethodParameters[i].IsParamArray)
+                        {
+                            List<object> convertedParams = new List<object>();
+                            for (int s = i; s < parameters.Count(); s++)
+                            {
+                                convertedParams.Add(parameters[s]);
+                            }
+                            paramList.Add(convertedParams.ToArray());
+                            break;
+                        }
+                        else
+                        {
+                            paramList.Add(jsParam);
+                        }
                     }
 
                     parameters = paramList.ToArray();
@@ -287,6 +305,14 @@ private static JavascriptMethod CreateJavaScriptMethod(MethodInfo methodInfo, bo
             jsMethod.JavascriptName = GetJavascriptName(methodInfo.Name, camelCaseJavascriptNames);
             jsMethod.Function = methodInfo.Invoke;
             jsMethod.ParameterCount = methodInfo.GetParameters().Length;
+            jsMethod.MethodParameters = methodInfo.GetParameters()
+                .Select(t => new MethodParameter()
+                { Name = t.Name,
+                    ParameterType = t.ParameterType,
+                    Position = t.Position,
+                    IsParamArray = t.GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0
+                }).ToList();
+            
 
             return jsMethod;
         }
diff --git a/CefSharp/Internals/MethodParameter.cs b/CefSharp/Internals/MethodParameter.cs
new file mode 100644
index 0000000000..967a591ff5
--- /dev/null
+++ b/CefSharp/Internals/MethodParameter.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace CefSharp.Internals
+{
+    [DataContract]
+    public class MethodParameter
+    {
+        public String Name { get; set; }
+
+        public Type ParameterType { get; set; }
+
+        public Boolean IsParamArray { get; set; }
+
+        public Int32 Position { get; set; }
+    }
+}
diff --git a/NuGet.config b/NuGet.config
index 6317951379..33107acaf3 100644
--- a/NuGet.config
+++ b/NuGet.config
@@ -5,5 +5,6 @@
     </activePackageSource>
   <packageSources>
     <add key="cefsharp-myget" value="https://www.myget.org/F/cefsharp/" />
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
   </packageSources>
 </configuration>
\ No newline at end of file

From d3d6907dacdc46dfd83388a364aac9cf58a4094b Mon Sep 17 00:00:00 2001
From: Chris Bardsley <chrisbmidas@gmail.com>
Date: Mon, 4 Apr 2016 21:44:22 -0700
Subject: [PATCH 2/2] Refactored changes from build#1644 to account for
 discussed changes.

---
 CefSharp.Example/BoundObject.cs               | 21 ++++++++++++++
 CefSharp.Example/Resources/BindingTest.html   | 29 +++++++++++++++++++
 CefSharp.Example/Resources/Home.html          |  8 -----
 .../ScriptedMethodsBoundObject.cs             | 21 --------------
 CefSharp/Internals/JavascriptMethod.cs        |  1 -
 .../Internals/JavascriptObjectRepository.cs   | 25 ++++++++++------
 CefSharp/Internals/MethodParameter.cs         | 16 +++-------
 NuGet.config                                  |  3 ++
 8 files changed, 73 insertions(+), 51 deletions(-)

diff --git a/CefSharp.Example/BoundObject.cs b/CefSharp.Example/BoundObject.cs
index 72fccb73ab..c5d0656bed 100644
--- a/CefSharp.Example/BoundObject.cs
+++ b/CefSharp.Example/BoundObject.cs
@@ -3,6 +3,7 @@
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 
 namespace CefSharp.Example
@@ -270,5 +271,25 @@ public SubBoundObject GetSubObject()
         {
             return SubObject;
         }
+
+        /// <summary>
+        /// Demonstrates the use of params as an argument in a bound object
+        /// </summary>
+        /// <param name="name">Dummy Argument</param>
+        /// <param name="args">Params Argument</param>
+        public string MethodWithParams(string name, params object[] args)
+        {
+            return String.Join(", ", args.ToArray());
+        }
+
+        public string MethodWithoutParams(string name, string arg2)
+        {
+            return String.Format("{0}, {1}", name, arg2);
+        }
+
+        public string methodWithoutAnything()
+        {
+            return "Method without anything called and returned successfully.";
+        }
     }
 }
diff --git a/CefSharp.Example/Resources/BindingTest.html b/CefSharp.Example/Resources/BindingTest.html
index 0caedff021..c08a017da5 100644
--- a/CefSharp.Example/Resources/BindingTest.html
+++ b/CefSharp.Example/Resources/BindingTest.html
@@ -237,5 +237,34 @@
                 }
             </script>
         </ul>
+        <p>
+            Javascript function sending variable number of parameters to Bound Object. (ParamArray Test)
+            <script type="text/javascript">
+                function invokeParamArrayMethod(func) {
+                    var result = func();
+                    document.getElementById('paramArrayResults').innerHTML = result;
+                }
+            </script>
+        <ul>
+            <li style="list-style:none;display:inline-block;">
+                <button onclick="invokeParamArrayMethod(function(){return bound.methodWithParams('test', 'hello-world')})">With 1 Params</button>
+            </li>
+            <li style="list-style:none;display:inline-block;">
+                <button onclick="invokeParamArrayMethod(function(){return bound.methodWithParams('test', 'hello-world', 'chris was here')})">With 2 Params</button>
+            </li>
+            <li style="list-style:none;display:inline-block;">
+                <button onclick="invokeParamArrayMethod(function(){return bound.methodWithParams('test')})">With no Params</button>
+            </li>
+            <li style="list-style:none;display:inline-block;">
+                <button onclick="invokeParamArrayMethod(function(){return bound.methodWithoutParams('test', 'hello')})">Normal Method</button>
+            </li>
+            <li style="list-style:none;display:inline-block;">
+                <button onclick="invokeParamArrayMethod(function(){return bound.methodWithoutAnything()})">Normal Method No Params</button>
+            </li>           
+        </ul>
+            <span>ParamArray Results</span>
+            <br />
+            <span id="paramArrayResults"></span>
+        </p>
     </body>
 </html>
diff --git a/CefSharp.Example/Resources/Home.html b/CefSharp.Example/Resources/Home.html
index dd8113ee32..0d78795c70 100644
--- a/CefSharp.Example/Resources/Home.html
+++ b/CefSharp.Example/Resources/Home.html
@@ -351,14 +351,6 @@ <h3 id="features-javascript-integration">JavaScript integration</h3>
                         objects.
                     </p>
                     <h3>Hooks by which you can modify and/or override certain features of the web browsing</h3>
-                    <p>
-                        A fix to allow params to be used by the .NET methods called by the javascript<br />
-                        <button onclick="boundEvent.methodWithParams('test', 'hello-world')">With 1 Params</button>
-                        <button onclick="boundEvent.methodWithParams('test', 'hello-world', 'chris was here')">With 2 Params</button>
-                        <button onclick="boundEvent.methodWithParams('test')">With no Params</button>
-                        <button onclick="boundEvent.methodWithoutParams('test', 'hello')">Normal Method</button>
-                        <button onclick="boundEvent.methodWithoutAnything()">Normal Method No Params</button>
-                    </p>
                 </div>
                 <div class="bs-docs-section">
                     <div class="page-header">
diff --git a/CefSharp.Example/ScriptedMethodsBoundObject.cs b/CefSharp.Example/ScriptedMethodsBoundObject.cs
index d1bff280d5..453cc6e938 100644
--- a/CefSharp.Example/ScriptedMethodsBoundObject.cs
+++ b/CefSharp.Example/ScriptedMethodsBoundObject.cs
@@ -36,26 +36,5 @@ public void RaiseEvent(string eventName, object eventData = null)
                 EventArrived(eventName, eventData);
             }
         }
-
-        /// <summary>
-        /// Demonstrates the use of params as an argument in a bound object
-        /// </summary>
-        /// <param name="name">Dummy Argument</param>
-        /// <param name="args">Params Argument</param>
-        public void MethodWithParams(string name, params object[] args)
-        {
-            var test = args.ElementAtOrDefault(0);
-            var test2 = args.ElementAtOrDefault(1);
-        }
-
-        public void MethodWithoutParams(string name, string arg2)
-        {
-            var test = arg2;
-        }
-
-        public void methodWithoutAnything()
-        {
-            var test = "";
-        }
     }
 }
diff --git a/CefSharp/Internals/JavascriptMethod.cs b/CefSharp/Internals/JavascriptMethod.cs
index 8b9738f177..5028dcb226 100644
--- a/CefSharp/Internals/JavascriptMethod.cs
+++ b/CefSharp/Internals/JavascriptMethod.cs
@@ -34,7 +34,6 @@ public class JavascriptMethod
         [DataMember]
         public string JavascriptName { get; set; }
 
-        [DataMember]
         public List<MethodParameter> MethodParameters { get; set; }
 
         /// <summary>
diff --git a/CefSharp/Internals/JavascriptObjectRepository.cs b/CefSharp/Internals/JavascriptObjectRepository.cs
index 17527ffba9..6aa310c772 100644
--- a/CefSharp/Internals/JavascriptObjectRepository.cs
+++ b/CefSharp/Internals/JavascriptObjectRepository.cs
@@ -104,28 +104,37 @@ public bool TryCallMethod(long objectId, string name, object[] parameters, out o
 
             try
             {
-                //Fix for C# paramArray and refactor on arguments mismatch 03/22/2016
+                //Added param array support.  Current implementation support param Object only. 04/04/2016
                 var missingParams = method.ParameterCount - parameters.Length;
-                if (missingParams > 0 || method.MethodParameters.Any(t => t.IsParamArray))
+                //CONDITION #1 : Check for parameter count missmatch between the parameters on the javascript function and the
+                //               number of parameters on the bound object method.
+                //CONDITION #2 : Check if the bound object method contains a ParamArray as the last parameter on the method signature.
+                if (missingParams > 0 || method.MethodParameters.LastOrDefault(t => t.IsParamArray) != null)
                 {
-                    var paramList = new List<object>();
+                    var paramList = new List<object>(method.MethodParameters.Count);
 
-                    for (int i = 0; i < method.MethodParameters.Count; i++)
+                    //Loop through all of the method parameters on the bound object.
+                    for (var i = 0; i < method.MethodParameters.Count; i++)
                     {
+                        //Attempt to get the javascript function param at the current bound object parameter index.
+                        //If the javascript function param is missing IE: NULL,  then add Type.Missing.
+                        //This will allow for default bound object parameters. IE: (string someParameter = "someValue")
                         object jsParam = parameters.ElementAtOrDefault(i);
                         if (jsParam == null && !method.MethodParameters[i].IsParamArray)
                         {
                             paramList.Add(Type.Missing);
                         }
+                        //If the method parameter is a paramArray IE: (params Object[] someParameter)
+                        //grab the parameters from the javascript function starting at the current bound object parameter index
+                        //and add create an array that will be passed in as the last bound object method parameter.
                         else if (method.MethodParameters[i].IsParamArray)
                         {
                             List<object> convertedParams = new List<object>();
-                            for (int s = i; s < parameters.Count(); s++)
+                            for (var s = i; s < parameters.Length; s++)
                             {
                                 convertedParams.Add(parameters[s]);
                             }
                             paramList.Add(convertedParams.ToArray());
-                            break;
                         }
                         else
                         {
@@ -307,9 +316,7 @@ private static JavascriptMethod CreateJavaScriptMethod(MethodInfo methodInfo, bo
             jsMethod.ParameterCount = methodInfo.GetParameters().Length;
             jsMethod.MethodParameters = methodInfo.GetParameters()
                 .Select(t => new MethodParameter()
-                { Name = t.Name,
-                    ParameterType = t.ParameterType,
-                    Position = t.Position,
+                {
                     IsParamArray = t.GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0
                 }).ToList();
             
diff --git a/CefSharp/Internals/MethodParameter.cs b/CefSharp/Internals/MethodParameter.cs
index 967a591ff5..af3ad6aabe 100644
--- a/CefSharp/Internals/MethodParameter.cs
+++ b/CefSharp/Internals/MethodParameter.cs
@@ -1,20 +1,12 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.Serialization;
-using System.Text;
+// Copyright © 2010-2016 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+using System;
 
 namespace CefSharp.Internals
 {
-    [DataContract]
     public class MethodParameter
     {
-        public String Name { get; set; }
-
-        public Type ParameterType { get; set; }
-
         public Boolean IsParamArray { get; set; }
-
-        public Int32 Position { get; set; }
     }
 }
diff --git a/NuGet.config b/NuGet.config
index 33107acaf3..8d4d26dc04 100644
--- a/NuGet.config
+++ b/NuGet.config
@@ -7,4 +7,7 @@
     <add key="cefsharp-myget" value="https://www.myget.org/F/cefsharp/" />
     <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
   </packageSources>
+  <disabledPackageSources>
+    <add key="nuget.org" value="true" />
+  </disabledPackageSources>
 </configuration>
\ No newline at end of file