Delete both regular and Metro user data dirs on uninstall.

chrome/installer/util/helper.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
 #include "chrome/installer/util/helper.h"
 
 #include "base/logging.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
+#include "base/win/windows_version.h"
+#include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/util_constants.h"
 
 namespace {
 
 FilePath GetChromeInstallBasePath(bool system,
                                   BrowserDistribution* distribution,
                                   const wchar_t* sub_path) {
@@ skipping 13 matching lines @@
 }
 
 }  // namespace
 
 namespace installer {
 
 FilePath GetChromeInstallPath(bool system_install, BrowserDistribution* dist) {
   return GetChromeInstallBasePath(system_install, dist, kInstallBinaryDir);
 }
 
-FilePath GetChromeUserDataPath(BrowserDistribution* dist) {
-  return GetChromeInstallBasePath(false, dist, kInstallUserDataDir);
+void GetChromeUserDataPaths(BrowserDistribution* dist,
+                            std::vector<FilePath>* paths) {
+  const bool has_metro_data = dist->CanSetAsDefault() &&
+      base::win::GetVersion() >= base::win::VERSION_WIN8;
+  FilePath data_dir(GetChromeInstallBasePath(false, dist, kInstallUserDataDir));
+  if (data_dir.empty()) {
+    paths->clear();
+  } else {
+    paths->resize(has_metro_data ? 2 : 1);
+    (*paths)[0] = data_dir;
+    if (has_metro_data) {
+      (*paths)[1] = data_dir.DirName().Append(
+          chrome::kMetroChromeUserDataSubDir);

[gab, 2012/08/03 17:54:20]

We do not want installer_util to depend on chrome (we want the opposite).

Move this constant into chrome/installer/util/util_constants.h.

And change GetUserDataDirectoryForEnvironment() in chrome_paths_win.cc to
something like:

bool GetUserDataDirectoryForEnvironment(bool current, FilePath* result) {
  std::vector<FilePath> data_dir_paths;
  BrowserDistribution* chrome_dist =
BrowserDistribution::GetSpecificDistribution(
          BrowserDistribution::CHROME_BROWSER));
  installer::GetChromeUserDataPaths(chrome_dist, &data_dir_paths);
  
  const bool want_metro = base::win::IsMetroProcess() ? current : !current;
  if (data_dir_paths.size() < (want_metro ? 2 : 1)) {
    NOTREACHED();
    return false;
  }
  *result = want_metro ? data_dir_paths[1] : data_dir_paths[0];
  return true;
}

[grt (UTC plus 2), 2012/08/03 20:18:37]

not done.  this is in common_constants, which installer_util already depends on
(note the lack of .gypi changes).  all other cases where util_constants
duplicates values defined in common_constants should be removed.  this task is
outside the scope of this CL.
this is incorrect since the browser may not be what is running.
i think this is a step in the wrong direction.  the existing logic is very
clear.  the code you propose assumes an implicit contract that the metro
directory comes after the desktop directory in the installer's list.  that seems
dangerous. i also think it's wrong for the product to ask the installer for
these directories.  if anything, i'd like to see a followup CL that puts all
"user data dir" logic in the product and have the installer ask the product,
since the product is the primary producer/consumer and the installer is just a
technician that steps in at uninstall time to do some bookkeeping and cleanup.

[gab, 2012/08/03 21:58:57]

Ah I see, chrome common constants != chrome :).

Thanks for clarifying!

+    }
+  }
 }
 
 BrowserDistribution* GetBinariesDistribution(bool system_install) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   ProductState state;
 
   // If we're part of a multi-install, we need to poll using the multi-installer
   // package's app guid rather than the browser's or Chrome Frame's app guid.
   // If we can't read the app's state from the registry, assume it isn't
   // multi-installed.
   if (state.Initialize(system_install, dist) && state.is_multi_install()) {
     return BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BINARIES);
   } else {
     return dist;
   }
 }
 
 std::wstring GetAppGuidForUpdates(bool system_install) {
   return GetBinariesDistribution(system_install)->GetAppGuid();
 }
 
 }  // namespace installer.