Backed out changeset bb739695f566 (bug 1421616)

Author: Tim Taubert

dom/credentialmanagement/CredentialsContainer.cpp

@@ -6,11 +6,12 @@
 
 #include "mozilla/dom/CredentialsContainer.h"
 #include "mozilla/dom/Promise.h"
+#include "mozilla/dom/WebAuthnManager.h"
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(CredentialsContainer, mParent, mManager)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(CredentialsContainer, mParent)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(CredentialsContainer)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(CredentialsContainer)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CredentialsContainer)
@@ -27,16 +28,6 @@ CredentialsContainer::CredentialsContainer(nsPIDOMWindowInner* aParent) :
 CredentialsContainer::~CredentialsContainer()
 {}
 
-void
-CredentialsContainer::EnsureWebAuthnManager()
-{
-  MOZ_ASSERT(NS_IsMainThread());
-
-  if (!mManager) {
-    mManager = new WebAuthnManager(mParent);
-  }
-}
-
 JSObject*
 CredentialsContainer::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
@@ -46,22 +37,22 @@ CredentialsContainer::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenPro
 already_AddRefed<Promise>
 CredentialsContainer::Get(const CredentialRequestOptions& aOptions)
 {
-  EnsureWebAuthnManager();
-  return mManager->GetAssertion(aOptions.mPublicKey, aOptions.mSignal);
+  RefPtr<WebAuthnManager> mgr = WebAuthnManager::GetOrCreate();
+  return mgr->GetAssertion(mParent, aOptions.mPublicKey, aOptions.mSignal);
 }
 
 already_AddRefed<Promise>
 CredentialsContainer::Create(const CredentialCreationOptions& aOptions)
 {
-  EnsureWebAuthnManager();
-  return mManager->MakeCredential(aOptions.mPublicKey, aOptions.mSignal);
+  RefPtr<WebAuthnManager> mgr = WebAuthnManager::GetOrCreate();
+  return mgr->MakeCredential(mParent, aOptions.mPublicKey, aOptions.mSignal);
 }
 
 already_AddRefed<Promise>
 CredentialsContainer::Store(const Credential& aCredential)
 {
-  EnsureWebAuthnManager();
-  return mManager->Store(aCredential);
+  RefPtr<WebAuthnManager> mgr = WebAuthnManager::GetOrCreate();
+  return mgr->Store(mParent, aCredential);
 }
 
 } // namespace dom

dom/credentialmanagement/CredentialsContainer.h

@@ -8,7 +8,6 @@
 #define mozilla_dom_CredentialsContainer_h
 
 #include "mozilla/dom/CredentialManagementBinding.h"
-#include "mozilla/dom/WebAuthnManager.h"
 
 namespace mozilla {
 namespace dom {
@@ -33,20 +32,15 @@ class CredentialsContainer final : public nsISupports
 
   already_AddRefed<Promise>
   Get(const CredentialRequestOptions& aOptions);
-
   already_AddRefed<Promise>
   Create(const CredentialCreationOptions& aOptions);
-
   already_AddRefed<Promise>
   Store(const Credential& aCredential);
 
 private:
   ~CredentialsContainer();
 
-  void EnsureWebAuthnManager();
-
   nsCOMPtr<nsPIDOMWindowInner> mParent;
-  RefPtr<WebAuthnManager> mManager;
 };
 
 } // namespace dom

dom/u2f/U2F.cpp

@@ -9,13 +9,13 @@
 #include "mozilla/dom/WebCryptoCommon.h"
 #include "mozilla/ipc/PBackgroundChild.h"
 #include "mozilla/ipc/BackgroundChild.h"
-#include "mozilla/dom/WebAuthnTransactionChild.h"
 #include "nsContentUtils.h"
 #include "nsICryptoHash.h"
 #include "nsIEffectiveTLDService.h"
 #include "nsNetCID.h"
 #include "nsNetUtil.h"
 #include "nsURLParsers.h"
+#include "U2FTransactionChild.h"
 #include "U2FUtil.h"
 #include "hasht.h"
 
