Remove FilePath usage from the CrashReporterClient interface on Windows.

chrome/install_static/install_util.cc

 // Copyright 2014 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 "chrome/install_static/install_util.h"
 
 #include <windows.h>
 #include <assert.h>
 #include <algorithm>
 #include <iostream>
@@ skipping 39 matching lines @@
 const wchar_t kUninstallArgumentsField[] = L"UninstallArguments";
 const wchar_t kMetricsReportingEnabled[] = L"MetricsReportingEnabled";
 
 const wchar_t kAppGuidCanary[] =
     L"{4ea16ac7-fd5a-47c3-875b-dbf4a2008c20}";
 const wchar_t kAppGuidGoogleChrome[] =
     L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
 const wchar_t kAppGuidGoogleBinaries[] =
     L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}";
 
+const wchar_t kHeadless[] = L"CHROME_HEADLESS";
+const wchar_t kShowRestart[] = L"CHROME_CRASHED";
+const wchar_t kRestartInfo[] = L"CHROME_RESTART";
+const wchar_t kRtlLocale[] = L"RIGHT_TO_LEFT";
+
+const char kGpuProcess[] = "gpu-process";
+const char kPpapiPluginProcess[] = "ppapi";
+const char kRendererProcess[] = "renderer";
+const char kUtilityProcess[] = "utility";
+
 namespace {
 
 // TODO(ananta)
 // http://crbug.com/604923
 // These constants are defined in the chrome/installer directory as well. We
 // need to unify them.
 #if defined(GOOGLE_CHROME_BUILD)
 const wchar_t kSxSSuffix[] = L" SxS";
 const wchar_t kGoogleChromeInstallSubDir1[] = L"Google";
 const wchar_t kGoogleChromeInstallSubDir2[] = L"Chrome";
@@ skipping 312 matching lines @@
   if (pattern[pattern_index] == L'*') {
     return MatchPatternImpl(source, pattern, source_index + 1,
                             pattern_index) ||
            MatchPatternImpl(source, pattern, source_index, pattern_index + 1);
   }
   return false;
 }
 
 // Defines the type of whitespace characters typically found in strings.
 constexpr char kWhiteSpaces[] = " \t\n\r\f\v";
+constexpr base::char16 kWhiteSpaces16[] = L" \t\n\r\f\v";
+
+// Define specializations for white spaces based on the type of the string.
+template<class StringType> StringType GetWhiteSpacesForType();
+template<>
+base::string16 GetWhiteSpacesForType() {
+  return kWhiteSpaces16;
+}
+template<>
+std::string GetWhiteSpacesForType() {
+  return kWhiteSpaces;
+}
 
 // Trim whitespaces from left & right
