[Content] Allow V8ValueConverter to convert -0 to an integer

content/child/v8_value_converter_impl_unittest.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/child/v8_value_converter_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 934 matching lines @@
     base::DictionaryValue* current_as_object = NULL;
     ASSERT_TRUE(current->GetAsDictionary(&current_as_object)) << i;
     ASSERT_TRUE(current_as_object->Get(kKey, &current)) << i;
   }
 
   // The leaf node shouldn't have any properties.
   base::DictionaryValue empty;
   EXPECT_TRUE(base::Value::Equals(&empty, current)) << *current;
 }
 
+TEST_F(V8ValueConverterImplTest, NegativeZero) {
+  v8::HandleScope handle_scope(isolate_);
+  v8::Local<v8::Context> context =
+      v8::Local<v8::Context>::New(isolate_, context_);
+  v8::MicrotasksScope microtasks(isolate_,
+                                 v8::MicrotasksScope::kDoNotRunMicrotasks);
+
+  v8::Context::Scope context_scope(context);
+  const char* source = "(function() { return -0; })();";
+
+  v8::Local<v8::Script> script(
+      v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
+  v8::Local<v8::Value> value = script->Run();
+  ASSERT_FALSE(value.IsEmpty());
+
+  {
+    V8ValueConverterImpl converter;
+    std::unique_ptr<base::Value> result = converter.FromV8Value(value, context);
+    ASSERT_TRUE(result->is_double())
+        << base::Value::GetTypeName(result->type());
+    EXPECT_EQ(0, result->GetDouble());
+  }
+  {
+    V8ValueConverterImpl converter;
+    converter.SetConvertNegativeZeroToInt(true);
+    std::unique_ptr<base::Value> result = converter.FromV8Value(value, context);
+    ASSERT_TRUE(result->is_int()) << base::Value::GetTypeName(result->type());
+    EXPECT_EQ(0, result->GetInt());
+  }
+}
+
 class V8ValueConverterOverridingStrategyForTesting
     : public V8ValueConverter::Strategy {
  public:
   V8ValueConverterOverridingStrategyForTesting()
       : reference_value_(NewReferenceValue()) {}
   bool FromV8Object(v8::Local<v8::Object> value,
                     std::unique_ptr<base::Value>* out,
                     v8::Isolate* isolate,
                     const FromV8ValueCallback& callback) const override {
     *out = NewReferenceValue();
@@ skipping 176 matching lines @@
   EXPECT_TRUE(
       base::Value::Equals(reference_number_value.get(), number_value.get()));
 
   v8::Local<v8::Primitive> undefined(v8::Undefined(isolate_));
   std::unique_ptr<base::Value> undefined_value(
       converter.FromV8Value(undefined, context));
   EXPECT_FALSE(undefined_value);
 }
 
 }  // namespace content