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}

10 files changed, 332 insertions, 168 deletions

diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 6a1d321..88e3524 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -563,6 +563,8 @@ source_set("test_support") {
     "test/animation_timelines_test_common.h",
     "test/begin_frame_args_test.cc",
     "test/begin_frame_args_test.h",
+    "test/begin_frame_source_test.cc",
+    "test/begin_frame_source_test.h",
     "test/failure_output_surface.cc",
     "test/failure_output_surface.h",
     "test/fake_content_layer_client.cc",
@@ -634,6 +636,7 @@ source_set("test_support") {
     "test/layer_tree_settings_for_testing.h",
     "test/layer_tree_test.cc",
     "test/layer_tree_test.h",
+    "test/mock_helper.h",
     "test/mock_occlusion_tracker.h",
     "test/ordered_simple_task_runner.cc",
     "test/ordered_simple_task_runner.h",
@@ -840,7 +843,9 @@ test("cc_unittests") {
     "scheduler/delay_based_time_source_unittest.cc",
     "scheduler/scheduler_state_machine_unittest.cc",
     "scheduler/scheduler_unittest.cc",
+    "test/begin_frame_source_test_unittest.cc",
     "test/layer_tree_json_parser_unittest.cc",
+    "test/mock_helper_unittest.cc",
     "test/ordered_simple_task_runner_unittest.cc",
     "test/test_web_graphics_context_3d_unittest.cc",
     "tiles/picture_layer_tiling_set_unittest.cc",
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index 03f8ae5..5332133 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -112,7 +112,9 @@
       'scheduler/delay_based_time_source_unittest.cc',
       'scheduler/scheduler_state_machine_unittest.cc',
       'scheduler/scheduler_unittest.cc',
+      'test/begin_frame_source_test_unittest.cc',
       'test/layer_tree_json_parser_unittest.cc',
+      'test/mock_helper_unittest.cc',
       'test/ordered_simple_task_runner_unittest.cc',
       'test/test_web_graphics_context_3d_unittest.cc',
       'tiles/picture_layer_tiling_set_unittest.cc',
@@ -165,6 +167,8 @@
       'test/animation_timelines_test_common.h',
       'test/begin_frame_args_test.cc',
       'test/begin_frame_args_test.h',
+      'test/begin_frame_source_test.cc',
+      'test/begin_frame_source_test.h',
       'test/failure_output_surface.cc',
       'test/failure_output_surface.h',
       'test/fake_content_layer_client.cc',
@@ -236,6 +240,7 @@
       'test/layer_tree_settings_for_testing.h',
       'test/layer_tree_test.cc',
       'test/layer_tree_test.h',
+      'test/mock_helper.h',
       'test/mock_occlusion_tracker.h',
       'test/ordered_simple_task_runner.cc',
       'test/ordered_simple_task_runner.h',
diff --git a/cc/scheduler/begin_frame_source.cc b/cc/scheduler/begin_frame_source.cc
index 1ee862b..2681983 100644
--- a/cc/scheduler/begin_frame_source.cc
+++ b/cc/scheduler/begin_frame_source.cc
@@ -13,18 +13,6 @@
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/scheduler.h"
 
-#ifdef NDEBUG
-#define DEBUG_FRAMES(...)
-#else
-#define DEBUG_FRAMES(name, arg1_name, arg1_val, arg2_name, arg2_val)   \
-  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), \
-               name,                                                   \
-               arg1_name,                                              \
-               arg1_val,                                               \
-               arg2_name,                                              \
-               arg2_val);
-#endif
-
 namespace cc {
 
 // BeginFrameObserverBase -----------------------------------------------
diff --git a/cc/scheduler/begin_frame_source.h b/cc/scheduler/begin_frame_source.h
index f6f1a78..87ed17f 100644
--- a/cc/scheduler/begin_frame_source.h
+++ b/cc/scheduler/begin_frame_source.h
@@ -13,6 +13,14 @@
 #include "cc/output/begin_frame_args.h"
 #include "cc/scheduler/delay_based_time_source.h"
 
+#ifdef NDEBUG
+#define DEBUG_FRAMES(...)
+#else
+#define DEBUG_FRAMES(name, arg1_name, arg1_val, arg2_name, arg2_val)         \
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), name, \
+               arg1_name, arg1_val, arg2_name, arg2_val);
+#endif
+
 namespace cc {
 
 // (Pure) Interface for observing BeginFrame messages from BeginFrameSource
diff --git a/cc/scheduler/begin_frame_source_unittest.cc b/cc/scheduler/begin_frame_source_unittest.cc
index 2c12ca9..afc3b30 100644
--- a/cc/scheduler/begin_frame_source_unittest.cc
+++ b/cc/scheduler/begin_frame_source_unittest.cc
@@ -2,173 +2,19 @@
 // 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 "cc/scheduler/begin_frame_source.h"
 
 #include "base/basictypes.h"
 #include "base/test/test_simple_task_runner.h"
-#include "cc/scheduler/begin_frame_source.h"
 #include "cc/test/begin_frame_args_test.h"
+#include "cc/test/begin_frame_source_test.h"
 #include "cc/test/scheduler_test_common.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)       \
-  {                                                                        \
-    ::testing::Expectation exp =                                           \
-        EXPECT_CALL((obs), OnBeginFrame(CreateBeginFrameArgsForTesting(    \
-                               BEGINFRAME_FROM_HERE, frame_time, deadline, \
-                               interval))).InSequence((obs).sequence);     \
-  }
-
-#define EXPECT_BEGIN_FRAME_USED(obs, frame_time, deadline, interval)       \
-  {                                                                        \
-    BeginFrameArgs args = CreateBeginFrameArgsForTesting(                  \
-        BEGINFRAME_FROM_HERE, frame_time, deadline, interval);             \
-    ::testing::Expectation exp =                                           \
-        EXPECT_CALL((obs), OnBeginFrame(args)).InSequence((obs).sequence); \
-    EXPECT_CALL((obs), LastUsedBeginFrameArgs())                           \
-        .Times(::testing::AnyNumber())                                     \
-        .After(exp)                                                        \
-        .WillRepeatedly(::testing::Return(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 {
 namespace {
 
-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 {
-    dict->SetString("type", "MockBeginFrameObserver");
-    dict->BeginDictionary("last_begin_frame_args");
-    LastUsedBeginFrameArgs().AsValueInto(dict);
-    dict->EndDictionary();
-  }
-
-  // A value different from the normal default returned by a BeginFrameObserver
-  // so it is easiable traced back here.
-  static const BeginFrameArgs kDefaultBeginFrameArgs;
-
-  MockBeginFrameObserver() {
-    // Set a "default" value returned by LastUsedBeginFrameArgs so that gMock
-    // doesn't fail an assert and instead returns useful information.
-    EXPECT_CALL(*this, LastUsedBeginFrameArgs())
-        .Times(::testing::AnyNumber())
-        .InSequence(sequence)
-        .WillRepeatedly(::testing::Return(kDefaultBeginFrameArgs));
-  }
-  virtual ~MockBeginFrameObserver() {}
-
-  ::testing::Sequence sequence;
-};
-
-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));
-}
-
-const BeginFrameArgs MockBeginFrameObserver::kDefaultBeginFrameArgs =
-    CreateBeginFrameArgsForTesting(
-#ifdef NDEBUG
-        nullptr,
-#else
-        FROM_HERE_WITH_EXPLICIT_FUNCTION(
-            "MockBeginFrameObserver::kDefaultBeginFrameArgs"),
-#endif
-        -1,
-        -1,
-        -1);
-
 // BeginFrameObserverBase testing ---------------------------------------
 class MockMinimalBeginFrameObserverBase : public BeginFrameObserverBase {
  public:
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