Add support for Float/Double types for JS Mojo bindings.

content/browser/webui/web_ui_mojo_browsertest.cc

 // Copyright 2014 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 <limits>
+
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 25 matching lines @@
 const int32 kExpectedInt32Value = -1145258561;
 const int64 kExpectedInt64Value = -77263311946305LL;
 
 // Positive numbers with different values in each byte, the last of
 // which can survive promotion to double and back.
 const uint8  kExpectedUInt8Value = 65;
 const uint16 kExpectedUInt16Value = 16961;
 const uint32 kExpectedUInt32Value = 1145258561;
 const uint64 kExpectedUInt64Value = 77263311946305LL;
 
+// Double/float values, including special case constants.
+const double kExpectedDoubleVal = 3.14159265358979323846;
+const double kExpectedDoubleInf = std::numeric_limits<double>::infinity();
+const double kExpectedDoubleNan = std::numeric_limits<double>::quiet_NaN();
+const float kExpectedFloatVal = static_cast<float>(kExpectedDoubleVal);
+const float kExpectedFloatInf = std::numeric_limits<float>::infinity();
+const float kExpectedFloatNan = std::numeric_limits<float>::quiet_NaN();
+
+// NaN has the property that it is not equal to itself.
+#define EXPECT_NAN(x) EXPECT_NE(x, x)
+
 // Returns the path to the mojom js bindings file.
 base::FilePath GetFilePathForJSResource(const std::string& path) {
   std::string binding_path = "gen/" + path + ".js";
 #if defined(OS_WIN)
   std::string tmp;
   base::ReplaceChars(binding_path, "//", "\\", &tmp);
   binding_path.swap(tmp);
 #endif
   base::FilePath file_path;
   PathService::Get(CHILD_PROCESS_EXE, &file_path);
@@ skipping 77 matching lines @@
     mojo::AllocationScope scope;
     mojo::EchoArgs::Builder builder;
     builder.set_si64(kExpectedInt64Value);
     builder.set_si32(kExpectedInt32Value);
     builder.set_si16(kExpectedInt16Value);
     builder.set_si8(kExpectedInt8Value);
     builder.set_ui64(kExpectedUInt64Value);
     builder.set_ui32(kExpectedUInt32Value);
     builder.set_ui16(kExpectedUInt16Value);
     builder.set_ui8(kExpectedUInt8Value);
+    builder.set_float_val(kExpectedFloatVal);
+    builder.set_float_inf(kExpectedFloatInf);
+    builder.set_float_nan(kExpectedFloatNan);
+    builder.set_double_val(kExpectedDoubleVal);
+    builder.set_double_inf(kExpectedDoubleInf);
+    builder.set_double_nan(kExpectedDoubleNan);
     builder.set_name("coming");
     client_->Echo(builder.Finish());
   }
 
   virtual ~EchoBrowserTargetImpl() {}
 
   // mojo::BrowserTarget overrides:
   // Check the response, and quit the RunLoop after N calls.
   virtual void EchoResponse(const mojo::EchoArgs& arg1,
                             const mojo::EchoArgs& arg2) OVERRIDE {
     EXPECT_EQ(kExpectedInt64Value, arg1.si64());
     EXPECT_EQ(kExpectedInt32Value, arg1.si32());
     EXPECT_EQ(kExpectedInt16Value, arg1.si16());
     EXPECT_EQ(kExpectedInt8Value, arg1.si8());
     EXPECT_EQ(kExpectedUInt64Value, arg1.ui64());
     EXPECT_EQ(kExpectedUInt32Value, arg1.ui32());
     EXPECT_EQ(kExpectedUInt16Value, arg1.ui16());
     EXPECT_EQ(kExpectedUInt8Value, arg1.ui8());
+    EXPECT_EQ(kExpectedFloatVal, arg1.float_val());
+    EXPECT_EQ(kExpectedFloatInf, arg1.float_inf());
+    EXPECT_NAN(arg1.float_nan());
+    EXPECT_EQ(kExpectedDoubleVal, arg1.double_val());
+    EXPECT_EQ(kExpectedDoubleInf, arg1.double_inf());
+    EXPECT_NAN(arg1.double_nan());
     EXPECT_EQ(std::string("coming"), arg1.name().To<std::string>());
 
     EXPECT_EQ(-1, arg2.si64());
     EXPECT_EQ(-1, arg2.si32());
     EXPECT_EQ(-1, arg2.si16());
     EXPECT_EQ(-1, arg2.si8());
     EXPECT_EQ(std::string("going"), arg2.name().To<std::string>());
 
     message_count += 1;
     if (message_count == kExpectedMessageCount)
@@ skipping 174 matching lines @@
   factory()->set_run_loop(&run_loop);
   GURL test_url(test_server()->GetURL("files/web_ui_mojo.html?echo"));
   NavigateToURL(shell(), test_url);
   // RunLoop is quit when response received from page.
   run_loop.Run();
   EXPECT_EQ(kExpectedMessageCount, message_count);
 }
 
 }  // namespace
 }  // namespace content