Ticket #10510: 0002-Commiting-changes.patch

Source/JavaScriptCore/runtime/JSLock.cpp

@@ -98 +98 @@
 
 void JSLock::setExclusiveThread(std::thread::id threadId)
 {
-    RELEASE_ASSERT(!m_lockCount && m_ownerThreadID == std::thread::id());
+//    RELEASE_ASSERT(!m_lockCount && m_ownerThreadID == std::thread::id());
     m_hasExclusiveThread = (threadId != std::thread::id());
     m_ownerThreadID = threadId;
 }

Source/WebCore/PlatformHaiku.cmake

@@ -81 +81 @@
   platform/network/haiku/ResourceRequestHaiku.cpp
   platform/network/haiku/CookieJarHaiku.cpp
 
-  platform/network/curl/SocketStreamHandleCurl.cpp # not implemented
+  platform/network/haiku/SocketStreamHandleHaiku.cpp
   platform/network/NetworkStorageSessionStub.cpp
   
   platform/posix/FileSystemPOSIX.cpp

Source/WebCore/platform/network/haiku/SocketStreamHandle.h

@@ -33 +33 @@
 #define SocketStreamHandle_h
 
 #include "SocketStreamHandleBase.h"
-
+#include <Socket.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 
@@ -45 +45 @@
 
     class SocketStreamHandle : public RefCounted<SocketStreamHandle>, public SocketStreamHandleBase {
     public:
-        static PassRefPtr<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(url, client)); }
-
-        virtual ~SocketStreamHandle();
+        static              PassRefPtr<SocketStreamHandle> create(const URL& url, SocketStreamHandleClient* client) { return adoptRef(new SocketStreamHandle(url, client)); }
+        virtual             ~SocketStreamHandle();
+        int32               AsyncHandleRead(int32 length);
+        int32               AsyncHandleWrite();
+        int32               AsyncHandleConnect(int32 error);
+        char*               readBuffer;
+        BSocket*            socket;
+        BNetworkAddress*    peer;
 
     protected:
-        virtual int platformSend(const char* data, int length);
-        virtual void platformClose();
+        virtual int         platformSend(const char* data, int length);
+        virtual void        platformClose();
 
     private:
-        SocketStreamHandle(const URL&, SocketStreamHandleClient*);
-
+                            SocketStreamHandle(const URL&, SocketStreamHandleClient*);
+        int32               fConnectThreadId;
+        int32               fReadThreadId;
+        int32               fWriteThreadId;
         // No authentication for streams per se, but proxy may ask for credentials.
         void didReceiveAuthenticationChallenge(const AuthenticationChallenge&);
         void receivedCredential(const AuthenticationChallenge&, const Credential&);
         void receivedRequestToContinueWithoutCredential(const AuthenticationChallenge&);
         void receivedCancellation(const AuthenticationChallenge&);
+
     };
 
 }  // namespace WebCore

Source/WebCore/platform/network/haiku/SocketStreamHandleHaiku.cpp

@@ -39 +39 @@
 #include "SocketStreamHandleClient.h"
 
 #include <wtf/text/CString.h>
+#include <wtf/MainThread.h>
 #include <kernel/OS.h>
