DevTools: always use 16bit strings for inspector protocol.

third_party/WebKit/Source/platform/v8_inspector/V8StringUtil.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/v8_inspector/V8StringUtil.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8Regex.h"
 #include "platform/v8_inspector/public/V8ContentSearchUtil.h"
@@ skipping 107 matching lines @@
     if (text.isEmpty())
         return result;
 
     OwnPtr<protocol::Vector<unsigned>> endings(lineEndings(text));
     unsigned size = endings->size();
     unsigned start = 0;
     for (unsigned lineNumber = 0; lineNumber < size; ++lineNumber) {
         unsigned lineEnd = endings->at(lineNumber);
         String16 line = text.substring(start, lineEnd - start);
         if (line.endsWith('\r'))
-            line = line.left(line.length() - 1);
+            line = line.substring(0, line.length() - 1);
 
         int matchLength;
         if (regex.match(line, 0, &matchLength) != -1)
             result.append(std::pair<int, String16>(lineNumber, line));
 
         start = lineEnd + 1;
     }
     return result;
 }
 
 PassOwnPtr<protocol::Debugger::SearchMatch> buildObjectForSearchMatch(int lineNumber, const String16& lineContent)
 {
     return protocol::Debugger::SearchMatch::create()
         .setLineNumber(lineNumber)
         .setLineContent(lineContent)
         .build();
 }
 
 PassOwnPtr<V8Regex> createSearchRegex(V8DebuggerImpl* debugger, const String16& query, bool caseSensitive, bool isRegex)
 {
     String16 regexSource = isRegex ? query : createSearchRegexSource(query);
     return adoptPtr(new V8Regex(debugger, regexSource, caseSensitive));
 }
 
 } // namespace
 
 v8::Local<v8::String> toV8String(v8::Isolate* isolate, const String16& string)
 {
-    if (string.isNull())
+    if (string.isEmpty())
         return v8::String::Empty(isolate);
-    if (string.is8Bit())
-        return v8::String::NewFromOneByte(isolate, string.characters8(), v8::NewStringType::kNormal, string.length()).ToLocalChecked();
     return v8::String::NewFromTwoByte(isolate, reinterpret_cast<const uint16_t*>(string.characters16()), v8::NewStringType::kNormal, string.length()).ToLocalChecked();
 }
 
 v8::Local<v8::String> toV8StringInternalized(v8::Isolate* isolate, const String16& string)
 {
-    if (string.isNull())
+    if (string.isEmpty())
         return v8::String::Empty(isolate);
-    if (string.is8Bit())
-        return v8::String::NewFromOneByte(isolate, string.characters8(), v8::NewStringType::kInternalized, string.length()).ToLocalChecked();
     return v8::String::NewFromTwoByte(isolate, reinterpret_cast<const uint16_t*>(string.characters16()), v8::NewStringType::kInternalized, string.length()).ToLocalChecked();
 }
 
 String16 toProtocolString(v8::Local<v8::String> value)
 {
     if (value.IsEmpty() || value->IsNull() || value->IsUndefined())
         return String16();
     UChar* buffer;
     String16 result = String16::createUninitialized(value->Length(), buffer);
     value->Write(reinterpret_cast<uint16_t*>(buffer), 0, value->Length());
@@ skipping 95 matching lines @@
                 return nullptr;
             jsonObject->setValue(toProtocolString(propertyName), propertyValue.release());
         }
         return jsonObject.release();
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 } // namespace blink