1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "nsWindowsShellService.h"
7
8 #include "BinaryPath.h"
9 #include "city.h"
10 #include "imgIContainer.h"
11 #include "imgIRequest.h"
12 #include "mozilla/RefPtr.h"
13 #include "nsIContent.h"
14 #include "nsIImageLoadingContent.h"
15 #include "nsIOutputStream.h"
16 #include "nsIStringBundle.h"
17 #include "nsNetUtil.h"
18 #include "nsServiceManagerUtils.h"
19 #include "nsShellService.h"
20 #include "nsDirectoryServiceUtils.h"
21 #include "nsAppDirectoryServiceDefs.h"
22 #include "nsDirectoryServiceDefs.h"
23 #include "nsIWindowsRegKey.h"
24 #include "nsUnicharUtils.h"
25 #include "nsIURLFormatter.h"
26 #include "nsXULAppAPI.h"
27 #include "mozilla/WindowsVersion.h"
28 #include "mozilla/dom/Element.h"
29
30 #include "windows.h"
31 #include "shellapi.h"
32 #include <propvarutil.h>
33 #include <propkey.h>
34
35 #ifdef _WIN32_WINNT
36 # undef _WIN32_WINNT
37 #endif
38 #define _WIN32_WINNT 0x0600
39 #define INITGUID
40 #undef NTDDI_VERSION
41 #define NTDDI_VERSION NTDDI_WIN8
42 // Needed for access to IApplicationActivationManager
43 #include <shlobj.h>
44 #include "WinUtils.h"
45
46 #include <mbstring.h>
47 #include <shlwapi.h>
48
49 #include <lm.h>
50 #undef ACCESS_READ
51
52 #ifndef MAX_BUF
53 # define MAX_BUF 4096
54 #endif
55
56 #define REG_SUCCEEDED(val) (val == ERROR_SUCCESS)
57
58 #define REG_FAILED(val) (val != ERROR_SUCCESS)
59
60 #define APP_REG_NAME_BASE L"Firefox-"
61
62 #ifdef DEBUG
63 # define NS_ENSURE_HRESULT(hres, ret) \
64 do { \
65 HRESULT result = hres; \
66 if (MOZ_UNLIKELY(FAILED(result))) { \
67 mozilla::SmprintfPointer msg = mozilla::Smprintf( \
68 "NS_ENSURE_HRESULT(%s, %s) failed with " \
69 "result 0x%" PRIX32, \
70 #hres, #ret, static_cast<uint32_t>(result)); \
71 NS_WARNING(msg.get()); \
72 return ret; \
73 } \
74 } while (false)
75 #else
76 # define NS_ENSURE_HRESULT(hres, ret) \
77 if (MOZ_UNLIKELY(FAILED(hres))) return ret
78 #endif
79
80 using mozilla::IsWin8OrLater;
81 using namespace mozilla;
82
NS_IMPL_ISUPPORTS(nsWindowsShellService,nsIToolkitShellService,nsIShellService,nsIWindowsShellService)83 NS_IMPL_ISUPPORTS(nsWindowsShellService, nsIToolkitShellService,
84 nsIShellService, nsIWindowsShellService)
85
86 static nsresult OpenKeyForReading(HKEY aKeyRoot, const nsAString& aKeyName,
87 HKEY* aKey) {
88 const nsString& flatName = PromiseFlatString(aKeyName);
89
90 DWORD res = ::RegOpenKeyExW(aKeyRoot, flatName.get(), 0, KEY_READ, aKey);
91 switch (res) {
92 case ERROR_SUCCESS:
93 break;
94 case ERROR_ACCESS_DENIED:
95 return NS_ERROR_FILE_ACCESS_DENIED;
96 case ERROR_FILE_NOT_FOUND:
97 return NS_ERROR_NOT_AVAILABLE;
98 }
99
100 return NS_OK;
101 }
102
GetHelperPath(nsAutoString & aPath)103 nsresult GetHelperPath(nsAutoString& aPath) {
104 nsresult rv;
105 nsCOMPtr<nsIProperties> directoryService =
106 do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
107 NS_ENSURE_SUCCESS(rv, rv);
108
109 nsCOMPtr<nsIFile> appHelper;
110 rv = directoryService->Get(XRE_EXECUTABLE_FILE, NS_GET_IID(nsIFile),
111 getter_AddRefs(appHelper));
112 NS_ENSURE_SUCCESS(rv, rv);
113
114 rv = appHelper->SetNativeLeafName(NS_LITERAL_CSTRING("uninstall"));
115 NS_ENSURE_SUCCESS(rv, rv);
116
117 rv = appHelper->AppendNative(NS_LITERAL_CSTRING("helper.exe"));
118 NS_ENSURE_SUCCESS(rv, rv);
119
120 rv = appHelper->GetPath(aPath);
121
122 aPath.Insert(L'"', 0);
123 aPath.Append(L'"');
124 return rv;
125 }
126
LaunchHelper(nsAutoString & aPath)127 nsresult LaunchHelper(nsAutoString& aPath) {
128 STARTUPINFOW si = {sizeof(si), 0};
129 PROCESS_INFORMATION pi = {0};
130
131 if (!CreateProcessW(nullptr, (LPWSTR)aPath.get(), nullptr, nullptr, FALSE, 0,
132 nullptr, nullptr, &si, &pi)) {
133 return NS_ERROR_FAILURE;
134 }
135
136 CloseHandle(pi.hProcess);
137 CloseHandle(pi.hThread);
138 return NS_OK;
139 }
140
IsPathDefaultForClass(const RefPtr<IApplicationAssociationRegistration> & pAAR,wchar_t * exePath,LPCWSTR aClassName)141 static bool IsPathDefaultForClass(
142 const RefPtr<IApplicationAssociationRegistration>& pAAR, wchar_t* exePath,
143 LPCWSTR aClassName) {
144 // Make sure the Prog ID matches what we have
145 LPWSTR registeredApp;
146 bool isProtocol = *aClassName != L'.';
147 ASSOCIATIONTYPE queryType = isProtocol ? AT_URLPROTOCOL : AT_FILEEXTENSION;
148 HRESULT hr = pAAR->QueryCurrentDefault(aClassName, queryType, AL_EFFECTIVE,
149 ®isteredApp);
150 if (FAILED(hr)) {
151 return false;
152 }
153
154 LPCWSTR progID = isProtocol ? L"FirefoxURL" : L"FirefoxHTML";
155 bool isDefault = !wcsnicmp(registeredApp, progID, wcslen(progID));
156
157 nsAutoString regAppName(registeredApp);
158 CoTaskMemFree(registeredApp);
159
160 if (isDefault) {
161 // Make sure the application path for this progID is this installation.
162 regAppName.AppendLiteral("\\shell\\open\\command");
163 HKEY theKey;
164 nsresult rv = OpenKeyForReading(HKEY_CLASSES_ROOT, regAppName, &theKey);
165 if (NS_FAILED(rv)) {
166 return false;
167 }
168
169 wchar_t cmdFromReg[MAX_BUF] = L"";
170 DWORD len = sizeof(cmdFromReg);
171 DWORD res = ::RegQueryValueExW(theKey, nullptr, nullptr, nullptr,
172 (LPBYTE)cmdFromReg, &len);
173 ::RegCloseKey(theKey);
174 if (REG_FAILED(res)) {
175 return false;
176 }
177
178 wchar_t fullCmd[MAX_BUF] = L"";
179 _snwprintf(fullCmd, MAX_BUF, L"\"%s\" -osint -url \"%%1\"", exePath);
180
181 isDefault = _wcsicmp(fullCmd, cmdFromReg) == 0;
182 }
183
184 return isDefault;
185 }
186
GetAppRegName(nsAutoString & aAppRegName)187 static nsresult GetAppRegName(nsAutoString& aAppRegName) {
188 nsresult rv;
189 nsCOMPtr<nsIProperties> dirSvc =
190 do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
191 NS_ENSURE_SUCCESS(rv, rv);
192
193 nsCOMPtr<nsIFile> exeFile;
194 rv = dirSvc->Get(XRE_EXECUTABLE_FILE, NS_GET_IID(nsIFile),
195 getter_AddRefs(exeFile));
196 NS_ENSURE_SUCCESS(rv, rv);
197
198 nsCOMPtr<nsIFile> appDir;
199 rv = exeFile->GetParent(getter_AddRefs(appDir));
200 NS_ENSURE_SUCCESS(rv, rv);
201
202 nsAutoString appDirStr;
203 rv = appDir->GetPath(appDirStr);
204 NS_ENSURE_SUCCESS(rv, rv);
205
206 aAppRegName = APP_REG_NAME_BASE;
207 uint64_t hash =
208 CityHash64(static_cast<const char*>(appDirStr.get()),
209 appDirStr.Length() * sizeof(nsAutoString::char_type));
210 aAppRegName.AppendInt((int)(hash >> 32), 16);
211 aAppRegName.AppendInt((int)hash, 16);
212
213 return rv;
214 }
215
216 NS_IMETHODIMP
IsDefaultBrowser(bool aForAllTypes,bool * aIsDefaultBrowser)217 nsWindowsShellService::IsDefaultBrowser(bool aForAllTypes,
218 bool* aIsDefaultBrowser) {
219 *aIsDefaultBrowser = false;
220
221 RefPtr<IApplicationAssociationRegistration> pAAR;
222 HRESULT hr = CoCreateInstance(
223 CLSID_ApplicationAssociationRegistration, nullptr, CLSCTX_INPROC,
224 IID_IApplicationAssociationRegistration, getter_AddRefs(pAAR));
225 if (FAILED(hr)) {
226 return NS_OK;
227 }
228
229 wchar_t exePath[MAXPATHLEN] = L"";
230 nsresult rv = BinaryPath::GetLong(exePath);
231
232 if (NS_FAILED(rv)) {
233 return NS_OK;
234 }
235
236 *aIsDefaultBrowser = IsPathDefaultForClass(pAAR, exePath, L"http");
237 if (*aIsDefaultBrowser && aForAllTypes) {
238 *aIsDefaultBrowser = IsPathDefaultForClass(pAAR, exePath, L".html");
239 }
240 return NS_OK;
241 }
242
LaunchControlPanelDefaultsSelectionUI()243 nsresult nsWindowsShellService::LaunchControlPanelDefaultsSelectionUI() {
244 IApplicationAssociationRegistrationUI* pAARUI;
245 HRESULT hr = CoCreateInstance(
246 CLSID_ApplicationAssociationRegistrationUI, NULL, CLSCTX_INPROC,
247 IID_IApplicationAssociationRegistrationUI, (void**)&pAARUI);
248 if (SUCCEEDED(hr)) {
249 nsAutoString appRegName;
250 GetAppRegName(appRegName);
251 hr = pAARUI->LaunchAdvancedAssociationUI(appRegName.get());
252 pAARUI->Release();
253 }
254 return SUCCEEDED(hr) ? NS_OK : NS_ERROR_FAILURE;
255 }
256
LaunchControlPanelDefaultPrograms()257 nsresult nsWindowsShellService::LaunchControlPanelDefaultPrograms() {
258 // Build the path control.exe path safely
259 WCHAR controlEXEPath[MAX_PATH + 1] = {'\0'};
260 if (!GetSystemDirectoryW(controlEXEPath, MAX_PATH)) {
261 return NS_ERROR_FAILURE;
262 }
263 LPCWSTR controlEXE = L"control.exe";
264 if (wcslen(controlEXEPath) + wcslen(controlEXE) >= MAX_PATH) {
265 return NS_ERROR_FAILURE;
266 }
267 if (!PathAppendW(controlEXEPath, controlEXE)) {
268 return NS_ERROR_FAILURE;
269 }
270
271 nsAutoString params(NS_LITERAL_STRING(
272 "control.exe /name Microsoft.DefaultPrograms "
273 "/page pageDefaultProgram\\pageAdvancedSettings?pszAppName="));
274 nsAutoString appRegName;
275 GetAppRegName(appRegName);
276 params.Append(appRegName);
277 STARTUPINFOW si = {sizeof(si), 0};
278 si.dwFlags = STARTF_USESHOWWINDOW;
279 si.wShowWindow = SW_SHOWDEFAULT;
280 PROCESS_INFORMATION pi = {0};
281 if (!CreateProcessW(controlEXEPath, static_cast<LPWSTR>(params.get()),
282 nullptr, nullptr, FALSE, 0, nullptr, nullptr, &si, &pi)) {
283 return NS_ERROR_FAILURE;
284 }
285 CloseHandle(pi.hProcess);
286 CloseHandle(pi.hThread);
287
288 return NS_OK;
289 }
290
IsWindowsLogonConnected()291 static bool IsWindowsLogonConnected() {
292 WCHAR userName[UNLEN + 1];
293 DWORD size = ArrayLength(userName);
294 if (!GetUserNameW(userName, &size)) {
295 return false;
296 }
297
298 LPUSER_INFO_24 info;
299 if (NetUserGetInfo(nullptr, userName, 24, (LPBYTE*)&info) != NERR_Success) {
300 return false;
301 }
302 bool connected = info->usri24_internet_identity;
303 NetApiBufferFree(info);
304
305 return connected;
306 }
307
SettingsAppBelievesConnected()308 static bool SettingsAppBelievesConnected() {
309 nsresult rv;
310 nsCOMPtr<nsIWindowsRegKey> regKey =
311 do_CreateInstance("@mozilla.org/windows-registry-key;1", &rv);
312 if (NS_FAILED(rv)) {
313 return false;
314 }
315
316 rv = regKey->Open(
317 nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
318 NS_LITERAL_STRING("SOFTWARE\\Microsoft\\Windows\\Shell\\Associations"),
319 nsIWindowsRegKey::ACCESS_READ);
320 if (NS_FAILED(rv)) {
321 return false;
322 }
323
324 uint32_t value;
325 rv = regKey->ReadIntValue(NS_LITERAL_STRING("IsConnectedAtLogon"), &value);
326 if (NS_FAILED(rv)) {
327 return false;
328 }
329
330 return !!value;
331 }
332
LaunchModernSettingsDialogDefaultApps()333 nsresult nsWindowsShellService::LaunchModernSettingsDialogDefaultApps() {
334 if (!IsWindowsBuildOrLater(14965) && !IsWindowsLogonConnected() &&
335 SettingsAppBelievesConnected()) {
336 // Use the classic Control Panel to work around a bug of older
337 // builds of Windows 10.
338 return LaunchControlPanelDefaultPrograms();
339 }
340
341 IApplicationActivationManager* pActivator;
342 HRESULT hr = CoCreateInstance(
343 CLSID_ApplicationActivationManager, nullptr, CLSCTX_INPROC,
344 IID_IApplicationActivationManager, (void**)&pActivator);
345
346 if (SUCCEEDED(hr)) {
347 DWORD pid;
348 hr = pActivator->ActivateApplication(
349 L"windows.immersivecontrolpanel_cw5n1h2txyewy"
350 L"!microsoft.windows.immersivecontrolpanel",
351 L"page=SettingsPageAppsDefaults", AO_NONE, &pid);
352 if (SUCCEEDED(hr)) {
353 // Do not check error because we could at least open
354 // the "Default apps" setting.
355 pActivator->ActivateApplication(
356 L"windows.immersivecontrolpanel_cw5n1h2txyewy"
357 L"!microsoft.windows.immersivecontrolpanel",
358 L"page=SettingsPageAppsDefaults"
359 L"&target=SystemSettings_DefaultApps_Browser",
360 AO_NONE, &pid);
361 }
362 pActivator->Release();
363 return SUCCEEDED(hr) ? NS_OK : NS_ERROR_FAILURE;
364 }
365 return NS_OK;
366 }
367
InvokeHTTPOpenAsVerb()368 nsresult nsWindowsShellService::InvokeHTTPOpenAsVerb() {
369 nsCOMPtr<nsIURLFormatter> formatter(
370 do_GetService("@mozilla.org/toolkit/URLFormatterService;1"));
371 if (!formatter) {
372 return NS_ERROR_UNEXPECTED;
373 }
374
375 nsString urlStr;
376 nsresult rv = formatter->FormatURLPref(
377 NS_LITERAL_STRING("app.support.baseURL"), urlStr);
378 if (NS_FAILED(rv)) {
379 return rv;
380 }
381 if (!StringBeginsWith(urlStr, NS_LITERAL_STRING("https://"))) {
382 return NS_ERROR_FAILURE;
383 }
384 urlStr.AppendLiteral("win10-default-browser");
385
386 SHELLEXECUTEINFOW seinfo = {sizeof(SHELLEXECUTEINFOW)};
387 seinfo.lpVerb = L"openas";
388 seinfo.lpFile = urlStr.get();
389 seinfo.nShow = SW_SHOWNORMAL;
390 if (!ShellExecuteExW(&seinfo)) {
391 return NS_ERROR_FAILURE;
392 }
393 return NS_OK;
394 }
395
LaunchHTTPHandlerPane()396 nsresult nsWindowsShellService::LaunchHTTPHandlerPane() {
397 OPENASINFO info;
398 info.pcszFile = L"http";
399 info.pcszClass = nullptr;
400 info.oaifInFlags =
401 OAIF_FORCE_REGISTRATION | OAIF_URL_PROTOCOL | OAIF_REGISTER_EXT;
402
403 HRESULT hr = SHOpenWithDialog(nullptr, &info);
404 if (SUCCEEDED(hr) || (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED))) {
405 return NS_OK;
406 }
407 return NS_ERROR_FAILURE;
408 }
409
410 NS_IMETHODIMP
SetDefaultBrowser(bool aClaimAllTypes,bool aForAllUsers)411 nsWindowsShellService::SetDefaultBrowser(bool aClaimAllTypes,
412 bool aForAllUsers) {
413 nsAutoString appHelperPath;
414 if (NS_FAILED(GetHelperPath(appHelperPath))) return NS_ERROR_FAILURE;
415
416 if (aForAllUsers) {
417 appHelperPath.AppendLiteral(" /SetAsDefaultAppGlobal");
418 } else {
419 appHelperPath.AppendLiteral(" /SetAsDefaultAppUser");
420 }
421
422 nsresult rv = LaunchHelper(appHelperPath);
423 if (NS_SUCCEEDED(rv) && IsWin8OrLater()) {
424 if (aClaimAllTypes) {
425 if (IsWin10OrLater()) {
426 rv = LaunchModernSettingsDialogDefaultApps();
427 } else {
428 rv = LaunchControlPanelDefaultsSelectionUI();
429 }
430 // The above call should never really fail, but just in case
431 // fall back to showing the HTTP association screen only.
432 if (NS_FAILED(rv)) {
433 if (IsWin10OrLater()) {
434 rv = InvokeHTTPOpenAsVerb();
435 } else {
436 rv = LaunchHTTPHandlerPane();
437 }
438 }
439 } else {
440 // Windows 10 blocks attempts to load the
441 // HTTP Handler association dialog.
442 if (IsWin10OrLater()) {
443 rv = LaunchModernSettingsDialogDefaultApps();
444 } else {
445 rv = LaunchHTTPHandlerPane();
446 }
447
448 // The above call should never really fail, but just in case
449 // fall back to showing control panel for all defaults
450 if (NS_FAILED(rv)) {
451 rv = LaunchControlPanelDefaultsSelectionUI();
452 }
453 }
454 }
455
456 nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
457 if (prefs) {
458 (void)prefs->SetBoolPref(PREF_CHECKDEFAULTBROWSER, true);
459 // Reset the number of times the dialog should be shown
460 // before it is silenced.
461 (void)prefs->SetIntPref(PREF_DEFAULTBROWSERCHECKCOUNT, 0);
462 }
463
464 return rv;
465 }
466
WriteBitmap(nsIFile * aFile,imgIContainer * aImage)467 static nsresult WriteBitmap(nsIFile* aFile, imgIContainer* aImage) {
468 nsresult rv;
469
470 RefPtr<gfx::SourceSurface> surface = aImage->GetFrame(
471 imgIContainer::FRAME_FIRST, imgIContainer::FLAG_SYNC_DECODE);
472 NS_ENSURE_TRUE(surface, NS_ERROR_FAILURE);
473
474 // For either of the following formats we want to set the biBitCount member
475 // of the BITMAPINFOHEADER struct to 32, below. For that value the bitmap
476 // format defines that the A8/X8 WORDs in the bitmap byte stream be ignored
477 // for the BI_RGB value we use for the biCompression member.
478 MOZ_ASSERT(surface->GetFormat() == gfx::SurfaceFormat::B8G8R8A8 ||
479 surface->GetFormat() == gfx::SurfaceFormat::B8G8R8X8);
480
481 RefPtr<gfx::DataSourceSurface> dataSurface = surface->GetDataSurface();
482 NS_ENSURE_TRUE(dataSurface, NS_ERROR_FAILURE);
483
484 int32_t width = dataSurface->GetSize().width;
485 int32_t height = dataSurface->GetSize().height;
486 int32_t bytesPerPixel = 4 * sizeof(uint8_t);
487 uint32_t bytesPerRow = bytesPerPixel * width;
488
489 // initialize these bitmap structs which we will later
490 // serialize directly to the head of the bitmap file
491 BITMAPINFOHEADER bmi;
492 bmi.biSize = sizeof(BITMAPINFOHEADER);
493 bmi.biWidth = width;
494 bmi.biHeight = height;
495 bmi.biPlanes = 1;
496 bmi.biBitCount = (WORD)bytesPerPixel * 8;
497 bmi.biCompression = BI_RGB;
498 bmi.biSizeImage = bytesPerRow * height;
499 bmi.biXPelsPerMeter = 0;
500 bmi.biYPelsPerMeter = 0;
501 bmi.biClrUsed = 0;
502 bmi.biClrImportant = 0;
503
504 BITMAPFILEHEADER bf;
505 bf.bfType = 0x4D42; // 'BM'
506 bf.bfReserved1 = 0;
507 bf.bfReserved2 = 0;
508 bf.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
509 bf.bfSize = bf.bfOffBits + bmi.biSizeImage;
510
511 // get a file output stream
512 nsCOMPtr<nsIOutputStream> stream;
513 rv = NS_NewLocalFileOutputStream(getter_AddRefs(stream), aFile);
514 NS_ENSURE_SUCCESS(rv, rv);
515
516 gfx::DataSourceSurface::MappedSurface map;
517 if (!dataSurface->Map(gfx::DataSourceSurface::MapType::READ, &map)) {
518 return NS_ERROR_FAILURE;
519 }
520
521 // write the bitmap headers and rgb pixel data to the file
522 rv = NS_ERROR_FAILURE;
523 if (stream) {
524 uint32_t written;
525 stream->Write((const char*)&bf, sizeof(BITMAPFILEHEADER), &written);
526 if (written == sizeof(BITMAPFILEHEADER)) {
527 stream->Write((const char*)&bmi, sizeof(BITMAPINFOHEADER), &written);
528 if (written == sizeof(BITMAPINFOHEADER)) {
529 // write out the image data backwards because the desktop won't
530 // show bitmaps with negative heights for top-to-bottom
531 uint32_t i = map.mStride * height;
532 do {
533 i -= map.mStride;
534 stream->Write(((const char*)map.mData) + i, bytesPerRow, &written);
535 if (written == bytesPerRow) {
536 rv = NS_OK;
537 } else {
538 rv = NS_ERROR_FAILURE;
539 break;
540 }
541 } while (i != 0);
542 }
543 }
544
545 stream->Close();
546 }
547
548 dataSurface->Unmap();
549
550 return rv;
551 }
552
553 NS_IMETHODIMP
SetDesktopBackground(dom::Element * aElement,int32_t aPosition,const nsACString & aImageName)554 nsWindowsShellService::SetDesktopBackground(dom::Element* aElement,
555 int32_t aPosition,
556 const nsACString& aImageName) {
557 if (!aElement || !aElement->IsHTMLElement(nsGkAtoms::img)) {
558 // XXX write background loading stuff!
559 return NS_ERROR_NOT_AVAILABLE;
560 }
561
562 nsresult rv;
563 nsCOMPtr<nsIImageLoadingContent> imageContent =
564 do_QueryInterface(aElement, &rv);
565 if (!imageContent) return rv;
566
567 // get the image container
568 nsCOMPtr<imgIRequest> request;
569 rv = imageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
570 getter_AddRefs(request));
571 if (!request) return rv;
572
573 nsCOMPtr<imgIContainer> container;
574 rv = request->GetImage(getter_AddRefs(container));
575 if (!container) return NS_ERROR_FAILURE;
576
577 // get the file name from localized strings
578 nsCOMPtr<nsIStringBundleService> bundleService(
579 do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv));
580 NS_ENSURE_SUCCESS(rv, rv);
581
582 nsCOMPtr<nsIStringBundle> shellBundle;
583 rv = bundleService->CreateBundle(SHELLSERVICE_PROPERTIES,
584 getter_AddRefs(shellBundle));
585 NS_ENSURE_SUCCESS(rv, rv);
586
587 // e.g. "Desktop Background.bmp"
588 nsAutoString fileLeafName;
589 rv = shellBundle->GetStringFromName("desktopBackgroundLeafNameWin",
590 fileLeafName);
591 NS_ENSURE_SUCCESS(rv, rv);
592
593 // get the profile root directory
594 nsCOMPtr<nsIFile> file;
595 rv = NS_GetSpecialDirectory(NS_APP_APPLICATION_REGISTRY_DIR,
596 getter_AddRefs(file));
597 NS_ENSURE_SUCCESS(rv, rv);
598
599 // eventually, the path is "%APPDATA%\Mozilla\Firefox\Desktop Background.bmp"
600 rv = file->Append(fileLeafName);
601 NS_ENSURE_SUCCESS(rv, rv);
602
603 nsAutoString path;
604 rv = file->GetPath(path);
605 NS_ENSURE_SUCCESS(rv, rv);
606
607 // write the bitmap to a file in the profile directory.
608 // We have to write old bitmap format for Windows 7 wallpapar support.
609 rv = WriteBitmap(file, container);
610
611 // if the file was written successfully, set it as the system wallpaper
612 if (NS_SUCCEEDED(rv)) {
613 nsCOMPtr<nsIWindowsRegKey> regKey =
614 do_CreateInstance("@mozilla.org/windows-registry-key;1", &rv);
615 NS_ENSURE_SUCCESS(rv, rv);
616
617 rv = regKey->Create(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
618 NS_LITERAL_STRING("Control Panel\\Desktop"),
619 nsIWindowsRegKey::ACCESS_SET_VALUE);
620 NS_ENSURE_SUCCESS(rv, rv);
621
622 nsAutoString tile;
623 nsAutoString style;
624 switch (aPosition) {
625 case BACKGROUND_TILE:
626 style.Assign('0');
627 tile.Assign('1');
628 break;
629 case BACKGROUND_CENTER:
630 style.Assign('0');
631 tile.Assign('0');
632 break;
633 case BACKGROUND_STRETCH:
634 style.Assign('2');
635 tile.Assign('0');
636 break;
637 case BACKGROUND_FILL:
638 style.AssignLiteral("10");
639 tile.Assign('0');
640 break;
641 case BACKGROUND_FIT:
642 style.Assign('6');
643 tile.Assign('0');
644 break;
645 case BACKGROUND_SPAN:
646 style.AssignLiteral("22");
647 tile.Assign('0');
648 break;
649 }
650
651 rv = regKey->WriteStringValue(NS_LITERAL_STRING("TileWallpaper"), tile);
652 NS_ENSURE_SUCCESS(rv, rv);
653 rv = regKey->WriteStringValue(NS_LITERAL_STRING("WallpaperStyle"), style);
654 NS_ENSURE_SUCCESS(rv, rv);
655 rv = regKey->Close();
656 NS_ENSURE_SUCCESS(rv, rv);
657
658 ::SystemParametersInfoW(SPI_SETDESKWALLPAPER, 0, (PVOID)path.get(),
659 SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
660 }
661 return rv;
662 }
663
664 NS_IMETHODIMP
GetDesktopBackgroundColor(uint32_t * aColor)665 nsWindowsShellService::GetDesktopBackgroundColor(uint32_t* aColor) {
666 uint32_t color = ::GetSysColor(COLOR_DESKTOP);
667 *aColor =
668 (GetRValue(color) << 16) | (GetGValue(color) << 8) | GetBValue(color);
669 return NS_OK;
670 }
671
672 NS_IMETHODIMP
SetDesktopBackgroundColor(uint32_t aColor)673 nsWindowsShellService::SetDesktopBackgroundColor(uint32_t aColor) {
674 int aParameters[2] = {COLOR_BACKGROUND, COLOR_DESKTOP};
675 BYTE r = (aColor >> 16);
676 BYTE g = (aColor << 16) >> 24;
677 BYTE b = (aColor << 24) >> 24;
678 COLORREF colors[2] = {RGB(r, g, b), RGB(r, g, b)};
679
680 ::SetSysColors(sizeof(aParameters) / sizeof(int), aParameters, colors);
681
682 nsresult rv;
683 nsCOMPtr<nsIWindowsRegKey> regKey =
684 do_CreateInstance("@mozilla.org/windows-registry-key;1", &rv);
685 NS_ENSURE_SUCCESS(rv, rv);
686
687 rv = regKey->Create(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
688 NS_LITERAL_STRING("Control Panel\\Colors"),
689 nsIWindowsRegKey::ACCESS_SET_VALUE);
690 NS_ENSURE_SUCCESS(rv, rv);
691
692 wchar_t rgb[12];
693 _snwprintf(rgb, 12, L"%u %u %u", r, g, b);
694
695 rv = regKey->WriteStringValue(NS_LITERAL_STRING("Background"),
696 nsDependentString(rgb));
697 NS_ENSURE_SUCCESS(rv, rv);
698
699 return regKey->Close();
700 }
701
702 NS_IMETHODIMP
CreateShortcut(nsIFile * aBinary,const nsTArray<nsString> & aArguments,const nsAString & aDescription,nsIFile * aIconFile,const nsAString & aAppUserModelId,nsIFile * aTarget)703 nsWindowsShellService::CreateShortcut(nsIFile* aBinary,
704 const nsTArray<nsString>& aArguments,
705 const nsAString& aDescription,
706 nsIFile* aIconFile,
707 const nsAString& aAppUserModelId,
708 nsIFile* aTarget) {
709 NS_ENSURE_ARG(aBinary);
710 NS_ENSURE_ARG(aTarget);
711
712 RefPtr<IShellLinkW> link;
713 HRESULT hr = CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER,
714 IID_IShellLinkW, getter_AddRefs(link));
715 NS_ENSURE_HRESULT(hr, NS_ERROR_FAILURE);
716
717 nsString path(aBinary->NativePath());
718 link->SetPath(path.get());
719
720 if (!aDescription.IsEmpty()) {
721 link->SetDescription(PromiseFlatString(aDescription).get());
722 }
723
724 // TODO: Properly escape quotes in the string, see bug 1604287.
725 nsString arguments;
726 for (auto& arg : aArguments) {
727 arguments.AppendPrintf("\"%S\" ", arg.get());
728 }
729
730 link->SetArguments(arguments.get());
731
732 if (aIconFile) {
733 nsString icon(aIconFile->NativePath());
734 link->SetIconLocation(icon.get(), 0);
735 }
736
737 if (!aAppUserModelId.IsEmpty()) {
738 RefPtr<IPropertyStore> propStore;
739 hr = link->QueryInterface(IID_IPropertyStore, getter_AddRefs(propStore));
740 NS_ENSURE_HRESULT(hr, NS_ERROR_FAILURE);
741
742 PROPVARIANT pv;
743 if (FAILED(InitPropVariantFromString(
744 PromiseFlatString(aAppUserModelId).get(), &pv))) {
745 return NS_ERROR_FAILURE;
746 }
747
748 hr = propStore->SetValue(PKEY_AppUserModel_ID, pv);
749 PropVariantClear(&pv);
750 NS_ENSURE_HRESULT(hr, NS_ERROR_FAILURE);
751
752 hr = propStore->Commit();
753 NS_ENSURE_HRESULT(hr, NS_ERROR_FAILURE);
754 }
755
756 RefPtr<IPersistFile> persist;
757 hr = link->QueryInterface(IID_IPersistFile, getter_AddRefs(persist));
758 NS_ENSURE_HRESULT(hr, NS_ERROR_FAILURE);
759
760 nsString target(aTarget->NativePath());
761 hr = persist->Save(target.get(), TRUE);
762 NS_ENSURE_HRESULT(hr, NS_ERROR_FAILURE);
763
764 return NS_OK;
765 }
766
nsWindowsShellService()767 nsWindowsShellService::nsWindowsShellService() {}
768
~nsWindowsShellService()769 nsWindowsShellService::~nsWindowsShellService() {}
770