diff options
Diffstat (limited to '')
| -rw-r--r-- | netwerk/streamconv/nsStreamConverterService.cpp | 543 |
1 files changed, 543 insertions, 0 deletions
diff --git a/netwerk/streamconv/nsStreamConverterService.cpp b/netwerk/streamconv/nsStreamConverterService.cpp new file mode 100644 index 0000000000..ce95bb0404 --- /dev/null +++ b/netwerk/streamconv/nsStreamConverterService.cpp @@ -0,0 +1,543 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsComponentManagerUtils.h" +#include "nsStreamConverterService.h" +#include "nsIComponentRegistrar.h" +#include "nsString.h" +#include "nsAtom.h" +#include "nsDeque.h" +#include "nsIInputStream.h" +#include "nsIStreamConverter.h" +#include "nsICategoryManager.h" +#include "nsXPCOM.h" +#include "nsISupportsPrimitives.h" +#include "nsTArray.h" +#include "nsServiceManagerUtils.h" +#include "nsISimpleEnumerator.h" +#include "mozilla/UniquePtr.h" + +/////////////////////////////////////////////////////////////////// +// Breadth-First-Search (BFS) algorithm state classes and types. + +// Used to establish discovered verticies. +enum BFScolors { white, gray, black }; + +// BFS hashtable data class. +struct BFSTableData { + nsCString key; + BFScolors color; + int32_t distance; + mozilla::UniquePtr<nsCString> predecessor; + + explicit BFSTableData(const nsACString& aKey) + : key(aKey), color(white), distance(-1) {} +}; + +//////////////////////////////////////////////////////////// +// nsISupports methods +NS_IMPL_ISUPPORTS(nsStreamConverterService, nsIStreamConverterService) + +//////////////////////////////////////////////////////////// +// nsIStreamConverterService methods + +//////////////////////////////////////////////////////////// +// nsStreamConverterService methods + +// Builds the graph represented as an adjacency list (and built up in +// memory using an nsObjectHashtable and nsCOMArray combination). +// +// :BuildGraph() consults the category manager for all stream converter +// CONTRACTIDS then fills the adjacency list with edges. +// An edge in this case is comprised of a FROM and TO MIME type combination. +// +// CONTRACTID format: +// @mozilla.org/streamconv;1?from=text/html&to=text/plain +// XXX curently we only handle a single from and to combo, we should repeat the +// XXX registration process for any series of from-to combos. +// XXX can use nsTokenizer for this. +// + +nsresult nsStreamConverterService::BuildGraph() { + nsresult rv; + + nsCOMPtr<nsICategoryManager> catmgr( + do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsISimpleEnumerator> entries; + rv = catmgr->EnumerateCategory(NS_ISTREAMCONVERTER_KEY, + getter_AddRefs(entries)); + if (NS_FAILED(rv)) return rv; + + // go through each entry to build the graph + nsCOMPtr<nsISupports> supports; + nsCOMPtr<nsISupportsCString> entry; + rv = entries->GetNext(getter_AddRefs(supports)); + while (NS_SUCCEEDED(rv)) { + entry = do_QueryInterface(supports); + + // get the entry string + nsAutoCString entryString; + rv = entry->GetData(entryString); + if (NS_FAILED(rv)) return rv; + + // cobble the entry string w/ the converter key to produce a full + // contractID. + nsAutoCString contractID(NS_ISTREAMCONVERTER_KEY); + contractID.Append(entryString); + + // now we've got the CONTRACTID, let's parse it up. + rv = AddAdjacency(contractID.get()); + if (NS_FAILED(rv)) return rv; + + rv = entries->GetNext(getter_AddRefs(supports)); + } + + return NS_OK; +} + +// XXX currently you can not add the same adjacency (i.e. you can't have +// multiple +// XXX stream converters registering to handle the same from-to combination. +// It's +// XXX not programatically prohibited, it's just that results are un-predictable +// XXX right now. +nsresult nsStreamConverterService::AddAdjacency(const char* aContractID) { + nsresult rv; + // first parse out the FROM and TO MIME-types. + + nsAutoCString fromStr, toStr; + rv = ParseFromTo(aContractID, fromStr, toStr); + if (NS_FAILED(rv)) return rv; + + // Each MIME-type is a vertex in the graph, so first lets make sure + // each MIME-type is represented as a key in our hashtable. + + nsTArray<RefPtr<nsAtom>>* const fromEdges = + mAdjacencyList.GetOrInsertNew(fromStr); + + mAdjacencyList.GetOrInsertNew(toStr); + + // Now we know the FROM and TO types are represented as keys in the hashtable. + // Let's "connect" the verticies, making an edge. + + RefPtr<nsAtom> vertex = NS_Atomize(toStr); + if (!vertex) return NS_ERROR_OUT_OF_MEMORY; + + NS_ASSERTION(fromEdges, "something wrong in adjacency list construction"); + if (!fromEdges) return NS_ERROR_FAILURE; + + // XXX(Bug 1631371) Check if this should use a fallible operation as it + // pretended earlier. + fromEdges->AppendElement(vertex); + return NS_OK; +} + +nsresult nsStreamConverterService::ParseFromTo(const char* aContractID, + nsCString& aFromRes, + nsCString& aToRes) { + nsAutoCString ContractIDStr(aContractID); + + int32_t fromLoc = ContractIDStr.Find("from="); + int32_t toLoc = ContractIDStr.Find("to="); + if (-1 == fromLoc || -1 == toLoc) return NS_ERROR_FAILURE; + + fromLoc = fromLoc + 5; + toLoc = toLoc + 3; + + nsAutoCString fromStr, toStr; + + ContractIDStr.Mid(fromStr, fromLoc, toLoc - 4 - fromLoc); + ContractIDStr.Mid(toStr, toLoc, ContractIDStr.Length() - toLoc); + + aFromRes.Assign(fromStr); + aToRes.Assign(toStr); + + return NS_OK; +} + +using BFSHashTable = nsClassHashtable<nsCStringHashKey, BFSTableData>; + +// nsObjectHashtable enumerator functions. + +class CStreamConvDeallocator : public nsDequeFunctor<nsCString> { + public: + void operator()(nsCString* anObject) override { delete anObject; } +}; + +// walks the graph using a breadth-first-search algorithm which generates a +// discovered verticies tree. This tree is then walked up (from destination +// vertex, to origin vertex) and each link in the chain is added to an +// nsStringArray. A direct lookup for the given CONTRACTID should be made prior +// to calling this method in an attempt to find a direct converter rather than +// walking the graph. +nsresult nsStreamConverterService::FindConverter( + const char* aContractID, nsTArray<nsCString>** aEdgeList) { + nsresult rv; + if (!aEdgeList) return NS_ERROR_NULL_POINTER; + *aEdgeList = nullptr; + + // walk the graph in search of the appropriate converter. + + uint32_t vertexCount = mAdjacencyList.Count(); + if (0 >= vertexCount) return NS_ERROR_FAILURE; + + // Create a corresponding color table for each vertex in the graph. + BFSHashTable lBFSTable; + for (const auto& entry : mAdjacencyList) { + const nsACString& key = entry.GetKey(); + MOZ_ASSERT(entry.GetWeak(), "no data in the table iteration"); + lBFSTable.InsertOrUpdate(key, mozilla::MakeUnique<BFSTableData>(key)); + } + + NS_ASSERTION(lBFSTable.Count() == vertexCount, + "strmconv BFS table init problem"); + + // This is our source vertex; our starting point. + nsAutoCString fromC, toC; + rv = ParseFromTo(aContractID, fromC, toC); + if (NS_FAILED(rv)) return rv; + + BFSTableData* data = lBFSTable.Get(fromC); + if (!data) { + return NS_ERROR_FAILURE; + } + + data->color = gray; + data->distance = 0; + auto* dtorFunc = new CStreamConvDeallocator(); + + nsDeque grayQ(dtorFunc); + + // Now generate the shortest path tree. + grayQ.Push(new nsCString(fromC)); + while (0 < grayQ.GetSize()) { + nsCString* currentHead = (nsCString*)grayQ.PeekFront(); + nsTArray<RefPtr<nsAtom>>* data2 = mAdjacencyList.Get(*currentHead); + if (!data2) return NS_ERROR_FAILURE; + + // Get the state of the current head to calculate the distance of each + // reachable vertex in the loop. + BFSTableData* headVertexState = lBFSTable.Get(*currentHead); + if (!headVertexState) return NS_ERROR_FAILURE; + + int32_t edgeCount = data2->Length(); + + for (int32_t i = 0; i < edgeCount; i++) { + nsAtom* curVertexAtom = data2->ElementAt(i); + auto* curVertex = new nsCString(); + curVertexAtom->ToUTF8String(*curVertex); + + BFSTableData* curVertexState = lBFSTable.Get(*curVertex); + if (!curVertexState) { + delete curVertex; + return NS_ERROR_FAILURE; + } + + if (white == curVertexState->color) { + curVertexState->color = gray; + curVertexState->distance = headVertexState->distance + 1; + curVertexState->predecessor = + mozilla::MakeUnique<nsCString>(*currentHead); + grayQ.Push(curVertex); + } else { + delete curVertex; // if this vertex has already been discovered, we + // don't want to leak it. (non-discovered vertex's + // get cleaned up when they're popped). + } + } + headVertexState->color = black; + nsCString* cur = (nsCString*)grayQ.PopFront(); + delete cur; + cur = nullptr; + } + // The shortest path (if any) has been generated and is represented by the + // chain of BFSTableData->predecessor keys. Start at the bottom and work our + // way up. + + // first parse out the FROM and TO MIME-types being registered. + + nsAutoCString fromStr, toMIMEType; + rv = ParseFromTo(aContractID, fromStr, toMIMEType); + if (NS_FAILED(rv)) return rv; + + // get the root CONTRACTID + nsAutoCString ContractIDPrefix(NS_ISTREAMCONVERTER_KEY); + auto* shortestPath = new nsTArray<nsCString>(); + + data = lBFSTable.Get(toMIMEType); + if (!data) { + // If this vertex isn't in the BFSTable, then no-one has registered for it, + // therefore we can't do the conversion. + delete shortestPath; + return NS_ERROR_FAILURE; + } + + while (data) { + if (fromStr.Equals(data->key)) { + // found it. We're done here. + *aEdgeList = shortestPath; + return NS_OK; + } + + // reconstruct the CONTRACTID. + // Get the predecessor. + if (!data->predecessor) break; // no predecessor + BFSTableData* predecessorData = lBFSTable.Get(*data->predecessor); + + if (!predecessorData) break; // no predecessor, chain doesn't exist. + + // build out the CONTRACTID. + nsAutoCString newContractID(ContractIDPrefix); + newContractID.AppendLiteral("?from="); + + newContractID.Append(predecessorData->key); + + newContractID.AppendLiteral("&to="); + newContractID.Append(data->key); + + // Add this CONTRACTID to the chain. + // XXX(Bug 1631371) Check if this should use a fallible operation as it + // pretended earlier. + shortestPath->AppendElement(newContractID); + + // move up the tree. + data = predecessorData; + } + delete shortestPath; + return NS_ERROR_FAILURE; // couldn't find a stream converter or chain. +} + +///////////////////////////////////////////////////// +// nsIStreamConverterService methods +NS_IMETHODIMP +nsStreamConverterService::CanConvert(const char* aFromType, const char* aToType, + bool* _retval) { + nsCOMPtr<nsIComponentRegistrar> reg; + nsresult rv = NS_GetComponentRegistrar(getter_AddRefs(reg)); + if (NS_FAILED(rv)) return rv; + + nsAutoCString contractID; + contractID.AssignLiteral(NS_ISTREAMCONVERTER_KEY "?from="); + contractID.Append(aFromType); + contractID.AppendLiteral("&to="); + contractID.Append(aToType); + + // See if we have a direct match + rv = reg->IsContractIDRegistered(contractID.get(), _retval); + if (NS_FAILED(rv)) return rv; + if (*_retval) return NS_OK; + + // Otherwise try the graph. + rv = BuildGraph(); + if (NS_FAILED(rv)) return rv; + + nsTArray<nsCString>* converterChain = nullptr; + rv = FindConverter(contractID.get(), &converterChain); + *_retval = NS_SUCCEEDED(rv); + + delete converterChain; + return NS_OK; +} + +NS_IMETHODIMP +nsStreamConverterService::ConvertedType(const nsACString& aFromType, + nsIChannel* aChannel, + nsACString& aOutToType) { + // first determine whether we can even handle this conversion + // build a CONTRACTID + nsAutoCString contractID; + contractID.AssignLiteral(NS_ISTREAMCONVERTER_KEY "?from="); + contractID.Append(aFromType); + contractID.AppendLiteral("&to=*/*"); + const char* cContractID = contractID.get(); + + nsresult rv; + nsCOMPtr<nsIStreamConverter> converter(do_CreateInstance(cContractID, &rv)); + if (NS_SUCCEEDED(rv)) { + return converter->GetConvertedType(aFromType, aChannel, aOutToType); + } + return rv; +} + +NS_IMETHODIMP +nsStreamConverterService::Convert(nsIInputStream* aFromStream, + const char* aFromType, const char* aToType, + nsISupports* aContext, + nsIInputStream** _retval) { + if (!aFromStream || !aFromType || !aToType || !_retval) { + return NS_ERROR_NULL_POINTER; + } + nsresult rv; + + // first determine whether we can even handle this conversion + // build a CONTRACTID + nsAutoCString contractID; + contractID.AssignLiteral(NS_ISTREAMCONVERTER_KEY "?from="); + contractID.Append(aFromType); + contractID.AppendLiteral("&to="); + contractID.Append(aToType); + const char* cContractID = contractID.get(); + + nsCOMPtr<nsIStreamConverter> converter(do_CreateInstance(cContractID, &rv)); + if (NS_FAILED(rv)) { + // couldn't go direct, let's try walking the graph of converters. + rv = BuildGraph(); + if (NS_FAILED(rv)) return rv; + + nsTArray<nsCString>* converterChain = nullptr; + + rv = FindConverter(cContractID, &converterChain); + if (NS_FAILED(rv)) { + // can't make this conversion. + // XXX should have a more descriptive error code. + return NS_ERROR_FAILURE; + } + + int32_t edgeCount = int32_t(converterChain->Length()); + NS_ASSERTION(edgeCount > 0, "findConverter should have failed"); + + // convert the stream using each edge of the graph as a step. + // this is our stream conversion traversal. + nsCOMPtr<nsIInputStream> dataToConvert = aFromStream; + nsCOMPtr<nsIInputStream> convertedData; + + for (int32_t i = edgeCount - 1; i >= 0; i--) { + const char* lContractID = converterChain->ElementAt(i).get(); + + converter = do_CreateInstance(lContractID, &rv); + + if (NS_FAILED(rv)) { + delete converterChain; + return rv; + } + + nsAutoCString fromStr, toStr; + rv = ParseFromTo(lContractID, fromStr, toStr); + if (NS_FAILED(rv)) { + delete converterChain; + return rv; + } + + rv = converter->Convert(dataToConvert, fromStr.get(), toStr.get(), + aContext, getter_AddRefs(convertedData)); + dataToConvert = convertedData; + if (NS_FAILED(rv)) { + delete converterChain; + return rv; + } + } + + delete converterChain; + convertedData.forget(_retval); + } else { + // we're going direct. + rv = converter->Convert(aFromStream, aFromType, aToType, aContext, _retval); + } + + return rv; +} + +NS_IMETHODIMP +nsStreamConverterService::AsyncConvertData(const char* aFromType, + const char* aToType, + nsIStreamListener* aListener, + nsISupports* aContext, + nsIStreamListener** _retval) { + if (!aFromType || !aToType || !aListener || !_retval) { + return NS_ERROR_NULL_POINTER; + } + + nsresult rv; + + // first determine whether we can even handle this conversion + // build a CONTRACTID + nsAutoCString contractID; + contractID.AssignLiteral(NS_ISTREAMCONVERTER_KEY "?from="); + contractID.Append(aFromType); + contractID.AppendLiteral("&to="); + contractID.Append(aToType); + const char* cContractID = contractID.get(); + + nsCOMPtr<nsIStreamConverter> listener(do_CreateInstance(cContractID, &rv)); + if (NS_FAILED(rv)) { + // couldn't go direct, let's try walking the graph of converters. + rv = BuildGraph(); + if (NS_FAILED(rv)) return rv; + + nsTArray<nsCString>* converterChain = nullptr; + + rv = FindConverter(cContractID, &converterChain); + if (NS_FAILED(rv)) { + // can't make this conversion. + // XXX should have a more descriptive error code. + return NS_ERROR_FAILURE; + } + + // aListener is the listener that wants the final, converted, data. + // we initialize finalListener w/ aListener so it gets put at the + // tail end of the chain, which in the loop below, means the *first* + // converter created. + nsCOMPtr<nsIStreamListener> finalListener = aListener; + + // convert the stream using each edge of the graph as a step. + // this is our stream conversion traversal. + int32_t edgeCount = int32_t(converterChain->Length()); + NS_ASSERTION(edgeCount > 0, "findConverter should have failed"); + for (int i = 0; i < edgeCount; i++) { + const char* lContractID = converterChain->ElementAt(i).get(); + + // create the converter for this from/to pair + nsCOMPtr<nsIStreamConverter> converter(do_CreateInstance(lContractID)); + NS_ASSERTION(converter, + "graph construction problem, built a contractid that wasn't " + "registered"); + + nsAutoCString fromStr, toStr; + rv = ParseFromTo(lContractID, fromStr, toStr); + if (NS_FAILED(rv)) { + delete converterChain; + return rv; + } + + // connect the converter w/ the listener that should get the converted + // data. + rv = converter->AsyncConvertData(fromStr.get(), toStr.get(), + finalListener, aContext); + if (NS_FAILED(rv)) { + delete converterChain; + return rv; + } + + // the last iteration of this loop will result in finalListener + // pointing to the converter that "starts" the conversion chain. + // this converter's "from" type is the original "from" type. Prior + // to the last iteration, finalListener will continuously be wedged + // into the next listener in the chain, then be updated. + finalListener = converter; + } + delete converterChain; + // return the first listener in the chain. + finalListener.forget(_retval); + } else { + // we're going direct. + rv = listener->AsyncConvertData(aFromType, aToType, aListener, aContext); + listener.forget(_retval); + } + + return rv; +} + +nsresult NS_NewStreamConv(nsStreamConverterService** aStreamConv) { + MOZ_ASSERT(aStreamConv != nullptr, "null ptr"); + if (!aStreamConv) return NS_ERROR_NULL_POINTER; + + RefPtr<nsStreamConverterService> conv = new nsStreamConverterService(); + conv.forget(aStreamConv); + + return NS_OK; +} |