Use MockRenderProcessHost in memory coordinator unittests

content/browser/memory/memory_coordinator_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_MEMORY_MEMORY_COORDINATOR_IMPL_H_
 #define CONTENT_BROWSER_MEMORY_MEMORY_COORDINATOR_IMPL_H_
 
 #include "base/callback.h"
 #include "base/memory/memory_coordinator_client.h"
 #include "base/memory/memory_pressure_monitor.h"
@@ skipping 10 matching lines @@
 namespace content {
 
 // NOTE: Memory coordinator is under development and not fully working.
 // TODO(bashi): Add content::MemoryCoordinator which is a pure virtual
 // interface to expose APIs outside content/.
 
 class MemoryCoordinatorHandleImpl;
 class MemoryCoordinatorImplTest;
 class MemoryMonitor;
 class MemoryStateUpdater;
+class RenderProcessHost;
 struct MemoryCoordinatorSingletonTraits;
 
 // MemoryCoordinatorImpl is an implementation of MemoryCoordinator.
 // The current implementation uses MemoryStateUpdater to update the global
 // memory state. See comments in MemoryStateUpdater for details.
 class CONTENT_EXPORT MemoryCoordinatorImpl : public NotificationObserver,
                                              public base::NonThreadSafe {
  public:
   using MemoryState = base::MemoryState;
 
@@ skipping 48 matching lines @@
   // remains the same until |duration| is passed or another call of this method.
   void ForceSetGlobalState(base::MemoryState new_state,
                            base::TimeDelta duration);
 
   // Changes the global state and notifies state changes to clients (lives in
   // the browser) and child processes (renderers) if needed. Returns true when
   // the state is actually changed.
   bool ChangeStateIfNeeded(MemoryState prev_state, MemoryState next_state);
 
  protected:
+  // Returns the RenderProcessHost which is correspond to the given id.
+  // Returns nullptr if there is no corresponding RenderProcessHost.
+  // This is a virtual method so that we can write tests without having
+  // actual RenderProcessHost.
+  virtual RenderProcessHost* GetRenderProcessHost(int render_process_id);
+
+  // Sets a delegate for testing.
+  void SetDelegateForTesting(
+      std::unique_ptr<MemoryCoordinatorDelegate> delegate);
+
   // Adds the given ChildMemoryCoordinator as a child of this coordinator.
   void AddChildForTesting(int dummy_render_process_id,
                           mojom::ChildMemoryCoordinatorPtr child);
 
   // Callback invoked by mojo when the child connection goes down. Exposed
   // for testing.
   void OnConnectionError(int render_process_id);
 
   // Returns true when a given renderer can be suspended.
   bool CanSuspendRenderer(int render_process_id);
@@ skipping 32 matching lines @@
   friend class MemoryCoordinatorHandleImpl;
 
   // Called when ChildMemoryCoordinator calls AddChild().
   void OnChildAdded(int render_process_id);
 
   // Called by SetChildMemoryState() to determine a child memory state based on
   // the current status of the child process.
   MemoryState OverrideGlobalState(MemoryState memroy_state,
                                   const ChildInfo& child);
 
-  void SetDelegateForTesting(
-      std::unique_ptr<MemoryCoordinatorDelegate> delegate);
-
   // Helper function of CreateHandle and AddChildForTesting.
   void CreateChildInfoMapEntry(
       int render_process_id,
       std::unique_ptr<MemoryCoordinatorHandleImpl> handle);
 
   // Notifies a state change to in-process clients.
   void NotifyStateToClients();
 
   // Notifies a state change to child processes.
   void NotifyStateToChildren();
@@ skipping 15 matching lines @@
   // MemoryCoordinator and removed automatically when an underlying binding is
   // disconnected.
   ChildInfoMap children_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryCoordinatorImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_MEMORY_MEMORY_COORDINATOR_IMPL_H_