Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Firefox/netwerk/streamconv/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 17 kB

Quelle nsStreamConverterService.cpp Sprache: C

/* -*- 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/Components.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(
      mozilla::components::CategoryManager::Service(&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;
}

quality92%

¤ Dauer der Verarbeitung: 0.39 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.