chromeos: Set a least score to the currently focused tab so that it is not selected

chrome/browser/oom_priority_manager.cc

 // Copyright (c) 2011 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 "chrome/browser/oom_priority_manager.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_process_host.h"
+#include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/zygote_host_linux.h"
 #include "content/common/notification_service.h"
 
 #if !defined(OS_CHROMEOS)
 #error This file only meant to be compiled on ChromeOS
 #endif
 
 using base::TimeDelta;
 using base::TimeTicks;
 using base::ProcessHandle;
 using base::ProcessMetrics;
 
 namespace browser {
 
 // The default interval in seconds after which to adjust the oom_score_adj
 // value.
 #define ADJUSTMENT_INTERVAL_SECONDS 10
 
 // The default interval in minutes for considering activation times
 // "equal".
 #define BUCKET_INTERVAL_MINUTES 10
 
+// The default interval in milliseconds to wait before setting the score of
+// currently focused tab.
+#define FOCUSED_TAB_SCORE_ADJUST_INTERVAL_MS 500
+
 OomPriorityManager::RendererStats::RendererStats()
   : is_pinned(false),
     is_selected(false),
     memory_used(0),
     renderer_handle(0) {
 }
 
 OomPriorityManager::RendererStats::~RendererStats() {
 }
 
-OomPriorityManager::OomPriorityManager() {
+OomPriorityManager::OomPriorityManager()
+  : focused_tab_pid_(0) {
   renderer_stats_.reserve(32);  // 99% of users have < 30 tabs open
   registrar_.Add(this,
       content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       NotificationService::AllSources());
   registrar_.Add(this,
       content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
       NotificationService::AllSources());
+  registrar_.Add(this,
+      content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+      NotificationService::AllSources());
 }
 
 OomPriorityManager::~OomPriorityManager() {
   Stop();
 }
 
 void OomPriorityManager::Start() {
   if (!timer_.IsRunning()) {
     timer_.Start(FROM_HERE,
                  TimeDelta::FromSeconds(ADJUSTMENT_INTERVAL_SECONDS),
@@ skipping 38 matching lines @@
   // it's not really possible for the times to be identical, but if
   // the user selected two tabs at about the same time, we still want
   // to take the one that uses more memory.
   if (abs((first.last_selected - second.last_selected).ToInternalValue()) <
       kTimeBucketInterval)
     return first.last_selected > second.last_selected;
 
   return first.memory_used < second.memory_used;
 }
 
+void OomPriorityManager::AdjustFocusedTabScore() {
+  base::AutoLock pid_to_oom_score_autolock(pid_to_oom_score_lock_);
+  ZygoteHost::GetInstance()->AdjustRendererOOMScore(
+      focused_tab_pid_, chrome::kLowestRendererOomScore);
+  pid_to_oom_score_[focused_tab_pid_] = chrome::kLowestRendererOomScore;
+}
+
+void OomPriorityManager::OnFocusTabScoreAdjustmentTimeout() {
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      NewRunnableMethod(this, &OomPriorityManager::AdjustFocusedTabScore));
+}
+
 void OomPriorityManager::Observe(int type, const NotificationSource& source,
                                     const NotificationDetails& details) {
   base::ProcessHandle handle = 0;
   base::AutoLock pid_to_oom_score_autolock(pid_to_oom_score_lock_);
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED:
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
       handle = Source<RenderProcessHost>(source)->GetHandle();
       pid_to_oom_score_.erase(handle);
       break;
     }
+    case content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED: {
+      bool visible = *Details<bool>(details).ptr();
+      if (visible) {
+        focused_tab_pid_ =
+            Source<RenderWidgetHost>(source).ptr()->process()->GetHandle();
+
+        // If the currently focused tab already has a lower score, do not
+        // set it. This can happen in case the newly focused tab is script
+        // connected to the previous tab.
+        ProcessScoreMap::iterator it;
+        it = pid_to_oom_score_.find(focused_tab_pid_);
+        if (it == pid_to_oom_score_.end()
+            || it->second != chrome::kLowestRendererOomScore) {
+          // By starting a timer we guarantee that the tab is focused for
+          // certain amount of time. Secondly, it also does not add overhead
+          // to the tab switching time.
+          if (focus_tab_score_adjust_timer_.IsRunning())
+            focus_tab_score_adjust_timer_.Reset();
+          else
+            focus_tab_score_adjust_timer_.Start(FROM_HERE,
+              TimeDelta::FromMilliseconds(FOCUSED_TAB_SCORE_ADJUST_INTERVAL_MS),
+              this, &OomPriorityManager::OnFocusTabScoreAdjustmentTimeout);
+        }
+      }
+      break;
+    }
     default:
       NOTREACHED() << L"Received unexpected notification";
       break;
   }
 }
 
 // Here we collect most of the information we need to sort the
 // existing renderers in priority order, and hand out oom_score_adj
 // scores based on that sort order.
 //
@@ skipping 103 matching lines @@
         ZygoteHost::GetInstance()->AdjustRendererOOMScore(
             iterator->renderer_handle, score);
         pid_to_oom_score_[iterator->renderer_handle] = score;
       }
       priority += priority_increment;
     }
   }
 }
 
 }  // namespace browser