code.vuplus.com Git - vuplus_webkit/blob - Source/WebKit/chromium/src/SocketStreamHandle.cpp

   1 /*
   2  * Copyright (C) 2009 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "SocketStreamHandle.h"
  33
  34 #if ENABLE(WEB_SOCKETS)
  35
  36 #include "Logging.h"
  37 #include "NotImplemented.h"
  38 #include "SocketStreamHandleClient.h"
  39 #include "WebData.h"
  40 #include "WebKit.h"
  41 #include "WebKitPlatformSupport.h"
  42 #include "WebSocketStreamHandle.h"
  43 #include "WebSocketStreamHandleClient.h"
  44 #include "WebURL.h"
  45 #include <wtf/PassOwnPtr.h>
  46
  47 using namespace WebKit;
  48
  49 namespace WebCore {
  50
  51 class SocketStreamHandleInternal : public WebSocketStreamHandleClient {
  52 public:
  53     static PassOwnPtr<SocketStreamHandleInternal> create(SocketStreamHandle* handle)
  54     {
  55         return adoptPtr(new SocketStreamHandleInternal(handle));
  56     }
  57     virtual ~SocketStreamHandleInternal();
  58
  59     void connect(const KURL&);
  60     int send(const char*, int);
  61     void close();
  62
  63     virtual void didOpenStream(WebSocketStreamHandle*, int);
  64     virtual void didSendData(WebSocketStreamHandle*, int);
  65     virtual void didReceiveData(WebSocketStreamHandle*, const WebData&);
  66     virtual void didClose(WebSocketStreamHandle*);
  67     virtual void didFail(WebSocketStreamHandle*, const WebSocketStreamError&);
  68
  69 private:
  70     explicit SocketStreamHandleInternal(SocketStreamHandle*);
  71
  72     SocketStreamHandle* m_handle;
  73     OwnPtr<WebSocketStreamHandle> m_socket;
  74     int m_maxPendingSendAllowed;
  75     int m_pendingAmountSent;
  76 };
  77
  78 SocketStreamHandleInternal::SocketStreamHandleInternal(SocketStreamHandle* handle)
  79     : m_handle(handle)
  80     , m_maxPendingSendAllowed(0)
  81     , m_pendingAmountSent(0)
  82 {
  83 }
  84
  85 SocketStreamHandleInternal::~SocketStreamHandleInternal()
  86 {
  87     m_handle = 0;
  88 }
  89
  90 void SocketStreamHandleInternal::connect(const KURL& url)
  91 {
  92     m_socket = adoptPtr(webKitPlatformSupport()->createSocketStreamHandle());
  93     LOG(Network, "connect");
  94     ASSERT(m_socket.get());
  95     m_socket->connect(url, this);
  96 }
  97
  98 int SocketStreamHandleInternal::send(const char* data, int len)
  99 {
 100     LOG(Network, "send len=%d", len);
 101     ASSERT(m_socket.get());
 102     if (m_pendingAmountSent + len >= m_maxPendingSendAllowed)
 103         len = m_maxPendingSendAllowed - m_pendingAmountSent - 1;
 104
 105     if (len <= 0)
 106         return len;
 107     WebData webdata(data, len);
 108     if (m_socket->send(webdata)) {
 109         m_pendingAmountSent += len;
 110         LOG(Network, "sent");
 111         return len;
 112     }
 113     LOG(Network, "busy. buffering");
 114     return 0;
 115 }
 116
 117 void SocketStreamHandleInternal::close()
 118 {
 119     LOG(Network, "close");
 120     m_socket->close();
 121 }
 122
 123 void SocketStreamHandleInternal::didOpenStream(WebSocketStreamHandle* socketHandle, int maxPendingSendAllowed)
 124 {
 125     LOG(Network, "SocketStreamHandleInternal::didOpen %d",
 126         maxPendingSendAllowed);
 127     ASSERT(maxPendingSendAllowed > 0);
 128     if (m_handle && m_socket.get()) {
 129         ASSERT(socketHandle == m_socket.get());
 130         m_maxPendingSendAllowed = maxPendingSendAllowed;
 131         m_handle->m_state = SocketStreamHandleBase::Open;
 132         if (m_handle->m_client) {
 133             m_handle->m_client->didOpenSocketStream(m_handle);
 134             return;
 135         }
 136     }
 137     LOG(Network, "no m_handle or m_socket?");
 138 }
 139
 140 void SocketStreamHandleInternal::didSendData(WebSocketStreamHandle* socketHandle, int amountSent)
 141 {
 142     LOG(Network, "SocketStreamHandleInternal::didSendData %d", amountSent);
 143     ASSERT(amountSent > 0);
 144     if (m_handle && m_socket.get()) {
 145         ASSERT(socketHandle == m_socket.get());
 146         m_pendingAmountSent -= amountSent;
 147         ASSERT(m_pendingAmountSent >= 0);
 148         m_handle->sendPendingData();
 149     }
 150 }
 151
 152 void SocketStreamHandleInternal::didReceiveData(WebSocketStreamHandle* socketHandle, const WebData& data)
 153 {
 154     LOG(Network, "didReceiveData");
 155     if (m_handle && m_socket.get()) {
 156         ASSERT(socketHandle == m_socket.get());
 157         if (m_handle->m_client)
 158             m_handle->m_client->didReceiveSocketStreamData(m_handle, data.data(), data.size());
 159     }
 160 }
 161
 162 void SocketStreamHandleInternal::didClose(WebSocketStreamHandle* socketHandle)
 163 {
 164     LOG(Network, "didClose");
 165     if (m_handle && m_socket.get()) {
 166         ASSERT(socketHandle == m_socket.get());
 167         m_socket.clear();
 168         SocketStreamHandle* h = m_handle;
 169         m_handle = 0;
 170         if (h->m_client)
 171             h->m_client->didCloseSocketStream(h);
 172     }
 173 }
 174
 175 void SocketStreamHandleInternal::didFail(WebSocketStreamHandle* socketHandle, const WebSocketStreamError& err)
 176 {
 177     LOG(Network, "didFail");
 178     if (m_handle && m_socket.get()) {
 179         ASSERT(socketHandle == m_socket.get());
 180         m_socket.clear();
 181         SocketStreamHandle* h = m_handle;
 182         m_handle = 0;
 183         if (h->m_client)
 184             h->m_client->didCloseSocketStream(h); // didFail(h, err);
 185     }
 186 }
 187
 188 // FIXME: auth
 189
 190 // SocketStreamHandle ----------------------------------------------------------
 191
 192 SocketStreamHandle::SocketStreamHandle(const KURL& url, SocketStreamHandleClient* client)
 193     : SocketStreamHandleBase(url, client)
 194 {
 195     m_internal = SocketStreamHandleInternal::create(this);
 196     m_internal->connect(m_url);
 197 }
 198
 199 SocketStreamHandle::~SocketStreamHandle()
 200 {
 201     setClient(0);
 202     m_internal.clear();
 203 }
 204
 205 int SocketStreamHandle::platformSend(const char* buf, int len)
 206 {
 207     if (!m_internal.get())
 208         return 0;
 209     return m_internal->send(buf, len);
 210 }
 211
 212 void SocketStreamHandle::platformClose()
 213 {
 214     if (m_internal.get())
 215         m_internal->close();
 216 }
 217
 218 void SocketStreamHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge& challenge)
 219 {
 220     if (m_client)
 221         m_client->didReceiveAuthenticationChallenge(this, challenge);
 222 }
 223
 224 void SocketStreamHandle::receivedCredential(const AuthenticationChallenge& challenge, const Credential& credential)
 225 {
 226     notImplemented();
 227 }
 228
 229 void SocketStreamHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge& challenge)
 230 {
 231     notImplemented();
 232 }
 233
 234 }  // namespace WebCore
 235
 236 #endif  // ENABLE(WEB_SOCKETS)