Introduce String::fromUTF8Lenient() and use it for cache_name in CacheStorage API.

third_party/WebKit/Source/wtf/text/UTF8.cpp

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 167 matching lines @@
         target += bytesToWrite;
     }
     *sourceStart = source;
     *targetStart = target;
     return result;
 }
 
 // This must be called with the length pre-determined by the first byte.
 // If presented with a length > 4, this returns false.  The Unicode
 // definition of UTF-8 goes up to 4-byte sequences.
-static bool isLegalUTF8(const unsigned char* source, int length)
+static bool isLegalUTF8(const unsigned char* source, int length, bool strict = true)
 {
     unsigned char a;
     const unsigned char* srcptr = source + length;
     switch (length) {
     default:
         return false;
     // Everything else falls through when "true"...
     case 4:
         if ((a = (*--srcptr)) < 0x80 || a > 0xBF)
             return false;
     case 3:
         if ((a = (*--srcptr)) < 0x80 || a > 0xBF)
             return false;
     case 2:
         if ((a = (*--srcptr)) > 0xBF)
             return false;
 
         // no fall-through in this inner switch
         switch (*source) {
         case 0xE0:
             if (a < 0xA0)
                 return false;
             break;
         case 0xED:
-            if (a > 0x9F)
+            // Surrogate values are mapped to [EDA080-EDAFBF] and [EDB080-EDBFBF] in lenient mode.
+            if (strict && a > 0x9F)
                 return false;
             break;
         case 0xF0:
             if (a < 0x90)
                 return false;
             break;
         case 0xF4:
             if (a > 0x8F)
                 return false;
             break;
@@ skipping 52 matching lines @@
     const char* source = *sourceStart;
     UChar* target = *targetStart;
     UChar orAllData = 0;
     while (source < sourceEnd) {
         int utf8SequenceLength = inlineUTF8SequenceLength(*source);
         if (sourceEnd - source < utf8SequenceLength)  {
             result = sourceExhausted;
             break;
         }
         // Do this check whether lenient or strict
-        if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(source), utf8SequenceLength)) {
+        if (!isLegalUTF8(reinterpret_cast<const unsigned char*>(source), utf8SequenceLength, strict)) {
             result = sourceIllegal;
             break;
         }
 
         UChar32 character = readUTF8Sequence(source, utf8SequenceLength);
 
         if (target >= targetEnd) {
             source -= utf8SequenceLength; // Back up source pointer!
             result = targetExhausted;
             break;
         }
 
         if (U_IS_BMP(character)) {
             // UTF-16 surrogate values are illegal in UTF-32
             if (U_IS_SURROGATE(character)) {
                 if (strict) {
                     source -= utf8SequenceLength; // return to the illegal value itself
                     result = sourceIllegal;
                     break;
                 }
-                *target++ = replacementCharacter;
-                orAllData |= replacementCharacter;
+                *target++ = static_cast<UChar>(character);
+                orAllData |= character;
             } else {
                 *target++ = static_cast<UChar>(character); // normal case
                 orAllData |= character;
             }
         } else if (U_IS_SUPPLEMENTARY(character)) {
             // target is a character in range 0xFFFF - 0x10FFFF
             if (target + 1 >= targetEnd) {
                 source -= utf8SequenceLength; // Back up source pointer!
                 result = targetExhausted;
                 break;
@@ skipping 118 matching lines @@
     return equalWithUTF8Internal(a, aEnd, b, bEnd);
 }
 
 bool equalLatin1WithUTF8(const LChar* a, const LChar* aEnd, const char* b, const char* bEnd)
 {
     return equalWithUTF8Internal(a, aEnd, b, bEnd);
 }
 
 } // namespace Unicode
 } // namespace WTF