Use system properties for heap profiler in Android instead of environment variables.

third_party/tcmalloc/chromium/src/base/commandlineflags.h

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 36 matching lines @@
 // elsewhere.
 #ifndef BASE_COMMANDLINEFLAGS_H_
 #define BASE_COMMANDLINEFLAGS_H_
 
 #include <config.h>
 #include <string>
 #include <string.h>               // for memchr
 #include <stdlib.h>               // for getenv
 #include "base/basictypes.h"
 
+#if defined(__ANDROID__) || defined(ANDROID)
+#include <sys/system_properties.h>
+#endif
+
 #define DECLARE_VARIABLE(type, name)                                          \
   namespace FLAG__namespace_do_not_use_directly_use_DECLARE_##type##_instead {  \
   extern PERFTOOLS_DLL_DECL type FLAGS_##name;                                \
   }                                                                           \
   using FLAG__namespace_do_not_use_directly_use_DECLARE_##type##_instead::FLAGS_##name
 
 #define DEFINE_VARIABLE(type, name, value, meaning) \
   namespace FLAG__namespace_do_not_use_directly_use_DECLARE_##type##_instead {  \
   PERFTOOLS_DLL_DECL type FLAGS_##name(value);                                \
   char FLAGS_no##name;                                                        \
@@ skipping 38 matching lines @@
   using FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_##name
 #define DEFINE_string(name, value, meaning) \
   namespace FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead {  \
   std::string FLAGS_##name(value);                                                   \
   char FLAGS_no##name;                                                        \
   }                                                                           \
   using FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_##name
 
 // These macros (could be functions, but I don't want to bother with a .cc
 // file), make it easier to initialize flags from the environment.
+// They are functions in Android because __system_property_get() doesn't
+// return a string.
+
+#if defined(__ANDROID__) || defined(ANDROID)
+
+// Returns a pointer to a static variable.  The string pointed by the returned
+// pointer must not be modified.
+inline const char* const EnvToString(const char* envname, const char* dflt) {
+  static char system_property_value[PROP_VALUE_MAX];
+  if (__system_property_get(envname, system_property_value) > 0)
+    return system_property_value;
+  return dflt;
+}
+
+inline bool EnvToBool(const char* envname, bool dflt) {
+  const char kTrueValues[] = "tTyY1";

[willchan no longer on Chromium, 2013/05/03 14:12:20]

Perhaps you should make this static, because the compiler is going to have to
initialize this local array on every call otherwise.

+  char system_property_value[PROP_VALUE_MAX];
+  if (__system_property_get(envname, system_property_value) > 0)
+    return memchr(kTrueValues, system_property_value[0], sizeof(kTrueValues));
+  return dflt;
+}
+
+inline int EnvToInt(const char* envname, int dflt) {
+  char system_property_value[PROP_VALUE_MAX];
+  if (__system_property_get(envname, system_property_value) > 0)
+    return strtol(system_property_value, NULL, 10);
+  return dflt;
+}
+
+inline int64 EnvToInt64(const char* envname, int64 dflt) {
+  char system_property_value[PROP_VALUE_MAX];
+  if (__system_property_get(envname, system_property_value) > 0)
+    return strtoll(system_property_value, NULL, 10);
+  return dflt;
+}
+
+inline double EnvToDouble(const char* envname, double dflt) {
+  char system_property_value[PROP_VALUE_MAX];
+  if (__system_property_get(envname, system_property_value) > 0)
+    return strtod(system_property_value, NULL);
+  return dflt;
+}
+
+#else  // defined(__ANDROID__) || defined(ANDROID)
 
 #define EnvToString(envname, dflt)   \
   (!getenv(envname) ? (dflt) : getenv(envname))
 
 #define EnvToBool(envname, dflt)   \
   (!getenv(envname) ? (dflt) : memchr("tTyY1\0", getenv(envname)[0], 6) != NULL)
 
 #define EnvToInt(envname, dflt)  \
   (!getenv(envname) ? (dflt) : strtol(getenv(envname), NULL, 10))
 
 #define EnvToInt64(envname, dflt)  \
   (!getenv(envname) ? (dflt) : strtoll(getenv(envname), NULL, 10))
 
 #define EnvToDouble(envname, dflt)  \
   (!getenv(envname) ? (dflt) : strtod(getenv(envname), NULL))
 
+#endif  // defined(__ANDROID__) || defined(ANDROID)
+
 #endif  // BASE_COMMANDLINEFLAGS_H_