Move Android user agent generation to native code

base/sys_info_android.cc

 // Copyright (c) 2012 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 <sys/system_properties.h>
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
+#include "base/stringprintf.h"
 
 namespace {
 
+// Parse out the OS version numbers from the system properties.
+void ParseOSVersionNumbers(const char* os_version_str,
+                           int *major_version,
+                           int *minor_version,
+                           int *bugfix_version) {
+  if (strlen(os_version_str) > 0) {
+    // Try to parse out the version numbers from the string.
+    int num_read = sscanf(os_version_str, "%d.%d.%d", major_version,
+        minor_version, bugfix_version);

[jar (doing other things), 2012/08/15 23:35:17]

nit: better to wrap to paren when you can (and you can here).

[gone, 2012/08/16 00:29:31]

Ah, wasn't sure whether the style guide allowed it.

+
+    if (num_read > 0) {
+      // If we don't have a full set of version numbers, make the extras 0.
+      if (num_read < 2) *minor_version = 0;
+      if (num_read < 3) *bugfix_version = 0;
+      return;
+    }
+  }
+
+  // For some reason, we couldn't parse the version number string.
+  *major_version = base::SysInfo::kDefaultAndroidMajorVersion;
+  *minor_version = base::SysInfo::kDefaultAndroidMinorVersion;
+  *bugfix_version = base::SysInfo::kDefaultAndroidBugfixVersion;
+}
+
 int ParseHeapSize(const base::StringPiece& str) {
   const int64 KB = 1024;
   const int64 MB = 1024 * KB;
   const int64 GB = 1024 * MB;
   CHECK_GT(str.size(), 0u);
   int64 factor = 1;
   size_t length = str.size();
   if (str[length - 1] == 'k') {
     factor = KB;
     length--;
@@ skipping 19 matching lines @@
 int GetDalvikHeapSizeMB() {
   char heap_size_str[PROP_VALUE_MAX];
   __system_property_get("dalvik.vm.heapsize", heap_size_str);
   return ParseHeapSize(heap_size_str);
 }
 
 }  // anonymous namespace
 
 namespace base {
 
+std::string SysInfo::GetAndroidBuildCodename() {
+  char os_version_codename_str[PROP_VALUE_MAX];
+  __system_property_get("ro.build.version.codename", os_version_codename_str);
+  return std::string(os_version_codename_str);
+}
+
+std::string SysInfo::GetAndroidBuildID() {
+  char os_build_id_str[PROP_VALUE_MAX];
+  __system_property_get("ro.build.id", os_build_id_str);
+  return std::string(os_build_id_str);
+}
+
+std::string SysInfo::GetDeviceName() {
+  char device_model_str[PROP_VALUE_MAX];
+  __system_property_get("ro.product.model", device_model_str);
+  return std::string(device_model_str);
+}
+
+void SysInfo::OperatingSystemVersionNumbers(int32* major_version,
+                                            int32* minor_version,
+                                            int32* bugfix_version) {
+  // Read the version number string out from the properties.
+  char os_version_str[PROP_VALUE_MAX];
+  __system_property_get("ro.build.version.release", os_version_str);
+
+  // Parse out the numbers.
+  int internal_major_version, internal_minor_version, internal_bugfix_version;

[jar (doing other things), 2012/08/15 23:35:17]

What is the advantage of having these temporaries?

Why did you define the private function to take int, rather than int32?  ... or
why did you use int32 for this function's arg, rather than int?

[gone, 2012/08/16 00:29:31]

They're defined as int32s for all of the other platforms, and I'm not sure if
sscanf will safely take int32s.  One option is to move the temporaries upwards
to the sscanf, I guess.

+  ParseOSVersionNumbers(os_version_str, &internal_major_version,
+      &internal_minor_version, &internal_bugfix_version);
+  *major_version = internal_major_version;
+  *minor_version = internal_minor_version;
+  *bugfix_version = internal_bugfix_version;
+}
+
 int SysInfo::DalvikHeapSizeMB() {
   static int heap_size = GetDalvikHeapSizeMB();
   return heap_size;
 }
 
 }  // namespace base