diff --git a/metrics/metrics_daemon.cc b/metrics/metrics_daemon.cc
index 4820590..273fa60 100644
--- a/metrics/metrics_daemon.cc
+++ b/metrics/metrics_daemon.cc
@@ -9,6 +9,7 @@
 
 #include <base/file_util.h>
 #include <base/logging.h>
+#include <base/string_util.h>
 #include <dbus/dbus-glib-lowlevel.h>
 
 #include "counter.h"
@@ -102,6 +103,8 @@
 const int MetricsDaemon::kMetricDiskStatsShortInterval = 1;  // seconds
 const int MetricsDaemon::kMetricDiskStatsLongInterval = 30;  // seconds
 
+const int MetricsDaemon::kMetricMeminfoInterval = 30;        // seconds
+
 // Assume a max rate of 250Mb/s for reads (worse for writes) and 512 byte
 // sectors.
 const int MetricsDaemon::kMetricSectorsIOMax = 500000;  // sectors/second
@@ -248,6 +251,9 @@
     DiskStatsReporterInit();
   }
 
+  // Start collecting meminfo stats.
+  ScheduleMeminfoCallback(kMetricMeminfoInterval);
+
   // Don't setup D-Bus and GLib in test mode.
   if (testing)
     return;
@@ -617,6 +623,124 @@
   }
 }
 
+void MetricsDaemon::ScheduleMeminfoCallback(int wait) {
+  if (testing_) {
+    return;
+  }
+  g_timeout_add_seconds(wait, MeminfoCallbackStatic, this);
+}
+
+// static
+gboolean MetricsDaemon::MeminfoCallbackStatic(void* handle) {
+  return (static_cast<MetricsDaemon*>(handle))->MeminfoCallback();
+}
+
+gboolean MetricsDaemon::MeminfoCallback() {
+  std::string meminfo;
+  const FilePath meminfo_path("/proc/meminfo");
+  if (!file_util::ReadFileToString(meminfo_path, &meminfo)) {
+    LOG(WARNING) << "cannot read " << meminfo_path.value().c_str();
+    return false;
+  }
+  return ProcessMeminfo(meminfo);
+}
+
+gboolean MetricsDaemon::ProcessMeminfo(std::string meminfo) {
+  // This array has one element for every item of /proc/meminfo that we want to
+  // report to UMA.  They must be listed in the same order in which
+  // /proc/meminfo prints them.
+  struct {
+    const char* name;   // print name
+    const char* match;  // string to match in output of /proc/meminfo
+    int log_scale;      // report with log scale instead of linear percent
+  } fields[] = {
+    { "MemTotal", "MemTotal" },  // SPECIAL CASE: total system memory
+    { "MemFree", "MemFree" },
+    { "Buffers", "Buffers" },
+    { "Cached", "Cached" },
+    // { "SwapCached", "SwapCached" },
+    { "Active", "Active" },
+    { "Inactive", "Inactive" },
+    { "ActiveAnon", "Active(anon)" },
+    { "InactiveAnon", "Inactive(anon)" },
+    { "ActiveFile" , "Active(file)" },
+    { "InactiveFile", "Inactive(file)" },
+    { "Unevictable", "Unevictable", 1 },
+    // { "Mlocked", "Mlocked" },
+    // { "SwapTotal", "SwapTotal" },
+    // { "SwapFree", "SwapFree" },
+    // { "Dirty", "Dirty" },
+    // { "Writeback", "Writeback" },
+    { "AnonPages", "AnonPages" },
+    { "Mapped", "Mapped" },
+    { "Shmem", "Shmem", 1 },
+    { "Slab", "Slab", 1 },
+    // { "SReclaimable", "SReclaimable" },
+    // { "SUnreclaim", "SUnreclaim" },
+  };
+  // arraysize doesn't work here, probably can't handle anonymous structs
+  const int nfields = sizeof(fields) / sizeof(fields[0]);
+  int total_memory = 0;
+  std::vector<std::string> lines;
+  int nlines = Tokenize(meminfo, "\n", &lines);
+
+  // Scan meminfo output and collect field values.  Each field name has to
+  // match a meminfo entry (case insensitive) after removing non-alpha
+  // characters from the entry.
+  int i = 0;
+  int iline = 0;
+  for (;;) {
+    if (i == nfields) {
+      // all fields are matched
+      return true;
+    }
+    if (iline == nlines) {
+      // end of input reached while scanning
+      LOG(WARNING) << "cannot find field " << fields[i].match
+                   << " and following";
+      return false;
+    }
+
+    std::vector<std::string> tokens;
+    Tokenize(lines[iline], ": ", &tokens);
+
+    if (strcmp(fields[i].match, tokens[0].c_str()) == 0) {
+      // name matches: parse value and report
+      int meminfo_value;
+      char metrics_name[128];
+      char* rest;
+      meminfo_value = static_cast<int>(strtol(tokens[1].c_str(), &rest, 10));
+      if (*rest != '\0') {
+        LOG(WARNING) << "missing meminfo value";
+        return false;
+      }
+      if (i == 0) {
+        // special case: total memory
+        total_memory = meminfo_value;
+      } else {
+        snprintf(metrics_name, sizeof(metrics_name),
+                 "Platform.Meminfo%s", fields[i].name);
+        if (fields[i].log_scale) {
+          // report value in kbytes, log scale, 4Gb max
+          SendMetric(metrics_name, meminfo_value, 1, 4 * 1000 * 1000, 100);
+        } else {
+          // report value as percent of total memory
+          if (total_memory == 0) {
+            // this "cannot happen"
+            LOG(WARNING) << "borked meminfo parser";
+            return false;
+          }
+          int percent = meminfo_value * 100 / total_memory;
+          SendLinearMetric(metrics_name, percent, 100, 101);
+        }
+      }
+      // start looking for next field
+      i++;
+    }
+    iline++;
+  }
+}
+
 // static
 void MetricsDaemon::ReportDailyUse(void* handle, int tag, int count) {
   if (count <= 0)
@@ -636,3 +760,13 @@
              << min << " " << max << " " << nbuckets;
   metrics_lib_->SendToUMA(name, sample, min, max, nbuckets);
 }
