Support "Pin to taskbar" for hosted app windows.

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/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/path_service.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/web_applications/update_shortcut_worker_win.h"
 #include "chrome/common/chrome_switches.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 "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");
 
 // Calculates checksum of an icon family using MD5.
@@ skipping 280 matching lines @@
     for (std::vector<base::FilePath>::const_iterator j = shortcut_files.begin();
          j != shortcut_files.end(); ++j) {
       // Any shortcut could have been pinned, either by chrome or the user, so
       // they are all unpinned.
       base::win::TaskbarUnpinShortcutLink(j->value().c_str());
       base::DeleteFile(*j, false);
     }
   }
 }
 
+void CreateIconAndSetRelaunchDetails(const base::FilePath& web_app_path,
+                                     const base::FilePath& icon_file,
+                                     const web_app::ShortcutInfo& shortcut_info,
+                                     HWND hwnd) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+
+  CommandLine command_line =
+      ShellIntegration::CommandLineArgsForLauncher(shortcut_info.url,
+                                                   shortcut_info.extension_id,
+                                                   shortcut_info.profile_path);
+
+  base::FilePath chrome_exe;
+  if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
+    NOTREACHED();
+    return;
+  }
+  command_line.SetProgram(chrome_exe);
+  ui::win::SetRelaunchDetailsForWindow(
+      command_line.GetCommandLineString(), shortcut_info.title, hwnd);
+
+  if (!base::PathExists(web_app_path) && !base::CreateDirectory(web_app_path)) {

[sky, 2014/05/23 13:27:27]

nit: no {}

[calamity, 2014/05/26 01:54:48]

Done.

+    return;
+  }
+
+  ui::win::SetAppIconForWindow(icon_file.value(), hwnd);
+  web_app::internals::CheckAndSaveIcon(icon_file, shortcut_info.favicon);
+}
+
+void OnShortcutInfoLoadedForSetRelaunchDetails(
+    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"));
+
+  content::BrowserThread::PostBlockingPoolTask(
+      FROM_HERE,
+      base::Bind(&CreateIconAndSetRelaunchDetails,
+                 web_app_path,
+                 icon_file,
+                 shortcut_info,
+                 hwnd));
+}
+
 }  // namespace
 
 namespace web_app {
 
 base::FilePath CreateShortcutInWebAppDir(
     const base::FilePath& web_app_dir,
     const web_app::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 =
       web_app_dir.Append(internals::GetSanitizedFileName(shortcut_info.title))
           .AddExtension(installer::kLnkExt);
   if (!PathExists(web_app_dir_shortcut)) {
     CreateShortcutsInPaths(web_app_dir,
                            shortcut_info,
                            paths,
                            SHORTCUT_CREATION_BY_USER,
                            &out_filenames);
     DCHECK_EQ(out_filenames.size(), 1u);
     DCHECK_EQ(out_filenames[0].value(), web_app_dir_shortcut.value());
   } else {
     internals::CheckAndSaveIcon(
         internals::GetIconFilePath(web_app_dir, shortcut_info.title),
         shortcut_info.favicon);
   }
   return web_app_dir_shortcut;
 }
 
+void UpdateRelaunchDetailsForApp(Profile* profile,
+                                 const extensions::Extension* extension,
+                                 HWND hwnd) {
+  web_app::UpdateShortcutInfoAndIconForApp(
+      extension,
+      profile,
+      base::Bind(&OnShortcutInfoLoadedForSetRelaunchDetails, hwnd));
+}
+
 namespace internals {
 
 // Saves |image| to |icon_file| if the file is outdated and refresh shell's
 // icon cache to ensure correct icon is displayed. Returns true if icon_file
 // is up to date or successfully updated.
 bool CheckAndSaveIcon(const base::FilePath& icon_file,
                       const gfx::ImageFamily& image) {
   if (ShouldUpdateIcon(icon_file, image)) {
     if (SaveIconWithCheckSum(icon_file, image)) {
       // Refresh shell's icon cache. This call is quite disruptive as user would
@@ skipping 185 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