1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsUpdateSyncManager.h"
#include "mozilla/Unused.h"
#include "mozilla/Services.h"
#include "nsComponentManagerUtils.h"
#include "nsCRT.h"
#include "nsIFile.h"
#include "nsIObserverService.h"
#include "nsIProperties.h"
#include "nsString.h"
#include "nsXULAppAPI.h"
// The lock code generates a path that already includes the vendor name,
// so this only needs to name the specific lock.
#define UPDATE_LOCK_NAME_TOKEN "UpdateLock"
nsUpdateSyncManager* gUpdateSyncManager = nullptr;
NS_IMPL_ISUPPORTS(nsUpdateSyncManager, nsIUpdateSyncManager, nsIObserver)
nsUpdateSyncManager::nsUpdateSyncManager() { OpenLock(); }
nsUpdateSyncManager::~nsUpdateSyncManager() {
ReleaseLock();
gUpdateSyncManager = nullptr;
}
already_AddRefed<nsUpdateSyncManager> nsUpdateSyncManager::GetSingleton() {
if (!gUpdateSyncManager) {
gUpdateSyncManager = new nsUpdateSyncManager();
}
return do_AddRef(gUpdateSyncManager);
}
NS_IMETHODIMP nsUpdateSyncManager::Observe(nsISupports* aSubject,
const char* aTopic,
const char16_t* aData) {
mozilla::Unused << aSubject;
mozilla::Unused << aData;
// We want to hold the lock for as much of the lifetime of the app as we can,
// so we observe xpcom-startup so we get constructed as early as possible,
// which triggers constructing the singleton.
if (!nsCRT::strcmp(aTopic, NS_XPCOM_STARTUP_OBSERVER_ID)) {
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (observerService) {
return observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID,
false);
}
return NS_ERROR_SERVICE_NOT_AVAILABLE;
}
if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
ReleaseLock();
}
return NS_OK;
}
nsresult nsUpdateSyncManager::OpenLock() {
if (mLock != MULTI_INSTANCE_LOCK_HANDLE_ERROR) {
// Lock is already open.
return NS_OK;
}
// Only open the lock from the browser process.
// Our component registration should already have made sure of this.
if (NS_WARN_IF(XRE_GetProcessType() != GeckoProcessType_Default)) {
return NS_OK;
}
nsCOMPtr<nsIProperties> dirSvc =
do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
NS_ENSURE_TRUE(dirSvc, NS_ERROR_SERVICE_NOT_AVAILABLE);
nsCOMPtr<nsIFile> appFile;
nsresult rv = dirSvc->Get(XRE_EXECUTABLE_FILE, NS_GET_IID(nsIFile),
getter_AddRefs(appFile));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIFile> appDirFile;
rv = appFile->GetParent(getter_AddRefs(appDirFile));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString appDirPath;
rv = appDirFile->GetPath(appDirPath);
NS_ENSURE_SUCCESS(rv, rv);
mLock = mozilla::OpenMultiInstanceLock(UPDATE_LOCK_NAME_TOKEN,
PromiseFlatString(appDirPath).get());
NS_ENSURE_TRUE(mLock, NS_ERROR_FAILURE);
return NS_OK;
}
void nsUpdateSyncManager::ReleaseLock() {
if (mLock == MULTI_INSTANCE_LOCK_HANDLE_ERROR) {
// Lock is already released.
return;
}
mozilla::ReleaseMultiInstanceLock(mLock);
mLock = MULTI_INSTANCE_LOCK_HANDLE_ERROR;
}
NS_IMETHODIMP nsUpdateSyncManager::IsOtherInstanceRunning(bool* aResult) {
if (NS_WARN_IF(XRE_GetProcessType() != GeckoProcessType_Default)) {
return NS_ERROR_SERVICE_NOT_AVAILABLE;
}
if (mLock == MULTI_INSTANCE_LOCK_HANDLE_ERROR) {
return NS_ERROR_NOT_INITIALIZED;
}
bool rv = mozilla::IsOtherInstanceRunning(mLock, aResult);
NS_ENSURE_TRUE(rv, NS_ERROR_FAILURE);
return NS_OK;
}
NS_IMETHODIMP nsUpdateSyncManager::ResetLock() {
ReleaseLock();
return OpenLock();
}
|
