diff --git a/chrome/chrome-app-tests.ts b/chrome/chrome-app-tests.ts
index 0ae0ae2af..12dc7b97d 100644
--- a/chrome/chrome-app-tests.ts
+++ b/chrome/chrome-app-tests.ts
@@ -24,4 +24,253 @@ chrome.app.runtime.onLaunched.addListener(function (launchData: runtime.LaunchDa
 chrome.app.runtime.onRestarted.addListener(function () { return; });
 
 // Get Current Window
-var currentWindow: cwindow.AppWindow = chrome.app.window.current();
\ No newline at end of file
+var currentWindow: cwindow.AppWindow = chrome.app.window.current();
+
+// Sockets
+// https://developer.chrome.com/apps/sockets_tcp
+function test_socketsTcp(): void {
+    var socketId: number;
+    var properties: chrome.sockets.tcp.SocketProperties = {};
+    var buffer: ArrayBuffer = new ArrayBuffer(256);
+    
+    // create
+    chrome.sockets.tcp.create((info) => {
+        socketId = info.socketId;
+    });
+
+    chrome.sockets.tcp.create(properties, (info) => {
+        socketId = info.socketId;
+    });
+
+    // update
+    chrome.sockets.tcp.update(socketId, properties);
+    chrome.sockets.tcp.update(socketId, properties, () => { });
+
+    // setPaused
+    chrome.sockets.tcp.setPaused(socketId, true);
+    chrome.sockets.tcp.setPaused(socketId, true, () => { });
+
+    // setKeepAlive
+    chrome.sockets.tcp.setKeepAlive(socketId, true, (result: number) => { });
+    chrome.sockets.tcp.setKeepAlive(socketId, true, 0, (result: number) => { });
+
+    // setNoDelay
+    chrome.sockets.tcp.setNoDelay(socketId, true, (result: number) => { });
+
+    // connect
+    chrome.sockets.tcp.connect(socketId, "192.168.0.1", 8080, (result: number) => { });
+
+    // disconnect
+    chrome.sockets.tcp.disconnect(socketId);
+    chrome.sockets.tcp.disconnect(socketId, () => { });
+
+    // send
+    chrome.sockets.tcp.send(socketId, buffer, (info: chrome.sockets.tcp.SendInfo) => { });
+
+    // close
+    chrome.sockets.tcp.close(socketId);
+    chrome.sockets.tcp.close(socketId, () => { });
+
+    // getInfo
+    chrome.sockets.tcp.getInfo(socketId, (info: chrome.sockets.tcp.SocketInfo) => { });
+
+    // getSockets
+    chrome.sockets.tcp.getSockets(socketId, (infos: chrome.sockets.tcp.SocketInfo[]) => { });
+}
+
+function test_socketsTcpEvents(): void {
+    chrome.sockets.tcp.onReceive.addListener((info: chrome.sockets.tcp.ReceiveEventArgs) => { });
+    chrome.sockets.tcp.onReceiveError.addListener((info: chrome.sockets.tcp.ReceiveErrorEventArgs) => { });
+}
+
+function testSocketsTcpTypes(): void {
+    // SocketProperties
+    var properties: chrome.sockets.tcp.SocketProperties;
+
+    properties = {
+    };
+
+    properties = {
+        persistent: true,
+        name: "test",
+        bufferSize: 1024
+    };
+
+    // SocketInfo
+    var socketInfo: chrome.sockets.tcp.SocketInfo;
+
+    socketInfo = {
+        socketId: 1,
+        persistent: true,
+        paused: true,
+        connected: false
+    };
+
+    socketInfo.name = "test";
+    socketInfo.bufferSize = 1024;
+    socketInfo.localAddress = "192.168.0.2";
+    socketInfo.localPort = 8000;
+    socketInfo.peerAddress = "192.168.0.3";
+    socketInfo.peerPort = 1000;
+}
+
+// https://developer.chrome.com/apps/sockets_udp
+function test_socketsUdp(): void {
+    var socketId: number;
+    var properties: chrome.sockets.udp.SocketProperties = {};
+    var buffer: ArrayBuffer = new ArrayBuffer(256);
+
+    // create
+    chrome.sockets.udp.create((info) => {
+        socketId = info.socketId;
+    });
+
+    chrome.sockets.udp.create(properties, (info) => {
+        socketId = info.socketId;
+    });
+
+    // update
+    chrome.sockets.udp.update(socketId, properties);
+    chrome.sockets.udp.update(socketId, properties, () => { });
+
+    // setPaused
+    chrome.sockets.udp.setPaused(socketId, true);
+    chrome.sockets.udp.setPaused(socketId, true, () => { });
+
+    // bind
+    chrome.sockets.udp.bind(socketId, "0.0.0.0", 8080, (result: number) => { });
+
+    // send
+    chrome.sockets.udp.send(socketId, buffer, "172.21.0.1", 10080, (info: chrome.sockets.udp.SendInfo) => { });
+
+    // close
+    chrome.sockets.udp.close(socketId);
+    chrome.sockets.udp.close(socketId, () => { });
+
+    // getInfo
+    chrome.sockets.udp.getInfo(socketId, (info: chrome.sockets.udp.SocketInfo) => { });
+
+    // getSockets
+    chrome.sockets.udp.getSockets((infos: chrome.sockets.udp.SocketInfo[]) => { });
+
+    // joinGroup
+    chrome.sockets.udp.joinGroup(socketId, "224.0.0.1", (result: number) => { });
+
+    // leaveGroup
+    chrome.sockets.udp.leaveGroup(socketId, "224.0.0.1", (result: number) => { });
+
+    // setMulticastTimeToLive
+    chrome.sockets.udp.setMulticastTimeToLive(socketId, 100, (result: number) => { });
+
+    // setMulticastLoopbackMode
+    chrome.sockets.udp.setMulticastLoopbackMode(socketId, true, (result: number) => { });
+
+    // getJoinedGroups
+    chrome.sockets.udp.getJoinedGroups(socketId, (groups: string[]) => { });
+}
+
+function test_socketsUdpEvents(): void {
+    chrome.sockets.udp.onReceive.addListener((info: chrome.sockets.udp.ReceiveEventArgs) => { });
+    chrome.sockets.udp.onReceiveError.addListener((info: chrome.sockets.udp.ReceiveErrorEventArgs) => { });
+}
+
+function testSocketsUdpTypes(): void {
+    // SocketProperties
+    var properties: chrome.sockets.udp.SocketProperties;
+
+    properties = {
+    };
+
+    properties = {
+        persistent: true,
+        name: "test",
+        bufferSize: 1024
+    };
+
+    // SocketInfo
+    var socketInfo: chrome.sockets.udp.SocketInfo;
+
+    socketInfo = {
+        socketId: 1,
+        persistent: true,
+        paused: true
+    };
+
+    socketInfo.name = "test";
+    socketInfo.bufferSize = 1024;
+    socketInfo.localAddress = "192.168.0.2";
+    socketInfo.localPort = 8000;
+}
+
+// https://developer.chrome.com/apps/sockets_tcpServer
+function test_socketsTcpServer(): void {
+    var socketId: number;
+    var properties: chrome.sockets.tcpServer.SocketProperties = {};
+    var buffer: ArrayBuffer = new ArrayBuffer(256);
+
+    // create
+    chrome.sockets.tcpServer.create((info) => {
+        socketId = info.socketId;
+    });
+
+    chrome.sockets.tcpServer.create(properties, (info) => {
+        socketId = info.socketId;
+    });
+
+    // update
+    chrome.sockets.tcpServer.update(socketId, properties);
+    chrome.sockets.tcpServer.update(socketId, properties, () => { });
+
+    // setPaused
+    chrome.sockets.tcpServer.setPaused(socketId, true);
+    chrome.sockets.tcpServer.setPaused(socketId, true, () => { });
+
+    // listen
+    chrome.sockets.tcpServer.listen(socketId, "0.0.0.0", 80, (result: number) => { });
+    chrome.sockets.tcpServer.listen(socketId, "0.0.0.0", 80, 128, (result: number) => { });
+
+    // disconnect
+    chrome.sockets.tcp.disconnect(socketId);
+    chrome.sockets.tcp.disconnect(socketId, () => { });
+
+    // close
+    chrome.sockets.udp.close(socketId);
+    chrome.sockets.udp.close(socketId, () => { });
+
+    // getInfo
+    chrome.sockets.udp.getInfo(socketId, (info: chrome.sockets.udp.SocketInfo) => { });
+
+    // getSockets
+    chrome.sockets.tcp.getSockets(socketId, (infos: chrome.sockets.tcp.SocketInfo[]) => { });
+}
+
+function test_socketsTcpServerEvents(): void {
+    chrome.sockets.tcpServer.onAccept.addListener((info: chrome.sockets.tcpServer.AcceptEventArgs) => { });
+    chrome.sockets.tcpServer.onAcceptError.addListener((info: chrome.sockets.tcpServer.AcceptErrorEventArgs) => { });
+}
+
+function testSocketsTcpServerTypes(): void {
+    // SocketProperties
+    var properties: chrome.sockets.tcpServer.SocketProperties;
+
+    properties = {
+    };
+
+    properties = {
+        persistent: true,
+        name: "test"
+    };
+
+    // SocketInfo
+    var socketInfo: chrome.sockets.tcpServer.SocketInfo;
+
+    socketInfo = {
+        socketId: 1,
+        persistent: true,
+        paused: true
+    };
+
+    socketInfo.name = "test";
+    socketInfo.localAddress = "192.168.0.2";
+    socketInfo.localPort = 8000;
+}
diff --git a/chrome/chrome-app.d.ts b/chrome/chrome-app.d.ts
index ad319394f..830b26e4f 100644
--- a/chrome/chrome-app.d.ts
+++ b/chrome/chrome-app.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for Chrome packaged application development
 // Project: http://developer.chrome.com/apps/
-// Definitions by: Adam Lay <https://github.com/AdamLay>
+// Definitions by: Adam Lay <https://github.com/AdamLay>, MIZUNE Pine <https://github.com/pine613>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ////////////////////
@@ -93,3 +93,189 @@ declare module chrome.app.window {
     var onMinimized: WindowEvent;
     var onRestored: WindowEvent;
 }
+
+
+////////////////////
+// Sockets
+////////////////////
+declare module chrome.sockets.tcp {
+    interface CreateInfo {
+        socketId: number;
+    }
+
+    interface SendInfo {
+        resultCode: number;
+        bytesSent?: number;
+    }
+
+    interface Event<T> {
+        addListener(callback: (info: T) => void): void;
+    }
+
+    interface ReceiveEventArgs {
+        socketId: number;
+        data: ArrayBuffer;
+    }
+
+    interface ReceiveErrorEventArgs {
+        socketId: number;
+        resultCode: number;
+    }
+
+    interface SocketProperties {
+        persistent?: boolean;
+        name?: string;
+        bufferSize?: number;
+    }
+
+    interface SocketInfo {
+        socketId: number;
+        persistent: boolean;
+        name?: string;
+        bufferSize?: number;
+        paused: boolean;
+        connected: boolean;
+        localAddress?: string;
+        localPort?: number;
+        peerAddress?: string;
+        peerPort?: number;
+    }
+
+    export function create(callback: (createInfo: CreateInfo) => void): void;
+    export function create(properties: SocketProperties, callback: (createInfo: CreateInfo) => void): void;
+
+    export function update(socketId: number, properties: SocketProperties, callback?: () => void): void;
+    export function setPaused(socketId: number, paused: boolean, callback?: () => void): void;
+
+    export function setKeepAlive(socketId: number,
+        enable: boolean, callback: (result: number) => void): void;
+    export function setKeepAlive(socketId: number,
+        enable: boolean, delay: number, callback: (result: number) => void): void;
+
+    export function setNoDelay(socketId: number, noDelay: boolean, callback: (result: number) => void): void;
+    export function connect(socketId: number,
+        peerAddress: string, peerPort: number, callback: (result: number) => void): void;
+    export function disconnect(socketId: number, callback?: () => void): void;
+    export function send(socketId: number, data: ArrayBuffer, callback: (sendInfo: SendInfo) => void): void;
+    export function close(socketId: number, callback?: () => void): void;
+    export function getInfo(socketId: number, callback: (socketInfo: SocketInfo) => void): void;
+    export function getSockets(socketId: number, callback: (socketInfos: SocketInfo[]) => void): void;
+
+    var onReceive: Event<ReceiveEventArgs>;
+    var onReceiveError: Event<ReceiveErrorEventArgs>;
+}
+
+declare module chrome.sockets.udp {
+    interface CreateInfo {
+        socketId: number;
+    }
+
+    interface SendInfo {
+        resultCode: number;
+        bytesSent?: number;
+    }
+
+    interface Event<T> {
+        addListener(callback: (info: T) => void): void;
+    }
+
+    interface ReceiveEventArgs {
+        socketId: number;
+        data: ArrayBuffer;
+        remoteAddress: string;
+        remotePort: number;
+    }
+
+    interface ReceiveErrorEventArgs {
+        socketId: number;
+        resultCode: number;
+    }
+
+    interface SocketProperties {
+        persistent?: boolean;
+        name?: string;
+        bufferSize?: number;
+    }
+
+    interface SocketInfo {
+        socketId: number;
+        persistent: boolean;
+        name?: string;
+        bufferSize?: number;
+        paused: boolean;
+        localAddress?: string;
+        localPort?: number;
+    }
+
+    export function create(callback: (createInfo: CreateInfo) => void): void;
+    export function create(properties: SocketProperties,
+        callback: (createInfo: CreateInfo) => void): void;
+
+    export function update(socketId: number, properties: SocketProperties, callback?: () => void): void;
+    export function setPaused(socketId: number, paused: boolean, callback?: () => void): void;
+    export function bind(socketId: number, address: string, port: number, callback: (result: number) => void): void;
+    export function send(socketId: number, data: ArrayBuffer, address: string, port: number, callback: (sendInfo: SendInfo) => void): void;
+    export function close(socketId: number, callback?: () => void): void;
+    export function getInfo(socketId: number, callback: (socketInfo: SocketInfo) => void): void;
+    export function getSockets(callback: (socketInfos: SocketInfo[]) => void): void;
+    export function joinGroup(socketId: number, address: string, callback: (result: number) => void): void;
+    export function leaveGroup(socketId: number, address: string, callback: (result: number) => void): void;
+    export function setMulticastTimeToLive(socketId: number, ttl: number, callback: (result: number) => void): void;
+    export function setMulticastLoopbackMode(socketId: number, enabled: boolean, callback: (result: number) => void): void;
+    export function getJoinedGroups(socketId: number, callback: (groups: string[]) => void): void;
+
+    var onReceive: Event<ReceiveEventArgs>;
+    var onReceiveError: Event<ReceiveErrorEventArgs>;
+}
+
+declare module chrome.sockets.tcpServer {
+    interface CreateInfo {
+        socketId: number;
+    }
+
+    interface Event<T> {
+        addListener(callback: (info: T) => void): void;
+    }
+
+    interface AcceptEventArgs {
+        socketId: number;
+        clientSocketId: number;
+    }
+
+    interface AcceptErrorEventArgs {
+        socketId: number;
+        resultCode: number;
+    }
+
+    interface SocketProperties {
+        persistent?: boolean;
+        name?: string;
+    }
+
+    interface SocketInfo {
+        socketId: number;
+        persistent: boolean;
+        name?: string;
+        paused: boolean;
+        localAddress?: string;
+        localPort?: number;
+    }
+
+    export function create(callback: (createInfo: CreateInfo) => void): void;
+    export function create(properties: SocketProperties, callback: (createInfo: CreateInfo) => void): void;
+
+    export function update(socketId: number, properties: SocketProperties, callback?: () => void): void;
+    export function setPaused(socketId: number, paused: boolean, callback?: () => void): void;
+
+    export function listen(socketId: number, address: string,
+        port: number, backlog: number, callback: (result: number) => void): void;
+    export function listen(socketId: number, address: string,
+        port: number, callback: (result: number) => void): void;
+
+    export function disconnect(socketId: number, callback?: () => void): void;
+    export function close(socketId: number, callback?: () => void): void;
+    export function getInfo(socketId: number, callback: (socketInfos: SocketInfo[]) => void): void;
+
+    var onAccept: Event<AcceptEventArgs>;
+    var onAcceptError: Event<AcceptErrorEventArgs>;
+}
\ No newline at end of file