ShellUtil: Add generic methods to add/delete Windows file associations.

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 173 matching lines @@
 // class.
 class RegistryEntry {
  public:
   // A bit-field enum of places to look for this key in the Windows registry.
   enum LookForIn {
     LOOK_IN_HKCU = 1 << 0,
     LOOK_IN_HKLM = 1 << 1,
     LOOK_IN_HKCU_THEN_HKLM = LOOK_IN_HKCU | LOOK_IN_HKLM,
   };
 
+  // Details about a Windows application, to be entered into the registry for
+  // the purpose of file associations.
+  struct ApplicationInfo {
+    ApplicationInfo()
+        : set_delegate_execute(false),
+          file_type_icon_index(0),
+          application_icon_index(0) {}
+
+    // The unique internal name Windows will use for file associations with this
+    // application.
+    base::string16 prog_id;
+    // The friendly name, and the path of the icon that will be used for files
+    // of these types when associated with this application by default. (They
+    // are NOT the name/icon that will represent the application under the Open
+    // With menu.)
+    base::string16 file_type_name;
+    // TODO(mgiuca): |file_type_icon_path| should be a base::FilePath.

[gab, 2014/09/12 13:32:37]

Agreed as that makes types more explicit, what prevents you from doing this now
(is it just a matter of avoiding extra plumbing in this first CL)?

[Matt Giuca, 2014/09/15 03:49:46]

Yes, I want to avoid touching heaps of other code in this CL. I'm happy to do it
in a follow-up. It's a simple change but touches a lot of things. Ditto for the
|command_line| one.

+    base::string16 file_type_icon_path;
+    int file_type_icon_index;
+    // The command to execute when opening a file via this association. It
+    // should contain "%1" to pass the filename as an argument.
+    // TODO(mgiuca): |command_line| should be a base::CommandLine.
+    base::string16 command_line;
+    // The unique internal name used by Windows 8 for this application. Distinct
+    // from |prog_id|. May be empty.
+    base::string16 app_id;
+
+    // User-visible details about this application. Any of these may be empty.
+    base::string16 application_name;
+    // TODO(mgiuca): |application_icon_path| should be a base::FilePath.
+    base::string16 application_icon_path;
+    int application_icon_index;
+    base::string16 application_description;
+    base::string16 publisher_name;

[gab, 2014/09/12 13:32:37]

This is the core info, I'd say put this block first in the struct.

[Matt Giuca, 2014/09/15 03:49:46]

What do you mean by "core info"? All of this is optional, and it's also ignored
before Win8. The most important info is in the first block.

+
+    // Whether the application will have a DelegateExecute key. This should only
+    // be used by Windows 8 Metro web browsers (i.e. Chrome itself). All other
+    // fields in this section are ignored if this is false.
+    bool set_delegate_execute;
+    // A GUID for this application.
+    base::string16 delegate_guid;
+    // The command to execute when opening this application via the Metro UI.
+    base::string16 delegate_command;
+  };
+
   // Returns the Windows browser client registration key for Chrome.  For
   // example: "Software\Clients\StartMenuInternet\Chromium[.user]".  Strictly
   // speaking, we should use the name of the executable (e.g., "chrome.exe"),
   // but that ship has sailed.  The cost of switching now is re-prompting users
   // to make Chrome their default browser, which isn't polite.  |suffix| is the
   // user-specific registration suffix; see GetUserSpecificDefaultBrowserSuffix
   // in shell_util.h for details.
   static base::string16 GetBrowserClientKey(BrowserDistribution* dist,
                                             const base::string16& suffix) {
     DCHECK(suffix.empty() || suffix[0] == L'.');
     return base::string16(ShellUtil::kRegStartMenuInternet)
         .append(1, L'\\')
         .append(dist->GetBaseAppName())
         .append(suffix);
   }
 
   // Returns the Windows Default Programs capabilities key for Chrome.  For
   // example:
   // "Software\Clients\StartMenuInternet\Chromium[.user]\Capabilities".
   static base::string16 GetCapabilitiesKey(BrowserDistribution* dist,
                                            const base::string16& suffix) {
     return GetBrowserClientKey(dist, suffix).append(L"\\Capabilities");
   }
 
   // This method returns a list of all the registry entries that
   // are needed to register this installation's ProgId and AppId.
   // These entries need to be registered in HKLM prior to Win8.
-  static void GetProgIdEntries(BrowserDistribution* dist,
-                               const base::string16& chrome_exe,
-                               const base::string16& suffix,
-                               ScopedVector<RegistryEntry>* entries) {
-    base::string16 icon_path(
-        ShellUtil::FormatIconLocation(
-            chrome_exe,
-            dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME)));
-    base::string16 open_cmd(ShellUtil::GetChromeShellOpenCmd(chrome_exe));
-    base::string16 delegate_command(
-        ShellUtil::GetChromeDelegateCommand(chrome_exe));
-    // For user-level installs: entries for the app id and DelegateExecute verb
-    // handler will be in HKCU; thus we do not need a suffix on those entries.
-    base::string16 app_id(
-        ShellUtil::GetBrowserModelId(
-            dist, InstallUtil::IsPerUserInstall(chrome_exe.c_str())));
-    base::string16 delegate_guid;
-    bool set_delegate_execute =
-        IsChromeMetroSupported() &&
-        dist->GetCommandExecuteImplClsid(&delegate_guid);
+  static void GetChromeProgIdEntries(BrowserDistribution* dist,
+                                     const base::string16& chrome_exe,
+                                     const base::string16& suffix,
+                                     ScopedVector<RegistryEntry>* entries) {
+    ApplicationInfo app_info;
+    app_info.prog_id = GetBrowserProgId(suffix);
+    app_info.file_type_name = dist->GetBrowserProgIdDesc();
+    app_info.file_type_icon_path = chrome_exe;
+    app_info.file_type_icon_index =
+        dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME);
+    app_info.command_line = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
+    // For user-level installs: entries for the app id will be in HKCU; thus we
+    // do not need a suffix on those entries.
+    app_info.app_id = ShellUtil::GetBrowserModelId(
+        dist, InstallUtil::IsPerUserInstall(chrome_exe.c_str()));
 
     // DelegateExecute ProgId. Needed for Chrome Metro in Windows 8.
-    if (set_delegate_execute) {
+    app_info.delegate_command = ShellUtil::GetChromeDelegateCommand(chrome_exe);
+    app_info.set_delegate_execute =
+        IsChromeMetroSupported() &&
+        dist->GetCommandExecuteImplClsid(&app_info.delegate_guid);
+
+    // The Chrome app icon path is the same as its file type path.
+    app_info.application_name = dist->GetDisplayName();
+    app_info.application_icon_path = app_info.file_type_icon_path;
+    app_info.application_icon_index = app_info.file_type_icon_index;
+    app_info.application_description = dist->GetAppDescription();
+    app_info.publisher_name = dist->GetPublisherName();

[gab, 2014/09/12 13:32:36]

As mentioned above, put this information first (and initialize all other members
of the struct in the same order they're declared in the struct (makes it easier
to see that nothing was missed).

Also, I'd say it's more "The file type icon is the same as the Chrome app icon."
-- i.e., the most likely to change one day would be the file type path, not the
app icon path.

[Matt Giuca, 2014/09/15 03:49:46]

See comment above.

OK I've done the latter suggestion. (Also filed bug: http://crbug.com/414141.)

+
+    GetProgIdEntries(app_info, entries);
+  }
+
+  // Gets the registry entries to register an application in the Windows
+  // registry. |app_info| provides all of the information needed.
+  static void GetProgIdEntries(const ApplicationInfo& app_info,
+                               ScopedVector<RegistryEntry>* entries) {
+    if (app_info.set_delegate_execute) {
       base::string16 model_id_shell(ShellUtil::kRegClasses);
       model_id_shell.push_back(base::FilePath::kSeparators[0]);
-      model_id_shell.append(app_id);
+      model_id_shell.append(app_info.app_id);
       model_id_shell.append(ShellUtil::kRegExePath);
       model_id_shell.append(ShellUtil::kRegShellPath);
 
       // <root hkey>\Software\Classes\<app_id>\.exe\shell @=open
       entries->push_back(new RegistryEntry(model_id_shell,
                                            ShellUtil::kRegVerbOpen));
 
-      // Each of Chrome's shortcuts has an appid; which, as of Windows 8, is
-      // registered to handle some verbs. This registration has the side-effect
-      // that these verbs now show up in the shortcut's context menu. We
-      // mitigate this side-effect by making the context menu entries
-      // user readable/localized strings. See relevant MSDN article:
+      // Each shortcut has an appid; which, as of Windows 8, is registered to
+      // handle some verbs. This registration has the side-effect that these
+      // verbs now show up in the shortcut's context menu. We mitigate this
+      // side-effect by making the context menu entries user readable/localized
+      // strings. See relevant MSDN article:
       // http://msdn.microsoft.com/en-US/library/windows/desktop/cc144171.aspx
       const struct {
         const wchar_t* verb;
         int name_id;
       } verbs[] = {
           { ShellUtil::kRegVerbOpen, -1 },
           { ShellUtil::kRegVerbOpenNewWindow, IDS_SHORTCUT_NEW_WINDOW_BASE },
       };
       for (size_t i = 0; i < arraysize(verbs); ++i) {
         base::string16 sub_path(model_id_shell);
         sub_path.push_back(base::FilePath::kSeparators[0]);
         sub_path.append(verbs[i].verb);
 
         // <root hkey>\Software\Classes\<app_id>\.exe\shell\<verb>
         if (verbs[i].name_id != -1) {
           // TODO(grt): http://crbug.com/75152 Write a reference to a localized
           // resource.
           base::string16 verb_name(
               installer::GetLocalizedString(verbs[i].name_id));
           entries->push_back(new RegistryEntry(sub_path, verb_name.c_str()));
         }
         entries->push_back(new RegistryEntry(
             sub_path, L"CommandId", L"Browser.Launch"));
 
         sub_path.push_back(base::FilePath::kSeparators[0]);
         sub_path.append(ShellUtil::kRegCommand);
 
         // <root hkey>\Software\Classes\<app_id>\.exe\shell\<verb>\command
-        entries->push_back(new RegistryEntry(sub_path, delegate_command));
+        entries->push_back(
+            new RegistryEntry(sub_path, app_info.delegate_command));
         entries->push_back(new RegistryEntry(
-            sub_path, ShellUtil::kRegDelegateExecute, delegate_guid));
+            sub_path, ShellUtil::kRegDelegateExecute, app_info.delegate_guid));
       }
     }
 
     // File association ProgId
