Reland "Add UnencodableHandling::kNoUnencodables"

This reverts commit 303d77a1.

Reason for revert: Did not fix the issue

Original change's description:
> Revert "Add UnencodableHandling::kNoUnencodables"
> 
> This reverts commit b4edab24.
> 
> Reason for revert: 
> 
> Webkit tests on Android nx4 are failing since:
> https://ci.chromium.org/buildbot/chromium.webkit/WebKit%20Android%20%28Nexus4%29/82322
> 
> speculative revert (sorry) since this is the only CL in the blame list realted to text encoding and the error says:
> 
> "
> UnicodeDecodeError raised: 'ascii' codec can't decode byte 0xe2 in position 146896: ordinal not in range(128)
> ...
> "
> 
> Original change's description:
> > Add UnencodableHandling::kNoUnencodables
> > 
> > The are no unencodable characters in UTF-8, however previously callers
> > to blink::TextCoder::Encode had to pass a dummy UnencodableHandling
> > argument. Add a kNoUnencodables value to the UnencodableHandling which is
> > an explicit no-op. Also add DCHECKs that is is only used for UTF-8 or
> > UTF-16.
> > 
> > Convert callers to use kNoUnencodables where the encoding is statically
> > known to be UTF-8.
> > 
> > It's still valid to use other values for the UnencodableHandling
> > argument with UTF-8 or UTF-16; kNoUnencodables simply documents that it
> > makes no difference.
> > 
> > Change-Id: I5eebe4c76ae4006ee91f3884f94ec3b5e410685b
> > Reviewed-on: https://chromium-review.googlesource.com/1206055
> > Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
> > Reviewed-by: Kentaro Hara <haraken@chromium.org>
> > Reviewed-by: Joshua Bell <jsbell@chromium.org>
> > Commit-Queue: Adam Rice <ricea@chromium.org>
> > Cr-Commit-Position: refs/heads/master@{#589451}
> 
> TBR=jsbell@chromium.org,ricea@chromium.org,yhirano@chromium.org,haraken@chromium.org
> 
> Change-Id: Iaddd13dc7e2fe9473528710dcdaf080f50d01ecc
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://chromium-review.googlesource.com/1213085
> Reviewed-by: Markus Heintz <markusheintz@chromium.org>
> Commit-Queue: Markus Heintz <markusheintz@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#589501}

TBR=jsbell@chromium.org,ricea@chromium.org,markusheintz@chromium.org,yhirano@chromium.org,haraken@chromium.org

Change-Id: I51221bfefd2e5d9505b05615ab38e5b1602e2fdf
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/1213172Reviewed-by: Markus Heintz <markusheintz@chromium.org>
Commit-Queue: Markus Heintz <markusheintz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589510}

third_party/blink/renderer/core/fetch/form_data_bytes_consumer.cc

@@ -475,7 +475,7 @@ class ComplexFormDataBytesConsumer final : public BytesConsumer {
 
 FormDataBytesConsumer::FormDataBytesConsumer(const String& string)
     : impl_(new SimpleFormDataBytesConsumer(EncodedFormData::Create(
-          UTF8Encoding().Encode(string, WTF::kEntitiesForUnencodables)))) {}
+          UTF8Encoding().Encode(string, WTF::kNoUnencodables)))) {}
 
 FormDataBytesConsumer::FormDataBytesConsumer(DOMArrayBuffer* buffer)
     : FormDataBytesConsumer(buffer->Data(), buffer->ByteLength()) {}

third_party/blink/renderer/core/xmlhttprequest/xml_http_request.cc

@@ -836,7 +836,7 @@ void XMLHttpRequest::send(Document* document, ExceptionState& exception_state) {
     String body = CreateMarkup(document);
 
     http_body = EncodedFormData::Create(
-        UTF8Encoding().Encode(body, WTF::kEntitiesForUnencodables));
+        UTF8Encoding().Encode(body, WTF::kNoUnencodables));
   }
 
   CreateRequest(std::move(http_body), exception_state);
