components/performance_manager/graph/system_node_impl_unittest.cc

// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/performance_manager/graph/system_node_impl.h"

#include "base/memory/memory_pressure_listener.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "components/memory_pressure/fake_memory_pressure_monitor.h"
#include "components/performance_manager/graph/frame_node_impl.h"
#include "components/performance_manager/graph/page_node_impl.h"
#include "components/performance_manager/graph/process_node_impl.h"
#include "components/performance_manager/test_support/graph_test_harness.h"
#include "components/performance_manager/test_support/mock_graphs.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace performance_manager {

namespace {

// Observer used to make sure that signals are dispatched correctly.
class SystemObserver : public SystemNodeImpl::ObserverDefaultImpl {
 public:
  size_t system_event_seen_count() const { return system_event_seen_count_; }

 private:
  size_t system_event_seen_count_ = 0;
};

using SystemNodeImplTest = GraphTestHarness;

}  // namespace

TEST_F(SystemNodeImplTest, SafeDowncast) {
  MockMultiplePagesWithMultipleProcessesGraph mock_graph(graph());
  auto& sys = mock_graph.system;
  SystemNode* node = sys.get();
  EXPECT_EQ(sys.get(), SystemNodeImpl::FromNode(node));
  NodeBase* base = sys.get();
  EXPECT_EQ(base, NodeBase::FromNode(node));
  EXPECT_EQ(static_cast<Node*>(node), base->ToNode());
}

using SystemNodeImplDeathTest = SystemNodeImplTest;

TEST_F(SystemNodeImplDeathTest, SafeDowncast) {
  const NodeBase* system = NodeBase::FromNode(graph()->GetSystemNodeImpl());
  ASSERT_DEATH_IF_SUPPORTED(PageNodeImpl::FromNodeBase(system), "");
}

namespace {

class LenientMockObserver : public SystemNodeImpl::Observer {
 public:
  LenientMockObserver() {}
  ~LenientMockObserver() override {}

  MOCK_METHOD1(OnProcessMemoryMetricsAvailable, void(const SystemNode*));
  MOCK_METHOD1(OnMemoryPressure,
               void(base::MemoryPressureListener::MemoryPressureLevel));
  MOCK_METHOD1(OnBeforeMemoryPressure,
               void(base::MemoryPressureListener::MemoryPressureLevel));

  void SetNotifiedSystemNode(const SystemNode* system_node) {
    notified_system_node_ = system_node;
  }

  const SystemNode* TakeNotifiedSystemNode() {
    const SystemNode* node = notified_system_node_;
    notified_system_node_ = nullptr;
    return node;
  }

 private:
  raw_ptr<const SystemNode> notified_system_node_ = nullptr;
};

using MockObserver = ::testing::StrictMock<LenientMockObserver>;

using testing::_;
using testing::Invoke;
using testing::InvokeWithoutArgs;

}  // namespace

TEST_F(SystemNodeImplTest, ObserverWorks) {
  MockObserver obs;
  graph()->AddSystemNodeObserver(&obs);

  const SystemNode* system_node = graph()->GetSystemNode();

  EXPECT_CALL(obs, OnProcessMemoryMetricsAvailable(_))
      .WillOnce(Invoke(&obs, &MockObserver::SetNotifiedSystemNode));
  SystemNodeImpl::FromNode(system_node)->OnProcessMemoryMetricsAvailable();
  EXPECT_EQ(system_node, obs.TakeNotifiedSystemNode());

  EXPECT_CALL(obs, OnBeforeMemoryPressure(
                       base::MemoryPressureListener::MemoryPressureLevel::
                           MEMORY_PRESSURE_LEVEL_CRITICAL));
  EXPECT_CALL(
      obs, OnMemoryPressure(base::MemoryPressureListener::MemoryPressureLevel::
                                MEMORY_PRESSURE_LEVEL_CRITICAL));
  SystemNodeImpl::FromNode(system_node)
      ->OnMemoryPressureForTesting(
          base::MemoryPressureListener::MemoryPressureLevel::
              MEMORY_PRESSURE_LEVEL_CRITICAL);

  graph()->RemoveSystemNodeObserver(&obs);
}

TEST_F(SystemNodeImplTest, MemoryPressureNotification) {
  MockObserver obs;
  graph()->AddSystemNodeObserver(&obs);
  memory_pressure::test::FakeMemoryPressureMonitor mem_pressure_monitor;

  {
    base::RunLoop run_loop;
    auto quit_closure = run_loop.QuitClosure();
    EXPECT_CALL(obs, OnBeforeMemoryPressure(
                         base::MemoryPressureListener::MemoryPressureLevel::
                             MEMORY_PRESSURE_LEVEL_CRITICAL))
        .WillOnce(InvokeWithoutArgs([&]() { std::move(quit_closure).Run(); }));
    EXPECT_CALL(obs, OnMemoryPressure(
                         base::MemoryPressureListener::MemoryPressureLevel::
                             MEMORY_PRESSURE_LEVEL_CRITICAL));
    mem_pressure_monitor.SetAndNotifyMemoryPressure(
        base::MemoryPressureListener::MemoryPressureLevel::
            MEMORY_PRESSURE_LEVEL_CRITICAL);
    run_loop.Run();
  }

  {
    base::RunLoop run_loop;
    auto quit_closure = run_loop.QuitClosure();
    EXPECT_CALL(obs, OnBeforeMemoryPressure(
                         base::MemoryPressureListener::MemoryPressureLevel::
                             MEMORY_PRESSURE_LEVEL_MODERATE))
        .WillOnce(InvokeWithoutArgs([&]() { std::move(quit_closure).Run(); }));
    EXPECT_CALL(obs, OnMemoryPressure(
                         base::MemoryPressureListener::MemoryPressureLevel::
                             MEMORY_PRESSURE_LEVEL_MODERATE));
    mem_pressure_monitor.SetAndNotifyMemoryPressure(
        base::MemoryPressureListener::MemoryPressureLevel::
            MEMORY_PRESSURE_LEVEL_MODERATE);
    run_loop.Run();
  }

  graph()->RemoveSystemNodeObserver(&obs);
}

}  // namespace performance_manager