DevTools: explicitly differentiate ints vs doubles in the protocol bindings.

third_party/WebKit/Source/platform/inspector_protocol/Values.cpp

 // Copyright 2016 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 "platform/inspector_protocol/Values.h"
 
 #include "platform/inspector_protocol/Parser.h"
 #include "platform/inspector_protocol/String16.h"
 
 #include <algorithm>
@@ skipping 59 matching lines @@
     dst->append('"');
 }
 
 } // anonymous namespace
 
 bool Value::asBoolean(bool*) const
 {
     return false;
 }
 
-bool Value::asNumber(double*) const
+bool Value::asDouble(double*) const
 {
     return false;
 }
 
-bool Value::asNumber(int*) const
+bool Value::asInteger(int*) const
 {
     return false;
 }
 
 bool Value::asString(String16*) const
 {
     return false;
 }
 
 String16 Value::toJSONString() const
@@ skipping 16 matching lines @@
 }
 
 bool FundamentalValue::asBoolean(bool* output) const
 {
     if (type() != TypeBoolean)
         return false;
     *output = m_boolValue;
     return true;
 }
 
-bool FundamentalValue::asNumber(double* output) const
+bool FundamentalValue::asDouble(double* output) const
 {
-    if (type() != TypeNumber)
-        return false;
-    *output = m_doubleValue;
-    return true;
+    if (type() == TypeDouble) {
+        *output = m_doubleValue;
+        return true;
+    }
+    if (type() == TypeInteger) {
+        *output = m_integerValue;
+        return true;
+    }
+    return false;
 }
 
-bool FundamentalValue::asNumber(int* output) const
+bool FundamentalValue::asInteger(int* output) const
 {
-    if (type() != TypeNumber)
+    if (type() != TypeInteger)
         return false;
-    *output = static_cast<int>(m_doubleValue);
+    *output = m_integerValue;
     return true;
 }
 
 void FundamentalValue::writeJSON(String16Builder* output) const
 {
-    DCHECK(type() == TypeBoolean || type() == TypeNumber);
+    DCHECK(type() == TypeBoolean || type() == TypeInteger || type() == TypeDouble);
     if (type() == TypeBoolean) {
         if (m_boolValue)
             output->append(trueString, 4);
         else
             output->append(falseString, 5);
-    } else if (type() == TypeNumber) {
+    } else if (type() == TypeDouble) {
         if (!std::isfinite(m_doubleValue)) {
             output->append(nullString, 4);
             return;
         }
         output->append(String16::fromDouble(m_doubleValue));
+    } else if (type() == TypeInteger) {
+        output->append(String16::fromInteger(m_integerValue));
     }
 }
 
 std::unique_ptr<Value> FundamentalValue::clone() const
 {
-    return type() == TypeNumber ? FundamentalValue::create(m_doubleValue) : FundamentalValue::create(m_boolValue);
+    switch (type()) {
+    case TypeDouble: return FundamentalValue::create(m_doubleValue);
+    case TypeInteger: return FundamentalValue::create(m_integerValue);
+    case TypeBoolean: return FundamentalValue::create(m_boolValue);
+    default:
+        NOTREACHED();
+    }
+    return nullptr;
 }
 
 bool StringValue::asString(String16* output) const
 {
     *output = m_stringValue;
     return true;
 }
 
 void StringValue::writeJSON(String16Builder* output) const
 {
     DCHECK(type() == TypeString);
     doubleQuoteStringForJSON(m_stringValue, output);
 }
 
 std::unique_ptr<Value> StringValue::clone() const
 {
     return StringValue::create(m_stringValue);
 }
 
 DictionaryValue::~DictionaryValue()
 {
 }
 
 void DictionaryValue::setBoolean(const String16& name, bool value)
 {
     setValue(name, FundamentalValue::create(value));
 }
 
-void DictionaryValue::setNumber(const String16& name, double value)
+void DictionaryValue::setInteger(const String16& name, int value)
 {
     setValue(name, FundamentalValue::create(value));
 }
+
+void DictionaryValue::setDouble(const String16& name, double value)
+{
+    setValue(name, FundamentalValue::create(value));
+}
 
 void DictionaryValue::setString(const String16& name, const String16& value)
 {
     setValue(name, StringValue::create(value));
 }
 
 void DictionaryValue::setValue(const String16& name, std::unique_ptr<Value> value)
 {
     set(name, value);
 }
 
 void DictionaryValue::setObject(const String16& name, std::unique_ptr<DictionaryValue> value)
 {
     set(name, value);
 }
 
 void DictionaryValue::setArray(const String16& name, std::unique_ptr<ListValue> value)
 {
     set(name, value);
 }
 
 bool DictionaryValue::getBoolean(const String16& name, bool* output) const
 {
     protocol::Value* value = get(name);
     if (!value)
         return false;
     return value->asBoolean(output);
 }
 
+bool DictionaryValue::getInteger(const String16& name, int* output) const
+{
+    Value* value = get(name);
+    if (!value)
+        return false;
+    return value->asInteger(output);
+}
+
+bool DictionaryValue::getDouble(const String16& name, double* output) const
+{
+    Value* value = get(name);
+    if (!value)
+        return false;
+    return value->asDouble(output);
+}
+
 bool DictionaryValue::getString(const String16& name, String16* output) const
 {
     protocol::Value* value = get(name);
     if (!value)
         return false;
     return value->asString(output);
 }
 
 DictionaryValue* DictionaryValue::getObject(const String16& name) const
 {
@@ skipping 19 matching lines @@
     return std::make_pair(key, m_data.find(key)->second.get());
 }
 
 bool DictionaryValue::booleanProperty(const String16& name, bool defaultValue) const
 {
     bool result = defaultValue;
     getBoolean(name, &result);
     return result;
 }
 
-double DictionaryValue::numberProperty(const String16& name, double defaultValue) const
+int DictionaryValue::integerProperty(const String16& name, int defaultValue) const
 {
-    double result = defaultValue;
-    getNumber(name, &result);
+    int result = defaultValue;
+    getInteger(name, &result);
     return result;
 }
 
+double DictionaryValue::doubleProperty(const String16& name, double defaultValue) const
+{
+    double result = defaultValue;
+    getDouble(name, &result);
+    return result;
+}
+
 void DictionaryValue::remove(const String16& name)
 {
     m_data.erase(name);
     m_order.erase(std::remove(m_order.begin(), m_order.end(), name), m_order.end());
 }
 
 void DictionaryValue::writeJSON(String16Builder* output) const
 {
     output->append('{');
     for (size_t i = 0; i < m_order.size(); ++i) {
@@ skipping 62 matching lines @@
 }
 
 protocol::Value* ListValue::at(size_t index)
 {
     DCHECK_LT(index, m_data.size());
     return m_data[index].get();
 }
 
 } // namespace protocol
 } // namespace blink