Bug 1130686 - Implement client.focus. r=baku

dom/webidl/Client.webidl

@@ -22,6 +22,8 @@ interface WindowClient : Client {
   readonly attribute VisibilityState visibilityState;
   readonly attribute boolean focused;
   readonly attribute FrameType frameType;
+
+  [Throws]
   Promise<WindowClient> focus();
 };
 

dom/workers/ServiceWorkerClient.h

@@ -50,10 +50,10 @@ public:
 
   ServiceWorkerClient(nsISupports* aOwner,
                       const ServiceWorkerClientInfo& aClientInfo)
-    : mOwner(aOwner),
-      mId(aClientInfo.mClientId),
-      mWindowId(aClientInfo.mWindowId),
-      mUrl(aClientInfo.mUrl)
+    : mOwner(aOwner)
+    , mId(aClientInfo.mClientId)
+    , mUrl(aClientInfo.mUrl)
+    , mWindowId(aClientInfo.mWindowId)
   {
     MOZ_ASSERT(aOwner);
   }
@@ -89,8 +89,10 @@ protected:
 private:
   nsCOMPtr<nsISupports> mOwner;
   nsString mId;
-  uint64_t mWindowId;
   nsString mUrl;
+
+protected:
+  uint64_t mWindowId;
 };
 
 } // namespace workers

dom/workers/ServiceWorkerWindowClient.cpp

@@ -7,6 +7,7 @@
 #include "ServiceWorkerWindowClient.h"
 
 #include "mozilla/dom/ClientBinding.h"
+#include "mozilla/dom/PromiseWorkerProxy.h"
 
 using namespace mozilla::dom;
 using namespace mozilla::dom::workers;
@@ -17,18 +18,135 @@ ServiceWorkerWindowClient::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGiv
   return WindowClientBinding::Wrap(aCx, this, aGivenProto);
 }
 
-already_AddRefed<Promise>
-ServiceWorkerWindowClient::Focus() const
+namespace {
+
+// Passing a null clientInfo will reject the promise with InvalidAccessError.
+class ResolveOrRejectPromiseRunnable final : public WorkerRunnable
 {
-  ErrorResult result;
+  nsRefPtr<PromiseWorkerProxy> mPromiseProxy;
+  UniquePtr<ServiceWorkerClientInfo> mClientInfo;
+
+public:
+  ResolveOrRejectPromiseRunnable(WorkerPrivate* aWorkerPrivate,
+                                 PromiseWorkerProxy* aPromiseProxy,
+                                 UniquePtr<ServiceWorkerClientInfo>&& aClientInfo)
+    : WorkerRunnable(aWorkerPrivate, WorkerThreadModifyBusyCount)
+    , mPromiseProxy(aPromiseProxy)
+    , mClientInfo(Move(aClientInfo))
+  {
+    AssertIsOnMainThread();
+  }
+
+  bool
+  WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+  {
+    MOZ_ASSERT(aWorkerPrivate);
+    aWorkerPrivate->AssertIsOnWorkerThread();
+
+    Promise* promise = mPromiseProxy->GetWorkerPromise();
+    MOZ_ASSERT(promise);
+
+    if (mClientInfo) {
+      nsRefPtr<ServiceWorkerWindowClient> client =
+        new ServiceWorkerWindowClient(promise->GetParentObject(), *mClientInfo);
+      promise->MaybeResolve(client);
+    } else {
+      promise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR);
+    }
+
+    // Release the reference on the worker thread.
+    mPromiseProxy->CleanUp(aCx);
+
+    return true;
+  }
+};
+
+class ClientFocusRunnable final : public nsRunnable
+{
+  uint64_t mWindowId;
+  nsRefPtr<PromiseWorkerProxy> mPromiseProxy;
+
+public:
+  ClientFocusRunnable(uint64_t aWindowId, PromiseWorkerProxy* aPromiseProxy)
+    : mWindowId(aWindowId)
+    , mPromiseProxy(aPromiseProxy)
+  {
+    MOZ_ASSERT(mPromiseProxy);
+    MOZ_ASSERT(mPromiseProxy->GetWorkerPromise());
+  }
+
+  NS_IMETHOD
+  Run() override
+  {
+    AssertIsOnMainThread();
+    nsGlobalWindow* window = nsGlobalWindow::GetOuterWindowWithId(mWindowId);
+    UniquePtr<ServiceWorkerClientInfo> clientInfo;
+
+    if (window) {
+      ErrorResult result;
+      //FIXME(catalinb): Bug 1144660 - check if we are allowed to focus here.
+      window->Focus(result);
+      clientInfo.reset(new ServiceWorkerClientInfo(window->GetDocument()));
+    }
+
+    DispatchResult(Move(clientInfo));
+    return NS_OK;
+  }
+
+private:
+  void
+  DispatchResult(UniquePtr<ServiceWorkerClientInfo>&& aClientInfo)
+  {
+    WorkerPrivate* workerPrivate = mPromiseProxy->GetWorkerPrivate();
+    MOZ_ASSERT(workerPrivate);
+
+    nsRefPtr<ResolveOrRejectPromiseRunnable> resolveRunnable =
+      new ResolveOrRejectPromiseRunnable(workerPrivate, mPromiseProxy,
+                                         Move(aClientInfo));
+
+    AutoJSAPI jsapi;
+    jsapi.Init();
+    JSContext* cx = jsapi.cx();
+    if (!resolveRunnable->Dispatch(cx)) {
+      nsRefPtr<PromiseWorkerProxyControlRunnable> controlRunnable =
+        new PromiseWorkerProxyControlRunnable(workerPrivate, mPromiseProxy);
+      if (!controlRunnable->Dispatch(cx)) {
+        NS_RUNTIMEABORT("Failed to dispatch Focus promise control runnable.");
+      }
+    }
+  }
+};
+
+} // anonymous namespace
+
+already_AddRefed<Promise>
+ServiceWorkerWindowClient::Focus(ErrorResult& aRv) const
+{
+  WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
+  MOZ_ASSERT(workerPrivate);
+  workerPrivate->AssertIsOnWorkerThread();
+
   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
   MOZ_ASSERT(global);
 
-  nsRefPtr<Promise> promise = Promise::Create(global, result);
-  if (NS_WARN_IF(result.Failed())) {
+  nsRefPtr<Promise> promise = Promise::Create(global, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
-  promise->MaybeReject(NS_ERROR_NOT_AVAILABLE);
+  nsRefPtr<PromiseWorkerProxy> promiseProxy =
+    PromiseWorkerProxy::Create(workerPrivate, promise);
+  if (!promiseProxy->GetWorkerPromise()) {
+    // Don't dispatch if adding the worker feature failed.
+    return promise.forget();
+  }
+
+  nsRefPtr<ClientFocusRunnable> r = new ClientFocusRunnable(mWindowId,
+                                                            promiseProxy);
+  aRv = NS_DispatchToMainThread(r);
+  if (NS_WARN_IF(aRv.Failed())) {
+    promise->MaybeReject(aRv.ErrorCode());
+  }
+
   return promise.forget();
 }

dom/workers/ServiceWorkerWindowClient.h

@@ -47,7 +47,7 @@ public:
   }
 
   already_AddRefed<Promise>
-  Focus() const;
+  Focus(ErrorResult& aRv) const;
 
 private:
   ~ServiceWorkerWindowClient()