page_timing_metadata_recorder_unittest.cc 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122
  1. // Copyright 2022 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/page_load_metrics/renderer/page_timing_metadata_recorder.h"
  5. #include <vector>
  6. #include "base/profiler/sample_metadata.h"
  7. #include "base/time/time.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. namespace page_load_metrics {
  10. struct MetadataTaggingRequest {
  11. base::TimeTicks period_start;
  12. base::TimeTicks period_end;
  13. base::StringPiece name;
  14. int64_t key;
  15. int64_t value;
  16. };
  17. class TestPageTimingMetadataRecorder : public PageTimingMetadataRecorder {
  18. public:
  19. explicit TestPageTimingMetadataRecorder(const MonotonicTiming& initial_timing)
  20. : PageTimingMetadataRecorder(initial_timing) {}
  21. void ApplyMetadataToPastSamples(base::TimeTicks period_start,
  22. base::TimeTicks period_end,
  23. base::StringPiece name,
  24. int64_t key,
  25. int64_t value,
  26. base::SampleMetadataScope scope) override {
  27. requests_.push_back({
  28. period_start,
  29. period_end,
  30. name,
  31. key,
  32. value,
  33. });
  34. }
  35. const std::vector<MetadataTaggingRequest>& GetMetadataTaggingRequests()
  36. const {
  37. return requests_;
  38. }
  39. private:
  40. std::vector<MetadataTaggingRequest> requests_ = {};
  41. };
  42. using PageTimingMetadataRecorderTest = testing::Test;
  43. TEST_F(PageTimingMetadataRecorderTest, FirstContentfulPaintUpdate) {
  44. PageTimingMetadataRecorder::MonotonicTiming timing = {};
  45. // The PageTimingMetadataRecorder constructor is supposed to call
  46. // UpdateMetadata once, but due to class construction limitation, the
  47. // call to ApplyMetadataToPastSample will not be captured by test class,
  48. // as the test class is not ready yet.
  49. TestPageTimingMetadataRecorder recorder(timing);
  50. const std::vector<MetadataTaggingRequest>& requests =
  51. recorder.GetMetadataTaggingRequests();
  52. timing.navigation_start = base::TimeTicks::Now() - base::Milliseconds(500);
  53. timing.first_contentful_paint =
  54. *timing.navigation_start + base::Milliseconds(10);
  55. recorder.UpdateMetadata(timing);
  56. ASSERT_EQ(1u, requests.size());
  57. EXPECT_EQ(*timing.navigation_start, requests.at(0).period_start);
  58. EXPECT_EQ(*timing.first_contentful_paint, requests.at(0).period_end);
  59. EXPECT_EQ("PageLoad.PaintTiming.NavigationToFirstContentfulPaint",
  60. requests.at(0).name);
  61. // Update first contentful paint timetick should sends another request.
  62. timing.first_contentful_paint =
  63. *timing.navigation_start + base::Milliseconds(20);
  64. recorder.UpdateMetadata(timing);
  65. ASSERT_EQ(2u, requests.size());
  66. EXPECT_EQ(*timing.navigation_start, requests.at(1).period_start);
  67. EXPECT_EQ(*timing.first_contentful_paint, requests.at(1).period_end);
  68. EXPECT_EQ("PageLoad.PaintTiming.NavigationToFirstContentfulPaint",
  69. requests.at(1).name);
  70. // If nothing modified, should not send any requests.
  71. recorder.UpdateMetadata(timing);
  72. EXPECT_EQ(2u, requests.size());
  73. }
  74. TEST_F(PageTimingMetadataRecorderTest, FirstInputDelayUpdate) {
  75. PageTimingMetadataRecorder::MonotonicTiming timing = {};
  76. // The PageTimingMetadataRecorder constructor is supposed to call
  77. // UpdateMetadata once, but due to class construction limitation, the
  78. // call to ApplyMetadataToPastSample will not be captured by test class,
  79. // as the test class is not ready yet.
  80. TestPageTimingMetadataRecorder recorder(timing);
  81. const std::vector<MetadataTaggingRequest>& requests =
  82. recorder.GetMetadataTaggingRequests();
  83. timing.first_input_delay = base::Milliseconds(10);
  84. timing.first_input_timestamp = base::TimeTicks::Now();
  85. recorder.UpdateMetadata(timing);
  86. ASSERT_EQ(1u, requests.size());
  87. EXPECT_EQ(*timing.first_input_timestamp, requests.at(0).period_start);
  88. EXPECT_EQ(*timing.first_input_timestamp + *timing.first_input_delay,
  89. requests.at(0).period_end);
  90. EXPECT_EQ("PageLoad.InteractiveTiming.FirstInputDelay4", requests.at(0).name);
  91. // Update first input delay should sends another request.
  92. timing.first_input_delay = base::Milliseconds(11);
  93. recorder.UpdateMetadata(timing);
  94. ASSERT_EQ(2u, requests.size());
  95. EXPECT_EQ(*timing.first_input_timestamp, requests.at(1).period_start);
  96. EXPECT_EQ(*timing.first_input_timestamp + *timing.first_input_delay,
  97. requests.at(1).period_end);
  98. EXPECT_EQ("PageLoad.InteractiveTiming.FirstInputDelay4", requests.at(1).name);
  99. // If nothing modified, should not send any requests.
  100. recorder.UpdateMetadata(timing);
  101. EXPECT_EQ(2u, requests.size());
  102. }
  103. } // namespace page_load_metrics