+
+void MetricsDaemon::SendLinearMetric(const string& name, int sample,
+                                     int max, int nbuckets) {
+  DLOG(INFO) << "received linear metric: " << name << " " << sample << " "
+             << max << " " << nbuckets;
+  // TODO(semenzato): add a proper linear histogram to the Chrome external
+  // metrics API.
+  LOG_IF(FATAL, nbuckets != max + 1) << "unsupported histogram scale";
+  metrics_lib_->SendEnumToUMA(name, sample, max);
+}
diff --git a/metrics/metrics_daemon.h b/metrics/metrics_daemon.h
index 5252518..e061445 100644
--- a/metrics/metrics_daemon.h
+++ b/metrics/metrics_daemon.h
@@ -49,6 +49,8 @@
   FRIEND_TEST(MetricsDaemonTest, MessageFilter);
   FRIEND_TEST(MetricsDaemonTest, PowerStateChanged);
   FRIEND_TEST(MetricsDaemonTest, ProcessKernelCrash);
+  FRIEND_TEST(MetricsDaemonTest, ProcessMeminfo);
+  FRIEND_TEST(MetricsDaemonTest, ProcessMeminfo2);
   FRIEND_TEST(MetricsDaemonTest, ProcessUncleanShutdown);
   FRIEND_TEST(MetricsDaemonTest, ProcessUserCrash);
   FRIEND_TEST(MetricsDaemonTest, ReportCrashesDailyFrequency);
@@ -125,6 +127,7 @@
   static const char kMetricWriteSectorsShortName[];
   static const int kMetricDiskStatsShortInterval;
   static const int kMetricDiskStatsLongInterval;
+  static const int kMetricMeminfoInterval;
   static const int kMetricSectorsIOMax;
   static const int kMetricSectorsBuckets;
   static const char kMetricsDiskStatsPath[];
@@ -234,6 +237,12 @@
   void SendMetric(const std::string& name, int sample,
                   int min, int max, int nbuckets);
 
