Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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;
+}