[CRD iOS] Fix the leaky RemotingClient

remoting/ios/session/remoting_client.mm

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 #import "remoting/ios/session/remoting_client.h"
 
@@ skipping 18 matching lines @@
 NSString* const kHostSessionStatusChanged = @"kHostSessionStatusChanged";
 NSString* const kHostSessionPinProvided = @"kHostSessionPinProvided";
 
 NSString* const kSessionDetails = @"kSessionDetails";
 NSString* const kSessonStateErrorCode = @"kSessonStateErrorCode";
 NSString* const kHostSessionPin = @"kHostSessionPin";
 
 @interface RemotingClient () {
   remoting::ChromotingClientRuntime* _runtime;
   std::unique_ptr<remoting::ChromotingSession> _session;
-  remoting::RemotingClientSessonDelegate* _sessonDelegate;
+  std::unique_ptr<remoting::RemotingClientSessonDelegate> _sessonDelegate;
   ClientSessionDetails* _sessionDetails;
   // Call _secretFetchedCallback on the network thread.
   remoting::protocol::SecretFetchedCallback _secretFetchedCallback;
   std::unique_ptr<remoting::RendererProxy> _renderer;
   std::unique_ptr<remoting::GestureInterpreter> _gestureInterpreter;
   //  std::unique_ptr<remoting::KeyboardInterpreter> _keyboardInterpreter;
 }
 @end
 
 @implementation RemotingClient
 
 @synthesize displayHandler = _displayHandler;
 
 - (instancetype)init {
   self = [super init];
   if (self) {
     _runtime = remoting::ChromotingClientRuntime::GetInstance();
-    _sessonDelegate = new remoting::RemotingClientSessonDelegate(self);
+    _sessonDelegate.reset(new remoting::RemotingClientSessonDelegate(self));
     _sessionDetails = [[ClientSessionDetails alloc] init];
 
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(hostSessionPinProvided:)
                name:kHostSessionPinProvided
              object:nil];
   }
   return self;
 }
@@ skipping 24 matching lines @@
   // info.capabilities =
   // info.flags =
   // info.host_version =
   // info.host_os =
   // info.host_os_version =
 
   remoting::protocol::ClientAuthenticationConfig client_auth_config;
   client_auth_config.host_id = info.host_id;
   client_auth_config.pairing_client_id = info.pairing_id;
   client_auth_config.pairing_secret = info.pairing_secret;
+
+  // ChromotingClient keeps strong reference to |client_auth_config| through its
+  // lifetime.
+  __weak RemotingClient* weakSelf = self;
   client_auth_config.fetch_secret_callback = base::BindBlockArc(
       ^(bool pairing_supported, const remoting::protocol::SecretFetchedCallback&
                                     secret_fetched_callback) {
-        _secretFetchedCallback = secret_fetched_callback;
-        _sessionDetails.state = SessionPinPrompt;
+        RemotingClient* strongSelf = weakSelf;
+        if (!strongSelf) {
+          return;
+        }
+        strongSelf->_secretFetchedCallback = secret_fetched_callback;
+        strongSelf->_sessionDetails.state = SessionPinPrompt;
         [[NSNotificationCenter defaultCenter]
             postNotificationName:kHostSessionStatusChanged
-                          object:self
+                          object:weakSelf
                         userInfo:[NSDictionary
-                                     dictionaryWithObject:_sessionDetails
+                                     dictionaryWithObject:strongSelf
+                                                              ->_sessionDetails
                                                    forKey:kSessionDetails]];
       });
 
   // TODO(nicholss): Add audio support to iOS.
   base::WeakPtr<remoting::protocol::AudioStub> audioPlayer = nullptr;
 
   _displayHandler = [[GlDisplayHandler alloc] init];
   _displayHandler.delegate = self;
 
   _session.reset(new remoting::ChromotingSession(
       _sessonDelegate->GetWeakPtr(), [_displayHandler CreateCursorShapeStub],
       [_displayHandler CreateVideoRenderer], audioPlayer, info,
       client_auth_config));
 
   _renderer = [_displayHandler CreateRendererProxy];
 
   _gestureInterpreter.reset(
       new remoting::GestureInterpreter(_renderer.get(), _session.get()));
 
   _session->Connect();
 }
 
 - (void)disconnectFromHost {
   if (_session) {
     _session->Disconnect();
+    _runtime->network_task_runner()->DeleteSoon(FROM_HERE, _session.release());
   }
   _displayHandler = nil;
-  // TODO(nicholss): Do we need to cleanup more?
+
+  // This needs to be deleted on the display thread since GlDisplayHandler binds
+  // its WeakPtrFactory to the display thread.
+  // TODO(yuweih): Ideally this constraint can be removed once we allow
+  // GlRenderer to be created on the UI thread before being used.
+  if (_renderer) {
+    _runtime->display_task_runner()->DeleteSoon(FROM_HERE, _renderer.release());
+  }
 }
 
 #pragma mark - Eventing
 
 - (void)hostSessionPinProvided:(NSNotification*)notification {
   NSString* pin = [[notification userInfo] objectForKey:kHostSessionPin];
   if (_secretFetchedCallback) {
     _runtime->network_task_runner()->PostTask(
         FROM_HERE, base::BindBlockArc(^{
           _secretFetchedCallback.Run(base::SysNSStringToUTF8(pin));
@@ skipping 86 matching lines @@
 
 - (void)canvasSizeChanged:(CGSize)size {
   _gestureInterpreter->OnDesktopSizeChanged(size.width, size.height);
 }
 
 - (void)rendererTicked {
   _gestureInterpreter->ProcessAnimations();
 }
 
 @end