Read ChromeOS version numbers from file before sandboxing and cache them.

base/sys_info_chromeos.cc

 // Copyright (c) 2009 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/sys_info.h"
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/threading/thread_restrictions.h"
 
+#include <execinfo.h>
+
 namespace base {
 
-#if defined(GOOGLE_CHROME_BUILD)
-static const char kLinuxStandardBaseVersionKey[] = "GOOGLE_RELEASE";
-#else
-static const char kLinuxStandardBaseVersionKey[] = "DISTRIB_RELEASE";
-#endif
+static const char kLinuxStandardBaseVersionKey[] = "CHROMEOS_RELEASE_VERSION";

[Chris Masone, 2011/03/29 15:43:25]

What will happen when this is run on a non-chrome-os platform, as many people do
while testing?  This was the entire purpose of the GOOGLE_CHROME_BUILD stuff, so
that we'd fail over in the case of chromium builds.  Like, will this change
cause failures on the trybots and builders?

[dgozman, 2011/03/30 12:30:17]

I think, when you run this on a non-chrome-os, you will not get ChromeOS version
anyway (just a linux version from DISTRIB_RELEASE in the best case).
And GOOGLE_CHROME_BUILD stuff fails when you gmerge Chrome to the ChromeOS
image.

Probably, we can try different strings here, but I'm not sure.

Btw, try run succeeded (chromeos, win, linux, mac):
http://build.chromium.org/p/tryserver.chromium/builders/linux_chromeos/builds...
http://build.chromium.org/p/tryserver.chromium/builders/win/builds/23727

[Chris Masone, 2011/03/30 14:38:02]

I know, but that was deemed to better than returning nothing by my original code
reviewers.
Yeah, but is there even a unit test for this code? I seem to recall it being
disabled at some point.

[dgozman, 2011/04/01 15:28:31]

I added checking for multiple keys.

+const char kLinuxStandardBaseReleaseFile[] = "/etc/lsb-release";
 
-const char kLinuxStandardBaseReleaseFile[] = "/etc/lsb-release";
+struct ChromeOSVersionNumbers {
+  ChromeOSVersionNumbers()
+      : major_version(0),
+        minor_version(0),
+        bugfix_version(0),
+        parsed(false) {
+  }
+
+  int32 major_version;
+  int32 minor_version;
+  int32 bugfix_version;
+  bool parsed;
+};
+
+static base::LazyInstance<ChromeOSVersionNumbers>
+    g_chrome_os_version_numbers(base::LINKER_INITIALIZED);
 
 // static
 void SysInfo::OperatingSystemVersionNumbers(int32 *major_version,
                                             int32 *minor_version,
                                             int32 *bugfix_version) {
-  // The other implementations of SysInfo don't block on the disk.
-  // See http://code.google.com/p/chromium/issues/detail?id=60394
-  // Perhaps the caller ought to cache this?
-  // Temporary allowing while we work the bug out.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  if (!g_chrome_os_version_numbers.Get().parsed) {
+    // The other implementations of SysInfo don't block on the disk.
+    // See http://code.google.com/p/chromium/issues/detail?id=60394
+    // Perhaps the caller ought to cache this?
+    // Temporary allowing while we work the bug out.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
 
-  // TODO(cmasone): If this gets called a lot, it may kill performance.
-  // consider using static variables to cache these values?
-  FilePath path(kLinuxStandardBaseReleaseFile);
-  std::string contents;
-  if (file_util::ReadFileToString(path, &contents)) {
-    ParseLsbRelease(contents, major_version, minor_version, bugfix_version);
+    FilePath path(kLinuxStandardBaseReleaseFile);
+    std::string contents;
+    if (file_util::ReadFileToString(path, &contents)) {
+      g_chrome_os_version_numbers.Get().parsed = true;
+      ParseLsbRelease(contents,
+          &(g_chrome_os_version_numbers.Get().major_version),
+          &(g_chrome_os_version_numbers.Get().minor_version),
+          &(g_chrome_os_version_numbers.Get().bugfix_version));
+    }
   }
+  *major_version = g_chrome_os_version_numbers.Get().major_version;
+  *minor_version = g_chrome_os_version_numbers.Get().minor_version;
+  *bugfix_version = g_chrome_os_version_numbers.Get().bugfix_version;
 }
 
 // static
 std::string SysInfo::GetLinuxStandardBaseVersionKey() {
   return std::string(kLinuxStandardBaseVersionKey);
 }
 
 // static
 void SysInfo::ParseLsbRelease(const std::string& lsb_release,
                               int32 *major_version,
@@ skipping 20 matching lines @@
                   minor_version);
     } else {  // 2 == i
       StringToInt(tokenizer.token_begin(),
                   tokenizer.token_end(),
                   bugfix_version);
     }
   }
 }
 
 }  // namespace base