[Chromoting] Implement GlRenderer

remoting/client/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/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/gl_renderer_delegate.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() {
+}
+
+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_);
+  }
+}
+
+void GlRenderer::OnPixelTransformationChanged(
+    const std::array<float, 9>& matrix) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  std::array<float, 9> normalized_matrix = matrix;
+  NormalizeTransformationMatrix(view_width_, view_height_, canvas_width_,
+                                canvas_height_, &normalized_matrix);
+  canvas_->SetNormalizedTransformation(normalized_matrix);
+  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(static_cast<float>(x) / canvas_width_,
+                                  static_cast<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 (delegate_) {
+      delegate_->OnSizeChanged(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;
+  if (!delegate_ || !delegate_->CanRenderFrame()) {
+    return;
+  }
+
+  glClear(GL_COLOR_BUFFER_BIT);
+  desktop_.Draw();
+  cursor_.Draw();
+  if (cursor_feedback_.Draw()) {
+    RequestRender();
+  }
+
+  delegate_->OnFrameRendered();
+
+  while (!pending_done_callbacks_.empty()) {
+    pending_done_callbacks_.front().Run();
+    pending_done_callbacks_.pop();
+  }
+}
+
+}  // namespace remoting