Pin to taskbar on Windows

fix brave/brave-browser#24054

* Pin to taskbar from first run or default browser dialog when user
want to do it.
* Pin to taskbar from settings.

Use upstream's api for pin state checking pin to taskbar
With this, this pin to shortcut feature is available also on Win7/8.

Author: simonhong

app/brave_generated_resources.grd

@@ -928,6 +928,11 @@ Or change later at <ph name="SETTINGS_EXTENIONS_LINK">$2<ex>brave://settings/ext
         Maybe later
       </message>
 
+      <if expr="is_win">
+        <message name="IDS_FIRSTRUN_DLG_PIN_SHORTCUT_TEXT" desc="Text for pin to taskbar checkbox">
+          Pin to taskbar
+        </message>
+      </if>
       <!-- Importer -->
       <message name="IDS_BRAVE_IMPORT_FROM_EDGE" desc="browser combo box: Microsoft Edge Legacy">
         Microsoft Edge Legacy

app/brave_settings_strings.grdp

@@ -140,6 +140,19 @@
     Customize the background image and widgets that appear on the new tab page
   </message>
 
+  <!-- Settings / Pin shortcut-->
+  <if expr="is_win">
+    <message name="IDS_SETTINGS_CAN_PIN_SHORTCUT">
+      Pin to taskbar
+    </message>
+    <message name="IDS_SETTINGS_PIN_SHORTCUT">
+      Pin
+    </message>
+    <message name="IDS_SETTINGS_SHORTCUT_PINNED">
+      Brave is already pinned
+    </message>
+  </if>
+
   <!-- Settings / Shields -->
   <message name="IDS_SETTINGS_BRAVE_SHIELDS_TITLE" desc="The title for Brave shields section in settings">
     Shields

browser/brave_shell_integration_win.cc

@@ -5,9 +5,6 @@
 
 #include "brave/browser/brave_shell_integration_win.h"
 
-#include <shlobj.h>
-#include <wrl/client.h>
-
 #include <memory>
 #include <string>
 #include <tuple>
@@ -21,7 +18,6 @@
 #include "base/strings/string_util.h"
 #include "base/task/thread_pool.h"
 #include "base/win/shortcut.h"
-#include "base/win/windows_version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
@@ -30,6 +26,7 @@
 #include "chrome/browser/shell_integration_win.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/shell_util.h"
+#include "chrome/installer/util/taskbar_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 
@@ -106,120 +103,13 @@ absl::optional<ScopedShortcutFile> GetShortcutPath(
   return absl::optional<ScopedShortcutFile>(shortcut_path);
 }
 
