Relaunch Chrome in metro-mode with the help of a helper process.

base/string_number_conversions.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/string_number_conversions.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <wctype.h>
@@ skipping 328 matching lines @@
     : public BaseIteratorRangeToNumberTraits<StringPiece16::const_iterator,
                                              VALUE,
                                              BASE> {};
 
 template <typename VALUE>
 bool String16ToIntImpl(const StringPiece16& input, VALUE* output) {
   return IteratorRangeToNumber<StringPiece16ToNumberTraits<VALUE, 10> >::Invoke(
       input.begin(), input.end(), output);
 }
 
+// A class template for mapping the size of a pointer to its corresponding
+// fundamental integer type.
+template<int PointerSize>
+class PointerSizeToIntT {
+};
+
+// A partial specialization of PointerSizeToIntT for 32-bit pointers.
+template<>
+class PointerSizeToIntT<sizeof(uint32)> {
+ public:
+  typedef uint32 IntType;
+};
+
+// A partial specialization of PointerSizeToIntT for 64-bit pointers.
+template<>
+class PointerSizeToIntT<sizeof(uint64)> {
+ public:
+  typedef uint64 IntType;
+};
+
+// A collection of helper functions for round-tripping pointer values.
+class PointerHelper {
+ public:
+  // The appropriate fundamental integer type for a pointer.
+  typedef PointerSizeToIntT<sizeof(void*)>::IntType IntType;
+
+  static std::string ToString(void* value) {
+    return IntToStringT<std::string, IntType, IntType, false>::
+        IntToString(reinterpret_cast<IntType>(value));
+  }
+
+  static string16 ToString16(void* value) {
+    return IntToStringT<string16, IntType, IntType, false>::
+        IntToString(reinterpret_cast<IntType>(value));
+  }
+
+  static bool ToPointer(const base::StringPiece& input, void** output) {
+    return StringToIntImpl(input, reinterpret_cast<IntType*>(output));
+  }
+
+  static bool ToPointer16(const base::StringPiece16& input, void** output) {
+    return String16ToIntImpl(input, reinterpret_cast<IntType*>(output));
+  }
+};
+
 }  // namespace
 
 std::string IntToString(int value) {
   return IntToStringT<std::string, int, unsigned int, true>::
       IntToString(value);
 }
 
 string16 IntToString16(int value) {
   return IntToStringT<string16, int, unsigned int, true>::
       IntToString(value);
@@ skipping 21 matching lines @@
 std::string Uint64ToString(uint64 value) {
   return IntToStringT<std::string, uint64, uint64, false>::
       IntToString(value);
 }
 
 string16 Uint64ToString16(uint64 value) {
   return IntToStringT<string16, uint64, uint64, false>::
       IntToString(value);
 }
 
+std::string PointerToString(void* value) {
+  return PointerHelper::ToString(value);
+}
+
+string16 PointerToString16(void* value) {
+  return PointerHelper::ToString16(value);
+}
+
 std::string DoubleToString(double value) {
   // According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
   char buffer[32];
   dmg_fp::g_fmt(buffer, value);
   return std::string(buffer);
 }
 
 bool StringToInt(const StringPiece& input, int* output) {
   return StringToIntImpl(input, output);
 }
@@ skipping 19 matching lines @@
 }
 
 bool StringToUint64(const StringPiece& input, uint64* output) {
   return StringToIntImpl(input, output);
 }
 
 bool StringToUint64(const StringPiece16& input, uint64* output) {
   return String16ToIntImpl(input, output);
 }
 
+bool StringToPointer(const StringPiece& input, void** output) {
+  return PointerHelper::ToPointer(input, output);
+}
+
+bool StringToPointer(const StringPiece16& input, void** output) {
+  return PointerHelper::ToPointer16(input, output);
+}
+
 bool StringToSizeT(const StringPiece& input, size_t* output) {
   return StringToIntImpl(input, output);
 }
 
 bool StringToSizeT(const StringPiece16& input, size_t* output) {
   return String16ToIntImpl(input, output);
 }
 
 bool StringToDouble(const std::string& input, double* output) {
   errno = 0;  // Thread-safe?  It is on at least Mac, Linux, and Windows.
@@ skipping 40 matching lines @@
 bool HexStringToInt(const StringPiece& input, int* output) {
   return IteratorRangeToNumber<HexIteratorRangeToIntTraits>::Invoke(
     input.begin(), input.end(), output);
 }
 
 bool HexStringToBytes(const std::string& input, std::vector<uint8>* output) {
   return HexStringToBytesT(input, output);
 }
 
 }  // namespace base