[Chromoting] Unit Tests for 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
index 011cea388bdf7326833f90479d69fb1df9153bdb..138af595bacb6c56e286544fb19c4a4961388ec6 100644
--- a/remoting/client/gl_renderer.cc
+++ b/remoting/client/gl_renderer.cc
@@ -6,16 +6,16 @@
 
 #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();
@@ -32,38 +32,41 @@ void GlRenderer::SetDelegate(base::WeakPtr<GlRendererDelegate> 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();
 }
 
@@ -71,67 +74,45 @@ 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;
@@ -139,10 +120,7 @@ void GlRenderer::OnRender() {
     return;
   }
 
-  glClear(GL_COLOR_BUFFER_BIT);
-  desktop_.Draw();
-  cursor_.Draw();
-  if (cursor_feedback_.Draw()) {
+  if (core_->DrawFrame()) {
     RequestRender();
   }