Refactor SetOmahaExperimentLabel out of gcpai and into install_util.

chrome/installer/util/install_util.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.
 //
 // See the corresponding header file for description of the functions in this
 // file.
 
 #include "chrome/installer/util/install_util.h"
 
 #include <shellapi.h>
@@ skipping 20 matching lines @@
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 
 using base::win::RegKey;
 using installer::ProductState;
 
 namespace {
 
+const wchar_t* kExperimentAppGuids[] = {
+    L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}",
+    L"{8A69D345-D564-463C-AFF1-A69D9E530F96}",
+};
+
+const wchar_t kExperimentLabels[] = L"experiment_labels";
+
 const wchar_t kStageBinaryPatching[] = L"binary_patching";
 const wchar_t kStageBuilding[] = L"building";
 const wchar_t kStageConfiguringAutoLaunch[] = L"configuring_auto_launch";
 const wchar_t kStageCopyingPreferencesFile[] = L"copying_prefs";
 const wchar_t kStageCreatingShortcuts[] = L"creating_shortcuts";
 const wchar_t kStageEnsemblePatching[] = L"ensemble_patching";
 const wchar_t kStageExecuting[] = L"executing";
 const wchar_t kStageFinishing[] = L"finishing";
 const wchar_t kStagePreconditions[] = L"preconditions";
 const wchar_t kStageRefreshingPolicy[] = L"refreshing_policy";
@@ skipping 465 matching lines @@
                            date_str, arraysize(date_str));
   if (len) {
     --len;  // Subtract terminating \0.
   } else {
     PLOG(DFATAL) << "GetDateFormat";
   }
 
   return string16(date_str, len);
 }
 
+// static
+bool InstallUtil::SetOmahaExperimentLabel(const string16& experiment_label,

[grt (UTC plus 2), 2012/11/23 00:09:55]

If this is meant to be called from the context of chrome.exe, then it could
potentially be called for Chromium, Google Chrome, Google Chrome SxS (canaray),
Google Chrome Frame, or Google Chrome App Host (or possibly even setup.exe).
Cases like this are handled by the BrowserDistribution class -- the base class
handles the Chromium case, and various derived types handle all of the others. I
think the right thing to do here is to add something like:
  virtual bool HasExperiments();
to BrowserDistribution that returns false. Override this in
GoogleChromeDistribution (return true), GoogleChromeSxSDistribution (return
false), and GoogleChromeBinariesDistribution (return true).

Then in this function, assuming it is to be called from chrome.exe and GCAPI,
you do something like this:
  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
  if (dist->HasExperiments()) {
    string16 client_state_path(dist->GetStateKey());
    RegKey client_state(root, client_state_root.c_str(), KEY_SET_VALUE);
    if (client_state.WriteValue(...) == ERROR_SUCCESS) { ... }
  }
This will only write to the registry for the products that actually have
experiments, and you get the correct registry location by going through the
GetStateKey method.

Since GCAPI is only meant to be used on Google Chrome, I think the call to
GetDistribution() will return the proper instance automatically.

If you need to preserve the behavior of writing into the key for the binaries (I
don't know why you would, but I haven't read any design docs so I'm completely
uninformed), then you'll furthermore need to do something like:

  if (InstallUtil::IsMultiInstall(dist, system_install)) {
    BrowserDistribution *binaries_dist =
BrowserDistribution::GetSpecificDistribution(BrowserDistribution::
CHROME_BINARIES);
    // do the same HasExperiments check such for binaries_dist
  }

Now come the extra twists. Have a drink while you read on. :-)

To handle the case of per-user vs. per-machine installs, the utility functions
in here typically take a |system_level| bool in param. Callers either already
know if they're user or system, or they use !InstallUtil::IsPerUserInstall(...)
to figure it out. This function should follow the same parameter, which means
replacing the HKEY registry_hive param with a bool system_level param, and then
inside the func have something like:
  HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;

But wait, there's more!

System-level Chrome doesn't have permission to write to ClientState in HKLM.
Omaha creates a lower-rights key called ClientStateMedium for use in this case.
I've just looked at the corresponding Omaha code, and it does not appear to read
from ClientStateMedium, so you have a small problem here. You have two options:
have Omaha give priority to ClientStateMedium for per-machine installs (this is
how things like the EULA-accepted flag are handled), or use Omaha facilities to
launch setup.exe at high integrity and add special handling to setup.exe to set
this value. I think the former solution is easier, but it means that any
user-level process on a machine can potentially tweak the value. Maybe this
isn't a problem. If so, it's not a difficult thing to change Omaha's behavior.

+                                          HKEY registry_hive) {
+  size_t successful_writes = 0;
+  string16 experiment_path;
+  for (size_t i = 0; i < arraysize(kExperimentAppGuids); ++i) {
+    experiment_path = google_update::kRegPathClientState;
+    experiment_path += L"\\";
+    experiment_path += kExperimentAppGuids[i];
+
+    RegKey client_state(registry_hive, experiment_path.c_str(),
+                        KEY_SET_VALUE);
+    if (client_state.WriteValue(kExperimentLabels,
+                                experiment_label.c_str()) == ERROR_SUCCESS) {
+      ++successful_writes;
+    }
+  }
+
+  return (successful_writes == arraysize(kExperimentAppGuids));
+}
+
 // Open |path| with minimal access to obtain information about it, returning
 // true and populating |handle| on success.
 // static
 bool InstallUtil::ProgramCompare::OpenForInfo(const FilePath& path,
                                               base::win::ScopedHandle* handle) {
   DCHECK(handle);
   handle->Set(base::CreatePlatformFile(path, base::PLATFORM_FILE_OPEN, NULL,
                                        NULL));
   return handle->IsValid();
 }
@@ skipping 49 matching lines @@
   // Open the program and see if it references the expected file.
   base::win::ScopedHandle handle;
   BY_HANDLE_FILE_INFORMATION info = {};
 
   return (OpenForInfo(program, &handle) &&
           GetInfo(handle, &info) &&
           info.dwVolumeSerialNumber == file_info_.dwVolumeSerialNumber &&
           info.nFileIndexHigh == file_info_.nFileIndexHigh &&
           info.nFileIndexLow == file_info_.nFileIndexLow);
 }