The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

 /* 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/. */

 /* This must occur *after* layers/PLayers.h to avoid typedefs conflicts. */

 #include "LayerScope.h"

 #include "Composer2D.h"

 #include "Effects.h"

 #include "mozilla/TimeStamp.h"

 #include "mozilla/Preferences.h"

 #include "mozilla/Endian.h"

 #include "TexturePoolOGL.h"

 #include "mozilla/layers/TextureHostOGL.h"

 #include "gfxColor.h"

 #include "gfxContext.h"

 #include "gfxUtils.h"

 #include "gfxPrefs.h"

 #include "nsIWidget.h"

 #include "GLContext.h"

 #include "GLContextProvider.h"

 #include "GLReadTexImageHelper.h"

 #include "nsIServiceManager.h"

 #include "nsIConsoleService.h"

 #include <memory>

 #include "mozilla/LinkedList.h"

 #include "mozilla/Base64.h"

 #include "mozilla/SHA1.h"

 #include "mozilla/StaticPtr.h"

 #include "nsThreadUtils.h"

 #include "nsISocketTransport.h"

 #include "nsIServerSocket.h"

 #include "nsReadLine.h"

 #include "nsNetCID.h"

 #include "nsIOutputStream.h"

 #include "nsIAsyncInputStream.h"

 #include "nsIEventTarget.h"

 #include "nsProxyRelease.h"

 // Undo the damage done by mozzconf.h

 #undef compress

 #include "mozilla/Compression.h"

 #ifdef __GNUC__

 #define PACKED_STRUCT __attribute__((packed))

 #else

 #define PACKED_STRUCT

 #endif

 namespace mozilla {

 namespace layers {

 using namespace mozilla::Compression;

 using namespace mozilla::gfx;

 using namespace mozilla::gl;

 using namespace mozilla;

 class DebugDataSender;

 class DebugGLData;

 /* This class handle websocket protocol which included

  * handshake and data frame's header

  */

 class LayerScopeWebSocketHandler : public nsIInputStreamCallback {

 public:

     NS_DECL_THREADSAFE_ISUPPORTS

     enum SocketStateType {

         NoHandshake,

         HandshakeSuccess,

         HandshakeFailed

     };

     LayerScopeWebSocketHandler()

         : mState(NoHandshake)

     { }

     virtual ~LayerScopeWebSocketHandler()

     {

         if (mTransport) {

             mTransport->Close(NS_OK);

         }

     }

     void OpenStream(nsISocketTransport* aTransport) {

         MOZ_ASSERT(aTransport);

         mTransport = aTransport;

         mTransport->OpenOutputStream(nsITransport::OPEN_BLOCKING,

                                      0,

                                      0,

                                      getter_AddRefs(mOutputStream));

         nsCOMPtr<nsIInputStream> debugInputStream;

         mTransport->OpenInputStream(0,

                                     0,

                                     0,

                                     getter_AddRefs(debugInputStream));

         mInputStream = do_QueryInterface(debugInputStream);

         mInputStream->AsyncWait(this, 0, 0, NS_GetCurrentThread());

     }

     bool WriteToStream(void *ptr, uint32_t size) {

         if (mState == NoHandshake) {

             // Not yet handshake, just return true in case of

             // LayerScope remove this handle

             return true;

         } else if (mState == HandshakeFailed) {

             return false;

         }

         // Generate WebSocket header

         uint8_t wsHeader[10];

         int wsHeaderSize = 0;

         const uint8_t opcode = 0x2;

         wsHeader[0] = 0x80 | (opcode & 0x0f); // FIN + opcode;

         if (size <= 125) {

             wsHeaderSize = 2;

             wsHeader[1] = size;

         } else if (size < 65536) {

             wsHeaderSize = 4;

             wsHeader[1] = 0x7E;

             NetworkEndian::writeUint16(wsHeader + 2, size);

         } else {

             wsHeaderSize = 10;

             wsHeader[1] = 0x7F;

             NetworkEndian::writeUint64(wsHeader + 2, size);

         }

         // Send WebSocket header

         nsresult rv;

         uint32_t cnt;

         rv = mOutputStream->Write(reinterpret_cast<char*>(wsHeader),

                                  wsHeaderSize, &cnt);

         if (NS_FAILED(rv))

             return false;

         uint32_t written = 0;

         while (written < size) {

             uint32_t cnt;

             rv = mOutputStream->Write(reinterpret_cast<char*>(ptr) + written,

                                      size - written, &cnt);

             if (NS_FAILED(rv))

                 return false;

             written += cnt;

         }

         return true;

     }

     // nsIInputStreamCallback

     NS_IMETHODIMP OnInputStreamReady(nsIAsyncInputStream *stream) MOZ_OVERRIDE

     {

         nsTArray<nsCString> protocolString;

         ReadInputStreamData(protocolString);

         if (WebSocketHandshake(protocolString)) {

             mState = HandshakeSuccess;

         } else {

             mState = HandshakeFailed;

         }

         return NS_OK;

     }

 private:

     void ReadInputStreamData(nsTArray<nsCString>& aProtocolString)

     {

         nsLineBuffer<char> lineBuffer;

         nsCString line;

         bool more = true;

         do {

             NS_ReadLine(mInputStream.get(), &lineBuffer, line, &more);

             if (line.Length() > 0) {

                 aProtocolString.AppendElement(line);

             }

         } while (more && line.Length() > 0);

     }

     bool WebSocketHandshake(nsTArray<nsCString>& aProtocolString)

     {

         nsresult rv;

         bool isWebSocket = false;

         nsCString version;

         nsCString wsKey;

         nsCString protocol;

         // Validate WebSocket client request.

         if (aProtocolString.Length() == 0)

             return false;

         // Check that the HTTP method is GET

         const char* HTTP_METHOD = "GET ";

         if (strncmp(aProtocolString[0].get(), HTTP_METHOD, strlen(HTTP_METHOD)) != 0) {

             return false;

         }

         for (uint32_t i = 1; i < aProtocolString.Length(); ++i) {

             const char* line = aProtocolString[i].get();

             const char* prop_pos = strchr(line, ':');

             if (prop_pos != nullptr) {

                 nsCString key(line, prop_pos - line);

                 nsCString value(prop_pos + 2);

                 if (key.EqualsIgnoreCase("upgrade") &&

                     value.EqualsIgnoreCase("websocket")) {

                     isWebSocket = true;

                 } else if (key.EqualsIgnoreCase("sec-websocket-version")) {

                     version = value;

                 } else if (key.EqualsIgnoreCase("sec-websocket-key")) {

                     wsKey = value;

                 } else if (key.EqualsIgnoreCase("sec-websocket-protocol")) {

                     protocol = value;

                 }

             }

         }

         if (!isWebSocket) {

             return false;

         }

         if (!(version.Equals("7") || version.Equals("8") || version.Equals("13"))) {

             return false;

         }

         if (!(protocol.EqualsIgnoreCase("binary"))) {

             return false;

         }

         // Client request is valid. Start to generate and send server response.

         nsAutoCString guid("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");

         nsAutoCString res;

         SHA1Sum sha1;

         nsCString combined(wsKey + guid);

         sha1.update(combined.get(), combined.Length());

         uint8_t digest[SHA1Sum::HashSize]; // SHA1 digests are 20 bytes long.

         sha1.finish(digest);

         nsCString newString(reinterpret_cast<char*>(digest), SHA1Sum::HashSize);

         Base64Encode(newString, res);

         nsCString response("HTTP/1.1 101 Switching Protocols\r\n");

         response.Append("Upgrade: websocket\r\n");

         response.Append("Connection: Upgrade\r\n");

         response.Append(nsCString("Sec-WebSocket-Accept: ") + res + nsCString("\r\n"));

         response.Append("Sec-WebSocket-Protocol: binary\r\n\r\n");

         uint32_t written = 0;

         uint32_t size = response.Length();

         while (written < size) {

             uint32_t cnt;

             rv = mOutputStream->Write(const_cast<char*>(response.get()) + written,

                                      size - written, &cnt);

             if (NS_FAILED(rv))

                 return false;

             written += cnt;

         }

         mOutputStream->Flush();

         return true;

     }

     nsCOMPtr<nsIOutputStream> mOutputStream;

     nsCOMPtr<nsIAsyncInputStream> mInputStream;

     nsCOMPtr<nsISocketTransport> mTransport;

     SocketStateType mState;

 };

 NS_IMPL_ISUPPORTS(LayerScopeWebSocketHandler, nsIInputStreamCallback);

 class LayerScopeWebSocketManager {

 public:

     LayerScopeWebSocketManager();

     ~LayerScopeWebSocketManager();

     void AddConnection(nsISocketTransport *aTransport)

     {

         MOZ_ASSERT(aTransport);

         nsRefPtr<LayerScopeWebSocketHandler> temp = new LayerScopeWebSocketHandler();

         temp->OpenStream(aTransport);

         mHandlers.AppendElement(temp.get());

     }

     void RemoveConnection(uint32_t aIndex)

     {

         MOZ_ASSERT(aIndex < mHandlers.Length());

         mHandlers.RemoveElementAt(aIndex);

     }

     void RemoveAllConnections()

     {

         mHandlers.Clear();

     }

     bool WriteAll(void *ptr, uint32_t size)

     {

         for (int32_t i = mHandlers.Length() - 1; i >= 0; --i) {

             if (!mHandlers[i]->WriteToStream(ptr, size)) {

                 // Send failed, remove this handler

                 RemoveConnection(i);

             }

         }

         return true;

     }

     bool IsConnected()

     {

         return (mHandlers.Length() != 0) ? true : false;

     }

     void AppendDebugData(DebugGLData *aDebugData);

     void DispatchDebugData();

 private:

     nsTArray<nsRefPtr<LayerScopeWebSocketHandler> > mHandlers;

     nsCOMPtr<nsIThread> mDebugSenderThread;

     nsRefPtr<DebugDataSender> mCurrentSender;

     nsCOMPtr<nsIServerSocket> mServerSocket;

 };

 static StaticAutoPtr<LayerScopeWebSocketManager> gLayerScopeWebSocketManager;

 class DebugGLData : public LinkedListElement<DebugGLData> {

 public:

     typedef enum {

         FrameStart,

         FrameEnd,

         TextureData,

         ColorData

     } DataType;

     virtual ~DebugGLData() { }

     DataType GetDataType() const { return mDataType; }

     intptr_t GetContextAddress() const { return mContextAddress; }

     int64_t GetValue() const { return mValue; }

     DebugGLData(DataType dataType)

         : mDataType(dataType),

           mContextAddress(0),

           mValue(0)

     { }

     DebugGLData(DataType dataType, GLContext* cx)

         : mDataType(dataType),

           mContextAddress(reinterpret_cast<intptr_t>(cx)),

           mValue(0)

     { }

     DebugGLData(DataType dataType, GLContext* cx, int64_t value)

         : mDataType(dataType),

           mContextAddress(reinterpret_cast<intptr_t>(cx)),

           mValue(value)

     { }

     virtual bool Write() {

         if (mDataType != FrameStart &&

             mDataType != FrameEnd)

         {

             NS_WARNING("Unimplemented data type!");

             return false;

         }

         DebugGLData::BasicPacket packet;

         packet.type = mDataType;

         packet.ptr = static_cast<uint64_t>(mContextAddress);

         packet.value = mValue;

         return WriteToStream(&packet, sizeof(packet));

     }

     static bool WriteToStream(void *ptr, uint32_t size) {

         if (!gLayerScopeWebSocketManager)

             return true;

         return gLayerScopeWebSocketManager->WriteAll(ptr, size);

     }

 protected:

     DataType mDataType;

     intptr_t mContextAddress;

     int64_t mValue;

 public:

   // the data packet formats; all packed

 #ifdef _MSC_VER

 #pragma pack(push, 1)

 #endif

     typedef struct {

         uint32_t type;

         uint64_t ptr;

         uint64_t value;

     } PACKED_STRUCT BasicPacket;

     typedef struct {

         uint32_t type;

         uint64_t ptr;

         uint64_t layerref;

         uint32_t color;

         uint32_t width;

         uint32_t height;

     } PACKED_STRUCT ColorPacket;

     typedef struct {

         uint32_t type;

         uint64_t ptr;

         uint64_t layerref;

         uint32_t name;

         uint32_t width;

         uint32_t height;

         uint32_t stride;

         uint32_t format;

         uint32_t target;

         uint32_t dataFormat;

         uint32_t dataSize;

     } PACKED_STRUCT TexturePacket;

 #ifdef _MSC_VER

 #pragma pack(pop)

 #endif

 };

 class DebugGLTextureData : public DebugGLData {

 public:

     DebugGLTextureData(GLContext* cx, void* layerRef, GLuint target, GLenum name, DataSourceSurface* img)

         : DebugGLData(DebugGLData::TextureData, cx),

           mLayerRef(layerRef),

           mTarget(target),

           mName(name),

           mImage(img)

     { }

     void *GetLayerRef() const { return mLayerRef; }

     GLuint GetName() const { return mName; }

     DataSourceSurface* GetImage() const { return mImage; }

     GLenum GetTextureTarget() const { return mTarget; }

     virtual bool Write() {

         DebugGLData::TexturePacket packet;

         char* dataptr = nullptr;

         uint32_t datasize = 0;

         std::auto_ptr<char> compresseddata;

         packet.type = mDataType;

         packet.ptr = static_cast<uint64_t>(mContextAddress);

         packet.layerref = reinterpret_cast<uint64_t>(mLayerRef);

         packet.name = mName;

         packet.format = 0;

         packet.target = mTarget;

         packet.dataFormat = LOCAL_GL_RGBA;

         if (mImage) {

             packet.width = mImage->GetSize().width;

             packet.height = mImage->GetSize().height;

             packet.stride = mImage->Stride();

             packet.dataSize = mImage->GetSize().height * mImage->Stride();

             dataptr = (char*) mImage->GetData();

             datasize = packet.dataSize;

             compresseddata = std::auto_ptr<char>((char*) moz_malloc(LZ4::maxCompressedSize(datasize)));

             if (compresseddata.get()) {

                 int ndatasize = LZ4::compress(dataptr, datasize, compresseddata.get());

                 if (ndatasize > 0) {

                     datasize = ndatasize;

                     dataptr = compresseddata.get();

                     packet.dataFormat = (1 << 16) | packet.dataFormat;

                     packet.dataSize = datasize;

                 }

             }

         } else {

             packet.width = 0;

             packet.height = 0;

             packet.stride = 0;

             packet.dataSize = 0;

         }

         // write the packet header data

         if (!WriteToStream(&packet, sizeof(packet)))

             return false;

         // then the image data

         if (!WriteToStream(dataptr, datasize))

             return false;

         // then pad out to 4 bytes

         if (datasize % 4 != 0) {

             static char buf[] = { 0, 0, 0, 0 };

             if (!WriteToStream(buf, 4 - (datasize % 4)))

                 return false;

         }

         return true;

     }

 protected:

     void* mLayerRef;

     GLenum mTarget;

     GLuint mName;

     RefPtr<DataSourceSurface> mImage;

 };

 class DebugGLColorData : public DebugGLData {

 public:

     DebugGLColorData(void* layerRef, const gfxRGBA& color, int width, int height)

         : DebugGLData(DebugGLData::ColorData),

           mColor(color.Packed()),

           mSize(width, height)

     { }

     void *GetLayerRef() const { return mLayerRef; }

     uint32_t GetColor() const { return mColor; }

     const nsIntSize& GetSize() const { return mSize; }

     virtual bool Write() {

         DebugGLData::ColorPacket packet;

         packet.type = mDataType;

         packet.ptr = static_cast<uint64_t>(mContextAddress);

         packet.layerref = reinterpret_cast<uintptr_t>(mLayerRef);

         packet.color = mColor;

         packet.width = mSize.width;

         packet.height = mSize.height;

         return WriteToStream(&packet, sizeof(packet));

     }

 protected:

     void *mLayerRef;

     uint32_t mColor;

     nsIntSize mSize;

 };

 static bool

 CheckSender()

 {

     if (!gLayerScopeWebSocketManager)

         return false;

     if (!gLayerScopeWebSocketManager->IsConnected())

         return false;

     return true;

 }

 class DebugListener : public nsIServerSocketListener

 {

 public:

     NS_DECL_THREADSAFE_ISUPPORTS

     DebugListener() { }

     virtual ~DebugListener() { }

     /* nsIServerSocketListener */

     NS_IMETHODIMP OnSocketAccepted(nsIServerSocket *aServ,

                                    nsISocketTransport *aTransport)

     {

         if (!gLayerScopeWebSocketManager)

             return NS_OK;

         printf_stderr("*** LayerScope: Accepted connection\n");

         gLayerScopeWebSocketManager->AddConnection(aTransport);

         return NS_OK;

     }

     NS_IMETHODIMP OnStopListening(nsIServerSocket *aServ,

                                   nsresult aStatus)

     {

         return NS_OK;

     }

 };

 NS_IMPL_ISUPPORTS(DebugListener, nsIServerSocketListener);

 class DebugDataSender : public nsIRunnable

 {

 public:

     NS_DECL_THREADSAFE_ISUPPORTS

     DebugDataSender() {

         mList = new LinkedList<DebugGLData>();

     }

     virtual ~DebugDataSender() {

         Cleanup();

     }

     void Append(DebugGLData *d) {

         mList->insertBack(d);

     }

     void Cleanup() {

         if (!mList)

             return;

         DebugGLData *d;

         while ((d = mList->popFirst()) != nullptr)

             delete d;

         delete mList;

         mList = nullptr;

     }

     /* nsIRunnable impl; send the data */

     NS_IMETHODIMP Run() {

         DebugGLData *d;

         nsresult rv = NS_OK;

         while ((d = mList->popFirst()) != nullptr) {

             std::auto_ptr<DebugGLData> cleaner(d);

             if (!d->Write()) {

                 rv = NS_ERROR_FAILURE;

                 break;

             }

         }

         Cleanup();

         if (NS_FAILED(rv)) {

             LayerScope::DestroyServerSocket();

         }

         return NS_OK;

     }

 protected:

     LinkedList<DebugGLData> *mList;

 };

 NS_IMPL_ISUPPORTS(DebugDataSender, nsIRunnable);

 void

 LayerScope::CreateServerSocket()

 {

     if (!gfxPrefs::LayerScopeEnabled()) {

         return;

     }

     if (!gLayerScopeWebSocketManager) {

         gLayerScopeWebSocketManager = new LayerScopeWebSocketManager();

     }

 }

 void

 LayerScope::DestroyServerSocket()

 {

     if (gLayerScopeWebSocketManager) {

         gLayerScopeWebSocketManager->RemoveAllConnections();

     }

 }

 void

 LayerScope::BeginFrame(GLContext* aGLContext, int64_t aFrameStamp)

 {

     if (!gLayerScopeWebSocketManager)

         return;

     if (!gLayerScopeWebSocketManager->IsConnected())

         return;

 #if 0

     // if we're sending data in between frames, flush the list down the socket,

     // and start a new one

     if (gCurrentSender) {

         gDebugSenderThread->Dispatch(gCurrentSender, NS_DISPATCH_NORMAL);

     }

 #endif

     gLayerScopeWebSocketManager->AppendDebugData(new DebugGLData(DebugGLData::FrameStart, aGLContext, aFrameStamp));

 }

 void

 LayerScope::EndFrame(GLContext* aGLContext)

 {

     if (!CheckSender())

         return;

     gLayerScopeWebSocketManager->AppendDebugData(new DebugGLData(DebugGLData::FrameEnd, aGLContext));

     gLayerScopeWebSocketManager->DispatchDebugData();

 }

 static void

 SendColor(void* aLayerRef, const gfxRGBA& aColor, int aWidth, int aHeight)

 {

     if (!CheckSender())

         return;

     gLayerScopeWebSocketManager->AppendDebugData(

         new DebugGLColorData(aLayerRef, aColor, aWidth, aHeight));

 }

 static void

 SendTextureSource(GLContext* aGLContext,

                   void* aLayerRef,

                   TextureSourceOGL* aSource,

                   bool aFlipY)

 {

     GLenum textureTarget = aSource->GetTextureTarget();

     ShaderConfigOGL config = ShaderConfigFromTargetAndFormat(textureTarget,

                                                              aSource->GetFormat());

     int shaderConfig = config.mFeatures;

     aSource->BindTexture(LOCAL_GL_TEXTURE0, gfx::Filter::LINEAR);

     GLuint textureId = 0;

     // This is horrid hack. It assumes that aGLContext matches the context

     // aSource has bound to.

     if (textureTarget == LOCAL_GL_TEXTURE_2D) {

         aGLContext->GetUIntegerv(LOCAL_GL_TEXTURE_BINDING_2D, &textureId);

     } else if (textureTarget == LOCAL_GL_TEXTURE_EXTERNAL) {

         aGLContext->GetUIntegerv(LOCAL_GL_TEXTURE_BINDING_EXTERNAL, &textureId);

     } else if (textureTarget == LOCAL_GL_TEXTURE_RECTANGLE) {

         aGLContext->GetUIntegerv(LOCAL_GL_TEXTURE_BINDING_RECTANGLE, &textureId);

     }

     gfx::IntSize size = aSource->GetSize();

     // By sending 0 to ReadTextureImage rely upon aSource->BindTexture binding

     // texture correctly. textureId is used for tracking in DebugGLTextureData.

     RefPtr<DataSourceSurface> img =

         aGLContext->ReadTexImageHelper()->ReadTexImage(0, textureTarget,

                                                        size,

                                                        shaderConfig, aFlipY);

     gLayerScopeWebSocketManager->AppendDebugData(

         new DebugGLTextureData(aGLContext, aLayerRef, textureTarget,

                                textureId, img));

 }

 static void

 SendTexturedEffect(GLContext* aGLContext,

                    void* aLayerRef,

                    const TexturedEffect* aEffect)

 {

     TextureSourceOGL* source = aEffect->mTexture->AsSourceOGL();

     if (!source)

         return;

     bool flipY = false;

     SendTextureSource(aGLContext, aLayerRef, source, flipY);

 }

 static void

 SendYCbCrEffect(GLContext* aGLContext,

                 void* aLayerRef,

                 const EffectYCbCr* aEffect)

 {

     TextureSource* sourceYCbCr = aEffect->mTexture;

     if (!sourceYCbCr)

         return;

     const int Y = 0, Cb = 1, Cr = 2;

     TextureSourceOGL* sourceY =  sourceYCbCr->GetSubSource(Y)->AsSourceOGL();

     TextureSourceOGL* sourceCb = sourceYCbCr->GetSubSource(Cb)->AsSourceOGL();

     TextureSourceOGL* sourceCr = sourceYCbCr->GetSubSource(Cr)->AsSourceOGL();

     bool flipY = false;

     SendTextureSource(aGLContext, aLayerRef, sourceY,  flipY);

     SendTextureSource(aGLContext, aLayerRef, sourceCb, flipY);

     SendTextureSource(aGLContext, aLayerRef, sourceCr, flipY);

 }

 void

 LayerScope::SendEffectChain(GLContext* aGLContext,

                             const EffectChain& aEffectChain,

                             int aWidth, int aHeight)

 {

     if (!CheckSender())

         return;

     const Effect* primaryEffect = aEffectChain.mPrimaryEffect;

     switch (primaryEffect->mType) {

     case EFFECT_RGB:

     {

         const TexturedEffect* texturedEffect =

             static_cast<const TexturedEffect*>(primaryEffect);

         SendTexturedEffect(aGLContext, aEffectChain.mLayerRef, texturedEffect);

     }

     break;

     case EFFECT_YCBCR:

     {

         const EffectYCbCr* yCbCrEffect =

             static_cast<const EffectYCbCr*>(primaryEffect);

         SendYCbCrEffect(aGLContext, aEffectChain.mLayerRef, yCbCrEffect);

     }

     case EFFECT_SOLID_COLOR:

     {

         const EffectSolidColor* solidColorEffect =

             static_cast<const EffectSolidColor*>(primaryEffect);

         gfxRGBA color(solidColorEffect->mColor.r,

                       solidColorEffect->mColor.g,

                       solidColorEffect->mColor.b,

                       solidColorEffect->mColor.a);

         SendColor(aEffectChain.mLayerRef, color, aWidth, aHeight);

     }

     break;

     case EFFECT_COMPONENT_ALPHA:

     case EFFECT_RENDER_TARGET:

     default:

         break;

     }

     //const Effect* secondaryEffect = aEffectChain.mSecondaryEffects[EFFECT_MASK];

     // TODO:

 }

 LayerScopeWebSocketManager::LayerScopeWebSocketManager()

 {

     NS_NewThread(getter_AddRefs(mDebugSenderThread));

     mServerSocket = do_CreateInstance(NS_SERVERSOCKET_CONTRACTID);

     int port = gfxPrefs::LayerScopePort();

     mServerSocket->Init(port, false, -1);

     mServerSocket->AsyncListen(new DebugListener);

 }

 LayerScopeWebSocketManager::~LayerScopeWebSocketManager()

 {

 }

 void LayerScopeWebSocketManager::AppendDebugData(DebugGLData *aDebugData)

 {

     if (!mCurrentSender) {

         mCurrentSender = new DebugDataSender();

     }

     mCurrentSender->Append(aDebugData);

 }

 void LayerScopeWebSocketManager::DispatchDebugData()

 {

     mDebugSenderThread->Dispatch(mCurrentSender, NS_DISPATCH_NORMAL);

     mCurrentSender = nullptr;

 }

 } /* layers */

 } /* mozilla */