cc: Adding creation location to debug BeginFrameArgs objects.

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"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/test/begin_frame_args_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(     \
-                        frame_time, deadline, interval)))            \
-            .InSequence((obs).sequence);                             \
+#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(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(frame_time, deadline, interval); \
-    ASSERT_FALSE(old_args == new_args);                                 \
-    (source).TestOnBeginFrame(new_args);                                \
-    EXPECT_EQ(args_equal_to, (source).TestLastUsedBeginFrameArgs());    \
+#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);
 
@@ skipping 32 matching lines @@
 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(
-      100, 200, 300));  // One call to LastUsedBeginFrameArgs
-  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
-            CreateBeginFrameArgsForTesting(100, 200, 300));
+      BEGINFRAME_FROM_HERE, 100, 200,
+      300));  // One call to LastUsedBeginFrameArgs
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
 
   obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
-      400, 600, 300));  // Multiple calls to LastUsedBeginFrameArgs
-  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
-            CreateBeginFrameArgsForTesting(400, 600, 300));
-  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
-            CreateBeginFrameArgsForTesting(400, 600, 300));
+      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(
-      700, 900, 300));  // No calls to LastUsedBeginFrameArgs
+      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(100, 200, 300));
-  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
-            CreateBeginFrameArgsForTesting(100, 200, 300));
+  obs.OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
 
   // Dropped
-  obs.OnBeginFrame(CreateBeginFrameArgsForTesting(400, 600, 300));
-  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
-            CreateBeginFrameArgsForTesting(100, 200, 300));
+  obs.OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
 
   // Dropped
-  obs.OnBeginFrame(CreateBeginFrameArgsForTesting(450, 650, 300));
-  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
-            CreateBeginFrameArgsForTesting(100, 200, 300));
+  obs.OnBeginFrame(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 450, 650, 300));
+  EXPECT_EQ(
+      obs.LastUsedBeginFrameArgs(),
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
 
   // Used
-  obs.OnBeginFrame(CreateBeginFrameArgsForTesting(700, 900, 300));
-  EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
-            CreateBeginFrameArgsForTesting(700, 900, 300));
+  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(-1, -1, -1);
+    CreateBeginFrameArgsForTesting(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "MockBeginFrameObserver::kDefaultBeginFrameArgs"),
+        -1,
+        -1,
+        -1);
 
 // BeginFrameObserverMixIn testing ---------------------------------------
 class MockMinimalBeginFrameObserverMixIn : public BeginFrameObserverMixIn {
  public:
   MOCK_METHOD1(OnBeginFrameMixInDelegate, bool(const BeginFrameArgs&));
   int64_t dropped_begin_frame_args() const { return dropped_begin_frame_args_; }
 };
 
 TEST(BeginFrameObserverMixInTest, OnBeginFrameImplementation) {
   using ::testing::Return;
   MockMinimalBeginFrameObserverMixIn obs;
   ::testing::InSequence ordered;  // These calls should be ordered
 
   // Initial conditions
   EXPECT_EQ(BeginFrameArgs(), obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(0, obs.dropped_begin_frame_args());
 
 #ifndef NDEBUG
   EXPECT_DEATH({ obs.OnBeginFrame(BeginFrameArgs()); }, "");
 #endif
 
-  BeginFrameArgs args1 = CreateBeginFrameArgsForTesting(100, 200, 300);
+  BeginFrameArgs args1 =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300);
   EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args1)).WillOnce(Return(true));
   obs.OnBeginFrame(args1);
   EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(0, obs.dropped_begin_frame_args());
 
 #ifndef NDEBUG
-  EXPECT_DEATH(
-      { obs.OnBeginFrame(CreateBeginFrameArgsForTesting(50, 200, 300)); }, "");
+  EXPECT_DEATH({
+                 obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
+                     BEGINFRAME_FROM_HERE, 50, 200, 300));
+               },
+               "");
 #endif
 
   // Returning false shouldn't update the LastUsedBeginFrameArgs value.
-  BeginFrameArgs args2 = CreateBeginFrameArgsForTesting(200, 300, 400);
+  BeginFrameArgs args2 =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 200, 300, 400);
   EXPECT_CALL(obs, OnBeginFrameMixInDelegate(args2)).WillOnce(Return(false));
   obs.OnBeginFrame(args2);
   EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
   EXPECT_EQ(1, obs.dropped_begin_frame_args());
 
-  BeginFrameArgs args3 = CreateBeginFrameArgsForTesting(150, 300, 400);
+  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());
 }
 
 // BeginFrameSource testing ----------------------------------------------
 TEST(BeginFrameSourceMixInTest, ObserverManipulation) {
   MockBeginFrameObserver obs;
   MockBeginFrameObserver otherObs;
@@ skipping 288 matching lines @@
     source_->AddObserver(obs_.get());
   }
 
   void TearDown() override { obs_.reset(); }
 };
 
 TEST_F(SyntheticBeginFrameSourceTest,
        SetNeedsBeginFramesCallsOnBeginFrameWithMissedTick) {
   now_src_->SetNowMicroseconds(10010);
   EXPECT_CALL((*obs_), OnBeginFrame(CreateBeginFrameArgsForTesting(
-                           10000, 20000, 10000, BeginFrameArgs::MISSED)));
+                           BEGINFRAME_FROM_HERE, 10000, 20000, 10000,
+                           BeginFrameArgs::MISSED)));
   source_->SetNeedsBeginFrames(true);  // Should cause the last tick to be sent
   // No tasks should need to be run for this to occur.
 }
 
 TEST_F(SyntheticBeginFrameSourceTest,
        SetNeedsBeginFramesCallsCausesOnBeginFrame) {
   source_->SetNeedsBeginFrames(true);
   EXPECT_EQ(10000, task_runner_->NextTaskTime().ToInternalValue());
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);
@@ skipping 228 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