Add a public interface for content::MemoryCoordinator

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"
 #include "base/memory/singleton.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "content/common/content_export.h"
 #include "content/common/memory_coordinator.mojom.h"
+#include "content/public/browser/memory_coordinator.h"
 #include "content/public/browser/memory_coordinator_delegate.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 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,
+class CONTENT_EXPORT MemoryCoordinatorImpl : public MemoryCoordinator,
+                                             public NotificationObserver,
                                              public base::NonThreadSafe {
  public:
   using MemoryState = base::MemoryState;
 
   static MemoryCoordinatorImpl* GetInstance();
 
   MemoryCoordinatorImpl(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                         std::unique_ptr<MemoryMonitor> monitor);
   ~MemoryCoordinatorImpl() override;
 
@@ skipping 25 matching lines @@
   virtual MemoryState GetGlobalMemoryState() const;
 
   // Returns the browser's current memory state. Note that the current state
   // could be different from the global memory state as the browser won't be
   // suspended.
   MemoryState GetCurrentMemoryState() const;
 
   // Sets the global memory state for testing.
   void SetCurrentMemoryStateForTesting(MemoryState memory_state);
 
+  // MemoryCoordinator implementation:
+  MemoryState GetStateForProcess(base::ProcessHandle handle) override;
+
   // NotificationObserver implementation:
   void Observe(int type,
                const NotificationSource& source,
                const NotificationDetails& details) override;
 
   // Overrides the global state to |new_state|. State update tasks won't be
   // scheduled until |duration| is passed. This means that the global state
   // remains the same until |duration| is passed or another call of this method.
   void ForceSetGlobalState(base::MemoryState new_state,
                            base::TimeDelta duration);
@@ skipping 94 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_