-    base::string16 chrome_html_prog_id(ShellUtil::kRegClasses);
-    chrome_html_prog_id.push_back(base::FilePath::kSeparators[0]);
-    chrome_html_prog_id.append(GetBrowserProgId(suffix));
+    base::string16 prog_id_path(ShellUtil::kRegClasses);
+    prog_id_path.push_back(base::FilePath::kSeparators[0]);
+    prog_id_path.append(app_info.prog_id);
+    entries->push_back(
+        new RegistryEntry(prog_id_path, app_info.file_type_name));
     entries->push_back(new RegistryEntry(
-        chrome_html_prog_id, dist->GetBrowserProgIdDesc()));
+        prog_id_path + ShellUtil::kRegDefaultIcon,
+        ShellUtil::FormatIconLocation(app_info.file_type_icon_path,
+                                      app_info.file_type_icon_index)));
     entries->push_back(new RegistryEntry(
-        chrome_html_prog_id + ShellUtil::kRegDefaultIcon, icon_path));
-    entries->push_back(new RegistryEntry(
-        chrome_html_prog_id + ShellUtil::kRegShellOpen, open_cmd));
-    if (set_delegate_execute) {
-      entries->push_back(new RegistryEntry(
-          chrome_html_prog_id + ShellUtil::kRegShellOpen,
-          ShellUtil::kRegDelegateExecute, delegate_guid));
+        prog_id_path + ShellUtil::kRegShellOpen, app_info.command_line));
+    if (app_info.set_delegate_execute) {
+      entries->push_back(
+          new RegistryEntry(prog_id_path + ShellUtil::kRegShellOpen,
+                            ShellUtil::kRegDelegateExecute,
+                            app_info.delegate_guid));
     }
 
     // The following entries are required as of Windows 8, but do not
     // depend on the DelegateExecute verb handler being set.
     if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
