Refs #220, fix sslproto memory leak

There were two issues: 1) at `connection_lost()` the timeout handle
was never cancelled because getting a cdef property on a cdef class
with `getattr` always return `None`, and 2) for now cancelling a
uvloop timeout handle only clears references to call arguments but
not the callback object itself, therefore the closure is now a part
of the arguments to avoid SSLProtocol object stays in memory until
the cancelled timeout handle actually get deallocated.

Author: fantix

tests/test_tcp.py

@@ -2651,6 +2651,33 @@ async def test():
             else:
                 self.fail('Unexpected ResourceWarning: {}'.format(cm.warning))
 
+    def test_handshake_timeout_handler_leak(self):
+        s = socket.socket(socket.AF_INET)
+        s.bind(('127.0.0.1', 0))
+        s.listen(1)
+        addr = s.getsockname()
+
+        async def test(ctx):
+            try:
+                await asyncio.wait_for(
+                    self.loop.create_connection(asyncio.Protocol, *addr, ssl=ctx),
+                    0.1, loop=self.loop)
+            except (ConnectionRefusedError, asyncio.TimeoutError):
+                pass
+            else:
+                self.fail('TimeoutError is not raised')
+
+        with s:
+            ctx = ssl.create_default_context()
+            self.loop.run_until_complete(test(ctx))
+            ctx = weakref.ref(ctx)
+
+        # SSLProtocol should be DECREF to 0
+        gc.collect()
+        gc.collect()
+        gc.collect()
+        self.assertIsNone(ctx())
+
 
 class Test_UV_TCPSSL(_TestSSL, tb.UVTestCase):
     pass

uvloop/sslproto.pyx

@@ -341,9 +341,9 @@ cdef class SSLProtocol:
         self._app_transport = None
         self._wakeup_waiter(exc)
 
-        if getattr(self, '_shutdown_timeout_handle', None):
+        if self._shutdown_timeout_handle:
             self._shutdown_timeout_handle.cancel()
-        if getattr(self, '_handshake_timeout_handle', None):
+        if self._handshake_timeout_handle:
             self._handshake_timeout_handle.cancel()
 
     def get_buffer(self, n):
@@ -453,8 +453,11 @@ cdef class SSLProtocol:
         self._set_state(DO_HANDSHAKE)
 
         # start handshake timeout count down
+        # XXX: This is a workaround to call cdef method and clear reference to self when
+        # the handle is cancelled (because uvloop currently clears only args)
         self._handshake_timeout_handle = \
             self._loop.call_later(self._ssl_handshake_timeout,
+                                  lambda x: x(),
                                   lambda: self._check_handshake_timeout())
 
         try:
@@ -533,8 +536,11 @@ cdef class SSLProtocol:
             self._abort(None)
         else:
             self._set_state(FLUSHING)
+            # XXX: This is a workaround to call cdef method and clear reference to self
+            # when the handle is cancelled (because uvloop currently clears only args)
             self._shutdown_timeout_handle = \
                 self._loop.call_later(self._ssl_shutdown_timeout,
+                                      lambda x: x(),
                                       lambda: self._check_shutdown_timeout())
             self._do_flush()