Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(837)

Unified Diff: chrome/install_static/install_util.cc

Issue 1913943003: Remove dependencies on chrome\installer from the ChromeCrashReporterClient class on Windows. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Update comment Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: chrome/install_static/install_util.cc
diff --git a/chrome/install_static/install_util.cc b/chrome/install_static/install_util.cc
index 6fbef47569c23475978e43550443272fd66e21a5..f3f641c1568c294a5e972408060d77ef9bfe3fab 100644
--- a/chrome/install_static/install_util.cc
+++ b/chrome/install_static/install_util.cc
@@ -5,14 +5,28 @@
#include "chrome/install_static/install_util.h"
#include <assert.h>
+#include <memory>
#include <windows.h>
grt (UTC plus 2) 2016/04/29 20:50:56 https://google.github.io/styleguide/cppguide.html#
ananta 2016/04/29 22:49:24 Done.
-#include <stddef.h>
#include "base/macros.h"
grt (UTC plus 2) 2016/04/29 20:50:56 would a DEPS file in this directory help prevent a
ananta 2016/04/29 22:49:23 Thanks. Good point. Done
-#include "base/strings/string16.h"
+#include "build/build_config.h"
+
+namespace install_static {
ProcessType g_process_type = ProcessType::UNINITIALIZED;
+// Chrome channel display names.
+// TODO(ananta)
+// http://crbug.com/604923
+// These constants are defined in the chrome/installer directory as well. We
+// need to unify them.
+const wchar_t kChromeChannelUnknown[] = L"unknown";
+const wchar_t kChromeChannelCanary[] = L"canary";
+const wchar_t kChromeChannelDev[] = L"dev";
+const wchar_t kChromeChannelBeta[] = L"beta";
+const wchar_t kChromeChannelStable[] = L"";
+const wchar_t kChromeChannelStableExplicit[] = L"stable";
+
namespace {
const wchar_t kRegPathClientState[] = L"Software\\Google\\Update\\ClientState";
grt (UTC plus 2) 2016/04/29 20:50:56 this is only for GOOGLE_CHROME_BUILD. Chromium bui
ananta 2016/04/29 22:49:23 Done.
ananta 2016/04/29 22:49:24 Done.
@@ -28,6 +42,9 @@ const wchar_t kRegValueUsageStats[] = L"usagestats";
const wchar_t kUninstallArgumentsField[] = L"UninstallArguments";
const wchar_t kMetricsReportingEnabled[] = L"MetricsReportingEnabled";
+const wchar_t kRegPathGoogleUpdate[] = L"Software\\Google\\Update";
+const wchar_t kRegGoogleUpdateVersion[] = L"version";
+
const wchar_t kAppGuidCanary[] =
L"{4ea16ac7-fd5a-47c3-875b-dbf4a2008c20}";
const wchar_t kAppGuidGoogleChrome[] =
@@ -35,6 +52,33 @@ const wchar_t kAppGuidGoogleChrome[] =
const wchar_t kAppGuidGoogleBinaries[] =
L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}";
+// 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";
+const wchar_t kRegApField[] = L"ap";
+#else
+const wchar_t kChromiumInstallSubDir[] = L"Chromium";
+#endif
+const wchar_t kUserDataDirname[] = L"User Data";
+const wchar_t kBrowserCrashDumpMetricsSubKey[] = L"\\BrowserCrashDumpAttempts";
+
+void Trace(const wchar_t* format_string, ...) {
+ static const int kMaxLogBufferSize = 1024;
+ static wchar_t buffer[kMaxLogBufferSize] = {};
+
+ va_list args = {};
+
+ va_start(args, format_string);
+ vswprintf(buffer, arraysize(buffer), format_string, args);
+ OutputDebugString(buffer);
+ va_end(args);
+}
+
bool ReadKeyValueString(bool system_install, const wchar_t* key_path,
const wchar_t* guid, const wchar_t* value_to_read,
base::string16* value_out) {
@@ -42,8 +86,10 @@ bool ReadKeyValueString(bool system_install, const wchar_t* key_path,
value_out->clear();
base::string16 full_key_path(key_path);
- full_key_path.append(1, L'\\');
- full_key_path.append(guid);
+ if (wcslen(guid) > 0) {
grt (UTC plus 2) 2016/04/29 20:50:56 if (guid && *guid) {
ananta 2016/04/29 22:49:23 Done.
ananta 2016/04/29 22:49:24 Done.
+ 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,
@@ -107,6 +153,256 @@ bool ReadKeyValueDW(bool system_install, const wchar_t* key_path,
return result == ERROR_SUCCESS && size == sizeof(*value_out);
}
+struct LanguageAndCodePage {
grt (UTC plus 2) 2016/04/29 20:50:56 nit: move this into GetLanguageAndCodePageFromVers
ananta 2016/04/29 22:49:23 Done.
+ WORD language;
+ WORD code_page;
+};
+
+bool GetLanguageAndCodePageFromVersionResource(const char* version_resource,
+ WORD* language,
+ WORD* code_page) {
+ if (!version_resource)
+ return false;
+
+ LanguageAndCodePage* translation_info = nullptr;
grt (UTC plus 2) 2016/04/29 20:50:56 MSDN leads me to believe that this should be: DW
ananta 2016/04/29 22:49:23 This is based on https://msdn.microsoft.com/en-us/
grt (UTC plus 2) 2016/05/02 22:22:06 Okay, thanks for the pointer.
+ uint32_t page_count = 0;
grt (UTC plus 2) 2016/04/29 20:50:56 "count" is a bit of a misnomer since this is popul
ananta 2016/04/29 22:49:23 Renamed to data_size_in_bytes
+ BOOL query_result = VerQueryValue(version_resource,
+ L"\\VarFileInfo\\Translation",
+ reinterpret_cast<void**>(&translation_info),
+ &page_count);
+ if (!query_result)
+ return false;
+
+ *language = translation_info->language;
+ *code_page = translation_info->code_page;
+ return true;
+}
+
+bool GetValueFromVersionResource(const char* version_resource,
+ const base::string16& name,
+ base::string16* value_str) {
+ assert(value_str);
+ value_str->clear();
+
+ WORD language = 0;
+ WORD code_page = 0;
+ if (!GetLanguageAndCodePageFromVersionResource(version_resource,
+ &language,
+ &code_page)) {
+ return false;
grt (UTC plus 2) 2016/04/29 20:50:56 based on https://msdn.microsoft.com/en-us/library/
ananta 2016/04/29 22:49:24 We could possibly do that. The logic below is the
grt (UTC plus 2) 2016/05/02 22:22:06 Gotcha. Thinking about it more, why are we even do
ananta 2016/05/02 22:43:27 Added a TODO in the function. Will look into this
+ }
+
+ WORD lang_codepage[8] = {};
+ size_t i = 0;
+ // Use the language and codepage
+ lang_codepage[i++] = language;
+ lang_codepage[i++] = code_page;
+ // Use the default language and codepage from the resource.
+ lang_codepage[i++] = ::GetUserDefaultLangID();
+ lang_codepage[i++] = code_page;
+ // Use the language from the resource and Latin codepage (most common).
+ lang_codepage[i++] = language;
+ lang_codepage[i++] = 1252;
+ // Use the default language and Latin codepage (most common).
+ lang_codepage[i++] = ::GetUserDefaultLangID();
+ lang_codepage[i++] = 1252;
+
+ static_assert((arraysize(lang_codepage) % 2) == 0,
+ "Language code page size should be a multiple of 2");
+ assert(arraysize(lang_codepage) == i);
+
+ i = 0;
grt (UTC plus 2) 2016/04/29 20:50:56 call me crazy, but: for (i = 0; i < arraysize(la
ananta 2016/04/29 22:49:24 Done.
+ while (i < arraysize(lang_codepage)) {
+ wchar_t sub_block[MAX_PATH] = {};
grt (UTC plus 2) 2016/04/29 20:50:56 we don't really need to zero this out since it get
ananta 2016/04/29 22:49:23 Done.
+ WORD language = lang_codepage[i++];
+ WORD code_page = lang_codepage[i++];
+ _snwprintf_s(sub_block, MAX_PATH, MAX_PATH,
+ L"\\StringFileInfo\\%04x%04x\\%ls", language, code_page, name.c_str());
grt (UTC plus 2) 2016/04/29 20:50:55 WORD is an unsigned short, so %04hx
ananta 2016/04/29 22:49:23 Done. https://msdn.microsoft.com/en-us/library/win
+ void* value = nullptr;
+ uint32_t size = 0;
+ BOOL r = ::VerQueryValue(version_resource, sub_block, &value, &size);
+ if (r && value) {
+ value_str->assign(static_cast<wchar_t*>(value));
+ return true;
+ }
+ }
+ return false;
+}
+
+// Returns the executable path for the current process.
+base::string16 GetCurrentProcessExePath() {
+ wchar_t exe_path[MAX_PATH] = {};
grt (UTC plus 2) 2016/04/29 20:50:55 is zeroing needed?
ananta 2016/04/29 22:49:23 I tend to always do it. Removed.
+ if (GetModuleFileName(NULL, exe_path, arraysize(exe_path)) == 0)
grt (UTC plus 2) 2016/04/29 20:50:56 nullptr
ananta 2016/04/29 22:49:24 Done.
+ 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, 0);
grt (UTC plus 2) 2016/04/29 20:50:56 uber-nit: 0 -> L'\0' to make it super clear that t
ananta 2016/04/29 22:49:24 Done.
grt (UTC plus 2) 2016/05/02 22:22:06 Hah, you did it on the line above that I missed, b
ananta 2016/05/02 22:43:27 Sorry, fixed.
+ 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)) {
+ 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;
+ } else {
+ Trace(L"Failed to create directory %ls, last error is %d\n",
+ full_path_str, error_code);
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+bool GetCollectStatsConsentImpl(const base::string16& exe_path) {
+ bool enabled = true;
+ bool controlled_by_policy = ReportingIsEnforcedByPolicy(&enabled);
+
+ if (controlled_by_policy && !enabled)
grt (UTC plus 2) 2016/04/29 20:50:56 i think the right thing here is really: if (Repo
ananta 2016/04/29 22:49:24 Done.
+ return false;
+
+ bool system_install = IsSystemInstall(exe_path.c_str());
+ base::string16 app_guid;
+
+ if (IsCanary(exe_path.c_str())) {
+ app_guid = kAppGuidCanary;
+ } else {
+ app_guid = IsMultiInstall(system_install) ? kAppGuidGoogleBinaries :
+ kAppGuidGoogleChrome;
+ }
+
+ DWORD out_value = 0;
+ if (system_install &&
+ ReadKeyValueDW(system_install, kRegPathClientStateMedium, app_guid,
grt (UTC plus 2) 2016/04/29 20:50:55 nit: indentation. please use "git cl format".
ananta 2016/04/29 22:49:24 Done.
+ kRegValueUsageStats, &out_value)) {
+ return out_value == 1;
+ }
+
+ return ReadKeyValueDW(system_install, kRegPathClientState, app_guid,
+ kRegValueUsageStats, &out_value) && out_value == 1;
+}
+
+// Returns true if the |source| string matches the |pattern|. The pattern
+// may contain wildcards like '?' which matches one character or a '*'
+// which matches 0 or more characters.
+// Please note that pattern matches the whole string. If you want to find
+// something in the middle of the string then you need to specify the pattern
+// as '*xyz*'.
+// |source_index| is the index of the current character being matched in
+// |source|.
+// |pattern_index| is the index of the current pattern character in |pattern|
+// which is matched with source.
+bool MatchPatternImpl(const base::string16& source,
+ const base::string16& pattern,
+ size_t source_index,
+ size_t pattern_index) {
+ if (source.empty() && pattern.empty())
+ return true;
+
+ if (source_index > source.length() || pattern_index > pattern.length())
+ return false;
+
+ // If we reached the end of both strings, then we are done.
+ if ((source_index == source.length()) &&
+ (pattern_index == pattern.length())) {
+ return true;
+ }
+
+ // If the current character in the pattern is a '*' then make sure that
+ // characters after the pattern are present in the source string. This
+ // assumes that you won't have two consecutive '*' characters in the pattern.
+ if ((pattern[pattern_index] == L'*') &&
+ (pattern_index + 1 < pattern.length()) &&
+ (source_index >= source.length())) {
+ return false;
+ }
+
+ // If the pattern contains wildcard characters '?' or '.' or there is a match
+ // then move ahead in both strings.
+ if ((pattern[pattern_index] == L'?') ||
+ (pattern[pattern_index] == source[source_index])) {
+ return MatchPatternImpl(source, pattern, source_index + 1,
+ pattern_index + 1);
+ }
+
+ // If we have a '*' then there are two possibilities
+ // 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;
+}
+
} // namespace
bool IsCanary(const wchar_t* exe_path) {
grt (UTC plus 2) 2016/04/29 20:50:56 is it possible/does it make sense to use base::Str
ananta 2016/04/29 22:49:24 Sadly no. StringPiece16 comes with logging.h, whic
grt (UTC plus 2) 2016/05/02 22:22:06 Acknowledged.
@@ -138,32 +434,12 @@ bool IsMultiInstall(bool is_system_install) {
return args.find(L"--multi-install") != base::string16::npos;
}
-bool AreUsageStatsEnabled(const wchar_t* exe_path) {
- bool enabled = true;
- bool controlled_by_policy = ReportingIsEnforcedByPolicy(&enabled);
-
- if (controlled_by_policy && !enabled)
- return false;
-
- bool system_install = IsSystemInstall(exe_path);
- base::string16 app_guid;
-
- if (IsCanary(exe_path)) {
- app_guid = kAppGuidCanary;
- } else {
- app_guid = IsMultiInstall(system_install) ? kAppGuidGoogleBinaries :
- kAppGuidGoogleChrome;
- }
-
- DWORD out_value = 0;
- if (system_install &&
- ReadKeyValueDW(system_install, kRegPathClientStateMedium, app_guid,
- kRegValueUsageStats, &out_value)) {
- return out_value == 1;
- }
+bool GetCollectStatsConsent() {
+ return GetCollectStatsConsentImpl(GetCurrentProcessExePath());
+}
- return ReadKeyValueDW(system_install, kRegPathClientState, app_guid,
- kRegValueUsageStats, &out_value) && out_value == 1;
+bool GetCollectStatsConsentForTesting(const base::string16& exe_path) {
+ return GetCollectStatsConsentImpl(exe_path);
}
bool ReportingIsEnforcedByPolicy(bool* breakpad_enabled) {
grt (UTC plus 2) 2016/04/29 20:50:55 breakpad_enabled -> metrics_reporting_enabled
ananta 2016/04/29 22:49:24 Done.
@@ -222,3 +498,221 @@ bool IsNonBrowserProcess() {
assert(g_process_type != ProcessType::UNINITIALIZED);
return g_process_type == ProcessType::NON_BROWSER_PROCESS;
}
+
+bool GetDefaultUserDataDirectory(base::string16* result) {
+ static const wchar_t kLocalAppData[] = L"%LOCALAPPDATA%";
+
+ std::unique_ptr<wchar_t> user_data_dir_path;
+
+ // This environment variable should be set on Windows 7 and up.
+ // If we fail to find this variable then we default to the temporary files
+ // path.
+ DWORD size = ::ExpandEnvironmentStrings(kLocalAppData, nullptr, 0);
+ if (size) {
+ user_data_dir_path.reset(new wchar_t[size]);
+ if (::ExpandEnvironmentStrings(kLocalAppData,
+ user_data_dir_path.get(),
+ size) != size) {
+ user_data_dir_path.reset(nullptr);
grt (UTC plus 2) 2016/04/29 20:50:56 nit: omit "nullptr"
ananta 2016/04/29 22:49:24 Done.
+ }
+ }
+ // We failed to find the %LOCALAPPDATA% folder. Fallback to the temporary
+ // files path. If we fail to find this we bail.
+ if (!user_data_dir_path.get()) {
+ size = ::GetTempPath(0, nullptr);
+ if (!size)
+ return false;
+ user_data_dir_path.reset(new wchar_t[size + 1]);
+ if (::GetTempPath(size + 1, user_data_dir_path.get()) != size)
+ return false;
+ }
+
+ base::string16 install_sub_directory = GetChromeInstallSubDirectory();
+
+ *result = user_data_dir_path.get();
+ if ((*result)[result->length() - 1] != L'\\')
+ result->append(L"\\");
+ result->append(install_sub_directory);
+ result->append(L"\\");
+ result->append(kUserDataDirname);
+ return true;
+}
+
+bool GetDefaultCrashDumpLocation(base::string16* crash_dir) {
+ // In order to be able to start crash handling very early, we do not rely on
+ // chrome's PathService entries (for DIR_CRASH_DUMPS) being available on
+ // Windows. See https://crbug.com/564398.
+ if (!GetDefaultUserDataDirectory(crash_dir))
+ return false;
+
+ // 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);
+ 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());
+}
+
+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());
+}
+
+bool HasEnvironmentVariable(const std::string& variable_name) {
+ return !!::GetEnvironmentVariable(utf8_to_string16(variable_name).c_str(),
+ NULL, 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);
+ assert(channel_name);
+
+ // Default values in case we don't find a version resource.
+ *product_name = L"Chrome";
+ *version = L"0.0.0.0-devel";
+ *channel_name = kChromeChannelUnknown;
+ special_build->clear();
+
+ DWORD dummy = 0;
+ DWORD length = ::GetFileVersionInfoSize(exe_path.c_str(), &dummy);
+ if (length) {
+ std::unique_ptr<char> data(new char[length]);
+ if (::GetFileVersionInfo(exe_path.c_str(), dummy, length,
+ data.get())) {
+ GetValueFromVersionResource(data.get(), L"ProductVersion", version);
+
+ base::string16 official_build;
+ GetValueFromVersionResource(data.get(), L"Official Build",
+ &official_build);
+ if (official_build != L"1")
+ version->append(L"-devel");
+ GetValueFromVersionResource(data.get(), L"ProductShortName",
+ product_name);
+ GetValueFromVersionResource(data.get(), L"SpecialBuild", special_build);
+ }
+ }
+ GetChromeChannelName(!IsSystemInstall(exe_path.c_str()), channel_name);
+ return true;
+}
+
+void GetChromeChannelName(bool is_per_user_install,
+ base::string16* channel_name) {
+#if !defined(GOOGLE_CHROME_BUILD)
+ *channel_name = kChromeChannelUnknown;
+ return;
+#else
+ channel_name->clear();
+ // TODO(ananta)
+ // http://crbug.com/604923
+ // Unify this with the chrome/installer/util/channel_info.h/.cc.
+ if (IsCanary(GetCurrentProcessExePath().c_str())) {
+ *channel_name = L"canary";
+ } else {
+ base::string16 value;
+ if (ReadKeyValueString(!is_per_user_install,
+ kRegPathClientState,
+ kAppGuidGoogleChrome,
+ kRegApField,
+ &value)) {
+ static const wchar_t kChromeChannelBetaPattern[] = L"1?1-";
+ static const wchar_t kChromeChannelBetaX64Pattern[] = L"*x64-beta*";
+ static const wchar_t kChromeChannelDevPattern[] = L"2?0-d";
+ static const wchar_t kChromeChannelDevX64Pattern[] = L"x64-dev";
+ static const wchar_t kChromeStableMultiInstallPattern[] = L"*multi*";
+
+ std::transform(value.begin(), value.end(), value.begin(), ::tolower);
+
+ // Channel names containing stable should be reported as an empty string.
+ if (value.find(kChromeChannelStableExplicit) !=
+ base::string16::npos) {
+ return;
+ }
+
+ if (MatchPattern(value, kChromeChannelDevPattern) ||
+ MatchPattern(value, kChromeChannelDevX64Pattern)) {
+ channel_name->assign(kChromeChannelDev);
+ }
+
+ if (MatchPattern(value, kChromeChannelBetaPattern) ||
+ MatchPattern(value, kChromeChannelBetaPattern)) {
+ channel_name->assign(kChromeChannelBeta);
+ }
+
+ if (value.find(kChromeStableMultiInstallPattern) !=
+ base::string16::npos) {
+ *channel_name = L"-m";
+ }
+
+ // If we fail to find any matching pattern in the channel name then we
+ // default to empty which means stable. Not sure if this is ok.
+ // TODO(ananta)
+ // http://crbug.com/604923
+ // Check if this is ok.
+ } else {
+ *channel_name = kChromeChannelUnknown;
+ }
+ }
+#endif // GOOGLE_CHROME_BUILD
+}
+
+std::string GetGoogleUpdateVersion() {
+ base::string16 update_version;
+ if (ReadKeyValueString(IsSystemInstall(GetCurrentProcessExePath().c_str()),
+ kRegPathGoogleUpdate,
+ L"",
+ kRegGoogleUpdateVersion,
+ &update_version)) {
+ return utf16_to_utf8(update_version);
+ }
+ return std::string();
+}
+
+base::string16 GetChromeInstallSubDirectory() {
+ base::string16 result;
+#if defined(GOOGLE_CHROME_BUILD)
+ base::string16 sub_directory = kGoogleChromeInstallSubDir1;
+ sub_directory += L"\\";
+ sub_directory += kGoogleChromeInstallSubDir2;
+ if (IsCanary(GetCurrentProcessExePath().c_str()))
+ sub_directory += kSxSSuffix;
+ result.append(sub_directory);
grt (UTC plus 2) 2016/04/29 20:50:56 nit: return result.append(sub_directory); #else
ananta 2016/04/29 22:49:24 Done.
+#else
+ result = result.append(kChromiumInstallSubDir);
+#endif
+ return result;
+}
+
+base::string16 GetBrowserCrashDumpAttemptsRegistryPath() {
+ base::string16 registry_path = L"Software";
grt (UTC plus 2) 2016/04/29 20:50:56 ? "Software\\" ?
ananta 2016/04/29 22:49:23 Thanks. Done.
+ base::string16 install_sub_directory = GetChromeInstallSubDirectory();
grt (UTC plus 2) 2016/04/29 20:50:56 nit: remove this variable and inline the call to G
ananta 2016/04/29 22:49:23 Done.
+ registry_path += install_sub_directory;
+ 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);
+}
+
+} // namespace install_static

Powered by Google App Engine
This is Rietveld 408576698