Adding drawable to CRD andorid and iOS gl rendering pipeline.

remoting/client/jni/jni_gl_display_handler.cc

 // 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.
 
 #include "remoting/client/jni/jni_gl_display_handler.h"
 
 #include <android/native_window_jni.h>
 #include <array>
 
 #include "base/android/jni_android.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #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"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/protocol/frame_consumer.h"
 
 namespace remoting {
 
 // The core that lives on the display thread.
 class JniGlDisplayHandler::Core : public protocol::CursorShapeStub,
@@ skipping 29 matching lines @@
   ChromotingJniRuntime* runtime_;
   base::WeakPtr<JniGlDisplayHandler> shell_;
 
   // Will be std::move'd when GrabFrameConsumer() is called.
   std::unique_ptr<DualBufferFrameConsumer> owned_frame_consumer_;
 
   base::WeakPtr<DualBufferFrameConsumer> frame_consumer_;
 
   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_;
   base::WeakPtrFactory<Core> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 JniGlDisplayHandler::Core::Core(ChromotingJniRuntime* runtime,
                                 base::WeakPtr<JniGlDisplayHandler> shell)
     : runtime_(runtime), shell_(shell), weak_factory_(this) {
+  renderer_ = 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();
 }
 
 JniGlDisplayHandler::Core::~Core() {}
 
 bool JniGlDisplayHandler::Core::CanRenderFrame() {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
   return egl_context_ && egl_context_->IsWindowBound();
 }
 
 void JniGlDisplayHandler::Core::OnFrameRendered() {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
   egl_context_->SwapBuffers();
   runtime_->ui_task_runner()->PostTask(
       FROM_HERE, base::Bind(&JniGlDisplayHandler::OnRenderDone, shell_));
 }
 
 void JniGlDisplayHandler::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));
 }
 
 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>
 JniGlDisplayHandler::Core::GrabFrameConsumer() {
   DCHECK(owned_frame_consumer_) << "The frame consumer is already grabbed.";
   return std::move(owned_frame_consumer_);
 }
 
 void JniGlDisplayHandler::Core::SurfaceCreated(
     base::android::ScopedJavaGlobalRef<jobject> surface) {
   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()));
+
+  renderer_->OnSurfaceCreated(base::MakeUnique<GlCanvas>(
+      static_cast<int>(egl_context_->client_version())));
+
   runtime_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DualBufferFrameConsumer::RequestFullDesktopFrame,
                             frame_consumer_));
 }
 
 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;
 }
 
 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>
 JniGlDisplayHandler::Core::GetWeakPtr() {
   return weak_ptr_;
 }
 
 // Shell implementations.
 
 JniGlDisplayHandler::JniGlDisplayHandler(
@@ skipping 110 matching lines @@
                                 java_display_);
 }
 
 void JniGlDisplayHandler::OnCanvasSizeChanged(int width, int height) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   Java_GlDisplay_changeCanvasSize(base::android::AttachCurrentThread(),
                                   java_display_, width, height);
 }
 
 }  // namespace remoting