Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Functions | Variables
TestStreamConv.cpp File Reference
#include "nsIServiceManager.h"
#include "nsIComponentManager.h"
#include "nsIComponentRegistrar.h"
#include "nsIStreamConverterService.h"
#include "nsIStreamConverter.h"
#include "nsICategoryManager.h"
#include "nsIFactory.h"
#include "nsIStringStream.h"
#include "nsCOMPtr.h"
#include "nsNetUtil.h"
#include "nspr.h"
#include "nsIEventQueueService.h"
#include "Converters.h"

Go to the source code of this file.


class  EndListener


#define ASYNC_TEST
#define SEND_DATA(x)   SendData(x, converterListener, request)


nsresult SendData (const char *aData, nsIStreamListener *aListener, nsIRequest *request)
int main (int argc, char *argv[])


static int gKeepRunning = 0
static nsIEventQueuegEventQ = nsnull

Define Documentation

Definition at line 51 of file TestStreamConv.cpp.

#define SEND_DATA (   x)    SendData(x, converterListener, request)

Definition at line 137 of file TestStreamConv.cpp.

Function Documentation

int main ( int  argc,
char *  argv[] 

Definition at line 140 of file TestStreamConv.cpp.

    nsresult rv;
        nsCOMPtr<nsIServiceManager> servMan;
        NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull);
        nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
        NS_ASSERTION(registrar, "Null nsIComponentRegistrar");
        if (registrar)
        // Create the Event Queue for this thread...
        nsCOMPtr<nsIEventQueueService> eventQService =
                 do_GetService(kEventQueueServiceCID, &rv);
        if (NS_FAILED(rv)) return rv;

        eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, &gEventQ);

        nsCOMPtr<nsICategoryManager> catman =
            do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
        if (NS_FAILED(rv)) return rv;
        nsXPIDLCString previous;

        // BEGIN - Stream converter registration
        //   All stream converters must register with the ComponentManager

        // these stream converters are just for testing. running this harness
        // from the dist/bin dir will also pickup converters registered
        // in other modules (necko converters for example).

        PRUint32 converterListSize = 7;
        const char *const converterList[] = {

        TestConverterFactory *convFactory = new TestConverterFactory(kTestConverterCID, "TestConverter", NS_ISTREAMCONVERTER_KEY);
        nsCOMPtr<nsIFactory> convFactSup(do_QueryInterface(convFactory, &rv));
        if (NS_FAILED(rv)) return rv;

        for (PRUint32 count = 0; count < converterListSize; ++count) {
            // register the TestConverter with the component manager. One contractid registration
            // per conversion pair (from - to pair).
            nsCString contractID(NS_ISTREAMCONVERTER_KEY);
            rv = registrar->RegisterFactory(kTestConverterCID,
            if (NS_FAILED(rv)) return rv;
            rv = catman->AddCategoryEntry(NS_ISTREAMCONVERTER_KEY, converterList[count], "x",
                                            PR_TRUE, PR_TRUE, getter_Copies(previous));
            if (NS_FAILED(rv)) return rv;

        nsCOMPtr<nsIStreamConverterService> StreamConvService =
                 do_GetService(kStreamConverterServiceCID, &rv);
        if (NS_FAILED(rv)) return rv;

        // Define the *from* content type and *to* content-type for conversion.
        static const char fromStr[] = "a/foo";
        static const char toStr[] = "c/foo";
        // ASYNCHRONOUS conversion

        // Build up a channel that represents the content we're
        // starting the transaction with.
        // sample multipart mixed content-type string:
        // "multipart/x-mixed-replacE;boundary=thisrandomstring"
#if 0
        nsCOMPtr<nsIChannel> channel;
        nsCOMPtr<nsIURI> dummyURI;
        rv = NS_NewURI(getter_AddRefs(dummyURI), "http://meaningless");
        if (NS_FAILED(rv)) return rv;

        rv = NS_NewInputStreamChannel(getter_AddRefs(channel),
                                      nsnull,   // inStr
                                      "text/plain", // content-type
                                      -1);      // XXX fix contentLength
        if (NS_FAILED(rv)) return rv;

        nsCOMPtr<nsIRequest> request(do_QueryInterface(channel));

        nsCOMPtr<nsIRequest> request;

        // setup a listener to receive the converted data. This guy is the end
        // listener in the chain, he wants the fully converted (toType) data.
        // An example of this listener in mozilla would be the DocLoader.
        nsIStreamListener *dataReceiver = new EndListener();

        // setup a listener to push the data into. This listener sits inbetween the
        // unconverted data of fromType, and the final listener in the chain (in this case
        // the dataReceiver.
        nsIStreamListener *converterListener = nsnull;
        rv = StreamConvService->AsyncConvertData(fromStr, toStr,
                                                 dataReceiver, nsnull, &converterListener);
        if (NS_FAILED(rv)) return rv;

        // at this point we have a stream listener to push data to, and the one
        // that will receive the converted data. Let's mimic On*() calls and get the conversion
        // going. Typically these On*() calls would be made inside their respective wrappers On*()
        // methods.
        rv = converterListener->OnStartRequest(request, nsnull);
        if (NS_FAILED(rv)) return rv;

        rv = SEND_DATA("aaa");
        if (NS_FAILED(rv)) return rv;

        rv = SEND_DATA("aaa");
        if (NS_FAILED(rv)) return rv;

        // Finish the request.
        rv = converterListener->OnStopRequest(request, nsnull, rv);
        if (NS_FAILED(rv)) return rv;

        // SYNCHRONOUS conversion
        nsCOMPtr<nsIInputStream> convertedData;
        rv = StreamConvService->Convert(inputData, fromStr, toStr,
                                        nsnull, getter_AddRefs(convertedData));
        if (NS_FAILED(rv)) return rv;

        // Enter the message pump to allow the URL load to proceed.
        while ( gKeepRunning ) {
            PLEvent *gEvent;
            /* gKeepRunning = PR_FALSE; */
    } // this scopes the nsCOMPtrs
    // no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
    return rv;

Here is the call graph for this function:

static NS_DEFINE_CID ( kStreamConverterServiceCID  ,
) [static]
nsresult SendData ( const char *  aData,
nsIStreamListener aListener,
nsIRequest request 

Definition at line 127 of file TestStreamConv.cpp.

    nsCOMPtr<nsIInputStream> dataStream;
    nsresult rv = NS_NewCharInputStream(getter_AddRefs(dataStream), aData);
    if (NS_FAILED(rv)) return rv;

    PRUint32 avail;

    return aListener->OnDataAvailable(request, nsnull, dataStream, 0, avail);

Here is the call graph for this function:

Variable Documentation

Definition at line 65 of file TestStreamConv.cpp.

int gKeepRunning = 0 [static]

Definition at line 64 of file TestStreamConv.cpp.