memory coordinator: Purge memory under memory pressure

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/memory/ptr_util.h"
@@ skipping 48 matching lines @@
 
 // A mock MemoryCoordinatorClient, for testing interaction between MC and
 // clients.
 class MockMemoryCoordinatorClient : public base::MemoryCoordinatorClient {
  public:
   void OnMemoryStateChange(base::MemoryState state) override {
     did_state_changed_ = true;
     state_ = state;
   }
 
+  void OnPurgeMemory() override { ++purge_memory_calls_; }
+
   bool did_state_changed() const { return did_state_changed_; }
   base::MemoryState state() const { return state_; }
+  int purge_memory_calls() const { return purge_memory_calls_; }
 
  private:
   bool did_state_changed_ = false;
   base::MemoryState state_ = base::MemoryState::NORMAL;
+  int purge_memory_calls_ = 0;
 };
 
 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);
 };
 
 class TestMemoryCoordinatorDelegate : public MemoryCoordinatorDelegate {
  public:
   TestMemoryCoordinatorDelegate() {}
   ~TestMemoryCoordinatorDelegate() override {}
 
   bool CanSuspendBackgroundedRenderer(int render_process_id) override {
     return true;
   }
 
-  void DiscardTab() override { ++discard_tab_count_; }
+  bool DiscardTab() override {
+    const int kMaxDiscardTabCount = 2;
+    if (discard_tab_count_ >= kMaxDiscardTabCount)
+      return false;
+    ++discard_tab_count_;
+    return true;
+  }
 
   int discard_tab_count() const { return discard_tab_count_; }
 
  private:
   int discard_tab_count_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TestMemoryCoordinatorDelegate);
 };
 
 // A MemoryCoordinatorImpl that can be directly constructed.
@@ skipping 444 matching lines @@
   EXPECT_EQ(2, delegate->discard_tab_count());
 
   // Back to NORMAL. Tab discarding should stop.
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(50);
   task_runner_->FastForwardBy(interval);
   EXPECT_EQ(2, delegate->discard_tab_count());
   task_runner_->FastForwardBy(interval);
   EXPECT_EQ(2, delegate->discard_tab_count());
 }
 
