Adding the iOS app and integration example with GlRenderer.

remoting/client/ios/display/gl_display_handler.mm

+// Copyright 2016 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 <Foundation/Foundation.h>
+#import <GLKit/GLKit.h>
+
+#import "remoting/client/ios/display/gl_display_handler.h"
+
+#import "remoting/client/ios/display/gl_demo_screen.h"
+
+#import "remoting/client/sys_opengl.h"
+
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.h"
+#include "remoting/client/chromoting_client.h"
+#include "remoting/client/dual_buffer_frame_consumer.h"
+#include "remoting/client/gl_renderer.h"
+#include "remoting/client/gl_renderer_delegate.h"
+#include "remoting/client/ios/app_runtime.h"
+#include "remoting/client/software_video_renderer.h"
+
+namespace remoting {
+namespace GlDisplayHandler {
+
+// The core that lives on the display thread.
+class Core :  // public protocol::CursorShapeStub,

[joedow, 2016/12/19 23:56:26]

Should CursorShapeStub be commented out?  Delete if so...

+              public GlRendererDelegate {
+ public:
+  Core(remoting::ios::AppRuntime* runtime);
+  ~Core() override;
+
+  // GlRendererDelegate interface.
+  bool CanRenderFrame() override;
+  void OnFrameRendered() override;
+  void OnSizeChanged(int width, int height) override;
+  void Draw();
+  void Created();
+  void SurfaceChanged(int width, int height);
+  std::unique_ptr<protocol::FrameConsumer> GrabFrameConsumer();
+  base::WeakPtr<Core> GetWeakPtr();
+
+ private:
+  // Will be std::move'd when GrabFrameConsumer() is called.
+  remoting::ios::AppRuntime* runtime_;
+  std::unique_ptr<DualBufferFrameConsumer> owned_frame_consumer_;
+
+  base::WeakPtr<DualBufferFrameConsumer> frame_consumer_;
+  EAGLContext* eagl_context_;
+  GlRenderer renderer_;
+  GlDemoScreen demoScreen_;

[Yuwei, 2016/12/19 23:26:09]

s/demoScreen_/demo_screen_/ ?

+
+  // Used on display thread.
+  base::WeakPtr<Core> weak_ptr_;
+  base::WeakPtrFactory<Core> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+Core::Core(remoting::ios::AppRuntime* runtime)
+    : runtime_(runtime), weak_factory_(this) {
+  weak_ptr_ = weak_factory_.GetWeakPtr();
+  renderer_.SetDelegate(weak_ptr_);
+  owned_frame_consumer_.reset(new remoting::DualBufferFrameConsumer(
+      base::Bind(&remoting::GlRenderer::OnFrameReceived,
+                 renderer_.GetWeakPtr()),
+      runtime_->display_task_runner(),
+      remoting::protocol::FrameConsumer::PixelFormat::FORMAT_RGBA));
+  frame_consumer_ = owned_frame_consumer_->GetWeakPtr();
+  renderer_.AddDrawable(&demoScreen_);
+}
+
+Core::~Core() {}
+
+bool Core::CanRenderFrame() {
+  DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
+  return eagl_context_ != NULL;  // && egl_context_->IsWindowBound();

[joedow, 2016/12/19 23:56:26]

Is the commented out condition intentional?

+}
+
+std::unique_ptr<protocol::FrameConsumer> Core::GrabFrameConsumer() {
+  // DCHECK(owned_frame_consumer_) << "The frame consumer is already grabbed.";

[joedow, 2016/12/19 23:56:26]

Why are all the DCHECKS commented out?

+  return std::move(owned_frame_consumer_);
+}
+
+void Core::OnFrameRendered() {
+  // DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
+  // egl_context_->SwapBuffers();
+  // runtime_->ui_task_runner()->PostTask(
+  //   FROM_HERE, base::Bind(&JniGlDisplayHandler::OnRenderDone, shell_));
+}
+
+void Core::OnSizeChanged(int width, int height) {
+  // DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
+  // runtime_->ui_task_runner()->PostTask(
+  //     FROM_HERE, base::Bind(&JniGlDisplayHandler::OnCanvasSizeChanged,
+  //     shell_,
+  //                           width, height));

[joedow, 2016/12/19 23:56:26]

Use NOTIMPLEMENTED() or NOTREACHED() instead of commenting out?

+}
+
+void Core::Created() {
+  //  DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
+  //  DCHECK(!egl_context_);
+  //  DCHECK(!window_);
+  eagl_context_ = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];

[Yuwei, 2016/12/19 23:26:09]

How does this work? Looks like you have created another context in
ExampleViewController...

+
+  // eagl_context_ = [EAGLContext currentContext];
+  renderer_.RequestCanvasSize();
+  //  window_ = ANativeWindow_fromSurface(base::android::AttachCurrentThread(),
+  //                                      surface.obj());
+  //  egl_context_.reset(new EglThreadContext());
+  //  egl_context_->BindToWindow(window_);
+
+  renderer_.OnSurfaceCreated([eagl_context_ API]);
+  //  runtime_->network_task_runner()->PostTask(
+  //      FROM_HERE,
+  //      base::Bind(&DualBufferFrameConsumer::RequestFullDesktopFrame,
+  //                            frame_consumer_));
+}
+
+void Core::Draw() {}
+
+void Core::SurfaceChanged(int width, int height) {
+  // DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
+  renderer_.OnSurfaceChanged(width, height);
+}
+
+base::WeakPtr<remoting::GlDisplayHandler::Core> Core::GetWeakPtr() {
+  return weak_ptr_;
+}
+
+}  // namespace GlDisplayHandler
+}  // namespace remoting
+
+@interface GlDisplayHandler ()
+@property(nonatomic) remoting::GlDisplayHandler::Core* core_;
+@property(nonatomic) remoting::ios::AppRuntime* runtime_;
+@end
+
+@implementation GlDisplayHandler
+
+@synthesize core_ = _core_;
+@synthesize runtime_ = _runtime_;
+
+- (id)initWithRuntime:(remoting::ios::AppRuntime*)runtime {
+  self.runtime_ = runtime;
+  return self;
+}
+
+- (void)created {
+  _core_ = new remoting::GlDisplayHandler::Core(self.runtime_);
+
+  self.runtime_->display_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&remoting::GlDisplayHandler::Core::Created,
+                            self.core_->GetWeakPtr()));
+}
+
+// In general, avoid expensive work in this function to maximize frame rate.
+- (void)draw {
+  self.runtime_->display_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&remoting::GlDisplayHandler::Core::Draw,
+                            self.core_->GetWeakPtr()));
+
+  //  core_->DrawFrame(std::move(frame), base::Closure());
+}
+
+- (std::unique_ptr<remoting::protocol::VideoRenderer>)CreateVideoRenderer {
+  return base::MakeUnique<remoting::SoftwareVideoRenderer>(
+      _core_->GrabFrameConsumer());
+}
+
+- (void)glkView:(GLKView*)view drawInRect:(CGRect)rect {
+  if (_core_) {
+    _core_->SurfaceChanged(rect.size.width, rect.size.height);
+  }
+}
+
+@end