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/1213085Reviewed-by: Markus Heintz <markusheintz@chromium.org>
Commit-Queue: Markus Heintz <markusheintz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589501}

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::kNoUnencodables)))) {}
+          UTF8Encoding().Encode(string, WTF::kEntitiesForUnencodables)))) {}
 
 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::kNoUnencodables));
+        UTF8Encoding().Encode(body, WTF::kEntitiesForUnencodables));
   }
 
   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::kNoUnencodables));
+        UTF8Encoding().Encode(body, WTF::kEntitiesForUnencodables));
     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::kNoUnencodables);
+                            WTF::kEntitiesForUnencodables);
   } else {
     result = codec_->Encode(input.Characters16(), input.length(),
-                            WTF::kNoUnencodables);
+                            WTF::kEntitiesForUnencodables);
   }
 
   const char* buffer = result.data();

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

@@ -60,8 +60,14 @@ 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::kNoUnencodables);
+                                WTF::kEntitiesForUnencodables);
     } else {
       bool have_output =
           Encode16BitString(input, high_surrogate, &prefix, &result);
@@ -128,7 +134,7 @@ class TextEncoderStream::Transformer final : public TransformStreamTransformer {
         // Third argument is ignored, as above.
         *prefix =
             encoder_->Encode(astral_character, base::size(astral_character),
-                             WTF::kNoUnencodables);
+                             WTF::kEntitiesForUnencodables);
         ++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::kNoUnencodables);
+        message_data.GetAsUSVString(), WTF::kEntitiesForUnencodables);
     return new PushMessageData(encoded_string.data(), encoded_string.length());
   }
 

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

@@ -215,7 +215,8 @@ 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::kNoUnencodables);
+  CString utf8_text =
+      UTF8Encoding().Encode(text, WTF::kEntitiesForUnencodables);
 
   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::kNoUnencodables);
+  CString utf8 = UTF8Encoding().Encode(not_encoded_string,
+                                       WTF::kURLEncodedEntitiesForUnencodables);
 
   url::RawCanonOutputT<char> buffer;
   int input_length = utf8.length();

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

@@ -48,9 +48,6 @@ 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,10 +52,6 @@ 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,16 +616,6 @@ 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();
 
@@ -695,13 +685,6 @@ 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,7 +26,6 @@
 #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"
@@ -206,7 +205,6 @@ 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,7 +26,8 @@
 #include "third_party/blink/renderer/platform/wtf/text/text_codec_user_defined.h"
 
 #include <memory>
-#include "third_party/blink/renderer/platform/wtf/assertions.h"
+
+#include <memory>
 #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"
@@ -69,7 +70,6 @@ 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();