Add tests for MemoryCoordinator::Can{Throttle,Suspend}Renderer()

content/browser/memory/memory_coordinator.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.h"
 
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/metrics/histogram_macros.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 55 matching lines @@
     mojom::MemoryCoordinatorHandleRequest request) {
   std::unique_ptr<MemoryCoordinatorHandleImpl> handle(
       new MemoryCoordinatorHandleImpl(std::move(request), this,
                                       render_process_id));
   handle->binding().set_connection_error_handler(
       base::Bind(&MemoryCoordinator::OnConnectionError, base::Unretained(this),
                  render_process_id));
   CreateChildInfoMapEntry(render_process_id, std::move(handle));
 }
 
-size_t MemoryCoordinator::NumChildrenForTesting() {
-  return children_.size();
-}
-
 bool MemoryCoordinator::SetChildMemoryState(int render_process_id,
                                             mojom::MemoryState memory_state) {
   // Can't set an invalid memory state.
   if (memory_state == mojom::MemoryState::UNKNOWN)
     return false;
 
   // Can't send a message to a child that doesn't exist.
   auto iter = children_.find(render_process_id);
   if (iter == children_.end())
     return false;
@@ skipping 71 matching lines @@
                                       dummy_render_process_id));
   handle->AddChild(std::move(child));
   CreateChildInfoMapEntry(dummy_render_process_id, std::move(handle));
 }
 
 void MemoryCoordinator::OnConnectionError(int render_process_id) {
   children_.erase(render_process_id);
 }
 
 bool MemoryCoordinator::CanThrottleRenderer(int render_process_id) {
-  // If there is no delegate (i.e. tests), renderers are always throttleable.
+  // If there is no delegate (i.e. unittests), renderers are always
+  // throttleable.
   // TODO(bashi): We check |delegate_| to avoid calling FromID() on a
   // wrong thread in tests. Figure out a better way to handle tests.
   if (!delegate_)
     return true;
   auto* render_process_host = RenderProcessHost::FromID(render_process_id);
   return render_process_host && render_process_host->IsProcessBackgrounded();
 }
 
 bool MemoryCoordinator::CanSuspendRenderer(int render_process_id) {
-  // If there is no delegate (i.e. tests), renderers are always suspendable.
+  // 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);
   if (!render_process_host || !render_process_host->IsProcessBackgrounded())
     return false;
   return delegate_->CanSuspendBackgroundedRenderer(render_process_id);
 }
 
+void MemoryCoordinator::SetDelegateForTesting(
+    std::unique_ptr<MemoryCoordinatorDelegate> delegate) {
+  CHECK(!delegate_);
+  delegate_ = std::move(delegate);
+}
+
 void MemoryCoordinator::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 = mojom::MemoryState::NORMAL;
   child_info.handle = std::move(handle);
 }
 
 MemoryCoordinator::ChildInfo::ChildInfo() {}
 
 MemoryCoordinator::ChildInfo::ChildInfo(const ChildInfo& rhs) {
   // This is a nop, but exists for compatibility with STL containers.
 }
 
 MemoryCoordinator::ChildInfo::~ChildInfo() {}
 
 }  // namespace content