Force migrate all clients from multi-install back to single-install.

chrome/installer/util/master_preferences.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.
 
 #include "chrome/installer/util/master_preferences.h"
 
 #include <stddef.h>
 
 #include "base/environment.h"
 #include "base/files/file_util.h"
@@ skipping 57 matching lines @@
                  << "Root item must be a dictionary.";
     return NULL;
   }
   return static_cast<base::DictionaryValue*>(root.release());
 }
 
 }  // namespace
 
 namespace installer {
 
-MasterPreferences::MasterPreferences() : distribution_(NULL),
-                                         preferences_read_from_file_(false),
-                                         chrome_(true),
-                                         multi_install_(false) {
+MasterPreferences::MasterPreferences() {
   InitializeFromCommandLine(*base::CommandLine::ForCurrentProcess());
 }
 
-MasterPreferences::MasterPreferences(const base::CommandLine& cmd_line)
-    : distribution_(NULL),
-      preferences_read_from_file_(false),
-      chrome_(true),
-      multi_install_(false) {
+MasterPreferences::MasterPreferences(const base::CommandLine& cmd_line) {
   InitializeFromCommandLine(cmd_line);
 }
 
-MasterPreferences::MasterPreferences(const base::FilePath& prefs_path)
-    : distribution_(NULL),
-      preferences_read_from_file_(false),
-      chrome_(true),
-      multi_install_(false) {
+MasterPreferences::MasterPreferences(const base::FilePath& prefs_path) {
   InitializeFromFilePath(prefs_path);
 }
 
-MasterPreferences::MasterPreferences(const std::string& prefs)
-    : distribution_(NULL),
-      preferences_read_from_file_(false),
-      chrome_(true),
-      multi_install_(false) {
+MasterPreferences::MasterPreferences(const std::string& prefs) {
   InitializeFromString(prefs);
 }
 
 MasterPreferences::~MasterPreferences() {
 }
 
 void MasterPreferences::InitializeFromCommandLine(
     const base::CommandLine& cmd_line) {
 #if defined(OS_WIN)
   if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
     base::FilePath prefs_path(cmd_line.GetSwitchValuePath(
         installer::switches::kInstallerData));
     InitializeFromFilePath(prefs_path);
   } else {
     master_dictionary_.reset(new base::DictionaryValue());
   }
 
   DCHECK(master_dictionary_.get());
 
   // A simple map from command line switches to equivalent switches in the
   // distribution dictionary.  Currently all switches added will be set to
   // 'true'.
   static const struct CmdLineSwitchToDistributionSwitch {
     const char* cmd_line_switch;
     const char* distribution_switch;
   } translate_switches[] = {
-    { installer::switches::kChrome,
-      installer::master_preferences::kChrome },
     { installer::switches::kDisableLogging,
       installer::master_preferences::kDisableLogging },
     { installer::switches::kMsi,
       installer::master_preferences::kMsi },
-    { installer::switches::kMultiInstall,
-      installer::master_preferences::kMultiInstall },
     { installer::switches::kDoNotRegisterForUpdateLaunch,
       installer::master_preferences::kDoNotRegisterForUpdateLaunch },
     { installer::switches::kDoNotLaunchChrome,
       installer::master_preferences::kDoNotLaunchChrome },
     { installer::switches::kMakeChromeDefault,
       installer::master_preferences::kMakeChromeDefault },
     { installer::switches::kSystemLevel,
       installer::master_preferences::kSystemLevel },
     { installer::switches::kVerboseLogging,
       installer::master_preferences::kVerboseLogging },
@@ skipping 24 matching lines @@
     std::string is_machine_var;
     env->GetVar(env_vars::kGoogleUpdateIsMachineEnvVar, &is_machine_var);
     if (is_machine_var == "1") {
       VLOG(1) << "Taking system-level from environment.";
       name.assign(installer::master_preferences::kDistroDict);
       name.append(".").append(installer::master_preferences::kSystemLevel);
       master_dictionary_->SetBoolean(name, true);
     }
   }
 
+  // Strip multi-install from the dictionary, if present.
+  master_dictionary_->Remove(std::string(master_preferences::kDistroDict) +
+                                 '.' + master_preferences::kMultiInstall,

[gab, 2016/12/12 21:38:16]

Why bother stripping it? We're not stripping kChrome nor any other garbage. What
I'd like one day is to only copy a select set to Preferences instead of stomping
it all out there but that's another story.

Also, have we updated online documentation already?

[grt (UTC plus 2), 2016/12/13 09:20:37]

This is an insurance policy against code that looks directly into the
process-wide MasterPreferences dict to check for multi-ness rather than querying
the InstallerState instance. I haven't found any in my various searches, but
that doesn't mean it's not there. :-)

Note that this does not edit the file on disk -- it just serves to keep the
state in-process consistent.
I plan to make a pass on chromium.org sometime after this lands.

[gab, 2016/12/14 16:33:38]

Got it, can you clarify the comment to that effect (i.e. to avoid this turning
into a justification to add stripping code for all-the-things).

+                             nullptr);
+
   // Cache a pointer to the distribution dictionary. Ignore errors if any.
   master_dictionary_->GetDictionary(installer::master_preferences::kDistroDict,
                                     &distribution_);
-
-  InitializeProductFlags();
 #endif
 }
 
 void MasterPreferences::InitializeFromFilePath(
     const base::FilePath& prefs_path) {
   std::string json_data;
   // Failure to read the file is ignored as |json_data| will be the empty string
   // and the remainder of this MasterPreferences object should still be
   // initialized as best as possible.
   if (base::PathExists(prefs_path) &&
@@ skipping 11 matching lines @@
   bool data_is_valid = true;
   if (!master_dictionary_.get()) {
     master_dictionary_.reset(new base::DictionaryValue());
     data_is_valid = false;
   } else {
     // Cache a pointer to the distribution dictionary.
     master_dictionary_->GetDictionary(
         installer::master_preferences::kDistroDict, &distribution_);
   }
 
-  InitializeProductFlags();
   EnforceLegacyPreferences();
   return data_is_valid;
 }
 
-void MasterPreferences::InitializeProductFlags() {
-  // Make sure we start out with the correct defaults.
-  multi_install_ = false;
-  chrome_ = true;
-
-  GetBool(installer::master_preferences::kMultiInstall, &multi_install_);
-
-  // When multi-install is specified, the checks are pretty simple (in theory):
-  // In order to be installed/uninstalled, each product must have its switch
-  // present on the command line.
-  // When multi-install is not set, operate on Chrome.
-  if (multi_install_) {
-    if (!GetBool(installer::master_preferences::kChrome, &chrome_))
-      chrome_ = false;
-  } else {
-    chrome_ = true;
-  }
-}
-
 void MasterPreferences::EnforceLegacyPreferences() {
   // If create_all_shortcuts was explicitly set to false, set
   // do_not_create_(desktop|quick_launch)_shortcut to true.
   bool create_all_shortcuts = true;
   GetBool(installer::master_preferences::kCreateAllShortcuts,
           &create_all_shortcuts);
   if (!create_all_shortcuts) {
     distribution_->SetBoolean(
         installer::master_preferences::kDoNotCreateDesktopShortcut, true);
     distribution_->SetBoolean(
@@ skipping 55 matching lines @@
   }
   return result;
 }
 
 // static
 const MasterPreferences& MasterPreferences::ForCurrentProcess() {
   return g_master_preferences.Get();
 }
 
 }  // namespace installer