Adding drawable to CRD andorid and iOS gl rendering pipeline.

remoting/client/display/gl_renderer.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/display/gl_renderer.h"
 
+#include <algorithm>
+
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "remoting/client/display/drawable.h"
 #include "remoting/client/display/gl_canvas.h"
 #include "remoting/client/display/gl_math.h"
 #include "remoting/client/display/gl_renderer_delegate.h"
 #include "remoting/client/display/sys_opengl.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace remoting {
 
+namespace {
+
+bool CompareDrawableZOrder(base::WeakPtr<Drawable> a,
+                           base::WeakPtr<Drawable> b) {
+  return a->GetZIndex() < b->GetZIndex();
+}
+
+}  // namespace
+
 GlRenderer::GlRenderer() :
     weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
 
-GlRenderer::~GlRenderer() {
-}
+GlRenderer::~GlRenderer() {}
 
 void GlRenderer::SetDelegate(base::WeakPtr<GlRendererDelegate> delegate) {
   DCHECK(!delegate_);
   delegate_ = delegate;
 }
 
 void GlRenderer::RequestCanvasSize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (delegate_) {
     delegate_->OnSizeChanged(canvas_width_, canvas_height_);
@@ skipping 47 matching lines @@
   pending_done_callbacks_.push(done);
   RequestRender();
 }
 
 void GlRenderer::OnCursorShapeChanged(const protocol::CursorShapeInfo& shape) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cursor_.SetCursorShape(shape);
   RequestRender();
 }
 
-void GlRenderer::OnSurfaceCreated(int gl_version) {
+void GlRenderer::OnSurfaceCreated(std::unique_ptr<Canvas> canvas) {
   DCHECK(thread_checker_.CalledOnValidThread());
-#ifndef NDEBUG
-  // Set the background clear color to bright green for debugging purposes.
-  glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
-#else
-  // Set the background clear color to black.
-  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-#endif
-  canvas_.reset(new GlCanvas(gl_version));
-  desktop_.SetCanvas(canvas_.get());
-  cursor_.SetCanvas(canvas_.get());
-  cursor_feedback_.SetCanvas(canvas_.get());
+  canvas_ = std::move(canvas);
+  for (auto& drawable : drawables_) {
+    drawable->SetCanvas(canvas_->GetWeakPtr());
+  }
 }
 
 void GlRenderer::OnSurfaceChanged(int view_width, int view_height) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!canvas_) {
     LOG(WARNING) << "Trying to set the view size when the canvas is not ready.";
     return;
   }
   canvas_->SetViewSize(view_width, view_height);
   RequestRender();
@@ skipping 14 matching lines @@
 void GlRenderer::RequestRender() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (render_scheduled_) {
     return;
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&GlRenderer::OnRender, weak_ptr_));
   render_scheduled_ = true;
 }
 
+void GlRenderer::AddDrawable(base::WeakPtr<Drawable> drawable) {
+  drawable->SetCanvas(canvas_ ? canvas_->GetWeakPtr() : nullptr);
+  drawables_.push_back(drawable);
+  std::sort(drawables_.begin(), drawables_.end(), CompareDrawableZOrder);
+}
+
 void GlRenderer::OnRender() {
   DCHECK(thread_checker_.CalledOnValidThread());
   render_scheduled_ = false;
   if (!delegate_ || !delegate_->CanRenderFrame()) {
     return;
   }
 
   if (canvas_) {
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    // Layers will be drawn from bottom to top.
-    desktop_.Draw();
-
-    // |cursor_feedback_| should be drawn before |cursor_| so that the cursor
-    // won't be covered by the feedback animation.
-    if (cursor_feedback_.Draw()) {
-      RequestRender();
+    canvas_->Clear();
+    // Draw each drawable in order.
+    for (auto& drawable : drawables_) {
+      if (drawable->Draw()) {
+        RequestRender();
+      }
     }
-
-    cursor_.Draw();
   }
 
   delegate_->OnFrameRendered();
 
   while (!pending_done_callbacks_.empty()) {
     pending_done_callbacks_.front().Run();
     pending_done_callbacks_.pop();
   }
 }
 
+std::unique_ptr<GlRenderer> GlRenderer::CreateGlRendererWithDesktop() {
+  std::unique_ptr<GlRenderer> renderer(new GlRenderer());
+  renderer->AddDrawable(renderer->desktop_.GetWeakPtr());

[Yuwei, 2017/01/12 23:23:17]

Sorry that I haven't spied the bug here. The thread checkers of these drawables
will be bound to whatever thread CreateGlRendererWithDesktop is called on.

I'll send a CL to fix this.

[joedow, 2017/01/13 15:49:44]

The thread checkers of the drawables will be initialized to the thread they were
created on (affinity is set in the c'tor of ewach drawable unless Detach is
called).  The renderer will have affinity to the thread
CreateGlRendererWithDesktop() is called on.  Not sure if that affects the
scenario you are concerned about.

+  renderer->AddDrawable(renderer->cursor_.GetWeakPtr());
+  renderer->AddDrawable(renderer->cursor_feedback_.GetWeakPtr());
+  return renderer;
+}
+
 }  // namespace remoting