Adding drawable to CRD andorid and iOS gl rendering pipeline.

remoting/client/jni/jni_gl_display_handler.cc

Index: remoting/client/jni/jni_gl_display_handler.cc
diff --git a/remoting/client/jni/jni_gl_display_handler.cc b/remoting/client/jni/jni_gl_display_handler.cc
index 42b2676db8c4a4453883c0ceb9d9f9d1cb1b74da..9a2f2b11e6143ee05e036d0e1658d954b281b3ea 100644
--- a/remoting/client/jni/jni_gl_display_handler.cc
+++ b/remoting/client/jni/jni_gl_display_handler.cc
@@ -13,6 +13,7 @@
 #include "base/memory/ptr_util.h"
 #include "jni/GlDisplay_jni.h"
 #include "remoting/client/cursor_shape_stub_proxy.h"
+#include "remoting/client/display/gl_canvas.h"
 #include "remoting/client/dual_buffer_frame_consumer.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
 #include "remoting/client/jni/egl_thread_context.h"
@@ -62,7 +63,7 @@ class JniGlDisplayHandler::Core : public protocol::CursorShapeStub,
 
   ANativeWindow* window_ = nullptr;
   std::unique_ptr<EglThreadContext> egl_context_;
-  GlRenderer renderer_;
+  std::unique_ptr<GlRenderer> renderer_;
 
   // Used on display thread.
   base::WeakPtr<Core> weak_ptr_;
@@ -74,12 +75,13 @@ class JniGlDisplayHandler::Core : public protocol::CursorShapeStub,
 JniGlDisplayHandler::Core::Core(ChromotingJniRuntime* runtime,
                                 base::WeakPtr<JniGlDisplayHandler> shell)
     : runtime_(runtime), shell_(shell), weak_factory_(this) {
+  renderer_ = std::move(GlRenderer::CreateGlRendererWithDesktop());
   weak_ptr_ = weak_factory_.GetWeakPtr();
-  renderer_.SetDelegate(weak_ptr_);
+  renderer_->SetDelegate(weak_ptr_);
   owned_frame_consumer_.reset(new DualBufferFrameConsumer(
-          base::Bind(&GlRenderer::OnFrameReceived, renderer_.GetWeakPtr()),
-          runtime_->display_task_runner(),
-          protocol::FrameConsumer::PixelFormat::FORMAT_RGBA));
+      base::Bind(&GlRenderer::OnFrameReceived, renderer_->GetWeakPtr()),
+      runtime_->display_task_runner(),
+      protocol::FrameConsumer::PixelFormat::FORMAT_RGBA));
   frame_consumer_ = owned_frame_consumer_->GetWeakPtr();
 }
 
@@ -107,7 +109,7 @@ void JniGlDisplayHandler::Core::OnSizeChanged(int width, int height) {
 void JniGlDisplayHandler::Core::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  renderer_.OnCursorShapeChanged(cursor_shape);
+  renderer_->OnCursorShapeChanged(cursor_shape);
 }
 
 std::unique_ptr<protocol::FrameConsumer>
@@ -121,12 +123,16 @@ void JniGlDisplayHandler::Core::SurfaceCreated(
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
   DCHECK(!egl_context_);
   DCHECK(!window_);
-  renderer_.RequestCanvasSize();
+  renderer_->RequestCanvasSize();
   window_ = ANativeWindow_fromSurface(base::android::AttachCurrentThread(),
                                       surface.obj());
   egl_context_.reset(new EglThreadContext());
   egl_context_->BindToWindow(window_);
-  renderer_.OnSurfaceCreated(static_cast<int>(egl_context_->client_version()));
+
+  std::unique_ptr canvas(
+      new GlCanvas(static_cast<int>(egl_context_->client_version())));
+  renderer_->OnSurfaceCreated(std::move(canvas));

[Yuwei, 2017/01/09 20:28:52]

Maybe use MakeUnique?

renderer_->OnSurfaceCreated(base::MakeUnique<GlCanvas>(static_cast<int>(...))

[nicholss, 2017/01/09 20:39:24]

does that make the code more clean? Seems like this change would just make it
confusing to me.

[Yuwei, 2017/01/09 22:41:54]

This is just a helper function to avoid wrapping the raw pointer and
std::mov'ing it. It's up to you though.

+
   runtime_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DualBufferFrameConsumer::RequestFullDesktopFrame,
                             frame_consumer_));
@@ -134,14 +140,14 @@ void JniGlDisplayHandler::Core::SurfaceCreated(
 
 void JniGlDisplayHandler::Core::SurfaceChanged(int width, int height) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  renderer_.OnSurfaceChanged(width, height);
+  renderer_->OnSurfaceChanged(width, height);
 }
 
 void JniGlDisplayHandler::Core::SurfaceDestroyed() {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
   DCHECK(egl_context_);
   DCHECK(window_);
-  renderer_.OnSurfaceDestroyed();
+  renderer_->OnSurfaceDestroyed();
   egl_context_.reset();
   ANativeWindow_release(window_);
   window_ = nullptr;
@@ -150,24 +156,24 @@ void JniGlDisplayHandler::Core::SurfaceDestroyed() {
 void JniGlDisplayHandler::Core::SetTransformation(
     const std::array<float, 9>& matrix) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  renderer_.OnPixelTransformationChanged(matrix);
+  renderer_->OnPixelTransformationChanged(matrix);
 }
 
 void JniGlDisplayHandler::Core::MoveCursor(float x, float y) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  renderer_.OnCursorMoved(x, y);
+  renderer_->OnCursorMoved(x, y);
 }
 
 void JniGlDisplayHandler::Core::SetCursorVisibility(bool visible) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  renderer_.OnCursorVisibilityChanged(visible);
+  renderer_->OnCursorVisibilityChanged(visible);
 }
 
 void JniGlDisplayHandler::Core::StartInputFeedback(float x,
                                                    float y,
                                                    float diameter) {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
-  renderer_.OnCursorInputFeedback(x, y, diameter);
+  renderer_->OnCursorInputFeedback(x, y, diameter);
 }
 
 base::WeakPtr<JniGlDisplayHandler::Core>