[inspector] fixed all shorten-64-to-32 warnings

src/inspector/StringUtil.cpp

 // Copyright 2016 the V8 project 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 "src/inspector/StringUtil.h"
 
 #include "src/inspector/protocol/Protocol.h"
 
 namespace v8_inspector {
 
 v8::Local<v8::String> toV8String(v8::Isolate* isolate, const String16& string) {
   if (string.isEmpty()) return v8::String::Empty(isolate);
+  DCHECK(string.length() < v8::String::kMaxLength);
   return v8::String::NewFromTwoByte(
              isolate, reinterpret_cast<const uint16_t*>(string.characters16()),
-             v8::NewStringType::kNormal, string.length())
+             v8::NewStringType::kNormal, static_cast<int>(string.length()))
       .ToLocalChecked();
 }
 
 v8::Local<v8::String> toV8StringInternalized(v8::Isolate* isolate,
                                              const String16& string) {
   if (string.isEmpty()) return v8::String::Empty(isolate);
+  DCHECK(string.length() < v8::String::kMaxLength);
   return v8::String::NewFromTwoByte(
              isolate, reinterpret_cast<const uint16_t*>(string.characters16()),
-             v8::NewStringType::kInternalized, string.length())
+             v8::NewStringType::kInternalized,
+             static_cast<int>(string.length()))
       .ToLocalChecked();
 }
 
 v8::Local<v8::String> toV8StringInternalized(v8::Isolate* isolate,
                                              const char* str) {
   return v8::String::NewFromUtf8(isolate, str, v8::NewStringType::kInternalized)
       .ToLocalChecked();
 }
 
 v8::Local<v8::String> toV8String(v8::Isolate* isolate,
                                  const StringView& string) {
   if (!string.length()) return v8::String::Empty(isolate);
+  DCHECK(string.length() < v8::String::kMaxLength);
   if (string.is8Bit())
     return v8::String::NewFromOneByte(
                isolate, reinterpret_cast<const uint8_t*>(string.characters8()),
-               v8::NewStringType::kNormal, string.length())
+               v8::NewStringType::kNormal, static_cast<int>(string.length()))
         .ToLocalChecked();
   return v8::String::NewFromTwoByte(
              isolate, reinterpret_cast<const uint16_t*>(string.characters16()),
-             v8::NewStringType::kNormal, string.length())
+             v8::NewStringType::kNormal, static_cast<int>(string.length()))
       .ToLocalChecked();
 }
 
 String16 toProtocolString(v8::Local<v8::String> value) {
   if (value.IsEmpty() || value->IsNull() || value->IsUndefined())
     return String16();
   std::unique_ptr<UChar[]> buffer(new UChar[value->Length()]);
   value->Write(reinterpret_cast<uint16_t*>(buffer.get()), 0, value->Length());
   return String16(buffer.get(), value->Length());
 }
@@ skipping 29 matching lines @@
       if (string.characters16()[i] != prefix[j]) return false;
     }
   }
   return true;
 }
 
 namespace protocol {
 
 std::unique_ptr<protocol::Value> parseJSON(const StringView& string) {
   if (!string.length()) return nullptr;
+  DCHECK(string.length() <= std::numeric_limits<int>::max());
   if (string.is8Bit())

[dgozman, 2016/09/12 22:44:25]

{}

[kozy, 2016/09/12 23:02:59]

Done.

-    return protocol::parseJSON(string.characters8(), string.length());
-  return protocol::parseJSON(string.characters16(), string.length());
+    return protocol::parseJSON(string.characters8(),
+                               static_cast<int>(string.length()));
+  return protocol::parseJSON(string.characters16(),
+                             static_cast<int>(string.length()));
 }
 
 std::unique_ptr<protocol::Value> parseJSON(const String16& string) {
   if (!string.length()) return nullptr;
-  return protocol::parseJSON(string.characters16(), string.length());
+  DCHECK(string.length() <= std::numeric_limits<int>::max());
+  return protocol::parseJSON(string.characters16(),
+                             static_cast<int>(string.length()));
 }
 
 }  // namespace protocol
 
 std::unique_ptr<protocol::Value> toProtocolValue(v8::Local<v8::Context> context,
                                                  v8::Local<v8::Value> value,
                                                  int maxDepth) {
   if (value.IsEmpty()) {
     UNREACHABLE();
     return nullptr;
@@ skipping 74 matching lines @@
 std::unique_ptr<StringBufferImpl> StringBufferImpl::adopt(String16& string) {
   return wrapUnique(new StringBufferImpl(string));
 }
 
 StringBufferImpl::StringBufferImpl(String16& string) {
   m_owner.swap(string);
   m_string = toStringView(m_owner);
 }
 
 }  // namespace v8_inspector