@@ -852,7 +852,7 @@ void XMLHttpRequest::send(const String& body, ExceptionState& exception_state) {
 
   if (!body.IsNull() && AreMethodAndURLValidForSend()) {
     http_body = EncodedFormData::Create(
-        UTF8Encoding().Encode(body, WTF::kEntitiesForUnencodables));
+        UTF8Encoding().Encode(body, WTF::kNoUnencodables));
     UpdateContentTypeAndCharset("text/plain;charset=UTF-8", "UTF-8");
   }
 

third_party/blink/renderer/modules/encoding/text_encoder.cc

@@ -67,10 +67,10 @@ NotShared<DOMUint8Array> TextEncoder::encode(const String& input) {
   // are present in the input.
   if (input.Is8Bit()) {
     result = codec_->Encode(input.Characters8(), input.length(),
-                            WTF::kEntitiesForUnencodables);
+                            WTF::kNoUnencodables);
   } else {
     result = codec_->Encode(input.Characters16(), input.length(),
-                            WTF::kEntitiesForUnencodables);
+                            WTF::kNoUnencodables);
   }
 
   const char* buffer = result.data();

third_party/blink/renderer/modules/encoding/text_encoder_stream.cc

@@ -60,14 +60,8 @@ class TextEncoderStream::Transformer final : public TransformStreamTransformer {
         // check is needed.
         prefix = ReplacementCharacterInUtf8();
       }
