Rename ContainsOnlyASCII() to ContainsOnlyASCIIOrEmpty()

This patch renames |ContainsOnlyASCII()| to |ContainsOnlyASCIIOrEmpty()| as
consistency with the patch[1] for improving readability.

Note: All renaming is done by global replace tool.

This patch similar to the patch[2] which renames |ContainsOnlyLatin1()|.

[1] http://crrev.com/c/1288157 Rename ContainsOnlyWhitespace() to
ContainsOnlyWhitespaceOrEmpty()
[2] http://crrev.com/c/1288501 Rename ContainsOnlyLatin1() to
ContainsOnlyLatin1OrEmpty()

Change-Id: I666c4e3a6c74d59ab8cd6b74bdf011c0e06d0b0c
Reviewed-on: https://chromium-review.googlesource.com/c/1288502
Commit-Queue: Yoshifumi Inoue <yosin@chromium.org>
Reviewed-by: Kent Tamura <tkent@chromium.org>
Cr-Commit-Position: refs/heads/master@{#601096}

third_party/blink/renderer/core/feature_policy/feature_policy.cc

@@ -99,7 +99,7 @@ ParsedFeaturePolicy ParseFeaturePolicy(
       }
 
       for (wtf_size_t i = 1; i < tokens.size(); i++) {
-        if (!tokens[i].ContainsOnlyASCII()) {
+        if (!tokens[i].ContainsOnlyASCIIOrEmpty()) {
           messages->push_back("Non-ASCII characters in origin.");
           continue;
         }

third_party/blink/renderer/core/html/forms/email_input_type.cc

@@ -65,7 +65,7 @@ std::unique_ptr<ScriptRegexp> EmailInputType::CreateEmailRegexp() {
 
 String EmailInputType::ConvertEmailAddressToASCII(const ScriptRegexp& regexp,
                                                   const String& address) {
-  if (address.ContainsOnlyASCII())
+  if (address.ContainsOnlyASCIIOrEmpty())
     return address;
 
   wtf_size_t at_position = address.find('@');
@@ -104,7 +104,7 @@ String EmailInputType::ConvertEmailAddressToASCII(const ScriptRegexp& regexp,
 
 String EmailInputType::ConvertEmailAddressToUnicode(
     const String& address) const {
-  if (!address.ContainsOnlyASCII())
+  if (!address.ContainsOnlyASCIIOrEmpty())
     return address;
 
   wtf_size_t at_position = address.find('@');

third_party/blink/renderer/modules/crypto/normalize_algorithm.cc

@@ -137,7 +137,7 @@ bool VerifyAlgorithmNameMappings(const AlgorithmNameMapping* begin,
       return false;
     String str(it->algorithm_name,
                static_cast<unsigned>(it->algorithm_name_length));
-    if (!str.ContainsOnlyASCII())
+    if (!str.ContainsOnlyASCIIOrEmpty())
       return false;
     if (str.UpperASCII() != str)
       return false;

third_party/blink/renderer/modules/encryptedmedia/media_key_session.cc

@@ -72,7 +72,7 @@ static bool IsValidSessionId(const String& session_id) {
       (session_id.length() > MaxSessionIdLength))
     return false;
 
-  if (!session_id.ContainsOnlyASCII())
+  if (!session_id.ContainsOnlyASCIIOrEmpty())
     return false;
 
   // Check that the sessionId only contains alphanumeric characters.

third_party/blink/renderer/modules/storage/cached_storage_area.cc

@@ -583,7 +583,7 @@ Vector<uint8_t> CachedStorageArea::StringToUint8Vector(
     }
     case FormatOption::kSessionStorageForceUTF8: {
       unsigned length = input.length();
-      if (input.Is8Bit() && input.ContainsOnlyASCII()) {
+      if (input.Is8Bit() && input.ContainsOnlyASCIIOrEmpty()) {
         Vector<uint8_t> result(length);
         std::memcpy(result.data(), input.Characters8(), length);
         return result;

third_party/blink/renderer/modules/time_zone_monitor/time_zone_monitor_client.cc

@@ -57,7 +57,7 @@ void TimeZoneMonitorClient::OnTimeZoneChange(const String& time_zone_info) {
   DCHECK(IsMainThread());
 
   if (!time_zone_info.IsEmpty()) {
-    DCHECK(time_zone_info.ContainsOnlyASCII());
+    DCHECK(time_zone_info.ContainsOnlyASCIIOrEmpty());
     icu::TimeZone* zone = icu::TimeZone::createTimeZone(
         icu::UnicodeString(time_zone_info.Ascii().data(), -1, US_INV));
     icu::TimeZone::adoptDefault(zone);

third_party/blink/renderer/platform/data_resource_helper.cc

@@ -36,7 +36,7 @@ String GetDataResourceAsASCIIString(const char* resource) {
 
   String data_string = builder.ToString();
   DCHECK(!data_string.IsEmpty());
-  DCHECK(data_string.ContainsOnlyASCII());
+  DCHECK(data_string.ContainsOnlyASCIIOrEmpty());
   return data_string;
 }
 

third_party/blink/renderer/platform/exported/web_string.cc

@@ -139,7 +139,7 @@ std::string WebString::Ascii() const {
 }
 
 bool WebString::ContainsOnlyASCII() const {
-  return String(impl_).ContainsOnlyASCII();
+  return String(impl_).ContainsOnlyASCIIOrEmpty();
 }
 
 WebString WebString::FromASCII(const std::string& s) {

third_party/blink/renderer/platform/mhtml/mhtml_archive.cc

@@ -248,7 +248,7 @@ void MHTMLArchive::GenerateMHTMLHeader(const String& boundary,
 
   // We use utf8() below instead of ascii() as ascii() replaces CRLFs with ??
   // (we still only have put ASCII characters in it).
-  DCHECK(string_builder.ToString().ContainsOnlyASCII());
+  DCHECK(string_builder.ToString().ContainsOnlyASCIIOrEmpty());
   CString ascii_string = string_builder.ToString().Utf8();
 
   output_buffer.Append(ascii_string.data(), ascii_string.length());

third_party/blink/renderer/platform/network/mime/mime_type_registry.cc

@@ -47,7 +47,7 @@ std::string ToLowerASCIIInternal(CHARTYPE* str, SIZETYPE length) {
 
 // Does the same as ToASCIIOrEmpty, but also makes the chars lower.
 std::string ToLowerASCIIOrEmpty(const String& str) {
-  if (str.IsEmpty() || !str.ContainsOnlyASCII())
+  if (str.IsEmpty() || !str.ContainsOnlyASCIIOrEmpty())
     return std::string();
   if (str.Is8Bit())
     return ToLowerASCIIInternal(str.Characters8(), str.length());

third_party/blink/renderer/platform/network/parsed_content_header_field_parameters.cc

@@ -66,7 +66,7 @@ ParsedContentHeaderFieldParameters::Parse(HeaderFieldTokenizer tokenizer,
 
 String ParsedContentHeaderFieldParameters::ParameterValueForName(
     const String& name) const {
-  if (!name.ContainsOnlyASCII())
+  if (!name.ContainsOnlyASCIIOrEmpty())
     return String();
   String lower_name = name.LowerASCII();
 

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

@@ -208,8 +208,8 @@ scoped_refptr<SecurityOrigin> SecurityOrigin::CreateOpaque(
 scoped_refptr<SecurityOrigin> SecurityOrigin::CreateFromUrlOrigin(
     const url::Origin& origin) {
   const url::SchemeHostPort& tuple = origin.GetTupleOrPrecursorTupleIfOpaque();
-  DCHECK(String::FromUTF8(tuple.scheme().c_str()).ContainsOnlyASCII());
-  DCHECK(String::FromUTF8(tuple.host().c_str()).ContainsOnlyASCII());
+  DCHECK(String::FromUTF8(tuple.scheme().c_str()).ContainsOnlyASCIIOrEmpty());
+  DCHECK(String::FromUTF8(tuple.host().c_str()).ContainsOnlyASCIIOrEmpty());
 
   scoped_refptr<SecurityOrigin> tuple_origin;
   if (!tuple.IsInvalid()) {

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

@@ -76,7 +76,7 @@ void StringImpl::DestroyIfNotStatic() const {
     delete this;
 }
 
-void StringImpl::UpdateContainsOnlyASCII() const {
+void StringImpl::UpdateContainsOnlyASCIIOrEmpty() const {
   contains_only_ascii_ = Is8Bit()
                              ? CharactersAreAllASCII(Characters8(), length())
                              : CharactersAreAllASCII(Characters16(), length());

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

@@ -224,7 +224,7 @@ class WTF_EXPORT StringImpl {
 
   bool IsStatic() const { return is_static_; }
 
-  bool ContainsOnlyASCII() const;
+  bool ContainsOnlyASCIIOrEmpty() const;
 
   bool IsSafeToSendToAnotherThread() const;
 
@@ -461,7 +461,7 @@ class WTF_EXPORT StringImpl {
   NOINLINE wtf_size_t HashSlowCase() const;
 
   void DestroyIfNotStatic() const;
-  void UpdateContainsOnlyASCII() const;
+  void UpdateContainsOnlyASCIIOrEmpty() const;
 
 #if DCHECK_IS_ON()
   std::string AsciiForDebugging() const;
@@ -521,9 +521,9 @@ inline bool Equal(const char* a, StringImpl* b) {
 }
 WTF_EXPORT bool EqualNonNull(const StringImpl* a, const StringImpl* b);
 
-ALWAYS_INLINE bool StringImpl::ContainsOnlyASCII() const {
+ALWAYS_INLINE bool StringImpl::ContainsOnlyASCIIOrEmpty() const {
   if (needs_ascii_check_)
-    UpdateContainsOnlyASCII();
+    UpdateContainsOnlyASCIIOrEmpty();
   return contains_only_ascii_;
 }
 

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

@@ -55,7 +55,7 @@ class StringUTF8Adaptor final {
     // UTF-8 when processing 8 bit strings. If |relative| is entirely ASCII, we
     // luck out and can avoid mallocing a new buffer to hold the UTF-8 data
     // because UTF-8 and Latin-1 use the same code units for ASCII code points.
-    if (string.Is8Bit() && string.ContainsOnlyASCII()) {
+    if (string.Is8Bit() && string.ContainsOnlyASCIIOrEmpty()) {
       data_ = reinterpret_cast<const char*>(string.Characters8());
       length_ = string.length();
     } else {

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

@@ -502,8 +502,8 @@ class WTF_EXPORT String {
                                       length);
   }
 
-  bool ContainsOnlyASCII() const {
-    return !impl_ || impl_->ContainsOnlyASCII();
+  bool ContainsOnlyASCIIOrEmpty() const {
+    return !impl_ || impl_->ContainsOnlyASCIIOrEmpty();
   }
   bool ContainsOnlyLatin1OrEmpty() const;
   bool ContainsOnlyWhitespaceOrEmpty() const {