Use MockRenderProcessHost in memory coordinator unittests

content/browser/memory/memory_coordinator_impl.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/metrics/histogram_macros.h"
 #include "base/process/process_handle.h"
 #include "base/process/process_metrics.h"
@@ skipping 298 matching lines @@
   TRACE_EVENT2("memory-infra", "MemoryCoordinatorImpl::ChangeStateIfNeeded",
                "prev", MemoryStateToString(prev_state),
                "next", MemoryStateToString(next_state));
   RecordStateChange(prev_state, next_state,
                     last_state_change_ - prev_last_state_change);
   NotifyStateToClients();
   NotifyStateToChildren();
   return true;
 }
 
+RenderProcessHost* MemoryCoordinatorImpl::GetRenderProcessHost(
+    int render_process_id) {
+  return RenderProcessHost::FromID(render_process_id);
+}
+
+void MemoryCoordinatorImpl::SetDelegateForTesting(
+    std::unique_ptr<MemoryCoordinatorDelegate> delegate) {
+  CHECK(!delegate_);
+  delegate_ = std::move(delegate);
+}
+
 void MemoryCoordinatorImpl::AddChildForTesting(
     int dummy_render_process_id, mojom::ChildMemoryCoordinatorPtr child) {
   mojom::MemoryCoordinatorHandlePtr mch;
   auto request = mojo::GetProxy(&mch);
   std::unique_ptr<MemoryCoordinatorHandleImpl> handle(
       new MemoryCoordinatorHandleImpl(std::move(request), this,
                                       dummy_render_process_id));
   handle->AddChild(std::move(child));
   CreateChildInfoMapEntry(dummy_render_process_id, std::move(handle));
 }
 
 void MemoryCoordinatorImpl::OnConnectionError(int render_process_id) {
   children_.erase(render_process_id);
 }
 
 bool MemoryCoordinatorImpl::CanSuspendRenderer(int render_process_id) {
-  // If there is no delegate (i.e. unittests), renderers are always suspendable.
-  if (!delegate_)
-    return true;
-  auto* render_process_host = RenderProcessHost::FromID(render_process_id);
+  auto* render_process_host = GetRenderProcessHost(render_process_id);
   if (!render_process_host || !render_process_host->IsProcessBackgrounded())
     return false;
   if (render_process_host->GetWorkerRefCount() > 0)
     return false;
+  // Assumes that we can't suspend renderers if there is no delegate.
+  if (!delegate_)
+    return false;
   return delegate_->CanSuspendBackgroundedRenderer(render_process_id);
 }
 
 void MemoryCoordinatorImpl::OnChildAdded(int render_process_id) {
   // Populate the global state as an initial state of a newly created process.
   auto new_state = GetGlobalMemoryState();
   SetChildMemoryState(render_process_id, new_state);
 }
 
 base::MemoryState MemoryCoordinatorImpl::OverrideGlobalState(
     MemoryState memory_state,
     const ChildInfo& child) {
   // We don't suspend foreground renderers. Throttle them instead.
   if (child.is_visible && memory_state == MemoryState::SUSPENDED)
     return MemoryState::THROTTLED;
 #if defined(OS_ANDROID)
   // On Android, we throttle background renderers immediately.
   // TODO(bashi): Create a specialized class of MemoryCoordinator for Android
   // and move this ifdef to the class.
   if (!child.is_visible && memory_state == MemoryState::NORMAL)
     return MemoryState::THROTTLED;
   // TODO(bashi): Suspend background renderers after a certain period of time.
 #endif  // defined(OS_ANDROID)
   return memory_state;
 }
 
-void MemoryCoordinatorImpl::SetDelegateForTesting(
-    std::unique_ptr<MemoryCoordinatorDelegate> delegate) {
-  CHECK(!delegate_);
-  delegate_ = std::move(delegate);
-}
-
 void MemoryCoordinatorImpl::CreateChildInfoMapEntry(
     int render_process_id,
     std::unique_ptr<MemoryCoordinatorHandleImpl> handle) {
   auto& child_info = children_[render_process_id];
   // Process always start with normal memory state.
   // We'll set renderer's memory state to the current global state when the
   // corresponding renderer process is ready to communicate. Renderer processes
   // call AddChild() when they are ready.
   child_info.memory_state = MemoryState::NORMAL;
   child_info.is_visible = true;
@@ skipping 19 matching lines @@
 
   // TODO(bashi): On MacOS we can't get process metrics for child processes and
   // therefore can't calculate the total private memory.
 #if !defined(OS_MACOSX)
   auto browser_metrics = base::ProcessMetrics::CreateCurrentProcessMetrics();
   base::WorkingSetKBytes working_set;
   browser_metrics->GetWorkingSetKBytes(&working_set);
   total_private_kb += working_set.priv;
 
   for (auto& iter : children()) {
-    auto* render_process_host = RenderProcessHost::FromID(iter.first);
+    auto* render_process_host = GetRenderProcessHost(iter.first);
     if (!render_process_host ||
         render_process_host->GetHandle() == base::kNullProcessHandle)
       continue;
     auto metrics = base::ProcessMetrics::CreateProcessMetrics(
         render_process_host->GetHandle());
     metrics->GetWorkingSetKBytes(&working_set);
     total_private_kb += working_set.priv;
   }
 #endif
 
   RecordMetricsOnStateChange(prev_state, next_state, duration,
                              total_private_kb / 1024);
 }
 
 MemoryCoordinatorImpl::ChildInfo::ChildInfo() {}
 
 MemoryCoordinatorImpl::ChildInfo::ChildInfo(const ChildInfo& rhs) {
   // This is a nop, but exists for compatibility with STL containers.
 }
 
 MemoryCoordinatorImpl::ChildInfo::~ChildInfo() {}
 
 }  // namespace content