Use 'icu::' namespace explicitly

net/base/net_util.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <map>
 #include <unicode/ucnv.h>
 #include <unicode/uidna.h>
 #include <unicode/ulocdata.h>
 #include <unicode/uniset.h>
@@ skipping 476 matching lines @@
 // Latin letters in the ASCII range.
 bool IsCompatibleWithASCIILetters(const std::string& lang) {
   // For now, just list Chinese, Japanese and Korean (positive list).
   // An alternative is negative-listing (languages using Greek and
   // Cyrillic letters), but it can be more dangerous.
   return !lang.substr(0, 2).compare("zh") ||
          !lang.substr(0, 2).compare("ja") ||
          !lang.substr(0, 2).compare("ko");
 }
 
-typedef std::map<std::string, UnicodeSet*> LangToExemplarSetMap;
+typedef std::map<std::string, icu::UnicodeSet*> LangToExemplarSetMap;
 
 class LangToExemplarSet {
  private:
   LangToExemplarSetMap map;
   LangToExemplarSet() { }
   ~LangToExemplarSet() {
     STLDeleteContainerPairSecondPointers(map.begin(), map.end());
   }
 
   friend class Singleton<LangToExemplarSet>;
   friend struct DefaultSingletonTraits<LangToExemplarSet>;
-  friend bool GetExemplarSetForLang(const std::string&, UnicodeSet**);
-  friend void SetExemplarSetForLang(const std::string&, UnicodeSet*);
+  friend bool GetExemplarSetForLang(const std::string&, icu::UnicodeSet**);
+  friend void SetExemplarSetForLang(const std::string&, icu::UnicodeSet*);
 
   DISALLOW_COPY_AND_ASSIGN(LangToExemplarSet);
 };
 
