dom/websocket/WebSocket.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef WebSocket_h__
   8 #define WebSocket_h__
   9
  10 #include "mozilla/Attributes.h"
  11 #include "mozilla/CheckedInt.h"
  12 #include "mozilla/dom/TypedArray.h"
  13 #include "mozilla/dom/WebSocketBinding.h"  // for BinaryType
  14 #include "mozilla/DOMEventTargetHelper.h"
  15 #include "mozilla/Mutex.h"
  16 #include "nsCOMPtr.h"
  17 #include "nsCycleCollectionParticipant.h"
  18 #include "nsISupports.h"
  19 #include "nsISupportsUtils.h"
  20 #include "nsString.h"
  21 #include "nsWrapperCache.h"
  22
  23 #define DEFAULT_WS_SCHEME_PORT 80
  24 #define DEFAULT_WSS_SCHEME_PORT 443
  25
  26 class nsIInputStream;
  27 class nsITransportProvider;
  28
  29 namespace mozilla {
  30 class ErrorResult;
  31
  32 namespace dom {
  33
  34 class Blob;
  35 class StringOrStringSequence;
  36 class WebSocketImpl;
  37
  38 class WebSocket final : public DOMEventTargetHelper {
  39   friend class WebSocketImpl;
  40
  41  public:
  42   enum { CONNECTING = 0, OPEN = 1, CLOSING = 2, CLOSED = 3 };
  43
  44  public:
  45   NS_DECL_ISUPPORTS_INHERITED
  46   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(WebSocket, DOMEventTargetHelper)
  47   virtual bool IsCertainlyAliveForCC() const override;
  48
  49   // EventTarget
  50   using EventTarget::EventListenerAdded;
  51   virtual void EventListenerAdded(nsAtom* aType) override;
  52
  53   using EventTarget::EventListenerRemoved;
  54   virtual void EventListenerRemoved(nsAtom* aType) override;
  55
  56   virtual void DisconnectFromOwner() override;
  57
  58   mozilla::Maybe<EventCallbackDebuggerNotificationType>
  59   GetDebuggerNotificationType() const override;
  60
  61   // nsWrapperCache
  62   virtual JSObject* WrapObject(JSContext* cx,
  63                                JS::Handle<JSObject*> aGivenProto) override;
  64
  65  public:  // static helpers:
  66   // Determine if preferences allow WebSocket
  67   static bool PrefEnabled(JSContext* aCx = nullptr,
  68                           JSObject* aGlobal = nullptr);
  69
  70  public:  // WebIDL interface:
  71   // Constructor:
  72   static already_AddRefed<WebSocket> Constructor(
  73       const GlobalObject& aGlobal, const nsAString& aUrl,
  74       const StringOrStringSequence& aProtocols, ErrorResult& rv);
  75
  76   static already_AddRefed<WebSocket> CreateServerWebSocket(
  77       const GlobalObject& aGlobal, const nsAString& aUrl,
  78       const Sequence<nsString>& aProtocols,
  79       nsITransportProvider* aTransportProvider,
  80       const nsAString& aNegotiatedExtensions, ErrorResult& rv);
  81
  82   static already_AddRefed<WebSocket> ConstructorCommon(
  83       const GlobalObject& aGlobal, const nsAString& aUrl,
  84       const Sequence<nsString>& aProtocols,
  85       nsITransportProvider* aTransportProvider,
  86       const nsACString& aNegotiatedExtensions, ErrorResult& rv);
  87
  88   // webIDL: readonly attribute DOMString url
  89   void GetUrl(nsAString& aResult);
  90
  91   // webIDL: readonly attribute unsigned short readyState;
  92   uint16_t ReadyState();
  93
  94   // webIDL: readonly attribute unsigned long long bufferedAmount;
  95   uint64_t BufferedAmount() const;
  96
  97   // webIDL: attribute Function? onopen;
  98   IMPL_EVENT_HANDLER(open)
  99
 100   // webIDL: attribute Function? onerror;
 101   IMPL_EVENT_HANDLER(error)
 102
 103   // webIDL: attribute Function? onclose;
 104   IMPL_EVENT_HANDLER(close)
 105
 106   // webIDL: readonly attribute DOMString extensions;
 107   void GetExtensions(nsAString& aResult);
 108
 109   // webIDL: readonly attribute DOMString protocol;
 110   void GetProtocol(nsAString& aResult);
 111
 112   // webIDL: void close(optional unsigned short code,
 113   //                    optional DOMString reason):
 114   void Close(const Optional<uint16_t>& aCode,
 115              const Optional<nsAString>& aReason, ErrorResult& aRv);
 116
 117   // webIDL: attribute Function? onmessage;
 118   IMPL_EVENT_HANDLER(message)
 119
 120   // webIDL: attribute DOMString binaryType;
 121   dom::BinaryType BinaryType() const;
 122   void SetBinaryType(dom::BinaryType aData);
 123
 124   // webIDL: void send(DOMString|Blob|ArrayBufferView data);
 125   void Send(const nsAString& aData, ErrorResult& aRv);
 126   void Send(Blob& aData, ErrorResult& aRv);
 127   void Send(const ArrayBuffer& aData, ErrorResult& aRv);
 128   void Send(const ArrayBufferView& aData, ErrorResult& aRv);
 129
 130  private:  // constructor && destructor
 131   explicit WebSocket(nsIGlobalObject* aGlobal);
 132   virtual ~WebSocket();
 133
 134   void SetReadyState(uint16_t aReadyState);
 135
 136   // These methods actually do the dispatch for various events.
 137   nsresult CreateAndDispatchSimpleEvent(const nsAString& aName);
 138   nsresult CreateAndDispatchMessageEvent(const nsACString& aData,
 139                                          bool aIsBinary);
 140   nsresult CreateAndDispatchCloseEvent(bool aWasClean, uint16_t aCode,
 141                                        const nsAString& aReason);
 142
 143   static bool IsValidProtocolString(const nsString& aValue);
 144
 145   // if there are "strong event listeners" (see comment in WebSocket.cpp) or
 146   // outgoing not sent messages then this method keeps the object alive
 147   // when js doesn't have strong references to it.
 148   void UpdateMustKeepAlive();
 149   // ATTENTION, when calling this method the object can be released
 150   // (and possibly collected).
 151   void DontKeepAliveAnyMore();
 152
 153  private:
 154   WebSocket(const WebSocket& x) = delete;  // prevent bad usage
 155   WebSocket& operator=(const WebSocket& x) = delete;
 156
 157   void Send(nsIInputStream* aMsgStream, const nsACString& aMsgString,
 158             uint32_t aMsgLength, bool aIsBinary, ErrorResult& aRv);
 159
 160   void AssertIsOnTargetThread() const;
 161
 162   // Raw pointer because this WebSocketImpl is created, managed and destroyed by
 163   // WebSocket.
 164   WebSocketImpl* mImpl;
 165
 166   bool mIsMainThread;
 167
 168   bool mKeepingAlive;
 169   bool mCheckMustKeepAlive;
 170
 171   CheckedUint64 mOutgoingBufferedAmount;
 172
 173   // related to the WebSocket constructor steps
 174   nsString mURI;
 175   nsString mEffectiveURL;  // after redirects
 176   nsCString mEstablishedExtensions;
 177   nsCString mEstablishedProtocol;
 178
 179   dom::BinaryType mBinaryType;
 180
 181   // This mutex protects mReadyState that is the only variable that is used in
 182   // different threads.
 183   mozilla::Mutex mMutex;
 184
 185   // This value should not be used directly but use ReadyState() instead.
 186   uint16_t mReadyState MOZ_GUARDED_BY(mMutex);
 187 };
 188
 189 }  // namespace dom
 190 }  // namespace mozilla
 191
 192 #endif