Adding drawable to CRD andorid and iOS gl rendering pipeline.

remoting/client/display/gl_renderer.h

 // 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.
 
 #ifndef REMOTING_CLIENT_DISPLAY_GL_RENDERER_H_
 #define REMOTING_CLIENT_DISPLAY_GL_RENDERER_H_
 
 #include <queue>
+#include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "remoting/client/display/gl_cursor.h"
 #include "remoting/client/display/gl_cursor_feedback.h"
 #include "remoting/client/display/gl_desktop.h"
 #include "remoting/proto/control.pb.h"
 
 namespace webrtc {
 class DesktopFrame;
 }  // namespace webrtc
 
 namespace remoting {
 
 namespace protocol {
 class CursorShapeInfo;
 }  // namespace protocol
 
-class GlCanvas;
+class Canvas;
 class GlRendererDelegate;
 class GlRendererTest;
 
 // Renders desktop and cursor on the OpenGL surface. Can be created on any
 // thread but thereafter must be used and deleted on the same thread (usually
 // the display thread. Or any Chromium thread with a task runner attached to
 // it) unless otherwise noted.
 // The unit of all length arguments is pixel.
 class GlRenderer {
  public:
@@ skipping 35 matching lines @@
   void OnFrameReceived(std::unique_ptr<webrtc::DesktopFrame> frame,
                        const base::Closure& done);
 
   void OnCursorShapeChanged(const protocol::CursorShapeInfo& shape);
 
   // Called after the EGL/EAGL context is established and the surface is created
   // (or recreated). Previous desktop frame and canvas transformation will be
   // lost after calling this function.
   // Caller must call OnSurfaceDestroyed() before calling this function if the
   // surface is recreated.
-  void OnSurfaceCreated(int gl_version);
+  void OnSurfaceCreated(std::unique_ptr<Canvas> canvas);
 
   // Sets the size of the view. Called right after OnSurfaceCreated() or
   // whenever the view size is changed.
   void OnSurfaceChanged(int view_width, int view_height);
 
   // Called when the surface is destroyed.
   void OnSurfaceDestroyed();
 
+  void AddDrawable(base::WeakPtr<Drawable> drawable);
+
   // Returns the weak pointer to be used on the display thread.
   base::WeakPtr<GlRenderer> GetWeakPtr();
 
+  // Convenience method to create a Renderer with standard desktop components.
+  static std::unique_ptr<GlRenderer> CreateGlRendererWithDesktop();
+
  private:
   friend class GlRendererTest;
 
   // Post a rendering task to the task runner of current thread.
   // Do nothing if render_callback_ is not set yet or an existing rendering task
   // in the queue will cover changes before this function is called.
   void RequestRender();
 
   // Draws out everything on current OpenGL buffer and runs closures in
   // |pending_done_callbacks_|.
   // Nothing will be drawn nor the done callbacks will be run if |delegate_| is
   // invalid or !delegate_.CanRenderFrame().
   void OnRender();
 
   base::WeakPtr<GlRendererDelegate> delegate_;
 
   // Done callbacks from OnFrameReceived. Will all be called once rendering
   // takes place.
   std::queue<base::Closure> pending_done_callbacks_;
 
   bool render_scheduled_ = false;
 
   int canvas_width_ = 0;
   int canvas_height_ = 0;
 
-  std::unique_ptr<GlCanvas> canvas_;
+  std::unique_ptr<Canvas> canvas_;
 
   GlCursor cursor_;
   GlCursorFeedback cursor_feedback_;
   GlDesktop desktop_;
 
+  std::vector<base::WeakPtr<Drawable>> drawables_;

[Yuwei, 2017/01/09 20:28:52]

Is it really more useful to store a WeakPtr instead of a unique_ptr? Since
GlRenderer controls the drawable after it is added to the vector, I think it
makes more sense to make the renderer own the drawables.

Also by doing so you can get rid of the GetWeakPtr() declaration in the drawable
interface and only define it for the fake drawable, and you can also remove
those three drawables above and create them inside
CreateGlRendererWithDesktop().

[nicholss, 2017/01/09 20:39:24]

I absolutely don't want the renderer to own the drawable. I would like to push 
in and pop out drawable elements in the render stack and I want to be able 
to push messages into them from other places and have it rendered for me
automatically. Think of the MVC pattern. I don't want the V to also be the C.

[Yuwei, 2017/01/09 22:41:54]

This can still be done if you grab the WeakPtr of the Drawable before pushing it
to the renderer though.
Currently GlRenderer is for both controlling the the render behavior and
actually rendering out the stack of Drawables so it's already like V+C...

I'm good with making the controller own the Drawables but only after the
controller part is separated from GlRenderer. If you will do that later at some
point then I'm okay with this change.

+
   base::ThreadChecker thread_checker_;
   base::WeakPtr<GlRenderer> weak_ptr_;
   base::WeakPtrFactory<GlRenderer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GlRenderer);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_CLIENT_DISPLAY_GL_RENDERER_H_