Add functionality to the install_static library to tokenize strings and compare versions.

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>
+#include <iterator>
 #include <memory>
+#include <sstream>
 
 #include "base/macros.h"
 #include "build/build_config.h"
 
 namespace install_static {
 
 ProcessType g_process_type = ProcessType::UNINITIALIZED;
 
 // TODO(ananta)
 // http://crbug.com/604923
@@ skipping 65 matching lines @@
   va_end(args);
 }
 
 // Reads a string value identified by |value_to_read| from the registry path
 // under |key_path|. We look in HKLM or HKCU depending on whether the
 // |system_install| parameter is true.
 // Please note that this function only looks in the 32bit view of the registry.
 bool ReadKeyValueString(bool system_install, const wchar_t* key_path,
                         const wchar_t* guid, const wchar_t* value_to_read,
                         base::string16* value_out) {
-  HKEY key = NULL;
+  HKEY key = nullptr;
   value_out->clear();
 
   base::string16 full_key_path(key_path);
   if (guid && *guid) {
     full_key_path.append(1, L'\\');
     full_key_path.append(guid);
   }
 
   if (::RegOpenKeyEx(system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
                      full_key_path.c_str(), 0,
@@ skipping 30 matching lines @@
   return result == ERROR_SUCCESS;
 }
 
 // Reads a DWORD value identified by |value_to_read| from the registry path
 // under |key_path|. We look in HKLM or HKCU depending on whether the
 // |system_install| parameter is true.
 // Please note that this function only looks in the 32bit view of the registry.
 bool ReadKeyValueDW(bool system_install, const wchar_t* key_path,
                     base::string16 guid, const wchar_t* value_to_read,
                     DWORD* value_out) {
-  HKEY key = NULL;
+  HKEY key = nullptr;
   *value_out = 0;
 
   base::string16 full_key_path(key_path);
   full_key_path.append(1, L'\\');
   full_key_path.append(guid);
 
   if (::RegOpenKeyEx(system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
                      full_key_path.c_str(), 0,
                      KEY_QUERY_VALUE | KEY_WOW64_32KEY, &key) !=
                      ERROR_SUCCESS) {
@@ skipping 90 matching lines @@
 }
 
 // Returns the executable path for the current process.
 base::string16 GetCurrentProcessExePath() {
   wchar_t exe_path[MAX_PATH];
   if (GetModuleFileName(nullptr, exe_path, arraysize(exe_path)) == 0)
     return base::string16();
   return exe_path;
 }
 
-// UTF8 to UTF16 and vice versa conversion helpers. We cannot use the base
-// string conversion utilities here as they bring about a dependency on
-// user32.dll which is not allowed in this file.
-
-// Convert a UTF16 string to an UTF8 string.
-std::string utf16_to_utf8(const base::string16 &source) {
-  if (source.empty())
-    return std::string();
-  int size = ::WideCharToMultiByte(CP_UTF8, 0, &source[0],
-      static_cast<int>(source.size()), nullptr, 0, nullptr, nullptr);
-  std::string result(size, '\0');
-  if (::WideCharToMultiByte(CP_UTF8, 0, &source[0],
-          static_cast<int>(source.size()), &result[0], size, nullptr,
-          nullptr) != size) {
-    assert(false);
-    return std::string();
-  }
-  return result;
-}
-
-// Convert a UTF8 string to a UTF16 string.
-base::string16 utf8_to_string16(const std::string &source) {
-  if (source.empty())
-    return base::string16();
-  int size = ::MultiByteToWideChar(CP_UTF8, 0, &source[0],
-      static_cast<int>(source.size()), nullptr, 0);
-  base::string16 result(size, L'\0');
-  if (::MultiByteToWideChar(CP_UTF8, 0, &source[0],
-          static_cast<int>(source.size()), &result[0], size) != size) {
-    assert(false);
-    return base::string16();
-  }
-  return result;
-}
-
 bool RecursiveDirectoryCreate(const base::string16& full_path) {
   // If the path exists, we've succeeded if it's a directory, failed otherwise.
   const wchar_t* full_path_str = full_path.c_str();
   DWORD file_attributes = ::GetFileAttributes(full_path_str);
   if (file_attributes != INVALID_FILE_ATTRIBUTES) {
     if ((file_attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
       Trace(L"%hs( %ls directory exists )\n", __FUNCTION__, full_path_str);
       return true;
     }
     Trace(L"%hs( %ls directory conflicts with an existing file. )\n",
           __FUNCTION__, full_path_str);
     return false;
   }
 
   // Invariant:  Path does not exist as file or directory.
 
   // Attempt to create the parent recursively.  This will immediately return
   // true if it already exists, otherwise will create all required parent
   // directories starting with the highest-level missing parent.
   base::string16 parent_path;
   std::size_t pos = full_path.find_last_of(L"/\\");
   if (pos != base::string16::npos) {
     parent_path = full_path.substr(0, pos);
     if (!RecursiveDirectoryCreate(parent_path)) {
       Trace(L"Failed to create one of the parent directories");
       return false;
     }
   }
-  if (!::CreateDirectory(full_path_str, NULL)) {
+  if (!::CreateDirectory(full_path_str, nullptr)) {
     DWORD error_code = ::GetLastError();
     if (error_code == ERROR_ALREADY_EXISTS) {
       DWORD file_attributes = ::GetFileAttributes(full_path_str);
       if ((file_attributes != INVALID_FILE_ATTRIBUTES) &&
           ((file_attributes & FILE_ATTRIBUTE_DIRECTORY) != 0)) {
         // This error code ERROR_ALREADY_EXISTS doesn't indicate whether we
         // were racing with someone creating the same directory, or a file
         // with the same path.  If the directory exists, we lost the
         // race to create the same directory.
         return true;
@@ skipping 80 matching lines @@
   // 1. We consider current character of source.
   // 2. We ignore current character of source.
   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";
+
+// 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));
+}
+
+bool IsValidNumber(const std::string& str) {
+  if (str.empty())
+    return false;
+  return std::all_of(str.begin(), str.end(), ::isdigit);
+}
+
 }  // namespace
 
 bool IsSxSChrome(const wchar_t* exe_path) {
-  return wcsstr(exe_path, L"Chrome SxS\\Application") != NULL;
+  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));
   if (ret && ret < arraysize(program_dir) &&
       !wcsnicmp(exe_path, program_dir, ret)) {
     return true;
   }
@@ skipping 20 matching lines @@
 
 bool GetCollectStatsConsent() {
   return GetCollectStatsConsentImpl(GetCurrentProcessExePath());
 }
 
 bool GetCollectStatsConsentForTesting(const base::string16& exe_path) {
   return GetCollectStatsConsentImpl(exe_path);
 }
 
 bool ReportingIsEnforcedByPolicy(bool* metrics_is_enforced_by_policy) {
-  HKEY key = NULL;
+  HKEY key = nullptr;
   DWORD value = 0;
   BYTE* value_bytes = reinterpret_cast<BYTE*>(&value);
   DWORD size = sizeof(value);
   DWORD type = REG_DWORD;
 
   if (::RegOpenKeyEx(HKEY_LOCAL_MACHINE, kRegPathChromePolicy, 0,
                      KEY_QUERY_VALUE, &key) == ERROR_SUCCESS) {
     if (::RegQueryValueEx(key, kMetricsReportingEnabled, 0, &type,
                           value_bytes, &size) == ERROR_SUCCESS) {
       *metrics_is_enforced_by_policy = value != 0;
@@ skipping 13 matching lines @@
   }
 
   return false;
 }
 
 void InitializeProcessType() {
   assert(g_process_type == ProcessType::UNINITIALIZED);
   typedef bool (*IsSandboxedProcessFunc)();
   IsSandboxedProcessFunc is_sandboxed_process_func =
       reinterpret_cast<IsSandboxedProcessFunc>(
-          GetProcAddress(GetModuleHandle(NULL), "IsSandboxedProcess"));
+          GetProcAddress(GetModuleHandle(nullptr), "IsSandboxedProcess"));
   if (is_sandboxed_process_func && is_sandboxed_process_func()) {
     g_process_type = ProcessType::NON_BROWSER_PROCESS;
     return;
   }
 
   // TODO(robertshield): Drop the command line check when we drop support for
   // enabling chrome_elf in unsandboxed processes.
   const wchar_t* command_line = GetCommandLine();
   if (command_line && wcsstr(command_line, L"--type")) {
     g_process_type = ProcessType::NON_BROWSER_PROCESS;
@@ skipping 57 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) {
-  DWORD value_length = ::GetEnvironmentVariable(
-      utf8_to_string16(variable_name).c_str(), NULL, 0);
+  DWORD value_length =
+      ::GetEnvironmentVariable(UTF8ToUTF16(variable_name).c_str(), nullptr, 0);
   if (value_length == 0)
     return std::string();
   std::unique_ptr<wchar_t[]> value(new wchar_t[value_length]);
-  ::GetEnvironmentVariable(utf8_to_string16(variable_name).c_str(),
-      value.get(), value_length);
-  return utf16_to_utf8(value.get());
+  ::GetEnvironmentVariable(UTF8ToUTF16(variable_name).c_str(), value.get(),
+                           value_length);
+  return UTF16ToUTF8(value.get());
 }
 
 bool SetEnvironmentString(const std::string& variable_name,
                           const std::string& new_value) {
-  return !!SetEnvironmentVariable(utf8_to_string16(variable_name).c_str(),
-      utf8_to_string16(new_value).c_str());
+  return !!SetEnvironmentVariable(UTF8ToUTF16(variable_name).c_str(),
+                                  UTF8ToUTF16(new_value).c_str());
 }
 
 bool HasEnvironmentVariable(const std::string& variable_name) {
-  return !!::GetEnvironmentVariable(utf8_to_string16(variable_name).c_str(),
-      NULL, 0);
+  return !!::GetEnvironmentVariable(UTF8ToUTF16(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 98 matching lines @@
 std::string GetGoogleUpdateVersion() {
   // TODO(ananta)
   // Consider whether Chromium should connect to Google update to manage
   // updates. Should this be returning an empty string for Chromium builds?.
   base::string16 update_version;
   if (ReadKeyValueString(IsSystemInstall(GetCurrentProcessExePath().c_str()),
                          kRegPathGoogleUpdate,
                          nullptr,
                          kRegGoogleUpdateVersion,
                          &update_version)) {
-    return utf16_to_utf8(update_version);
+    return UTF16ToUTF8(update_version);
   }
   return std::string();
 }
 
 base::string16 GetChromeInstallSubDirectory() {
 #if defined(GOOGLE_CHROME_BUILD)
   base::string16 result = kGoogleChromeInstallSubDir1;
   result += L"\\";
   result += kGoogleChromeInstallSubDir2;
   if (IsSxSChrome(GetCurrentProcessExePath().c_str()))
@@ skipping 10 matching lines @@
   registry_path += kBrowserCrashDumpMetricsSubKey;
   return registry_path;
 }
 
 bool MatchPattern(const base::string16& source,
                   const base::string16& pattern) {
   assert(pattern.find(L"**") == base::string16::npos);
   return MatchPatternImpl(source, pattern, 0, 0);
 }
 
+std::string UTF16ToUTF8(const base::string16& source) {
+  if (source.empty() ||
+      static_cast<int>(source.size()) > std::numeric_limits<int>::max()) {
+    return std::string();
+  }
+  int size = ::WideCharToMultiByte(CP_UTF8, 0, &source[0],
+                                   static_cast<int>(source.size()), nullptr, 0,
+                                   nullptr, nullptr);
+  std::string result(size, '\0');
+  if (::WideCharToMultiByte(CP_UTF8, 0, &source[0],
+                            static_cast<int>(source.size()), &result[0], size,
+                            nullptr, nullptr) != size) {
+    assert(false);
+    return std::string();
+  }
+  return result;
+}
+
+base::string16 UTF8ToUTF16(const std::string& source) {
+  if (source.empty() ||
+      static_cast<int>(source.size()) > std::numeric_limits<int>::max()) {
+    return base::string16();
+  }
+  int size = ::MultiByteToWideChar(CP_UTF8, 0, &source[0],
+                                   static_cast<int>(source.size()), nullptr, 0);
+  base::string16 result(size, L'\0');
+  if (::MultiByteToWideChar(CP_UTF8, 0, &source[0],
+                            static_cast<int>(source.size()), &result[0],
+                            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;
+}
+
+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.
+  std::vector<std::string> version1_components =
+      TokenizeString(version1, '.', false);
+  if (version1_components.empty())
+    return false;
+
+  std::vector<std::string> version2_components =
+      TokenizeString(version2, '.', false);
+  if (version2_components.empty())
+    return false;
+
+  // You may have less tokens in either string. Use the minimum of the number
+  // of tokens as the initial count.
+  const size_t count =
+      std::min(version1_components.size(), version2_components.size());
+  for (size_t i = 0; i < count; ++i) {
+    // If either of the version components don't contain valid numeric digits
+    // bail.
+    if (!IsValidNumber(version1_components[i]) ||
+        !IsValidNumber(version2_components[i])) {
+      return false;
+    }
+
+    int version1_component = std::stoi(version1_components[i]);
+    int version2_component = std::stoi(version2_components[i]);
+
+    if (version1_component > version2_component) {
+      *result = 1;
+      return true;
+    }
+
+    if (version1_component < version2_component) {
+      *result = -1;
+      return true;
+    }
+  }
+
+  // Handle remaining tokens. Here if we have non zero tokens remaining in the
+  // version 1 list then it means that the version1 string is larger. If the
+  // version 1 token list has tokens left, then if either of these tokens is
+  // greater than 0 then it means that the version1 string is smaller than the
+  // version2 string.
+  if (version1_components.size() > version2_components.size()) {
+    for (size_t i = count; i < version1_components.size(); ++i) {
+      // If the version components don't contain valid numeric digits bail.
+      if (!IsValidNumber(version1_components[i]))
+        return false;
+
+      if (std::stoi(version1_components[i]) > 0) {
+        *result = 1;
+        return true;
+      }
+    }
+  } else if (version1_components.size() < version2_components.size()) {
+    for (size_t i = count; i < version2_components.size(); ++i) {
+      // If the version components don't contain valid numeric digits bail.
+      if (!IsValidNumber(version2_components[i]))
+        return false;
+
+      if (std::stoi(version2_components[i]) > 0) {
+        *result = -1;
+        return true;
+      }
+    }
+  }
+  // Here it means that both versions are equal.
+  *result = 0;
+  return true;
+}
+
 }  // namespace install_static