-      entries->push_back(new RegistryEntry(
-          chrome_html_prog_id, ShellUtil::kRegAppUserModelId, app_id));
+      if (!app_info.app_id.empty()) {
+        entries->push_back(new RegistryEntry(
+            prog_id_path, ShellUtil::kRegAppUserModelId, app_info.app_id));
+      }
 
-      // Add \Software\Classes\ChromeHTML\Application entries
-      base::string16 chrome_application(chrome_html_prog_id +
-                                        ShellUtil::kRegApplication);
-      entries->push_back(new RegistryEntry(
-          chrome_application, ShellUtil::kRegAppUserModelId, app_id));
-      entries->push_back(new RegistryEntry(
-          chrome_application, ShellUtil::kRegApplicationIcon, icon_path));
+      // Add \Software\Classes\<prog_id>\Application entries
+      base::string16 application_path(prog_id_path +
+                                      ShellUtil::kRegApplication);
+      if (!app_info.app_id.empty()) {
+        entries->push_back(new RegistryEntry(
+            application_path, ShellUtil::kRegAppUserModelId, app_info.app_id));
+      }
+      if (!app_info.application_icon_path.empty()) {
+        entries->push_back(new RegistryEntry(
+            application_path,
+            ShellUtil::kRegApplicationIcon,
+            ShellUtil::FormatIconLocation(app_info.application_icon_path,
+                                          app_info.application_icon_index)));
+      }
       // TODO(grt): http://crbug.com/75152 Write a reference to a localized

