Expose MemoryCoordinator's global budget information.

base/memory/memory_coordinator_proxy.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 BASE_MEMORY_MEMORY_COORDINATOR_PROXY_H_
 #define BASE_MEMORY_MEMORY_COORDINATOR_PROXY_H_
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/memory/memory_coordinator_client.h"
 #include "base/memory/singleton.h"
 
 namespace base {
 
 // The proxy of MemoryCoordinator to be accessed from components that are not
 // in content/browser e.g. net.
+// TODO(chrisha): Consider moving these individual callbacks to a delegate that
+// is injected.

[bashi, 2016/11/07 00:16:37]

+1 :)

[chrisha, 2016/11/07 19:33:41]

I'll do this in a follow-up CL, as it's going to be a bit of a mess to do here.

[bashi, 2016/11/07 23:17:08]

Oh, I didn't mean I wanted this refactoring in this CL. Sorry for confusion. I
can do that if you don't have a bandwidth for this :)

 class BASE_EXPORT MemoryCoordinatorProxy {
  public:
   using GetCurrentMemoryStateCallback = base::Callback<MemoryState()>;
   using SetCurrentMemoryStateCallback = base::Callback<void(MemoryState)>;
+  using GetRemainingGlobalBudgetCallback = base::Callback<int64_t()>;
 
   static MemoryCoordinatorProxy* GetInstance();
 
   // Returns the current memory state.
   MemoryState GetCurrentMemoryState() const;
 
   // Sets the current memory state. This function is for testing only.
   void SetCurrentMemoryStateForTesting(MemoryState memory_state);
 
+  // Returns the remaining global budget usable in aggregate by all Chrome
+  // processes. This indicates how many MB of memory are remaining for Chrome
+  // processes to use before the memory coordinator will take efforts to reclaim
+  // memory. A negative amount indicates that the coordinator is actively trying
+  // to reclaim that much memory.
+  int64_t GetRemainingGlobalBudget() const;

[bashi, 2016/11/07 00:16:37]

nit: we use int for MemoryMonitor::GetFreeMemoryUntilCriticalMB(). Should we use
int64_t everywhere?

[chrisha, 2016/11/07 19:33:41]

Well, an auto-scaled 'int' is sufficient for each platform, but Mojo has no such
thing, and forces me to use an int64_t in order to accommodate both platforms.
I'd prefer to go the other way and keep everything an int, except for the IPC
message itself?

[bashi, 2016/11/07 23:17:08]

I see.

+
   // Sets state-getter callback.
   void SetGetCurrentMemoryStateCallback(GetCurrentMemoryStateCallback callback);
 
   // Sets state-setter callback.
   void SetSetCurrentMemoryStateForTestingCallback(
       SetCurrentMemoryStateCallback callback);
 
+  // Sets the remaining global budget callback.
+  void SetGetRemainingGlobalBudgetCallback(
+      GetRemainingGlobalBudgetCallback get_remaining_budget_callback);
+
  private:
   friend struct base::DefaultSingletonTraits<MemoryCoordinatorProxy>;
 
   MemoryCoordinatorProxy();
   virtual ~MemoryCoordinatorProxy();
 
   GetCurrentMemoryStateCallback getter_callback_;
   SetCurrentMemoryStateCallback setter_callback_;
+  GetRemainingGlobalBudgetCallback get_remaining_budget_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryCoordinatorProxy);
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_MEMORY_COORDINATOR_PROXY_H_