uriloader/exthandler/nsLocalHandlerApp.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim:expandtab:shiftwidth=2:tabstop=2:cin:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsLocalHandlerApp.h"
   8 #include "nsIURI.h"
   9 #include "nsIProcess.h"
  10 #include "nsComponentManagerUtils.h"
  11 #include "mozilla/dom/Promise.h"
  12 #include "nsProxyRelease.h"
  13
  14 // XXX why does nsMIMEInfoImpl have a threadsafe nsISupports?  do we need one
  15 // here too?
  16 NS_IMPL_ISUPPORTS(nsLocalHandlerApp, nsILocalHandlerApp, nsIHandlerApp)
  17
  18 using namespace mozilla;
  19
  20 ////////////////////////////////////////////////////////////////////////////////
  21 //// nsIHandlerApp
  22
  23 NS_IMETHODIMP nsLocalHandlerApp::GetName(nsAString& aName) {
  24   if (mName.IsEmpty() && mExecutable) {
  25     // Don't want to cache this, just in case someone resets the app
  26     // without changing the description....
  27     mExecutable->GetLeafName(aName);
  28   } else {
  29     aName.Assign(mName);
  30   }
  31
  32   return NS_OK;
  33 }
  34
  35 /**
  36  * This method returns a std::function that will be executed on a thread other
  37  * than the main thread. To facilitate things, it should effectively be a global
  38  * function that does not maintain a reference to the this pointer. There should
  39  * be no reference to any objects that will be shared across threads. Sub-class
  40  * implementations should make local copies of everything they need and capture
  41  * those in the callback.
  42  */
  43 std::function<nsresult(nsString&)>
  44 nsLocalHandlerApp::GetPrettyNameOnNonMainThreadCallback() {
  45   nsString name;
  46
  47   // Calculate the name now, on the main thread, so as to avoid
  48   // doing anything with the this pointer on the other thread
  49   auto result = GetName(name);
  50
  51   return [name, result](nsString& aName) -> nsresult {
  52     aName = name;
  53     return result;
  54   };
  55 }
  56
  57 NS_IMETHODIMP
  58 nsLocalHandlerApp::PrettyNameAsync(JSContext* aCx, dom::Promise** aPromise) {
  59   NS_ENSURE_ARG_POINTER(aPromise);
  60
  61   *aPromise = nullptr;
  62
  63   if (!mExecutable) {
  64     return NS_ERROR_FAILURE;
  65   }
  66
  67   nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
  68   if (NS_WARN_IF(!global)) {
  69     return NS_ERROR_FAILURE;
  70   }
  71
  72   ErrorResult err;
  73   RefPtr<dom::Promise> outer = dom::Promise::Create(global, err);
  74   if (NS_WARN_IF(err.Failed())) {
  75     return err.StealNSResult();
  76   }
  77
  78   outer.forget(aPromise);
  79
  80   nsAutoString executablePath;
  81   nsresult result = mExecutable->GetPath(executablePath);
  82
  83   if (NS_FAILED(result) || executablePath.IsEmpty()) {
  84     (*aPromise)->MaybeReject(result);
  85     return NS_OK;
  86   }
  87
  88   nsMainThreadPtrHandle<dom::Promise> promiseHolder(
  89       new nsMainThreadPtrHolder<dom::Promise>(
  90           "nsLocalHandlerApp::prettyExecutableName Promise", *aPromise));
  91
  92   auto prettyNameGetter = GetPrettyNameOnNonMainThreadCallback();
  93
  94   result = NS_DispatchBackgroundTask(
  95       NS_NewRunnableFunction(
  96           __func__,
  97           [promiseHolder /* can't move this because if the dispatch fails, we
  98                             call reject on the promiseHolder */
  99            ,
 100            prettyNameGetter = std::move(prettyNameGetter)]() mutable -> void {
 101             nsAutoString prettyExecutableName;
 102
 103             nsresult result = prettyNameGetter(prettyExecutableName);
 104
 105             DebugOnly<nsresult> rv =
 106                 NS_DispatchToMainThread(NS_NewRunnableFunction(
 107                     __func__,
 108                     [promiseHolder = std::move(promiseHolder),
 109                      prettyExecutableName = std::move(prettyExecutableName),
 110                      result]() {
 111                       if (NS_FAILED(result)) {
 112                         promiseHolder.get()->MaybeReject(result);
 113                       } else {
 114                         promiseHolder.get()->MaybeResolve(prettyExecutableName);
 115                       }
 116                     }));
 117             NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
 118                                  "NS_DispatchToMainThread failed");
 119           }),
 120       NS_DISPATCH_EVENT_MAY_BLOCK);
 121
 122   if (NS_FAILED(result)) {
 123     promiseHolder.get()->MaybeReject(result);
 124   }
 125
 126   return NS_OK;
 127 }
 128
 129 NS_IMETHODIMP nsLocalHandlerApp::SetName(const nsAString& aName) {
 130   mName.Assign(aName);
 131
 132   return NS_OK;
 133 }
 134
 135 NS_IMETHODIMP
 136 nsLocalHandlerApp::SetDetailedDescription(const nsAString& aDescription) {
 137   mDetailedDescription.Assign(aDescription);
 138
 139   return NS_OK;
 140 }
 141
 142 NS_IMETHODIMP
 143 nsLocalHandlerApp::GetDetailedDescription(nsAString& aDescription) {
 144   aDescription.Assign(mDetailedDescription);
 145
 146   return NS_OK;
 147 }
 148
 149 NS_IMETHODIMP
 150 nsLocalHandlerApp::Equals(nsIHandlerApp* aHandlerApp, bool* _retval) {
 151   NS_ENSURE_ARG_POINTER(aHandlerApp);
 152
 153   *_retval = false;
 154
 155   // If the handler app isn't a local handler app, then it's not the same app.
 156   nsCOMPtr<nsILocalHandlerApp> localHandlerApp = do_QueryInterface(aHandlerApp);
 157   if (!localHandlerApp) return NS_OK;
 158
 159   // If either handler app doesn't have an executable, then they aren't
 160   // the same app.
 161   nsCOMPtr<nsIFile> executable;
 162   nsresult rv = localHandlerApp->GetExecutable(getter_AddRefs(executable));
 163   if (NS_FAILED(rv)) return rv;
 164
 165   // Equality for two empty nsIHandlerApp
 166   if (!executable && !mExecutable) {
 167     *_retval = true;
 168     return NS_OK;
 169   }
 170
 171   // At least one is set so they are not equal
 172   if (!mExecutable || !executable) return NS_OK;
 173
 174   // Check the command line parameter list lengths
 175   uint32_t len;
 176   localHandlerApp->GetParameterCount(&len);
 177   if (mParameters.Length() != len) return NS_OK;
 178
 179   // Check the command line params lists
 180   for (uint32_t idx = 0; idx < mParameters.Length(); idx++) {
 181     nsAutoString param;
 182     if (NS_FAILED(localHandlerApp->GetParameter(idx, param)) ||
 183         !param.Equals(mParameters[idx]))
 184       return NS_OK;
 185   }
 186
 187   return executable->Equals(mExecutable, _retval);
 188 }
 189
 190 NS_IMETHODIMP
 191 nsLocalHandlerApp::LaunchWithURI(
 192     nsIURI* aURI, mozilla::dom::BrowsingContext* aBrowsingContext) {
 193   // pass the entire URI to the handler.
 194   nsAutoCString spec;
 195   aURI->GetAsciiSpec(spec);
 196   return LaunchWithIProcess(spec);
 197 }
 198
 199 nsresult nsLocalHandlerApp::LaunchWithIProcess(const nsCString& aArg) {
 200   nsresult rv;
 201   nsCOMPtr<nsIProcess> process = do_CreateInstance(NS_PROCESS_CONTRACTID, &rv);
 202   if (NS_FAILED(rv)) return rv;
 203
 204   if (NS_FAILED(rv = process->Init(mExecutable))) return rv;
 205
 206   const char* string = aArg.get();
 207
 208   return process->Run(false, &string, 1);
 209 }
 210
 211 ////////////////////////////////////////////////////////////////////////////////
 212 //// nsILocalHandlerApp
 213
 214 NS_IMETHODIMP
 215 nsLocalHandlerApp::GetExecutable(nsIFile** aExecutable) {
 216   NS_IF_ADDREF(*aExecutable = mExecutable);
 217   return NS_OK;
 218 }
 219
 220 NS_IMETHODIMP
 221 nsLocalHandlerApp::SetExecutable(nsIFile* aExecutable) {
 222   mExecutable = aExecutable;
 223   return NS_OK;
 224 }
 225
 226 NS_IMETHODIMP
 227 nsLocalHandlerApp::GetParameterCount(uint32_t* aParameterCount) {
 228   *aParameterCount = mParameters.Length();
 229   return NS_OK;
 230 }
 231
 232 NS_IMETHODIMP
 233 nsLocalHandlerApp::ClearParameters() {
 234   mParameters.Clear();
 235   return NS_OK;
 236 }
 237
 238 NS_IMETHODIMP
 239 nsLocalHandlerApp::AppendParameter(const nsAString& aParam) {
 240   mParameters.AppendElement(aParam);
 241   return NS_OK;
 242 }
 243
 244 NS_IMETHODIMP
 245 nsLocalHandlerApp::GetParameter(uint32_t parameterIndex, nsAString& _retval) {
 246   if (mParameters.Length() <= parameterIndex) return NS_ERROR_INVALID_ARG;
 247
 248   _retval.Assign(mParameters[parameterIndex]);
 249   return NS_OK;
 250 }
 251
 252 NS_IMETHODIMP
 253 nsLocalHandlerApp::ParameterExists(const nsAString& aParam, bool* _retval) {
 254   *_retval = mParameters.Contains(aParam);
 255   return NS_OK;
 256 }