[CRD iOS] Some fixes for rendering

remoting/ios/display/gl_display_handler.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
 
 #include <array>
 
@@ skipping 48 matching lines @@
   base::WeakPtr<Core> GetWeakPtr();
 
  private:
   remoting::ChromotingClientRuntime* runtime_;
 
   // Will be std::move'd when GrabFrameConsumer() is called.
   std::unique_ptr<DualBufferFrameConsumer> owned_frame_consumer_;
   base::WeakPtr<DualBufferFrameConsumer> frame_consumer_;
 
   // TODO(yuweih): Release references once the surface is destroyed.
-  GLKView* gl_view_;
   EAGLContext* eagl_context_;
   std::unique_ptr<GlRenderer> renderer_;
   //  GlDemoScreen *demo_screen_;
   id<GlDisplayHandlerDelegate> handler_delegate_;
 
   // Used on display thread.
   base::WeakPtr<Core> weak_ptr_;
   base::WeakPtrFactory<Core> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
@@ skipping 46 matching lines @@
   handler_delegate_ = delegate;
 }
 
 void Core::SetCursorShape(const protocol::CursorShapeInfo& cursor_shape) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
   renderer_->OnCursorShapeChanged(cursor_shape);
 }
 
 bool Core::CanRenderFrame() {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  return gl_view_ != NULL && eagl_context_ != NULL;
+
+  return eagl_context_ != nil;
 }
 
 std::unique_ptr<protocol::FrameConsumer> Core::GrabFrameConsumer() {
   DCHECK(owned_frame_consumer_) << "The frame consumer is already grabbed.";
   return std::move(owned_frame_consumer_);
 }
 
 void Core::OnFrameReceived(std::unique_ptr<webrtc::DesktopFrame> frame,
                            const base::Closure& done) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
   renderer_->OnFrameReceived(std::move(frame), done);
 }
 
 void Core::OnFrameRendered() {
-  [gl_view_ display];
+  [eagl_context_ presentRenderbuffer:GL_RENDERBUFFER];
 }
 
 void Core::OnSizeChanged(int width, int height) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
   runtime_->ui_task_runner()->PostTask(
       FROM_HERE, base::BindBlockArc(^() {
         [handler_delegate_ canvasSizeChanged:CGSizeMake(width, height)];
       }));
 }
 
 void Core::Stop() {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
 
   eagl_context_ = nil;
   // demo_screen_ = nil;
 }
 
 void Core::SurfaceCreated(GLKView* view) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  gl_view_ = view;
+
+  // Bind the view's framebuffer object to OpenGL.
+  [view bindDrawable];
 
   renderer_->OnSurfaceCreated(
       base::MakeUnique<GlCanvas>(static_cast<int>([eagl_context_ API])));
 
   renderer_->RequestCanvasSize();
 
   runtime_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DualBufferFrameConsumer::RequestFullDesktopFrame,
                             frame_consumer_));
 }
@@ skipping 13 matching lines @@
 }
 
 base::WeakPtr<remoting::GlDisplayHandler::Core> Core::GetWeakPtr() {
   return weak_ptr_;
 }
 
 }  // namespace GlDisplayHandler
 }  // namespace remoting
 
 @interface GlDisplayHandler () {
-  remoting::GlDisplayHandler::Core* _core;
+  std::unique_ptr<remoting::GlDisplayHandler::Core> _core;
   remoting::ChromotingClientRuntime* _runtime;
   std::unique_ptr<remoting::QueuedTaskPoster> _uiTaskPoster;
 }
 @end
 
 @implementation GlDisplayHandler
 
 - (id)init {
   self = [super init];
   if (self) {
     _runtime = remoting::ChromotingClientRuntime::GetInstance();
-    _core = new remoting::GlDisplayHandler::Core();
+    _core.reset(new remoting::GlDisplayHandler::Core());
     _uiTaskPoster.reset(
         new remoting::QueuedTaskPoster(_runtime->display_task_runner()));
   }
   return self;
 }
 
+- (void)dealloc {
+  _runtime->display_task_runner()->DeleteSoon(FROM_HERE, _core.release());
+}
+
 #pragma mark - Public
 
 - (void)stop {
   _runtime->display_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&remoting::GlDisplayHandler::Core::Stop, _core->GetWeakPtr()));
 }
 
 - (std::unique_ptr<remoting::protocol::VideoRenderer>)CreateVideoRenderer {
   return base::MakeUnique<remoting::SoftwareVideoRenderer>(
@@ skipping 37 matching lines @@
                  _core->GetWeakPtr(), delegate));
 }
 
 - (id<GlDisplayHandlerDelegate>)delegate {
   // Implementation is still required for UNAVAILABLE_ATTRIBUTE.
   NOTREACHED();
   return nil;
 }
 
 @end