@@ -293,9 +293,9 @@ U2F::~U2F()
   }
 
   if (mChild) {
-    RefPtr<WebAuthnTransactionChild> c;
+    RefPtr<U2FTransactionChild> c;
     mChild.swap(c);
-    c->Disconnect();
+    c->Send__delete__(c);
   }
 
   mRegisterCallback.reset();
@@ -437,8 +437,8 @@ U2F::Register(const nsAString& aAppId,
 }
 
 void
-U2F::FinishMakeCredential(const uint64_t& aTransactionId,
-                          nsTArray<uint8_t>& aRegBuffer)
+U2F::FinishRegister(const uint64_t& aTransactionId,
+                    nsTArray<uint8_t>& aRegBuffer)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
@@ -566,9 +566,9 @@ U2F::Sign(const nsAString& aAppId,
 }
 
 void
-U2F::FinishGetAssertion(const uint64_t& aTransactionId,
-                        nsTArray<uint8_t>& aCredentialId,
-                        nsTArray<uint8_t>& aSigBuffer)
+U2F::FinishSign(const uint64_t& aTransactionId,
+                nsTArray<uint8_t>& aCredentialId,
+                nsTArray<uint8_t>& aSigBuffer)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
@@ -749,7 +749,7 @@ U2F::MaybeCreateBackgroundActor()
     return false;
   }
 
-  RefPtr<WebAuthnTransactionChild> mgr(new WebAuthnTransactionChild(this));
+  RefPtr<U2FTransactionChild> mgr(new U2FTransactionChild(this));
   PWebAuthnTransactionChild* constructedMgr =
     actorChild->SendPWebAuthnTransactionConstructor(mgr);
 

dom/u2f/U2F.h

@@ -12,7 +12,6 @@
 #include "mozilla/dom/BindingDeclarations.h"
 #include "mozilla/dom/Nullable.h"
 #include "mozilla/dom/U2FBinding.h"
-#include "mozilla/dom/WebAuthnManagerBase.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/MozPromise.h"
 #include "nsProxyRelease.h"
