Reland "Enable SysInfo::AmountOfPhysicalMemory to be called from within the Linux Sandbox"

Trigger caching of SysInfo::AmountOfPhysicalMemory in PreSandboxInit() to enable
it to be called by the renderer process after the sandbox is sealed.

BUG=312241

Review URL: https://codereview.chromium.org/55913004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@232790 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 51 insertions, 23 deletions

diff --git a/base/sys_info_linux.cc b/base/sys_info_linux.cc
index acc4771..d7c9f10 100644
--- a/base/sys_info_linux.cc
+++ b/base/sys_info_linux.cc
@@ -7,6 +7,7 @@
 #include <limits>
 
 #include "base/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 
@@ -22,41 +23,68 @@ int64 AmountOfMemory(int pages_name) {
   return static_cast<int64>(pages) * page_size;
 }
 
+int64 AmountOfPhysicalMemory() {
+  return AmountOfMemory(_SC_PHYS_PAGES);
+}
+
+size_t MaxSharedMemorySize() {
+  std::string contents;
+  base::ReadFileToString(base::FilePath("/proc/sys/kernel/shmmax"), &contents);
+  DCHECK(!contents.empty());
+  if (!contents.empty() && contents[contents.length() - 1] == '\n') {
+    contents.erase(contents.length() - 1);
+  }
+
+  int64 limit;
+  if (!base::StringToInt64(contents, &limit)) {
+    limit = 0;
+  }
+  if (limit < 0 ||
+      static_cast<uint64>(limit) > std::numeric_limits<size_t>::max()) {
+    limit = 0;
+  }
+  DCHECK(limit > 0);
+  return static_cast<size_t>(limit);
+}
+
+template<typename T, T (*F)(void)>
+class LazySysInfoValue {
+ public:
+  LazySysInfoValue()
+      : value_(F()) { }
+
+  ~LazySysInfoValue() { }
+
+  T value() { return value_; }
+
+ private:
+  const T value_;
+
+  DISALLOW_COPY_AND_ASSIGN(LazySysInfoValue);
+};
+
+base::LazyInstance<LazySysInfoValue<int64, AmountOfPhysicalMemory> >::Leaky
+    g_lazy_physical_memory = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<LazySysInfoValue<size_t, MaxSharedMemorySize> >::Leaky
+    g_lazy_max_shared_memory = LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 namespace base {
 
 // static
-int64 SysInfo::AmountOfPhysicalMemory() {
-  return AmountOfMemory(_SC_PHYS_PAGES);
+int64 SysInfo::AmountOfAvailablePhysicalMemory() {
+  return AmountOfMemory(_SC_AVPHYS_PAGES);
 }
 
 // static
-int64 SysInfo::AmountOfAvailablePhysicalMemory() {
-  return AmountOfMemory(_SC_AVPHYS_PAGES);
+int64 SysInfo::AmountOfPhysicalMemory() {
+  return g_lazy_physical_memory.Get().value();
 }
 
 // static
 size_t SysInfo::MaxSharedMemorySize() {
-  static int64 limit;
-  static bool limit_valid = false;
-  if (!limit_valid) {
-    std::string contents;
-    ReadFileToString(FilePath("/proc/sys/kernel/shmmax"), &contents);
-    DCHECK(!contents.empty());
-    if (!contents.empty() && contents[contents.length() - 1] == '\n') {
-      contents.erase(contents.length() - 1);
-    }
-    if (base::StringToInt64(contents, &limit)) {
-      DCHECK(limit >= 0);
-      DCHECK(static_cast<uint64>(limit) <= std::numeric_limits<size_t>::max());
-      limit_valid = true;
-    } else {
-      NOTREACHED();
-      return 0;
-    }
-  }
-  return static_cast<size_t>(limit);
+  return g_lazy_max_shared_memory.Get().value();
 }
 
 // static