Adding drawable to CRD andorid and iOS gl rendering pipeline.

remoting/client/display/gl_renderer_unittest.cc

Index: remoting/client/display/gl_renderer_unittest.cc
diff --git a/remoting/client/display/gl_renderer_unittest.cc b/remoting/client/display/gl_renderer_unittest.cc
index 7edb9bd0e07b56910365bdfaf0b81ec846e9dabf..4068ecd90d374d6ab861e55aab491e8ef8f69b11 100644
--- a/remoting/client/display/gl_renderer_unittest.cc
+++ b/remoting/client/display/gl_renderer_unittest.cc
@@ -10,6 +10,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "remoting/client/display/fake_canvas.h"
 #include "remoting/client/display/gl_renderer_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
@@ -67,8 +68,38 @@ class FakeGlRendererDelegate : public GlRendererDelegate {
   int canvas_height_ = 0;
 
   base::Closure on_frame_rendered_callback_;
-
   base::WeakPtrFactory<FakeGlRendererDelegate> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeGlRendererDelegate);
+};
+
+class FakeDrawable : public Drawable {
+ public:
+  FakeDrawable() : weak_factory_(this) {}
+
+  void SetId(int id) { id_ = id; }
+  int GetId() { return id_; }
+
+  base::WeakPtr<Drawable> GetWeakPtr() override {
+    return weak_factory_.GetWeakPtr();
+  }
+
+  void SetCanvas(base::WeakPtr<Canvas> canvas) override {}
+
+  bool Draw() override {
+    drawn_++;
+    return false;
+  }
+
+  int DrawnCount() { return drawn_; }
+
+ private:
+  int drawn_ = 0;
+  int id_ = -1;
+
+  base::WeakPtrFactory<FakeDrawable> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeDrawable);
 };
 
 class GlRendererTest : public testing::Test {
@@ -76,6 +107,8 @@ class GlRendererTest : public testing::Test {
   void SetUp() override;
   void SetDesktopFrameWithSize(const webrtc::DesktopSize& size);
   void PostSetDesktopFrameTasks(const webrtc::DesktopSize& size, int count);
+  int GetDrawablesCount();
+  std::vector<base::WeakPtr<Drawable>> GetDrawables();
 
  protected:
   void RequestRender();
@@ -103,6 +136,14 @@ void GlRendererTest::RequestRender() {
   renderer_->RequestRender();
 }
 
+int GlRendererTest::GetDrawablesCount() {
+  return (int)renderer_->drawables_.size();

[Sergey Ulanov, 2017/01/11 22:47:31]

style guide doesn't allow c-style casts, static_cast<> can be used to cast
size_t to int, but I think in this case the compiler should cast it implicitly,
i.e. remove (int)?

[nicholss, 2017/01/11 23:43:25]

Done.

+}
+
+std::vector<base::WeakPtr<Drawable>> GlRendererTest::GetDrawables() {
+  return renderer_->drawables_;
+}
+
 void GlRendererTest::SetDesktopFrameWithSize(const webrtc::DesktopSize& size) {
   renderer_->OnFrameReceived(
       base::MakeUnique<webrtc::BasicDesktopFrame>(size),
@@ -167,24 +208,24 @@ TEST_F(GlRendererTest, TestRequestRenderOnlyScheduleOnce) {
 
 TEST_F(GlRendererTest, TestDelegateOnSizeChanged) {
   SetDesktopFrameWithSize(webrtc::DesktopSize(16, 16));
-  EXPECT_EQ(1, delegate_.on_size_changed_call_count());
-  EXPECT_EQ(16, delegate_.canvas_width());
-  EXPECT_EQ(16, delegate_.canvas_height());
+  ASSERT_EQ(1, delegate_.on_size_changed_call_count());
+  ASSERT_EQ(16, delegate_.canvas_width());
+  ASSERT_EQ(16, delegate_.canvas_height());
 
   SetDesktopFrameWithSize(webrtc::DesktopSize(16, 16));
-  EXPECT_EQ(1, delegate_.on_size_changed_call_count());
-  EXPECT_EQ(16, delegate_.canvas_width());
-  EXPECT_EQ(16, delegate_.canvas_height());
+  ASSERT_EQ(1, delegate_.on_size_changed_call_count());
+  ASSERT_EQ(16, delegate_.canvas_width());
+  ASSERT_EQ(16, delegate_.canvas_height());
 
   SetDesktopFrameWithSize(webrtc::DesktopSize(32, 32));
-  EXPECT_EQ(2, delegate_.on_size_changed_call_count());
-  EXPECT_EQ(32, delegate_.canvas_width());
-  EXPECT_EQ(32, delegate_.canvas_height());
+  ASSERT_EQ(2, delegate_.on_size_changed_call_count());
+  ASSERT_EQ(32, delegate_.canvas_width());
+  ASSERT_EQ(32, delegate_.canvas_height());
 
   renderer_->RequestCanvasSize();
-  EXPECT_EQ(3, delegate_.on_size_changed_call_count());
-  EXPECT_EQ(32, delegate_.canvas_width());
-  EXPECT_EQ(32, delegate_.canvas_height());
+  ASSERT_EQ(3, delegate_.on_size_changed_call_count());
+  ASSERT_EQ(32, delegate_.canvas_width());
+  ASSERT_EQ(32, delegate_.canvas_height());
 }
 
 TEST_F(GlRendererTest, TestOnFrameReceivedDoneCallbacks) {
@@ -199,10 +240,110 @@ TEST_F(GlRendererTest, TestOnFrameReceivedDoneCallbacks) {
 
   PostSetDesktopFrameTasks(webrtc::DesktopSize(16, 16), 20);
   RunUntilRendered();
-  EXPECT_EQ(2, delegate_.on_frame_rendered_call_count());
-  EXPECT_EQ(21, on_desktop_frame_processed_call_count());
+  ASSERT_EQ(2, delegate_.on_frame_rendered_call_count());
+  ASSERT_EQ(21, on_desktop_frame_processed_call_count());
 }
 
 // TODO(yuweih): Add tests to validate the rendered output.
 
+TEST_F(GlRendererTest, TestAddDrawable) {
+  FakeDrawable* drawable0 = new FakeDrawable();
+  drawable0->SetId(0);
+  renderer_->AddDrawable(drawable0->GetWeakPtr());
+  ASSERT_EQ(1, GetDrawablesCount());
+}
+
+TEST_F(GlRendererTest, TestAddDrawableDefaultOrder) {
+  FakeDrawable* drawable0 = new FakeDrawable();
+  drawable0->SetId(0);
+  renderer_->AddDrawable(drawable0->GetWeakPtr());
+  ASSERT_EQ(1, GetDrawablesCount());
+
+  FakeDrawable* drawable1 = new FakeDrawable();
+  drawable1->SetId(1);
+  renderer_->AddDrawable(drawable1->GetWeakPtr());
+  ASSERT_EQ(2, GetDrawablesCount());
+
+  FakeDrawable* drawable2 = new FakeDrawable();
+  drawable2->SetId(2);
+  renderer_->AddDrawable(drawable2->GetWeakPtr());
+  ASSERT_EQ(3, GetDrawablesCount());
+
+  int i = 0;
+  for (auto& drawable : GetDrawables()) {
+    FakeDrawable* fg = static_cast<FakeDrawable*>(drawable.get());
+    ASSERT_EQ(i, fg->GetId());
+    i++;
+  }
+  ASSERT_EQ(3, i);
+}
+
+TEST_F(GlRendererTest, TestAddDrawableOrder) {
+  FakeDrawable* drawable2 = new FakeDrawable();

[Sergey Ulanov, 2017/01/11 22:47:31]

I think you need to use unique_ptr<> here to ensure these are destroyed.

[nicholss, 2017/01/11 23:43:25]

Done.

+  drawable2->SetId(2);
+  drawable2->SetZIndex(2);
+  renderer_->AddDrawable(drawable2->GetWeakPtr());
+  ASSERT_EQ(1, GetDrawablesCount());
+
+  FakeDrawable* drawable0 = new FakeDrawable();
+  drawable0->SetId(0);
+  renderer_->AddDrawable(drawable0->GetWeakPtr());
+  ASSERT_EQ(2, GetDrawablesCount());
+
+  FakeDrawable* drawable1 = new FakeDrawable();
+  drawable1->SetId(1);
+  drawable1->SetZIndex(1);
+  renderer_->AddDrawable(drawable1->GetWeakPtr());
+  ASSERT_EQ(3, GetDrawablesCount());
+
+  int i = 0;
+  for (auto& drawable : GetDrawables()) {
+    FakeDrawable* fg = static_cast<FakeDrawable*>(drawable.get());
+    ASSERT_EQ(i, fg->GetId());
+    i++;
+  }
+  ASSERT_EQ(3, i);
+}
+
+TEST_F(GlRendererTest, TestAddDrawableDrawn) {
+  std::unique_ptr<Canvas> fakeCanvas(new FakeCanvas());
+  renderer_->OnSurfaceCreated(std::move(fakeCanvas));
+  delegate_.can_render_frame_ = true;
+  PostSetDesktopFrameTasks(webrtc::DesktopSize(16, 16), 1);
+  FakeDrawable* drawable0 = new FakeDrawable();
+  drawable0->SetId(3);
+  renderer_->AddDrawable(drawable0->GetWeakPtr());
+  RequestRender();
+  RunTasksInCurrentQueue();
+  FakeDrawable* drawable1 = new FakeDrawable();
+  drawable1->SetId(2);
+  drawable1->SetZIndex(1);
+  renderer_->AddDrawable(drawable1->GetWeakPtr());
+
+  RequestRender();
+  RunTasksInCurrentQueue();
+
+  FakeDrawable* drawable2 = new FakeDrawable();
+  drawable2->SetId(1);
+  drawable2->SetZIndex(2);
+  renderer_->AddDrawable(drawable2->GetWeakPtr());
+  ASSERT_EQ(3, GetDrawablesCount());
+
+  RequestRender();
+  RunTasksInCurrentQueue();
+  for (auto& drawable : GetDrawables()) {
+    FakeDrawable* fg = static_cast<FakeDrawable*>(drawable.get());
+    EXPECT_EQ(fg->GetId(), fg->DrawnCount());
+  }
+}
+
+TEST_F(GlRendererTest, TestCreateGlRendererWithDesktop) {
+  renderer_ = GlRenderer::CreateGlRendererWithDesktop();
+  renderer_->SetDelegate(delegate_.GetWeakPtr());
+  ASSERT_EQ(3, GetDrawablesCount());
+}
+
+// TODO(nicholss): Add a test where the drawable is destructed and the renderer
+// gets a dead weakptr.
+
 }  // namespace remoting