Remove foreground tab idle handler

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 155 matching lines @@
 using blink::WebScriptController;
 using blink::WebSecurityPolicy;
 using blink::WebString;
 using blink::WebView;
 
 namespace content {
 
 namespace {
 
 const int64 kInitialIdleHandlerDelayMs = 1000;
-const int64 kShortIdleHandlerDelayMs = 1000;
 const int64 kLongIdleHandlerDelayMs = 30*1000;
-const int kIdleCPUUsageThresholdInPercents = 3;
 
 // Maximum allocation size allowed for image scaling filters that
 // require pre-scaling. Skia will fallback to a filter that doesn't
 // require pre-scaling if the default filter would require an
 // allocation that exceeds this limit.
 const size_t kImageCacheSingleAllocationByteLimit = 64 * 1024 * 1024;
 
 const size_t kEmulatedDiscardableMemoryBytesToKeepWhenWidgetsHidden =
     4 * 1024 * 1024;
 
@@ skipping 809 matching lines @@
   idle_timer_.Stop();
   idle_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(initial_delay_ms),
       this, &RenderThreadImpl::IdleHandler);
 }
 
 void RenderThreadImpl::IdleHandler() {
   bool run_in_foreground_tab = (widget_count_ > hidden_widget_count_) &&
                                GetContentClient()->renderer()->
                                    RunIdleHandlerWhenWidgetsHidden();
-  if (run_in_foreground_tab) {
-    IdleHandlerInForegroundTab();
+  if (run_in_foreground_tab)
     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 (blink::mainThreadIsolate() &&
       !blink::mainThreadIsolate()->IdleNotification(1000)) {
     continue_timer = true;
@@ skipping 21 matching lines @@
                  idle_notification_delay_in_ms_ +
                  1000000 / (idle_notification_delay_in_ms_ + 2000)));
 
   } else {
     idle_timer_.Stop();
   }
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
 }
 
-void RenderThreadImpl::IdleHandlerInForegroundTab() {
-  // Increase the delay in the same way as in IdleHandler,
-  // but make it periodic by reseting it once it is too big.
-  int64 new_delay_ms = idle_notification_delay_in_ms_ +
-                       1000000 / (idle_notification_delay_in_ms_ + 2000);
-  if (new_delay_ms >= kLongIdleHandlerDelayMs)
-    new_delay_ms = kShortIdleHandlerDelayMs;
-
-  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();
-
-      bool finished_idle_work = true;
-      if (blink::mainThreadIsolate() &&
-          !blink::mainThreadIsolate()->IdleNotification(idle_hint)) {
-        finished_idle_work = false;
-      }
-      if (!base::DiscardableMemory::ReduceMemoryUsage())

[reveman, 2014/09/25 13:34:17]

where is this moved?

[jochen (gone - plz use gerrit), 2014/09/25 14:18:28]

nowhere. In our experiments, the idle handler is almost never invoked, because
the system's load is typically higher than 3%

also, it's not really an idle handler, we just keep posting a delayed task, so
we might end up discarding memory in the middle of an animation.

[reveman, 2014/09/25 15:03:41]

This call will discard memory that has not been used for some specific amount of
time. Calling this in the middle of an animation is not a problem as it won't
discard memory that is still frequently used. Calling this when actually idle
would be nice but just posting a delayed  task is fine too in this case.
However, we can't just remove it as that will affect the memory usage of
significantly.

[jochen (gone - plz use gerrit), 2014/09/25 15:08:36]

so just postTask this call every 30s should be fine (which is more or less what
the handler did)?

Is there a test that I can use to verify that nothing regresses?

[reveman, 2014/09/25 16:44:49]

Maybe. Is there not a better idle signal we can hook this up to instead? What
about the blink scheduler which is mentioned in the description of this cl?
Sorry, nothing good at the moment. Feel free to add some implementation specific
test to RenderThreadImplBrowserTest similar to
EmulatedDiscardableMemoryDiscardedWhenWidgetsHidden if you like. You probably
have to add some hooks to the discardable memory interface to avoid having the
test take seconds to run though.

-        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(
     int64 idle_notification_delay_in_ms) {
   idle_notification_delay_in_ms_ = idle_notification_delay_in_ms;
 }
 
 void RenderThreadImpl::UpdateHistograms(int sequence_number) {
@@ skipping 556 matching lines @@
   hidden_widget_count_--;
 
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 }  // namespace content