Bug 1099296 - Attach LoadInfo to remaining callers of ioService and ProtocolHandlers - websocket changes (r=jduell)

Author: Christoph Kerschbaumer

docshell/base/LoadInfo.h

@@ -20,6 +20,7 @@ namespace mozilla {
 namespace net {
 class HttpChannelParent;
 class FTPChannelParent;
+class WebSocketChannelParent;
 }
 
 /**
@@ -51,6 +52,7 @@ class MOZ_EXPORT LoadInfo MOZ_FINAL : public nsILoadInfo
 
   friend class net::HttpChannelParent;
   friend class net::FTPChannelParent;
+  friend class net::WebSocketChannelParent;
 
   ~LoadInfo();
 

dom/base/WebSocket.cpp

@@ -1574,15 +1574,11 @@ WebSocketImpl::InitializeConnection()
   // are not thread-safe.
   mOriginDocument = nullptr;
 
-  nsCOMPtr<nsILoadInfo> loadInfo =
-    new LoadInfo(doc ?
-                   doc->NodePrincipal() : mPrincipal.get(),
-                 mPrincipal,
-                 doc,
-                 nsILoadInfo::SEC_NORMAL,
-                 nsIContentPolicy::TYPE_WEBSOCKET);
-  rv = wsChannel->SetLoadInfo(loadInfo);
-  NS_ENSURE_SUCCESS(rv, rv);
+  wsChannel->InitLoadInfo(doc ? doc->AsDOMNode() : nullptr,
+                          doc ? doc->NodePrincipal() : mPrincipal.get(),
+                          mPrincipal,
+                          nsILoadInfo::SEC_NORMAL,
+                          nsIContentPolicy::TYPE_WEBSOCKET);
 
   if (!mRequestedProtocolList.IsEmpty()) {
     rv = wsChannel->SetProtocol(mRequestedProtocolList);

netwerk/ipc/NeckoChannelParams.ipdlh

@@ -121,5 +121,18 @@ struct RtspChannelConnectArgs
   uint32_t channelId;
 };
 
+//-----------------------------------------------------------------------------
+// WS IPDL structs
+//-----------------------------------------------------------------------------
+
+struct WebSocketLoadInfoArgs
+{
+  PrincipalInfo requestingPrincipalInfo;
+  PrincipalInfo triggeringPrincipalInfo;
+  uint32_t      securityFlags;
+  uint32_t      contentPolicyType;
+  uint32_t      innerWindowID;
+};
+
 } // namespace ipc
 } // namespace mozilla

netwerk/protocol/websocket/BaseWebSocketChannel.cpp

@@ -182,6 +182,19 @@ BaseWebSocketChannel::SetPingTimeout(uint32_t aSeconds)
   return NS_OK;
 }
 
+NS_IMETHODIMP
+BaseWebSocketChannel::InitLoadInfo(nsIDOMNode* aLoadingNode,
+                                   nsIPrincipal* aLoadingPrincipal,
+                                   nsIPrincipal* aTriggeringPrincipal,
+                                   uint32_t aSecurityFlags,
+                                   uint32_t aContentPolicyType)
+{
+  nsCOMPtr<nsINode> node = do_QueryInterface(aLoadingNode);
+  mLoadInfo = new LoadInfo(aLoadingPrincipal, aTriggeringPrincipal,
+                           node, aSecurityFlags, aContentPolicyType);
+  return NS_OK;
+}
+
 //-----------------------------------------------------------------------------
 // BaseWebSocketChannel::nsIProtocolHandler
 //-----------------------------------------------------------------------------

netwerk/protocol/websocket/BaseWebSocketChannel.h

@@ -52,6 +52,9 @@ class BaseWebSocketChannel : public nsIWebSocketChannel,
   NS_IMETHOD SetPingInterval(uint32_t aSeconds) MOZ_OVERRIDE;
   NS_IMETHOD GetPingTimeout(uint32_t *aSeconds) MOZ_OVERRIDE;
   NS_IMETHOD SetPingTimeout(uint32_t aSeconds) MOZ_OVERRIDE;
+  NS_IMETHOD InitLoadInfo(nsIDOMNode* aLoadingNode, nsIPrincipal* aLoadingPrincipal,
+                          nsIPrincipal* aTriggeringPrincipal, uint32_t aSecurityFlags,
+                          uint32_t aContentPolicyType) MOZ_OVERRIDE;
 
   // Off main thread URI access.
   virtual void GetEffectiveURL(nsAString& aEffectiveURL) const = 0;

netwerk/protocol/websocket/PWebSocket.ipdl

@@ -9,6 +9,7 @@ include protocol PNecko;
 include protocol PBrowser;
 include InputStreamParams;
 include URIParams;
+include NeckoChannelParams;
 
 include protocol PBlob; //FIXME: bug #792908
 
@@ -31,7 +32,8 @@ parent:
             uint32_t aPingInterval,
             bool aClientSetPingInterval,
             uint32_t aPingTimeout,
-            bool aClientSetPingTimeout);
+            bool aClientSetPingTimeout,
+            WebSocketLoadInfoArgs aLoadInfoArgs);
   Close(uint16_t code, nsCString reason);
   SendMsg(nsCString aMsg);
   SendBinaryMsg(nsCString aMsg);

netwerk/protocol/websocket/WebSocketChannelChild.cpp

@@ -13,6 +13,7 @@
 #include "nsNetUtil.h"
 #include "mozilla/ipc/InputStreamUtils.h"
 #include "mozilla/ipc/URIUtils.h"
+#include "mozilla/ipc/BackgroundUtils.h"
 #include "mozilla/net/ChannelEventQueue.h"
 #include "SerializedLoadContext.h"
 
@@ -452,6 +453,25 @@ WebSocketChannelChild::OnServerClose(const uint16_t& aCode,
   }
 }
 
+// helper function to assign loadInfo to wsArgs
+void
+propagateLoadInfo(nsILoadInfo *aLoadInfo,
+                  WebSocketLoadInfoArgs& wsArgs)
+{
+  mozilla::ipc::PrincipalInfo requestingPrincipalInfo;
+  mozilla::ipc::PrincipalInfo triggeringPrincipalInfo;
+
+  mozilla::ipc::PrincipalToPrincipalInfo(aLoadInfo->LoadingPrincipal(),
+                                         &requestingPrincipalInfo);
+  wsArgs.requestingPrincipalInfo() = requestingPrincipalInfo;
+  mozilla::ipc::PrincipalToPrincipalInfo(aLoadInfo->TriggeringPrincipal(),
+                                         &triggeringPrincipalInfo);
+  wsArgs.triggeringPrincipalInfo() = triggeringPrincipalInfo;
+  wsArgs.securityFlags() = aLoadInfo->GetSecurityFlags();
+  wsArgs.contentPolicyType() = aLoadInfo->GetContentPolicyType();
+  wsArgs.innerWindowID() = aLoadInfo->GetInnerWindowID();
+}
+
 NS_IMETHODIMP
 WebSocketChannelChild::AsyncOpen(nsIURI *aURI,
                                  const nsACString &aOrigin,
@@ -482,12 +502,16 @@ WebSocketChannelChild::AsyncOpen(nsIURI *aURI,
   // Corresponding release in DeallocPWebSocket
   AddIPDLReference();
 
+  WebSocketLoadInfoArgs wsArgs;
+  propagateLoadInfo(mLoadInfo, wsArgs);
+
   gNeckoChild->SendPWebSocketConstructor(this, tabChild,
                                          IPC::SerializedLoadContext(this));
   if (!SendAsyncOpen(uri, nsCString(aOrigin), mProtocol, mEncrypted,
                      mPingInterval, mClientSetPingInterval,
-                     mPingResponseTimeout, mClientSetPingTimeout))
+                     mPingResponseTimeout, mClientSetPingTimeout, wsArgs)) {
     return NS_ERROR_UNEXPECTED;
+  }
 
   mOriginalURI = aURI;
   mURI = mOriginalURI;

netwerk/protocol/websocket/WebSocketChannelParent.cpp

@@ -9,6 +9,7 @@
 #include "nsIAuthPromptProvider.h"
 #include "mozilla/ipc/InputStreamUtils.h"
 #include "mozilla/ipc/URIUtils.h"
+#include "mozilla/ipc/BackgroundUtils.h"
 #include "SerializedLoadContext.h"
 #include "nsIOService.h"
 #include "mozilla/net/NeckoCommon.h"
@@ -66,13 +67,15 @@ WebSocketChannelParent::RecvAsyncOpen(const URIParams& aURI,
                                       const uint32_t& aPingInterval,
                                       const bool& aClientSetPingInterval,
                                       const uint32_t& aPingTimeout,
-                                      const bool& aClientSetPingTimeout)
+                                      const bool& aClientSetPingTimeout,
+                                      const WebSocketLoadInfoArgs& aLoadInfoArgs)
 {
   LOG(("WebSocketChannelParent::RecvAsyncOpen() %p\n", this));
 
   nsresult rv;
   nsCOMPtr<nsIURI> uri;
-
+  nsCOMPtr<nsIPrincipal> requestingPrincipal, triggeringPrincipal;
+  nsCOMPtr<nsILoadInfo> loadInfo;
 
   bool appOffline = false;
   uint32_t appId = GetAppId();
@@ -94,6 +97,28 @@ WebSocketChannelParent::RecvAsyncOpen(const URIParams& aURI,
   if (NS_FAILED(rv))
     goto fail;
 
+  requestingPrincipal =
+    mozilla::ipc::PrincipalInfoToPrincipal(aLoadInfoArgs.requestingPrincipalInfo(), &rv);
+  if (NS_FAILED(rv)) {
+    goto fail;
+  }
+
+  triggeringPrincipal =
+    mozilla::ipc::PrincipalInfoToPrincipal(aLoadInfoArgs.triggeringPrincipalInfo(), &rv);
+  if (NS_FAILED(rv)) {
+    goto fail;
+  }
+
+  loadInfo = new LoadInfo(requestingPrincipal,
+                          triggeringPrincipal,
+                          aLoadInfoArgs.securityFlags(),
+                          aLoadInfoArgs.contentPolicyType(),
+                          aLoadInfoArgs.innerWindowID());
+  rv = mChannel->SetLoadInfo(loadInfo);
+  if (NS_FAILED(rv)) {
+    goto fail;
+  }
+
   rv = mChannel->SetNotificationCallbacks(this);
   if (NS_FAILED(rv))
     goto fail;

netwerk/protocol/websocket/WebSocketChannelParent.h

@@ -45,7 +45,8 @@ class WebSocketChannelParent : public PWebSocketParent,
                      const uint32_t& aPingInterval,
                      const bool& aClientSetPingInterval,
                      const uint32_t& aPingTimeout,
-                     const bool& aClientSetPingTimeout) MOZ_OVERRIDE;
+                     const bool& aClientSetPingTimeout,
+                     const WebSocketLoadInfoArgs& aLoadInfoArgs) MOZ_OVERRIDE;
   bool RecvClose(const uint16_t & code, const nsCString & reason) MOZ_OVERRIDE;
   bool RecvSendMsg(const nsCString& aMsg) MOZ_OVERRIDE;
   bool RecvSendBinaryMsg(const nsCString& aMsg) MOZ_OVERRIDE;

netwerk/protocol/websocket/nsIWebSocketChannel.idl

@@ -10,6 +10,8 @@ interface nsILoadGroup;
 interface nsIWebSocketListener;
 interface nsIInputStream;
 interface nsILoadInfo;
+interface nsIDOMNode;
+interface nsIPrincipal;
 
 #include "nsISupports.idl"
 
@@ -20,7 +22,7 @@ interface nsILoadInfo;
  * We are also making it scriptable for now, but this may change once we have
  * WebSockets for Workers.
  */
-[scriptable, uuid(3fb248c2-c0fc-4516-9c58-505a92ad8c64)]
+[scriptable, uuid(21217c03-2ff7-4f9c-9d10-6d3d94a7d843)]
 interface nsIWebSocketChannel : nsISupports
 {
     /**
@@ -67,6 +69,63 @@ interface nsIWebSocketChannel : nsISupports
      */
     readonly attribute ACString extensions;
 
+    /**
+     * Init the WebSocketChannel with LoadInfo arguments.
+     * @param aLoadingNode
+     *        The loadingDocument of the channel.
+     *        The element or document where the result of this request will be
+     *        used. This is the document/element that will get access to the
+     *        result of this request. For example for an image load, it's the
+     *        document in which the image will be loaded. And for a CSS
+     *        stylesheet it's the document whose rendering will be affected by
+     *        the stylesheet.
+     *        For loads that are not related to any document, such as loads coming
+     *        from addons or internal browser features, use null here.
+     * @param aLoadingPrincipal
+     *        The loadingPrincipal of the channel.
+     *        The principal of the document where the result of this request will
+     *        be used.
+     *        This defaults to the principal of aLoadingNode, so when aLoadingNode
+     *        is passed then aLoadingPrincipal can be left as null. However, for
+     *        loads where aLoadingNode is null this argument must be passed.
+     *        For example for loads from a WebWorker, pass the principal
+     *        of that worker. For loads from an addon or from internal browser
+     *        features, pass the system principal.
+     *        If aLoadingNode is null and the URI being loaded isn't coming from
+     *        a webpage, the principal should almost always be the systemPrincipal.
+     *        One exception to this is for loads from WebWorkers since they don't
+     *        have any nodes to be passed as aLoadingNode.
+     *        Please note, aLoadingPrincipal is *not* the principal of the
+     *        resource being loaded. But rather the principal of the context
+     *        where the resource will be used.
+     * @param aTriggeringPrincipal
+     *        The triggeringPrincipal of the load.
+     *        The triggeringPrincipal is the principal of the resource that caused
+     *        this particular URL to be loaded.
+     *        For WebSockets, the loadingPrincipal and the triggeringPrincipal
+     *        are *always* identical.
+     * @param aSecurityFlags
+     *        The securityFlags of the channel.
+     *        Any of the securityflags defined in nsILoadInfo.idl
+     * @param aContentPolicyType
+     *        The contentPolicyType of the channel.
+     *        Any of the content types defined in nsIContentPolicy.idl
+     * @return reference to the new nsIChannel object
+     *
+     *
+     * Keep in mind that URIs coming from a webpage should *never* use the
+     * systemPrincipal as the loadingPrincipal.
+     *
+     * Please note, if you provide both a loadingNode and a loadingPrincipal,
+     * then loadingPrincipal must be equal to loadingNode->NodePrincipal().
+     * But less error prone is to just supply a loadingNode.
+     */
+     void initLoadInfo(in nsIDOMNode aLoadingNode,
+                       in nsIPrincipal aLoadingPrincipal,
+                       in nsIPrincipal aTriggeringPrincipal,
+                       in unsigned long aSecurityFlags,
+                       in unsigned long aContentPolicyType);
+
     /**
      * Asynchronously open the websocket connection.  Received messages are fed
      * to the socket listener as they arrive.  The socket listener's methods

netwerk/test/unit/test_dns_proxy_bypass.js

@@ -2,6 +2,8 @@
  * 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/. */
 
+Cu.import("resource://gre/modules/Services.jsm");
+
 var ioService = Cc["@mozilla.org/network/io-service;1"].
   getService(Ci.nsIIOService);
 
@@ -61,6 +63,13 @@ function run_test() {
   prefs.setBoolPref("network.proxy.socks_remote_dns", true);
   var chan = Cc["@mozilla.org/network/protocol;1?name=ws"].
     createInstance(Components.interfaces.nsIWebSocketChannel);
+
+  chan.initLoadInfo(null, // aLoadingNode
+                    Services.scriptSecurityManager.getSystemPrincipal(),
+                    null, // aTriggeringPrincipal
+                    Ci.nsILoadInfo.SEC_NORMAL,
+                    Ci.nsIContentPolicy.TYPE_WEBSOCKET);
+
   var uri = ioService.newURI(url, null, null);
   chan.asyncOpen(uri, url, listener, null);
   do_test_pending();

netwerk/test/unit/test_websocket_offline.js

@@ -35,6 +35,12 @@ function run_test() {
   try {
     chan = Cc["@mozilla.org/network/protocol;1?name=ws"].
       createInstance(Components.interfaces.nsIWebSocketChannel);
+    chan.initLoadInfo(null, // aLoadingNode
+                      Services.scriptSecurityManager.getSystemPrincipal(),
+                      null, // aTriggeringPrincipal
+                      Ci.nsILoadInfo.SEC_NORMAL,
+                      Ci.nsIContentPolicy.TYPE_WEBSOCKET);
+
     var uri = Services.io.newURI(url, null, null);
     chan.asyncOpen(uri, url, listener, null);
     do_test_pending();