Refactor MemoryCoordinatorProxy

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_coordinator_proxy.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.
 
 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 MemoryCoordinator,
+class CONTENT_EXPORT MemoryCoordinatorImpl : public base::MemoryCoordinator,
+                                             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 21 matching lines @@
   // TODO(bashi): Remove this when MemoryPressureMonitor is retired.
   void RecordMemoryPressure(
       base::MemoryPressureMonitor::MemoryPressureLevel level);
 
   // Returns the global memory state.
   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;
+  MemoryState GetCurrentMemoryState() const override;
 
   // Sets the global memory state for testing.
-  void SetCurrentMemoryStateForTesting(MemoryState memory_state);
+  void SetCurrentMemoryStateForTesting(MemoryState memory_state) override;
 
   // 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
@@ skipping 98 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_