[gab, 2014/09/12 13:32:36]

This TODO now belongs in the Chrome specific method above.

[Matt Giuca, 2014/09/15 03:49:46]

Done.

       // resource for name, description, and company.
-      entries->push_back(new RegistryEntry(
-          chrome_application, ShellUtil::kRegApplicationName,
-          dist->GetDisplayName()));
-      entries->push_back(new RegistryEntry(
-          chrome_application, ShellUtil::kRegApplicationDescription,
-          dist->GetAppDescription()));
-      entries->push_back(new RegistryEntry(
-          chrome_application, ShellUtil::kRegApplicationCompany,
-          dist->GetPublisherName()));
+      if (!app_info.application_name.empty()) {
+        entries->push_back(new RegistryEntry(application_path,
+                                             ShellUtil::kRegApplicationName,
+                                             app_info.application_name));
+      }
+      if (!app_info.application_description.empty()) {
+        entries->push_back(
+            new RegistryEntry(application_path,
+                              ShellUtil::kRegApplicationDescription,
+                              app_info.application_description));
+      }
+      if (!app_info.publisher_name.empty()) {
+        entries->push_back(new RegistryEntry(application_path,
+                                             ShellUtil::kRegApplicationCompany,
+                                             app_info.publisher_name));
+      }

[gab, 2014/09/12 13:32:36]

Does it really hurt to set those if they're empty? I think it'd be fine and
would make the code smaller.

[Matt Giuca, 2014/09/15 03:49:46]

I don't know, but I could imagine Windows treating it differently if it was
empty vs missing (for example, somewhere it might display the filename if the
ApplicationName is missing, but show an empty string if ApplicationName is "").
I'd rather play it safe and not write empty strings here.

     }
   }
 
   // This method returns a list of the registry entries needed to declare a
   // capability of handling a protocol on Windows.
   static void GetProtocolCapabilityEntries(
       BrowserDistribution* dist,
       const base::string16& suffix,
       const base::string16& protocol,
       ScopedVector<RegistryEntry>* entries) {
@@ skipping 83 matching lines @@
   }
 
   // This method returns a list of the registry entries required for this
   // installation to be registered in the Windows shell.
   // In particular:
   //  - App Paths
   //    http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121
   //  - File Associations
   //    http://msdn.microsoft.com/en-us/library/bb166549
   // These entries need to be registered in HKLM prior to Win8.