+  // Sends a linear histogram sample to Chrome for transport to UMA. See
+  // MetricsLibrary::SendToUMA in metrics_library.h for a description of the
+  // arguments.
+  void SendLinearMetric(const std::string& name, int sample,
+                        int max, int nbuckets);
+
   // Initializes disk stats reporting.
   void DiskStatsReporterInit();
 
@@ -250,6 +259,20 @@
   // Reports disk statistics.
   void DiskStatsCallback();
 
+  // Schedules meminfo collection callback.
+  void ScheduleMeminfoCallback(int wait);
+
+  // Reports memory statistics (static version for glib).  Argument is a glib
+  // artifact.
+  static gboolean MeminfoCallbackStatic(void* handle);
+
+  // Reports memory statistics.  Returns false on failure.
+  gboolean MeminfoCallback();
+
+  // Parses content of /proc/meminfo and sends fields of interest to UMA.
+  // Returns false on errors.
+  gboolean ProcessMeminfo(std::string meminfo);
+
   // Test mode.
   bool testing_;
 
diff --git a/metrics/metrics_daemon_test.cc b/metrics/metrics_daemon_test.cc
index 208d8e5..476bf1c 100644
--- a/metrics/metrics_daemon_test.cc
+++ b/metrics/metrics_daemon_test.cc
@@ -27,6 +27,7 @@
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
+using ::testing::AtLeast;
 
 static const int kSecondsPerDay = 24 * 60 * 60;
 
@@ -578,6 +579,66 @@
   EXPECT_TRUE(ds_state != daemon_.diskstats_state_);
 }
 
+TEST_F(MetricsDaemonTest, ProcessMeminfo) {
+  const char* meminfo = "\
+MemTotal:        2000000 kB\n\
+MemFree:         1000000 kB\n\
+Buffers:           10492 kB\n\
+Cached:           213652 kB\n\
+SwapCached:            0 kB\n\
+Active:           133400 kB\n\
+Inactive:         183396 kB\n\
+Active(anon):      92984 kB\n\
+Inactive(anon):    58860 kB\n\
+Active(file):      40416 kB\n\
+Inactive(file):   124536 kB\n\
+Unevictable:           0 kB\n\
+Mlocked:               0 kB\n\
+SwapTotal:             0 kB\n\
+SwapFree:              0 kB\n\
+Dirty:                40 kB\n\
+Writeback:             0 kB\n\
+AnonPages:         92652 kB\n\
+Mapped:            59716 kB\n\
+Shmem:             59196 kB\n\
+Slab:              16656 kB\n\
+SReclaimable:       6132 kB\n\
+SUnreclaim:        10524 kB\n\
+KernelStack:        1648 kB\n\
+PageTables:         2780 kB\n\
+NFS_Unstable:          0 kB\n\
+Bounce:                0 kB\n\
+WritebackTmp:          0 kB\n\
+CommitLimit:      970656 kB\n\
+Committed_AS:    1260528 kB\n\
+VmallocTotal:     122880 kB\n\
+VmallocUsed:       12144 kB\n\
+VmallocChunk:     103824 kB\n\
+DirectMap4k:        9636 kB\n\
+DirectMap2M:     1955840 kB\n\
+";
+  EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, _, 100))
+      .Times(AtLeast(1));
+  EXPECT_CALL(metrics_lib_, SendToUMA(_, _, _, _, _))
+      .Times(AtLeast(1));
+  EXPECT_CALL(metrics_lib_, SendToUMA("NFS_Unstable", _, _, _, _))
+      .Times(0);
+  EXPECT_CALL(metrics_lib_, SendEnumToUMA("NFS_Unstable", _, _))
+      .Times(0);
+  EXPECT_TRUE(daemon_.ProcessMeminfo(meminfo));
+}
+
+TEST_F(MetricsDaemonTest, ProcessMeminfo2) {
+  const char* meminfo = "\
+MemTotal:        2000000 kB\n\
+MemFree:         1000000 kB\n\
+";
+  /* Not enough fields */
+  EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, 50, 100))
+      .Times(1);
+  EXPECT_FALSE(daemon_.ProcessMeminfo(meminfo));
+}
+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();