-// NOTE: Below Pin/IsPin method is copied lastest chromium.
-// Delete and use upstreams one when it's available from our trunk.
-
-// ScopedPIDLFromPath class, and the idea of using IPinnedList3::Modify,
-// are thanks to Gee Law <https://geelaw.blog/entries/msedge-pins/>
-class ScopedPIDLFromPath {
- public:
-  explicit ScopedPIDLFromPath(PCWSTR path)
-      : p_id_list_(ILCreateFromPath(path)) {}
-  ~ScopedPIDLFromPath() {
-    if (p_id_list_)
-      ILFree(p_id_list_);
-  }
-  PIDLIST_ABSOLUTE Get() const { return p_id_list_; }
-
- private:
-  PIDLIST_ABSOLUTE const p_id_list_;
-};
-
-enum class PinnedListModifyCaller { kExplorer = 4 };
-
-constexpr GUID CLSID_TaskbandPin = {
-    0x90aa3a4e,
-    0x1cba,
-    0x4233,
-    {0xb8, 0xbb, 0x53, 0x57, 0x73, 0xd4, 0x84, 0x49}};
-
-// Undocumented COM interface for manipulating taskbar pinned list.
-class __declspec(uuid("0DD79AE2-D156-45D4-9EEB-3B549769E940")) IPinnedList3
-    : public IUnknown {
- public:
-  virtual HRESULT STDMETHODCALLTYPE EnumObjects() = 0;
-  virtual HRESULT STDMETHODCALLTYPE GetPinnableInfo() = 0;
-  virtual HRESULT STDMETHODCALLTYPE IsPinnable() = 0;
-  virtual HRESULT STDMETHODCALLTYPE Resolve() = 0;
-  virtual HRESULT STDMETHODCALLTYPE LegacyModify() = 0;
-  virtual HRESULT STDMETHODCALLTYPE GetChangeCount() = 0;
-  virtual HRESULT STDMETHODCALLTYPE IsPinned(PCIDLIST_ABSOLUTE) = 0;
-  virtual HRESULT STDMETHODCALLTYPE GetPinnedItem() = 0;
-  virtual HRESULT STDMETHODCALLTYPE GetAppIDForPinnedItem() = 0;
-  virtual HRESULT STDMETHODCALLTYPE ItemChangeNotify() = 0;
-  virtual HRESULT STDMETHODCALLTYPE UpdateForRemovedItemsAsNecessary() = 0;
-  virtual HRESULT STDMETHODCALLTYPE PinShellLink() = 0;
-  virtual HRESULT STDMETHODCALLTYPE GetPinnedItemForAppID() = 0;
-  virtual HRESULT STDMETHODCALLTYPE Modify(PCIDLIST_ABSOLUTE unpin,
-                                           PCIDLIST_ABSOLUTE pin,
-                                           PinnedListModifyCaller caller) = 0;
-};
-
-// Returns the taskbar pinned list if successful, an empty ComPtr otherwise.
-Microsoft::WRL::ComPtr<IPinnedList3> GetTaskbarPinnedList() {
-  if (base::win::GetVersion() < base::win::Version::WIN10_RS5)
-    return nullptr;
-
-  Microsoft::WRL::ComPtr<IPinnedList3> pinned_list;
-  if (FAILED(CoCreateInstance(CLSID_TaskbandPin, nullptr, CLSCTX_INPROC_SERVER,
-                              IID_PPV_ARGS(&pinned_list)))) {
-    return nullptr;
-  }
-
-  return pinned_list;
-}
-
-void PinShortcutWin10(const base::FilePath& shortcut) {
-  Microsoft::WRL::ComPtr<IPinnedList3> pinned_list = GetTaskbarPinnedList();
-  if (!pinned_list)
-    return;
-
-  ScopedPIDLFromPath item_id_list(shortcut.value().data());
-  pinned_list->Modify(nullptr, item_id_list.Get(),
-                      PinnedListModifyCaller::kExplorer);
-}
-
-absl::optional<bool> IsShortcutPinnedWin10(const base::FilePath& shortcut) {
-  Microsoft::WRL::ComPtr<IPinnedList3> pinned_list = GetTaskbarPinnedList();
-  if (!pinned_list.Get())
-    return absl::nullopt;
-
-  ScopedPIDLFromPath item_id_list(shortcut.value().data());
-  HRESULT hr = pinned_list->IsPinned(item_id_list.Get());
-  // S_OK means `shortcut` is pinned, S_FALSE mean it's not pinned.
-  return SUCCEEDED(hr) ? absl::optional<bool>(hr == S_OK) : absl::nullopt;
-}
-
-bool IsShortcutPinned(const ShellUtil::ShortcutProperties& properties) {
-  // Generate the shortcut to check pin state.
-  absl::optional<ScopedShortcutFile> shortcut_path =
-      GetShortcutPath(ExtractShortcutNameFromProperties(properties));
-  if (!shortcut_path) {
-    LOG(ERROR) << __func__ << " failed to get shortcut path";
-    return false;
-  }
-
-  if (!CreateShortcut(properties, shortcut_path->file_path())) {
-    LOG(ERROR) << __func__ << " Failed to create shortcut";
-    return false;
-  }
-
-  // Check pin state with newly created shortcut.
-  auto pinned = IsShortcutPinnedWin10(shortcut_path->file_path());
-  if (!pinned) {
-    LOG(ERROR) << __func__ << " Can't use pin method.";
-    return false;
-  }
-
-  return pinned.value();
-}
-
 // All args could be empty when we want to pin default profile's shortcut.
