cc: Adding a BeginFrameObserverMultiplexer.

cc/scheduler/begin_frame_source_unittest.cc

 // Copyright 2011 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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 203 matching lines @@
   EXPECT_EQ(1, obs.dropped_begin_frame_args());
 
   BeginFrameArgs args3 =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 150, 300, 400);
   EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args3)).WillOnce(Return(true));
   obs.OnBeginFrame(args3);
   EXPECT_EQ(args3, obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(1, obs.dropped_begin_frame_args());
 }
 
+// BeginFrameObserverMultiplexer testing ---------------------------------
+
+class MockHasObserversCallback {
+ public:
+  MOCK_METHOD1(Callback, void(bool));
+
+  BeginFrameObserverMultiplexer::HasObserversCallback Get() {
+    return base::Bind(&MockHasObserversCallback::Callback,
+                      base::Unretained(this));
+  }
+};
+
+TEST(BeginFrameObserverMultiplexerTest, ObserverManipulation) {
+  scoped_ptr<BeginFrameObserverMultiplexer> obs =
+      BeginFrameObserverMultiplexer::Create();
+
+  ::testing::StrictMock<MockMinimalBeginFrameObserverMixIn> obs_child1;
+  ::testing::StrictMock<MockMinimalBeginFrameObserverMixIn> obs_child2;
+
+  // Initial conditions
+  EXPECT_EQ(BeginFrameArgs(), obs->LastUsedBeginFrameArgs());
+
+  // Calling without any observers, should be fine
+  BeginFrameArgs args1 =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300);
+  obs->OnBeginFrame(args1);
+  EXPECT_EQ(args1, obs->LastUsedBeginFrameArgs());
+
+  // Adding an observer triggers a MISSED frame for that observer if they have
+  // never receive the BeginFrameArgs before.
+  EXPECT_CALL(obs_child1,
+              OnBeginFrameMixInDelegate(CreateBeginFrameArgsForTesting(
+                  BEGINFRAME_FROM_HERE, 100, 200, 300, BeginFrameArgs::MISSED)))
+      .WillOnce(::testing::Return(true));
+  obs->AddObserver(&obs_child1);
+
+#ifndef NDEBUG
+  EXPECT_DEATH({ obs->AddObserver(&obs_child1); }, "");
+
+  EXPECT_DEATH({ obs->RemoveObserver(&obs_child2); }, "");
+#endif
+
+  EXPECT_CALL(obs_child2,
+              OnBeginFrameMixInDelegate(CreateBeginFrameArgsForTesting(
+                  BEGINFRAME_FROM_HERE, 100, 200, 300, BeginFrameArgs::MISSED)))
+      .WillOnce(::testing::Return(false));
+  obs->AddObserver(&obs_child2);
+
+  // Re-adding the observer shouldn't cause OnBeginFrame to get called again if
+  // it was used.
+  obs->RemoveObserver(&obs_child1);
+  obs->AddObserver(&obs_child1);
+
+  // This observer dropped the last missed frames so should get it again.
+  EXPECT_CALL(obs_child2,
+              OnBeginFrameMixInDelegate(CreateBeginFrameArgsForTesting(
+                  BEGINFRAME_FROM_HERE, 100, 200, 300, BeginFrameArgs::MISSED)))
+      .WillOnce(::testing::Return(false));
+  obs->RemoveObserver(&obs_child2);
+  obs->AddObserver(&obs_child2);
+}
+
+TEST(BeginFrameObserverMultiplexerTest, HasObserverCallback) {
+  {
+    ::testing::StrictMock<MockHasObserversCallback> cb;
+    EXPECT_CALL(cb, Callback(false));
+
+    scoped_ptr<BeginFrameObserverMultiplexer> obs =
+        BeginFrameObserverMultiplexer::Create();
+    obs->SetHasObserverCallback(cb.Get());
+  }
+
+  {
+    ::testing::StrictMock<MockHasObserversCallback> cb;
+    EXPECT_CALL(cb, Callback(true));
+    EXPECT_CALL(cb, Callback(false));  // Destructor
+
+    scoped_ptr<BeginFrameObserverMultiplexer> obs =
+        BeginFrameObserverMultiplexer::Create();
+    MockMinimalBeginFrameObserverMixIn obs_child;
+    obs->AddObserver(&obs_child);
+    obs->SetHasObserverCallback(cb.Get());
+  }
+
+  {
+    ::testing::InSequence ordered;
+
+    ::testing::StrictMock<MockHasObserversCallback> cb;
+    EXPECT_CALL(cb, Callback(false));
+    EXPECT_CALL(cb, Callback(true));
+    EXPECT_CALL(cb, Callback(false));
+
+    scoped_ptr<BeginFrameObserverMultiplexer> obs =
+        BeginFrameObserverMultiplexer::Create();
+    MockMinimalBeginFrameObserverMixIn obs_child;
+    obs->SetHasObserverCallback(cb.Get());
+    obs->AddObserver(&obs_child);
+    obs->RemoveObserver(&obs_child);
+  }
+
+  {
+    ::testing::InSequence ordered;
+
+    ::testing::StrictMock<MockHasObserversCallback> cb;
+    EXPECT_CALL(cb, Callback(false));
+    EXPECT_CALL(cb, Callback(true));
+    EXPECT_CALL(cb, Callback(false));
+
+    scoped_ptr<BeginFrameObserverMultiplexer> obs =
+        BeginFrameObserverMultiplexer::Create();
+    MockMinimalBeginFrameObserverMixIn obs_child1;
+    MockMinimalBeginFrameObserverMixIn obs_child2;
+    obs->SetHasObserverCallback(cb.Get());
+    obs->AddObserver(&obs_child1);
+    obs->AddObserver(&obs_child2);
+    obs->RemoveObserver(&obs_child1);
+    obs->RemoveObserver(&obs_child2);
+  }
+
+  {
+    ::testing::InSequence ordered;
+    ::testing::StrictMock<MockHasObserversCallback> cb1;
+    EXPECT_CALL(cb1, Callback(false));
+    EXPECT_CALL(cb1, Callback(true));
+    EXPECT_CALL(cb1, Callback(false));
+
+    ::testing::StrictMock<MockHasObserversCallback> cb2;
+    EXPECT_CALL(cb2, Callback(true));
+    EXPECT_CALL(cb2, Callback(false));
+
+    ::testing::StrictMock<MockHasObserversCallback> cb3;
+    EXPECT_CALL(cb3, Callback(false));
+
+    scoped_ptr<BeginFrameObserverMultiplexer> obs =
+        BeginFrameObserverMultiplexer::Create();
+    MockMinimalBeginFrameObserverMixIn obs_child;
+    obs->SetHasObserverCallback(cb1.Get());
+    obs->AddObserver(&obs_child);
+    obs->SetHasObserverCallback(cb2.Get());
+    obs->RemoveObserver(&obs_child);
+    obs->SetHasObserverCallback(cb3.Get());
+  }
+}
+
+TEST(BeginFrameObserverMultiplexerTest, OnBeginFrame) {
+  scoped_ptr<BeginFrameObserverMultiplexer> obs =
+      BeginFrameObserverMultiplexer::Create();
+
+  MockBeginFrameObserver obs_child1;
+  EXPECT_BEGIN_FRAME_USED(obs_child1, 100, 200, 300);
+  EXPECT_BEGIN_FRAME_USED(obs_child1, 400, 600, 300);
+  MockBeginFrameObserver obs_child2;
+  EXPECT_CALL(obs_child2,
+              OnBeginFrame(CreateBeginFrameArgsForTesting(
+                  BEGINFRAME_FROM_HERE, 100, 200, 300, BeginFrameArgs::MISSED)))
+      .InSequence(obs_child2.sequence);
+  EXPECT_BEGIN_FRAME_USED(obs_child2, 400, 600, 300);
+  EXPECT_BEGIN_FRAME_USED(obs_child2, 700, 800, 300);
+
+  obs->AddObserver(&obs_child1);
+  obs->OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+  obs->AddObserver(&obs_child2);
+  obs->OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+  obs->RemoveObserver(&obs_child1);
+  obs->OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 700, 800, 300));
+}
+
 // BeginFrameSource testing ----------------------------------------------
 TEST(BeginFrameSourceMixInTest, ObserverManipulation) {
   MockBeginFrameObserver obs;
   MockBeginFrameObserver otherObs;
   FakeBeginFrameSource source;
 
   source.AddObserver(&obs);
   EXPECT_EQ(&obs, source.GetObserver());
 
 #ifndef NDEBUG
@@ skipping 532 matching lines @@
   mux_->SetActiveSource(source2_);
   SEND_BEGIN_FRAME_DROP(*source2_, 750, 1050, 300);
   SEND_BEGIN_FRAME_USED(*source2_, 1050, 1250, 300);
 
   mux_->SetActiveSource(source1_);
   SEND_BEGIN_FRAME_DROP(*source2_, 1100, 1400, 300);
 }
 
 }  // namespace
 }  // namespace cc