@@ -25,7 +24,7 @@ class nsISerialEventTarget;
 namespace mozilla {
 namespace dom {
 
-class WebAuthnTransactionChild;
+class U2FTransactionChild;
 class U2FRegisterCallback;
 class U2FSignCallback;
 
@@ -60,7 +59,6 @@ class U2FTransaction
 };
 
 class U2F final : public nsIDOMEventListener
-                , public WebAuthnManagerBase
                 , public nsWrapperCache
 {
 public:
@@ -99,22 +97,18 @@ class U2F final : public nsIDOMEventListener
        const Optional<Nullable<int32_t>>& opt_aTimeoutSeconds,
        ErrorResult& aRv);
 
-  // WebAuthnManagerBase
-
   void
-  FinishMakeCredential(const uint64_t& aTransactionId,
-                       nsTArray<uint8_t>& aRegBuffer) override;
+  FinishRegister(const uint64_t& aTransactionId, nsTArray<uint8_t>& aRegBuffer);
 
   void
-  FinishGetAssertion(const uint64_t& aTransactionId,
-                     nsTArray<uint8_t>& aCredentialId,
-                     nsTArray<uint8_t>& aSigBuffer) override;
+  FinishSign(const uint64_t& aTransactionId,
+             nsTArray<uint8_t>& aCredentialId,
+             nsTArray<uint8_t>& aSigBuffer);
 
   void
-  RequestAborted(const uint64_t& aTransactionId,
-                 const nsresult& aError) override;
+  RequestAborted(const uint64_t& aTransactionId, const nsresult& aError);
 
-  void ActorDestroyed() override;
+  void ActorDestroyed();
 
 private:
   ~U2F();
@@ -141,7 +135,7 @@ class U2F final : public nsIDOMEventListener
   Maybe<nsMainThreadPtrHandle<U2FSignCallback>> mSignCallback;
 
   // IPC Channel to the parent process.
-  RefPtr<WebAuthnTransactionChild> mChild;
+  RefPtr<U2FTransactionChild> mChild;
 
   // The current transaction, if any.
   Maybe<U2FTransaction> mTransaction;

dom/u2f/U2FTransactionChild.cpp

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "U2FTransactionChild.h"
+
+namespace mozilla {
+namespace dom {
+
+mozilla::ipc::IPCResult
+U2FTransactionChild::RecvConfirmRegister(const uint64_t& aTransactionId,
+                                         nsTArray<uint8_t>&& aRegBuffer)
+{
+  mU2F->FinishRegister(aTransactionId, aRegBuffer);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+U2FTransactionChild::RecvConfirmSign(const uint64_t& aTransactionId,
+                                     nsTArray<uint8_t>&& aCredentialId,
+                                     nsTArray<uint8_t>&& aBuffer)
+{
+  mU2F->FinishSign(aTransactionId, aCredentialId, aBuffer);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+U2FTransactionChild::RecvAbort(const uint64_t& aTransactionId,
+                               const nsresult& aError)
+{
+  mU2F->RequestAborted(aTransactionId, aError);
+  return IPC_OK();
+}
+
+void
+U2FTransactionChild::ActorDestroy(ActorDestroyReason why)
+{
+  mU2F->ActorDestroyed();
+}
+
+} // namespace dom
+} // namespace mozilla

dom/u2f/U2FTransactionChild.h

@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_U2FTransactionChild_h
+#define mozilla_dom_U2FTransactionChild_h
+
+#include "mozilla/dom/WebAuthnTransactionChildBase.h"
+
+/*
+ * Child process IPC implementation for U2F API. Receives results of U2F
+ * transactions from the parent process, and sends them to the U2FManager
+ * to either cancel the transaction, or be formatted and relayed to content.
+ */
+
+namespace mozilla {
+namespace dom {
+
+class U2FTransactionChild final : public WebAuthnTransactionChildBase
+{
+public:
+  explicit U2FTransactionChild(U2F* aU2F) : mU2F(aU2F) {
+    MOZ_ASSERT(mU2F);
+  }
+
+  mozilla::ipc::IPCResult
+  RecvConfirmRegister(const uint64_t& aTransactionId,
+                      nsTArray<uint8_t>&& aRegBuffer) override;
+
+  mozilla::ipc::IPCResult
+  RecvConfirmSign(const uint64_t& aTransactionId,
+                  nsTArray<uint8_t>&& aCredentialId,
+                  nsTArray<uint8_t>&& aBuffer) override;
+
+  mozilla::ipc::IPCResult
+  RecvAbort(const uint64_t& aTransactionId, const nsresult& aError) override;
+
+  void ActorDestroy(ActorDestroyReason why) override;
+
+private:
+  // ~U2F() will destroy child actors.
+  U2F* mU2F;
+};
+
+}
+}
+
+#endif //mozilla_dom_U2FTransactionChild_h

dom/u2f/U2FTransactionParent.cpp

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "U2FTransactionParent.h"
+#include "mozilla/dom/U2FTokenManager.h"
+#include "mozilla/ipc/BackgroundParent.h"
+
+namespace mozilla {
+namespace dom {
+
+mozilla::ipc::IPCResult
+U2FTransactionParent::RecvRequestRegister(const uint64_t& aTransactionId,
+                                          const WebAuthnMakeCredentialInfo& aTransactionInfo)
+{
+  AssertIsOnBackgroundThread();
+  U2FTokenManager* mgr = U2FTokenManager::Get();
+  mgr->Register(this, aTransactionId, aTransactionInfo);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+U2FTransactionParent::RecvRequestSign(const uint64_t& aTransactionId,
+                                      const WebAuthnGetAssertionInfo& aTransactionInfo)
+{
+  AssertIsOnBackgroundThread();
+  U2FTokenManager* mgr = U2FTokenManager::Get();
+  mgr->Sign(this, aTransactionId, aTransactionInfo);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+U2FTransactionParent::RecvRequestCancel(const uint64_t& aTransactionId)
+{
+  AssertIsOnBackgroundThread();
+  U2FTokenManager* mgr = U2FTokenManager::Get();
+  mgr->Cancel(this, aTransactionId);
+  return IPC_OK();
+}
+
+void
+U2FTransactionParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+  AssertIsOnBackgroundThread();
+  U2FTokenManager* mgr = U2FTokenManager::Get();
+  mgr->MaybeClearTransaction(this);
+}
+
+} // namespace dom
+} // namespace mozilla