-  static void GetAppRegistrationEntries(const base::string16& chrome_exe,
-                                        const base::string16& suffix,
-                                        ScopedVector<RegistryEntry>* entries) {
+  static void GetChromeAppRegistrationEntries(
+      const base::string16& chrome_exe,
+      const base::string16& suffix,
+      ScopedVector<RegistryEntry>* entries) {
     const base::FilePath chrome_path(chrome_exe);
     base::string16 app_path_key(ShellUtil::kAppPathsRegistryKey);
     app_path_key.push_back(base::FilePath::kSeparators[0]);
     app_path_key.append(chrome_path.BaseName().value());
     entries->push_back(new RegistryEntry(app_path_key, chrome_exe));
     entries->push_back(new RegistryEntry(app_path_key,
         ShellUtil::kAppPathsRegistryPathName, chrome_path.DirName().value()));
 
     const base::string16 html_prog_id(GetBrowserProgId(suffix));
     for (int i = 0; ShellUtil::kPotentialFileAssociations[i] != NULL; i++) {
-      base::string16 key(ShellUtil::kRegClasses);
-      key.push_back(base::FilePath::kSeparators[0]);
-      key.append(ShellUtil::kPotentialFileAssociations[i]);
-      key.push_back(base::FilePath::kSeparators[0]);
-      key.append(ShellUtil::kRegOpenWithProgids);
-      entries->push_back(
-          new RegistryEntry(key, html_prog_id, base::string16()));
+      GetAppExtRegistrationEntries(
+          html_prog_id, ShellUtil::kPotentialFileAssociations[i], entries);
     }
   }
 
+  // Gets the registry entries to register an application as a handler for a
+  // particular file extension. |prog_id| is the unique internal name Windows
+  // uses for the application. |ext| is the file extension, which must begin
+  // with a '.'.
+  static void GetAppExtRegistrationEntries(
+      const base::string16& prog_id,
+      const base::string16& ext,
+      ScopedVector<RegistryEntry>* entries) {
+    // In HKEY_CLASSES_ROOT\EXT\OpenWithProgids, create an empty value with this
+    // class's name.

[gab, 2014/09/12 13:32:37]

s/name/prog_id

[Matt Giuca, 2014/09/15 03:49:46]

Done.

+    base::string16 key_name(ShellUtil::kRegClasses);
+    key_name.push_back(base::FilePath::kSeparators[0]);
+    key_name.append(ext);
+    key_name.push_back(base::FilePath::kSeparators[0]);
+    key_name.append(ShellUtil::kRegOpenWithProgids);
+    entries->push_back(new RegistryEntry(key_name, prog_id, base::string16()));
+  }
+
+  // Gets the registry entries to register an application as the default handler
+  // for a particular file extension. |prog_id| is the unique internal name
+  // Windows uses for the application. |ext| is the file extension, which must
+  // begin with a '.'. If |overwrite_existing|, always sets the default handler;
+  // otherwise only sets if there is no existing default.
+  static void GetAppDefaultRegistrationEntries(

[gab, 2014/09/12 13:32:36]

Note in the method name that these are XP style defaults (I don't think they do
anything beyond XP).

[Matt Giuca, 2014/09/15 03:49:45]

They certainly work in Windows 7 (haven't tested in 8). For app registrations,
I'm only using this (not the IApplicationAssociationRegistration interface), and
it's working fine. Is there a reason I should be using both the old and the new
approaches for file type registration?

Anyway I'm happy to rename this to "XPStyle" but I'm wondering if I also need to
use the new interface to register a file type as the default. From my brief
reading of the docs, this new interface (which by the way is deprecated in
Windows 8) is for user-mode apps to register handlers at the system level, which
is not what I want for app registrations, so I think it's fine to continue just
using the XP style.

[gab, 2014/09/18 01:16:15]

You're right that IApplicationAssociationRegistration doesn't work in Win8 as
they changed the entire landscape.

I also didn't think the registry method @ [1] worked post-XP (are you sure it
doesn't just happen to work because there is only one program in the extension
you're testing, making it an implicit default?

In Win8 the registrations + SHCNE_ASSOCCHANGED call will most likely be enough
to give the user a fly-in saying "a new application support file type foo", but
setting the default won't do anything IMO.

[1]
http://msdn.microsoft.com/en-ca/library/windows/desktop/cc144148(v=vs.85).aspx

[Matt Giuca, 2014/09/30 10:21:12]

Where on that page ([1]) does it say it doesn't work post-XP? All I can find is
that it says OpenWithList "is intended only for .exe applications on operating
systems prior to Windows XP". But we aren't using OpenWithList; we're using
OpenWithProgIds.

It certainly does work as expected in Windows 7.

My Windows 8 machine is out of commission at the moment (we recently moved
offices). I will set it up tomorrow. So I can't confirm your question about
making it the implicit default. But from memory, I'm fairly sure last time I
tried it out on Windows 8 I played with setting and unsetting the default in the
registry, and it worked just like in Windows 7.
As I said on the other comment, I haven't seen a fly-in and I don't see any
evidence that setting the default doesn't work. As far as I can tell, this stuff
has not changed since Windows XP or possibly even earlier than that. (However,
again, browser registration is a different story because of how special browsers
are in Windows 8.)

[gab, 2014/10/01 14:31:11]

Browsers are special indeed in that being default handler for HTTP gives super
powers to the application.

But I thought the act of making X default for Y was under the same restricted OS
control for all Ys in Win8 (but I'm happy to be wrong, browsers may very well be
even more special than I thought).

I'd appreciate if you could update the API comments with your findings as you
test this CL on Win8.

[Matt Giuca, 2014/10/02 09:36:33]

I have completed my investigation on Windows 8, and updated the documentation
accordingly.

So you are partly right: Windows 8 *does* ignore the default setting in the
registry (so this function has no effect). However, there is no fly-in upon
SHChangeNotify. Instead, if there is only one handler, it automatically becomes
the default. If there are 2 or more, it prompts the user to choose a default the
first time it is opened.

So for my use case, that is equivalent to calling
GetAppDefaultRegistrationEntries with overwrite_existing=false.

+      const base::string16& prog_id,
+      const base::string16& ext,
+      bool overwrite_existing,
+      ScopedVector<RegistryEntry>* entries) {
+    // Set the default value of HKEY_CLASSES_ROOT\EXT to this class's name.
+    base::string16 key_name(ShellUtil::kRegClasses);
+    key_name.push_back(base::FilePath::kSeparators[0]);
+    key_name.append(ext);
+    scoped_ptr<RegistryEntry> default_association(
+        new RegistryEntry(key_name, prog_id));
+    if (overwrite_existing ||
+        !default_association->KeyExistsInRegistry(RegistryEntry::LOOK_IN_HKCU))
+      entries->push_back(default_association.release());

[gab, 2014/09/12 13:32:36]

nit: {} since conditional is multiline

[Matt Giuca, 2014/09/15 03:49:45]

Done.

+  }
+
   // This method returns a list of all the user level registry entries that
   // are needed to make Chromium the default handler for a protocol on XP.
   static void GetXPStyleUserProtocolEntries(
       const base::string16& protocol,
       const base::string16& chrome_icon,
       const base::string16& chrome_open,
       ScopedVector<RegistryEntry>* entries) {
     // Protocols associations.
     base::string16 url_key(ShellUtil::kRegClasses);
     url_key.push_back(base::FilePath::kSeparators[0]);
@@ skipping 28 matching lines @@
   // we register them anyways as some legacy apps are hardcoded to lookup those
   // values.
   static void GetXPStyleDefaultBrowserUserEntries(
       BrowserDistribution* dist,
       const base::string16& chrome_exe,
       const base::string16& suffix,
       ScopedVector<RegistryEntry>* entries) {
     // File extension associations.
     base::string16 html_prog_id(GetBrowserProgId(suffix));
     for (int i = 0; ShellUtil::kDefaultFileAssociations[i] != NULL; i++) {
-      base::string16 ext_key(ShellUtil::kRegClasses);
-      ext_key.push_back(base::FilePath::kSeparators[0]);
-      ext_key.append(ShellUtil::kDefaultFileAssociations[i]);
-      entries->push_back(new RegistryEntry(ext_key, html_prog_id));
+      GetAppDefaultRegistrationEntries(
+          html_prog_id, ShellUtil::kDefaultFileAssociations[i], true, entries);
     }
 
     // Protocols associations.
     base::string16 chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
     base::string16 chrome_icon =
         ShellUtil::FormatIconLocation(
             chrome_exe,
             dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME));
     for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
       GetXPStyleUserProtocolEntries(ShellUtil::kBrowserProtocolAssociations[i],
@@ skipping 35 matching lines @@
     DCHECK(look_for_in);
 
     RegistryStatus status = DOES_NOT_EXIST;
     if (look_for_in & LOOK_IN_HKCU)
       status = StatusInRegistryUnderRoot(HKEY_CURRENT_USER);
     if (status == DOES_NOT_EXIST && (look_for_in & LOOK_IN_HKLM))
       status = StatusInRegistryUnderRoot(HKEY_LOCAL_MACHINE);
     return status == SAME_VALUE;
   }
 
+  // Checks if the current registry entry exists in \|key_path_|\|name_|,
+  // regardless of value. Same lookup rules as ExistsInRegistry.
+  // Unlike ExistsInRegistry, this returns true if some other value is present
+  // with the same key.
+  bool KeyExistsInRegistry(uint32 look_for_in) const {

[gab, 2014/09/12 13:32:37]

Seems your only caller of this cares only about HKCU, so they could directly do:

StatusInRegistryUnderRoot(HKEY_CURRENT_USER) != DOES_NOT_EXIST

(although I agree this method is nicer as a potential public API if we move
RegistryEntry out of this file)

[Matt Giuca, 2014/09/15 03:49:46]

I think for the latter reason that it's best to keep this abstraction. (It's
better for consistency with ExistsInRegistry).

+    DCHECK(look_for_in);
+
+    RegistryStatus status = DOES_NOT_EXIST;
+    if (look_for_in & LOOK_IN_HKCU)
+      status = StatusInRegistryUnderRoot(HKEY_CURRENT_USER);
+    if (status == DOES_NOT_EXIST && (look_for_in & LOOK_IN_HKLM))
+      status = StatusInRegistryUnderRoot(HKEY_LOCAL_MACHINE);
+    return status != DOES_NOT_EXIST;
+  }
+
  private:
   // States this RegistryKey can be in compared to the registry.
   enum RegistryStatus {
     // |name_| does not exist in the registry
     DOES_NOT_EXIST,
     // |name_| exists, but its value != |value_|
     DIFFERENT_VALUE,
     // |name_| exists and its value is |value_|
     SAME_VALUE,
   };
@@ skipping 93 matching lines @@
 // under a single registry root. Not doing so caused http://crbug.com/144910 for
 // users who first-installed Chrome in that revision range (those users are
 // still impacted by http://crbug.com/144910). This method will keep returning
 // true for affected users (i.e. who have all the registrations, but over both
 // registry roots).
 bool IsChromeRegistered(BrowserDistribution* dist,
                         const base::string16& chrome_exe,
                         const base::string16& suffix,
                         uint32 look_for_in) {
   ScopedVector<RegistryEntry> entries;
-  RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &entries);
+  RegistryEntry::GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
   RegistryEntry::GetShellIntegrationEntries(dist, chrome_exe, suffix, &entries);
-  RegistryEntry::GetAppRegistrationEntries(chrome_exe, suffix, &entries);
+  RegistryEntry::GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
   return AreEntriesRegistered(entries, look_for_in);
 }
 
 // This method checks if Chrome is already registered on the local machine
 // for the requested protocol. It just checks the one value required for this.
 // See RegistryEntry::ExistsInRegistry for the behavior of |look_for_in|.
 bool IsChromeRegisteredForProtocol(BrowserDistribution* dist,
                                    const base::string16& suffix,
                                    const base::string16& protocol,
                                    uint32 look_for_in) {
@@ skipping 1364 matching lines @@
   // Check if chrome is already registered with this suffix.
   if (IsChromeRegistered(dist, chrome_exe, suffix, look_for_in))
     return true;
 
   bool result = true;
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // Do the full registration if we can do it at user-level or if the user is
     // an admin.
     ScopedVector<RegistryEntry> progid_and_appreg_entries;
     ScopedVector<RegistryEntry> shell_entries;
-    RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix,
-                                    &progid_and_appreg_entries);
-    RegistryEntry::GetAppRegistrationEntries(chrome_exe, suffix,
-                                             &progid_and_appreg_entries);
+    RegistryEntry::GetChromeProgIdEntries(
+        dist, chrome_exe, suffix, &progid_and_appreg_entries);
+    RegistryEntry::GetChromeAppRegistrationEntries(
+        chrome_exe, suffix, &progid_and_appreg_entries);
     RegistryEntry::GetShellIntegrationEntries(
         dist, chrome_exe, suffix, &shell_entries);
     result = (AddRegistryEntries(root, progid_and_appreg_entries) &&
               AddRegistryEntries(root, shell_entries));
   } else if (elevate_if_not_admin &&
       base::win::GetVersion() >= base::win::VERSION_VISTA &&
       ElevateAndRegisterChrome(dist, chrome_exe, suffix, base::string16())) {
     // If the user is not an admin and OS is between Vista and Windows 7
     // inclusively, try to elevate and register. This is only intended for
     // user-level installs as system-level installs should always be run with
     // admin rights.
     result = true;
   } else {
     // If we got to this point then all we can do is create ProgId and basic app
     // registrations under HKCU.
     ScopedVector<RegistryEntry> entries;
-    RegistryEntry::GetProgIdEntries(
+    RegistryEntry::GetChromeProgIdEntries(
         dist, chrome_exe, base::string16(), &entries);
     // Prefer to use |suffix|; unless Chrome's ProgIds are already registered
     // with no suffix (as per the old registration style): in which case some
     // other registry entries could refer to them and since we were not able to
     // set our HKLM entries above, we are better off not altering these here.
     if (!AreEntriesRegistered(entries, RegistryEntry::LOOK_IN_HKCU)) {
       if (!suffix.empty()) {
         entries.clear();
-        RegistryEntry::GetProgIdEntries(dist, chrome_exe, suffix, &entries);
-        RegistryEntry::GetAppRegistrationEntries(chrome_exe, suffix, &entries);
+        RegistryEntry::GetChromeProgIdEntries(
+            dist, chrome_exe, suffix, &entries);
+        RegistryEntry::GetChromeAppRegistrationEntries(
+            chrome_exe, suffix, &entries);
       }
       result = AddRegistryEntries(HKEY_CURRENT_USER, entries);
     } else {
       // The ProgId is registered unsuffixed in HKCU, also register the app with
       // Windows in HKCU (this was not done in the old registration style and
       // thus needs to be done after the above check for the unsuffixed
       // registration).
       entries.clear();
-      RegistryEntry::GetAppRegistrationEntries(chrome_exe, base::string16(),
-                                               &entries);
+      RegistryEntry::GetChromeAppRegistrationEntries(
+          chrome_exe, base::string16(), &entries);
       result = AddRegistryEntries(HKEY_CURRENT_USER, entries);
     }
   }
   SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
   return result;
 }
 
 bool ShellUtil::RegisterChromeForProtocol(BrowserDistribution* dist,
                                           const base::string16& chrome_exe,
                                           const base::string16& unique_suffix,
@@ skipping 168 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;
 }
