Implement ToValue() for SystemMetrics, SystemMemoryInfoKB, DiskInfo, and SwapInfo.

base/process/process_metrics_linux.cc

 // Copyright (c) 2013 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 "base/process/process_metrics.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 492 matching lines @@
   pgmajfault = 0;
 
 #ifdef OS_CHROMEOS
   shmem = 0;
   slab = 0;
   gem_objects = -1;
   gem_size = -1;
 #endif
 }
 
+scoped_ptr<Value> SystemMemoryInfoKB::ToValue() const {
+  scoped_ptr<DictionaryValue> res(new base::DictionaryValue());
+
+  res->SetInteger("total", total);
+  res->SetInteger("free", free);
+  res->SetInteger("buffers", buffers);
+  res->SetInteger("cached", cached);
+  res->SetInteger("active_anon", active_anon);
+  res->SetInteger("inactive_anon", inactive_anon);
+  res->SetInteger("active_file", active_file);
+  res->SetInteger("inactive_file", inactive_file);
+  res->SetInteger("swap_total", swap_total);
+  res->SetInteger("swap_free", swap_free);
+  res->SetInteger("swap_used", swap_total - swap_free);
+  res->SetInteger("dirty", dirty);
+  res->SetInteger("pswpin", pswpin);
+  res->SetInteger("pswpout", pswpout);
+  res->SetInteger("pgmajfault", pgmajfault);
+#ifdef OS_CHROMEOS
+  res->SetInteger("shmem", shmem);
+  res->SetInteger("slab", slab);
+  res->SetInteger("gem_objects", gem_objects);
+  res->SetInteger("gem_size", gem_size);
+#endif
+
+  return res.PassAs<Value>();
+}
+
 bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
   // Synchronously reading files in /proc is safe.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Used memory is: total - free - buffers - caches
   FilePath meminfo_file("/proc/meminfo");
   std::string meminfo_data;
   if (!ReadFileToString(meminfo_file, &meminfo_data)) {
     DLOG(WARNING) << "Failed to open " << meminfo_file.value();
     return false;
@@ skipping 109 matching lines @@
   read_time = 0;
   writes = 0;
   writes_merged = 0;
   sectors_written = 0;
   write_time = 0;
   io = 0;
   io_time = 0;
   weighted_io_time = 0;
 }
 
+scoped_ptr<Value> SystemDiskInfo::ToValue() const {
+  scoped_ptr<DictionaryValue> res(new base::DictionaryValue());
+
+  // Write out uint64 variables as doubles.
+  // Note: this may discard some precision, but for JS there's no other option.
+  res->SetDouble("reads", static_cast<double>(reads));
+  res->SetDouble("reads_merged", static_cast<double>(reads_merged));
+  res->SetDouble("sectors_read", static_cast<double>(sectors_read));
+  res->SetDouble("read_time", static_cast<double>(read_time));
+  res->SetDouble("writes", static_cast<double>(writes));
+  res->SetDouble("writes_merged", static_cast<double>(writes_merged));
+  res->SetDouble("sectors_written", static_cast<double>(sectors_written));
+  res->SetDouble("write_time", static_cast<double>(write_time));
+  res->SetDouble("io", static_cast<double>(io));
+  res->SetDouble("io_time", static_cast<double>(io_time));
+  res->SetDouble("weighted_io_time", static_cast<double>(weighted_io_time));
+
+  return res.PassAs<Value>();
+}
+
 bool IsValidDiskName(const std::string& candidate) {
   if (candidate.length() < 3)
     return false;
   if (candidate.substr(0,2) == "sd" || candidate.substr(0,2) == "hd") {
     // [sh]d[a-z]+ case
     for (size_t i = 2; i < candidate.length(); i++) {
       if (!islower(candidate[i]))
         return false;
     }
   } else {
@@ skipping 85 matching lines @@
       diskinfo->io += io;
       diskinfo->io_time += io_time;
       diskinfo->weighted_io_time += weighted_io_time;
     }
   }
 
   return true;
 }
 
 #if defined(OS_CHROMEOS)
+scoped_ptr<Value> SwapInfo::ToValue() const {
+  scoped_ptr<DictionaryValue> res(new DictionaryValue());
+
+  // Write out uint64 variables as doubles.
+  // Note: this may discard some precision, but for JS there's no other option.
+  res->SetDouble("num_reads", static_cast<double>(num_reads));
+  res->SetDouble("num_writes", static_cast<double>(num_writes));
+  res->SetDouble("orig_data_size", static_cast<double>(orig_data_size));
+  res->SetDouble("compr_data_size", static_cast<double>(compr_data_size));
+  res->SetDouble("mem_used_total", static_cast<double>(mem_used_total));
+  if (compr_data_size > 0)
+    res->SetDouble("compression_ratio", static_cast<double>(orig_data_size) /
+                                        static_cast<double>(compr_data_size));
+  else
+    res->SetDouble("compression_ratio", 0);
+
+  return res.PassAs<Value>();
+}
+
 void GetSwapInfo(SwapInfo* swap_info) {
   // Synchronously reading files in /sys/block/zram0 is safe.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   base::FilePath zram_path("/sys/block/zram0");
   uint64 orig_data_size = ReadFileToUint64(zram_path.Append("orig_data_size"));
   if (orig_data_size <= 4096) {
     // A single page is compressed at startup, and has a high compression
     // ratio. We ignore this as it doesn't indicate any real swapping.
     swap_info->orig_data_size = 0;
     swap_info->num_reads = 0;
     swap_info->num_writes = 0;
     swap_info->compr_data_size = 0;
     swap_info->mem_used_total = 0;
     return;
   }
   swap_info->orig_data_size = orig_data_size;
   swap_info->num_reads = ReadFileToUint64(zram_path.Append("num_reads"));
   swap_info->num_writes = ReadFileToUint64(zram_path.Append("num_writes"));
   swap_info->compr_data_size =
       ReadFileToUint64(zram_path.Append("compr_data_size"));
   swap_info->mem_used_total =
       ReadFileToUint64(zram_path.Append("mem_used_total"));
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace base