Merge MemoryCoordinator and MemoryCoordinatorImpl into one class

content/browser/memory/memory_coordinator_impl_unittest.cc

 // Copyright 2016 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 "content/browser/memory/memory_coordinator_impl.h"
 
+#include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/memory_coordinator_proxy.h"
+#include "base/memory/memory_pressure_monitor.h"
+#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "content/browser/memory/memory_monitor.h"
 #include "content/browser/memory/memory_state_updater.h"
 #include "content/public/common/content_features.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
+void RunUntilIdle() {
+  base::RunLoop loop;
+  loop.RunUntilIdle();
+}
+
+// A mock ChildMemoryCoordinator, for testing interaction between MC and CMC.
+class MockChildMemoryCoordinator : public mojom::ChildMemoryCoordinator {
+ public:
+  MockChildMemoryCoordinator()
+      : state_(mojom::MemoryState::NORMAL),
+        on_state_change_calls_(0) {}
+
+  ~MockChildMemoryCoordinator() override {}
+
+  void OnStateChange(mojom::MemoryState state) override {
+    state_ = state;
+    ++on_state_change_calls_;
+  }
+
+  mojom::MemoryState state() const { return state_; }
+  int on_state_change_calls() const { return on_state_change_calls_; }
+
+ private:
+  mojom::MemoryState state_;
+  int on_state_change_calls_;
+};
+
+// A mock MemoryCoordinatorClient, for testing interaction between MC and
+// clients.
 class MockMemoryCoordinatorClient : public base::MemoryCoordinatorClient {
  public:
   void OnMemoryStateChange(base::MemoryState state) override {
     is_called_ = true;
     state_ = state;
   }
 
   bool is_called() { return is_called_; }
   base::MemoryState state() { return state_; }
 
  private:
   bool is_called_ = false;
   base::MemoryState state_ = base::MemoryState::NORMAL;
 };
 
-}  // namespace
-
 class MockMemoryMonitor : public MemoryMonitor {
  public:
   MockMemoryMonitor() {}
   ~MockMemoryMonitor() override {}
 
   void SetFreeMemoryUntilCriticalMB(int free_memory) {
     free_memory_ = free_memory;
   }
 
   // MemoryMonitor implementation
   int GetFreeMemoryUntilCriticalMB() override { return free_memory_; }
 
  private:
   int free_memory_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(MockMemoryMonitor);
 };
 
