base: Add soft memory limit to DiscardableMemoryManager.

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 863 matching lines @@
 }
 
 void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
   idle_notification_delay_in_ms_ = initial_delay_ms;
   idle_timer_.Stop();
   idle_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(initial_delay_ms),
       this, &RenderThreadImpl::IdleHandler);
 }
 
 void RenderThreadImpl::IdleHandler() {

[reveman, 2014/06/23 14:59:40]

Using this idle handler seem to work Ok but there might be corner cases where
this is not doing exactly what we want as it seems to be somewhat specifically
designed for v8 garbage collection. I think the intent is at least clear and we
can improve it using follow up patches if necessary.

[willchan no longer on Chromium, 2014/06/24 16:33:00]

I'm not going to bother with the review until James OKs this. We've historically
been very cautious with idle handlers since detecting idleness (predicting the
future) is a hard problem.

   bool run_in_foreground_tab = (widget_count_ > hidden_widget_count_) &&
                                GetContentClient()->renderer()->
                                    RunIdleHandlerWhenWidgetsHidden();
   if (run_in_foreground_tab) {
     IdleHandlerInForegroundTab();
     return;
   }
 
   base::allocator::ReleaseFreeMemory();
 
   // Continue the idle timer if the webkit shared timer is not suspended or
   // something is left to do.
   bool continue_timer = !webkit_shared_timer_suspended_;
 
   if (!v8::V8::IdleNotification()) {
     continue_timer = true;
   }
+  if (!base::DiscardableMemory::IdleNotification()) {
+    continue_timer = true;
+  }
 
   // Schedule next invocation.
   // Dampen the delay using the algorithm (if delay is in seconds):
   //    delay = delay + 1 / (delay + 2)
   // Using floor(delay) has a dampening effect such as:
   //    1s, 1, 1, 2, 2, 2, 2, 3, 3, ...
   // If the delay is in milliseconds, the above formula is equivalent to:
   //    delay_ms / 1000 = delay_ms / 1000 + 1 / (delay_ms / 1000 + 2)
   // which is equivalent to
   //    delay_ms = delay_ms + 1000*1000 / (delay_ms + 2000).
@@ skipping 21 matching lines @@
   if (idle_notifications_to_skip_ > 0) {
     idle_notifications_to_skip_--;
   } else  {
     int cpu_usage = 0;
     Send(new ViewHostMsg_GetCPUUsage(&cpu_usage));
     // Idle notification hint roughly specifies the expected duration of the
     // idle pause. We set it proportional to the idle timer delay.
     int idle_hint = static_cast<int>(new_delay_ms / 10);
     if (cpu_usage < kIdleCPUUsageThresholdInPercents) {
       base::allocator::ReleaseFreeMemory();
-      if (v8::V8::IdleNotification(idle_hint)) {
-        // V8 finished collecting garbage.
+
+      bool finished_idle_work = true;
+      if (!v8::V8::IdleNotification(idle_hint))
+        finished_idle_work = false;
+      if (!base::DiscardableMemory::IdleNotification())
+        finished_idle_work = false;
+
+      // V8 finished collecting garbage and discardable memory system has no
+      // more idle work left.
+      if (finished_idle_work)
         new_delay_ms = kLongIdleHandlerDelayMs;
-      }
     }
   }
   ScheduleIdleHandler(new_delay_ms);
 }
 
 int64 RenderThreadImpl::GetIdleNotificationDelayInMs() const {
   return idle_notification_delay_in_ms_;
 }
 
 void RenderThreadImpl::SetIdleNotificationDelayInMs(
@@ skipping 563 matching lines @@
   hidden_widget_count_--;
 
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 }  // namespace content