Log app and tab discards.

chrome/browser/memory/tab_manager_delegate_chromeos.cc

 // Copyright 2015 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/memory/tab_manager_delegate_chromeos.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 20 matching lines @@
 #include "chrome/browser/memory/tab_stats.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_features.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_service_manager.h"
 #include "components/arc/common/process.mojom.h"
+#include "components/device_event_log/device_event_log.h"
 #include "components/exo/shell_surface.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/zygote_host_linux.h"
 #include "ui/aura/window.h"
 #include "ui/wm/public/activation_client.h"
 
@@ skipping 522 matching lines @@
 }
 
 
 chromeos::DebugDaemonClient* TabManagerDelegate::GetDebugDaemonClient() {
   return chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
 }
 
 void TabManagerDelegate::LowMemoryKillImpl(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
-
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   VLOG(2) << "LowMemoryKillImpl";
 
   const std::vector<TabManagerDelegate::Candidate> candidates =
       GetSortedCandidates(tab_list, arc_processes);
 
   int target_memory_to_free_kb = mem_stat_->TargetMemoryToFreeKB();
+  bool killed_candidate = false;
+
   // Kill processes until the estimated amount of freed memory is sufficient to
   // bring the system memory back to a normal level.
   // The list is sorted by descending importance, so we go through the list
   // backwards.
   for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
     VLOG(3) << "Target memory to free: " << target_memory_to_free_kb << " KB";
     // Never kill selected tab or Android foreground app, regardless whether
     // they're in the active window. Since the user experience would be bad.
     ProcessType process_type = it->process_type();
     if (process_type == ProcessType::VISIBLE_APP ||
         process_type == ProcessType::FOCUSED_APP ||
         process_type == ProcessType::FOCUSED_TAB) {
       VLOG(2) << "Skipped killing " << *it;
       continue;
     }
     if (it->app()) {
       int estimated_memory_freed_kb =
           mem_stat_->EstimatedMemoryFreedKB(it->app()->pid());
       if (KillArcProcess(it->app()->nspid())) {
         target_memory_to_free_kb -= estimated_memory_freed_kb;
         MemoryKillsMonitor::LogLowMemoryKill("APP", estimated_memory_freed_kb);
-        VLOG(2) << "Killed " << *it;
+        MEMORY_LOG(ERROR) << "Killed " << *it << ", estimated "
+                          << estimated_memory_freed_kb << " kB freed";

[Daniel Erat, 2017/04/10 17:39:49]

nit: "KB" rather than "kB" here and below? i think that this is units of 1024
bytes rather than 1000 bytes, per base/process/process_metrics_linux.cc. i'm
just going by https://en.wikipedia.org/wiki/Kilobyte, though, so feel free to
ignore this :-P

[teravest, 2017/04/10 17:52:03]

Done.

+        killed_candidate = true;
       }
     } else {
       int64_t tab_id = it->tab()->tab_contents_id;
       // The estimation is problematic since multiple tabs may share the same
       // process, while the calculation counts memory used by the whole process.
       // So |estimated_memory_freed_kb| is an over-estimation.
       int estimated_memory_freed_kb =
           mem_stat_->EstimatedMemoryFreedKB(it->tab()->renderer_handle);
       if (KillTab(tab_id)) {
         target_memory_to_free_kb -= estimated_memory_freed_kb;
         MemoryKillsMonitor::LogLowMemoryKill("TAB", estimated_memory_freed_kb);
-        VLOG(2) << "Killed " << *it;
+        MEMORY_LOG(ERROR) << "Killed " << *it << ", estimated "
+                          << estimated_memory_freed_kb << " kB freed";
+        killed_candidate = true;
       }
     }
     if (target_memory_to_free_kb < 0)
       break;
   }
+  if (!killed_candidate) {
+    MEMORY_LOG(ERROR) << "No candidate killed.";
+  }
 }
 
 void TabManagerDelegate::AdjustOomPrioritiesImpl(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
   // Least important first.
   const auto candidates = GetSortedCandidates(tab_list, arc_processes);
 
   // Now we assign priorities based on the sorted list. We're assigning
   // priorities in the range of kLowestRendererOomScore to
@@ skipping 84 matching lines @@
     }
     priority += priority_increment;
   }
 
   if (oom_scores_to_change.size())
     GetDebugDaemonClient()->SetOomScoreAdj(
         oom_scores_to_change, base::Bind(&OnSetOomScoreAdj));
 }
 
 }  // namespace memory