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

[grt (UTC plus 2), 2014/10/01 16:28:38]

instead of "unique internal name," which doesn't say much, just call it a ProgID
or programmatic identifier, which has meaning to all Windows developers and can
be found via search.

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

Done.

+    // 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.
+    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.

[grt (UTC plus 2), 2014/10/01 16:28:38]

should or must? what happens if it doesn't?

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

Then the filename won't get passed as an argument. This still qualifies as
"should" in my mind, because it still works if you don't do it, it just might
not do what you want.

Reworded slightly.

+    // 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

[grt (UTC plus 2), 2014/10/01 16:28:38]

where possible, please use the same terminology as MSDN so that it's easy to
search to find out what these things really mean. in this case, this value is
the AppUserModelID
(http://msdn.microsoft.com/library/windows/desktop/dd378459.aspx).

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

Done.

+    // 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;
+
+    // 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.

[grt (UTC plus 2), 2014/10/01 16:28:38]

    // The CLSID for the application's DelegateExecute handler.

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

Done.

+    base::string16 delegate_guid;

[grt (UTC plus 2), 2014/10/01 16:28:38]

delegate_clsid

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

Done.

+    // 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) {
+    int chrome_icon_index =
+        dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME);
+
+    ApplicationInfo app_info;
+    app_info.prog_id = GetBrowserProgId(suffix);
+    app_info.file_type_name = dist->GetBrowserProgIdDesc();
+    // File types associated with Chrome are just given the Chrome icon.
+    app_info.file_type_icon_path = chrome_exe;
+    app_info.file_type_icon_index = chrome_icon_index;
+    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);
+
+    // TODO(grt): http://crbug.com/75152 Write a reference to a localized
+    // resource for name, description, and company.
+    app_info.application_name = dist->GetDisplayName();
+    app_info.application_icon_path = chrome_exe;
+    app_info.application_icon_index = chrome_icon_index;
+    app_info.application_description = dist->GetAppDescription();
+    app_info.publisher_name = dist->GetPublisherName();
+
+    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);

[grt (UTC plus 2), 2014/10/01 16:28:38]

DCHECK_NE(std::string16(), app_info.app_id);
and other fields that need to be set to register the DEx handler

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

No longer applies (reverted all this code).

       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()));
         }
+        // TODO(mgiuca): Generalize this or move it into the Chrome-specific
+        // code. DO NOT SUBMIT.

[grt (UTC plus 2), 2014/10/01 16:28:38]

DO NOT SUBMIT?

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

It just means I'm planning to do this before submitting. (There's a presubmit
error that prevents the CQ from submitting it if it contains the string "DO NOT
SUBMIT" to make sure I remember to do it.)

[gab, 2014/10/02 13:03:59]

Nice, didn't know about this trick, I was using a more obscure one which
prevents // not followed by a space, e.g.
//FIXME: blah blah
is (or at least was -- I've noticed it not work sometimes) caught by presubmit.

I'll switch to using this, thanks!

PS: Any idea why the code for it [1] uses 'DO NOT ''SUBMIT' rather than simply
'DO NOT SUBMIT'? This would explain why I missed it when doing a quick lookup
for it yesterday.
[1]
https://code.google.com/p/chromium/codesearch#chromium/tools/depot_tools/pres...

         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));
-      // TODO(grt): http://crbug.com/75152 Write a reference to a localized
-      // 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()));
+      // 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)));
+      }
+      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));
+      }
     }
   }
 
   // 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 prog_id.
+    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(
+      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)) {

[grt (UTC plus 2), 2014/10/01 16:28:38]

is HKCU correct here? the comment above says HKCR. maybe the comment should say
"HKEY_CURRENT_USER\Software\Classes\EXT" if that's what is really meant.

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

Done.

+      entries->push_back(default_association.release());
+    }
+  }
+
   // 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 {
+    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;

[grt (UTC plus 2), 2014/10/01 16:28:38]

DCHECK that command_line contains %1?

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

I don't know if we want that. It's still a valid file association, it just
probably won't do what you want. It doesn't feel right for this code to enforce
that your command line conforms to a particular pattern.

+
+  // 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) {
+    // TODO(mgiuca): Do we allow empty file extensions?
+    // TODO(mgiuca): Do we allow file extensions with a '.' in them?
+    DCHECK(!it->empty());
+    DCHECK((*it)[0] != L'.');
+    base::string16 ext(1, L'.');
+    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);
+
+  // TODO(mgiuca): Remove the extension association entries. This requires that
+  // the extensions associated with a particular prog_id are stored in that
+  // prog_id's key.
+}