Refactor of BrowserDistribution.

chrome/installer/util/installation_validator.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.
 
 // Implementation of the installation validator.
 
 #include "chrome/installer/util/installation_validator.h"
 
 #include <algorithm>
 #include <set>
@@ skipping 195 matching lines @@
          app_cmd.is_auto_run_on_os_upgrade(),
          "be marked to run on OS upgrade"},
     {google_update::kRegRunAsUserField,
          app_cmd.is_run_as_user(),
          "be marked to run as user"},
   };
   for (int i = 0; i < arraysize(check_list); ++i) {
     bool expected = flags_exp.find(check_list[i].exp_key) != flags_exp.end();
     if (check_list[i].val != expected) {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName() << ": "
+      LOG(ERROR) << ctx.dist->GetDisplayName() << ": "
                  << name << " command should " << (expected ? "" : "not ")
                  << check_list[i].msg << ".";
     }
   }
 }
 
 // Validates both "install-application" and "install-extension" depending on
 // what is passed in.
 void InstallationValidator::ValidateInstallCommand(
     const ProductContext& ctx,
@@ skipping 183 matching lines @@
   for (; cmd_iterators.first != cmd_iterators.second; ++cmd_iterators.first) {
     const string16& cmd_id = cmd_iterators.first->first;
     // Do we have an expectation for this command?
     expectation = the_expectations.find(cmd_id);
     if (expectation != the_expectations.end()) {
       (expectation->second)(ctx, cmd_iterators.first->second, is_valid);
       // Remove this command from the set of expectations since we found it.
       the_expectations.erase(expectation);
     } else {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << ctx.dist->GetDisplayName()
                  << " has an unexpected Google Update product command named \""
                  << cmd_id << "\".";
     }
   }
 
   // Report on any expected commands that weren't present.
   CommandExpectations::const_iterator scan(the_expectations.begin());
   CommandExpectations::const_iterator end(the_expectations.end());
   for (; scan != end; ++scan) {
     *is_valid = false;
-    LOG(ERROR) << ctx.dist->GetAppShortCutName()
+    LOG(ERROR) << ctx.dist->GetDisplayName()
                << " is missing the Google Update product command named \""
                << scan->first << "\".";
   }
 }
 
 // Validates the multi-install binaries' Google Update commands.
 void InstallationValidator::ValidateBinariesCommands(
     const ProductContext& ctx,
     bool* is_valid) {
   DCHECK(is_valid);
@@ skipping 148 matching lines @@
 
   base::FilePath expected_path = installer::GetChromeInstallPath(
       ctx.system_install, bins_dist);
   expected_path = expected_path
       .AppendASCII(ctx.state.version().GetString())
       .Append(installer::kInstallerDir)
       .Append(installer::kSetupExe);
   if (!base::FilePath::CompareEqualIgnoreCase(expected_path.value(),
                                               setup_exe.value())) {
     *is_valid = false;
-    LOG(ERROR) << ctx.dist->GetAppShortCutName() << " path to " << purpose
+    LOG(ERROR) << ctx.dist->GetDisplayName() << " path to " << purpose
                << " is not " << expected_path.value() << ": "
                << setup_exe.value();
   }
 }
 
 // Validates that |command| meets the expectations described in |expected|.
 void InstallationValidator::ValidateCommandExpectations(
     const ProductContext& ctx,
     const CommandLine& command,
     const SwitchExpectations& expected,
     const string16& source,
     bool* is_valid) {
   for (SwitchExpectations::size_type i = 0, size = expected.size(); i < size;
        ++i) {
     const SwitchExpectations::value_type& expectation = expected[i];
     if (command.HasSwitch(expectation.first) != expectation.second) {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName() << " " << source
+      LOG(ERROR) << ctx.dist->GetDisplayName() << " " << source
                  << (expectation.second ? " is missing" : " has") << " \""
                  << expectation.first << "\""
                  << (expectation.second ? "" : " but shouldn't") << ": "
                  << command.GetCommandLineString();
     }
   }
 }
 
 // Validates that |command|, originating from |source|, is formed properly for
 // the product described by |ctx|
