Moving the GL implementation details into a sub folder for client display.

remoting/client/display/gl_renderer.cc

Index: remoting/client/display/gl_renderer.cc
diff --git a/remoting/client/gl_renderer.cc b/remoting/client/display/gl_renderer.cc
similarity index 67%
rename from remoting/client/gl_renderer.cc
rename to remoting/client/display/gl_renderer.cc
index 64ce7d31d537b0db9870ebe1a8a77bcb631153f5..c2bfc4096fc209a57c3dbc200d863b55cdbe8d9f 100644
--- a/remoting/client/gl_renderer.cc
+++ b/remoting/client/display/gl_renderer.cc
@@ -2,26 +2,31 @@
 // 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 "remoting/client/display/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/display/gl_canvas.h"
+#include "remoting/client/display/gl_math.h"
+#include "remoting/client/display/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();
+GlRenderer::GlRenderer() : weak_factory_(this) {
   thread_checker_.DetachFromThread();
 }
 
-GlRenderer::~GlRenderer() {
+GlRenderer::~GlRenderer() {}

[nicholss, 2017/01/03 23:14:34]

This change leaked into this CL, this was not intended. 

+
+GlRenderer* GlRenderer::CreateGlRendererWithDesktop() {
+  GlRenderer* renderer = new GlRenderer();
+  renderer->AddDrawable(renderer->desktop_.GetWeakPtr());
+  renderer->AddDrawable(renderer->cursor_.GetWeakPtr());
+  renderer->AddDrawable(renderer->cursor_feedback_.GetWeakPtr());
+  return renderer;
 }
 
 void GlRenderer::SetDelegate(base::WeakPtr<GlRendererDelegate> delegate) {
@@ -41,31 +46,35 @@ void GlRenderer::OnPixelTransformationChanged(
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!canvas_) {
     LOG(WARNING) << "Trying to set transformation matrix when the canvas is "
-        "not ready.";
+                    "not ready.";
     return;
   }
   canvas_->SetTransformationMatrix(matrix);
   RequestRender();
 }
 
+// TODO(nicholss): This method seems like it should not be in this class.
 void GlRenderer::OnCursorMoved(float x, float y) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cursor_.SetCursorPosition(x, y);
   RequestRender();
 }
 
+// TODO(nicholss): This method seems like it should not be in this class.
 void GlRenderer::OnCursorInputFeedback(float x, float y, float diameter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cursor_feedback_.StartAnimation(x, y, diameter);
   RequestRender();
 }
 
+// TODO(nicholss): This method seems like it should not be in this class.
 void GlRenderer::OnCursorVisibilityChanged(bool visible) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cursor_.SetCursorVisible(visible);
   RequestRender();
 }
 
+// TODO(nicholss): This method seems like it should not be in this class.
 void GlRenderer::OnFrameReceived(std::unique_ptr<webrtc::DesktopFrame> frame,
                                  const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -84,6 +93,7 @@ void GlRenderer::OnFrameReceived(std::unique_ptr<webrtc::DesktopFrame> frame,
   RequestRender();
 }
 
+// TODO(nicholss): This method seems like it should not be in this class.
 void GlRenderer::OnCursorShapeChanged(const protocol::CursorShapeInfo& shape) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cursor_.SetCursorShape(shape);
@@ -92,17 +102,10 @@ void GlRenderer::OnCursorShapeChanged(const protocol::CursorShapeInfo& shape) {
 
 void GlRenderer::OnSurfaceCreated(int gl_version) {
   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_.reset(GlCanvas::CreateGlCanvas(gl_version));
+  for (auto& drawable : drawables_) {
+    drawable->SetCanvas(canvas_.get());
+  }
 }
 
 void GlRenderer::OnSurfaceChanged(int view_width, int view_height) {
@@ -117,14 +120,14 @@ void GlRenderer::OnSurfaceChanged(int view_width, int view_height) {
 
 void GlRenderer::OnSurfaceDestroyed() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  cursor_feedback_.SetCanvas(nullptr);
-  cursor_.SetCanvas(nullptr);
-  desktop_.SetCanvas(nullptr);
+  for (auto& drawable : drawables_) {
+    drawable->SetCanvas(nullptr);
+  }
   canvas_.reset();
 }
 
 base::WeakPtr<GlRenderer> GlRenderer::GetWeakPtr() {
-  return weak_ptr_;
+  return weak_factory_.GetWeakPtr();
 }
 
 void GlRenderer::RequestRender() {
@@ -133,32 +136,32 @@ void GlRenderer::RequestRender() {
     return;
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&GlRenderer::OnRender, weak_ptr_));
+      FROM_HERE, base::Bind(&GlRenderer::OnRender, GetWeakPtr()));
   render_scheduled_ = true;
 }
 
+void GlRenderer::AddDrawable(base::WeakPtr<GlDrawable> drawable) {
+  drawable->SetCanvas(canvas_.get());
+  drawables_.push_back(drawable);
+  std::sort(drawables_.begin(), drawables_.end(),
+            drawable::DrawablesZOrderComparator);
+}
+
 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()) {