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

src/inspector/string-16.cc

 // 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/string-16.h"
 #include "src/base/platform/platform.h"
 #include "src/inspector/protocol-platform.h"
 
 #include <algorithm>
 #include <cctype>
 #include <cstdlib>
 #include <cstring>
+#include <limits>
 #include <locale>
 #include <string>
 
 namespace v8_inspector {
 
 namespace {
 
 bool isASCII(UChar c) { return !(c & ~0x7F); }
 
 bool isSpaceOrNewLine(UChar c) {
   return isASCII(c) && c <= ' ' && (c == ' ' || (c <= 0xD && c >= 0x9));
 }
 
 int charactersToInteger(const UChar* characters, size_t length,
                         bool* ok = nullptr) {
   std::vector<char> buffer;
   buffer.reserve(length + 1);
   for (size_t i = 0; i < length; ++i) {
     if (!isASCII(characters[i])) {
       if (ok) *ok = false;
       return 0;
     }
     buffer.push_back(static_cast<char>(characters[i]));
   }
   buffer.push_back('\0');
 
   char* endptr;
-  int result = std::strtol(buffer.data(), &endptr, 10);
-  if (ok) *ok = !(*endptr);
-  return result;
+  long result = std::strtol(buffer.data(), &endptr, 10);
+  if (ok) {
+    *ok = !(*endptr) && result <= std::numeric_limits<int>::max() &&
+          result >= std::numeric_limits<int>::min();
+  }
+  return static_cast<int>(result);
 }
 
 const UChar replacementCharacter = 0xFFFD;
 using UChar32 = uint32_t;
 
 inline int inlineUTF8SequenceLengthNonASCII(char b0) {
   if ((b0 & 0xC0) != 0xC0) return 0;
   if ((b0 & 0xE0) == 0xC0) return 2;
   if ((b0 & 0xF0) == 0xE0) return 3;
   if ((b0 & 0xF8) == 0xF0) return 4;
@@ skipping 188 matching lines @@
 // Magic values subtracted from a buffer value during UTF8 conversion.
 // This table contains as many values as there might be trailing bytes
 // in a UTF-8 sequence.
 static const UChar32 offsetsFromUTF8[6] = {0x00000000UL,
                                            0x00003080UL,
                                            0x000E2080UL,
                                            0x03C82080UL,
                                            static_cast<UChar32>(0xFA082080UL),
                                            static_cast<UChar32>(0x82082080UL)};
 
-static inline UChar32 readUTF8Sequence(const char*& sequence, unsigned length) {
+static inline UChar32 readUTF8Sequence(const char*& sequence, size_t length) {
   UChar32 character = 0;
 
   // The cases all fall through.
   switch (length) {
     case 6:
       character += static_cast<unsigned char>(*sequence++);
       character <<= 6;
     case 5:
       character += static_cast<unsigned char>(*sequence++);
       character <<= 6;
@@ skipping 97 matching lines @@
 
 // static
 String16 String16::fromInteger(int number) {
   const size_t kBufferSize = 50;
   char buffer[kBufferSize];
   v8::base::OS::SNPrintF(buffer, kBufferSize, "%d", number);
   return String16(buffer);
 }
 
 // static
+String16 String16::fromInteger(size_t number) {
+  const size_t kBufferSize = 50;
+  char buffer[kBufferSize];
+  std::snprintf(buffer, kBufferSize, "%zu", number);
+  return String16(buffer);
+}
+
+// static
 String16 String16::fromDouble(double number) {
   const size_t kBufferSize = 100;
   char buffer[kBufferSize];
   v8::base::OS::SNPrintF(buffer, kBufferSize, "%f", number);
   return String16(buffer);
 }
 
 // static
 String16 String16::fromDoublePrecision3(double number) {
   const size_t kBufferSize = 100;
@@ skipping 10 matching lines @@
   return String16(buffer);
 }
 
 int String16::toInteger(bool* ok) const {
   return charactersToInteger(characters16(), length(), ok);
 }
 
 String16 String16::stripWhiteSpace() const {
   if (!length()) return String16();
 
-  unsigned start = 0;
-  unsigned end = length() - 1;
+  size_t start = 0;
+  size_t end = length() - 1;
 
   // skip white space from start
   while (start <= end && isSpaceOrNewLine(characters16()[start])) ++start;
 
   // only white space
   if (start > end) return String16();
 
   // skip white space from end
   while (end && isSpaceOrNewLine(characters16()[end])) --end;
 
@@ skipping 37 matching lines @@
   std::vector<UChar> buffer(length);
   UChar* bufferStart = buffer.data();
 
   UChar* bufferCurrent = bufferStart;
   const char* stringCurrent = stringStart;
   if (convertUTF8ToUTF16(&stringCurrent, stringStart + length, &bufferCurrent,
                          bufferCurrent + buffer.size(), 0,
                          true) != conversionOK)
     return String16();
 
-  unsigned utf16Length = bufferCurrent - bufferStart;
+  size_t utf16Length = bufferCurrent - bufferStart;
   return String16(bufferStart, utf16Length);
 }
 
 std::string String16::utf8() const {
-  unsigned length = this->length();
+  size_t length = this->length();
 
   if (!length) return std::string("");
 
   // Allocate a buffer big enough to hold all the characters
   // (an individual UTF-16 UChar can only expand to 3 UTF-8 bytes).
   // Optimization ideas, if we find this function is hot:
   //  * We could speculatively create a CStringBuffer to contain 'length'
   //    characters, and resize if necessary (i.e. if the buffer contains
   //    non-ascii characters). (Alternatively, scan the buffer first for
   //    ascii characters, so we know this will be sufficient).
@@ skipping 26 matching lines @@
     // There should be room left, since one UChar hasn't been
     // converted.
     DCHECK((buffer + 3) <= (buffer + bufferVector.size()));
     putUTF8Triple(buffer, *characters);
   }
 
   return std::string(bufferVector.data(), buffer - bufferVector.data());
 }
 
 }  // namespace v8_inspector