system_node_impl_unittest.cc 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154
  1. // Copyright 2018 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/performance_manager/graph/system_node_impl.h"
  5. #include "base/memory/memory_pressure_listener.h"
  6. #include "base/memory/raw_ptr.h"
  7. #include "base/run_loop.h"
  8. #include "components/memory_pressure/fake_memory_pressure_monitor.h"
  9. #include "components/performance_manager/graph/frame_node_impl.h"
  10. #include "components/performance_manager/graph/page_node_impl.h"
  11. #include "components/performance_manager/graph/process_node_impl.h"
  12. #include "components/performance_manager/graph/system_node_impl.h"
  13. #include "components/performance_manager/test_support/graph_test_harness.h"
  14. #include "components/performance_manager/test_support/mock_graphs.h"
  15. #include "testing/gmock/include/gmock/gmock.h"
  16. #include "testing/gtest/include/gtest/gtest.h"
  17. namespace performance_manager {
  18. namespace {
  19. // Observer used to make sure that signals are dispatched correctly.
  20. class SystemObserver : public SystemNodeImpl::ObserverDefaultImpl {
  21. public:
  22. size_t system_event_seen_count() const { return system_event_seen_count_; }
  23. private:
  24. size_t system_event_seen_count_ = 0;
  25. };
  26. using SystemNodeImplTest = GraphTestHarness;
  27. } // namespace
  28. TEST_F(SystemNodeImplTest, SafeDowncast) {
  29. MockMultiplePagesWithMultipleProcessesGraph mock_graph(graph());
  30. auto& sys = mock_graph.system;
  31. SystemNode* node = sys.get();
  32. EXPECT_EQ(sys.get(), SystemNodeImpl::FromNode(node));
  33. NodeBase* base = sys.get();
  34. EXPECT_EQ(base, NodeBase::FromNode(node));
  35. EXPECT_EQ(static_cast<Node*>(node), base->ToNode());
  36. }
  37. using SystemNodeImplDeathTest = SystemNodeImplTest;
  38. TEST_F(SystemNodeImplDeathTest, SafeDowncast) {
  39. const NodeBase* system = NodeBase::FromNode(graph()->GetSystemNodeImpl());
  40. ASSERT_DEATH_IF_SUPPORTED(PageNodeImpl::FromNodeBase(system), "");
  41. }
  42. namespace {
  43. class LenientMockObserver : public SystemNodeImpl::Observer {
  44. public:
  45. LenientMockObserver() {}
  46. ~LenientMockObserver() override {}
  47. MOCK_METHOD1(OnProcessMemoryMetricsAvailable, void(const SystemNode*));
  48. MOCK_METHOD1(OnMemoryPressure,
  49. void(base::MemoryPressureListener::MemoryPressureLevel));
  50. MOCK_METHOD1(OnBeforeMemoryPressure,
  51. void(base::MemoryPressureListener::MemoryPressureLevel));
  52. void SetNotifiedSystemNode(const SystemNode* system_node) {
  53. notified_system_node_ = system_node;
  54. }
  55. const SystemNode* TakeNotifiedSystemNode() {
  56. const SystemNode* node = notified_system_node_;
  57. notified_system_node_ = nullptr;
  58. return node;
  59. }
  60. private:
  61. raw_ptr<const SystemNode> notified_system_node_ = nullptr;
  62. };
  63. using MockObserver = ::testing::StrictMock<LenientMockObserver>;
  64. using testing::_;
  65. using testing::Invoke;
  66. using testing::InvokeWithoutArgs;
  67. } // namespace
  68. TEST_F(SystemNodeImplTest, ObserverWorks) {
  69. MockObserver obs;
  70. graph()->AddSystemNodeObserver(&obs);
  71. const SystemNode* system_node = graph()->GetSystemNode();
  72. EXPECT_CALL(obs, OnProcessMemoryMetricsAvailable(_))
  73. .WillOnce(Invoke(&obs, &MockObserver::SetNotifiedSystemNode));
  74. SystemNodeImpl::FromNode(system_node)->OnProcessMemoryMetricsAvailable();
  75. EXPECT_EQ(system_node, obs.TakeNotifiedSystemNode());
  76. EXPECT_CALL(obs, OnBeforeMemoryPressure(
  77. base::MemoryPressureListener::MemoryPressureLevel::
  78. MEMORY_PRESSURE_LEVEL_CRITICAL));
  79. EXPECT_CALL(
  80. obs, OnMemoryPressure(base::MemoryPressureListener::MemoryPressureLevel::
  81. MEMORY_PRESSURE_LEVEL_CRITICAL));
  82. SystemNodeImpl::FromNode(system_node)
  83. ->OnMemoryPressureForTesting(
  84. base::MemoryPressureListener::MemoryPressureLevel::
  85. MEMORY_PRESSURE_LEVEL_CRITICAL);
  86. graph()->RemoveSystemNodeObserver(&obs);
  87. }
  88. TEST_F(SystemNodeImplTest, MemoryPressureNotification) {
  89. MockObserver obs;
  90. graph()->AddSystemNodeObserver(&obs);
  91. memory_pressure::test::FakeMemoryPressureMonitor mem_pressure_monitor;
  92. {
  93. base::RunLoop run_loop;
  94. auto quit_closure = run_loop.QuitClosure();
  95. EXPECT_CALL(obs, OnBeforeMemoryPressure(
  96. base::MemoryPressureListener::MemoryPressureLevel::
  97. MEMORY_PRESSURE_LEVEL_CRITICAL))
  98. .WillOnce(InvokeWithoutArgs([&]() { std::move(quit_closure).Run(); }));
  99. EXPECT_CALL(obs, OnMemoryPressure(
  100. base::MemoryPressureListener::MemoryPressureLevel::
  101. MEMORY_PRESSURE_LEVEL_CRITICAL));
  102. mem_pressure_monitor.SetAndNotifyMemoryPressure(
  103. base::MemoryPressureListener::MemoryPressureLevel::
  104. MEMORY_PRESSURE_LEVEL_CRITICAL);
  105. run_loop.Run();
  106. }
  107. {
  108. base::RunLoop run_loop;
  109. auto quit_closure = run_loop.QuitClosure();
  110. EXPECT_CALL(obs, OnBeforeMemoryPressure(
  111. base::MemoryPressureListener::MemoryPressureLevel::
  112. MEMORY_PRESSURE_LEVEL_MODERATE))
  113. .WillOnce(InvokeWithoutArgs([&]() { std::move(quit_closure).Run(); }));
  114. EXPECT_CALL(obs, OnMemoryPressure(
  115. base::MemoryPressureListener::MemoryPressureLevel::
  116. MEMORY_PRESSURE_LEVEL_MODERATE));
  117. mem_pressure_monitor.SetAndNotifyMemoryPressure(
  118. base::MemoryPressureListener::MemoryPressureLevel::
  119. MEMORY_PRESSURE_LEVEL_MODERATE);
  120. run_loop.Run();
  121. }
  122. graph()->RemoveSystemNodeObserver(&obs);
  123. }
  124. } // namespace performance_manager