memory coordinator: Purge memory under memory pressure

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/cancelable_callback.h"
 #include "base/memory/memory_coordinator_client.h"
@@ skipping 132 matching lines @@
 
   // Stores information about any known child processes.
   struct ChildInfo {
     // This object must be compatible with STL containers.
     ChildInfo();
     ChildInfo(const ChildInfo& rhs);
     ~ChildInfo();
 
     MemoryState memory_state;
     bool is_visible = false;
+    base::TimeTicks can_purge_after;
     std::unique_ptr<MemoryCoordinatorHandleImpl> handle;
   };
 
   // A map from process ID (RenderProcessHost::GetID()) to child process info.
   using ChildInfoMap = std::map<int, ChildInfo>;
 
   ChildInfoMap& children() { return children_; }
 
   base::SingleThreadTaskRunner* task_runner() { return task_runner_.get(); }
 
  private:
 #if !defined(OS_MACOSX)
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplBrowserTest, HandleAdded);
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplBrowserTest,
                            CanSuspendRenderer);
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorWithServiceWorkerTest,
                            CannotSuspendRendererWithServiceWorker);
 #endif
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, OnChildVisibilityChanged);
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, CalculateNextCondition);
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, UpdateCondition);
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, SetMemoryStateForTesting);
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, ForceSetMemoryCondition);
   FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, DiscardTabUnderCritical);
+  FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, OnWarningCondition);
+  FRIEND_TEST_ALL_PREFIXES(MemoryCoordinatorImplTest, OnCriticalCondition);
 
   friend struct MemoryCoordinatorSingletonTraits;
   friend class MemoryCoordinatorHandleImpl;
 
   // Called when ChildMemoryCoordinator calls AddChild().
   void OnChildAdded(int render_process_id);
 
   // Called when visibility of a child process is changed.
   void OnChildVisibilityChanged(int render_process_id, bool is_visible);
 
   // Called by SetChildMemoryState() to determine a child memory state based on
   // the current status of the child process.
   MemoryState OverrideState(MemoryState memroy_state, const ChildInfo& child);
 
   // Helper function of CreateHandle and AddChildForTesting.
   void CreateChildInfoMapEntry(
       int render_process_id,
       std::unique_ptr<MemoryCoordinatorHandleImpl> handle);
 
   // Updates the browser's memory state and notifies it to in-process clients.
   void UpdateBrowserStateAndNotifyStateToClients(MemoryState state);
 
   // Notifies a state change to in-process clients.
   void NotifyStateToClients(MemoryState state);
 
   // Notifies a state change to child processes.
   void NotifyStateToChildren(MemoryState state);
 
+  // Called periodically while the memory condition is WARNING.
+  void OnWarningCondition();
+
+  // Called periodically while the memory condition is CRITICAL.
+  void OnCriticalCondition();
+
+  enum class PurgeTarget {
+    BACKGROUNDED,
+    ALL,
+  };
+
+  // Tries to find a candidate child process for purging memory and asks the
+  // child to purge memory.
+  bool TryToPurgeMemoryFromChildren(PurgeTarget target);
+
+  // Tries to purge memory from the browser process.
+  bool TryToPurgeMemoryFromBrowser();
+
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   std::unique_ptr<MemoryCoordinatorDelegate> delegate_;
   std::unique_ptr<MemoryMonitor> memory_monitor_;
   std::unique_ptr<MemoryConditionObserver> condition_observer_;
   std::unique_ptr<base::TickClock> tick_clock_;
   NotificationRegistrar notification_registrar_;
 
   // The current memory condition.
   MemoryCondition memory_condition_ = MemoryCondition::NORMAL;
 
   // The memory state of the browser process.
   MemoryState browser_memory_state_ = MemoryState::NORMAL;
 
   // The time tick of last state change of the browser process.
   base::TimeTicks last_state_change_;
 
   // Memory state for a process will remain unchanged until this period of time
   // passes.
   base::TimeDelta minimum_state_transition_period_;
 
   // Used to delay setting browser's memory state. Cancelable to avoid executing
   // multiple tasks in the same time frame.
   base::CancelableClosure delayed_browser_memory_state_setter_;
 
+  // If this isn't null, purging memory from the browser process is suppressed
+  // until this ticks is passed.
+  base::TimeTicks can_purge_after_;
+
   // Tracks child processes. An entry is added when a renderer connects to
   // MemoryCoordinator and removed automatically when an underlying binding is
   // disconnected.
   ChildInfoMap children_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryCoordinatorImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_MEMORY_MEMORY_COORDINATOR_IMPL_H_