Bug 1203802 - Websocket Frame Listener API for devtool Network Inspector - part 4 - IPC, r=michal

Author: bakulf

ipc/glue/IPCMessageUtils.h

@@ -14,6 +14,7 @@
 #include "mozilla/DebugOnly.h"
 #include "mozilla/dom/ipc/StructuredCloneData.h"
 #include "mozilla/Maybe.h"
+#include "mozilla/net/WebSocketFrame.h"
 #include "mozilla/TimeStamp.h"
 #ifdef XP_WIN
 #include "mozilla/TimeStamp_windows.h"
@@ -718,6 +719,22 @@ struct ParamTraits<mozilla::dom::ipc::StructuredCloneData>
   }
 };
 
+template <>
+struct ParamTraits<mozilla::net::WebSocketFrameData>
+{
+  typedef mozilla::net::WebSocketFrameData paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam)
+  {
+    aParam.WriteIPCParams(aMsg);
+  }
+
+  static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
+  {
+    return aResult->ReadIPCParams(aMsg, aIter);
+  }
+};
+
 template <>
 struct ParamTraits<mozilla::SerializedStructuredCloneBuffer>
 {

netwerk/ipc/NeckoChild.cpp

@@ -15,6 +15,7 @@
 #include "mozilla/net/WyciwygChannelChild.h"
 #include "mozilla/net/FTPChannelChild.h"
 #include "mozilla/net/WebSocketChannelChild.h"
+#include "mozilla/net/WebSocketFrameListenerChild.h"
 #include "mozilla/net/DNSRequestChild.h"
 #include "mozilla/net/RemoteOpenFileChild.h"
 #include "mozilla/net/ChannelDiverterChild.h"
@@ -158,6 +159,23 @@ NeckoChild::DeallocPWebSocketChild(PWebSocketChild* child)
   return true;
 }
 
+PWebSocketFrameListenerChild*
+NeckoChild::AllocPWebSocketFrameListenerChild(const uint64_t& aInnerWindowID)
+{
+  RefPtr<WebSocketFrameListenerChild> c =
+    new WebSocketFrameListenerChild(aInnerWindowID);
+  return c.forget().take();
+}
+
+bool
+NeckoChild::DeallocPWebSocketFrameListenerChild(PWebSocketFrameListenerChild* aActor)
+{
+  RefPtr<WebSocketFrameListenerChild> c =
+    dont_AddRef(static_cast<WebSocketFrameListenerChild*>(aActor));
+  MOZ_ASSERT(c);
+  return true;
+}
+
 PDataChannelChild*
 NeckoChild::AllocPDataChannelChild(const uint32_t& channelId)
 {

netwerk/ipc/NeckoChild.h

@@ -79,6 +79,9 @@ class NeckoChild :
                                                  const nsString& aRealm,
                                                  const uint64_t& aCallbackId) override;
   virtual bool RecvAppOfflineStatus(const uint32_t& aId, const bool& aOffline) override;
+  virtual PWebSocketFrameListenerChild*
+    AllocPWebSocketFrameListenerChild(const uint64_t& aInnerWindowID) override;
+  virtual bool DeallocPWebSocketFrameListenerChild(PWebSocketFrameListenerChild*) override;
 
   /* Predictor Messsages */
   virtual bool RecvPredOnPredictPreconnect(const URIParams& aURI) override;

netwerk/ipc/NeckoParent.cpp

@@ -13,6 +13,7 @@
 #include "mozilla/net/WyciwygChannelParent.h"
 #include "mozilla/net/FTPChannelParent.h"
 #include "mozilla/net/WebSocketChannelParent.h"
+#include "mozilla/net/WebSocketFrameListenerParent.h"
 #include "mozilla/net/DataChannelParent.h"
 #ifdef NECKO_PROTOCOL_rtsp
 #include "mozilla/net/RtspControllerParent.h"
@@ -347,6 +348,23 @@ NeckoParent::DeallocPWebSocketParent(PWebSocketParent* actor)
   return true;
 }
 