+// A MemoryCoordinatorImpl that can be directly constructed.
+class TestMemoryCoordinatorImpl : public MemoryCoordinatorImpl {
+ public:
+  // Mojo machinery for wrapping a mock ChildMemoryCoordinator.
+  struct Child {
+    Child(mojom::ChildMemoryCoordinatorPtr* cmc_ptr) : cmc_binding(&cmc) {
+      cmc_binding.Bind(mojo::GetProxy(cmc_ptr));
+      RunUntilIdle();
+    }
+
+    MockChildMemoryCoordinator cmc;
+    mojo::Binding<mojom::ChildMemoryCoordinator> cmc_binding;
+  };
+
+  TestMemoryCoordinatorImpl(
+      scoped_refptr<base::TestMockTimeTaskRunner> task_runner)
+      : MemoryCoordinatorImpl(task_runner,
+                              base::MakeUnique<MockMemoryMonitor>()) {}
+  ~TestMemoryCoordinatorImpl() override {}
+
+  using MemoryCoordinatorImpl::OnConnectionError;
+  using MemoryCoordinatorImpl::children;
+
+  MockChildMemoryCoordinator* CreateChildMemoryCoordinator(
+      int process_id) {
+    mojom::ChildMemoryCoordinatorPtr cmc_ptr;
+    children_.push_back(std::unique_ptr<Child>(new Child(&cmc_ptr)));
+    AddChildForTesting(process_id, std::move(cmc_ptr));
+    return &children_.back()->cmc;
+  }
+
+  // Wrapper of MemoryCoordinator::SetMemoryState that also calls RunUntilIdle.
+  bool SetChildMemoryState(
+      int render_process_id, mojom::MemoryState memory_state) {
+    bool result = MemoryCoordinatorImpl::SetChildMemoryState(
+        render_process_id, memory_state);
+    RunUntilIdle();
+    return result;
+  }
+
+  std::vector<std::unique_ptr<Child>> children_;
+};
+
+}  // namespace
+
 class MemoryCoordinatorImplTest : public testing::Test {
  public:
   void SetUp() override {
     scoped_feature_list_.InitAndEnableFeature(features::kMemoryCoordinator);
 
     task_runner_ = new base::TestMockTimeTaskRunner();
-    coordinator_.reset(new MemoryCoordinatorImpl(
-        task_runner_, base::WrapUnique(new MockMemoryMonitor)));
+    coordinator_.reset(new TestMemoryCoordinatorImpl(task_runner_));
 
     base::MemoryCoordinatorProxy::GetInstance()->
         SetGetCurrentMemoryStateCallback(base::Bind(
-            &MemoryCoordinator::GetCurrentMemoryState,
+            &MemoryCoordinatorImpl::GetCurrentMemoryState,
             base::Unretained(coordinator_.get())));
     base::MemoryCoordinatorProxy::GetInstance()->
         SetSetCurrentMemoryStateForTestingCallback(base::Bind(
-            &MemoryCoordinator::SetCurrentMemoryStateForTesting,
+            &MemoryCoordinatorImpl::SetCurrentMemoryStateForTesting,
             base::Unretained(coordinator_.get())));
   }
 
   MockMemoryMonitor* GetMockMemoryMonitor() {
     return static_cast<MockMemoryMonitor*>(coordinator_->memory_monitor());
   }
 
  protected:
-  std::unique_ptr<MemoryCoordinatorImpl> coordinator_;
+  std::unique_ptr<TestMemoryCoordinatorImpl> coordinator_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::MessageLoop message_loop_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
+TEST_F(MemoryCoordinatorImplTest, ChildRemovedOnConnectionError) {
+  coordinator_->CreateChildMemoryCoordinator(1);
+  ASSERT_EQ(1u, coordinator_->children().size());
+  coordinator_->OnConnectionError(1);
+  EXPECT_EQ(0u, coordinator_->children().size());
+}
+
+TEST_F(MemoryCoordinatorImplTest, SetMemoryStateFailsInvalidState) {
+  auto cmc1 = coordinator_->CreateChildMemoryCoordinator(1);
+
+  EXPECT_FALSE(
+      coordinator_->SetChildMemoryState(1, mojom::MemoryState::UNKNOWN));
+  EXPECT_EQ(0, cmc1->on_state_change_calls());
+}
+
+TEST_F(MemoryCoordinatorImplTest, SetMemoryStateFailsInvalidRenderer) {
+  auto cmc1 = coordinator_->CreateChildMemoryCoordinator(1);
+
+  EXPECT_FALSE(
+      coordinator_->SetChildMemoryState(2, mojom::MemoryState::THROTTLED));
+  EXPECT_EQ(0, cmc1->on_state_change_calls());
+}
+
+TEST_F(MemoryCoordinatorImplTest, SetMemoryStateNotDeliveredNop) {
+  auto cmc1 = coordinator_->CreateChildMemoryCoordinator(1);
+
+  EXPECT_FALSE(
+      coordinator_->SetChildMemoryState(2, mojom::MemoryState::NORMAL));
+  EXPECT_EQ(0, cmc1->on_state_change_calls());
+}
+
+TEST_F(MemoryCoordinatorImplTest, SetMemoryStateDelivered) {
+  auto cmc1 = coordinator_->CreateChildMemoryCoordinator(1);
+  auto cmc2 = coordinator_->CreateChildMemoryCoordinator(2);
+
+  EXPECT_TRUE(
+      coordinator_->SetChildMemoryState(1, mojom::MemoryState::THROTTLED));
+  EXPECT_EQ(1, cmc1->on_state_change_calls());
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc1->state());
+
+  EXPECT_TRUE(
+      coordinator_->SetChildMemoryState(2, mojom::MemoryState::SUSPENDED));
+  EXPECT_EQ(1, cmc2->on_state_change_calls());
+  // Child processes are considered as visible (foreground) by default,
+  // and visible ones won't be suspended but throttled.
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc2->state());
+}
+
+TEST_F(MemoryCoordinatorImplTest, SetChildMemoryState) {
+  auto cmc = coordinator_->CreateChildMemoryCoordinator(1);
+  auto iter = coordinator_->children().find(1);
+  ASSERT_TRUE(iter != coordinator_->children().end());
+
+  // Foreground
+  iter->second.is_visible = true;
+  EXPECT_TRUE(coordinator_->SetChildMemoryState(1, mojom::MemoryState::NORMAL));
+  EXPECT_EQ(mojom::MemoryState::NORMAL, cmc->state());
+  EXPECT_TRUE(
+      coordinator_->SetChildMemoryState(1, mojom::MemoryState::THROTTLED));
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
+  EXPECT_TRUE(
+      coordinator_->SetChildMemoryState(1, mojom::MemoryState::SUSPENDED));
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
+
+  // Background
+  iter->second.is_visible = false;
+  EXPECT_TRUE(coordinator_->SetChildMemoryState(1, mojom::MemoryState::NORMAL));
+#if defined(OS_ANDROID)
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
+#else
+  EXPECT_EQ(mojom::MemoryState::NORMAL, cmc->state());
+#endif
+  EXPECT_TRUE(
+      coordinator_->SetChildMemoryState(1, mojom::MemoryState::THROTTLED));
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
+  EXPECT_TRUE(
+      coordinator_->SetChildMemoryState(1, mojom::MemoryState::SUSPENDED));
+  EXPECT_EQ(mojom::MemoryState::SUSPENDED, cmc->state());
+}
+
 TEST_F(MemoryCoordinatorImplTest, CalculateNextState) {
   auto* state_updater = coordinator_->state_updater_.get();
   state_updater->expected_renderer_size_ = 10;
   state_updater->new_renderers_until_throttled_ = 4;
   state_updater->new_renderers_until_suspended_ = 2;
   state_updater->new_renderers_back_to_normal_ = 5;
   state_updater->new_renderers_back_to_throttled_ = 3;
   DCHECK(state_updater->ValidateParameters());
 
   // The default state is NORMAL.
@@ skipping 58 matching lines @@
   state_updater->new_renderers_back_to_throttled_ = 3;
   DCHECK(state_updater->ValidateParameters());
 
   {
     // Transition happens (NORMAL -> THROTTLED).
     MockMemoryCoordinatorClient client;
     base::MemoryCoordinatorClientRegistry::GetInstance()->Register(&client);
     coordinator_->current_state_ = base::MemoryState::NORMAL;
     GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(40);
     state_updater->UpdateState();
-    base::RunLoop loop;
-    loop.RunUntilIdle();
+    RunUntilIdle();
     EXPECT_TRUE(client.is_called());
     EXPECT_EQ(base::MemoryState::THROTTLED, client.state());
     base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(&client);
   }
 
   {
     // No transtion (NORMAL -> NORMAL). OnStateChange shouldn't be called.
     MockMemoryCoordinatorClient client;
     base::MemoryCoordinatorClientRegistry::GetInstance()->Register(&client);
     coordinator_->current_state_ = base::MemoryState::NORMAL;
     GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(50);
     state_updater->UpdateState();
-    base::RunLoop loop;
-    loop.RunUntilIdle();
+    RunUntilIdle();
     EXPECT_FALSE(client.is_called());
     EXPECT_EQ(base::MemoryState::NORMAL, client.state());
     base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(&client);
   }
 }
 
 TEST_F(MemoryCoordinatorImplTest, SetMemoryStateForTesting) {
   auto* state_updater = coordinator_->state_updater_.get();
   state_updater->expected_renderer_size_ = 10;
   state_updater->new_renderers_until_throttled_ = 4;
@@ skipping 19 matching lines @@
   EXPECT_EQ(base::MemoryState::THROTTLED,
             base::MemoryCoordinatorProxy::GetInstance()->
                 GetCurrentMemoryState());
 
   base::MemoryCoordinatorProxy::GetInstance()->SetCurrentMemoryStateForTesting(
       base::MemoryState::THROTTLED);
   EXPECT_EQ(base::MemoryState::THROTTLED,
             coordinator_->GetCurrentMemoryState());
   EXPECT_EQ(base::MemoryState::THROTTLED,
             base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
-  base::RunLoop loop;
-  loop.RunUntilIdle();
+            GetCurrentMemoryState());
+  RunUntilIdle();
   EXPECT_TRUE(client.is_called());
   EXPECT_EQ(base::MemoryState::THROTTLED, client.state());
   base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(&client);
 }
 
 TEST_F(MemoryCoordinatorImplTest, ForceSetGlobalState) {
   auto* state_updater = coordinator_->state_updater_.get();
   state_updater->expected_renderer_size_ = 10;
   state_updater->new_renderers_until_throttled_ = 4;
   state_updater->new_renderers_until_suspended_ = 2;
@@ skipping 32 matching lines @@
   // Also make sure that the state is updated based on free avaiable memory.
   // Since the global state has changed in the previous task, we have to wait
   // for |minimum_transition|.
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(40);
   task_runner_->FastForwardBy(minimum_transition);
   task_runner_->RunUntilIdle();
   EXPECT_EQ(base::MemoryState::THROTTLED, coordinator_->GetGlobalMemoryState());
 }
 
 }  // namespace content