NotForReview: Expose the global memory budget (chromium side)

content/browser/memory/memory_coordinator_impl.cc

 // 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.
 
 #include "content/browser/memory/memory_coordinator_impl.h"
 
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_handle.h"
@@ skipping 71 matching lines @@
 // for the role of this class.
 class MemoryCoordinatorHandleImpl : public mojom::MemoryCoordinatorHandle {
  public:
   MemoryCoordinatorHandleImpl(mojom::MemoryCoordinatorHandleRequest request,
                               MemoryCoordinatorImpl* coordinator,
                               int render_process_id);
   ~MemoryCoordinatorHandleImpl() override;
 
   // mojom::MemoryCoordinatorHandle:
   void AddChild(mojom::ChildMemoryCoordinatorPtr child) override;
+  void GetGlobalBudgetHandle(
+      const GetGlobalBudgetHandleCallback& callback) override {
+    auto handle = coordinator_->global_budget_handle_->Clone(
+        mojo::SharedBufferHandle::AccessMode::READ_ONLY);
+    callback.Run(std::move(handle));
+  }
+  void SetGlobalBudgetUpdateInterval(uint32_t interval_ms) override {
+    base::TimeDelta interval = base::TimeDelta::FromMilliseconds(interval_ms);
+    coordinator_->condition_observer_->ScheduleUpdateCondition(interval);
+  }
 
   mojom::ChildMemoryCoordinatorPtr& child() { return child_; }
   mojo::Binding<mojom::MemoryCoordinatorHandle>& binding() { return binding_; }
 
  private:
   MemoryCoordinatorImpl* coordinator_;
   int render_process_id_;
   mojom::ChildMemoryCoordinatorPtr child_;
   mojo::Binding<mojom::MemoryCoordinatorHandle> binding_;
 
@@ skipping 42 matching lines @@
                          MemoryCoordinatorImplSingletonTraits>::get();
 }
 
 MemoryCoordinatorImpl::MemoryCoordinatorImpl(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     std::unique_ptr<MemoryMonitor> memory_monitor)
     : delegate_(GetContentClient()->browser()->GetMemoryCoordinatorDelegate()),
       memory_monitor_(std::move(memory_monitor)),
       condition_observer_(
           base::MakeUnique<MemoryConditionObserver>(this, task_runner)),
-      minimum_state_transition_period_(base::TimeDelta::FromSeconds(
-          kDefaultMinimumTransitionPeriodSeconds)) {
+      minimum_state_transition_period_(
+          base::TimeDelta::FromSeconds(kDefaultMinimumTransitionPeriodSeconds)),
+      global_budget_handle_(mojo::SharedBufferHandle::Create(sizeof(int64_t))),
+      global_budget_mapping_(global_budget_handle_->Map(sizeof(int64_t))) {
   DCHECK(memory_monitor_.get());
+  DCHECK(global_budget_mapping_.get());
   base::MemoryCoordinatorProxy::SetMemoryCoordinator(this);
+  UpdateGlobalBudget(-1);
 }
 
 MemoryCoordinatorImpl::~MemoryCoordinatorImpl() {
   base::MemoryCoordinatorProxy::SetMemoryCoordinator(nullptr);
 }
 
 void MemoryCoordinatorImpl::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK(last_state_change_.is_null());
 
@@ skipping 57 matching lines @@
 
 void MemoryCoordinatorImpl::RecordMemoryPressure(
     base::MemoryPressureMonitor::MemoryPressureLevel level) {
   // TODO(bashi): Record memory pressure level.
 }
 
 MemoryState MemoryCoordinatorImpl::GetCurrentMemoryState() const {
   return browser_memory_state_;
 }
 
+int64_t MemoryCoordinatorImpl::GetGlobalBudget() {
+  return *reinterpret_cast<int64_t*>(global_budget_mapping_.get());
+}
+
+void MemoryCoordinatorImpl::SetGlobalBudgetUpdateInterval(
+    uint32_t interval_ms) {
+  condition_observer_->ScheduleUpdateCondition(
+      base::TimeDelta::FromMilliseconds(interval_ms));
+}
+
 void MemoryCoordinatorImpl::ForceSetMemoryCondition(MemoryCondition condition,
                                                     base::TimeDelta duration) {
   UpdateConditionIfNeeded(condition);
   condition_observer_->ScheduleUpdateCondition(duration);
 }
 
 void MemoryCoordinatorImpl::Observe(int type,
                                     const NotificationSource& source,
                                     const NotificationDetails& details) {
   DCHECK(type == NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED);
@@ skipping 57 matching lines @@
       SetChildMemoryState(iter.first, state);
     }
     // Idea: Purge memory from background processes.
   } else if (next_condition == MemoryCondition::CRITICAL) {
     // Set THROTTLED state to all clients/processes.
     UpdateBrowserStateAndNotifyStateToClients(MemoryState::THROTTLED);
     NotifyStateToChildren(MemoryState::THROTTLED);
   }
 }
 
+void MemoryCoordinatorImpl::UpdateGlobalBudget(int budget) {
+  *reinterpret_cast<int64_t*>(global_budget_mapping_.get()) = budget;
+}
+
 void MemoryCoordinatorImpl::DiscardTab() {
   if (delegate_)
     delegate_->DiscardTab();
 }
 
 RenderProcessHost* MemoryCoordinatorImpl::GetRenderProcessHost(
     int render_process_id) {
   return RenderProcessHost::FromID(render_process_id);
 }
 
@@ skipping 113 matching lines @@
 
 MemoryCoordinatorImpl::ChildInfo::ChildInfo() {}
 
 MemoryCoordinatorImpl::ChildInfo::ChildInfo(const ChildInfo& rhs) {
   // This is a nop, but exists for compatibility with STL containers.
 }
 
 MemoryCoordinatorImpl::ChildInfo::~ChildInfo() {}
 
 }  // namespace content