+PWebSocketFrameListenerParent*
+NeckoParent::AllocPWebSocketFrameListenerParent(const uint64_t& aInnerWindowID)
+{
+  RefPtr<WebSocketFrameListenerParent> c =
+    new WebSocketFrameListenerParent(aInnerWindowID);
+  return c.forget().take();
+}
+
+bool
+NeckoParent::DeallocPWebSocketFrameListenerParent(PWebSocketFrameListenerParent* aActor)
+{
+  RefPtr<WebSocketFrameListenerParent> c =
+    dont_AddRef(static_cast<WebSocketFrameListenerParent*>(aActor));
+  MOZ_ASSERT(c);
+  return true;
+}
+
 PDataChannelParent*
 NeckoParent::AllocPDataChannelParent(const uint32_t &channelId)
 {

netwerk/ipc/NeckoParent.h

@@ -172,6 +172,9 @@ class NeckoParent
   virtual bool RecvCancelHTMLDNSPrefetch(const nsString& hostname,
                                          const uint16_t& flags,
                                          const nsresult& reason) override;
+  virtual PWebSocketFrameListenerParent*
+    AllocPWebSocketFrameListenerParent(const uint64_t& aInnerWindowID) override;
+  virtual bool DeallocPWebSocketFrameListenerParent(PWebSocketFrameListenerParent*) override;
 
   virtual mozilla::ipc::IProtocol*
   CloneProtocol(Channel* aChannel,

netwerk/ipc/PNecko.ipdl

@@ -12,6 +12,7 @@ include protocol PBrowser;
 include protocol PWyciwygChannel;
 include protocol PFTPChannel;
 include protocol PWebSocket;
+include protocol PWebSocketFrameListener;
 include protocol PTCPSocket;
 include protocol PTCPServerSocket;
 include protocol PUDPSocket;
@@ -45,6 +46,7 @@ prio(normal upto urgent) sync protocol PNecko
   manages PWyciwygChannel;
   manages PFTPChannel;
   manages PWebSocket;
+  manages PWebSocketFrameListener;
   manages PTCPSocket;
   manages PTCPServerSocket;
   manages PUDPSocket;
@@ -72,6 +74,7 @@ parent:
 
   PDNSRequest(nsCString hostName, uint32_t flags, nsCString networkInterface);
 
+  PWebSocketFrameListener(uint64_t aInnerWindowID);
 
   /* Predictor Methods */
   PredPredict(OptionalURIParams targetURI, OptionalURIParams sourceURI,

netwerk/protocol/websocket/PWebSocketFrameListener.ipdl

@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+
+/* 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/. */
+
+include protocol PNecko;
+
+using mozilla::net::WebSocketFrameData from "ipc/IPCMessageUtils.h";
+
+namespace mozilla {
+namespace net {
+
+async protocol PWebSocketFrameListener
+{
+  manager PNecko;
+
+child:
+  FrameReceived(uint32_t aWebSocketSerialID,
+                WebSocketFrameData aFrameData);
+
+  FrameSent(uint32_t aWebSocketSerialID,
+            WebSocketFrameData aFrameData);
+
+  __delete__();
+
+parent:
+  Close();
+};
+
+} //namespace net
+} //namespace mozilla

netwerk/protocol/websocket/WebSocketFrame.cpp

@@ -21,20 +21,18 @@ NS_INTERFACE_MAP_END
 NS_IMPL_ADDREF(WebSocketFrame)
 NS_IMPL_RELEASE(WebSocketFrame)
 
+WebSocketFrame::WebSocketFrame(const WebSocketFrameData& aData)
+  : mData(aData)
+{}
+
 WebSocketFrame::WebSocketFrame(bool aFinBit, bool aRsvBit1, bool aRsvBit2,
                                bool aRsvBit3, uint8_t aOpCode, bool aMaskBit,
                                uint32_t aMask, const nsCString& aPayload)
-  : mFinBit(aFinBit)
-  , mRsvBit1(aRsvBit1)
-  , mRsvBit2(aRsvBit2)
-  , mRsvBit3(aRsvBit3)
-  , mMaskBit(aMaskBit)
-  , mOpCode(aOpCode)
-  , mMask(aMask)
-  , mPayload(aPayload)
+  : mData(PR_Now(), aFinBit, aRsvBit1, aRsvBit2, aRsvBit3, aOpCode, aMaskBit,
+          aMask, aPayload)
 {
   MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
-  mTimeStamp = PR_Now();
+  mData.mTimeStamp = PR_Now();
 }
 
 WebSocketFrame::~WebSocketFrame()
@@ -52,24 +50,119 @@ WebSocketFrame::method(type* aValue)           \
   return NS_OK;                                \
 }
 
-WSF_GETTER(GetTimeStamp, mTimeStamp, DOMHighResTimeStamp);
-WSF_GETTER(GetFinBit, mFinBit, bool);
-WSF_GETTER(GetRsvBit1, mRsvBit1, bool);
-WSF_GETTER(GetRsvBit2, mRsvBit2, bool);
-WSF_GETTER(GetRsvBit3, mRsvBit3, bool);
-WSF_GETTER(GetOpCode, mOpCode, uint16_t);
-WSF_GETTER(GetMaskBit, mMaskBit, bool);
-WSF_GETTER(GetMask, mMask, uint32_t);
+WSF_GETTER(GetTimeStamp, mData.mTimeStamp, DOMHighResTimeStamp);
+WSF_GETTER(GetFinBit, mData.mFinBit, bool);
+WSF_GETTER(GetRsvBit1, mData.mRsvBit1, bool);
+WSF_GETTER(GetRsvBit2, mData.mRsvBit2, bool);
+WSF_GETTER(GetRsvBit3, mData.mRsvBit3, bool);
+WSF_GETTER(GetOpCode, mData.mOpCode, uint16_t);
+WSF_GETTER(GetMaskBit, mData.mMaskBit, bool);
+WSF_GETTER(GetMask, mData.mMask, uint32_t);
 
 #undef WSF_GETTER
 
 NS_IMETHODIMP
 WebSocketFrame::GetPayload(nsACString& aValue)
 {
   MOZ_ASSERT(NS_IsMainThread());
-  aValue = mPayload;
+  aValue = mData.mPayload;
   return NS_OK;
 }
 
+WebSocketFrameData::WebSocketFrameData()
+  : mTimeStamp(0)
+  , mFinBit(false)
+  , mRsvBit1(false)
+  , mRsvBit2(false)
+  , mRsvBit3(false)
+  , mMaskBit(false)
+  , mOpCode(0)
+  , mMask(0)
+{
+  MOZ_COUNT_CTOR(WebSocketFrameData);
+}
+
+WebSocketFrameData::WebSocketFrameData(DOMHighResTimeStamp aTimeStamp,
+                                       bool aFinBit, bool aRsvBit1,
+                                       bool aRsvBit2, bool aRsvBit3,
+                                       uint8_t aOpCode, bool aMaskBit,
+                                       uint32_t aMask,
+                                       const nsCString& aPayload)
+  : mTimeStamp(aTimeStamp)
+  , mFinBit(aFinBit)
+  , mRsvBit1(aRsvBit1)
+  , mRsvBit2(aRsvBit2)
+  , mRsvBit3(aRsvBit3)
+  , mMaskBit(aMaskBit)
+  , mOpCode(aOpCode)
+  , mMask(aMask)
+  , mPayload(aPayload)
+{
+  MOZ_COUNT_CTOR(WebSocketFrameData);
+}
+
+WebSocketFrameData::WebSocketFrameData(const WebSocketFrameData& aData)
+  : mTimeStamp(aData.mTimeStamp)
+  , mFinBit(aData.mFinBit)
+  , mRsvBit1(aData.mRsvBit1)
+  , mRsvBit2(aData.mRsvBit2)
+  , mRsvBit3(aData.mRsvBit3)
+  , mMaskBit(aData.mMaskBit)
+  , mOpCode(aData.mOpCode)
+  , mMask(aData.mMask)
+  , mPayload(aData.mPayload)
+{
+  MOZ_COUNT_CTOR(WebSocketFrameData);
+}
+
+WebSocketFrameData::~WebSocketFrameData()
+{
+  MOZ_COUNT_DTOR(WebSocketFrameData);
+}
+
+void
+WebSocketFrameData::WriteIPCParams(IPC::Message* aMessage) const
+{
+  WriteParam(aMessage, mTimeStamp);
+  WriteParam(aMessage, mFinBit);
+  WriteParam(aMessage, mRsvBit1);
+  WriteParam(aMessage, mRsvBit2);
+  WriteParam(aMessage, mRsvBit3);
+  WriteParam(aMessage, mOpCode);
+  WriteParam(aMessage, mMaskBit);
+  WriteParam(aMessage, mMask);
+  WriteParam(aMessage, mPayload);
+}
+
+bool
+WebSocketFrameData::ReadIPCParams(const IPC::Message* aMessage,
+                                  void** aIter)
+{
+  if (!ReadParam(aMessage, aIter, &mTimeStamp)) {
+    return false;
+  }
+
+#define ReadParamHelper(x)                     \
+  {                                            \
+    bool bit;                                  \
+    if (!ReadParam(aMessage, aIter, &bit)) {   \
+      return false;                            \
+    }                                          \
+    x = bit;                                   \
+  }
+
+  ReadParamHelper(mFinBit);
+  ReadParamHelper(mRsvBit1);
+  ReadParamHelper(mRsvBit2);
+  ReadParamHelper(mRsvBit3);
+  ReadParamHelper(mMaskBit);
+
+#undef ReadParamHelper
+
+  return ReadParam(aMessage, aIter, &mOpCode) &&
+         ReadParam(aMessage, aIter, &mMask) &&
+         ReadParam(aMessage, aIter, &mPayload);
+}
+
 } // net namespace
 } // mozilla namespace