Adding drawable to CRD andorid and iOS gl rendering pipeline.

remoting/client/display/gl_renderer_unittest.cc

 // 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.
 
 #include "remoting/client/display/gl_renderer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #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"
 
 namespace remoting {
 
 class FakeGlRendererDelegate : public GlRendererDelegate {
  public:
   FakeGlRendererDelegate() : weak_factory_(this) {}
 
@@ skipping 39 matching lines @@
   int can_render_frame_call_count_ = 0;
   int on_frame_rendered_call_count_ = 0;
   int on_size_changed_call_count_ = 0;
 
   int canvas_width_ = 0;
   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(Canvas* canvas) override { canvas_ = canvas; }
+
+  bool Draw() override {
+    drawn_++;
+    return false;
+  }
+
+  int DrawnCount() { return drawn_; }
+
+ private:
+  int drawn_ = 0;
+  int id_ = -1;
+  Canvas* canvas_ = nullptr;
+
+  base::WeakPtrFactory<FakeDrawable> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeDrawable);
 };
 
 class GlRendererTest : public testing::Test {
  public:
   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();
   void OnDesktopFrameProcessed();
   void RunTasksInCurrentQueue();
   void RunUntilRendered();
   int on_desktop_frame_processed_call_count() {
     return on_desktop_frame_processed_call_count_;
   }
 
   base::MessageLoop message_loop_;
   std::unique_ptr<GlRenderer> renderer_;
   FakeGlRendererDelegate delegate_;
 
  private:
   int on_desktop_frame_processed_call_count_ = 0;
 };
 
 void GlRendererTest::SetUp() {
   renderer_.reset(new GlRenderer());
   renderer_->SetDelegate(delegate_.GetWeakPtr());
 }
 
 void GlRendererTest::RequestRender() {
   renderer_->RequestRender();
 }
 
+int GlRendererTest::GetDrawablesCount() {
+  return (int)renderer_->drawables_.size();
+}
+
+std::vector<base::WeakPtr<Drawable>> GlRendererTest::GetDrawables() {
+  return renderer_->drawables_;
+}
+
 void GlRendererTest::SetDesktopFrameWithSize(const webrtc::DesktopSize& size) {
   renderer_->OnFrameReceived(
       base::MakeUnique<webrtc::BasicDesktopFrame>(size),
       base::Bind(&GlRendererTest::OnDesktopFrameProcessed,
                  base::Unretained(this)));
 }
 
 void GlRendererTest::PostSetDesktopFrameTasks(const webrtc::DesktopSize& size,
                                               int count) {
   for (int i = 0; i < count; i++) {
@@ skipping 44 matching lines @@
   EXPECT_EQ(1, delegate_.on_frame_rendered_call_count());
 
   RequestRender();
   RunTasksInCurrentQueue();
   EXPECT_EQ(2, delegate_.can_render_frame_call_count());
   EXPECT_EQ(2, delegate_.on_frame_rendered_call_count());
 }
 
 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) {
   delegate_.can_render_frame_ = true;
 
   // Implicitly calls RequestRender().
 
   PostSetDesktopFrameTasks(webrtc::DesktopSize(16, 16), 1);
   RunUntilRendered();
   EXPECT_EQ(1, delegate_.on_frame_rendered_call_count());
   EXPECT_EQ(1, on_desktop_frame_processed_call_count());
 
   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();
+  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