+TEST_F(MemoryCoordinatorImplTest, OnWarningCondition) {
+  MockMemoryCoordinatorClient client;
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Register(&client);
+  auto* child1 = coordinator_->CreateChildMemoryCoordinator(1);
+  auto* child2 = coordinator_->CreateChildMemoryCoordinator(2);
+  base::TimeDelta interval =
+      coordinator_->background_child_purge_candidate_period_ +
+      base::TimeDelta::FromSeconds(1);
+
+  // child1: Foreground, child2: Background
+  coordinator_->OnChildVisibilityChanged(1, true);
+  coordinator_->OnChildVisibilityChanged(2, false);
+
+  // Note: we never ask foreground processes (including the browser process) to
+  // purge memory on WARNING condition.
+
+  // Don't ask the background child to purge until the child remains
+  // backgrounded for a certain period of time.
+  coordinator_->OnWarningCondition();
+  RunUntilIdle();
+  EXPECT_EQ(0, client.purge_memory_calls());
+  EXPECT_EQ(0, child1->purge_memory_calls());
+  EXPECT_EQ(0, child2->purge_memory_calls());
+
+  // After a certain period of time is passed, request the child to purge
+  // memory.
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnWarningCondition();
+  task_runner_->RunUntilIdle();
+  RunUntilIdle();
+  EXPECT_EQ(0, client.purge_memory_calls());
+  EXPECT_EQ(0, child1->purge_memory_calls());
+  EXPECT_EQ(1, child2->purge_memory_calls());
+
+  // Don't purge memory more than once when the child stays backgrounded.
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnWarningCondition();
+  RunUntilIdle();
+  EXPECT_EQ(0, client.purge_memory_calls());
+  EXPECT_EQ(0, child1->purge_memory_calls());
+  EXPECT_EQ(1, child2->purge_memory_calls());
+
+  // The background child goes to foreground, goes to background, then a
+  // certain period of time is passed. Another purging request should be sent.
+  coordinator_->OnChildVisibilityChanged(2, true);
+  coordinator_->OnChildVisibilityChanged(2, false);
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnWarningCondition();
+  RunUntilIdle();
+  EXPECT_EQ(0, client.purge_memory_calls());
+  EXPECT_EQ(0, child1->purge_memory_calls());
+  EXPECT_EQ(2, child2->purge_memory_calls());
+
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(&client);
+}
+
+TEST_F(MemoryCoordinatorImplTest, OnCriticalCondition) {
+  MockMemoryCoordinatorClient client;
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Register(&client);
+  auto* child1 = coordinator_->CreateChildMemoryCoordinator(1);
+  auto* child2 = coordinator_->CreateChildMemoryCoordinator(2);
+  auto* delegate = coordinator_->GetDelegate();
+  base::TimeDelta interval =
+      coordinator_->background_child_purge_candidate_period_ +
+      base::TimeDelta::FromSeconds(1);
+
+  // child1: Foreground, child2: Background
+  coordinator_->OnChildVisibilityChanged(1, true);
+  coordinator_->OnChildVisibilityChanged(2, false);
+
+  // Our mocked |delegate| allows discarding tab twice. While tab discarding
+  // succeeds we don't purge memory.
+  coordinator_->OnCriticalCondition();
+  task_runner_->RunUntilIdle();
+  RunUntilIdle();
+  EXPECT_EQ(1, delegate->discard_tab_count());
+  EXPECT_EQ(0, client.purge_memory_calls());
+  EXPECT_EQ(0, child1->purge_memory_calls());
+  EXPECT_EQ(0, child2->purge_memory_calls());
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnCriticalCondition();
+  RunUntilIdle();
+  EXPECT_EQ(2, delegate->discard_tab_count());
+  EXPECT_EQ(0, client.purge_memory_calls());
+  EXPECT_EQ(0, child1->purge_memory_calls());
+  EXPECT_EQ(0, child2->purge_memory_calls());
+
+  // Purge memory from all children regardless of their visibility.
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnCriticalCondition();
+  RunUntilIdle();
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnCriticalCondition();
+  RunUntilIdle();
+  EXPECT_EQ(2, delegate->discard_tab_count());
+  EXPECT_EQ(0, client.purge_memory_calls());
+  EXPECT_EQ(1, child1->purge_memory_calls());
+  EXPECT_EQ(1, child2->purge_memory_calls());
+
+  // Purge memory from browser process only after we asked all children to
+  // purge memory.
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnCriticalCondition();
+  RunUntilIdle();
+  EXPECT_EQ(2, delegate->discard_tab_count());
+  EXPECT_EQ(1, client.purge_memory_calls());
+  EXPECT_EQ(1, child1->purge_memory_calls());
+  EXPECT_EQ(1, child2->purge_memory_calls());
+
+  // Don't request purging for a certain period of time if we already requested.
+  task_runner_->FastForwardBy(interval);
+  coordinator_->OnCriticalCondition();
+  RunUntilIdle();
+  EXPECT_EQ(2, delegate->discard_tab_count());
+  EXPECT_EQ(1, client.purge_memory_calls());
+  EXPECT_EQ(1, child1->purge_memory_calls());
+  EXPECT_EQ(1, child2->purge_memory_calls());
+
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(&client);
+}
+
 #if defined(OS_ANDROID)
 // TODO(jcivelli): Broken on Android. http://crbug.com/678665
 #define MAYBE_GetStateForProcess DISABLED_GetStateForProcess
 #else
 #define MAYBE_GetStateForProcess GetStateForProcess
 #endif
 TEST_F(MemoryCoordinatorImplTest, MAYBE_GetStateForProcess) {
   EXPECT_EQ(base::MemoryState::UNKNOWN,
             coordinator_->GetStateForProcess(base::kNullProcessHandle));
   EXPECT_EQ(base::MemoryState::NORMAL,
@@ skipping 19 matching lines @@
 
   EXPECT_TRUE(
       coordinator_->SetChildMemoryState(1, MemoryState::THROTTLED));
   EXPECT_EQ(base::MemoryState::THROTTLED,
             coordinator_->GetStateForProcess(process1.Handle()));
   EXPECT_EQ(base::MemoryState::NORMAL,
             coordinator_->GetStateForProcess(process2.Handle()));
 }
 
 }  // namespace content