Use MockRenderProcessHost in memory coordinator unittests

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 "content/public/test/mock_render_process_host.h"
+#include "content/public/test/test_browser_context.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();
@@ skipping 49 matching lines @@
 
   // MemoryMonitor implementation
   int GetFreeMemoryUntilCriticalMB() override { return free_memory_; }
 
  private:
   int free_memory_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(MockMemoryMonitor);
 };
 
+class TestMemoryCoordinatorDelegate : public MemoryCoordinatorDelegate {
+ public:
+  TestMemoryCoordinatorDelegate() {}
+  ~TestMemoryCoordinatorDelegate() override {}
+
+  bool CanSuspendBackgroundedRenderer(int render_process_id) override {
+    return true;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestMemoryCoordinatorDelegate);
+};
+
 // 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>()) {}
+                              base::MakeUnique<MockMemoryMonitor>()) {
+    SetDelegateForTesting(base::MakeUnique<TestMemoryCoordinatorDelegate>());
+  }
+
   ~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));
+    render_process_hosts_[process_id] =
+        base::MakeUnique<MockRenderProcessHost>(&browser_context_);
     return &children_.back()->cmc;
   }
 
+  RenderProcessHost* GetRenderProcessHost(int render_process_id) override {
+    return GetMockRenderProcessHost(render_process_id);
+  }
+
+  MockRenderProcessHost* GetMockRenderProcessHost(int render_process_id) {
+    auto iter = render_process_hosts_.find(render_process_id);
+    if (iter == render_process_hosts_.end())
+      return nullptr;
+    return iter->second.get();
+  }
+
   // Wrapper of MemoryCoordinator::SetMemoryState that also calls RunUntilIdle.
   bool SetChildMemoryState(
       int render_process_id, MemoryState memory_state) {
     bool result = MemoryCoordinatorImpl::SetChildMemoryState(
         render_process_id, memory_state);
     RunUntilIdle();
     return result;
   }
 
+  TestBrowserContext browser_context_;
   std::vector<std::unique_ptr<Child>> children_;
+  std::map<int, std::unique_ptr<MockRenderProcessHost>> render_process_hosts_;
 };
 
 }  // namespace
 
 class MemoryCoordinatorImplTest : public testing::Test {
  public:
   using MemoryState = base::MemoryState;
 
   void SetUp() override {
     scoped_feature_list_.InitAndEnableFeature(features::kMemoryCoordinator);
@@ skipping 66 matching lines @@
       coordinator_->SetChildMemoryState(2, 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);
+  auto* render_process_host = coordinator_->GetMockRenderProcessHost(1);
   ASSERT_TRUE(iter != coordinator_->children().end());
+  ASSERT_TRUE(render_process_host);
 
   // Foreground
   iter->second.is_visible = true;
+  render_process_host->set_is_process_backgrounded(false);
   EXPECT_TRUE(coordinator_->SetChildMemoryState(1, MemoryState::NORMAL));
   EXPECT_EQ(mojom::MemoryState::NORMAL, cmc->state());
   EXPECT_TRUE(
       coordinator_->SetChildMemoryState(1, MemoryState::THROTTLED));
   EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
   EXPECT_TRUE(
       coordinator_->SetChildMemoryState(1, MemoryState::SUSPENDED));
   EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
 
   // Background
   iter->second.is_visible = false;
+  render_process_host->set_is_process_backgrounded(true);
   EXPECT_TRUE(coordinator_->SetChildMemoryState(1, 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, MemoryState::THROTTLED));
   EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
   EXPECT_TRUE(
       coordinator_->SetChildMemoryState(1, MemoryState::SUSPENDED));
   EXPECT_EQ(mojom::MemoryState::SUSPENDED, cmc->state());
+
+  // Background but there are workers
+  render_process_host->IncrementServiceWorkerRefCount();
+  EXPECT_TRUE(
+      coordinator_->SetChildMemoryState(1, MemoryState::THROTTLED));
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
+  EXPECT_FALSE(
+      coordinator_->SetChildMemoryState(1, MemoryState::SUSPENDED));
+  EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
+  render_process_host->DecrementSharedWorkerRefCount();
 }
 
 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());
@@ skipping 167 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