Windows: Automatically associate file types with Chrome apps.

chrome/browser/web_applications/web_app_win.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/browser/web_applications/web_app_win.h"
 
 #include <shlobj.h>
 
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/path_service.h"
+#include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/web_applications/update_shortcut_worker_win.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/common/extension.h"
+#include "net/base/mime_util.h"
 #include "ui/base/win/shell.h"
 #include "ui/gfx/icon_util.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_family.h"
 
 namespace {
 
 const base::FilePath::CharType kIconChecksumFileExt[] =
     FILE_PATH_LITERAL(".ico.md5");
 
+const base::FilePath::CharType kWinAppShimExe[] =
+    FILE_PATH_LITERAL("win_app_shim.exe");
+
 // Calculates checksum of an icon family using MD5.
 // The checksum is derived from all of the icons in the family.
 void GetImageCheckSum(const gfx::ImageFamily& image, base::MD5Digest* digest) {
   DCHECK(digest);
   base::MD5Context md5_context;
   base::MD5Init(&md5_context);
 
   for (gfx::ImageFamily::const_iterator it = image.begin(); it != image.end();
        ++it) {
     SkBitmap bitmap = it->AsBitmap();
@@ skipping 309 matching lines @@
     HWND hwnd,
     const web_app::ShortcutInfo& shortcut_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Set window's icon to the one we're about to create/update in the web app
   // path. The icon cache will refresh on icon creation.
   base::FilePath web_app_path =
       web_app::GetWebAppDataDirectory(shortcut_info.profile_path,
                                       shortcut_info.extension_id,
                                       shortcut_info.url);
-  base::FilePath icon_file =
-      web_app_path.Append(web_app::internals::GetSanitizedFileName(
-                              shortcut_info.title))
-          .ReplaceExtension(FILE_PATH_LITERAL(".ico"));
-
+  base::FilePath icon_file = GetIconFilePath(web_app_path, shortcut_info.title);
   content::BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&CreateIconAndSetRelaunchDetails,
                  web_app_path,
                  icon_file,
                  shortcut_info,
                  hwnd));
 }
 
+// Creates an "app shim exe" by linking or copying the generic app shim exe.
+// This is the binary that will be run when the user opens a file with this
+// application. The name and icon of the binary will be used on the Open With
+// menu. For this reason, we cannot simply launch chrome.exe. We give the app
+// shim exe the same name as the application (with no ".exe" extension), so that
+// the correct title will appear on the Open With menu. (Note: we also need a
+// separate binary per app because Windows only allows a single association with
+// each executable.)
+// |file_name| is the full path of the shim binary to be created.

[jackhou1, 2014/10/27 02:13:28]

Should this say "|path| is the full ..."?

[Matt Giuca, 2014/11/04 06:00:09]

Done.

