Cleanup: Remove the WebCryptoAlgorithm::name() attribute.

Source/modules/crypto/NormalizeAlgorithm.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 106 matching lines @@
     WebKit::WebCryptoAlgorithmId algorithmId;
     const char* algorithmName;
     AlgorithmParamsForOperation paramsForOperation[NumberOfAlgorithmOperations];
 };
 
 // AlgorithmRegistry enumerates each of the different algorithms and its
 // parameters. This describes the same information as the static tables above,
 // but in a more convenient runtime form.
 class AlgorithmRegistry {
 public:
-    static const AlgorithmInfo* lookupAlgorithmByName(const String& algorithmName);
+    static AlgorithmRegistry& instance();
+
+    const AlgorithmInfo* lookupAlgorithmByName(const String&) const;
+    const AlgorithmInfo* lookupAlgorithmById(WebKit::WebCryptoAlgorithmId) const;
 
 private:
     AlgorithmRegistry();
 
     // Algorithm name to ID.
     typedef HashMap<String, WebKit::WebCryptoAlgorithmId, CaseFoldingHash> AlgorithmNameToIdMap;
     AlgorithmNameToIdMap m_algorithmNameToId;
 
     // Algorithm ID to information.
     AlgorithmInfo m_algorithms[WebKit::NumberOfWebCryptoAlgorithmId];
 };
 
-const AlgorithmInfo* AlgorithmRegistry::lookupAlgorithmByName(const String& algorithmName)
+AlgorithmRegistry& AlgorithmRegistry::instance()
 {
     DEFINE_STATIC_LOCAL(AlgorithmRegistry, registry, ());
+    return registry;
+}
 
-    AlgorithmNameToIdMap::const_iterator it = registry.m_algorithmNameToId.find(algorithmName);
-    if (it == registry.m_algorithmNameToId.end())
+const AlgorithmInfo* AlgorithmRegistry::lookupAlgorithmByName(const String& algorithmName) const
+{
+    AlgorithmNameToIdMap::const_iterator it = m_algorithmNameToId.find(algorithmName);
+    if (it == m_algorithmNameToId.end())
         return 0;
-    return &registry.m_algorithms[it->value];
+    return lookupAlgorithmById(it->value);
+}
+
+const AlgorithmInfo* AlgorithmRegistry::lookupAlgorithmById(WebKit::WebCryptoAlgorithmId algorithmId) const
+{
+    ASSERT(algorithmId >= 0 && algorithmId < WTF_ARRAY_LENGTH(m_algorithms));
+    return &m_algorithms[algorithmId];
 }
 
 AlgorithmRegistry::AlgorithmRegistry()
 {
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(algorithmNameMappings); ++i) {
         const AlgorithmNameMapping& mapping = algorithmNameMappings[i];
         m_algorithmNameToId.add(mapping.algorithmName, mapping.algorithmId);
         m_algorithms[mapping.algorithmId].algorithmName = mapping.algorithmName;
         m_algorithms[mapping.algorithmId].algorithmId = mapping.algorithmId;
     }
@@ skipping 266 matching lines @@
         es.throwTypeError(context.toString("Not an object"));
         return 0;
     }
 
     String algorithmName;
     if (!raw.get("name", algorithmName)) {
         es.throwTypeError(context.toString("name", "Missing or not a string"));
         return 0;
     }
 
-    const AlgorithmInfo* info = AlgorithmRegistry::lookupAlgorithmByName(algorithmName);
+    const AlgorithmInfo* info = AlgorithmRegistry::instance().lookupAlgorithmByName(algorithmName);
     if (!info) {
         es.throwDOMException(NotSupportedError, context.toString("Unrecognized algorithm name"));
         return 0;
     }
 
     return info;
 }
 
 // This implementation corresponds with:
 // http://www.w3.org/TR/WebCryptoAPI/#algorithm-normalizing-rules
@@ skipping 10 matching lines @@
     if (info->paramsForOperation[op] == UnsupportedOp) {
         es.throwDOMException(NotSupportedError, context.toString("Unsupported operation"));
         return false;
     }
 
     WebKit::WebCryptoAlgorithmParamsType paramsType = static_cast<WebKit::WebCryptoAlgorithmParamsType>(info->paramsForOperation[op]);
     OwnPtr<WebKit::WebCryptoAlgorithmParams> params;
     if (!parseAlgorithmParams(raw, paramsType, params, context, es))
         return false;
 
-    algorithm = WebKit::WebCryptoAlgorithm(info->algorithmId, info->algorithmName, params.release());
+    algorithm = WebKit::WebCryptoAlgorithm(info->algorithmId, params.release());
     return true;
 }
 
 } // namespace
 
 bool normalizeAlgorithm(const Dictionary& raw, AlgorithmOperation op, WebKit::WebCryptoAlgorithm& algorithm, ExceptionState& es)
 {
     return normalizeAlgorithm(raw, op, algorithm, ExceptionContext(), es);
 }
 
+const char* algorithmIdToName(WebKit::WebCryptoAlgorithmId id)
+{
+    return AlgorithmRegistry::instance().lookupAlgorithmById(id)->algorithmName;
+}
+
 } // namespace WebCore