tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

CachePurgeLock.cpp (2866B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 #include "CachePurgeLock.h"
      6 #include "nsCOMPtr.h"
      7 #include "nsIFile.h"
      8 #include "nsAppRunner.h"
      9 #include "mozilla/MultiInstanceLock.h"
     10 #include "nsLocalFile.h"
     11 
     12 namespace mozilla::net {
     13 
     14 NS_IMPL_ISUPPORTS(CachePurgeLock, nsICachePurgeLock)
     15 
     16 static nsresult PrepareLockArguments(const nsACString& profileName,
     17                                     nsCString& lockName,
     18                                     nsString& appDirPath) {
     19  nsresult rv;
     20 
     21  nsCOMPtr<nsIFile> appFile = mozilla::GetNormalizedAppFile(nullptr);
     22  if (!appFile) {
     23    return NS_ERROR_NOT_AVAILABLE;
     24  }
     25 
     26  nsCOMPtr<nsIFile> appDirFile;
     27  rv = appFile->GetParent(getter_AddRefs(appDirFile));
     28  NS_ENSURE_SUCCESS(rv, rv);
     29 
     30  rv = appDirFile->GetPath(appDirPath);
     31  NS_ENSURE_SUCCESS(rv, rv);
     32 
     33  lockName = profileName;
     34  lockName.Append("-cachePurge");
     35 
     36  return NS_OK;
     37 }
     38 
     39 NS_IMETHODIMP
     40 CachePurgeLock::GetLockFile(const nsACString& profileName, nsIFile** aResult) {
     41  nsresult rv;
     42  nsCString lockName;
     43  nsString appDirPath;
     44  rv = PrepareLockArguments(profileName, lockName, appDirPath);
     45  if (NS_FAILED(rv)) {
     46    return rv;
     47  }
     48 
     49  nsCString filePath;
     50  if (!GetMultiInstanceLockFileName(lockName.get(), appDirPath.get(),
     51                                    filePath)) {
     52    return NS_ERROR_NOT_AVAILABLE;
     53  }
     54 
     55  nsCOMPtr<nsIFile> lockFile = new nsLocalFile();
     56  rv = lockFile->InitWithNativePath(filePath);
     57  NS_ENSURE_SUCCESS(rv, rv);
     58 
     59  lockFile.forget(aResult);
     60  return NS_OK;
     61 }
     62 
     63 NS_IMETHODIMP
     64 CachePurgeLock::Lock(const nsACString& profileName) {
     65  nsresult rv;
     66  if (mLock != MULTI_INSTANCE_LOCK_HANDLE_ERROR) {
     67    // Lock is already open.
     68    return NS_OK;
     69  }
     70 
     71  nsCString lockName;
     72  nsString appDirPath;
     73  rv = PrepareLockArguments(profileName, lockName, appDirPath);
     74  if (NS_FAILED(rv)) {
     75    return rv;
     76  }
     77 
     78  mLock = mozilla::OpenMultiInstanceLock(lockName.get(), appDirPath.get());
     79  if (mLock == MULTI_INSTANCE_LOCK_HANDLE_ERROR) {
     80    return NS_ERROR_FAILURE;
     81  }
     82 
     83  return NS_OK;
     84 }
     85 
     86 NS_IMETHODIMP
     87 CachePurgeLock::IsOtherInstanceRunning(bool* aResult) {
     88  if (NS_WARN_IF(XRE_GetProcessType() != GeckoProcessType_Default)) {
     89    return NS_ERROR_SERVICE_NOT_AVAILABLE;
     90  }
     91 
     92  if (mLock == MULTI_INSTANCE_LOCK_HANDLE_ERROR) {
     93    return NS_ERROR_NOT_INITIALIZED;
     94  }
     95 
     96  bool rv = mozilla::IsOtherInstanceRunning(mLock, aResult);
     97  NS_ENSURE_TRUE(rv, NS_ERROR_FAILURE);
     98 
     99  return NS_OK;
    100 }
    101 
    102 NS_IMETHODIMP
    103 CachePurgeLock::Unlock() {
    104  if (mLock == MULTI_INSTANCE_LOCK_HANDLE_ERROR) {
    105    // Lock is already released.
    106    return NS_OK;
    107  }
    108 
    109  mozilla::ReleaseMultiInstanceLock(mLock);
    110  mLock = MULTI_INSTANCE_LOCK_HANDLE_ERROR;
    111 
    112  return NS_OK;
    113 }
    114 
    115 }  // namespace mozilla::net