Allow chrome.send to pass number, boolean, null and arrays of those

webkit/glue/cpp_variant.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
 // This file contains definitions for CppVariant.
 
 #include <limits>
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "webkit/glue/cpp_variant.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 192 matching lines @@
     NOTREACHED();
     return 0.0;
   }
 }
 
 bool CppVariant::ToBoolean() const {
   DCHECK(isBool());
   return value.boolValue;
 }
 
-std::vector<std::string> CppVariant::ToStringVector() const {
+std::vector<CppVariant> CppVariant::ToVector() const {
   DCHECK(isObject());
-  std::vector<std::string> string_vector;
+  std::vector<CppVariant> vector;
   NPObject* np_value = value.objectValue;
   NPIdentifier length_id = WebBindings::getStringIdentifier("length");
 
   if (WebBindings::hasProperty(NULL, np_value, length_id)) {
-    NPVariant length_value;
+    CppVariant length_value;
     if (WebBindings::getProperty(NULL, np_value, length_id, &length_value)) {
       int length = 0;
       // The length is a double in some cases.
       if (NPVARIANT_IS_DOUBLE(length_value))
         length = static_cast<int>(NPVARIANT_TO_DOUBLE(length_value));
       else if (NPVARIANT_IS_INT32(length_value))
         length = NPVARIANT_TO_INT32(length_value);
-      WebBindings::releaseVariantValue(&length_value);
+      else
+        NOTREACHED();
 
       // For sanity, only allow 60000 items.
       length = std::min(60000, length);
       for (int i = 0; i < length; ++i) {
         // Get each of the items.
-        std::string index = base::StringPrintf("%d", i);
-        NPIdentifier index_id = WebBindings::getStringIdentifier(index.c_str());
-        if (WebBindings::hasProperty(NULL, np_value, index_id)) {
-          NPVariant index_value;
-          if (WebBindings::getProperty(NULL, np_value, index_id, &index_value)) {
-            if (NPVARIANT_IS_STRING(index_value)) {
-              std::string string(
-                  NPVARIANT_TO_STRING(index_value).UTF8Characters,
-                  NPVARIANT_TO_STRING(index_value).UTF8Length);
-              string_vector.push_back(string);
-            }
-            WebBindings::releaseVariantValue(&index_value);
+        NPIdentifier index = WebBindings::getIntIdentifier(i);
+        if (WebBindings::hasProperty(NULL, np_value, index)) {
+          CppVariant index_value;

[Evan Martin, 2011/01/26 19:21:10]

Just to confirm, by using CppVariant here it implicitly frees the result?

[arv (Not doing code reviews), 2011/01/26 19:38:58]

Yes, CppVariant calls FreeData in its destructor.

+          if (WebBindings::getProperty(NULL, np_value, index, &index_value)) {
+            CppVariant cpp;
+            cpp.Set(index_value);
+            vector.push_back(cpp);
           }
         }
       }
     }
+  } else {
+    NOTREACHED();
   }
-  return string_vector;
+  return vector;
 }
 
 bool CppVariant::Invoke(const std::string& method, const CppVariant* args,
                         uint32 arg_count, CppVariant& result) const {
   DCHECK(isObject());
   NPIdentifier method_name = WebBindings::getStringIdentifier(method.c_str());
   NPObject* np_object = value.objectValue;
   if (WebBindings::hasMethod(NULL, np_object, method_name)) {
     NPVariant r;
     bool status = WebBindings::invoke(NULL, np_object, method_name, args, arg_count, &r);
     result.Set(r);
     return status;
   } else {
     return false;
   }
 }