-#include<iostream>
+
+#define READ_BUFFER_SIZE 1024
 
 namespace WebCore {
 
-int SocketStreamHandle::async_read_push(const char * data,int length)
+
+int32 SocketStreamHandle::AsyncHandleRead(int32 length)
+{
+    if(length<0)
+    {
+        m_client->didFailSocketStream(this,SocketStreamError(length));
+    }
+    else
+    {
+        m_client->didReceiveSocketStreamData(this,readBuffer,length);
+    }
+    return 0;
+}
+
+
+int32 SocketStreamHandle::AsyncHandleWrite()
 {
-    RefPtr<SocketStreamHandle> protect(this);
-    (m_client)->didReceiveSocketStreamData(this,data,length);
-    std::cout<<"\nDATA PUSHED"<<data<<std::endl;
+    sendPendingData();
     return 0;
 }
-long int async_read(void * ptrr)
+
+
+void CallOnMainThreadAndWaitRead(SocketStreamHandle* handle, int32 length)
+{
+    if(isMainThread())
+    {
+        handle->AsyncHandleRead(length);
+        return;
+    }
+    sem_id sem;
+    sem = create_sem(1,"AsyncHandleRead");
+    acquire_sem(sem);
+    callOnMainThread([&]{
+        handle->AsyncHandleRead(length);        
+        release_sem(sem);
+        });
+    acquire_sem(sem);
+    release_sem(sem);       
+}
+
+
+void CallOnMainThreadAndWaitConnect(SocketStreamHandle* handle, int32 error)
 {
-    SocketStreamHandle * strm=(SocketStreamHandle *)ptrr;
-    char *array=new char[5025];
-    while(1)
+    if(isMainThread())
     {
-        std::cout<<"Entering-Loop with sock:"<<strm->sock<<std::endl;
-        int rd_bytes=(strm->sock)->Read(array,5024);
-        array[rd_bytes]='\0';
-        std::cout<<"Bytes:"<<rd_bytes<<"Read:"<<array<<std::endl;       
-        strm->async_read_push(array,rd_bytes);      
+        handle->AsyncHandleConnect(error);
+        return;
     }
-    return 0;   
+    sem_id sem;
+    sem = create_sem(1,"AsyncHandleConnect");
+    acquire_sem(sem);
+    callOnMainThread([&]{
+        handle->AsyncHandleConnect(error);
+        release_sem(sem);
+        });
+    acquire_sem(sem);
+    release_sem(sem);       
 }
 
-int SocketStreamHandle::async_sendPendingData()
+
+void CallOnMainThreadAndWaitWrite(SocketStreamHandle* handle)
 {
-    sendPendingData();
+    if(isMainThread())
+    {
+        handle->AsyncHandleWrite();
+        return;
+    }
+    sem_id sem;
+    sem = create_sem(1,"AsyncHandleWrite");
+    acquire_sem(sem);
+    callOnMainThread([&]{
+        handle->AsyncHandleWrite();
+        release_sem(sem);
+        });
+    acquire_sem(sem);
+    release_sem(sem);       
+}
+
+
+int32 AsyncReadThread(void* data)
+{
+    SocketStreamHandle* handle = (SocketStreamHandle*)data;
+    while(true)
+    {
+        int32 numberReadBytes = (handle->socket)->Read(handle->readBuffer,READ_BUFFER_SIZE);    
+        CallOnMainThreadAndWaitRead(handle,numberReadBytes);        
+    }
     return 0;
 }
 
-long int async_write(void * ptrr)
+
+int32 SocketStreamHandle::AsyncHandleConnect(int32 error)
 {
-    SocketStreamHandle * strm=(SocketStreamHandle *)ptrr;
-    status_t resp=(strm->sock)->WaitForWritable(B_INFINITE_TIMEOUT);
-    std::cout<<resp<<" "<<B_OK<<" "<<B_WOULD_BLOCK<<" "<<B_TIMED_OUT<<std::endl;;
-    if(resp==B_OK)
-        strm->async_sendPendingData();
+    if(error != B_OK)
+    {
+        m_client->didFailSocketStream(this,SocketStreamError(error));
+    }
     else
-        return resp;
+    {
+        fReadThreadId = spawn_thread(AsyncReadThread,"AsyncReadThread",63,(void*)this);
+        resume_thread(fReadThreadId);
+        m_state = Open;
+        m_client->didOpenSocketStream(this);
+    }
+    return error;
+}
+
+
+int32 AsyncWriteThread(void* data)
+{
+    SocketStreamHandle* handle = (SocketStreamHandle*)data;
+    status_t response=(handle->socket)->WaitForWritable(B_INFINITE_TIMEOUT);
+    CallOnMainThreadAndWaitWrite(handle);
+    return response;
+}
+
+
+int32 AsyncConnectThread(void* data)
+{
+    SocketStreamHandle* handle = (SocketStreamHandle*)data;
+    status_t error=(handle->socket)->Connect(*(handle->peer));
+    CallOnMainThreadAndWaitConnect(handle, error);
     return 0;
 }
 
 SocketStreamHandle::SocketStreamHandle(const URL& url, SocketStreamHandleClient* client)
-    : SocketStreamHandleBase(url, client)
+    : 
+    SocketStreamHandleBase(url, client)
 {
     LOG(Network, "SocketStreamHandle %p new client %p", this, m_client);
-    rd_thread=wr_thread=0;
-    unsigned int port = url.hasPort() ? url.port() : (url.protocolIs("wss") ? 443:80);
-    
+    fReadThreadId = 0;
+    fWriteThreadId = 0;
+    fConnectThreadId=0;
+    readBuffer = new char[READ_BUFFER_SIZE];
+    unsigned int port = url.hasPort() ? url.port() : (url.protocolIs("wss") ? 443 : 80);    
     peer = new BNetworkAddress(url.host().utf8().data(),port);
-    sock= new BSocket((*peer));
-    if(sock->IsConnected()==false)
-    {
-        status_t err=sock->Connect((*peer));
-        if(err!=B_OK)
-        {
-            (m_client)->didFailSocketStream(this,SocketStreamError(err));
-            return;
-        }
-    }
-    rd_thread=spawn_thread(async_read,"async_read",63,(void*)this);
-    resume_thread(rd_thread);
-    std::cout<<"New request:"<<url.host().utf8().data()<<":"<<port<<std::endl<<"Sock:"<<sock<<"Read-thread-id:"<<rd_thread<<std::endl;
-    m_state=Open;
-    m_client->didOpenSocketStream(this);
-    
-    //char *array=new char[1025];
-    //int rd_bytes=sock->Read(array,1024);
-    //m_client->didReceiveSocketStreamData(this,array,rd_bytes);
+    socket = new BSocket();
+    fConnectThreadId = spawn_thread(AsyncConnectThread,"AsyncConnectThread",63,(void*)this);
+    resume_thread(fConnectThreadId);
 }
 
+
 SocketStreamHandle::~SocketStreamHandle()
 {
     LOG(Network, "SocketStreamHandle %p delete", this);
+    kill_thread(fReadThreadId);
+    kill_thread(fWriteThreadId);
+    kill_thread(fConnectThreadId);
+    delete readBuffer;
     delete peer;
-    delete sock;
+    delete socket;
     setClient(0);
 }
 
 
-
 int SocketStreamHandle::platformSend(const char* buffer, int length)
 {
-    int written=0,flag=0;
-    std::cout<<"To-Write:"<<buffer<<std::endl;
+    int32 writtenLength = 0;
+    bool flagForPending = false;
     LOG(Network, "SocketStreamHandle %p platformSend", this);
-    if(sock->WaitForWritable(0)==B_OK)
+    status_t response=socket->WaitForWritable(0);
+    if(response == B_OK)
+    {
+        writtenLength=socket->Write(buffer,length);
+        if(writtenLength < length)
+            flagForPending = true;
+    }
+    else if(response == B_TIMED_OUT
+                || response == B_WOULD_BLOCK)
     {
-        written=sock->Write(buffer,length);
-        if(written<length)
-            flag=1;
-        std::cout<<"WRITTEN:"<<written<<std::endl;
+        flagForPending = true;
     }
     else
     {
-        flag=1;
+        m_client->didFailSocketStream(this,SocketStreamError(response));
     }
-    if(flag==1)
+    if(flagForPending)
     {
-        std::cout<<"VOILA"<<std::endl;
-        wr_thread=spawn_thread(async_write,"async_write",63,(void*)this);
-        resume_thread(wr_thread);
+        fWriteThreadId = spawn_thread(AsyncWriteThread,"AsyncWriteThread",63,(void*)this);
+        resume_thread(fWriteThreadId);
     }
-    return written;
+    return writtenLength;
 }
 
+
 void SocketStreamHandle::platformClose()
 {
     LOG(Network, "SocketStreamHandle %p platformClose", this);
-    kill_thread(rd_thread);
-    if(wr_thread!=0)
-        kill_thread(wr_thread);
-    sock->Disconnect();
+    suspend_thread(fReadThreadId);
+    suspend_thread(fWriteThreadId);
+    suspend_thread(fConnectThreadId);
+    socket->Disconnect();
     m_client->didCloseSocketStream(this);
 }
 
+
 void SocketStreamHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge&)
 {
     notImplemented();
 }
 
+
 void SocketStreamHandle::receivedCredential(const AuthenticationChallenge&, const Credential&)
 {
     notImplemented();
 }
 
+
 void SocketStreamHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge&)
 {
     notImplemented();
 }
 
+
 void SocketStreamHandle::receivedCancellation(const AuthenticationChallenge&)
 {
     notImplemented();
 }
 
+
 }  // namespace WebCore