chrome/installer/util/google_update_settings.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/installer/util/google_update_settings.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/command_line.h"
  10 #include "base/path_service.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/threading/thread_restrictions.h"
  15 #include "base/time/time.h"
  16 #include "base/win/registry.h"
  17 #include "chrome/common/chrome_switches.h"
  18 #include "chrome/installer/util/browser_distribution.h"
  19 #include "chrome/installer/util/channel_info.h"
  20 #include "chrome/installer/util/google_update_constants.h"
  21 #include "chrome/installer/util/install_util.h"
  22 #include "chrome/installer/util/installation_state.h"
  23 #include "chrome/installer/util/product.h"
  24
  25 using base::win::RegKey;
  26 using installer::InstallationState;
  27
  28 namespace {
  29
  30 const wchar_t kGoogleUpdatePoliciesKey[] =
  31     L"SOFTWARE\\Policies\\Google\\Update";
  32 const wchar_t kGoogleUpdateUpdatePolicyValue[] = L"UpdateDefault";
  33 const wchar_t kGoogleUpdateUpdateOverrideValuePrefix[] = L"Update";
  34 const GoogleUpdateSettings::UpdatePolicy kGoogleUpdateDefaultUpdatePolicy =
  35 #if defined(GOOGLE_CHROME_BUILD)
  36     GoogleUpdateSettings::AUTOMATIC_UPDATES;
  37 #else
  38     GoogleUpdateSettings::UPDATES_DISABLED;
  39 #endif
  40
  41 bool ReadGoogleUpdateStrKey(const wchar_t* const name, std::wstring* value) {
  42   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
  43   std::wstring reg_path = dist->GetStateKey();
  44   RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ);
  45   if (key.ReadValue(name, value) != ERROR_SUCCESS) {
  46     RegKey hklm_key(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_READ);
  47     return (hklm_key.ReadValue(name, value) == ERROR_SUCCESS);
  48   }
  49   return true;
  50 }
  51
  52 bool WriteGoogleUpdateStrKeyInternal(BrowserDistribution* dist,
  53                                      const wchar_t* const name,
  54                                      const std::wstring& value) {
  55   DCHECK(dist);
  56   std::wstring reg_path(dist->GetStateKey());
  57   RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_SET_VALUE);
  58   return (key.WriteValue(name, value.c_str()) == ERROR_SUCCESS);
  59 }
  60
  61 bool WriteGoogleUpdateStrKey(const wchar_t* const name,
  62                              const std::wstring& value) {
  63   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
  64   return WriteGoogleUpdateStrKeyInternal(dist, name, value);
  65 }
  66
  67 bool WriteGoogleUpdateStrKeyMultiInstall(BrowserDistribution* dist,
  68                                          const wchar_t* const name,
  69                                          const std::wstring& value,
  70                                          bool system_level) {
  71   bool result = WriteGoogleUpdateStrKeyInternal(dist, name, value);
  72   if (!InstallUtil::IsMultiInstall(dist, system_level))
  73     return result;
  74   // It is a multi-install distro. Must write the reg value again.
  75   BrowserDistribution* multi_dist =
  76       BrowserDistribution::GetSpecificDistribution(
  77           BrowserDistribution::CHROME_BINARIES);
  78   return WriteGoogleUpdateStrKeyInternal(multi_dist, name, value) && result;
  79 }
  80
  81 bool ClearGoogleUpdateStrKey(const wchar_t* const name) {
  82   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
  83   std::wstring reg_path = dist->GetStateKey();
  84   RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ | KEY_WRITE);
  85   std::wstring value;
  86   if (key.ReadValue(name, &value) != ERROR_SUCCESS)
  87     return false;
  88   return (key.WriteValue(name, L"") == ERROR_SUCCESS);
  89 }
  90
  91 bool RemoveGoogleUpdateStrKey(const wchar_t* const name) {
  92   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
  93   std::wstring reg_path = dist->GetStateKey();
  94   RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ | KEY_WRITE);
  95   if (!key.HasValue(name))
  96     return true;
  97   return (key.DeleteValue(name) == ERROR_SUCCESS);
  98 }
  99
 100 bool GetChromeChannelInternal(bool system_install,
 101                               bool add_multi_modifier,
 102                               string16* channel) {
 103   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 104   if (dist->GetChromeChannel(channel)) {
 105     return true;
 106   }
 107
 108   HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 109   string16 reg_path = dist->GetStateKey();
 110   RegKey key(root_key, reg_path.c_str(), KEY_READ);
 111
 112   installer::ChannelInfo channel_info;
 113   if (!channel_info.Initialize(key)) {
 114     channel->assign(installer::kChromeChannelUnknown);
 115     return false;
 116   }
 117
 118   if (!channel_info.GetChannelName(channel)) {
 119     channel->assign(installer::kChromeChannelUnknown);
 120   }
 121
 122   // Tag the channel name if this is a multi-install.
 123   if (add_multi_modifier && channel_info.IsMultiInstall()) {
 124     if (!channel->empty()) {
 125       channel->append(1, L'-');
 126     }
 127     channel->append(1, L'm');
 128   }
 129
 130   return true;
 131 }
 132
 133 // Populates |update_policy| with the UpdatePolicy enum value corresponding to a
 134 // DWORD read from the registry and returns true if |value| is within range.
 135 // If |value| is out of range, returns false without modifying |update_policy|.
 136 bool GetUpdatePolicyFromDword(
 137     const DWORD value,
 138     GoogleUpdateSettings::UpdatePolicy* update_policy) {
 139   switch (value) {
 140     case GoogleUpdateSettings::UPDATES_DISABLED:
 141     case GoogleUpdateSettings::AUTOMATIC_UPDATES:
 142     case GoogleUpdateSettings::MANUAL_UPDATES_ONLY:
 143     case GoogleUpdateSettings::AUTO_UPDATES_ONLY:
 144       *update_policy = static_cast<GoogleUpdateSettings::UpdatePolicy>(value);
 145       return true;
 146     default:
 147       LOG(WARNING) << "Unexpected update policy override value: " << value;
 148   }
 149   return false;
 150 }
 151
 152 }  // namespace
 153
 154 bool GoogleUpdateSettings::IsSystemInstall() {
 155   bool system_install = false;
 156   base::FilePath module_dir;
 157   if (!PathService::Get(base::DIR_MODULE, &module_dir)) {
 158     LOG(WARNING)
 159         << "Failed to get directory of module; assuming per-user install.";
 160   } else {
 161     system_install = !InstallUtil::IsPerUserInstall(module_dir.value().c_str());
 162   }
 163   return system_install;
 164 }
 165
 166 bool GoogleUpdateSettings::GetCollectStatsConsent() {
 167   return GetCollectStatsConsentAtLevel(IsSystemInstall());
 168 }
 169
 170 // Older versions of Chrome unconditionally read from HKCU\...\ClientState\...
 171 // and then HKLM\...\ClientState\....  This means that system-level Chrome
 172 // never checked ClientStateMedium (which has priority according to Google
 173 // Update) and gave preference to a value in HKCU (which was never checked by
 174 // Google Update).  From now on, Chrome follows Google Update's policy.
 175 bool GoogleUpdateSettings::GetCollectStatsConsentAtLevel(bool system_install) {
 176   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 177
 178   // Consent applies to all products in a multi-install package.
 179   if (InstallUtil::IsMultiInstall(dist, system_install)) {
 180     dist = BrowserDistribution::GetSpecificDistribution(
 181         BrowserDistribution::CHROME_BINARIES);
 182   }
 183
 184   RegKey key;
 185   DWORD value = 0;
 186   bool have_value = false;
 187
 188   // For system-level installs, try ClientStateMedium first.
 189   have_value =
 190       system_install &&
 191       key.Open(HKEY_LOCAL_MACHINE, dist->GetStateMediumKey().c_str(),
 192                KEY_QUERY_VALUE) == ERROR_SUCCESS &&
 193       key.ReadValueDW(google_update::kRegUsageStatsField,
 194                       &value) == ERROR_SUCCESS;
 195
 196   // Otherwise, try ClientState.
 197   if (!have_value) {
 198     have_value =
 199         key.Open(system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
 200                  dist->GetStateKey().c_str(),
 201                  KEY_QUERY_VALUE) == ERROR_SUCCESS &&
 202         key.ReadValueDW(google_update::kRegUsageStatsField,
 203                         &value) == ERROR_SUCCESS;
 204   }
 205
 206   // Google Update specifically checks that the value is 1, so we do the same.
 207   return have_value && value == 1;
 208 }
 209
 210 bool GoogleUpdateSettings::SetCollectStatsConsent(bool consented) {
 211   return SetCollectStatsConsentAtLevel(IsSystemInstall(), consented);
 212 }
 213
 214 bool GoogleUpdateSettings::SetCollectStatsConsentAtLevel(bool system_install,
 215                                                          bool consented) {
 216   // Google Update writes and expects 1 for true, 0 for false.
 217   DWORD value = consented ? 1 : 0;
 218
 219   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 220
 221   // Consent applies to all products in a multi-install package.
 222   if (InstallUtil::IsMultiInstall(dist, system_install)) {
 223     dist = BrowserDistribution::GetSpecificDistribution(
 224         BrowserDistribution::CHROME_BINARIES);
 225   }
 226
 227   // Write to ClientStateMedium for system-level; ClientState otherwise.
 228   HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 229   std::wstring reg_path =
 230       system_install ? dist->GetStateMediumKey() : dist->GetStateKey();
 231   RegKey key;
 232   LONG result = key.Create(root_key, reg_path.c_str(), KEY_SET_VALUE);
 233   if (result != ERROR_SUCCESS) {
 234     LOG(ERROR) << "Failed opening key " << reg_path << " to set "
 235                << google_update::kRegUsageStatsField << "; result: " << result;
 236   } else {
 237     result = key.WriteValue(google_update::kRegUsageStatsField, value);
 238     LOG_IF(ERROR, result != ERROR_SUCCESS) << "Failed setting "
 239         << google_update::kRegUsageStatsField << " in key " << reg_path
 240         << "; result: " << result;
 241   }
 242   return (result == ERROR_SUCCESS);
 243 }
 244
 245 bool GoogleUpdateSettings::GetMetricsId(std::wstring* metrics_id) {
 246   return ReadGoogleUpdateStrKey(google_update::kRegMetricsId, metrics_id);
 247 }
 248
 249 bool GoogleUpdateSettings::SetMetricsId(const std::wstring& metrics_id) {
 250   return WriteGoogleUpdateStrKey(google_update::kRegMetricsId, metrics_id);
 251 }
 252
 253 // EULA consent is only relevant for system-level installs.
 254 bool GoogleUpdateSettings::SetEULAConsent(
 255     const InstallationState& machine_state,
 256     BrowserDistribution* dist,
 257     bool consented) {
 258   DCHECK(dist);
 259   const DWORD eula_accepted = consented ? 1 : 0;
 260   std::wstring reg_path = dist->GetStateMediumKey();
 261   bool succeeded = true;
 262   RegKey key;
 263
 264   // Write the consent value into the product's ClientStateMedium key.
 265   if (key.Create(HKEY_LOCAL_MACHINE, reg_path.c_str(),
 266                  KEY_SET_VALUE) != ERROR_SUCCESS ||
 267       key.WriteValue(google_update::kRegEULAAceptedField,
 268                      eula_accepted) != ERROR_SUCCESS) {
 269     succeeded = false;
 270   }
 271
 272   // If this is a multi-install, also write it into the binaries' key.
 273   // --mutli-install is not provided on the command-line, so deduce it from
 274   // the product's state.
 275   const installer::ProductState* product_state =
 276       machine_state.GetProductState(true, dist->GetType());
 277   if (product_state != NULL && product_state->is_multi_install()) {
 278     dist = BrowserDistribution::GetSpecificDistribution(
 279         BrowserDistribution::CHROME_BINARIES);
 280     reg_path = dist->GetStateMediumKey();
 281     if (key.Create(HKEY_LOCAL_MACHINE, reg_path.c_str(),
 282                    KEY_SET_VALUE) != ERROR_SUCCESS ||
 283         key.WriteValue(google_update::kRegEULAAceptedField,
 284                        eula_accepted) != ERROR_SUCCESS) {
 285         succeeded = false;
 286     }
 287   }
 288
 289   return succeeded;
 290 }
 291
 292 int GoogleUpdateSettings::GetLastRunTime() {
 293   std::wstring time_s;
 294   if (!ReadGoogleUpdateStrKey(google_update::kRegLastRunTimeField, &time_s))
 295     return -1;
 296   int64 time_i;
 297   if (!base::StringToInt64(time_s, &time_i))
 298     return -1;
 299   base::TimeDelta td =
 300       base::Time::NowFromSystemTime() - base::Time::FromInternalValue(time_i);
 301   return td.InDays();
 302 }
 303
 304 bool GoogleUpdateSettings::SetLastRunTime() {
 305   int64 time = base::Time::NowFromSystemTime().ToInternalValue();
 306   return WriteGoogleUpdateStrKey(google_update::kRegLastRunTimeField,
 307                                  base::Int64ToString16(time));
 308 }
 309
 310 bool GoogleUpdateSettings::RemoveLastRunTime() {
 311   return RemoveGoogleUpdateStrKey(google_update::kRegLastRunTimeField);
 312 }
 313
 314 bool GoogleUpdateSettings::GetBrowser(std::wstring* browser) {
 315   return ReadGoogleUpdateStrKey(google_update::kRegBrowserField, browser);
 316 }
 317
 318 bool GoogleUpdateSettings::GetLanguage(std::wstring* language) {
 319   return ReadGoogleUpdateStrKey(google_update::kRegLangField, language);
 320 }
 321
 322 bool GoogleUpdateSettings::GetBrand(std::wstring* brand) {
 323   return ReadGoogleUpdateStrKey(google_update::kRegRLZBrandField, brand);
 324 }
 325
 326 bool GoogleUpdateSettings::GetReactivationBrand(std::wstring* brand) {
 327   return ReadGoogleUpdateStrKey(google_update::kRegRLZReactivationBrandField,
 328                                 brand);
 329 }
 330
 331 bool GoogleUpdateSettings::GetClient(std::wstring* client) {
 332   return ReadGoogleUpdateStrKey(google_update::kRegClientField, client);
 333 }
 334
 335 bool GoogleUpdateSettings::SetClient(const std::wstring& client) {
 336   return WriteGoogleUpdateStrKey(google_update::kRegClientField, client);
 337 }
 338
 339 bool GoogleUpdateSettings::GetReferral(std::wstring* referral) {
 340   return ReadGoogleUpdateStrKey(google_update::kRegReferralField, referral);
 341 }
 342
 343 bool GoogleUpdateSettings::ClearReferral() {
 344   return ClearGoogleUpdateStrKey(google_update::kRegReferralField);
 345 }
 346
 347 bool GoogleUpdateSettings::UpdateDidRunState(bool did_run,
 348                                              bool system_level) {
 349   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 350   return UpdateDidRunStateForDistribution(dist, did_run, system_level);
 351 }
 352
 353 bool GoogleUpdateSettings::UpdateDidRunStateForDistribution(
 354     BrowserDistribution* dist,
 355     bool did_run,
 356     bool system_level) {
 357   return WriteGoogleUpdateStrKeyMultiInstall(dist,
 358                                              google_update::kRegDidRunField,
 359                                              did_run ? L"1" : L"0",
 360                                              system_level);
 361 }
 362
 363 std::wstring GoogleUpdateSettings::GetChromeChannel(bool system_install) {
 364   std::wstring channel;
 365   GetChromeChannelInternal(system_install, false, &channel);
 366   return channel;
 367 }
 368
 369 bool GoogleUpdateSettings::GetChromeChannelAndModifiers(bool system_install,
 370                                                         string16* channel) {
 371   return GetChromeChannelInternal(system_install, true, channel);
 372 }
 373
 374 void GoogleUpdateSettings::UpdateInstallStatus(bool system_install,
 375     installer::ArchiveType archive_type, int install_return_code,
 376     const std::wstring& product_guid) {
 377   DCHECK(archive_type != installer::UNKNOWN_ARCHIVE_TYPE ||
 378          install_return_code != 0);
 379   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 380
 381   RegKey key;
 382   installer::ChannelInfo channel_info;
 383   std::wstring reg_key(google_update::kRegPathClientState);
 384   reg_key.append(L"\\");
 385   reg_key.append(product_guid);
 386   LONG result = key.Open(reg_root, reg_key.c_str(),
 387                          KEY_QUERY_VALUE | KEY_SET_VALUE);
 388   if (result == ERROR_SUCCESS)
 389     channel_info.Initialize(key);
 390   else if (result != ERROR_FILE_NOT_FOUND)
 391     LOG(ERROR) << "Failed to open " << reg_key << "; Error: " << result;
 392
 393   if (UpdateGoogleUpdateApKey(archive_type, install_return_code,
 394                               &channel_info)) {
 395     // We have a modified channel_info value to write.
 396     // Create the app's ClientState key if it doesn't already exist.
 397     if (!key.Valid()) {
 398       result = key.Open(reg_root, google_update::kRegPathClientState,
 399                         KEY_CREATE_SUB_KEY);
 400       if (result == ERROR_SUCCESS)
 401         result = key.CreateKey(product_guid.c_str(), KEY_SET_VALUE);
 402
 403       if (result != ERROR_SUCCESS) {
 404         LOG(ERROR) << "Failed to create " << reg_key << "; Error: " << result;
 405         return;
 406       }
 407     }
 408     if (!channel_info.Write(&key)) {
 409       LOG(ERROR) << "Failed to write to application's ClientState key "
 410                  << google_update::kRegApField << " = " << channel_info.value();
 411     }
 412   }
 413 }
 414
 415 bool GoogleUpdateSettings::UpdateGoogleUpdateApKey(
 416     installer::ArchiveType archive_type, int install_return_code,
 417     installer::ChannelInfo* value) {
 418   DCHECK(archive_type != installer::UNKNOWN_ARCHIVE_TYPE ||
 419          install_return_code != 0);
 420   bool modified = false;
 421
 422   if (archive_type == installer::FULL_ARCHIVE_TYPE || !install_return_code) {
 423     if (value->SetFullSuffix(false)) {
 424       VLOG(1) << "Removed incremental installer failure key; "
 425                  "switching to channel: "
 426               << value->value();
 427       modified = true;
 428     }
 429   } else if (archive_type == installer::INCREMENTAL_ARCHIVE_TYPE) {
 430     if (value->SetFullSuffix(true)) {
 431       VLOG(1) << "Incremental installer failed; switching to channel: "
 432               << value->value();
 433       modified = true;
 434     } else {
 435       VLOG(1) << "Incremental installer failure; already on channel: "
 436               << value->value();
 437     }
 438   } else {
 439     // It's okay if we don't know the archive type.  In this case, leave the
 440     // "-full" suffix as we found it.
 441     DCHECK_EQ(installer::UNKNOWN_ARCHIVE_TYPE, archive_type);
 442   }
 443
 444   if (value->SetMultiFailSuffix(false)) {
 445     VLOG(1) << "Removed multi-install failure key; switching to channel: "
 446             << value->value();
 447     modified = true;
 448   }
 449
 450   return modified;
 451 }
 452
 453 int GoogleUpdateSettings::DuplicateGoogleUpdateSystemClientKey() {
 454   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 455   std::wstring reg_path = dist->GetStateKey();
 456
 457   // Minimum access needed is to be able to write to this key.
 458   RegKey reg_key(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_SET_VALUE);
 459   if (!reg_key.Valid())
 460     return 0;
 461
 462   HANDLE target_handle = 0;
 463   if (!DuplicateHandle(GetCurrentProcess(), reg_key.Handle(),
 464                        GetCurrentProcess(), &target_handle, KEY_SET_VALUE,
 465                        TRUE, DUPLICATE_SAME_ACCESS)) {
 466     return 0;
 467   }
 468   return reinterpret_cast<int>(target_handle);
 469 }
 470
 471 bool GoogleUpdateSettings::WriteGoogleUpdateSystemClientKey(
 472     int handle, const std::wstring& key, const std::wstring& value) {
 473   HKEY reg_key = reinterpret_cast<HKEY>(reinterpret_cast<void*>(handle));
 474   DWORD size = static_cast<DWORD>(value.size()) * sizeof(wchar_t);
 475   LSTATUS status = RegSetValueEx(reg_key, key.c_str(), 0, REG_SZ,
 476       reinterpret_cast<const BYTE*>(value.c_str()), size);
 477   return status == ERROR_SUCCESS;
 478 }
 479
 480 GoogleUpdateSettings::UpdatePolicy GoogleUpdateSettings::GetAppUpdatePolicy(
 481     const std::wstring& app_guid,
 482     bool* is_overridden) {
 483   bool found_override = false;
 484   UpdatePolicy update_policy = kGoogleUpdateDefaultUpdatePolicy;
 485
 486 #if defined(GOOGLE_CHROME_BUILD)
 487   DCHECK(!app_guid.empty());
 488   RegKey policy_key;
 489
 490   // Google Update Group Policy settings are always in HKLM.
 491   if (policy_key.Open(HKEY_LOCAL_MACHINE, kGoogleUpdatePoliciesKey,
 492                       KEY_QUERY_VALUE) == ERROR_SUCCESS) {
 493     static const size_t kPrefixLen =
 494         arraysize(kGoogleUpdateUpdateOverrideValuePrefix) - 1;
 495     DWORD value;
 496     std::wstring app_update_override;
 497     app_update_override.reserve(kPrefixLen + app_guid.size());
 498     app_update_override.append(kGoogleUpdateUpdateOverrideValuePrefix,
 499                                kPrefixLen);
 500     app_update_override.append(app_guid);
 501     // First try to read and comprehend the app-specific override.
 502     found_override = (policy_key.ReadValueDW(app_update_override.c_str(),
 503                                              &value) == ERROR_SUCCESS &&
 504                       GetUpdatePolicyFromDword(value, &update_policy));
 505
 506     // Failing that, try to read and comprehend the default override.
 507     if (!found_override &&
 508         policy_key.ReadValueDW(kGoogleUpdateUpdatePolicyValue,
 509                                &value) == ERROR_SUCCESS) {
 510       GetUpdatePolicyFromDword(value, &update_policy);
 511     }
 512   }
 513 #endif  // defined(GOOGLE_CHROME_BUILD)
 514
 515   if (is_overridden != NULL)
 516     *is_overridden = found_override;
 517
 518   return update_policy;
 519 }
 520
 521 string16 GoogleUpdateSettings::GetUninstallCommandLine(bool system_install) {
 522   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 523   string16 cmd_line;
 524   RegKey update_key;
 525
 526   if (update_key.Open(root_key, google_update::kRegPathGoogleUpdate,
 527                       KEY_QUERY_VALUE) == ERROR_SUCCESS) {
 528     update_key.ReadValue(google_update::kRegUninstallCmdLine, &cmd_line);
 529   }
 530
 531   return cmd_line;
 532 }
 533
 534 Version GoogleUpdateSettings::GetGoogleUpdateVersion(bool system_install) {
 535   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 536   string16 version;
 537   RegKey key;
 538
 539   if (key.Open(root_key,
 540                google_update::kRegPathGoogleUpdate,
 541                KEY_QUERY_VALUE) == ERROR_SUCCESS &&
 542       key.ReadValue(google_update::kRegGoogleUpdateVersion,
 543                     &version) == ERROR_SUCCESS) {
 544     return Version(UTF16ToUTF8(version));
 545   }
 546
 547   return Version();
 548 }
 549
 550 base::Time GoogleUpdateSettings::GetGoogleUpdateLastStartedAU(
 551     bool system_install) {
 552   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 553   RegKey update_key;
 554
 555   if (update_key.Open(root_key, google_update::kRegPathGoogleUpdate,
 556                       KEY_QUERY_VALUE) == ERROR_SUCCESS) {
 557     DWORD last_start;
 558     if (update_key.ReadValueDW(google_update::kRegLastStartedAUField,
 559                                &last_start) == ERROR_SUCCESS) {
 560       return base::Time::FromTimeT(last_start);
 561     }
 562   }
 563
 564   return base::Time();
 565 }
 566
 567 base::Time GoogleUpdateSettings::GetGoogleUpdateLastChecked(
 568     bool system_install) {
 569   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 570   RegKey update_key;
 571
 572   if (update_key.Open(root_key, google_update::kRegPathGoogleUpdate,
 573                       KEY_QUERY_VALUE) == ERROR_SUCCESS) {
 574     DWORD last_check;
 575     if (update_key.ReadValueDW(google_update::kRegLastCheckedField,
 576                                &last_check) == ERROR_SUCCESS) {
 577       return base::Time::FromTimeT(last_check);
 578     }
 579   }
 580
 581   return base::Time();
 582 }
 583
 584 bool GoogleUpdateSettings::GetUpdateDetailForApp(bool system_install,
 585                                                  const wchar_t* app_guid,
 586                                                  ProductData* data) {
 587   DCHECK(app_guid);
 588   DCHECK(data);
 589
 590   bool product_found = false;
 591
 592   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 593   string16 clientstate_reg_path(google_update::kRegPathClientState);
 594   clientstate_reg_path.append(L"\\");
 595   clientstate_reg_path.append(app_guid);
 596
 597   RegKey clientstate;
 598   if (clientstate.Open(root_key, clientstate_reg_path.c_str(),
 599                        KEY_QUERY_VALUE) == ERROR_SUCCESS) {
 600     string16 version;
 601     DWORD dword_value;
 602     if ((clientstate.ReadValueDW(google_update::kRegLastCheckSuccessField,
 603                                  &dword_value) == ERROR_SUCCESS) &&
 604         (clientstate.ReadValue(google_update::kRegVersionField,
 605                                &version) == ERROR_SUCCESS)) {
 606       product_found = true;
 607       data->version = WideToASCII(version);
 608       data->last_success = base::Time::FromTimeT(dword_value);
 609       data->last_result = 0;
 610       data->last_error_code = 0;
 611       data->last_extra_code = 0;
 612
 613       if (clientstate.ReadValueDW(google_update::kRegLastInstallerResultField,
 614                                   &dword_value) == ERROR_SUCCESS) {
 615         // Google Update convention is that if an installer writes an result
 616         // code that is invalid, it is clamped to an exit code result.
 617         const DWORD kMaxValidInstallResult = 4;  // INSTALLER_RESULT_EXIT_CODE
 618         data->last_result = std::min(dword_value, kMaxValidInstallResult);
 619       }
 620       if (clientstate.ReadValueDW(google_update::kRegLastInstallerErrorField,
 621                                   &dword_value) == ERROR_SUCCESS) {
 622         data->last_error_code = dword_value;
 623       }
 624       if (clientstate.ReadValueDW(google_update::kRegLastInstallerExtraField,
 625                                   &dword_value) == ERROR_SUCCESS) {
 626         data->last_extra_code = dword_value;
 627       }
 628     }
 629   }
 630
 631   return product_found;
 632 }
 633
 634 bool GoogleUpdateSettings::GetUpdateDetailForGoogleUpdate(bool system_install,
 635                                                           ProductData* data) {
 636   return GetUpdateDetailForApp(system_install,
 637                                google_update::kGoogleUpdateUpgradeCode,
 638                                data);
 639 }
 640
 641 bool GoogleUpdateSettings::GetUpdateDetail(bool system_install,
 642                                            ProductData* data) {
 643   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 644   return GetUpdateDetailForApp(system_install,
 645                                dist->GetAppGuid().c_str(),
 646                                data);
 647 }
 648
 649 bool GoogleUpdateSettings::SetExperimentLabels(
 650     bool system_install,
 651     const string16& experiment_labels) {
 652   HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 653
 654   // Use the browser distribution and install level to write to the correct
 655   // client state/app guid key.
 656   bool success = false;
 657   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 658   if (dist->ShouldSetExperimentLabels()) {
 659     string16 client_state_path(
 660         system_install ? dist->GetStateMediumKey() : dist->GetStateKey());
 661     RegKey client_state(
 662         reg_root, client_state_path.c_str(), KEY_SET_VALUE);
 663     if (experiment_labels.empty()) {
 664       success = client_state.DeleteValue(google_update::kExperimentLabels)
 665           == ERROR_SUCCESS;
 666     } else {
 667       success = client_state.WriteValue(google_update::kExperimentLabels,
 668           experiment_labels.c_str()) == ERROR_SUCCESS;
 669     }
 670   }
 671
 672   return success;
 673 }
 674
 675 bool GoogleUpdateSettings::ReadExperimentLabels(
 676     bool system_install,
 677     string16* experiment_labels) {
 678   HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 679
 680   // If this distribution does not set the experiment labels, don't bother
 681   // reading.
 682   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 683   if (!dist->ShouldSetExperimentLabels())
 684     return false;
 685
 686   string16 client_state_path(
 687       system_install ? dist->GetStateMediumKey() : dist->GetStateKey());
 688
 689   RegKey client_state;
 690   LONG result =
 691       client_state.Open(reg_root, client_state_path.c_str(), KEY_QUERY_VALUE);
 692   if (result == ERROR_SUCCESS) {
 693     result = client_state.ReadValue(google_update::kExperimentLabels,
 694                                     experiment_labels);
 695   }
 696
 697   // If the key or value was not present, return the empty string.
 698   if (result == ERROR_FILE_NOT_FOUND || result == ERROR_PATH_NOT_FOUND) {
 699     experiment_labels->clear();
 700     return true;
 701   }
 702
 703   return result == ERROR_SUCCESS;
 704 }