dom/bluetooth/BluetoothMapRequestHandle.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   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 "BluetoothCommon.h"
   8 #include "BluetoothMapRequestHandle.h"
   9 #include "BluetoothReplyRunnable.h"
  10 #include "BluetoothService.h"
  11
  12 #include "mozilla/dom/BluetoothMapRequestHandleBinding.h"
  13 #include "mozilla/dom/ContentChild.h"
  14 #include "mozilla/dom/Promise.h"
  15
  16 using namespace mozilla;
  17 using namespace dom;
  18
  19 USING_BLUETOOTH_NAMESPACE
  20
  21 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(BluetoothMapRequestHandle, mOwner)
  22 NS_IMPL_CYCLE_COLLECTING_ADDREF(BluetoothMapRequestHandle)
  23 NS_IMPL_CYCLE_COLLECTING_RELEASE(BluetoothMapRequestHandle)
  24 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BluetoothMapRequestHandle)
  25   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  26   NS_INTERFACE_MAP_ENTRY(nsISupports)
  27 NS_INTERFACE_MAP_END
  28
  29 BluetoothMapRequestHandle::BluetoothMapRequestHandle(nsPIDOMWindow* aOwner)
  30   : mOwner(aOwner)
  31 {
  32   MOZ_ASSERT(aOwner);
  33 }
  34
  35 BluetoothMapRequestHandle::~BluetoothMapRequestHandle()
  36 {
  37 }
  38
  39 already_AddRefed<BluetoothMapRequestHandle>
  40 BluetoothMapRequestHandle::Create(nsPIDOMWindow* aOwner)
  41 {
  42   MOZ_ASSERT(aOwner);
  43
  44   nsRefPtr<BluetoothMapRequestHandle> handle =
  45     new BluetoothMapRequestHandle(aOwner);
  46
  47   return handle.forget();
  48 }
  49
  50 already_AddRefed<Promise>
  51 BluetoothMapRequestHandle::ReplyToFolderListing(long aMasId,
  52   const nsAString& aFolderlists, ErrorResult& aRv)
  53 {
  54   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
  55   if (!global) {
  56     aRv.Throw(NS_ERROR_FAILURE);
  57     return nullptr;
  58   }
  59
  60   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
  61   NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
  62
  63   BluetoothService* bs = BluetoothService::Get();
  64   if (!bs) {
  65     aRv.Throw(NS_ERROR_FAILURE);
  66     return nullptr;
  67   }
  68
  69   if (XRE_GetProcessType() == GeckoProcessType_Default) {
  70     // In-process reply
  71     bs->ReplyToMapFolderListing(aMasId, aFolderlists,
  72       new BluetoothVoidReplyRunnable(nullptr, promise));
  73   } else {
  74     ContentChild *cc = ContentChild::GetSingleton();
  75     if (!cc) {
  76       aRv.Throw(NS_ERROR_FAILURE);
  77       return nullptr;
  78     }
  79
  80     bs->ReplyToMapFolderListing(aMasId, aFolderlists,
  81       new BluetoothVoidReplyRunnable(nullptr, promise));
  82   }
  83
  84   return promise.forget();
  85 }
  86
  87 already_AddRefed<Promise>
  88 BluetoothMapRequestHandle::ReplyToMessagesListing(long aMasId,
  89                                                   File& aBlob,
  90                                                   bool aNewMessage,
  91                                                   const nsAString& aTimestamp,
  92                                                   int aSize,
  93                                                   ErrorResult& aRv)
  94 {
  95   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
  96   if (!global) {
  97     aRv.Throw(NS_ERROR_FAILURE);
  98     return nullptr;
  99   }
 100
 101   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
 102   NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
 103
 104   BluetoothService* bs = BluetoothService::Get();
 105   if (!bs) {
 106     aRv.Throw(NS_ERROR_FAILURE);
 107     return nullptr;
 108   }
 109
 110   if (XRE_GetProcessType() == GeckoProcessType_Default) {
 111     // In-process reply
 112     bs->ReplyToMapMessagesListing(aMasId, &aBlob, aNewMessage, aTimestamp,
 113       aSize, new BluetoothVoidReplyRunnable(nullptr, promise));
 114   } else {
 115     ContentChild *cc = ContentChild::GetSingleton();
 116     if (!cc) {
 117       aRv.Throw(NS_ERROR_FAILURE);
 118       return nullptr;
 119     }
 120
 121     BlobChild* actor = cc->GetOrCreateActorForBlob(&aBlob);
 122     if (!actor) {
 123       aRv.Throw(NS_ERROR_FAILURE);
 124       return nullptr;
 125     }
 126
 127     bs->ReplyToMapMessagesListing(nullptr, actor, aMasId, aNewMessage,
 128       aTimestamp, aSize, new BluetoothVoidReplyRunnable(nullptr, promise));
 129   }
 130
 131   return promise.forget();
 132 }
 133
 134 already_AddRefed<Promise>
 135 BluetoothMapRequestHandle::ReplyToGetMessage(long aMasId, File& aBlob,
 136                                              ErrorResult& aRv)
 137 {
 138   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
 139   if (!global) {
 140     aRv.Throw(NS_ERROR_FAILURE);
 141     return nullptr;
 142   }
 143
 144   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
 145   NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
 146
 147   BluetoothService* bs = BluetoothService::Get();
 148   if (!bs) {
 149     aRv.Throw(NS_ERROR_FAILURE);
 150     return nullptr;
 151   }
 152
 153   if (XRE_GetProcessType() == GeckoProcessType_Default) {
 154     // In-process reply
 155     bs->ReplyToMapGetMessage(&aBlob, aMasId,
 156       new BluetoothVoidReplyRunnable(nullptr, promise));
 157   } else {
 158     ContentChild *cc = ContentChild::GetSingleton();
 159     if (!cc) {
 160       aRv.Throw(NS_ERROR_FAILURE);
 161       return nullptr;
 162     }
 163
 164     BlobChild* actor = cc->GetOrCreateActorForBlob(&aBlob);
 165     if (!actor) {
 166       aRv.Throw(NS_ERROR_FAILURE);
 167       return nullptr;
 168     }
 169
 170     bs->ReplyToMapGetMessage(nullptr, actor, aMasId,
 171       new BluetoothVoidReplyRunnable(nullptr, promise));
 172   }
 173
 174   return promise.forget();
 175 }
 176
 177 already_AddRefed<Promise>
 178 BluetoothMapRequestHandle::ReplyToSetMessageStatus(long aMasId,
 179                                                    bool aStatus,
 180                                                    ErrorResult& aRv)
 181 {
 182   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
 183   if (!global) {
 184     aRv.Throw(NS_ERROR_FAILURE);
 185     return nullptr;
 186   }
 187
 188   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
 189   NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
 190
 191   BluetoothService* bs = BluetoothService::Get();
 192   if (!bs) {
 193     aRv.Throw(NS_ERROR_FAILURE);
 194     return nullptr;
 195   }
 196
 197   bs->ReplyToMapSetMessageStatus(aMasId, aStatus,
 198     new BluetoothVoidReplyRunnable(nullptr, promise));
 199
 200   return promise.forget();
 201 }
 202
 203 already_AddRefed<Promise>
 204 BluetoothMapRequestHandle::ReplyToSendMessage(long aMasId,
 205                                               bool aStatus,
 206                                               ErrorResult& aRv)
 207 {
 208   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
 209   if (!global) {
 210     aRv.Throw(NS_ERROR_FAILURE);
 211     return nullptr;
 212   }
 213
 214   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
 215   NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
 216
 217   BluetoothService* bs = BluetoothService::Get();
 218   if (!bs) {
 219     aRv.Throw(NS_ERROR_FAILURE);
 220     return nullptr;
 221   }
 222
 223   bs->ReplyToMapSendMessage(aMasId, aStatus,
 224     new BluetoothVoidReplyRunnable(nullptr, promise));
 225
 226   return promise.forget();
 227 }
 228
 229 already_AddRefed<Promise>
 230 BluetoothMapRequestHandle::ReplyToMessageUpdate(long aMasId,
 231                                                 bool aStatus,
 232                                                 ErrorResult& aRv)
 233 {
 234   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
 235   if (!global) {
 236     aRv.Throw(NS_ERROR_FAILURE);
 237     return nullptr;
 238   }
 239
 240   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
 241   NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
 242
 243   BluetoothService* bs = BluetoothService::Get();
 244   if (!bs) {
 245     aRv.Throw(NS_ERROR_FAILURE);
 246     return nullptr;
 247   }
 248
 249   bs->ReplyToMapMessageUpdate(aMasId, aStatus,
 250     new BluetoothVoidReplyRunnable(nullptr, promise));
 251
 252   return promise.forget();
 253 }
 254
 255 JSObject*
 256 BluetoothMapRequestHandle::WrapObject(JSContext* aCx)
 257 {
 258   return BluetoothMapRequestHandleBinding::Wrap(aCx, this);
 259 }