NotForReview: Expose the global memory budget (chromium side)

content/browser/memory/memory_condition_observer.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_condition_observer.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/browser/memory/memory_monitor.h"
@@ skipping 44 matching lines @@
     DCHECK(value > 0);
     *target = base::TimeDelta::FromSeconds(value);
   }
 }
 
 }  // namespace
 
 MemoryConditionObserver::MemoryConditionObserver(
     MemoryCoordinatorImpl* coordinator,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : coordinator_(coordinator), task_runner_(task_runner) {
+    : coordinator_(coordinator),
+      task_runner_(task_runner),
+      current_available_(0) {
   DCHECK(coordinator_);
   InitializeParameters();
   DCHECK(ValidateParameters());
+  update_condition_closure_.Reset(base::Bind(
+      &MemoryConditionObserver::UpdateCondition, base::Unretained(this)));
 }
 
 MemoryConditionObserver::~MemoryConditionObserver() {}
 
-void MemoryConditionObserver::ScheduleUpdateCondition(base::TimeDelta delta) {
-  update_condition_closure_.Reset(base::Bind(
-      &MemoryConditionObserver::UpdateCondition, base::Unretained(this)));
+void MemoryConditionObserver::ScheduleUpdateCondition(
+    base::TimeDelta interval) {
+  if (!interval.is_zero() && interval != monitoring_interval_) {
+    monitoring_interval_ = interval;
+    update_condition_closure_.Reset(base::Bind(
+        &MemoryConditionObserver::UpdateCondition, base::Unretained(this)));
+  }
   task_runner_->PostDelayedTask(FROM_HERE, update_condition_closure_.callback(),
-                                delta);
+                                interval);
 }
 
 MemoryCondition MemoryConditionObserver::CalculateNextCondition() {
-  int available =
-      coordinator_->memory_monitor()->GetFreeMemoryUntilCriticalMB();
-
-  // TODO(chrisha): Move this histogram recording to a better place when
-  // https://codereview.chromium.org/2479673002/ is landed.
-  UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Coordinator.FreeMemoryUntilCritical",
-                                available);
-
-  if (available <= 0)
+  if (current_available_ <= 0)
     return MemoryCondition::CRITICAL;
 
-  auto current = coordinator_->GetMemoryCondition();
-  int expected_renderer_count = available / expected_renderer_size_;
+  auto current_condition = coordinator_->GetMemoryCondition();
+  int expected_renderer_count = current_available_ / expected_renderer_size_;
 
-  switch (current) {
+  switch (current_condition) {
     case MemoryCondition::NORMAL:
       if (expected_renderer_count <= new_renderers_until_critical_)
         return MemoryCondition::CRITICAL;
       if (expected_renderer_count <= new_renderers_until_warning_)
         return MemoryCondition::WARNING;
       return MemoryCondition::NORMAL;
     case MemoryCondition::WARNING:
       if (expected_renderer_count <= new_renderers_until_critical_)
         return MemoryCondition::CRITICAL;
       if (expected_renderer_count >= new_renderers_back_to_normal_)
         return MemoryCondition::NORMAL;
       return MemoryCondition::WARNING;
     case MemoryCondition::CRITICAL:
       if (expected_renderer_count >= new_renderers_back_to_normal_)
         return MemoryCondition::NORMAL;
       if (expected_renderer_count >= new_renderers_back_to_warning_)
         return MemoryCondition::WARNING;
       return MemoryCondition::CRITICAL;
   }
   NOTREACHED();
   return MemoryCondition::NORMAL;
 }
 
 void MemoryConditionObserver::UpdateCondition() {
+  int available =
+      coordinator_->memory_monitor()->GetFreeMemoryUntilCriticalMB();
+  UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Coordinator.FreeMemoryUntilCritical",
+                                available);
+  current_available_ = std::min(available, max_available_);
   auto next_condition = CalculateNextCondition();
+  coordinator_->UpdateGlobalBudget(current_available_);
   coordinator_->UpdateConditionIfNeeded(next_condition);
   ScheduleUpdateCondition(monitoring_interval_);
 }
 
 void MemoryConditionObserver::InitializeParameters() {
   expected_renderer_size_ = kDefaultExpectedRendererSizeMB;
   new_renderers_until_warning_ = kDefaultNewRenderersUntilWarning;
   new_renderers_until_critical_ = kDefaultNewRenderersUntilCritical;
   new_renderers_back_to_normal_ = kDefaultNewRenderersBackToNormal;
   new_renderers_back_to_warning_ = kDefaultNewRenderersBackToWarning;
   monitoring_interval_ =
       base::TimeDelta::FromSeconds(kDefaultMonitoringIntervalSeconds);
 
   // Override default parameters with variations.
   static constexpr char kMemoryCoordinatorV0Trial[] = "MemoryCoordinatorV0";
   std::map<std::string, std::string> params;
   variations::GetVariationParams(kMemoryCoordinatorV0Trial, &params);
   SetIntVariationParameter(params, "expected_renderer_size",
                            &expected_renderer_size_);
   SetIntVariationParameter(params, "new_renderers_until_warning",
                            &new_renderers_until_warning_);
   SetIntVariationParameter(params, "new_renderers_until_critical",
                            &new_renderers_until_critical_);
   SetIntVariationParameter(params, "new_renderers_back_to_normal",
                            &new_renderers_back_to_normal_);
   SetIntVariationParameter(params, "new_renderers_back_to_warning",
                            &new_renderers_back_to_warning_);
   SetSecondsVariationParameter(params, "monitoring_interval",
                                &monitoring_interval_);
+
+  const std::string simulate_option =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          "simulate-memory-pressure");
+  if (simulate_option == "warning") {
+    max_available_ = expected_renderer_size_ * new_renderers_until_warning_;
+  } else if (simulate_option == "critical") {
+    max_available_ = expected_renderer_size_ * new_renderers_until_critical_;
+  } else {
+    max_available_ = INT_MAX;
+  }
 }
 
 bool MemoryConditionObserver::ValidateParameters() {
   return (new_renderers_until_warning_ > new_renderers_until_critical_) &&
          (new_renderers_back_to_normal_ > new_renderers_back_to_warning_) &&
          (new_renderers_back_to_normal_ > new_renderers_until_warning_) &&
          (new_renderers_back_to_warning_ > new_renderers_until_critical_);
 }
 
 }  // namespace content