-void Trim(std::string* str) {
-  str->erase(str->find_last_not_of(kWhiteSpaces) + 1);
-  str->erase(0, str->find_first_not_of(kWhiteSpaces));
+template<class StringType>
+void TrimT(StringType* str) {
+  str->erase(str->find_last_not_of(GetWhiteSpacesForType<StringType>()) + 1);
+  str->erase(0, str->find_first_not_of(GetWhiteSpacesForType<StringType>()));
 }
 
 bool IsValidNumber(const std::string& str) {
   if (str.empty())
     return false;
   return std::all_of(str.begin(), str.end(), ::isdigit);
 }
 
+// Tokenizes a string based on a single character delimiter.
+template<class StringType, class DelimiterType>
+std::vector<StringType> TokenizeStringT(const StringType& str,
+                                        DelimiterType delimiter,

[grt (UTC plus 2), 2016/06/02 22:57:44]

Can you do away with this template arg and use typename StringType::value_type
here (value_type may be the wrong name, but I think basic_string has a typedef
for the char type)?

[ananta, 2016/06/02 23:10:30]

Done.

+                                        bool trim_spaces) {
+  std::vector<StringType> tokens;
+  std::basic_istringstream<DelimiterType> buffer(str);
+  for (StringType token; std::getline(buffer, token, delimiter);) {
+    if (trim_spaces)
+      TrimT<StringType>(&token);
+    tokens.push_back(token);
+  }
+  return tokens;
+}
+
 }  // namespace
 
 bool IsSxSChrome(const wchar_t* exe_path) {
   return wcsstr(exe_path, L"Chrome SxS\\Application") != nullptr;
 }
 
 bool IsSystemInstall(const wchar_t* exe_path) {
   wchar_t program_dir[MAX_PATH] = {};
   DWORD ret = ::GetEnvironmentVariable(L"PROGRAMFILES", program_dir,
                                        arraysize(program_dir));
@@ skipping 136 matching lines @@
   // We have to make sure the user data dir exists on first run. See
   // http://crbug.com/591504.
   if (!RecursiveDirectoryCreate(crash_dir->c_str()))
     return false;
   crash_dir->append(L"\\Crashpad");
   return true;
 }
 
 
 std::string GetEnvironmentString(const std::string& variable_name) {
+  return UTF16ToUTF8(GetEnvironmentString16(UTF8ToUTF16(variable_name)));
+}
+
+base::string16 GetEnvironmentString16(const base::string16& variable_name) {
   DWORD value_length =
-      ::GetEnvironmentVariable(UTF8ToUTF16(variable_name).c_str(), nullptr, 0);
+      ::GetEnvironmentVariable(variable_name.c_str(), nullptr, 0);
   if (value_length == 0)
-    return std::string();
+    return base::string16();
   std::unique_ptr<wchar_t[]> value(new wchar_t[value_length]);
-  ::GetEnvironmentVariable(UTF8ToUTF16(variable_name).c_str(), value.get(),
-                           value_length);
-  return UTF16ToUTF8(value.get());
+  ::GetEnvironmentVariable(variable_name.c_str(), value.get(), value_length);
+  return value.get();
 }
 
 bool SetEnvironmentString(const std::string& variable_name,
                           const std::string& new_value) {
-  return !!SetEnvironmentVariable(UTF8ToUTF16(variable_name).c_str(),
-                                  UTF8ToUTF16(new_value).c_str());
+  return SetEnvironmentString16(UTF8ToUTF16(variable_name),
+                                UTF8ToUTF16(new_value));
+}
+
+bool SetEnvironmentString16(const base::string16& variable_name,
+                            const base::string16& new_value) {
+  return !!SetEnvironmentVariable(variable_name.c_str(), new_value.c_str());
 }
 
 bool HasEnvironmentVariable(const std::string& variable_name) {
-  return !!::GetEnvironmentVariable(UTF8ToUTF16(variable_name).c_str(), nullptr,
-                                    0);
+  return HasEnvironmentVariable16(UTF8ToUTF16(variable_name));
+}
+
+bool HasEnvironmentVariable16(const base::string16& variable_name) {
+  return !!::GetEnvironmentVariable(variable_name.c_str(), nullptr, 0);
 }
 
 bool GetExecutableVersionDetails(const base::string16& exe_path,
                                  base::string16* product_name,
                                  base::string16* version,
                                  base::string16* special_build,
                                  base::string16* channel_name) {
   assert(product_name);
   assert(version);
   assert(special_build);
@@ skipping 167 matching lines @@
                             size) != size) {
     assert(false);
     return base::string16();
   }
   return result;
 }
 
 std::vector<std::string> TokenizeString(const std::string& str,
                                         char delimiter,
                                         bool trim_spaces) {
-  std::vector<std::string> tokens;
-  std::istringstream buffer(str);
-  for (std::string token; std::getline(buffer, token, delimiter);) {
-    if (trim_spaces)
-      Trim(&token);
-    tokens.push_back(token);
-  }
-  return tokens;
+  return TokenizeStringT<std::string, char>(str, delimiter, trim_spaces);
+}
+
+std::vector<base::string16> TokenizeString16(const base::string16& str,
+                                             base::char16 delimiter,
+                                             bool trim_spaces) {
+  return TokenizeStringT<base::string16, base::char16>(
+            str, delimiter, trim_spaces);
 }
 
 bool CompareVersionStrings(const std::string& version1,
                            const std::string& version2,
                            int* result) {
   if (version1.empty() || version2.empty())
     return false;
 
   // Tokenize both version strings with "." as the separator. If either of
   // the returned token lists are empty then bail.
@@ skipping 60 matching lines @@
         return true;
       }
     }
   }
   // Here it means that both versions are equal.
   *result = 0;
   return true;
 }
 
 }  // namespace install_static