[DevTools] Reduce API surface of String16.

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/V8InspectorImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8Regex.h"
 
 namespace blink {
 
 namespace {
 
 String16 findMagicComment(const String16& content, const String16& name, bool multiline, bool* deprecated)
 {
-    DCHECK(name.find("=") == kNotFound);
+    DCHECK(name.find("=") == String16::kNotFound);
     if (deprecated)
         *deprecated = false;
 
     unsigned length = content.length();
     unsigned nameLength = name.length();
 
     size_t pos = length;
     size_t equalSignPos = 0;
     size_t closingCommentPos = 0;
     while (true) {
         pos = content.reverseFind(name, pos);
-        if (pos == kNotFound)
+        if (pos == String16::kNotFound)
             return String16();
 
         // Check for a /\/[\/*][@#][ \t]/ regexp (length of 4) before found name.
         if (pos < 4)
             return String16();
         pos -= 4;
         if (content[pos] != '/')
             continue;
         if ((content[pos + 1] != '/' || multiline)
             && (content[pos + 1] != '*' || !multiline))
             continue;
         if (content[pos + 2] != '#' && content[pos + 2] != '@')
             continue;
         if (content[pos + 3] != ' ' && content[pos + 3] != '\t')
             continue;
         equalSignPos = pos + 4 + nameLength;
         if (equalSignPos < length && content[equalSignPos] != '=')
             continue;
         if (multiline) {
             closingCommentPos = content.find("*/", equalSignPos + 1);
-            if (closingCommentPos == kNotFound)
+            if (closingCommentPos == String16::kNotFound)
                 return String16();
         }
 
         break;
     }
 
     if (deprecated && content[pos + 2] == '@')
         *deprecated = true;
 
     DCHECK(equalSignPos);
     DCHECK(!multiline || closingCommentPos);
     size_t urlPos = equalSignPos + 1;
     String16 match = multiline
         ? content.substring(urlPos, closingCommentPos - urlPos)
         : content.substring(urlPos);
 
     size_t newLine = match.find("\n");
-    if (newLine != kNotFound)
+    if (newLine != String16::kNotFound)
         match = match.substring(0, newLine);
     match = match.stripWhiteSpace();
 
-    String16 disallowedChars("\"' \t");
     for (unsigned i = 0; i < match.length(); ++i) {
-        if (disallowedChars.find(match[i]) != kNotFound)
+        UChar c = match[i];
+        if (c == '"' || c == '\'' || c == ' ' || c == '\t')
             return "";
     }
 
     return match;
 }
 
 String16 createSearchRegexSource(const String16& text)
 {
     String16Builder result;
     String16 specials("[](){}+-*.,?\\^$|");

[caseq, 2016/08/13 00:28:54]

unused now?

[dgozman, 2016/08/13 04:49:59]

Done.

 
     for (unsigned i = 0; i < text.length(); i++) {
-        if (specials.find(text[i]) != kNotFound)
+        UChar c = text[i];
+        if (c == '[' || c == ']' || c == '(' || c == ')' || c == '{' || c == '}'
+            || c == '+' || c == '-' || c == '*' || c == '.' || c == ',' || c == '?'
+            || c == '\\' || c == '^' || c == '$' || c == '|') {
             result.append('\\');
+        }
         result.append(text[i]);
     }
 
     return result.toString();
 }
 
 std::unique_ptr<std::vector<unsigned>> lineEndings(const String16& text)
 {
     std::unique_ptr<std::vector<unsigned>> result(new std::vector<unsigned>());
 
+    const String16 lineEndString = "\n";
     unsigned start = 0;
     while (start < text.length()) {
-        size_t lineEnd = text.find('\n', start);
-        if (lineEnd == kNotFound)
+        size_t lineEnd = text.find(lineEndString, start);
+        if (lineEnd == String16::kNotFound)
             break;
 
         result->push_back(static_cast<unsigned>(lineEnd));
         start = lineEnd + 1;
     }
     result->push_back(text.length());
 
     return result;
 }
 
 std::vector<std::pair<int, String16>> scriptRegexpMatchesByLines(const V8Regex& regex, const String16& text)
 {
     std::vector<std::pair<int, String16>> result;
     if (text.isEmpty())
         return result;
 
     std::unique_ptr<std::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'))
+        if (line.length() && line[line.length() - 1] == '\r')
             line = line.substring(0, line.length() - 1);
 
         int matchLength;
         if (regex.match(line, 0, &matchLength) != -1)
             result.push_back(std::pair<int, String16>(lineNumber, line));
 
         start = lineEnd + 1;
     }
     return result;
 }
@@ skipping 137 matching lines @@
                 return nullptr;
             jsonObject->setValue(toProtocolString(propertyName), std::move(propertyValue));
         }
         return std::move(jsonObject);
     }
     NOTREACHED();
     return nullptr;
 }
 
 } // namespace blink