[inspector] enabled presubmit for inspector sub folder

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>
 
+#include "src/base/platform/platform.h"
+#include "src/inspector/protocol-platform.h"
+
 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;
-  long result = std::strtol(buffer.data(), &endptr, 10);
+  int64_t result =
+      static_cast<int64_t>(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;
 
@@ skipping 25 matching lines @@
 } ConversionResult;
 
 ConversionResult convertUTF16ToUTF8(const UChar** sourceStart,
                                     const UChar* sourceEnd, char** targetStart,
                                     char* targetEnd, bool strict) {
   ConversionResult result = conversionOK;
   const UChar* source = *sourceStart;
   char* target = *targetStart;
   while (source < sourceEnd) {
     UChar32 ch;
-    unsigned short bytesToWrite = 0;
+    uint32_t bytesToWrite = 0;
     const UChar32 byteMask = 0xBF;
     const UChar32 byteMark = 0x80;
     const UChar* oldSource =
         source;  // In case we have to back up because of target overflow.
-    ch = static_cast<unsigned short>(*source++);
+    ch = static_cast<uint16_t>(*source++);
     // If we have a surrogate pair, convert to UChar32 first.
     if (ch >= 0xD800 && ch <= 0xDBFF) {
       // If the 16 bits following the high surrogate are in the source buffer...
       if (source < sourceEnd) {
-        UChar32 ch2 = static_cast<unsigned short>(*source);
+        UChar32 ch2 = static_cast<uint16_t>(*source);
         // If it's a low surrogate, convert to UChar32.
         if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
           ch = ((ch - 0xD800) << 10) + (ch2 - 0xDC00) + 0x0010000;
           ++source;
         } else if (strict) {  // it's an unpaired high surrogate
           --source;           // return to the illegal value itself
           result = sourceIllegal;
           break;
         }
       } else {     // We don't have the 16 bits following the high surrogate.
@@ skipping 25 matching lines @@
 
     target += bytesToWrite;
     if (target > targetEnd) {
       source = oldSource;  // Back up source pointer!
       target -= bytesToWrite;
       result = targetExhausted;
       break;
     }
     switch (bytesToWrite) {  // note: everything falls through.
       case 4:
-        *--target = (char)((ch | byteMark) & byteMask);
+        *--target = static_cast<char>((ch | byteMark) & byteMask);
         ch >>= 6;
       case 3:
-        *--target = (char)((ch | byteMark) & byteMask);
+        *--target = static_cast<char>((ch | byteMark) & byteMask);
         ch >>= 6;
       case 2:
-        *--target = (char)((ch | byteMark) & byteMask);
+        *--target = static_cast<char>((ch | byteMark) & byteMask);
         ch >>= 6;
       case 1:
-        *--target = (char)(ch | firstByteMark[bytesToWrite]);
+        *--target = static_cast<char>(ch | firstByteMark[bytesToWrite]);
     }
     target += bytesToWrite;
   }
   *sourceStart = source;
   *targetStart = target;
   return result;
 }
 
 /**
  * Is this code point a BMP code point (U+0000..U+ffff)?
@@ skipping 349 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