Adding the iOS app and integration example with GlRenderer.

remoting/client/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_GL_RENDERER_H_
 #define REMOTING_CLIENT_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/gl_cursor.h"
 #include "remoting/client/gl_cursor_feedback.h"
 #include "remoting/client/gl_desktop.h"
 #include "remoting/proto/control.pb.h"
 
@@ skipping 65 matching lines @@
   // surface is recreated.
   void OnSurfaceCreated(int gl_version);
 
   // 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(GlDrawable* drawable);

[Yuwei, 2016/12/19 23:26:09]

Could we just make the class own the drawable? Holding raw pointer may cause
burden to maintain the order of destruction. What about passing and storing
std::unique_ptr?

Currently the way this class works is the caller sets the position of the cursor
and the desktop image, etc., then the class will just render out the result, so
how the canvas is drawn/the GlDrawable stuff seem to be an implementation detail
to me. I feel that it's clearer to provide a function like DrawDemoScreen() and
make the demo screen a part of the renderer.

Anyway it's still up to you to decide whether the user is allowed to add extra
drawables to the renderer O_o

[Yuwei, 2016/12/19 23:54:19]

I meant something like ShouldDrawDemoScreen(boolean). Not a function similar to
Draw()...

+
   // Returns the weak pointer to be used on the display thread.
   base::WeakPtr<GlRenderer> GetWeakPtr();
 
  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();
@@ skipping 14 matching lines @@
 
   int canvas_width_ = 0;
   int canvas_height_ = 0;
 
   std::unique_ptr<GlCanvas> canvas_;
 
   GlCursor cursor_;
   GlCursorFeedback cursor_feedback_;
   GlDesktop desktop_;
 
+  std::vector<GlDrawable*> drawables;

[joedow, 2016/12/19 23:56:26]

Does order of the drawing matter?  Maybe add a comment on whether it does or
not.

[joedow, 2016/12/19 23:56:26]

Is a raw* the right thing?  Can ownership be transferred or perhaps use a
WeakPtr here?

[joedow, 2016/12/19 23:56:26]

s/drawables/drawables_

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