Stop using callbacks in 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/singleton.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 18 matching lines @@
 //
 // State calculation:
 // MemoryCoordinatorImpl uses followings to determine the global state:
 // * Compute "number of renderers which can be created until the system will
 //   be in a critical state". Call this N.
 //   (See memory_monitor.h for the definition of "critical")
 // * Covert N to a memory state using some thresholds/hysteresis for each state.
 //   Once a state is changed to a limited state, larger N will be needed to go
 //   back to a relaxed state. (e.g. THROTTLED -> NORMAL)
 // * Once a state is changed, it remains the same for a certain period of time.
-class CONTENT_EXPORT MemoryCoordinatorImpl : public MemoryCoordinator,
-                                             public NotificationObserver,
-                                             public base::NonThreadSafe {
+class CONTENT_EXPORT MemoryCoordinatorImpl
+    : public MemoryCoordinator,
+      public NotificationObserver,
+      public base::MemoryCoordinatorInterface,

[chrisha, 2016/12/13 15:42:47]

I'm not sure we need multiple inheritance here.

Rather, I'd define a private MemoryCoordinatorInterface implementation in the
.cc file, that wraps the necessary functions, and forwards them to the
MemoryCoordinatorImpl? Then an accessor to get a pointer to that particular
interface?

This is the most flexible in the long run, as MemoryCoordinator and
base::MemoryCoordinatorInterface end up having functions with the same name at
some point...

+      public base::NonThreadSafe {
  public:
   MemoryCoordinatorImpl(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                         std::unique_ptr<MemoryMonitor> monitor);
   ~MemoryCoordinatorImpl() override;
 
+  MemoryMonitor* memory_monitor() { return memory_monitor_.get(); }
+
   // MemoryCoordinator implementations:
   void Start() override;
   void OnChildAdded(int render_process_id) override;
 
-  MemoryMonitor* memory_monitor() { return memory_monitor_.get(); }
+  base::MemoryState GetGlobalMemoryState() const override;
 
-  base::MemoryState GetGlobalMemoryState() const override;
-  base::MemoryState GetCurrentMemoryState() const override;
-  void SetCurrentMemoryStateForTesting(base::MemoryState memory_state) override;
+  base::WeakPtr<base::MemoryCoordinatorInterface> GetWeakPtr() override;
+
+  // base::MemoryCoordinatorInterface implementations:
+  base::MemoryState GetLocalMemoryState() override;
+  void SetMemoryStateForTesting(base::MemoryState state) 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,
@@ skipping 77 matching lines @@
   base::TimeDelta monitoring_interval_;
 
   base::WeakPtrFactory<MemoryCoordinatorImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryCoordinatorImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_MEMORY_MEMORY_COORDINATOR_IMPL_H_