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

content/child/v8_value_converter_impl.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 166 matching lines @@
 
 V8ValueConverter* V8ValueConverter::create() {
   return new V8ValueConverterImpl();
 }
 
 V8ValueConverterImpl::V8ValueConverterImpl()
     : date_allowed_(false),
       reg_exp_allowed_(false),
       function_allowed_(false),
       strip_null_from_objects_(false),
+      convert_negative_zero_to_int_(false),
       avoid_identity_hash_for_testing_(false),
       strategy_(NULL) {}
 
 void V8ValueConverterImpl::SetDateAllowed(bool val) {
   date_allowed_ = val;
 }
 
 void V8ValueConverterImpl::SetRegExpAllowed(bool val) {
   reg_exp_allowed_ = val;
 }
 
 void V8ValueConverterImpl::SetFunctionAllowed(bool val) {
   function_allowed_ = val;
 }
 
 void V8ValueConverterImpl::SetStripNullFromObjects(bool val) {
   strip_null_from_objects_ = val;
 }
 
+void V8ValueConverterImpl::SetConvertNegativeZeroToInt(bool val) {
+  convert_negative_zero_to_int_ = val;
+}
+
 void V8ValueConverterImpl::SetStrategy(Strategy* strategy) {
   strategy_ = strategy;
 }
 
 v8::Local<v8::Value> V8ValueConverterImpl::ToV8Value(
     const base::Value* value, v8::Local<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::EscapableHandleScope handle_scope(context->GetIsolate());
   return handle_scope.Escape(
       ToV8ValueImpl(context->GetIsolate(), context->Global(), value));
@@ skipping 150 matching lines @@
   }
 
   if (val->IsInt32())
     return base::MakeUnique<base::FundamentalValue>(
         val->ToInt32(isolate)->Value());
 
   if (val->IsNumber()) {
     double val_as_double = val.As<v8::Number>()->Value();
     if (!std::isfinite(val_as_double))
       return nullptr;
+    // Normally, this would be an integer, and fall into IsInt32(). But if the
+    // value is -0, it's treated internally as a double. Consumers are allowed
+    // to ignore this esoterica and treat it as an integer.
+    if (convert_negative_zero_to_int_ && val_as_double == 0.0)
+      return base::MakeUnique<base::FundamentalValue>(0);
     return base::MakeUnique<base::FundamentalValue>(val_as_double);
   }
 
   if (val->IsString()) {
     v8::String::Utf8Value utf8(val);
     return base::MakeUnique<base::StringValue>(
         std::string(*utf8, utf8.length()));
   }
 
   if (val->IsUndefined()) {
@@ skipping 222 matching lines @@
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     std::move(child));
   }
 
   return std::move(result);
 }
 
 }  // namespace content