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 {
+
+struct {
+  bool operator()(base::WeakPtr<Drawable> a, base::WeakPtr<Drawable> b) {
+    return a->ZIndex() < b->ZIndex();
+  }
+} DrawableZOrderComparator;
+}
+
 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) {
+  if (canvas_) {
+    drawable->SetCanvas(canvas_->GetWeakPtr());
+  } else {
+    drawable->SetCanvas(nullptr);
+  }
+  drawables_.push_back(drawable);
+  std::sort(drawables_.begin(), drawables_.end(), DrawableZOrderComparator);
+}
+
 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());
+  renderer->AddDrawable(renderer->cursor_.GetWeakPtr());
+  renderer->AddDrawable(renderer->cursor_feedback_.GetWeakPtr());
+  return renderer;
+}
+
 }  // namespace remoting