Add memory usage info to SyslogsProvider, and clean up bug report screenshot data.

chrome/browser/chromeos/system/syslogs_provider.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/chromeos/system/syslogs_provider.h"
 
+#include <functional>
+#include <set>
+
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/memory_details.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/browser/browser_thread.h"
 
 namespace chromeos {
 namespace system {
 namespace {
 
 const char kSysLogsScript[] =
     "/usr/share/userfeedback/scripts/sysinfo_script_runner";
 const char kBzip2Command[] =
@@ skipping 187 matching lines @@
   // Schedule a task on the FILE thread which will then trigger a request
   // callback on the calling thread (e.g. UI) when complete.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           this, &SyslogsProviderImpl::ReadSyslogs, request,
           compress_logs, context));
 
   return request->handle();
 }
 

[stevenjb, 2011/08/03 01:55:20]

Actual new code.

+// Derived class from memoryDetails converts the results into a single string
+// and adds a "mem_usage" entry to the logs, then forwards the result.
+// Format of entry is (one process per line, reverse-sorted by size):
+//   Tab [Title1|Title2]: 50 MB
+//   Browser: 30 MB
+//   Tab [Title]: 20 MB
+//   Extension [Title]: 10 MB
+// ...
+class SyslogsMemoryHandler : public MemoryDetails {
+ public:
+  typedef SyslogsProvider::ReadCompleteCallback ReadCompleteCallback;
+
+  // |logs| is modified (see comment above) and passed to |request|.
+  // |zip_content| is passed to |request|.
+  SyslogsMemoryHandler(
+      scoped_refptr<CancelableRequest<ReadCompleteCallback> > request,
+      LogDictionaryType* logs,
+      std::string* zip_content)
+      : request_(request),
+        logs_(logs),
+        zip_content_(zip_content) {
+  }
+
+  virtual void OnDetailsAvailable() OVERRIDE {
+    const ProcessData& chrome = processes()[0];  // Chrome is the first entry.
+    // Process info, sorted by memory used (highest to lowest).
+    typedef std::pair<size_t, std::string> ProcInfo;
+    typedef std::set<ProcInfo, std::greater<ProcInfo> > ProcInfoSet;
+    ProcInfoSet process_info;
+    for (ProcessMemoryInformationList::const_iterator iter1 =
+             chrome.processes.begin();
+         iter1 != chrome.processes.end(); ++iter1) {
+      std::string process_string(
+          ChildProcessInfo::GetFullTypeNameInEnglish(
+              iter1->type, iter1->renderer_type));
+      if (!iter1->titles.empty()) {
+        std::string titles(" [");
+        for (std::vector<string16>::const_iterator iter2 =
+                 iter1->titles.begin();
+             iter2 != iter1->titles.end(); ++iter2) {
+          if (iter2 != iter1->titles.begin())
+            titles += "|";
+          titles += UTF16ToUTF8(*iter2);
+        }
+        titles += "]";
+        process_string += titles;
+      }
+      // Use private working set for memory used calculation.
+      size_t ws_bytes = iter1->working_set.priv / 1024;

[James Cook, 2011/08/03 17:06:49]

If you're dividing by 1024, this isn't bytes.  ws_mb ?

[stevenjb, 2011/08/03 19:11:39]

Done.

+      process_info.insert(std::make_pair(ws_bytes, process_string));
+    }
+    // Add one line for each reverse-sorted entry.
+    std::string mem_string;
+    for (ProcInfoSet::iterator iter = process_info.begin();
+         iter != process_info.end(); ++iter) {
+      mem_string += iter->second + StringPrintf(": %u MB", iter->first) + "\n";
+    }
+    (*logs_)["mem_usage"] = mem_string;
+    // This will call the callback on the calling thread.
+    request_->ForwardResult(
+        Tuple2<LogDictionaryType*, std::string*>(logs_, zip_content_));
+  }
+
+ private:
+  virtual ~SyslogsMemoryHandler() {}
+
+  scoped_refptr<CancelableRequest<ReadCompleteCallback> > request_;
+  LogDictionaryType* logs_;
+  std::string* zip_content_;
+  DISALLOW_COPY_AND_ASSIGN(SyslogsMemoryHandler);
+};
+
 // Called from FILE thread.
 void SyslogsProviderImpl::ReadSyslogs(
     scoped_refptr<CancelableRequest<ReadCompleteCallback> > request,
     bool compress_logs,
     SyslogsContext context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (request->canceled())
     return;
 
@@ skipping 14 matching lines @@
       GetSyslogsContextString(context));
 
   std::string* zip_content = NULL;
   if (compress_logs) {
     // Load compressed logs.
     zip_content = new std::string();
     LoadCompressedLogs(zip_file, zip_content);
     file_util::Delete(zip_file, false);
   }
 
-  // Will call the callback on the calling thread.
-  request->ForwardResult(Tuple2<LogDictionaryType*,
-                                std::string*>(logs, zip_content));
+  // SyslogsMemoryHandler will clean itself up.
+  // SyslogsMemoryHandler::OnDetailsAvailable() will modify |logs| and call
+  // request->ForwardResult(logs, zip_content).
+  scoped_refptr<SyslogsMemoryHandler>
+      handler(new SyslogsMemoryHandler(request, logs, zip_content));
+  handler->StartFetch();
 }
 
-
 void SyslogsProviderImpl::LoadCompressedLogs(const FilePath& zip_file,
                                             std::string* zip_content) {
   DCHECK(zip_content);
   if (!file_util::ReadFileToString(zip_file, zip_content)) {
     LOG(ERROR) << "Cannot read compressed logs file from " <<
         zip_file.value().c_str();
   }
 }
 
 const char* SyslogsProviderImpl::GetSyslogsContextString(
@@ skipping 21 matching lines @@
 SyslogsProvider* SyslogsProvider::GetInstance() {
   return SyslogsProviderImpl::GetInstance();
 }
 
 }  // namespace system
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. SyslogsProviderImpl is a
 // Singleton and won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::system::SyslogsProviderImpl);