[Chromoting] Unit Tests for 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/memory/ptr_util.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_core.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() :
+    core_(GlRendererCore::CreateCore()),
     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_);
+    delegate_->OnSizeChanged(core_->GetCanvasWidth(), core_->GetCanvasHeight());
   }
 }
 
+void GlRenderer::RequestRender() {
+  if (render_scheduled_) {
+    return;
+  }
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&GlRenderer::OnRender, weak_ptr_));
+  render_scheduled_ = true;
+}
+
 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);
+  core_->SetPixelTransformation(matrix);
   RequestRender();
 }
 
 void GlRenderer::OnCursorMoved(int x, int y) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  cursor_.SetCursorPosition(x, y);
+  core_->MoveCursor(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_);
+  core_->StartFeedbackAnimation(x, y, diameter);
   RequestRender();
 }
 
 void GlRenderer::OnCursorVisibilityChanged(bool visible) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  cursor_.SetCursorVisible(visible);
+  core_->SetCursorVisibility(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 (core_->GetCanvasWidth() != frame->size().width() ||
+      core_->GetCanvasHeight() != 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_);
+    core_->SetCanvasSize(frame->size().width(), frame->size().height());
   }
 
-  desktop_.SetVideoFrame(std::move(frame));
+  core_->SetDesktopFrame(*frame);
   pending_done_callbacks_.push(done);
   RequestRender();
 }
 
 void GlRenderer::OnCursorShapeChanged(const protocol::CursorShapeInfo& shape) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  cursor_.SetCursorShape(shape);
+  core_->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());
+  core_->CreateCanvas(gl_version);
 }
 
 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;
+  core_->SetViewSize(view_width, view_height);
   RequestRender();
 }
 
 void GlRenderer::OnSurfaceDestroyed() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  cursor_feedback_.SetCanvas(nullptr);
-  cursor_.SetCanvas(nullptr);
-  desktop_.SetCanvas(nullptr);
-  canvas_.reset();
+  core_->DestroyCanvas();
 }
 
 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()) {
+  if (core_->DrawFrame()) {
     RequestRender();
   }
 
   delegate_->OnFrameRendered();
 
   while (!pending_done_callbacks_.empty()) {
     pending_done_callbacks_.front().Run();
     pending_done_callbacks_.pop();
   }
 }
 
 }  // namespace remoting