-void PinToTaskbarImpl(const base::FilePath& profile_path,
+bool PinToTaskbarImpl(const base::FilePath& profile_path,
                       const std::u16string& profile_name,
                       const std::wstring& aumid) {
   base::FilePath chrome_exe;
-  base::PathService::Get(base::FILE_EXE, &chrome_exe);
+  if (!base::PathService::Get(base::FILE_EXE, &chrome_exe))
+    return false;
 
   ShellUtil::ShortcutProperties properties(ShellUtil::CURRENT_USER);
   ShellUtil::AddDefaultShortcutProperties(chrome_exe, &properties);
@@ -243,131 +133,89 @@ void PinToTaskbarImpl(const base::FilePath& profile_path,
       GetShortcutPath(ExtractShortcutNameFromProperties(properties));
   if (!shortcut_path) {
     LOG(ERROR) << __func__ << " failed to get shortcut path";
-    return;
+    return false;
   }
 
   if (!CreateShortcut(properties, shortcut_path->file_path())) {
     LOG(ERROR) << __func__ << " Failed to create shortcut";
-    return;
-  }
-
-  // Check pin state with newly created shortcut.
-  auto pinned = IsShortcutPinnedWin10(shortcut_path->file_path());
-  if (!pinned) {
-    LOG(ERROR) << __func__ << " Can't use pin method.";
-    return;
-  }
-
-  // Don't try to pin again when it's already pinned.
-  if (pinned.value())
-    return;
-
-  PinShortcutWin10(shortcut_path->file_path());
-}
-
-bool HasTaskbarAnyPinnedBraveShortcuts(
-    const std::vector<std::tuple<base::FilePath, std::u16string, std::wstring>>&
-        profile_attrs) {
-  base::FilePath chrome_exe;
-  base::PathService::Get(base::FILE_EXE, &chrome_exe);
-
-  ShellUtil::ShortcutProperties properties(ShellUtil::CURRENT_USER);
-  ShellUtil::AddDefaultShortcutProperties(chrome_exe, &properties);
-  for (const auto& attr : profile_attrs) {
-    const auto profile_path = std::get<0>(attr);
-    const auto profile_name = std::get<1>(attr);
-    const auto profile_aumid = std::get<2>(attr);
-    if (!profile_path.empty()) {
-      properties.set_arguments(
-          profiles::internal::CreateProfileShortcutFlags(profile_path));
-      properties.set_shortcut_name(
-          profiles::internal::GetShortcutFilenameForProfile(profile_name));
-      properties.set_app_id(profile_aumid);
-    }
-
-    if (IsShortcutPinned(properties))
-      return true;
+    return false;
   }
 
-  return false;
+  return PinShortcutToTaskbar(shortcut_path->file_path());
 }
 
-void DoPinToTaskbar(Profile* profile) {
+void DoPinToTaskbar(const base::FilePath& profile_path,
+                    base::OnceCallback<void(bool)> callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  base::FilePath profile_path;
   std::u16string profile_name;
   std::wstring aumid;
-  if (profile) {
+  if (!profile_path.empty()) {
     ProfileManager* profile_manager = g_browser_process->profile_manager();
     ProfileAttributesEntry* entry =
         profile_manager->GetProfileAttributesStorage()
-            .GetProfileAttributesWithPath(profile->GetPath());
-    profile_path = profile->GetPath();
+            .GetProfileAttributesWithPath(profile_path);
     profile_name = entry->GetName();
     aumid = shell_integration::win::GetAppUserModelIdForBrowser(profile_path);
   }
 
   base::ThreadPool::CreateCOMSTATaskRunner({base::MayBlock()})
-      ->PostTask(FROM_HERE, base::BindOnce(&PinToTaskbarImpl, profile_path,
-                                           profile_name, aumid));
+      ->PostTaskAndReplyWithResult(
+          FROM_HERE,
+          base::BindOnce(&PinToTaskbarImpl, profile_path, profile_name, aumid),
+          std::move(callback));
 }
 
-bool CanPinToTaskbar() {
-  base::FilePath chrome_exe;
-  if (!base::PathService::Get(base::FILE_EXE, &chrome_exe))
-    return false;
+}  // namespace
 
-  // TODO(simonhong): Support win7/8
-  if (base::win::GetVersion() < base::win::Version::WIN10_RS5)
-    return false;
+namespace shell_integration::win {
 
-  return true;
-}
+void PinToTaskbar(Profile* profile,
+                  base::OnceCallback<void(bool)> result_callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-}  // namespace
+  if (!CanPinShortcutToTaskbar()) {
+    std::move(result_callback).Run(false);
+    return;
+  }
 
-namespace shell_integration::win {
+  base::FilePath profile_path;
+  if (profile)
+    profile_path = profile->GetPath();
 
-void PinToTaskbar(Profile* profile) {
-  // Disable pin-to-taskabar uitll we have checkbox to ask the user to use it.
-  return;
+  // TODO(simonhong): handle connection error state if caller wants.
+  GetIsPinnedToTaskbarState(
+      base::DoNothing(),
+      base::BindOnce(
+          [](const base::FilePath& profile_path,
+             base::OnceCallback<void(bool)> result_callback, bool succeeded,
+             bool is_pinned_to_taskbar) {
+            if (succeeded && is_pinned_to_taskbar) {
+              // Early return. Already pinned.
+              std::move(result_callback).Run(true);
+              return;
+            }
+            DoPinToTaskbar(profile_path, std::move(result_callback));
+          },
+          std::move(profile_path), std::move(result_callback)));
+}
 
+void IsShortcutPinned(base::OnceCallback<void(bool)> result_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  if (!CanPinToTaskbar())
+  if (!CanPinShortcutToTaskbar()) {
+    std::move(result_callback).Run(false);
     return;
-
-  // At the very early stage, |g_browser_process| or its profile_manager
-  // are not initialzied yet. In that case, skip checking existing pin state.
-  std::vector<std::tuple<base::FilePath, std::u16string, std::wstring>>
-      profile_attrs;
-  // Gather data that is available on UI thread and pass it.
-  if (g_browser_process && g_browser_process->profile_manager()) {
-    for (const auto* entry : g_browser_process->profile_manager()
-                                 ->GetProfileAttributesStorage()
-                                 .GetAllProfilesAttributes()) {
-      profile_attrs.push_back(
-          std::make_tuple(entry->GetPath(), entry->GetName(),
-                          win::GetAppUserModelIdForBrowser(entry->GetPath())));
-    }
   }
 
-  base::ThreadPool::CreateCOMSTATaskRunner({base::MayBlock()})
-      ->PostTaskAndReplyWithResult(
-          FROM_HERE,
-          base::BindOnce(&HasTaskbarAnyPinnedBraveShortcuts,
-                         std::move(profile_attrs)),
-          base::BindOnce(
-              [](Profile* profile, bool has_pin) {
-                if (has_pin) {
-                  VLOG(2) << " Taskbar has already pinned brave shortcuts";
-                  return;
-                }
-                DoPinToTaskbar(profile);
-              },
-              profile));
-  return;
+  GetIsPinnedToTaskbarState(
+      base::DoNothing(),
+      base::BindOnce(
+          [](base::OnceCallback<void(bool)> result_callback, bool succeeded,
+             bool is_pinned_to_taskbar) {
+            std::move(result_callback).Run(succeeded && is_pinned_to_taskbar);
+          },
+          std::move(result_callback)));
 }
 
 }  // namespace shell_integration::win

browser/brave_shell_integration_win.h

@@ -6,12 +6,21 @@
 #ifndef BRAVE_BROWSER_BRAVE_SHELL_INTEGRATION_WIN_H_
 #define BRAVE_BROWSER_BRAVE_SHELL_INTEGRATION_WIN_H_
 
+#include "base/callback.h"
+#include "base/callback_helpers.h"
+
 class Profile;
 
 namespace shell_integration::win {
 
 // Pin profile-specific shortcut when |profile| is non-null.
-void PinToTaskbar(Profile* profile = nullptr);
+void PinToTaskbar(
+    Profile* profile = nullptr,
+    base::OnceCallback<void(bool)> result_callback = base::DoNothing());
+
+// Returns true when taskbar has any shortcuts(default or profile-specific
+// ones).
+void IsShortcutPinned(base::OnceCallback<void(bool)> result_callback);
 
 }  // namespace shell_integration::win