cros: Log per-process memory use on low memory events

chrome/browser/memory_details.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/memory_details.h"
 
 #include "base/bind.h"
 #include "base/file_version_info.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/process_type.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 #include "content/public/browser/zygote_host_linux.h"
 #endif
 
+using base::StringPrintf;
 using content::BrowserChildProcessHostIterator;
 using content::BrowserThread;
 using content::NavigationEntry;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 // static
 std::string ProcessMemoryInformation::GetRendererTypeNameInEnglish(
     RendererProcessType type) {
@@ skipping 60 matching lines @@
 // This operation will hit no fewer than 3 threads.
 //
 // The BrowserChildProcessHostIterator can only be accessed from the IO thread.
 //
 // The RenderProcessHostIterator can only be accessed from the UI thread.
 //
 // This operation can take 30-100ms to complete.  We never want to have
 // one task run for that long on the UI or IO threads.  So, we run the
 // expensive parts of this operation over on the file thread.
 //
-void MemoryDetails::StartFetch() {
+void MemoryDetails::StartFetch(UserMetricsMode user_metrics_mode) {
   // This might get called from the UI or FILE threads, but should not be
   // getting called from the IO thread.
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
+  user_metrics_mode_ = user_metrics_mode;
 
   // In order to process this request, we need to use the plugin information.
   // However, plugin process information is only available from the IO thread.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MemoryDetails::CollectChildInfoOnIOThread, this));
 }
 
 MemoryDetails::~MemoryDetails() {}
 
+std::string MemoryDetails::ToLogString() {
+  std::string log;
+  log.reserve(4096);
+  const ProcessData& chrome = *ChromeBrowser();
+  for (ProcessMemoryInformationList::const_iterator iter1 =
+           chrome.processes.begin();
+       iter1 != chrome.processes.end(); ++iter1) {
+    log += ProcessMemoryInformation::GetFullTypeNameInEnglish(
+            iter1->type, iter1->renderer_type);
+    if (!iter1->titles.empty()) {
+      log += " [";
+      for (std::vector<string16>::const_iterator iter2 =
+               iter1->titles.begin();
+           iter2 != iter1->titles.end(); ++iter2) {
+        if (iter2 != iter1->titles.begin())
+          log += "|";
+        log += UTF16ToUTF8(*iter2);
+      }
+      log += "]";
+    }
+    log += StringPrintf(" %d MB private, %d MB shared\n",
+                        static_cast<int>(iter1->working_set.priv) / 1024,
+                        static_cast<int>(iter1->working_set.shared) / 1024);
+  }
+  return log;
+}
+
 void MemoryDetails::CollectChildInfoOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   std::vector<ProcessMemoryInformation> child_info;
 
   // Collect the list of child processes.
   for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
     ProcessMemoryInformation info;
     info.pid = base::GetProcId(iter.GetData().handle);
     if (!info.pid)
@@ skipping 173 matching lines @@
   for (size_t index = 0; index < chrome_browser->processes.size();
       index++) {
     if (chrome_browser->processes[index].type ==
         content::PROCESS_TYPE_UNKNOWN) {
       chrome_browser->processes.erase(
           chrome_browser->processes.begin() + index);
       index--;
     }
   }
 
-  UpdateHistograms();
+  if (user_metrics_mode_ == UPDATE_USER_METRICS)
+    UpdateHistograms();
 
   OnDetailsAvailable();
 }
 
 void MemoryDetails::UpdateHistograms() {
   // Reports a set of memory metrics to UMA.
   // Memory is measured in KB.
 
   const ProcessData& browser = *ChromeBrowser();
   size_t aggregate_memory = 0;
@@ skipping 88 matching lines @@
   UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginProcessCount",
       pepper_plugin_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.RendererProcessCount", renderer_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.WorkerProcessCount", worker_count);
   // TODO(viettrungluu): Do we want separate counts for the other
   // (platform-specific) process types?
 
   int total_sample = static_cast<int>(aggregate_memory / 1000);
   UMA_HISTOGRAM_MEMORY_MB("Memory.Total", total_sample);
 }