Issue 6180 - use ABP_TEXT everywhere in order to let String be a UTF-8 string

compiled/filter/Filter.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 22 matching lines @@
 {
   StringMap<Filter*> knownFilters(8192);
 
   void NormalizeWhitespace(DependentString& text)
   {
     String::size_type start = 0;
     String::size_type end = text.length();
 
     // Remove leading spaces and special characters like line breaks
     for (; start < end; start++)
-      if (text[start] > ' ')
+      if (text[start] > ABP_TEXT(' '))
         break;
 
     // Now look for invalid characters inside the string
     String::size_type pos;
     for (pos = start; pos < end; pos++)
-      if (text[pos] < ' ')
+      if (text[pos] < ABP_TEXT(' '))
         break;
 
     if (pos < end)
     {
       // Found invalid characters, copy all the valid characters while skipping
       // the invalid ones.
       String::size_type delta = 1;
       for (pos = pos + 1; pos < end; pos++)
       {
-        if (text[pos] < ' ')
+        if (text[pos] < ABP_TEXT(' '))
           delta++;
         else
           text[pos - delta] = text[pos];
       }
       end -= delta;
     }
 
     // Remove trailing spaces
     for (; end > 0; end--)
-      if (text[end - 1] != ' ')
+      if (text[end - 1] != ABP_TEXT(' '))
         break;
 
     // Set new string boundaries
     text.reset(text, start, end - start);
   }
 }
 
 Filter::Filter(Type type, const String& text)
     : mText(text), mType(type)
 {
   annotate_address(this, "Filter");
 }
 
 Filter::~Filter()
 {
   knownFilters.erase(mText);
 }
 
 OwnedString Filter::Serialize() const
 {
-  OwnedString result(u"[Filter]\ntext="_str);
+  OwnedString result(ABP_TEXT("[Filter]\ntext="_str));
   result.append(mText);
-  result.append(u'\n');
+  result.append(ABP_TEXT('\n'));
   return result;
 }
 
 Filter* Filter::FromText(DependentString& text)
 {
   NormalizeWhitespace(text);
   if (text.empty())
     return nullptr;
 
   // Parsing also normalizes the filter text, so it has to be done before the
@@ skipping 43 matching lines @@
       break;
     case ElemHideFilter::classType:
       filter = FilterPtr(new ElemHideFilter(text, data.elemhide), false);
       break;
     case ElemHideException::classType:
       filter = FilterPtr(new ElemHideException(text, data.elemhide), false);
       break;
     case ElemHideEmulationFilter::classType:
       filter = FilterPtr(new ElemHideEmulationFilter(text, data.elemhide), false);
       if (static_cast<ElemHideEmulationFilter*>(filter.get())->IsGeneric())
-        filter = FilterPtr(new InvalidFilter(text, u"filter_elemhideemulation_nodomain"_str), false);
+        filter = FilterPtr(new InvalidFilter(text, ABP_TEXT("filter_elemhideemulation_nodomain"_str)), false);
       break;
     default:
       // This should never happen but just in case
       return nullptr;
   }
 
   enter_context("Adding to known filters");
   if (text != filter->mText)
     knownFilters[filter->mText] = filter.get();
   else
     // This is a hack: we looked up the entry using text but create it using
     // filter->mText. This works because both are equal at this point. However,
     // text refers to a temporary buffer which will go away.
     knownFilter.assign(filter->mText, filter.get());
   exit_context();
 
   return filter.release();
 }