cc: Move the MockBeginFrameObserver (and helper macros) into cc/test directory.

This allows usage in other tests which interface with observers.

The change also refactors the EXPECT_* macros so they can be used with further expectations and closer match the EXPECT_CALL form.

The EXPECT_* macros also now work with a second implicit sequence such as;
{
  ::testing::InSequence seq;

  EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
  EXPECT_CALL(other, Function());
  EXPECT_BEGIN_FRAME_USED(obs, 400, 500, 600);
}

R=brianderson
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1493233002

Cr-Commit-Position: refs/heads/master@{#363147}

5 files changed, 312 insertions, 0 deletions

diff --git a/cc/test/begin_frame_source_test.cc b/cc/test/begin_frame_source_test.cc
new file mode 100644
index 0000000..ef1c033
--- /dev/null
+++ b/cc/test/begin_frame_source_test.cc
@@ -0,0 +1,42 @@
+// 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 "cc/test/begin_frame_source_test.h"
+
+#include "cc/test/begin_frame_args_test.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+
+void MockBeginFrameObserver::AsValueInto(
+    base::trace_event::TracedValue* dict) const {
+  dict->SetString("type", "MockBeginFrameObserver");
+  dict->BeginDictionary("last_begin_frame_args");
+  last_begin_frame_args.AsValueInto(dict);
+  dict->EndDictionary();
+}
+
+MockBeginFrameObserver::MockBeginFrameObserver()
+    : last_begin_frame_args(kDefaultBeginFrameArgs) {
+  EXPECT_CALL(*this, LastUsedBeginFrameArgs())
+      .Times(::testing::AnyNumber())
+      .WillRepeatedly(::testing::ReturnPointee(&last_begin_frame_args));
+}
+
+MockBeginFrameObserver::~MockBeginFrameObserver() {}
+
+const BeginFrameArgs MockBeginFrameObserver::kDefaultBeginFrameArgs =
+    CreateBeginFrameArgsForTesting(
+#ifdef NDEBUG
+        nullptr,
+#else
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "MockBeginFrameObserver::kDefaultBeginFrameArgs"),
+#endif
+        -1,
+        -1,
+        -1);
+
+}  // namespace cc
diff --git a/cc/test/begin_frame_source_test.h b/cc/test/begin_frame_source_test.h
new file mode 100644
index 0000000..98f5d90
--- /dev/null
+++ b/cc/test/begin_frame_source_test.h
@@ -0,0 +1,73 @@
+// 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.
+
+#ifndef CC_TEST_BEGIN_FRAME_SOURCE_TEST_H_
+#define CC_TEST_BEGIN_FRAME_SOURCE_TEST_H_
+
+#include "base/basictypes.h"
+#include "base/trace_event/trace_event_argument.h"
+#include "cc/scheduler/begin_frame_source.h"
+#include "cc/test/begin_frame_args_test.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// Macros to help set up expected calls on the MockBeginFrameObserver.
+#define EXPECT_BEGIN_FRAME_DROP(obs, frame_time, deadline, interval)      \
+  EXPECT_CALL((obs),                                                      \
+              OnBeginFrame(CreateBeginFrameArgsForTesting(                \
+                  BEGINFRAME_FROM_HERE, frame_time, deadline, interval))) \
+      .Times(1)                                                           \
+      .InSequence((obs).sequence)
+
+#define EXPECT_BEGIN_FRAME_USED(obs, frame_time, deadline, interval)      \
+  EXPECT_CALL((obs),                                                      \
+              OnBeginFrame(CreateBeginFrameArgsForTesting(                \
+                  BEGINFRAME_FROM_HERE, frame_time, deadline, interval))) \
+      .InSequence((obs).sequence)                                         \
+      .WillOnce(::testing::SaveArg<0>(&((obs).last_begin_frame_args)))
+
+// Macros to send BeginFrameArgs on a FakeBeginFrameSink (and verify resulting
+// observer behaviour).
+#define SEND_BEGIN_FRAME(args_equal_to, source, frame_time, deadline, \
+                         interval)                                    \
+  {                                                                   \
+    BeginFrameArgs old_args = (source).TestLastUsedBeginFrameArgs();  \
+    BeginFrameArgs new_args = CreateBeginFrameArgsForTesting(         \
+        BEGINFRAME_FROM_HERE, frame_time, deadline, interval);        \
+    ASSERT_FALSE(old_args == new_args);                               \
+    (source).TestOnBeginFrame(new_args);                              \
+    EXPECT_EQ(args_equal_to, (source).TestLastUsedBeginFrameArgs());  \
+  }
+
+// When dropping LastUsedBeginFrameArgs **shouldn't** change.
+#define SEND_BEGIN_FRAME_DROP(source, frame_time, deadline, interval) \
+  SEND_BEGIN_FRAME(old_args, source, frame_time, deadline, interval);
+
+// When used LastUsedBeginFrameArgs **should** be updated.
+#define SEND_BEGIN_FRAME_USED(source, frame_time, deadline, interval) \
+  SEND_BEGIN_FRAME(new_args, source, frame_time, deadline, interval);
+
+namespace cc {
+
+class MockBeginFrameObserver : public BeginFrameObserver {
+ public:
+  MOCK_METHOD1(OnBeginFrame, void(const BeginFrameArgs&));
+  MOCK_CONST_METHOD0(LastUsedBeginFrameArgs, const BeginFrameArgs());
+
+  virtual void AsValueInto(base::trace_event::TracedValue* dict) const;
+
+  // A value different from the normal default returned by a BeginFrameObserver
+  // so it is easiable traced back here.
+  static const BeginFrameArgs kDefaultBeginFrameArgs;
+
+  MockBeginFrameObserver();
+  virtual ~MockBeginFrameObserver();
+
+  BeginFrameArgs last_begin_frame_args;
+  ::testing::Sequence sequence;
+};
+
+}  // namespace cc
+
+#endif  // CC_TEST_BEGIN_FRAME_SOURCE_TEST_H_
diff --git a/cc/test/begin_frame_source_test_unittest.cc b/cc/test/begin_frame_source_test_unittest.cc
new file mode 100644
index 0000000..601da31
--- /dev/null
+++ b/cc/test/begin_frame_source_test_unittest.cc
@@ -0,0 +1,124 @@
+// 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 "cc/test/begin_frame_source_test.h"
+
+#include "cc/test/begin_frame_args_test.h"
+#include "cc/test/mock_helper.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+TEST(MockBeginFrameObserverTest, FailOnMissingCalls) {
+  EXPECT_MOCK_FAILURE({
+    ::testing::NiceMock<MockBeginFrameObserver> obs;
+    EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
+    EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
+
+    obs.OnBeginFrame(
+        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+  });
+}
+
+TEST(MockBeginFrameObserverTest, FailOnMultipleCalls) {
+  EXPECT_MOCK_FAILURE({
+    ::testing::NiceMock<MockBeginFrameObserver> obs;
+    EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
+    EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
+
+    obs.OnBeginFrame(
+        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+    obs.OnBeginFrame(
+        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+    obs.OnBeginFrame(
+        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+  });
+}
+
+TEST(MockBeginFrameObserverTest, FailOnWrongCallOrder) {
+  EXPECT_MOCK_FAILURE({
+    ::testing::NiceMock<MockBeginFrameObserver> obs;
+    EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
+    EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
+
+    obs.OnBeginFrame(
+        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+    obs.OnBeginFrame(
+        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+  });
+}
+
+TEST(MockBeginFrameObserverTest, ExpectOnBeginFrame) {
+  ::testing::NiceMock<MockBeginFrameObserver> obs;
+  EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
+  EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
+  EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
+
+  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
+            MockBeginFrameObserver::kDefaultBeginFrameArgs);
+
+  obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
+      BEGINFRAME_FROM_HERE, 100, 200,
+      300));  // One call to LastUsedBeginFrameArgs
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+
+  obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
+      BEGINFRAME_FROM_HERE, 400, 600,
+      300));  // Multiple calls to LastUsedBeginFrameArgs
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+
+  obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
+      BEGINFRAME_FROM_HERE, 700, 900,
+      300));  // No calls to LastUsedBeginFrameArgs
+}
+
+TEST(MockBeginFrameObserverTest, ExpectOnBeginFrameStatus) {
+  ::testing::NiceMock<MockBeginFrameObserver> obs;
+  EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
+  EXPECT_BEGIN_FRAME_DROP(obs, 400, 600, 300);
+  EXPECT_BEGIN_FRAME_DROP(obs, 450, 650, 300);
+  EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
+
+  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
+            MockBeginFrameObserver::kDefaultBeginFrameArgs);
+
+  // Used
+  obs.OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+
+  // Dropped
+  obs.OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+
+  // Dropped
+  obs.OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 450, 650, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+
+  // Used
+  obs.OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 700, 900, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 700, 900, 300));
+}
+
+}  // namespace
+}  // namespace cc
diff --git a/cc/test/mock_helper.h b/cc/test/mock_helper.h
new file mode 100644
index 0000000..9ca9afb
--- /dev/null
+++ b/cc/test/mock_helper.h
@@ -0,0 +1,29 @@
+// 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.
+
+#ifndef CC_TEST_MOCK_HELPER_H_
+#define CC_TEST_MOCK_HELPER_H_
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest-spi.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#define EXPECT_MOCK_FAILURE(statement)                            \
+  do {                                                            \
+    class GTestExpectMockFailureHelper {                          \
+     public:                                                      \
+      static void Execute() { statement; }                        \
+    };                                                            \
+    ::testing::TestPartResultArray gtest_failures;                \
+    {                                                             \
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter( \
+          ::testing::ScopedFakeTestPartResultReporter::           \
+              INTERCEPT_ONLY_CURRENT_THREAD,                      \
+          &gtest_failures);                                       \
+      GTestExpectMockFailureHelper::Execute();                    \
+    }                                                             \
+    EXPECT_GT(gtest_failures.size(), 0);                          \
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // CC_TEST_MOCK_HELPER_H_
diff --git a/cc/test/mock_helper_unittest.cc b/cc/test/mock_helper_unittest.cc
new file mode 100644
index 0000000..d6b9898
--- /dev/null
+++ b/cc/test/mock_helper_unittest.cc
@@ -0,0 +1,44 @@
+// 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 "cc/test/mock_helper.h"
+
+#include "testing/gtest/include/gtest/gtest-spi.h"
+
+namespace {
+class TestingMock {
+ public:
+  MOCK_METHOD0(Test, void(void));
+};
+
+TEST(ExpectMockFailureTest, FailsWhenNoMock) {
+  EXPECT_NONFATAL_FAILURE({ EXPECT_MOCK_FAILURE({ ; }); }, "");
+}
+
+TEST(ExpectMockFailureTest, FailsWhenMockSucceeds) {
+  EXPECT_NONFATAL_FAILURE({
+    EXPECT_MOCK_FAILURE({
+      ::testing::NiceMock<TestingMock> t1;
+      EXPECT_CALL(t1, Test());
+
+      t1.Test();
+    });
+  }, "");
+}
+
+TEST(ExpectMockFailureTest, PassesWhenMockFailsForMissing) {
+  EXPECT_MOCK_FAILURE({
+    ::testing::NiceMock<TestingMock> t1;
+    EXPECT_CALL(t1, Test());
+  });
+}
+
+TEST(ExpectMockFailureTest, PassesWhenMockFailsForUnexpected) {
+  EXPECT_MOCK_FAILURE({
+    ::testing::StrictMock<TestingMock> t1;
+    t1.Test();
+  });
+}
+
+}  // namespace