+
+// static
+bool ShellUtil::AddFileAssociations(
+    const base::string16& progid,
+    const base::CommandLine& command_line,
+    const base::string16& file_type_name,
+    const base::FilePath& icon_path,
+    const std::set<base::string16>& file_extensions) {
+  ScopedVector<RegistryEntry> entries;
+
+  // Create a class for this app.
+  RegistryEntry::ApplicationInfo app_info;
+  app_info.prog_id = progid;
+  app_info.file_type_name = file_type_name;
+  app_info.file_type_icon_path = icon_path.value();
+  app_info.file_type_icon_index = 0;
+  app_info.command_line = command_line.GetCommandLineString();
+  RegistryEntry::GetProgIdEntries(app_info, &entries);
+
+  // Associate each extension that the app can handle with the class. Set this
+  // app as the default handler if and only if there is no existing default.
+  for (std::set<base::string16>::const_iterator it = file_extensions.begin();
+       it != file_extensions.end();
+       ++it) {
+    base::string16 ext(1, L'.');

[gab, 2014/09/12 13:32:36]

Add this check above.

DCHECK(!it->empty() && (*it)[0] != L'.');

[Matt Giuca, 2014/09/15 03:49:46]

Done.

+    ext.append(*it);
+    RegistryEntry::GetAppExtRegistrationEntries(progid, ext, &entries);
+    RegistryEntry::GetAppDefaultRegistrationEntries(
+        progid, ext, false, &entries);
+  }
+
+  return AddRegistryEntries(HKEY_CURRENT_USER, entries);
+}
+
+// static
+bool ShellUtil::DeleteFileAssociations(const base::string16& progid) {
+  // Delete the key HKEY_CLASSES_ROOT\PROGID.
+  base::string16 key_path(ShellUtil::kRegClasses);
+  key_path.push_back(base::FilePath::kSeparators[0]);
+  key_path.append(progid);
+  return InstallUtil::DeleteRegistryKey(
+      HKEY_CURRENT_USER, key_path, WorkItem::kWow64Default);
+
+  // Note: there is no need to remove the association from the extension to the
+  // class, as Windows will ignore it. See:
+  // http://msdn.microsoft.com/en-us/library/windows/desktop/cc144148.aspx

[gab, 2014/09/12 13:32:37]

Right but you should still delete the OpenWith registrations (i.e.
GetAppExt...()).

[Matt Giuca, 2014/09/15 03:49:46]

While that document doesn't say *not* to remove those associations, it doesn't
hurt to leave them (I've tested it, and Windows ignores it if the class has been
removed).

Jack originally suggested (in comment #4) that we record a list of all
extensions in the progid key, so that later we can go to each extension and
delete its association.

Without doing that, we can't delete the association from each extension without
doing a linear scan through the entire list of classes. I think I'll take Jack's
advice but I don't want to do it in this CL (which is OK because we're not using
this code just yet).

Added a TODO.

[gab, 2014/09/18 01:16:15]

The documentation *does* explicitly say that these should be removed: "When
uninstalling an application, the ProgIDs and most other registry information
associated with that application should be deleted as part of the
uninstallation." @
http://msdn.microsoft.com/en-ca/library/windows/desktop/cc144148(v=vs.85).asp...

I don't think recording extra state about what needs to be cleaned is necessary.
The registry lives in memory on Windows and iterating through it to find what
you need to remove is most likely not a problem (we do much worse already; on
uninstall we iterate over all shortcuts on disk in known locations to delete the
ones pointing to our chrome.exe; this requires IO over an unbounded amount of
files...).

[Matt Giuca, 2014/09/30 10:21:12]

But remember I will be calling this code far more frequently than when
uninstalling Chrome. It will be whenever an app is removed, which could be
triggered by sync and could be done in bulk. I don't think that iterating over
every single key in HKEY_CLASSES_ROOT is a good idea in this situation. Far
better to keep our own index so we can delete exactly what we need.

[gab, 2014/10/01 14:31:11]

Ok fair enough, but I still think we should remove them, so this TODO should be
handled shortly after landing this CL.

[Matt Giuca, 2014/10/02 09:36:33]

Acknowledged.

+}