Merge branch 'vanilla_0.4.4' and resolve conflicts

TODO: Validate for removed patches due to relocation

Resolved Conflicts:
	LibOVR/Src/Kernel/OVR_ThreadsWinAPI.cpp
	LibOVR/Src/OVR_Linux_HMDDevice.cpp
	LibOVR/Src/OVR_OSX_HMDDevice.cpp
	LibOVR/Src/OVR_Profile.cpp
	LibOVR/Src/OVR_Sensor2Impl.cpp
	LibOVR/Src/OVR_SensorFusion.cpp
	LibOVR/Src/OVR_SensorImpl.cpp
	LibOVR/Src/OVR_Win32_DeviceStatus.cpp
	LibOVR/Src/OVR_Win32_HIDDevice.cpp
	LibOVR/Src/OVR_Win32_HIDDevice.h
	LibOVR/Src/OVR_Win32_HMDDevice.cpp

1 files changed, 242 insertions, 0 deletions

diff --git a/LibOVR/Src/Net/OVR_Socket.h b/LibOVR/Src/Net/OVR_Socket.h
new file mode 100644
index 0000000..b02e038
--- /dev/null
+++ b/LibOVR/Src/Net/OVR_Socket.h
@@ -0,0 +1,242 @@
+/************************************************************************************
+
+PublicHeader:   n/a
+Filename    :   OVR_Socket.h
+Content     :   Socket common data shared between all platforms.
+Created     :   June 10, 2014
+Authors     :   Kevin Jenkins, Chris Taylor
+
+Copyright   :   Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License"); 
+you may not use the Oculus VR Rift SDK except in compliance with the License, 
+which is provided at the time of installation or download, or which 
+otherwise accompanies this software in either electronic or hard copy form.
+
+You may obtain a copy of the License at
+
+http://www.oculusvr.com/licenses/LICENSE-3.2 
+
+Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#ifndef OVR_Socket_h
+#define OVR_Socket_h
+
+#include "../Kernel/OVR_Types.h"
+#include "../Kernel/OVR_Timer.h"
+#include "../Kernel/OVR_Allocator.h"
+#include "../Kernel/OVR_RefCount.h"
+#include "../Kernel/OVR_String.h"
+
+// OS-specific socket headers
+#if defined(OVR_OS_WIN32)
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+# include <unistd.h>
+# include <sys/types.h>
+# include <netinet/in.h>
+#ifdef OVR_OS_ANDROID
+#include <sys/socket.h>
+#endif
+#endif
+
+namespace OVR { namespace Net {
+
+class SockAddr;
+class UDPSocket;
+class TCPSocket;
+
+
+//-----------------------------------------------------------------------------
+// Portable numeric Socket handle
+#if defined(OVR_OS_WIN32)
+typedef SOCKET SocketHandle;
+#else
+typedef int SocketHandle;
+static const SocketHandle INVALID_SOCKET = -1;
+static const int SOCKET_ERROR = -1;
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Types of network transport
+enum TransportType
+{
+	TransportType_None,          // No transport (useful placeholder for invalid states)
+	TransportType_Loopback,      // Loopback transport: Class talks to itself
+	TransportType_TCP,           // TCP/IPv4/v6
+	TransportType_UDP,           // UDP/IPv4/v6
+	TransportType_PacketizedTCP  // Packetized TCP: Message framing is automatic
+};
+
+
+//-----------------------------------------------------------------------------
+// Abstraction for a network socket. Inheritance hierarchy
+// modeled after RakNet so that future support can be added
+// for Linux, Windows RT, consoles, etc.
+class Socket : public RefCountBase<Socket>
+{
+public:
+	Socket();
+	virtual void Close() = 0;
+
+public:
+	TransportType Transport; // Type of transport
+};
+
+
+//-----------------------------------------------------------------------------
+// Bind parameters for Berkley sockets
+struct BerkleyBindParameters
+{
+public:
+	BerkleyBindParameters();
+
+public:
+	uint16_t Port;     // Port
+	String Address;
+    uint32_t blockingTimeout;
+};
+
+
+//-----------------------------------------------------------------------------
+// Berkley socket
+class BerkleySocket : public Socket
+{
+public:
+	BerkleySocket();
+	virtual ~BerkleySocket();
+
+	virtual void   Close();
+	virtual int32_t GetSockname(SockAddr* pSockAddrOut);
+	virtual void   SetBlockingTimeout(int timeoutMs) // milliseconds
+	{
+        TimeoutSec = timeoutMs / 1000;
+        TimeoutUsec = (timeoutMs % 1000) * 1000;
+	}
+    int            GetBlockingTimeoutUsec() const
+    {
+        return TimeoutUsec;
+    }
+    int            GetBlockingTimeoutSec() const
+    {
+        return TimeoutSec;
+    }
+    SocketHandle   GetSocketHandle() const
+    {
+        return TheSocket;
+    }
+
+protected:
+	SocketHandle TheSocket;           // Socket handle
+    int TimeoutUsec, TimeoutSec;
+};
+
+
+//-----------------------------------------------------------------------------
+// UDP socket events
+class SocketEvent_UDP
+{
+public:
+	virtual ~SocketEvent_UDP(){}
+
+	virtual void UDP_OnRecv(Socket* pSocket, uint8_t* pData,
+							uint32_t bytesRead, SockAddr* pSockAddr)
+	{
+		OVR_UNUSED4(pSocket, pData, bytesRead, pSockAddr);
+	}
+};
+
+
+//-----------------------------------------------------------------------------
+// TCP socket events
+class SocketEvent_TCP
+{
+public:
+	virtual ~SocketEvent_TCP(){}
+
+	virtual void TCP_OnRecv     (Socket* pSocket,
+                                 uint8_t* pData,
+                                 int bytesRead)
+	{
+		OVR_UNUSED3(pSocket, pData, bytesRead);
+	}
+	virtual void TCP_OnClosed   (TCPSocket* pSocket)
+	{
+		OVR_UNUSED(pSocket);
+	}
+	virtual void TCP_OnAccept   (TCPSocket* pListener,
+                                 SockAddr* pSockAddr,
+								 SocketHandle newSock)
+	{
+		OVR_UNUSED3(pListener, pSockAddr, newSock);
+	}
+	virtual void TCP_OnConnected(TCPSocket* pSocket)
+	{
+		OVR_UNUSED(pSocket);
+	}
+};
+
+
+//-----------------------------------------------------------------------------
+// UDP Berkley socket
+
+// Base class for UDP sockets, code shared between platforms
+class UDPSocketBase : public BerkleySocket
+{
+public:
+	UDPSocketBase();
+
+public:
+	virtual SocketHandle Bind(BerkleyBindParameters* pBindParameters) = 0;
+	virtual int          Send(const void* pData,
+                              int bytes,
+                              SockAddr* pSockAddr) = 0;
+	virtual void         Poll(SocketEvent_UDP* eventHandler) = 0;
+
+protected:
+	virtual void         OnRecv(SocketEvent_UDP* eventHandler,
+                                uint8_t* pData,
+								int bytesRead,
+                                SockAddr* address) = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// TCP Berkley socket
+
+// Base class for TCP sockets, code shared between platforms
+class TCPSocketBase : public BerkleySocket
+{
+public:
+	TCPSocketBase();
+	TCPSocketBase(SocketHandle handle);
+
+public:
+	virtual SocketHandle Bind(BerkleyBindParameters* pBindParameters) = 0;
+	virtual int          Listen() = 0;
+	virtual int          Connect(SockAddr* pSockAddr) = 0;
+	virtual int          Send(const void* pData,
+                              int bytes) = 0;
+protected:
+	virtual void         OnRecv(SocketEvent_TCP* eventHandler,
+                                uint8_t* pData,
+                                int bytesRead) = 0;
+
+protected:
+	bool IsListenSocket; // Is the socket listening (acting as a server)?
+};
+
+
+}} // OVR::Net
+
+#endif