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

third_party/WebKit/Source/platform/v8_inspector/V8ProfilerAgentImpl.cpp

 // Copyright 2015 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/v8_inspector/V8ProfilerAgentImpl.h"
 
 #include "platform/v8_inspector/Atomics.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
@@ skipping 40 matching lines @@
     const int childrenCount = node->GetChildrenCount();
     for (int i = 0; i < childrenCount; i++) {
         const v8::CpuProfileNode* child = node->GetChild(i);
         children->addItem(buildInspectorObjectFor(isolate, child));
     }
 
     std::unique_ptr<protocol::Array<protocol::Profiler::PositionTickInfo>> positionTicks = buildInspectorObjectForPositionTicks(node);
 
     std::unique_ptr<protocol::Profiler::CPUProfileNode> result = protocol::Profiler::CPUProfileNode::create()
         .setFunctionName(toProtocolString(node->GetFunctionName()))
-        .setScriptId(String16::number(node->GetScriptId()))
+        .setScriptId(String16::fromInteger(node->GetScriptId()))
         .setUrl(toProtocolString(node->GetScriptResourceName()))
         .setLineNumber(node->GetLineNumber())
         .setColumnNumber(node->GetColumnNumber())
         .setHitCount(node->GetHitCount())
         .setCallUID(node->GetCallUid())
         .setChildren(std::move(children))
         .setPositionTicks(std::move(positionTicks))
         .setDeoptReason(node->GetBailoutReason())
         .setId(node->GetNodeId()).build();
     return result;
@@ skipping 126 matching lines @@
     m_enabled = false;
     m_state->setBoolean(ProfilerAgentState::profilerEnabled, false);
 }
 
 void V8ProfilerAgentImpl::setSamplingInterval(ErrorString* error, int interval)
 {
     if (m_recordingCPUProfile) {
         *error = "Cannot change sampling interval when profiling.";
         return;
     }
-    m_state->setNumber(ProfilerAgentState::samplingInterval, interval);
+    m_state->setInteger(ProfilerAgentState::samplingInterval, interval);
     m_isolate->GetCpuProfiler()->SetSamplingInterval(interval);
 }
 
 void V8ProfilerAgentImpl::restore()
 {
     DCHECK(!m_enabled);
     if (!m_state->booleanProperty(ProfilerAgentState::profilerEnabled, false))
         return;
     m_enabled = true;
     int interval = 0;
-    m_state->getNumber(ProfilerAgentState::samplingInterval, &interval);
+    m_state->getInteger(ProfilerAgentState::samplingInterval, &interval);
     if (interval)
         m_isolate->GetCpuProfiler()->SetSamplingInterval(interval);
     if (m_state->booleanProperty(ProfilerAgentState::userInitiatedProfiling, false)) {
         ErrorString error;
         start(&error);
     }
 }
 
 void V8ProfilerAgentImpl::start(ErrorString* error)
 {
@@ skipping 24 matching lines @@
         if (!profile->get() && errorString)
             *errorString = "Profile is not found";
     }
     m_frontendInitiatedProfileId = String16();
     m_state->setBoolean(ProfilerAgentState::userInitiatedProfiling, false);
     m_session->client()->profilingStopped();
 }
 
 String16 V8ProfilerAgentImpl::nextProfileId()
 {
-    return String16::number(atomicIncrement(&s_lastProfileId));
+    return String16::fromInteger(atomicIncrement(&s_lastProfileId));
 }
 
 void V8ProfilerAgentImpl::startProfiling(const String16& title)
 {
     v8::HandleScope handleScope(m_isolate);
     m_isolate->GetCpuProfiler()->StartProfiling(toV8String(m_isolate, title), true);
 }
 
 std::unique_ptr<protocol::Profiler::CPUProfile> V8ProfilerAgentImpl::stopProfiling(const String16& title, bool serialize)
 {
     v8::HandleScope handleScope(m_isolate);
     v8::CpuProfile* profile = m_isolate->GetCpuProfiler()->StopProfiling(toV8String(m_isolate, title));
     if (!profile)
         return nullptr;
     std::unique_ptr<protocol::Profiler::CPUProfile> result;
     if (serialize)
         result = createCPUProfile(m_isolate, profile);
     profile->Delete();
     return result;
 }
 
 bool V8ProfilerAgentImpl::isRecording() const
 {
     return m_recordingCPUProfile || !m_startedProfiles.empty();
 }
 
 } // namespace blink