Add BeginFrameObserverProxy

content/browser/renderer_host/compositor_begin_frame_observer_impl_unittest.cc

Index: content/browser/renderer_host/compositor_begin_frame_observer_impl_unittest.cc
diff --git a/content/browser/renderer_host/compositor_begin_frame_observer_impl_unittest.cc b/content/browser/renderer_host/compositor_begin_frame_observer_impl_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e0b312c023c0f8fb399f743d6e1b42379dfbd6b2
--- /dev/null
+++ b/content/browser/renderer_host/compositor_begin_frame_observer_impl_unittest.cc
@@ -0,0 +1,106 @@
+// Copyright 2015 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 <algorithm>
+#include <list>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/test/test_simple_task_runner.h"
+#include "cc/output/begin_frame_args.h"
+#include "cc/test/begin_frame_args_test.h"
+#include "content/browser/renderer_host/compositor_begin_frame_observer_impl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/compositor/compositor.h"
+#include "ui/compositor/test/context_factories_for_test.h"
+
+namespace content {
+namespace {
+
+class TestCompositorBeginFrameObserverImplClient
+    : public CompositorBeginFrameObserverImplClient {
+ public:
+  TestCompositorBeginFrameObserverImplClient() : begin_frame_sent_(false) {}
+  ~TestCompositorBeginFrameObserverImplClient() {}
+
+  // CompositorBeginFrameObserverImplClient:
+  void SendBeginFrame(const cc::BeginFrameArgs& args) override {
+    last_begin_frame_args_ = args;
+    begin_frame_sent_ = true;
+  }
+
+  bool begin_frame_sent() { return begin_frame_sent_; }
+  cc::BeginFrameArgs last_begin_frame_args() { return last_begin_frame_args_; }
+
+ private:
+  bool begin_frame_sent_;
+  cc::BeginFrameArgs last_begin_frame_args_;
+};
+
+class CompositorBeginFrameObserverImplTest : public testing::Test {
+ public:
+  CompositorBeginFrameObserverImplTest() {}
+  ~CompositorBeginFrameObserverImplTest() override {}
+
+  void SetUp() override {
+    bool enable_pixel_output = false;
+    ui::ContextFactory* context_factory =
+        ui::InitializeContextFactoryForTests(enable_pixel_output);
+    compositor_task_runner_ = new base::TestSimpleTaskRunner();
+    compositor_.reset(new ui::Compositor(gfx::kNullAcceleratedWidget,
+                                         context_factory,
+                                         compositor_task_runner_));
+  }
+
+  void TearDown() override {
+    compositor_.reset();
+    ui::TerminateContextFactoryForTests();
+  }
+
+  ui::Compositor* compositor() { return compositor_.get(); }
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
+  scoped_ptr<ui::Compositor> compositor_;
+};
+
+}  // namespace
+
+TEST_F(CompositorBeginFrameObserverImplTest, BeginFrameScheduling) {
+  TestCompositorBeginFrameObserverImplClient client;
+  CompositorBeginFrameObserverImpl begin_frame_observer(&client);
+  begin_frame_observer.SetCompositor(compositor());
+  begin_frame_observer.SetNeedsBeginFrames(true);
+  EXPECT_FALSE(client.begin_frame_sent());
+
+  cc::BeginFrameArgs args =
+    cc::CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE,
+                                       base::TimeTicks::FromInternalValue(33));
+  compositor()->SendBeginFramesToChildren(args);
+  EXPECT_TRUE(client.begin_frame_sent());
+  EXPECT_EQ(args.frame_time, client.last_begin_frame_args().frame_time);
+
+  begin_frame_observer.ResetCompositor();
+}
+
+TEST_F(CompositorBeginFrameObserverImplTest, AddAndRemoveFromCompositor) {
+  TestCompositorBeginFrameObserverImplClient client;
+  CompositorBeginFrameObserverImpl begin_frame_observer(&client);
+
+  std::list<ui::CompositorBeginFrameObserver*>& list =
+    compositor()->BeginFrameObserverListForTesting();
+  EXPECT_TRUE(list.empty());
+
+  begin_frame_observer.SetNeedsBeginFrames(true);
+  begin_frame_observer.SetCompositor(compositor());
+  std::list<ui::CompositorBeginFrameObserver*>::iterator it =
+    std::find(list.begin(), list.end(), &begin_frame_observer);
+  EXPECT_TRUE(list.end() != it);
+
+  begin_frame_observer.ResetCompositor();
+  EXPECT_TRUE(compositor()->BeginFrameObserverListForTesting().empty());

[danakj, 2015/03/19 22:36:40]

you could do this without exposing compositor implementation details by just
checking that it does call the observer on SendBeingFrames, and stopped after
Reset?

[simonhong, 2015/03/20 16:07:36]

Yep, that way can verify.
I added that in the above test case.

+}
+
+}  // namespace content