Change type of MemoryCoordinatorImpl::ChildInfo::memory_state

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"
@@ skipping 98 matching lines @@
   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) {
+      int render_process_id, 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:
+  using MemoryState = base::MemoryState;
+
   void SetUp() override {
     scoped_feature_list_.InitAndEnableFeature(features::kMemoryCoordinator);
 
     task_runner_ = new base::TestMockTimeTaskRunner();
     coordinator_.reset(new TestMemoryCoordinatorImpl(task_runner_));
 
     base::MemoryCoordinatorProxy::GetInstance()->
         SetGetCurrentMemoryStateCallback(base::Bind(
             &MemoryCoordinatorImpl::GetCurrentMemoryState,
             base::Unretained(coordinator_.get())));
@@ skipping 18 matching lines @@
   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));
+      coordinator_->SetChildMemoryState(1, 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));
+      coordinator_->SetChildMemoryState(2, 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));
+      coordinator_->SetChildMemoryState(2, 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));
+      coordinator_->SetChildMemoryState(1, 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));
+      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);
   ASSERT_TRUE(iter != coordinator_->children().end());
 
   // Foreground
   iter->second.is_visible = true;
-  EXPECT_TRUE(coordinator_->SetChildMemoryState(1, mojom::MemoryState::NORMAL));
+  EXPECT_TRUE(coordinator_->SetChildMemoryState(1, MemoryState::NORMAL));
   EXPECT_EQ(mojom::MemoryState::NORMAL, cmc->state());
   EXPECT_TRUE(
-      coordinator_->SetChildMemoryState(1, mojom::MemoryState::THROTTLED));
+      coordinator_->SetChildMemoryState(1, MemoryState::THROTTLED));
   EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
   EXPECT_TRUE(
-      coordinator_->SetChildMemoryState(1, mojom::MemoryState::SUSPENDED));
+      coordinator_->SetChildMemoryState(1, MemoryState::SUSPENDED));
   EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
 
   // Background
   iter->second.is_visible = false;
-  EXPECT_TRUE(coordinator_->SetChildMemoryState(1, mojom::MemoryState::NORMAL));
+  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, mojom::MemoryState::THROTTLED));
+      coordinator_->SetChildMemoryState(1, MemoryState::THROTTLED));
   EXPECT_EQ(mojom::MemoryState::THROTTLED, cmc->state());
   EXPECT_TRUE(
-      coordinator_->SetChildMemoryState(1, mojom::MemoryState::SUSPENDED));
+      coordinator_->SetChildMemoryState(1, 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;
@@ skipping 168 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