-      // Note that the third argument here is ignored since the encoding is
-      // UTF-8, which will use U+FFFD-replacement rather than ASCII fallback
-      // substitution when unencodable sequences (for instance, unpaired UTF-16
-      // surrogates) are present in the input.
-      // TODO(ricea): Add WTF::kNoUnencodables enum value to make this
-      // behaviour explicit for UTF-N encodings.
       result = encoder_->Encode(input.Characters8(), input.length(),
-                                WTF::kEntitiesForUnencodables);
+                                WTF::kNoUnencodables);
     } else {
       bool have_output =
           Encode16BitString(input, high_surrogate, &prefix, &result);
@@ -134,7 +128,7 @@ class TextEncoderStream::Transformer final : public TransformStreamTransformer {
         // Third argument is ignored, as above.
         *prefix =
             encoder_->Encode(astral_character, base::size(astral_character),
-                             WTF::kEntitiesForUnencodables);
+                             WTF::kNoUnencodables);
         ++begin;
         if (begin == end)
           return true;

third_party/blink/renderer/modules/push_messaging/push_message_data.cc

@@ -43,7 +43,7 @@ PushMessageData* PushMessageData::Create(
 
   if (message_data.IsUSVString()) {
     CString encoded_string = UTF8Encoding().Encode(
-        message_data.GetAsUSVString(), WTF::kEntitiesForUnencodables);
+        message_data.GetAsUSVString(), WTF::kNoUnencodables);
     return new PushMessageData(encoded_string.data(), encoded_string.length());
   }
 

third_party/blink/renderer/platform/blob/blob_data.cc

@@ -215,8 +215,7 @@ void BlobData::AppendText(const String& text,
                           bool do_normalize_line_endings_to_native) {
   DCHECK_EQ(file_composition_, FileCompositionStatus::NO_UNKNOWN_SIZE_FILES)
       << "Blobs with a unknown-size file cannot have other items.";
-  CString utf8_text =
-      UTF8Encoding().Encode(text, WTF::kEntitiesForUnencodables);
+  CString utf8_text = UTF8Encoding().Encode(text, WTF::kNoUnencodables);
 
   if (do_normalize_line_endings_to_native) {
     if (utf8_text.length() >

third_party/blink/renderer/platform/weborigin/kurl.cc

@@ -632,8 +632,8 @@ String DecodeURLEscapeSequences(const String& string,
 }
 
 String EncodeWithURLEscapeSequences(const String& not_encoded_string) {
-  CString utf8 = UTF8Encoding().Encode(not_encoded_string,
-                                       WTF::kURLEncodedEntitiesForUnencodables);
+  CString utf8 =
+      UTF8Encoding().Encode(not_encoded_string, WTF::kNoUnencodables);
 
   url::RawCanonOutputT<char> buffer;
   int input_length = utf8.length();

third_party/blink/renderer/platform/wtf/text/text_codec.cc

@@ -48,6 +48,9 @@ uint32_t TextCodec::GetUnencodableReplacement(
       snprintf(replacement, sizeof(UnencodableReplacementArray), "\\%x ",
                code_point);
       return static_cast<uint32_t>(strlen(replacement));
+
+    case kNoUnencodables:
+      break;
   }
   NOTREACHED();
   replacement[0] = 0;

third_party/blink/renderer/platform/wtf/text/text_codec.h

@@ -52,6 +52,10 @@ enum UnencodableHandling {
   // Encodes the character as a CSS entity.  For example U+06DE
   // would be \06de.  See: https://www.w3.org/TR/css-syntax-3/#escaping
   kCSSEncodedEntitiesForUnencodables,
+
+  // Used when all characters can be encoded in the character set. Only
+  // applicable to UTF-N encodings.
+  kNoUnencodables,
 };
 
 typedef char UnencodableReplacementArray[32];

third_party/blink/renderer/platform/wtf/text/text_codec_icu.cc

@@ -616,6 +616,16 @@ static void GbkCallbackSubstitute(const void* context,
 }
 #endif  // USING_SYSTEM_ICU
 
+static void NotReachedEntityCallback(const void* context,
+                                     UConverterFromUnicodeArgs* from_u_args,
+                                     const UChar* code_units,
+                                     int32_t length,
+                                     UChar32 code_point,
+                                     UConverterCallbackReason reason,
+                                     UErrorCode* err) {
+  NOTREACHED();
+}
+
 class TextCodecInput final {
   STACK_ALLOCATED();
 
@@ -685,6 +695,13 @@ CString TextCodecICU::EncodeInternal(const TextCodecInput& input,
                             0, 0, 0, &err);
 #endif
       break;
+    case kNoUnencodables:
+      DCHECK(encoding_ == UTF16BigEndianEncoding() ||
+             encoding_ == UTF16LittleEndianEncoding() ||
+             encoding_ == UTF8Encoding());
+      ucnv_setFromUCallBack(converter_icu_, NotReachedEntityCallback, nullptr,
+                            nullptr, nullptr, &err);
+      break;
   }
 
   DCHECK(U_SUCCESS(err));

third_party/blink/renderer/platform/wtf/text/text_codec_latin1.cc

@@ -26,6 +26,7 @@
 #include "third_party/blink/renderer/platform/wtf/text/text_codec_latin1.h"
 
 #include <memory>
+#include "third_party/blink/renderer/platform/wtf/assertions.h"
 #include "third_party/blink/renderer/platform/wtf/text/cstring.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_buffer.h"
 #include "third_party/blink/renderer/platform/wtf/text/text_codec_ascii_fast_path.h"
@@ -205,6 +206,7 @@ template <typename CharType>
 static CString EncodeComplexWindowsLatin1(const CharType* characters,
                                           size_t length,
                                           UnencodableHandling handling) {
+  DCHECK_NE(handling, kNoUnencodables);
   size_t target_length = length;
   Vector<char> result(target_length);
   char* bytes = result.data();

third_party/blink/renderer/platform/wtf/text/text_codec_user_defined.cc

@@ -26,8 +26,7 @@
 #include "third_party/blink/renderer/platform/wtf/text/text_codec_user_defined.h"
 
 #include <memory>
-
-#include <memory>
+#include "third_party/blink/renderer/platform/wtf/assertions.h"
 #include "third_party/blink/renderer/platform/wtf/text/cstring.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_buffer.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
@@ -70,6 +69,7 @@ template <typename CharType>
 static CString EncodeComplexUserDefined(const CharType* characters,
                                         size_t length,
                                         UnencodableHandling handling) {
+  DCHECK_NE(handling, kNoUnencodables);
   size_t target_length = length;
   Vector<char> result(target_length);
   char* bytes = result.data();