Let CastSystemMemoryPressureEvaluator relax thresholds

CastSystemMemoryPressureEvaluator can accept requests from apps
to relax memory pressure thresholds. Normal memory pressure thresholds
can be restored when those apps quit.

Bug: internal b/141100797
Test: Build and run with eureka-internal/316737.

Merge-With: eureka-internal/316737

Change-Id: I6752297ef1ea25e5e28965f00ad6cb04db194a29
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1816729Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Commit-Queue: Guohui Deng <guohuideng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#700922}

chromecast/browser/BUILD.gn

@@ -84,6 +84,8 @@ cast_source_set("browser") {
     "cast_renderer_block_data.h",
     "cast_session_id_map.cc",
     "cast_session_id_map.h",
+    "cast_system_memory_pressure_evaluator_adjuster.cc",
+    "cast_system_memory_pressure_evaluator_adjuster.h",
     "cast_web_contents_impl.cc",
     "cast_web_contents_impl.h",
     "cast_web_contents_manager.cc",

chromecast/browser/cast_browser_main_parts.cc

@@ -37,6 +37,7 @@
 #include "chromecast/browser/cast_content_browser_client.h"
 #include "chromecast/browser/cast_feature_list_creator.h"
 #include "chromecast/browser/cast_system_memory_pressure_evaluator.h"
+#include "chromecast/browser/cast_system_memory_pressure_evaluator_adjuster.h"
 #include "chromecast/browser/devtools/remote_debugging_server.h"
 #include "chromecast/browser/media/media_caps_impl.h"
 #include "chromecast/browser/metrics/cast_browser_metrics.h"
@@ -356,7 +357,8 @@ CastBrowserMainParts::CastBrowserMainParts(
       parameters_(parameters),
       cast_content_browser_client_(cast_content_browser_client),
       url_request_context_factory_(url_request_context_factory),
-      media_caps_(new media::MediaCapsImpl()) {
+      media_caps_(new media::MediaCapsImpl()),
+      cast_system_memory_pressure_evaluator_adjuster_(nullptr) {
   DCHECK(cast_content_browser_client);
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   AddDefaultCommandLineSwitches(command_line);
@@ -471,9 +473,13 @@ int CastBrowserMainParts::PreCreateThreads() {
 void CastBrowserMainParts::PreMainMessageLoopRun() {
 #if !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
   memory_pressure_monitor_.reset(new util::MultiSourceMemoryPressureMonitor());
-  memory_pressure_monitor_->SetSystemEvaluator(
+  auto cast_system_memory_pressure_evaluator =
       std::make_unique<CastSystemMemoryPressureEvaluator>(
-          memory_pressure_monitor_->CreateVoter()));
+          memory_pressure_monitor_->CreateVoter());
+  cast_system_memory_pressure_evaluator_adjuster_ =
+      cast_system_memory_pressure_evaluator.get();
+  memory_pressure_monitor_->SetSystemEvaluator(
+      std::move(cast_system_memory_pressure_evaluator));
 
   // base::Unretained() is safe because the browser client will outlive any
   // component in the browser; this factory method will not be called after
@@ -545,6 +551,7 @@ void CastBrowserMainParts::PreMainMessageLoopRun() {
   cast_browser_process_->SetCastService(
       cast_browser_process_->browser_client()->CreateCastService(
           cast_browser_process_->browser_context(),
+          cast_system_memory_pressure_evaluator_adjuster_,
           cast_browser_process_->pref_service(),
           video_plane_controller_.get(), window_manager_.get()));
   cast_browser_process_->cast_service()->Initialize();

chromecast/browser/cast_browser_main_parts.h

@@ -35,6 +35,7 @@ class ViewsDelegate;
 #endif  // defined(USE_AURA)
 
 namespace chromecast {
+class CastSystemMemoryPressureEvaluatorAdjuster;
 class WaylandServerController;
 
 #if defined(USE_AURA)
@@ -110,11 +111,12 @@ class CastBrowserMainParts : public content::BrowserMainParts {
   // Tracks all media pipeline backends.
   std::unique_ptr<media::MediaPipelineBackendManager>
       media_pipeline_backend_manager_;
-
 #if !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
   std::unique_ptr<util::MultiSourceMemoryPressureMonitor>
       memory_pressure_monitor_;
 #endif  // !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
+  CastSystemMemoryPressureEvaluatorAdjuster*
+      cast_system_memory_pressure_evaluator_adjuster_;
 
 #if BUILDFLAG(ENABLE_CHROMECAST_EXTENSIONS)
   std::unique_ptr<extensions::ExtensionsClient> extensions_client_;

chromecast/browser/cast_content_browser_client.cc

@@ -239,6 +239,8 @@ CastContentBrowserClient::~CastContentBrowserClient() {
 
 std::unique_ptr<CastService> CastContentBrowserClient::CreateCastService(
     content::BrowserContext* browser_context,
+    CastSystemMemoryPressureEvaluatorAdjuster*
+        cast_system_memory_pressure_evaluator_adjuster,
     PrefService* pref_service,
     media::VideoPlaneController* video_plane_controller,
     CastWindowManager* window_manager) {

chromecast/browser/cast_content_browser_client.h

@@ -47,6 +47,7 @@ class X509Certificate;
 
 namespace chromecast {
 class CastService;
+class CastSystemMemoryPressureEvaluatorAdjuster;
 class CastWindowManager;
 class CastFeatureListCreator;
 class GeneralAudienceBrowsingService;
@@ -86,6 +87,8 @@ class CastContentBrowserClient
   // Creates and returns the CastService instance for the current process.
   virtual std::unique_ptr<CastService> CreateCastService(
       content::BrowserContext* browser_context,
+      CastSystemMemoryPressureEvaluatorAdjuster*
+          cast_system_memory_pressure_evaluator_adjuster,
       PrefService* pref_service,
       media::VideoPlaneController* video_plane_controller,
       CastWindowManager* window_manager);

chromecast/browser/cast_system_memory_pressure_evaluator.cc

@@ -11,11 +11,21 @@
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_metrics.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/base/metrics/cast_metrics_helper.h"
 
+#define MAKE_SURE_THREAD(callback, ...)                                 \
+  if (!task_runner_->BelongsToCurrentThread()) {                        \
+    task_runner_->PostTask(                                             \
+        FROM_HERE,                                                      \
+        base::BindOnce(&CastSystemMemoryPressureEvaluator::callback,    \
+                       weak_ptr_factory_.GetWeakPtr(), ##__VA_ARGS__)); \
+    return;                                                             \
+  }
+
 namespace chromecast {
 namespace {
 
@@ -25,6 +35,10 @@ namespace {
 constexpr float kCriticalMemoryFraction = 0.25f;
 constexpr float kModerateMemoryFraction = 0.4f;
 
+// Default Relaxed memory thresholds selectively applied to a few apps.
+constexpr float kRelaxedCriticalMemoryFraction = 0.1f;
+constexpr float kRelaxedModerateMemoryFraction = 0.2f;
+
 // Memory thresholds in MB for the simple heuristic based on 'free' memory.
 constexpr int kCriticalFreeMemoryKB = 20 * 1024;
 constexpr int kModerateFreeMemoryKB = 30 * 1024;
@@ -46,14 +60,22 @@ int GetSystemReservedKb() {
 CastSystemMemoryPressureEvaluator::CastSystemMemoryPressureEvaluator(
     std::unique_ptr<util::MemoryPressureVoter> voter)
     : util::SystemMemoryPressureEvaluator(std::move(voter)),
-      critical_memory_fraction_(
+      critical_memory_fraction_command_line_(
           GetSwitchValueDouble(switches::kCastMemoryPressureCriticalFraction,
-                               kCriticalMemoryFraction)),
-      moderate_memory_fraction_(
+                               -1.0f)),
+      moderate_memory_fraction_command_line_(
           GetSwitchValueDouble(switches::kCastMemoryPressureModerateFraction,
-                               kModerateMemoryFraction)),
+                               -1.0f)),
       system_reserved_kb_(GetSystemReservedKb()),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_ptr_factory_(this) {
+  relaxed_critical_memory_fraction_ = kRelaxedCriticalMemoryFraction;
+  relaxed_moderate_memory_fraction_ = kRelaxedModerateMemoryFraction;
+  critical_memory_fraction_ = critical_memory_fraction_command_line_;
+  moderate_memory_fraction_ = moderate_memory_fraction_command_line_;
+  // If the fractions from command line parameters are invalid they are subject
+  // to adjustment.
+  AdjustMemoryFractions(false);
   PollPressureLevel();
 }
 
@@ -61,6 +83,7 @@ CastSystemMemoryPressureEvaluator::~CastSystemMemoryPressureEvaluator() =
     default;
 
 void CastSystemMemoryPressureEvaluator::PollPressureLevel() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
   base::MemoryPressureListener::MemoryPressureLevel level =
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
 
@@ -106,7 +129,7 @@ void CastSystemMemoryPressureEvaluator::PollPressureLevel() {
                                 info.available / 1024, 1, 2000, 100);
   }
 
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+  task_runner_->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&CastSystemMemoryPressureEvaluator::PollPressureLevel,
                      weak_ptr_factory_.GetWeakPtr()),
@@ -115,6 +138,7 @@ void CastSystemMemoryPressureEvaluator::PollPressureLevel() {
 
 void CastSystemMemoryPressureEvaluator::UpdateMemoryPressureLevel(
     base::MemoryPressureListener::MemoryPressureLevel new_level) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
   auto old_vote = current_vote();
   SetCurrentVote(new_level);
 
@@ -128,4 +152,56 @@ void CastSystemMemoryPressureEvaluator::UpdateMemoryPressureLevel(
       "Memory.Pressure.LevelChange", new_level);
 }
 
+void CastSystemMemoryPressureEvaluator::AdjustMemoryFractions(bool relax) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  if (critical_memory_fraction_command_line_ < 0) {
+    critical_memory_fraction_ =
+        relax ? relaxed_critical_memory_fraction_ : kCriticalMemoryFraction;
+  }
+  if (moderate_memory_fraction_command_line_ < 0) {
+    moderate_memory_fraction_ =
+        relax ? relaxed_moderate_memory_fraction_ : kModerateMemoryFraction;
+  }
+  LOG(INFO) << __func__
+            << ": critical_memory_fraction_=" << critical_memory_fraction_
+            << ", moderate_memory_fraction_=" << moderate_memory_fraction_;
+}
+
+void CastSystemMemoryPressureEvaluator::ConfigRelaxMemoryPressureThresholds(
+    float relaxed_critical_memory_fraction,
+    float relaxed_moderate_memory_fraction) {
+  MAKE_SURE_THREAD(ConfigRelaxMemoryPressureThresholds,
+                   relaxed_critical_memory_fraction,
+                   relaxed_moderate_memory_fraction);
+
+  LOG(INFO) << __func__ << ", " << relaxed_critical_memory_fraction << ", "
+            << relaxed_moderate_memory_fraction;
+
+  if (relaxed_critical_memory_fraction > 0) {
+    relaxed_critical_memory_fraction_ = relaxed_critical_memory_fraction;
+  }
+  if (relaxed_moderate_memory_fraction > 0) {
+    relaxed_moderate_memory_fraction_ = relaxed_moderate_memory_fraction;
+  }
+}
+
+void CastSystemMemoryPressureEvaluator::RelaxMemoryPressureThresholds(
+    std::string requesting_app_session_id) {
+  MAKE_SURE_THREAD(RelaxMemoryPressureThresholds,
+                   std::move(requesting_app_session_id));
+  apps_needing_relaxed_memory_pressure_thresholds_.insert(
+      std::move(requesting_app_session_id));
+  AdjustMemoryFractions(true);
+}
+void CastSystemMemoryPressureEvaluator::RestoreMemoryPressureThresholds(
+    const std::string& requesting_app_session_id) {
+  MAKE_SURE_THREAD(RestoreMemoryPressureThresholds, requesting_app_session_id);
+  apps_needing_relaxed_memory_pressure_thresholds_.erase(
+      requesting_app_session_id);
+  if (apps_needing_relaxed_memory_pressure_thresholds_.empty()) {
+    AdjustMemoryFractions(false);
+  }
+}
+
 }  // namespace chromecast

chromecast/browser/cast_system_memory_pressure_evaluator.h

@@ -5,30 +5,63 @@
 #ifndef CHROMECAST_BROWSER_CAST_SYSTEM_MEMORY_PRESSURE_EVALUATOR_H_
 #define CHROMECAST_BROWSER_CAST_SYSTEM_MEMORY_PRESSURE_EVALUATOR_H_
 
+#include <string>
+
+#include "base/containers/flat_set.h"
 #include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/util/memory_pressure/system_memory_pressure_evaluator.h"
+#include "chromecast/browser/cast_system_memory_pressure_evaluator_adjuster.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}  // namespace base
 
 namespace chromecast {
 
 // Memory pressure evaluator for Cast: polls for current memory
 // usage periodically and sends memory pressure notifications.
 class CastSystemMemoryPressureEvaluator
-    : public util::SystemMemoryPressureEvaluator {
+    : public util::SystemMemoryPressureEvaluator,
+      public CastSystemMemoryPressureEvaluatorAdjuster {
  public:
   explicit CastSystemMemoryPressureEvaluator(
       std::unique_ptr<util::MemoryPressureVoter> voter);
   ~CastSystemMemoryPressureEvaluator() override;
 
+  // CastSystemMemoryPressureEvaluatorAdjuster implementation:
+  void ConfigRelaxMemoryPressureThresholds(
+      float relaxed_critical_memory_fraction,
+      float relaxed_moderate_memory_fraction) override;
+  void RelaxMemoryPressureThresholds(
+      std::string requesting_app_session_id) override;
+  void RestoreMemoryPressureThresholds(
+      const std::string& requesting_app_session_id) override;
+
  private:
   void PollPressureLevel();
   void UpdateMemoryPressureLevel(
       base::MemoryPressureListener::MemoryPressureLevel new_level);
+  void AdjustMemoryFractions(bool relax);
+
+  // Fractions in effect.
+  float critical_memory_fraction_;
+  float moderate_memory_fraction_;
+
+  // Fractions when the thrsholds are relaxed.
+  float relaxed_critical_memory_fraction_;
+  float relaxed_moderate_memory_fraction_;
+
+  // When negative, no valid critical/moderate memory fraction present
+  // in command line parameters.
+  float const critical_memory_fraction_command_line_;
+  float const moderate_memory_fraction_command_line_;
 
-  const float critical_memory_fraction_;
-  const float moderate_memory_fraction_;
+  base::flat_set<std::string> apps_needing_relaxed_memory_pressure_thresholds_;
 
   const int system_reserved_kb_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::WeakPtrFactory<CastSystemMemoryPressureEvaluator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CastSystemMemoryPressureEvaluator);

chromecast/browser/cast_system_memory_pressure_evaluator_adjuster.cc

+// Copyright 2019 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 "chromecast/browser/cast_system_memory_pressure_evaluator_adjuster.h"
+
+namespace chromecast {
+
+void CastSystemMemoryPressureEvaluatorAdjuster::
+    ConfigRelaxMemoryPressureThresholds(
+        float relaxed_critical_memory_fraction,
+        float relaxed_moderate_memory_fraction) {}
+
+void CastSystemMemoryPressureEvaluatorAdjuster::RelaxMemoryPressureThresholds(
+    std::string requesting_app_session_id) {}
+
+void CastSystemMemoryPressureEvaluatorAdjuster::RestoreMemoryPressureThresholds(
+    const std::string& requesting_app_session_id) {}
+
+}  // namespace chromecast
\ No newline at end of file

chromecast/browser/cast_system_memory_pressure_evaluator_adjuster.h

+// Copyright 2019 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 CHROMECAST_BROWSER_CAST_SYSTEM_MEMORY_PRESSURE_EVALUATOR_ADJUSTER_H_
+#define CHROMECAST_BROWSER_CAST_SYSTEM_MEMORY_PRESSURE_EVALUATOR_ADJUSTER_H_
+
+#include <string>
+
+namespace chromecast {
+class CastSystemMemoryPressureEvaluatorAdjuster {
+ public:
+  CastSystemMemoryPressureEvaluatorAdjuster() = default;
+  virtual ~CastSystemMemoryPressureEvaluatorAdjuster() = default;
+
+  // The three functions below can be called from any thread.
+  // Negative fractions are invalid.
+  virtual void ConfigRelaxMemoryPressureThresholds(
+      float relaxed_critical_memory_fraction,
+      float relaxed_moderate_memory_fraction);
+  virtual void RelaxMemoryPressureThresholds(
+      std::string requesting_app_session_id);
+  virtual void RestoreMemoryPressureThresholds(
+      const std::string& requesting_app_session_id);
+};
+
+}  // namespace chromecast
+
+#endif  // CHROMECAST_BROWSER_CAST_SYSTEM_MEMORY_PRESSURE_EVALUATOR_ADJUSTER_H_
\ No newline at end of file