OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // net/tools/testserver/testserver.py is picky about the format of what it | 5 // net/tools/testserver/testserver.py is picky about the format of what it |
6 // calls its "echo" messages. One might go so far as to mutter to oneself that | 6 // calls its "echo" messages. One might go so far as to mutter to oneself that |
7 // it isn't an echo server at all. | 7 // it isn't an echo server at all. |
8 // | 8 // |
9 // The response is based on the request but obfuscated using a random key. | 9 // The response is based on the request but obfuscated using a random key. |
10 const request = "0100000005320000005hello"; | 10 const request = "0100000005320000005hello"; |
11 var expectedResponsePattern = /0100000005320000005.{11}/; | 11 var expectedResponsePattern = /0100000005320000005.{11}/; |
| 12 const http_get = "GET test.html HTTP/1.0\r\n\r\n"; |
| 13 var expectedHTTPPattern = /HTTP.1.0 200 OK/; |
12 | 14 |
13 var address; | 15 var tcp_address; |
| 16 var https_address; |
14 var bytesSent = 0; | 17 var bytesSent = 0; |
15 var dataAsString; | 18 var dataAsString; |
16 var dataRead = []; | 19 var dataRead = []; |
17 var port = -1; | 20 var tcp_port = -1; |
| 21 var https_port = -1; |
18 var protocol = "none"; | 22 var protocol = "none"; |
19 var socketId = 0; | 23 var tcp_socketId = 0; |
| 24 var https_socketId = 0; |
20 var echoDataSent = false; | 25 var echoDataSent = false; |
21 var succeeded = false; | 26 var succeeded = false; |
22 var waitCount = 0; | 27 var waitCount = 0; |
23 | 28 |
| 29 // Keys are socketIds. Values are inner dictionaries with two keys: onReceive, |
| 30 // onReceiveError. Both are functions. |
| 31 var receive_dispatcher = {} |
| 32 |
24 // Many thanks to Dennis for his StackOverflow answer: http://goo.gl/UDanx | 33 // Many thanks to Dennis for his StackOverflow answer: http://goo.gl/UDanx |
25 // Since amended to handle BlobBuilder deprecation. | 34 // Since amended to handle BlobBuilder deprecation. |
26 function string2ArrayBuffer(string, callback) { | 35 function string2ArrayBuffer(string, callback) { |
27 var blob = new Blob([string]); | 36 var blob = new Blob([string]); |
28 var f = new FileReader(); | 37 var f = new FileReader(); |
29 f.onload = function(e) { | 38 f.onload = function(e) { |
30 callback(e.target.result); | 39 callback(e.target.result); |
31 }; | 40 }; |
32 f.readAsArrayBuffer(blob); | 41 f.readAsArrayBuffer(blob); |
33 } | 42 } |
34 | 43 |
35 function arrayBuffer2String(buf, callback) { | 44 function arrayBuffer2String(buf, callback) { |
36 var blob = new Blob([new Uint8Array(buf)]); | 45 var blob = new Blob([new Uint8Array(buf)]); |
37 var f = new FileReader(); | 46 var f = new FileReader(); |
38 f.onload = function(e) { | 47 f.onload = function(e) { |
39 callback(e.target.result); | 48 callback(e.target.result); |
40 }; | 49 }; |
41 f.readAsText(blob); | 50 f.readAsText(blob); |
42 } | 51 } |
43 | 52 |
| 53 function dispatchSocketReceive(receiveInfo) { |
| 54 if (receive_dispatcher[receiveInfo.socketId] !== undefined) { |
| 55 receive_dispatcher[receiveInfo.socketId].onReceive(receiveInfo); |
| 56 } else { |
| 57 console.log("dispatchSocketReceive: No handler for socket " + |
| 58 receiveInfo.socketId); |
| 59 } |
| 60 } |
| 61 |
| 62 function dispatchSocketReceiveError(receiveErrorInfo) { |
| 63 if (receive_dispatcher[receiveErrorInfo.socketId] !== undefined) { |
| 64 receive_dispatcher[receiveErrorInfo.socketId].onReceiveError( |
| 65 receiveErrorInfo); |
| 66 } else { |
| 67 console.log("dispatchSocketReceiveError: No handler for socket " + |
| 68 receiveErrorInfo.socketId); |
| 69 } |
| 70 } |
| 71 |
44 var testSocketCreation = function() { | 72 var testSocketCreation = function() { |
45 function onCreate(socketInfo) { | 73 function onCreate(socketInfo) { |
46 function onGetInfo(info) { | 74 function onGetInfo(info) { |
47 chrome.test.assertFalse(info.connected); | 75 chrome.test.assertFalse(info.connected); |
48 | 76 |
49 if (info.peerAddress || info.peerPort) { | 77 if (info.peerAddress || info.peerPort) { |
50 chrome.test.fail('Unconnected socket should not have peer'); | 78 chrome.test.fail('Unconnected socket should not have peer'); |
51 } | 79 } |
52 if (info.localAddress || info.localPort) { | 80 if (info.localAddress || info.localPort) { |
53 chrome.test.fail('Unconnected socket should not have local binding'); | 81 chrome.test.fail('Unconnected socket should not have local binding'); |
(...skipping 10 matching lines...) Expand all Loading... |
64 chrome.test.assertTrue(socketInfo.socketId > 0); | 92 chrome.test.assertTrue(socketInfo.socketId > 0); |
65 | 93 |
66 // Obtaining socket information before a connect() call should be safe, but | 94 // Obtaining socket information before a connect() call should be safe, but |
67 // return empty values. | 95 // return empty values. |
68 chrome.sockets.tcp.getInfo(socketInfo.socketId, onGetInfo); | 96 chrome.sockets.tcp.getInfo(socketInfo.socketId, onGetInfo); |
69 } | 97 } |
70 | 98 |
71 chrome.sockets.tcp.create({}, onCreate); | 99 chrome.sockets.tcp.create({}, onCreate); |
72 }; | 100 }; |
73 | 101 |
74 | |
75 var testSending = function() { | 102 var testSending = function() { |
76 dataRead = ""; | 103 dataRead = ""; |
77 succeeded = false; | 104 succeeded = false; |
78 echoDataSent = false; | 105 echoDataSent = false; |
79 waitCount = 0; | 106 waitCount = 0; |
80 | 107 |
81 setTimeout(waitForBlockingOperation, 1000); | 108 setTimeout(waitForBlockingOperation, 1000); |
82 | 109 |
83 createSocket(); | 110 createSocket(); |
84 | 111 |
85 function createSocket() { | 112 function createSocket() { |
86 chrome.sockets.tcp.create({ | 113 chrome.sockets.tcp.create({ |
87 "name": "test", | 114 "name": "test", |
88 "persistent": true, | 115 "persistent": true, |
89 "bufferSize": 104 | 116 "bufferSize": 104 |
90 }, onCreateComplete); | 117 }, onCreateComplete); |
91 } | 118 } |
92 | 119 |
93 function onCreateComplete(socketInfo) { | 120 function onCreateComplete(socketInfo) { |
94 console.log("onCreateComplete"); | 121 console.log("onCreateComplete"); |
95 socketId = socketInfo.socketId; | 122 tcp_socketId = socketInfo.socketId; |
96 chrome.test.assertTrue(socketId > 0, "failed to create socket"); | 123 chrome.test.assertTrue(tcp_socketId > 0, "failed to create socket"); |
97 | 124 |
98 console.log("add event listeners"); | 125 console.log("add event listeners"); |
99 chrome.sockets.tcp.onReceive.addListener(onSocketReceive); | 126 receive_dispatcher[tcp_socketId] = { |
100 chrome.sockets.tcp.onReceiveError.addListener(onSocketReceiveError); | 127 onReceive: onSocketReceive, |
| 128 onReceiveError: onSocketReceiveError |
| 129 }; |
101 | 130 |
102 chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterCreateComplete); | 131 chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterCreateComplete); |
103 } | 132 } |
104 | 133 |
105 function onGetInfoAfterCreateComplete(result) { | 134 function onGetInfoAfterCreateComplete(result) { |
106 console.log("onGetInfoAfterCreateComplete"); | 135 console.log("onGetInfoAfterCreateComplete"); |
107 chrome.test.assertTrue(!result.localAddress, | 136 chrome.test.assertTrue(!result.localAddress, |
108 "Socket should not have local address"); | 137 "Socket should not have local address"); |
109 chrome.test.assertTrue(!result.localPort, | 138 chrome.test.assertTrue(!result.localPort, |
110 "Socket should not have local port"); | 139 "Socket should not have local port"); |
111 chrome.test.assertTrue(!result.peerAddress, | 140 chrome.test.assertTrue(!result.peerAddress, |
112 "Socket should not have peer address"); | 141 "Socket should not have peer address"); |
113 chrome.test.assertTrue(!result.peerPort, | 142 chrome.test.assertTrue(!result.peerPort, |
114 "Socket should not have peer port"); | 143 "Socket should not have peer port"); |
115 chrome.test.assertFalse(result.connected, "Socket should not be connected"); | 144 chrome.test.assertFalse(result.connected, "Socket should not be connected"); |
116 | 145 |
117 chrome.test.assertEq("test", result.name, "Socket name did not persist"); | 146 chrome.test.assertEq("test", result.name, "Socket name did not persist"); |
118 chrome.test.assertTrue(result.persistent, | 147 chrome.test.assertTrue(result.persistent, |
119 "Socket should be persistent"); | 148 "Socket should be persistent"); |
120 chrome.test.assertEq(104, result.bufferSize, "Buffer size did not persist"); | 149 chrome.test.assertEq(104, result.bufferSize, "Buffer size did not persist"); |
121 chrome.test.assertFalse(result.paused, "Socket should not be paused"); | 150 chrome.test.assertFalse(result.paused, "Socket should not be paused"); |
122 | 151 |
123 chrome.sockets.tcp.update(socketId, { | 152 chrome.sockets.tcp.update(tcp_socketId, { |
124 "name": "test2", | 153 "name": "test2", |
125 "persistent": false, | 154 "persistent": false, |
126 bufferSize: 2048 | 155 bufferSize: 2048 |
127 }, onUpdateComplete); | 156 }, onUpdateComplete); |
128 } | 157 } |
129 | 158 |
130 function onUpdateComplete() { | 159 function onUpdateComplete() { |
131 console.log("onUpdateComplete"); | 160 console.log("onUpdateComplete"); |
132 chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterUpdateComplete); | 161 chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterUpdateComplete); |
133 } | 162 } |
134 | 163 |
135 function onGetInfoAfterUpdateComplete(result) { | 164 function onGetInfoAfterUpdateComplete(result) { |
136 console.log("onGetInfoAfterUpdateComplete"); | 165 console.log("onGetInfoAfterUpdateComplete"); |
137 chrome.test.assertTrue(!result.localAddress, | 166 chrome.test.assertTrue(!result.localAddress, |
138 "Socket should not have local address"); | 167 "Socket should not have local address"); |
139 chrome.test.assertTrue(!result.localPort, | 168 chrome.test.assertTrue(!result.localPort, |
140 "Socket should not have local port"); | 169 "Socket should not have local port"); |
141 chrome.test.assertTrue(!result.peerAddress, | 170 chrome.test.assertTrue(!result.peerAddress, |
142 "Socket should not have peer address"); | 171 "Socket should not have peer address"); |
143 chrome.test.assertTrue(!result.peerPort, | 172 chrome.test.assertTrue(!result.peerPort, |
144 "Socket should not have peer port"); | 173 "Socket should not have peer port"); |
145 chrome.test.assertFalse(result.connected, "Socket should not be connected"); | 174 chrome.test.assertFalse(result.connected, "Socket should not be connected"); |
146 | 175 |
147 chrome.test.assertEq("test2", result.name, "Socket name did not persist"); | 176 chrome.test.assertEq("test2", result.name, "Socket name did not persist"); |
148 chrome.test.assertFalse(result.persistent, | 177 chrome.test.assertFalse(result.persistent, |
149 "Socket should not be persistent"); | 178 "Socket should not be persistent"); |
150 chrome.test.assertEq(2048, result.bufferSize, | 179 chrome.test.assertEq(2048, result.bufferSize, |
151 "Buffer size did not persist"); | 180 "Buffer size did not persist"); |
152 chrome.test.assertFalse(result.paused, "Socket should not be paused"); | 181 chrome.test.assertFalse(result.paused, "Socket should not be paused"); |
153 | 182 |
154 chrome.sockets.tcp.connect(socketId, address, port, onConnectComplete); | 183 chrome.sockets.tcp.connect(tcp_socketId, tcp_address, tcp_port, |
| 184 onConnectComplete); |
155 } | 185 } |
156 | 186 |
157 function onConnectComplete(result) { | 187 function onConnectComplete(result) { |
158 console.log("onConnectComplete"); | 188 console.log("onConnectComplete"); |
159 chrome.test.assertEq(0, result, | 189 chrome.test.assertEq(0, result, |
160 "Connect failed with error " + result); | 190 "Connect failed with error " + result); |
161 | 191 |
162 chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterConnectComplete); | 192 chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterConnectComplete); |
163 } | 193 } |
164 | 194 |
165 function onGetInfoAfterConnectComplete(result) { | 195 function onGetInfoAfterConnectComplete(result) { |
166 console.log("onGetInfoAfterConnectComplete"); | 196 console.log("onGetInfoAfterConnectComplete"); |
167 chrome.test.assertTrue(!!result.localAddress, | 197 chrome.test.assertTrue(!!result.localAddress, |
168 "Bound socket should always have local address"); | 198 "Bound socket should always have local address"); |
169 chrome.test.assertTrue(!!result.localPort, | 199 chrome.test.assertTrue(!!result.localPort, |
170 "Bound socket should always have local port"); | 200 "Bound socket should always have local port"); |
171 | 201 |
172 // NOTE: We're always called with 'localhost', but getInfo will only return | 202 // NOTE: We're always called with 'localhost', but getInfo will only return |
173 // IPs, not names. | 203 // IPs, not names. |
174 chrome.test.assertEq(result.peerAddress, "127.0.0.1", | 204 chrome.test.assertEq(result.peerAddress, "127.0.0.1", |
175 "Peer addresss should be the listen server"); | 205 "Peer addresss should be the listen server"); |
176 chrome.test.assertEq(result.peerPort, port, | 206 chrome.test.assertEq(result.peerPort, tcp_port, |
177 "Peer port should be the listen server"); | 207 "Peer port should be the listen server"); |
178 chrome.test.assertTrue(result.connected, "Socket should be connected"); | 208 chrome.test.assertTrue(result.connected, "Socket should be connected"); |
179 | 209 |
180 chrome.sockets.tcp.setPaused(socketId, true, onSetPausedComplete); | 210 chrome.sockets.tcp.setPaused(tcp_socketId, true, onSetPausedComplete); |
181 } | 211 } |
182 | 212 |
183 function onSetPausedComplete() { | 213 function onSetPausedComplete() { |
184 console.log("onSetPausedComplete"); | 214 console.log("onSetPausedComplete"); |
185 chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterSetPausedComplete); | 215 chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterSetPausedComplete); |
186 } | 216 } |
187 | 217 |
188 function onGetInfoAfterSetPausedComplete(result) { | 218 function onGetInfoAfterSetPausedComplete(result) { |
189 console.log("onGetInfoAfterSetPausedComplete"); | 219 console.log("onGetInfoAfterSetPausedComplete"); |
190 chrome.test.assertTrue(result.paused, "Socket should be paused"); | 220 chrome.test.assertTrue(result.paused, "Socket should be paused"); |
191 chrome.sockets.tcp.setPaused(socketId, false, onUnpauseComplete); | 221 chrome.sockets.tcp.setPaused(tcp_socketId, false, onUnpauseComplete); |
192 } | 222 } |
193 | 223 |
194 function onUnpauseComplete() { | 224 function onUnpauseComplete() { |
195 console.log("onUnpauseComplete"); | 225 console.log("onUnpauseComplete"); |
196 chrome.sockets.tcp.getInfo(socketId, onGetInfoAfterUnpauseComplete); | 226 chrome.sockets.tcp.getInfo(tcp_socketId, onGetInfoAfterUnpauseComplete); |
197 } | 227 } |
198 | 228 |
199 function onGetInfoAfterUnpauseComplete(result) { | 229 function onGetInfoAfterUnpauseComplete(result) { |
200 console.log("onGetInfoAfterUnpauseComplete"); | 230 console.log("onGetInfoAfterUnpauseComplete"); |
201 chrome.test.assertFalse(result.paused, "Socket should not be paused"); | 231 chrome.test.assertFalse(result.paused, "Socket should not be paused"); |
202 chrome.sockets.tcp.setNoDelay(socketId, true, onSetNoDelayComplete); | 232 chrome.sockets.tcp.setNoDelay(tcp_socketId, true, onSetNoDelayComplete); |
203 } | 233 } |
204 | 234 |
205 function onSetNoDelayComplete(result) { | 235 function onSetNoDelayComplete(result) { |
206 console.log("onSetNoDelayComplete"); | 236 console.log("onSetNoDelayComplete"); |
207 if (result != 0) { | 237 if (result != 0) { |
208 chrome.test.fail("setNoDelay failed for TCP: " + | 238 chrome.test.fail("setNoDelay failed for TCP: " + |
209 "result=" + result + ", " + | 239 "result=" + result + ", " + |
210 "lastError=" + chrome.runtime.lastError.message); | 240 "lastError=" + chrome.runtime.lastError.message); |
211 } | 241 } |
212 chrome.sockets.tcp.setKeepAlive( | 242 chrome.sockets.tcp.setKeepAlive( |
213 socketId, true, 1000, onSetKeepAliveComplete); | 243 tcp_socketId, true, 1000, onSetKeepAliveComplete); |
214 } | 244 } |
215 | 245 |
216 function onSetKeepAliveComplete(result) { | 246 function onSetKeepAliveComplete(result) { |
217 console.log("onSetKeepAliveComplete"); | 247 console.log("onSetKeepAliveComplete"); |
218 if (result != 0) { | 248 if (result != 0) { |
219 chrome.test.fail("setKeepAlive failed for TCP: " + | 249 chrome.test.fail("setKeepAlive failed for TCP: " + |
220 "result=" + result + ", " + | 250 "result=" + result + ", " + |
221 "lastError=" + chrome.runtime.lastError.message); | 251 "lastError=" + chrome.runtime.lastError.message); |
222 } | 252 } |
223 | 253 |
224 string2ArrayBuffer(request, function(arrayBuffer) { | 254 string2ArrayBuffer(request, function(arrayBuffer) { |
225 echoDataSent = true; | 255 echoDataSent = true; |
226 chrome.sockets.tcp.send(socketId, arrayBuffer, onSendComplete); | 256 chrome.sockets.tcp.send(tcp_socketId, arrayBuffer, onSendComplete); |
227 }); | 257 }); |
228 } | 258 } |
229 | 259 |
230 function onSendComplete(sendInfo) { | 260 function onSendComplete(sendInfo) { |
231 console.log("onSendComplete: " + sendInfo.bytesSent + " bytes."); | 261 console.log("onSendComplete: " + sendInfo.bytesSent + " bytes."); |
232 chrome.test.assertEq(0, sendInfo.resultCode, "Send failed."); | 262 chrome.test.assertEq(0, sendInfo.resultCode, "Send failed."); |
233 chrome.test.assertTrue(sendInfo.bytesSent > 0, | 263 chrome.test.assertTrue(sendInfo.bytesSent > 0, |
234 "Send didn't write bytes."); | 264 "Send didn't write bytes."); |
235 bytesSent += sendInfo.bytesSent; | 265 bytesSent += sendInfo.bytesSent; |
236 } | 266 } |
237 | 267 |
238 function onSocketReceive(receiveInfo) { | 268 function onSocketReceive(receiveInfo) { |
239 console.log("onSocketReceive"); | 269 console.log("onSocketReceive"); |
240 chrome.test.assertEq(socketId, receiveInfo.socketId); | 270 chrome.test.assertEq(tcp_socketId, receiveInfo.socketId); |
241 arrayBuffer2String(receiveInfo.data, function(s) { | 271 arrayBuffer2String(receiveInfo.data, function(s) { |
242 dataAsString = s; // save this for error reporting | 272 dataAsString = s; // save this for error reporting |
243 var match = !!s.match(expectedResponsePattern); | 273 var match = !!s.match(expectedResponsePattern); |
244 chrome.test.assertTrue(match, "Received data does not match."); | 274 chrome.test.assertTrue(match, "Received data does not match."); |
245 console.log("echo data received, closing socket"); | 275 console.log("echo data received, closing socket"); |
246 chrome.sockets.tcp.close(socketId, onCloseComplete); | 276 chrome.sockets.tcp.close(tcp_socketId, onCloseComplete); |
247 }); | 277 }); |
248 } | 278 } |
249 | 279 |
250 function onSocketReceiveError(receiveErrorInfo) { | 280 function onSocketReceiveError(receiveErrorInfo) { |
251 // Note: Once we have sent the "echo" message, the echo server sends back | 281 // Note: Once we have sent the "echo" message, the echo server sends back |
252 // the "echo" response and closes the connection right away. This means | 282 // the "echo" response and closes the connection right away. This means |
253 // we get a "connection closed" error very quickly after sending our | 283 // we get a "connection closed" error very quickly after sending our |
254 // message. This is why we ignore errors from that point on. | 284 // message. This is why we ignore errors from that point on. |
255 if (echoDataSent) | 285 if (echoDataSent) |
256 return; | 286 return; |
257 | 287 |
258 console.log("onSocketReceiveError"); | 288 console.log("onSocketReceiveError"); |
259 chrome.test.fail("Receive error on socket " + receiveErrorInfo.socketId + | 289 chrome.test.fail("Receive error on socket " + receiveErrorInfo.socketId + |
260 ": result code=" + receiveErrorInfo.resultCode); | 290 ": result code=" + receiveErrorInfo.resultCode); |
261 } | 291 } |
262 | 292 |
263 function onCloseComplete() { | 293 function onCloseComplete() { |
264 console.log("onCloseComplete"); | 294 console.log("onCloseComplete"); |
265 succeeded = true; | 295 succeeded = true; |
266 chrome.test.succeed(); | 296 chrome.test.succeed(); |
267 } | 297 } |
268 | 298 |
269 }; // testSending() | 299 }; // testSending() |
270 | 300 |
| 301 var testSecure = function () { |
| 302 var request_sent = false; |
| 303 succeeded = false; |
| 304 dataAsString = ""; |
| 305 setTimeout(waitForBlockingOperation, 1000); |
| 306 |
| 307 // Run the test a few times. First with misuse_testing=MISUSE_NONE, |
| 308 // to test that the API works correctly when used properly. Then |
| 309 // with different values of misuse_mode, test that the API does |
| 310 // not malfunction when used improperly. Upon success, each misuse |
| 311 // must close the socket and call onCloseComplete(). |
| 312 var MISUSE_NONE = 0; |
| 313 var MISUSE_SECURE_PENDING_READ = 1; |
| 314 var MISUSE_LAST = MISUSE_SECURE_PENDING_READ; |
| 315 var misuse_mode = MISUSE_NONE; |
| 316 |
| 317 chrome.sockets.tcp.create({}, onCreateComplete); |
| 318 |
| 319 function onCreateComplete(socketInfo) { |
| 320 https_socketId = socketInfo.socketId; |
| 321 receive_dispatcher[https_socketId] = { |
| 322 onReceive: onSocketReceive, |
| 323 onReceiveError: onSocketReceiveError |
| 324 }; |
| 325 |
| 326 chrome.test.assertTrue(https_socketId > 0, "failed to create socket"); |
| 327 if (misuse_mode == MISUSE_SECURE_PENDING_READ) { |
| 328 // Don't pause the socket. This will let the sockets runtime |
| 329 // keep a pending read on it. |
| 330 console.log("HTTPS onCreateComplete: in MISUSE_SECURE_PENDING_READ " + |
| 331 "mode, skipping setPaused(false)."); |
| 332 onPausedComplete(); |
| 333 } else { |
| 334 chrome.sockets.tcp.setPaused(https_socketId, true, onPausedComplete); |
| 335 } |
| 336 } |
| 337 |
| 338 function onPausedComplete() { |
| 339 console.log("HTTPS onPausedComplete. Connecting to " +https_address + ":" + |
| 340 https_port); |
| 341 chrome.sockets.tcp.connect(https_socketId, https_address, https_port, |
| 342 onConnectComplete); |
| 343 } |
| 344 |
| 345 function onConnectComplete(result) { |
| 346 console.log("HTTPS onConnectComplete"); |
| 347 chrome.test.assertEq(0, result, |
| 348 "Connect failed with error " + result); |
| 349 chrome.sockets.tcp.secure(https_socketId, null, onSecureComplete); |
| 350 } |
| 351 |
| 352 function onSecureComplete(result) { |
| 353 console.log("HTTPS onSecureComplete(" + result + ")"); |
| 354 if (misuse_mode == MISUSE_SECURE_PENDING_READ) { |
| 355 // net::ERR_INVALID_ARGUMENT is -4. |
| 356 chrome.test.assertEq(-4, result, |
| 357 "Secure should have failed when a read " + |
| 358 "was pending (" + result + ")"); |
| 359 chrome.sockets.tcp.close(https_socketId, onCloseComplete); |
| 360 } else { |
| 361 chrome.test.assertEq(0, result, |
| 362 "Secure failed with error " + result); |
| 363 chrome.sockets.tcp.setPaused(https_socketId, false, onUnpauseComplete); |
| 364 } |
| 365 } |
| 366 |
| 367 function onUnpauseComplete() { |
| 368 console.log("HTTPS onUnpauseComplete"); |
| 369 string2ArrayBuffer(http_get, function(arrayBuffer) { |
| 370 request_sent = true; |
| 371 chrome.sockets.tcp.send(https_socketId, arrayBuffer, onSendComplete); |
| 372 }); |
| 373 } |
| 374 |
| 375 function onSendComplete(sendInfo) { |
| 376 console.log("HTTPS onSendComplete: " + sendInfo.bytesSent + " bytes."); |
| 377 chrome.test.assertEq(0, sendInfo.resultCode, "Send failed."); |
| 378 chrome.test.assertTrue(sendInfo.bytesSent > 0, |
| 379 "Send didn't write bytes."); |
| 380 bytesSent += sendInfo.bytesSent; |
| 381 } |
| 382 |
| 383 function onSocketReceive(receiveInfo) { |
| 384 console.log("HTTPS onSocketReceive"); |
| 385 chrome.test.assertEq(https_socketId, receiveInfo.socketId); |
| 386 arrayBuffer2String(receiveInfo.data, function(s) { |
| 387 // we will get more data than we care about. We only care about the |
| 388 // first segment of data (the HTTP 200 code). Ignore the rest, which |
| 389 // won't match the pattern. |
| 390 if (succeeded == false) { |
| 391 dataAsString = s; // for waitForBlockingOperation(). |
| 392 console.log("HTTPS receive: got " + s); |
| 393 var match = !!s.match(expectedHTTPPattern); |
| 394 chrome.test.assertTrue(match, "Received data does not match."); |
| 395 console.log("HTTPS response received, closing socket."); |
| 396 chrome.sockets.tcp.close(https_socketId, onCloseComplete); |
| 397 } |
| 398 succeeded = true; |
| 399 }); |
| 400 } |
| 401 |
| 402 function onSocketReceiveError(receiveErrorInfo) { |
| 403 console.log("HTTPS onSocketReceiveError"); |
| 404 if (request_sent) { |
| 405 return; |
| 406 } |
| 407 chrome.test.fail("Receive error on socket " + receiveErrorInfo.socketId + |
| 408 ": result code=" + receiveErrorInfo.resultCode); |
| 409 } |
| 410 |
| 411 function onCloseComplete() { |
| 412 console.log("HTTPS Test Succeeded"); |
| 413 if (misuse_mode == MISUSE_LAST) { |
| 414 // The test has run in all misuse modes. |
| 415 chrome.test.succeed(); |
| 416 } else { |
| 417 // Run the test again in the next misuse mode. |
| 418 misuse_mode += 1; |
| 419 chrome.sockets.tcp.create({}, onCreateComplete); |
| 420 } |
| 421 } |
| 422 }; // testSecure() |
| 423 |
271 function waitForBlockingOperation() { | 424 function waitForBlockingOperation() { |
272 if (++waitCount < 10) { | 425 if (++waitCount < 10) { |
273 setTimeout(waitForBlockingOperation, 1000); | 426 setTimeout(waitForBlockingOperation, 1000); |
274 } else { | 427 } else { |
275 // We weren't able to succeed in the given time. | 428 // We weren't able to succeed in the given time. |
276 chrome.test.fail("Operations didn't complete after " + waitCount + " " + | 429 chrome.test.fail("Operations didn't complete after " + waitCount + " " + |
277 "seconds. Response so far was <" + dataAsString + ">."); | 430 "seconds. Response so far was <" + dataAsString + ">."); |
278 } | 431 } |
279 } | 432 } |
280 | 433 |
281 var onMessageReply = function(message) { | 434 var onMessageReply = function(message) { |
282 var parts = message.split(":"); | 435 var components = message.split(','); |
283 var test_type = parts[0]; | 436 var tests = []; |
284 address = parts[1]; | 437 for (var i = 0; i < components.length; ++i) { |
285 port = parseInt(parts[2]); | 438 var parts = components[i].split(":"); |
286 console.log("Running tests, protocol " + test_type + ", echo server " + | 439 var test_type = parts[0]; |
287 address + ":" + port); | 440 if (test_type == 'tcp') { |
288 if (test_type == 'tcp') { | 441 tcp_address = parts[1]; |
289 protocol = test_type; | 442 tcp_port = parseInt(parts[2]); |
290 chrome.test.runTests([testSocketCreation, testSending]); | 443 console.log("Running tests for TCP, echo server " + |
291 } else { | 444 tcp_address + ":" + tcp_port); |
292 chrome.test.fail("Invalid test type: " + test_type); | 445 tests = tests.concat([testSocketCreation, testSending]); |
| 446 } else if (test_type == 'https') { |
| 447 https_address = parts[1]; |
| 448 https_port = parseInt(parts[2]); |
| 449 console.log("Running tests for HTTPS, server " + |
| 450 https_address + ":" + https_port); |
| 451 tests = tests.concat([testSecure]); |
| 452 } else { |
| 453 chrome.test.fail("Invalid test type: " + test_type); |
| 454 } |
293 } | 455 } |
| 456 // Setup the suite-wide event listeners. |
| 457 chrome.sockets.tcp.onReceive.addListener(dispatchSocketReceive); |
| 458 chrome.sockets.tcp.onReceiveError.addListener(dispatchSocketReceiveError); |
| 459 |
| 460 chrome.test.runTests(tests); |
294 }; | 461 }; |
295 | 462 |
296 // Find out which protocol we're supposed to test, and which echo server we | 463 // Find out which protocol we're supposed to test, and which echo server we |
297 // should be using, then kick off the tests. | 464 // should be using, then kick off the tests. |
298 chrome.test.sendMessage("info_please", onMessageReply); | 465 chrome.test.sendMessage("info_please", onMessageReply); |
OLD | NEW |