On user-level Chrome self-destruct, make user-created shortcuts target system-level chrome.exe.

chrome/installer/util/shell_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.
 //
 // This file defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include "chrome/installer/util/shell_util.h"
@@ skipping 1185 matching lines @@
   return true;
 }
 
 // Shortcut filters for BatchShortcutAction().
 
 typedef base::Callback<bool(const base::FilePath& /*shortcut_path*/,
                             const string16& /*args*/)>
     ShortcutFilterCallback;
 
 // FilterTargetEq is a shortcut filter that matches only shortcuts that have a
-// specific target.
+// specific target, and optionally matches shortcuts that have non-empty
+// arguments.
 class FilterTargetEq {
  public:
-  explicit FilterTargetEq(const base::FilePath& desired_target_exe);
+  FilterTargetEq(const base::FilePath& desired_target_exe, bool require_args);
 
   // Returns true if filter rules are satisfied, i.e.:
-  // - |target_path| matches |desired_target_compare_|.
+  // - |target_path|'s target == |desired_target_compare_|, and
+  // - |args| is non-empty (if |require_args_| == true).
   bool Match(const base::FilePath& target_path, const string16& args) const;
 
   // A convenience routine to create a callback to call Match().
   // The callback is only valid during the lifetime of the FilterTargetEq
   // instance.
   ShortcutFilterCallback AsShortcutFilterCallback();
 
  private:
   InstallUtil::ProgramCompare desired_target_compare_;
+
+  bool require_args_;
 };
 
-FilterTargetEq::FilterTargetEq(const base::FilePath& desired_target_exe)
-    : desired_target_compare_(desired_target_exe) {}
+FilterTargetEq::FilterTargetEq(const base::FilePath& desired_target_exe,
+                               bool require_args)
+    : desired_target_compare_(desired_target_exe),
+      require_args_(require_args) {}
 
 bool FilterTargetEq::Match(const base::FilePath& target_path,
                            const string16& args) const {
-  return desired_target_compare_.EvaluatePath(target_path);
+  if (!desired_target_compare_.EvaluatePath(target_path))
+    return false;
+  if (require_args_ && args.empty())
+    return false;
+  return true;
 }
 
 ShortcutFilterCallback FilterTargetEq::AsShortcutFilterCallback() {
   return base::Bind(&FilterTargetEq::Match, base::Unretained(this));
 }
 
 // Shortcut operations for BatchShortcutAction().
 
 typedef base::Callback<bool(const base::FilePath& /*shortcut_path*/)>
     ShortcutOperationCallback;
@@ skipping 795 matching lines @@
 }
 
 // static
 bool ShellUtil::RemoveShortcuts(ShellUtil::ShortcutLocation location,
                                 BrowserDistribution* dist,
                                 ShellChange level,
                                 const base::FilePath& target_exe) {
   if (!ShellUtil::ShortcutLocationIsSupported(location))
     return true;  // Vacuous success.
 
-  FilterTargetEq shortcut_filter(target_exe);
+  FilterTargetEq shortcut_filter(target_exe, false);
   // Main operation to apply to each shortcut in the directory specified.
   ShortcutOperationCallback shortcut_operation(
       location == SHORTCUT_LOCATION_TASKBAR_PINS ?
           base::Bind(&ShortcutOpUnpin) : base::Bind(&ShortcutOpDelete));
   bool success = BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                                      shortcut_operation, location, dist, level);
   // Remove chrome-specific shortcut folders if they are now empty.
   if (success &&
       (location == SHORTCUT_LOCATION_START_MENU ||
        location == SHORTCUT_LOCATION_APP_SHORTCUTS)) {
     success = RemoveShortcutFolderIfEmpty(location, dist, level);
   }
   return success;
 }
 
 // static
 bool ShellUtil::UpdateShortcuts(
     ShellUtil::ShortcutLocation location,
     BrowserDistribution* dist,
     ShellChange level,
     const base::FilePath& target_exe,
+    bool require_args,

[gab, 2013/09/09 13:00:31]

I don't see a case where setting |require_args| to false for UpdateShortcuts()
makes sense... how about hardcoding it hardcoded to |false| below.

I find this whole |require_args| argument kind of confusing (I understand now it
is to re-use the same filter for Delete and Update) and would rather at least
keep it internal to ShellUtil.

To test it instead you simply have to make sure that calling RemoveShortcuts
removes all shortcuts (including those without args); while UpdateShortcuts only
updates those with args.

[huangs, 2013/09/11 19:02:52]

The purpose of |require_args| is keep UpdateShortcuts() general; it's rather ad
hoc that our main usage opts to not retarget links without args (so we will not
have duplicate shortcuts). 

To follow he suggestion, I'm removing |require_args|, and renaming
UpdateShortcuts() to UpdateShortcutsWithArgs() to be explicit. The test cases
would also need to be changed (dummy arguments need to be added).

[gab, 2013/09/11 20:23:06]

sgtm.

     const ShellUtil::ShortcutProperties& properties) {
   if (!ShellUtil::ShortcutLocationIsSupported(location))
     return true;  // Vacuous success.
 
-  FilterTargetEq shortcut_filter(target_exe);
+  FilterTargetEq shortcut_filter(target_exe, require_args);
   ShortcutOperationCallback shortcut_operation(
       base::Bind(&ShortcutOpUpdate, TranslateShortcutProperties(properties)));
   return BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                              shortcut_operation, location, dist, level);
 }
 
 bool ShellUtil::GetUserSpecificRegistrySuffix(string16* suffix) {
   // Use a thread-safe cache for the user's suffix.
   static base::LazyInstance<UserSpecificRegistrySuffix>::Leaky suffix_instance =
       LAZY_INSTANCE_INITIALIZER;
@@ skipping 53 matching lines @@
     // are any left...).
     if (free_bits >= 8 && next_byte_index < size) {
       free_bits -= 8;
       bit_stream += bytes[next_byte_index++] << free_bits;
     }
   }
 
   DCHECK_EQ(ret.length(), encoded_length);
   return ret;
 }