Fix mem leak in WindowsManifestMerger.cpp

[XinWang10]

Summary

Code in WindowsManifestMerger.cpp could cause mem leak.
For code in function mergeNamespaces in line 330, it has 2
pointer OriginalDefinedDefaultHref and NewDefinedDefaultHref
which could point to mem which allocated by new operator,
in some branch ends with return it didn't handle them which could
be a risk.

[XinWang10]

• add the missing one

[skan]

llvm/lib/WindowsManifest/WindowsManifestMerger.cpp

352

Do we need to free the memory when the error is taken?

[XinWang10]

OK, when failed and report error mem will be freed automatically.

llvm/lib/WindowsManifest/WindowsManifestMerger.cpp

static Error mergeNamespaces(xmlNodePtr OriginalNode,
   for (xmlNsPtr Def = AdditionalNode->nsDef; Def; Def = Def->next) {
     if (xmlNsPtr OriginalNsDef =
             getNamespaceWithPrefix(Def->prefix, OriginalNode)) {
       if (!Def->prefix) {
         if (namespaceOverrides(Def->href, OriginalNsDef->href)) {
           NewDefinedDefaultHref = TO_XML_CHAR(strdup(FROM_XML_CHAR(Def->href)));
         }
       } else if (!xmlStringsEqual(OriginalNsDef->href, Def->href)) {
+        if (NewDefinedDefaultHref)
+          xmlFree(const_cast<unsigned char *>(NewDefinedDefaultHref));
         return make_error<WindowsManifestError>(
             Twine("conflicting namespace definitions for ") +
             FROM_XML_CHAR(Def->prefix));
       }
     } else {
       xmlNsPtr NewDef = xmlCopyNamespace(Def);
       NewDef->next = OriginalNode->nsDef;
       OriginalNode->nsDef = NewDef;
if (OriginalDefinedDefaultHref) {
       // prefix for the overridden definition and apply it to all children
       // who relied on that definition.
       if (NonDominantDefinedDefault &&
           namespaceOverrides(NonDominantDefinedDefault->href,
                              OriginalDefinedDefaultHref)) {
         Expected<xmlNsPtr> EC =
             searchOrDefine(OriginalDefinedDefaultHref, DominantNode);
         if (!EC) {
+          xmlFree(const_cast<unsigned char *>(OriginalDefinedDefaultHref));
+          if (NewDefinedDefaultHref)
+            xmlFree(const_cast<unsigned char *>(NewDefinedDefaultHref));
           return EC.takeError();
         }
         xmlNsPtr PrefixDominantDefinedDefault = std::move(EC.get());
         explicateNamespace(PrefixDominantDefinedDefault, DominantNode);
       }
       // In this case the node with a higher priority namespace did not have a
       // default namespace definition, but the lower priority node did.  In this
       // case the new default namespace definition is copied.  A side effect of
       // this is that all children will suddenly find themselves in a different
       // default namespace.  To maintain correctness we need to ensure that all
       // children now explicitly refer to the namespace that they had previously
       // implicitly inherited.
     } else if (getNamespaceWithPrefix(nullptr, NonDominantNode)) {
       if (DominantNode->parent) {
         xmlNsPtr ClosestDefault = getClosestDefault(DominantNode->parent);
         Expected<xmlNsPtr> EC =
             searchOrDefine(ClosestDefault->href, DominantNode);
         if (!EC) {
+          if (NewDefinedDefaultHref)
+            xmlFree(const_cast<unsigned char *>(NewDefinedDefaultHref));
           return EC.takeError();
         }
         xmlNsPtr ExplicitDefault = std::move(EC.get());
         explicateNamespace(ExplicitDefault, DominantNode);
       }
     }
   } else {
     // Covers case where the incoming node has a default namespace definition
     // that overrides the original node's namespace.  This always leads to
     // the original node receiving that new default namespace.
     if (hasDefinedDefaultNamespace(DominantNode)) {
       NonDominantNode->ns = getNamespaceWithPrefix(nullptr, NonDominantNode);
     } else {
       // This covers the case where the incoming node either has a prefix
       // namespace, or an inherited default namespace.  Since the namespace
       // may not yet be defined in the original tree we do a searchOrDefine
       // for it, and then set the namespace equal to it.
       Expected<xmlNsPtr> EC =
           searchOrDefine(DominantNode->ns->href, NonDominantNode);
       if (!EC) {
+        if (OriginalDefinedDefaultHref)
+          xmlFree(const_cast<unsigned char *>(OriginalDefinedDefaultHref));
+        if (NewDefinedDefaultHref)
+          xmlFree(const_cast<unsigned char *>(NewDefinedDefaultHref));
         return EC.takeError();
       }
       xmlNsPtr Explicit = std::move(EC.get());
       NonDominantNode->ns = Explicit;
     }
     // This covers cases where the incoming dominant node HAS a default
     // namespace definition, but MIGHT NOT NECESSARILY be in that namespace.
     if (xmlNsPtr DominantDefaultDefined =