Revert of Fix free memory calculation.

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 <stddef.h>
 #include <stdint.h>
@@ skipping 514 matching lines @@
 const size_t kDiskWrites = 7;
 const size_t kDiskWritesMerged = 8;
 const size_t kDiskSectorsWritten = 9;
 const size_t kDiskWriteTime = 10;
 const size_t kDiskIO = 11;
 const size_t kDiskIOTime = 12;
 const size_t kDiskWeightedIOTime = 13;
 
 }  // namespace
 
+SystemMemoryInfoKB::SystemMemoryInfoKB() {
+  total = 0;
+  free = 0;
+#if defined(OS_LINUX)
+  available = 0;
+#endif
+  buffers = 0;
+  cached = 0;
+  active_anon = 0;
+  inactive_anon = 0;
+  active_file = 0;
+  inactive_file = 0;
+  swap_total = 0;
+  swap_free = 0;
+  dirty = 0;
+
+  pswpin = 0;
+  pswpout = 0;
+  pgmajfault = 0;
+
+#ifdef OS_CHROMEOS
+  shmem = 0;
+  slab = 0;
+  gem_objects = -1;
+  gem_size = -1;
+#endif
+}
+
+SystemMemoryInfoKB::SystemMemoryInfoKB(const SystemMemoryInfoKB& other) =
+    default;
+
 std::unique_ptr<Value> SystemMemoryInfoKB::ToValue() const {
   std::unique_ptr<DictionaryValue> res(new DictionaryValue());
 
   res->SetInteger("total", total);
   res->SetInteger("free", free);
+#if defined(OS_LINUX)
   res->SetInteger("available", available);
+#endif
   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("reclaimable", reclaimable);
   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
 
@@ skipping 27 matching lines @@
       DLOG(WARNING) << "meminfo: tokens: " << tokens.size()
                     << " malformed line: " << line.as_string();
       continue;
     }
 
     int* target = NULL;
     if (tokens[0] == "MemTotal:")
       target = &meminfo->total;
     else if (tokens[0] == "MemFree:")
       target = &meminfo->free;
+#if defined(OS_LINUX)
     else if (tokens[0] == "MemAvailable:")
       target = &meminfo->available;
+#endif
     else if (tokens[0] == "Buffers:")
       target = &meminfo->buffers;
     else if (tokens[0] == "Cached:")
       target = &meminfo->cached;
     else if (tokens[0] == "Active(anon):")
       target = &meminfo->active_anon;
     else if (tokens[0] == "Inactive(anon):")
       target = &meminfo->inactive_anon;
     else if (tokens[0] == "Active(file):")
       target = &meminfo->active_file;
     else if (tokens[0] == "Inactive(file):")
       target = &meminfo->inactive_file;
     else if (tokens[0] == "SwapTotal:")
       target = &meminfo->swap_total;
     else if (tokens[0] == "SwapFree:")
       target = &meminfo->swap_free;
     else if (tokens[0] == "Dirty:")
       target = &meminfo->dirty;
-    else if (tokens[0] == "SReclaimable:")
-      target = &meminfo->reclaimable;
 #if defined(OS_CHROMEOS)
     // Chrome OS has a tweaked kernel that allows us to query Shmem, which is
     // usually video memory otherwise invisible to the OS.
     else if (tokens[0] == "Shmem:")
       target = &meminfo->shmem;
     else if (tokens[0] == "Slab:")
       target = &meminfo->slab;
 #endif
     if (target)
       StringToInt(tokens[1], target);
@@ skipping 303 matching lines @@
 #if defined(OS_LINUX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
   uint64_t wake_ups;
   const char kWakeupStat[] = "se.statistics.nr_wakeups";
   return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
       CalculateIdleWakeupsPerSecond(wake_ups) : 0;
 }
 #endif  // defined(OS_LINUX)
 
 }  // namespace base