Migrate WTF::HashMap::get() to ::at()

third_party/WebKit/Source/wtf/text/TextEncodingRegistry.cpp

 /*
  * Copyright (C) 2006, 2007, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 109 matching lines @@
 
 static const char textEncodingNameBlacklist[][6] = {"UTF-7"};
 
 #if ERROR_DISABLED
 
 static inline void checkExistingName(const char*, const char*) {}
 
 #else
 
 static void checkExistingName(const char* alias, const char* atomicName) {
-  const char* oldAtomicName = textEncodingNameMap->get(alias);
+  const char* oldAtomicName = textEncodingNameMap->at(alias);
   if (!oldAtomicName)
     return;
   if (oldAtomicName == atomicName)
     return;
   // Keep the warning silent about one case where we know this will happen.
   if (strcmp(alias, "ISO-8859-8-I") == 0 &&
       strcmp(oldAtomicName, "ISO-8859-8-I") == 0 &&
       strcasecmp(atomicName, "iso-8859-8") == 0)
     return;
   LOG(ERROR) << "alias " << alias << " maps to " << oldAtomicName
@@ skipping 15 matching lines @@
   // problem, see bug 43554.
   if (0 == strcmp(alias, "8859_1"))
     return true;
   return false;
 }
 
 static void addToTextEncodingNameMap(const char* alias, const char* name) {
   DCHECK_LE(strlen(alias), maxEncodingNameLength);
   if (isUndesiredAlias(alias))
     return;
-  const char* atomicName = textEncodingNameMap->get(name);
+  const char* atomicName = textEncodingNameMap->at(name);
   DCHECK(strcmp(alias, name) == 0 || atomicName);
   if (!atomicName)
     atomicName = name;
   checkExistingName(alias, atomicName);
   textEncodingNameMap->insert(alias, atomicName);
 }
 
 static void addToTextCodecMap(const char* name,
                               NewTextCodecFunction function,
                               const void* additionalData) {
-  const char* atomicName = textEncodingNameMap->get(name);
+  const char* atomicName = textEncodingNameMap->at(name);
   DCHECK(atomicName);
   textCodecMap->insert(atomicName, TextCodecFactory(function, additionalData));
 }
 
 static void pruneBlacklistedCodecs() {
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(textEncodingNameBlacklist); ++i) {
     const char* atomicName =
-        textEncodingNameMap->get(textEncodingNameBlacklist[i]);
+        textEncodingNameMap->at(textEncodingNameBlacklist[i]);
     if (!atomicName)
       continue;
 
     Vector<const char*> names;
     TextEncodingNameMap::const_iterator it = textEncodingNameMap->begin();
     TextEncodingNameMap::const_iterator end = textEncodingNameMap->end();
     for (; it != end; ++it) {
       if (it->value == atomicName)
         names.push_back(it->key);
     }
@@ skipping 40 matching lines @@
   TextCodecICU::registerEncodingNames(addToTextEncodingNameMap);
   TextCodecICU::registerCodecs(addToTextCodecMap);
 
   pruneBlacklistedCodecs();
 }
 
 std::unique_ptr<TextCodec> newTextCodec(const TextEncoding& encoding) {
   MutexLocker lock(encodingRegistryMutex());
 
   DCHECK(textCodecMap);
-  TextCodecFactory factory = textCodecMap->get(encoding.name());
+  TextCodecFactory factory = textCodecMap->at(encoding.name());
   DCHECK(factory.function);
   return factory.function(encoding, factory.additionalData);
 }
 
 const char* atomicCanonicalTextEncodingName(const char* name) {
   if (!name || !name[0])
     return 0;
   if (!textEncodingNameMap)
     buildBaseTextCodecMaps();
 
   MutexLocker lock(encodingRegistryMutex());
 
-  if (const char* atomicName = textEncodingNameMap->get(name))
+  if (const char* atomicName = textEncodingNameMap->at(name))
     return atomicName;
   if (atomicDidExtendTextCodecMaps())
     return 0;
   extendTextCodecMaps();
   atomicSetDidExtendTextCodecMaps();
-  return textEncodingNameMap->get(name);
+  return textEncodingNameMap->at(name);
 }
 
 template <typename CharacterType>
 const char* atomicCanonicalTextEncodingName(const CharacterType* characters,
                                             size_t length) {
   char buffer[maxEncodingNameLength + 1];
   size_t j = 0;
   for (size_t i = 0; i < length; ++i) {
     char c = static_cast<char>(characters[i]);
     if (j == maxEncodingNameLength || c != characters[i])
@@ skipping 31 matching lines @@
   MutexLocker lock(encodingRegistryMutex());
 
   TextEncodingNameMap::const_iterator it = textEncodingNameMap->begin();
   TextEncodingNameMap::const_iterator end = textEncodingNameMap->end();
   for (; it != end; ++it)
     fprintf(stderr, "'%s' => '%s'\n", it->key, it->value);
 }
 #endif
 
 }  // namespace WTF