Stop using callbacks in MemoryCoordinatorProxy

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_proxy.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/test_mock_time_task_runner.h"
@@ skipping 42 matching lines @@
 
 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)));
 
-    base::MemoryCoordinatorProxy::GetInstance()->
-        SetGetCurrentMemoryStateCallback(base::Bind(
-            &MemoryCoordinator::GetCurrentMemoryState,
-            base::Unretained(coordinator_.get())));
-    base::MemoryCoordinatorProxy::GetInstance()->
-        SetSetCurrentMemoryStateForTestingCallback(base::Bind(
-            &MemoryCoordinator::SetCurrentMemoryStateForTesting,
-            base::Unretained(coordinator_.get())));
+    base::MemoryCoordinatorProxy::GetInstance()->Set(
+        coordinator_->GetWeakPtr());
   }
 
   MockMemoryMonitor* GetMockMemoryMonitor() {
     return static_cast<MockMemoryMonitor*>(coordinator_->memory_monitor());
   }
 
  protected:
   std::unique_ptr<MemoryCoordinatorImpl> coordinator_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::MessageLoop message_loop_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 TEST_F(MemoryCoordinatorImplTest, CalculateNextState) {
   coordinator_->expected_renderer_size_ = 10;
   coordinator_->new_renderers_until_throttled_ = 4;
   coordinator_->new_renderers_until_suspended_ = 2;
   coordinator_->new_renderers_back_to_normal_ = 5;
   coordinator_->new_renderers_back_to_throttled_ = 3;
   DCHECK(coordinator_->ValidateParameters());
 
   // The default state is NORMAL.
-  EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->GetCurrentMemoryState());
+  EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::NORMAL,
             base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
+                GetLocalMemoryState());
 
   // Transitions from NORMAL
   coordinator_->current_state_ = base::MemoryState::NORMAL;
-  EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->GetCurrentMemoryState());
+  EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::NORMAL,
             base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
+                GetLocalMemoryState());
 
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(50);
   EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->CalculateNextState());
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(40);
   EXPECT_EQ(base::MemoryState::THROTTLED, coordinator_->CalculateNextState());
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(20);
   EXPECT_EQ(base::MemoryState::SUSPENDED, coordinator_->CalculateNextState());
 
   // Transitions from THROTTLED
   coordinator_->current_state_ = base::MemoryState::THROTTLED;
   EXPECT_EQ(base::MemoryState::THROTTLED,
-            coordinator_->GetCurrentMemoryState());
+            coordinator_->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::THROTTLED,
             base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
+                GetLocalMemoryState());
 
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(40);
   EXPECT_EQ(base::MemoryState::THROTTLED, coordinator_->CalculateNextState());
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(50);
   EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->CalculateNextState());
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(20);
   EXPECT_EQ(base::MemoryState::SUSPENDED, coordinator_->CalculateNextState());
 
   // Transitions from SUSPENDED
   coordinator_->current_state_ = base::MemoryState::SUSPENDED;
-  // GetCurrentMemoryState() returns THROTTLED state for the browser process
+  // GetLocalMemoryState() returns THROTTLED state for the browser process
   // when the global state is SUSPENDED.
   EXPECT_EQ(base::MemoryState::THROTTLED,
-            coordinator_->GetCurrentMemoryState());
+            coordinator_->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::THROTTLED,
             base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
+                GetLocalMemoryState());
 
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(20);
   EXPECT_EQ(base::MemoryState::SUSPENDED, coordinator_->CalculateNextState());
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(30);
   EXPECT_EQ(base::MemoryState::THROTTLED, coordinator_->CalculateNextState());
   GetMockMemoryMonitor()->SetFreeMemoryUntilCriticalMB(50);
   EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->CalculateNextState());
 }
 
 TEST_F(MemoryCoordinatorImplTest, UpdateState) {
@@ skipping 36 matching lines @@
 TEST_F(MemoryCoordinatorImplTest, SetMemoryStateForTesting) {
   coordinator_->expected_renderer_size_ = 10;
   coordinator_->new_renderers_until_throttled_ = 4;
   coordinator_->new_renderers_until_suspended_ = 2;
   coordinator_->new_renderers_back_to_normal_ = 5;
   coordinator_->new_renderers_back_to_throttled_ = 3;
   DCHECK(coordinator_->ValidateParameters());
 
   MockMemoryCoordinatorClient client;
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(&client);
-  EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->GetCurrentMemoryState());
+  EXPECT_EQ(base::MemoryState::NORMAL, coordinator_->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::NORMAL,
-            base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
+            base::MemoryCoordinatorProxy::GetInstance()->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::NORMAL, client.state());
 
-  base::MemoryCoordinatorProxy::GetInstance()->SetCurrentMemoryStateForTesting(
+  base::MemoryCoordinatorProxy::GetInstance()->SetMemoryStateForTesting(
       base::MemoryState::SUSPENDED);
-  // GetCurrentMemoryState() returns THROTTLED state for the browser process
+  // GetLocalMemoryState() returns THROTTLED state for the browser process
   // when the global state is SUSPENDED.
   EXPECT_EQ(base::MemoryState::THROTTLED,
-            coordinator_->GetCurrentMemoryState());
+            coordinator_->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::THROTTLED,
-            base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
+            base::MemoryCoordinatorProxy::GetInstance()->GetLocalMemoryState());
 
-  base::MemoryCoordinatorProxy::GetInstance()->SetCurrentMemoryStateForTesting(
+  base::MemoryCoordinatorProxy::GetInstance()->SetMemoryStateForTesting(
       base::MemoryState::THROTTLED);
   EXPECT_EQ(base::MemoryState::THROTTLED,
-            coordinator_->GetCurrentMemoryState());
+            coordinator_->GetLocalMemoryState());
   EXPECT_EQ(base::MemoryState::THROTTLED,
-            base::MemoryCoordinatorProxy::GetInstance()->
-                GetCurrentMemoryState());
+            base::MemoryCoordinatorProxy::GetInstance()->GetLocalMemoryState());
   base::RunLoop loop;
   loop.RunUntilIdle();
   EXPECT_TRUE(client.is_called());
   EXPECT_EQ(base::MemoryState::THROTTLED, client.state());
   base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(&client);
 }
 
 TEST_F(MemoryCoordinatorImplTest, ForceSetGlobalState) {
   coordinator_->expected_renderer_size_ = 10;
   coordinator_->new_renderers_until_throttled_ = 4;
@@ skipping 33 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