CrOS: Prefer discarding internal web UI pages when out of memory

chrome/browser/chromeos/memory/oom_priority_manager.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 "chrome/browser/chromeos/memory/oom_priority_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/memory/low_memory_observer.h"
 #include "chrome/browser/memory_details.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/zygote_host_linux.h"
 #include "ui/base/text/bytes_formatting.h"
 
 using base::TimeDelta;
@@ skipping 25 matching lines @@
 // value.
 const int kAdjustmentIntervalSeconds = 10;
 
 // If there has been no priority adjustment in this interval, we assume the
 // machine was suspended and correct our timing statistics.
 const int kSuspendThresholdSeconds = kAdjustmentIntervalSeconds * 4;
 
 // The default interval in milliseconds to wait before setting the score of
 // currently focused tab. Must be be long enough that a user who is flipping
 // through tabs with Ctrl-Tab does not mark each every tab as "focused".
-const int kFocusedTabScoreAdjustIntervalMs = 2000;
+const int kFocusedTabScoreAdjustIntervalMs = 1500;
 
 // Returns a unique ID for a WebContents.  Do not cast back to a pointer, as
 // the WebContents could be deleted if the user closed the tab.
 int64 IdFromWebContents(WebContents* web_contents) {
   return reinterpret_cast<int64>(web_contents);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OomMemoryDetails logs details about all Chrome processes during an out-of-
 // memory event in an attempt to identify the culprit, then discards a tab and
@@ skipping 37 matching lines @@
   Release();
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // OomPriorityManager
 
 OomPriorityManager::TabStats::TabStats()
   : is_app(false),
+    is_reloadable_ui(false),
     is_pinned(false),
     is_selected(false),
     is_discarded(false),
     renderer_handle(0),
     tab_contents_id(0) {
 }
 
 OomPriorityManager::TabStats::~TabStats() {
 }
 
@@ skipping 45 matching lines @@
   TabStatsList::iterator it = stats.begin();
   for ( ; it != stats.end(); ++it) {
     string16 str;
     str.reserve(4096);
     str += it->title;
     str += ASCIIToUTF16(" (");
     int score = pid_to_oom_score_[it->renderer_handle];
     str += base::IntToString16(score);
     str += ASCIIToUTF16(")");
     str += ASCIIToUTF16(it->is_app ? " app" : "");
+    str += ASCIIToUTF16(it->is_reloadable_ui ? " reloadable_ui" : "");
     str += ASCIIToUTF16(it->is_pinned ? " pinned" : "");
     str += ASCIIToUTF16(it->is_discarded ? " discarded" : "");
     titles.push_back(str);
   }
   return titles;
 }
 
 // TODO(jamescook): This should consider tabs with references to other tabs,
 // such as tabs created with JavaScript window.open().  We might want to
 // discard the entire set together, or use that in the priority computation.
@@ skipping 13 matching lines @@
   return false;
 }
 
 void OomPriorityManager::LogMemoryAndDiscardTab() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Deletes itself upon completion.
   OomMemoryDetails* details = new OomMemoryDetails();
   details->StartFetch(MemoryDetails::SKIP_USER_METRICS);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// OomPriorityManager, private:
+
+// static
+bool OomPriorityManager::IsReloadableUI(const GURL& url) {
+  // There are many chrome:// UI URLs, but only look for the ones that users
+  // are likely to have open. Most of the benefit is the from NTP URL.
+  const char* kReloadableUrlPrefixes[] = {
+      chrome::kChromeUIDownloadsURL,
+      chrome::kChromeUIHistoryURL,
+      chrome::kChromeUINewTabURL,
+      chrome::kChromeUISettingsURL,

[Dan Beam, 2016/06/01 17:30:36]

why wouldn't we use WebUIControllerFactoryRegistry::UseWebUIForURL() instead of
this half-baked list?

+  };
+  // Prefix-match against the table above. Use strncmp to avoid allocating
+  // memory to convert the URL prefix constants into std::strings.
+  for (size_t i = 0; i < arraysize(kReloadableUrlPrefixes); ++i) {
+    if (!strncmp(url.spec().c_str(),
+                 kReloadableUrlPrefixes[i],
+                 strlen(kReloadableUrlPrefixes[i])))
+      return true;
+  }
+  return false;
+}
+
 bool OomPriorityManager::DiscardTabById(int64 target_web_contents_id) {
   for (BrowserList::const_iterator browser_iterator = BrowserList::begin();
        browser_iterator != BrowserList::end(); ++browser_iterator) {
     Browser* browser = *browser_iterator;
     TabStripModel* model = browser->tab_strip_model();
     for (int idx = 0; idx < model->count(); idx++) {
       // Can't discard tabs that are already discarded or active.
       if (model->IsTabDiscarded(idx) || (model->active_index() == idx))
         continue;
       WebContents* web_contents = model->GetWebContentsAt(idx);
@@ skipping 80 matching lines @@
 }
 
 // Returns true if |first| is considered less desirable to be killed
 // than |second|.
 bool OomPriorityManager::CompareTabStats(TabStats first,
                                          TabStats second) {
   // Being currently selected is most important to protect.
   if (first.is_selected != second.is_selected)
     return first.is_selected;
 
+  // Tab with internal web UI like NTP or Settings are good choices to discard,
+  // so protect non-Web UI and let the other conditionals finish the sort.
+  if (first.is_reloadable_ui != second.is_reloadable_ui)
+    return !first.is_reloadable_ui;
+
   // Being pinned is important to protect.
   if (first.is_pinned != second.is_pinned)
     return first.is_pinned;
 
   // Being an app is important too, as you're the only visible surface in the
   // window and we don't want to discard that.
   if (first.is_app != second.is_app)
     return first.is_app;
 
   // TODO(jamescook): Incorporate sudden_termination_allowed into the sort
@@ skipping 117 matching lines @@
        browser_iterator != BrowserList::end_last_active();
        ++browser_iterator) {
     Browser* browser = *browser_iterator;
     bool is_browser_for_app = browser->is_app();
     const TabStripModel* model = browser->tab_strip_model();
     for (int i = 0; i < model->count(); i++) {
       WebContents* contents = model->GetWebContentsAt(i);
       if (!contents->IsCrashed()) {
         TabStats stats;
         stats.is_app = is_browser_for_app;
+        stats.is_reloadable_ui = IsReloadableUI(contents->GetURL());
         stats.is_pinned = model->IsTabPinned(i);
         stats.is_selected = browser_active && model->IsTabSelected(i);
         stats.is_discarded = model->IsTabDiscarded(i);
         stats.last_selected = contents->GetLastSelectedTime();
         stats.renderer_handle = contents->GetRenderProcessHost()->GetHandle();
         stats.title = contents->GetTitle();
         stats.tab_contents_id = IdFromWebContents(contents);
         stats_list.push_back(stats);
       }
     }
@@ skipping 50 matching lines @@
         content::ZygoteHost::GetInstance()->AdjustRendererOOMScore(
             iterator->renderer_handle, score);
         pid_to_oom_score_[iterator->renderer_handle] = score;
       }
       priority += priority_increment;
     }
   }
 }
 
 }  // namespace chromeos