[Chromoting] Implement GlRenderer

remoting/client/gl_renderer.cc

Index: remoting/client/gl_renderer.cc
diff --git a/remoting/client/gl_renderer.cc b/remoting/client/gl_renderer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b5c061c16a2401a9f5ff1d281c10327df24c3349
--- /dev/null
+++ b/remoting/client/gl_renderer.cc
@@ -0,0 +1,158 @@
+// 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/gl_renderer.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "remoting/client/gl_canvas.h"
+#include "remoting/client/gl_math.h"
+#include "remoting/client/sys_opengl.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+
+namespace remoting {
+
+GlRenderer::GlRenderer() :
+    weak_factory_(this) {
+  weak_ptr_ = weak_factory_.GetWeakPtr();
+  thread_checker_.DetachFromThread();
+}
+
+GlRenderer::~GlRenderer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+void GlRenderer::SetRenderCallback(const RenderCallback& callback) {
+  DCHECK(!render_callback_);
+  render_callback_ = callback;
+}
+
+void GlRenderer::SetCanvasSizeChangedCallback(const SizeCallback& callback) {
+  DCHECK(!canvas_size_changed_callback_);
+  canvas_size_changed_callback_ = callback;
+}
+
+void GlRenderer::RequestCanvasSize() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  canvas_size_changed_callback_.Run(canvas_width_, canvas_height_);
+}
+
+void GlRenderer::OnPixelTransformationChanged(
+    std::unique_ptr<std::array<float, 9>> mat) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  NormalizeTransformationMatrix(view_width_, view_height_, canvas_width_,
+                                canvas_height_, mat.get());
+  canvas_->SetNormalizedTransformation(*mat.get());
+  RequestRender();
+}
+
+void GlRenderer::OnCursorMoved(int x, int y) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  cursor_.SetCursorPosition(x, y);
+  RequestRender();
+}
+
+void GlRenderer::OnCursorInputFeedback(int x, int y, float diameter) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  cursor_feedback_.StartAnimation(((float) x) / canvas_width_,
+                                  ((float) y) / canvas_height_,
+                                  diameter / canvas_width_,
+                                  diameter / canvas_height_);
+  RequestRender();
+}
+
+void GlRenderer::OnCursorVisibilityChanged(bool visible) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  cursor_.SetCursorVisible(visible);
+  RequestRender();
+}
+
+void GlRenderer::OnFrameReceived(std::unique_ptr<webrtc::DesktopFrame> frame,
+                                 const base::Closure& done) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(frame->size().width() > 0 && frame->size().height() > 0);
+  if (canvas_width_ != frame->size().width() ||
+      canvas_height_ != frame->size().height()) {
+    if (canvas_size_changed_callback_) {
+      canvas_size_changed_callback_.Run(frame->size().width(),
+                                        frame->size().height());
+    }
+    canvas_width_ = frame->size().width();
+    canvas_height_ = frame->size().height();
+    cursor_.SetCanvasSize(canvas_width_, canvas_height_);
+  }
+
+  desktop_.SetVideoFrame(std::move(frame));
+  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) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Set the background clear color to black.
+  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+  canvas_.reset(new GlCanvas(gl_version));
+  desktop_.SetCanvas(canvas_.get());
+  cursor_.SetCanvas(canvas_.get());
+  cursor_feedback_.SetCanvas(canvas_.get());
+}
+
+void GlRenderer::OnSurfaceChanged(int view_width, int view_height) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(view_width > 0 && view_height > 0);
+  glViewport(0, 0, view_width, view_height);
+  view_width_ = view_width;
+  view_height_ = view_height;
+  RequestRender();
+}
+
+void GlRenderer::OnSurfaceDestroyed() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  cursor_feedback_.SetCanvas(nullptr);
+  cursor_.SetCanvas(nullptr);
+  desktop_.SetCanvas(nullptr);
+  canvas_.reset();
+}
+
+base::WeakPtr<GlRenderer> GlRenderer::GetWeakPtr() {
+  return weak_ptr_;
+}
+
+void GlRenderer::RequestRender() {
+  if (render_scheduled_) {
+    return;
+  }
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&GlRenderer::OnRender, weak_ptr_));
+  render_scheduled_ = true;
+}
+
+void GlRenderer::OnRender() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  render_scheduled_ = false;
+  render_callback_.Run(base::Bind(&GlRenderer::OnDrawFrame, weak_ptr_));
+}
+
+void GlRenderer::OnDrawFrame() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  glClear(GL_COLOR_BUFFER_BIT);
+  desktop_.Draw();
+  cursor_.Draw();
+  if (cursor_feedback_.Draw()) {
+    RequestRender();
+  }
+  while (!pending_done_callbacks_.empty()) {
+    pending_done_callbacks_.front().Run();
+    pending_done_callbacks_.pop();
+  }
+}
+
+}  // namespace remoting