+bool CreateAppShimBinary(const base::FilePath& path) {
+  // TODO(mgiuca): Hard-link instead of copying, if on the same file system.
+  base::FilePath chrome_binary_directory;
+  if (!PathService::Get(base::DIR_EXE, &chrome_binary_directory)) {
+    NOTREACHED();
+    return false;
+  }
+  base::FilePath generic_shim_path =
+      chrome_binary_directory.Append(kWinAppShimExe);
+  LOG(INFO) << "Copying shim exe from " << generic_shim_path.value() << " to "
+            << path.value();
+  if (!base::CopyFile(generic_shim_path, path)) {
+    LOG(ERROR) << "Could not copy app shim exe to " << path.value();
+    return false;
+  }
+
+  return true;
+}
+
+// Gets the full command line for calling the shim binary. This will include a
+// placeholder "%1" argument, which Windows will substitute with the filename
+// chosen by the user.
+base::CommandLine GetAppShimCommandLine(const base::FilePath& app_shim_path,
+                                        const std::string& extension_id,
+                                        const base::FilePath& profile_path) {
+  // Get the command-line to pass to the shim (e.g., "chrome.exe --app-id=...").
+  base::FilePath chrome_exe;
+  if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
+    NOTREACHED();
+    return base::CommandLine(base::CommandLine::NO_PROGRAM);
+  }
+  CommandLine chrome_cmd_line = ShellIntegration::CommandLineArgsForLauncher(
+      GURL(), extension_id, profile_path);
+  chrome_cmd_line.SetProgram(chrome_exe);
+  chrome_cmd_line.AppendArg("%1");
+
+  // Get the command-line for calling the shim (e.g.,
+  // "app_shim -- chrome.exe --app-id=...").
+  CommandLine shim_cmd_line(app_shim_path);
+  // Ensure all subsequent switches are treated as args to the shim.
+  shim_cmd_line.AppendArg("--");
+  for (const auto& arg : chrome_cmd_line.argv())
+    shim_cmd_line.AppendArgNative(arg);
+
+  return shim_cmd_line;
+}
+
+// Gets the set of file extensions associated with a particular file handler.
+// Uses both the MIME types and extensions.
+void GetHandlerFileExtensions(const extensions::FileHandlerInfo& handler,
+                              std::set<base::string16>* exts) {
+  for (const auto& mime : handler.types) {
+    std::vector<base::string16> mime_type_extensions;
+    net::GetExtensionsForMimeType(mime, &mime_type_extensions);
+    exts->insert(mime_type_extensions.begin(), mime_type_extensions.end());
+  }
+  for (const auto& ext : handler.extensions)
+    exts->insert(base::UTF8ToUTF16(ext));
+}
+
+// Creates operating system file type associations for a given app.
+// This is the platform specific implementation of the CreateFileAssociations
+// function, and is executed on the FILE thread.
+// Returns true on success, false on failure.
+bool CreateFileAssociationsForApp(
+    const std::string& extension_id,
+    const base::string16& title,
+    const base::FilePath& profile_path,
+    const extensions::FileHandlersInfo& file_handlers_info) {
+  LOG(INFO) << "CreateFileAssociationsForApp: " << title;
+
+  base::FilePath web_app_path =
+      web_app::GetWebAppDataDirectory(profile_path, extension_id, GURL());
+  base::FilePath file_name = web_app::internals::GetSanitizedFileName(title);
+
+  // The progid is "chrome-APPID-HANDLERID". This is the internal name Windows
+  // will use for file associations with this application.
+  base::string16 progid_base = L"chrome-";
+  progid_base += base::UTF8ToUTF16(extension_id);
+
+  // Create the app shim binary (see CreateAppShimBinary for rationale). Get the
+  // command line for the shim.
+  base::FilePath app_shim_path = web_app_path.Append(file_name);
+  if (!CreateAppShimBinary(app_shim_path))
+    return false;

[jackhou1, 2014/10/27 02:13:28]

Blank line after return.

[Matt Giuca, 2014/11/04 06:00:09]

Done.

+  CommandLine shim_cmd_line(
+      GetAppShimCommandLine(app_shim_path, extension_id, profile_path));
+
+  // TODO(mgiuca): Get the file type name from the manifest, or generate a
+  // default one. (If this is blank, Windows will generate one of the form
+  // '<EXT> file'.)
+  base::string16 file_type_name = L"";
+
+  // TODO(mgiuca): Generate a new icon for this application's file associations
+  // that looks like a page with the application icon inside.
+  base::FilePath icon_file = GetIconFilePath(web_app_path, title);
+
+  // Create a separate file association (ProgId) for each handler. This allows
+  // each handler to have its own filetype name and icon, and also a different
+  // command line (so the app can see which handler was invoked).
+  for (const auto& handler : file_handlers_info) {
+    base::string16 progid = progid_base + L"-" + base::UTF8ToUTF16(handler.id);
+
+    std::set<base::string16> exts;
+    GetHandlerFileExtensions(handler, &exts);
+
+    if (!ShellUtil::AddFileAssociations(

[jackhou1, 2014/10/27 02:13:28]

Just something to think about: Would any issues come up if any/all of these
parameters change? I.e. if the progid changes, we should be adding a new
association. If any of the others change, we should be modifying the existing
association.

[Matt Giuca, 2014/11/04 06:00:09]

Well if the progid doesn't change, then it will just overwrite the existing
association. (We should be careful to clean up any fileexts that have been
removed since the last version though.)

If the progid does change, then we'll create a second one. But that is fine
because the progid is keyed to the app ID (so if it changes, then effectively
we've installed a new app).

+            progid, shim_cmd_line, file_type_name, icon_file, exts)) {
+      return false;

[jackhou1, 2014/10/27 02:13:28]

Should we delete the shim if this fails?

[Matt Giuca, 2014/11/04 06:00:09]

Done.

+    }
+  }
+
+  // Success. Tell Windows Explorer to update its cache.
+  SHChangeNotify(
+      SHCNE_ASSOCCHANGED, SHCNF_IDLIST | SHCNF_FLUSHNOWAIT, nullptr, nullptr);
+  return true;
+}
+
 }  // namespace
 
 namespace web_app {
 
 base::FilePath CreateShortcutInWebAppDir(const base::FilePath& web_app_dir,
                                          const ShortcutInfo& shortcut_info) {
   std::vector<base::FilePath> paths;
   paths.push_back(web_app_dir);
   std::vector<base::FilePath> out_filenames;
   base::FilePath web_app_dir_shortcut =
@@ skipping 87 matching lines @@
   if (pin_to_taskbar) {
     base::FilePath file_name = GetSanitizedFileName(shortcut_info.title);
     // Use the web app path shortcut for pinning to avoid having unique numbers
     // in the application name.
     base::FilePath shortcut_to_pin = web_app_path.Append(file_name).
         AddExtension(installer::kLnkExt);
     if (!base::win::TaskbarPinShortcutLink(shortcut_to_pin.value().c_str()))
       return false;
   }
 
+  if (switches::kEnableAppsFileAssociations) {
+    CreateFileAssociationsForApp(shortcut_info.extension_id,
+                                 shortcut_info.title,
+                                 shortcut_info.profile_path,
+                                 file_handlers_info);
+  }
+
   return true;
 }
 
 void UpdatePlatformShortcuts(
     const base::FilePath& web_app_path,
     const base::string16& old_app_title,
     const ShortcutInfo& shortcut_info,
     const extensions::FileHandlersInfo& file_handlers_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
@@ skipping 123 matching lines @@
 
 }  // namespace internals
 
 void UpdateShortcutForTabContents(content::WebContents* web_contents) {
   // UpdateShortcutWorker will delete itself when it's done.
   UpdateShortcutWorker* worker = new UpdateShortcutWorker(web_contents);
   worker->Run();
 }
 
 }  // namespace web_app