@@ skipping 46 matching lines @@
 // Validates the "opv" and "cmd" values for the product described in |ctx|.
 void InstallationValidator::ValidateOldVersionValues(
     const ProductContext& ctx,
     bool* is_valid) {
   DCHECK(is_valid);
 
   // opv and cmd must both be present or both absent
   if (ctx.state.old_version() == NULL) {
     if (!ctx.state.rename_cmd().empty()) {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << ctx.dist->GetDisplayName()
                  << " has a rename command but no opv: "
                  << ctx.state.rename_cmd();
     }
   } else {
     if (ctx.state.rename_cmd().empty()) {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << ctx.dist->GetDisplayName()
                  << " has an opv but no rename command: "
                  << ctx.state.old_version()->GetString();
     } else {
       ValidateRenameCommand(ctx, is_valid);
     }
   }
 }
 
 // Validates the multi-install state of the product described in |ctx|.
 void InstallationValidator::ValidateMultiInstallProduct(
     const ProductContext& ctx,
     bool* is_valid) {
   DCHECK(is_valid);
 
   const ProductState* binaries =
       ctx.machine_state.GetProductState(ctx.system_install,
                                         BrowserDistribution::CHROME_BINARIES);
   if (!binaries) {
     if (ctx.dist->GetType() == BrowserDistribution::CHROME_APP_HOST) {
       if (!ctx.machine_state.GetProductState(
               true,  // system-level
               BrowserDistribution::CHROME_BINARIES) &&
           !ctx.machine_state.GetProductState(
               true,  // system-level
               BrowserDistribution::CHROME_BROWSER)) {
         *is_valid = false;
-        LOG(ERROR) << ctx.dist->GetAppShortCutName()
+        LOG(ERROR) << ctx.dist->GetDisplayName()
                    << " (" << ctx.state.version().GetString() << ") is "
                    << "installed without Chrome Binaries or a system-level "
                    << "Chrome.";
       }
     } else {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << ctx.dist->GetDisplayName()
                  << " (" << ctx.state.version().GetString() << ") is installed "
                  << "without Chrome Binaries.";
     }
   } else {
     // Version must match that of binaries.
     if (ctx.state.version().CompareTo(binaries->version()) != 0) {
       *is_valid = false;
-      LOG(ERROR) << "Version of " << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << "Version of " << ctx.dist->GetDisplayName()
                  << " (" << ctx.state.version().GetString() << ") does not "
                     "match that of Chrome Binaries ("
                  << binaries->version().GetString() << ").";
     }
 
     // Channel value must match that of binaries.
     if (!ctx.state.channel().Equals(binaries->channel())) {
       *is_valid = false;
-      LOG(ERROR) << "Channel name of " << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << "Channel name of " << ctx.dist->GetDisplayName()
                  << " (" << ctx.state.channel().value()
                  << ") does not match that of Chrome Binaries ("
                  << binaries->channel().value() << ").";
     }
   }
 }
 
 // Validates the Google Update commands for the product described in |ctx|.
 void InstallationValidator::ValidateAppCommands(
     const ProductContext& ctx,
@@ skipping 13 matching lines @@
   ValidateAppCommandExpectations(ctx, expectations, is_valid);
 }
 
 // Validates usagestats for the product or binaries in |ctx|.
 void InstallationValidator::ValidateUsageStats(const ProductContext& ctx,
                                                bool* is_valid) {
   DWORD usagestats = 0;
   if (ctx.state.GetUsageStats(&usagestats)) {
     if (!ctx.rules.UsageStatsAllowed(ctx)) {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << ctx.dist->GetDisplayName()
                  << " has a usagestats value (" << usagestats
                  << "), yet should not.";
     } else if (usagestats != 0 && usagestats != 1) {
       *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetAppShortCutName()
+      LOG(ERROR) << ctx.dist->GetDisplayName()
                  << " has an unsupported usagestats value (" << usagestats
                  << ").";
     }
   }
 }
 
 // Validates the product described in |product_state| according to |rules|.
 void InstallationValidator::ValidateProduct(
     const InstallationState& machine_state,
     bool system_install,
@@ skipping 99 matching lines @@
                                                      InstallationType* type) {
   DCHECK(type);
   InstallationState machine_state;
 
   machine_state.Initialize();
 
   return ValidateInstallationTypeForState(machine_state, system_level, type);
 }
 
 }  // namespace installer