-bool GetExemplarSetForLang(const std::string& lang, UnicodeSet** lang_set) {
+bool GetExemplarSetForLang(const std::string& lang,
+                           icu::UnicodeSet** lang_set) {
   const LangToExemplarSetMap& map = Singleton<LangToExemplarSet>()->map;
   LangToExemplarSetMap::const_iterator pos = map.find(lang);
   if (pos != map.end()) {
     *lang_set = pos->second;
     return true;
   }
   return false;
 }
 
-void SetExemplarSetForLang(const std::string& lang, UnicodeSet* lang_set) {
+void SetExemplarSetForLang(const std::string& lang,
+                           icu::UnicodeSet* lang_set) {
   LangToExemplarSetMap& map = Singleton<LangToExemplarSet>()->map;
   map.insert(std::make_pair(lang, lang_set));
 }
 
 static Lock lang_set_lock;
 
 // Returns true if all the characters in component_characters are used by
 // the language |lang|.
-bool IsComponentCoveredByLang(const UnicodeSet& component_characters,
+bool IsComponentCoveredByLang(const icu::UnicodeSet& component_characters,
                               const std::string& lang) {
-  static const UnicodeSet kASCIILetters(0x61, 0x7a);  // [a-z]
-  UnicodeSet* lang_set;
+  static const icu::UnicodeSet kASCIILetters(0x61, 0x7a);  // [a-z]
+  icu::UnicodeSet* lang_set;
   // We're called from both the UI thread and the history thread.
   {
     AutoLock lock(lang_set_lock);
     if (!GetExemplarSetForLang(lang, &lang_set)) {
       UErrorCode status = U_ZERO_ERROR;
       ULocaleData* uld = ulocdata_open(lang.c_str(), &status);
       // TODO(jungshik) Turn this check on when the ICU data file is
       // rebuilt with the minimal subset of locale data for languages
       // to which Chrome is not localized but which we offer in the list
       // of languages selectable for Accept-Languages. With the rebuilt ICU
       // data, ulocdata_open never should fall back to the default locale.
       // (issue 2078)
       // DCHECK(U_SUCCESS(status) && status != U_USING_DEFAULT_WARNING);
       if (U_SUCCESS(status) && status != U_USING_DEFAULT_WARNING) {
-        lang_set = reinterpret_cast<UnicodeSet *>(
+        lang_set = reinterpret_cast<icu::UnicodeSet *>(
             ulocdata_getExemplarSet(uld, NULL, 0,
                                     ULOCDATA_ES_STANDARD, &status));
         // If |lang| is compatible with ASCII Latin letters, add them.
         if (IsCompatibleWithASCIILetters(lang))
           lang_set->addAll(kASCIILetters);
       } else {
-        lang_set = new UnicodeSet(1, 0);
+        lang_set = new icu::UnicodeSet(1, 0);
       }
       lang_set->freeze();
       SetExemplarSetForLang(lang, lang_set);
       ulocdata_close(uld);
     }
   }
   return !lang_set->isEmpty() && lang_set->containsAll(component_characters);
 }
 
 // Returns true if the given Unicode host component is safe to display to the
@@ skipping 21 matching lines @@
       L"[[\\ \u00bc\u00bd\u01c3\u0337\u0338"
       L"\u05c3\u05f4\u06d4\u0702\u115f\u1160][\u2000-\u200b]"
       L"[\u2024\u2027\u2028\u2029\u2039\u203a\u2044\u205f]"
       L"[\u2154-\u2156][\u2159-\u215b][\u215f\u2215\u23ae"
       L"\u29f6\u29f8\u2afb\u2afd][\u2ff0-\u2ffb][\u3014"
       L"\u3015\u3033\u3164\u321d\u321e\u33ae\u33af\u33c6\u33df\ufe14"
       L"\ufe15\ufe3f\ufe5d\ufe5e\ufeff\uff0e\uff06\uff61\uffa0\ufff9]"
       L"[\ufffa-\ufffd]]"), status);
 #else
   UnicodeSet dangerous_characters(UnicodeString(
-      "[[\\ \\u0020\\u00bc\\u00bd\\u01c3\\u0337\\u0338"
+      "[[\\u0020\\u00bc\\u00bd\\u01c3\\u0337\\u0338"
       "\\u05c3\\u05f4\\u06d4\\u0702\\u115f\\u1160][\\u2000-\\u200b]"
       "[\\u2024\\u2027\\u2028\\u2029\\u2039\\u203a\\u2044\\u205f]"
       "[\\u2154-\\u2156][\\u2159-\\u215b][\\u215f\\u2215\\u23ae"
       "\\u29f6\\u29f8\\u2afb\\u2afd][\\u2ff0-\\u2ffb][\\u3014"
       "\\u3015\\u3033\\u3164\\u321d\\u321e\\u33ae\\u33af\\u33c6\\u33df\\ufe14"
       "\\ufe15\\ufe3f\\ufe5d\\ufe5e\\ufeff\\uff0e\\uff06\\uff61\\uffa0\\ufff9]"
       "[\\ufffa-\\ufffd]]", -1, US_INV), status);
 #endif
   DCHECK(U_SUCCESS(status));
-  UnicodeSet component_characters;
-  component_characters.addAll(UnicodeString(str, str_len));
+  icu::UnicodeSet component_characters;
+  component_characters.addAll(icu::UnicodeString(str, str_len));
   if (dangerous_characters.containsSome(component_characters))
     return false;
 
   // If the language list is empty, the result is completely determined
   // by whether a component is a single script or not. This will block
   // even "safe" script mixing cases like <Chinese, Latin-ASCII> that are
   // allowed with |languages| (while it blocks Chinese + Latin letters with
   // an accent as should be the case), but we want to err on the safe side
   // when |languages| is empty.
   if (languages.empty())
     return IsIDNComponentInSingleScript(str, str_len);
 
   // |common_characters| is made up of  ASCII numbers, hyphen, plus and
   // underscore that are used across scripts and allowed in domain names.
   // (sync'd with characters allowed in url_canon_host with square
   // brackets excluded.) See kHostCharLookup[] array in url_canon_host.cc.
-  UnicodeSet common_characters(UNICODE_STRING_SIMPLE("[[0-9]\\-_+\\ ]"),
-                               status);
+  icu::UnicodeSet common_characters(UNICODE_STRING_SIMPLE("[[0-9]\\-_+\\ ]"),
+                                    status);
   DCHECK(U_SUCCESS(status));
   // Subtract common characters because they're always allowed so that
   // we just have to check if a language-specific set contains
   // the remainder.
   component_characters.removeAll(common_characters);
 
   std::string languages_list(WideToASCII(languages));
   StringTokenizer t(languages_list, ",");
   while (t.GetNext()) {
     if (IsComponentCoveredByLang(component_characters, t.token()))
@@ skipping 659 matching lines @@
 GURL SimplifyUrlForRequest(const GURL& url) {
   DCHECK(url.is_valid());
   GURL::Replacements replacements;
   replacements.ClearUsername();
   replacements.ClearPassword();
   replacements.ClearRef();
   return url.ReplaceComponents(replacements);
 }
 
 }  // namespace net