Attachment #8731371 for bug #1217544

Attachment #8731371: Part 5: SyncService for bug #1217544

View | Details | Raw Unified | Return to bug 1217544
Collapse All | Expand All





/* -*- 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 "SyncManagerParent.h"
#include "SyncService.h"

#include "mozilla/unused.h"
#include "mozilla/ipc/BackgroundParent.h"

namespace mozilla {

using namespace ipc;

namespace dom {

SyncManagerParent::SyncManagerParent()
  : mService(SyncService::GetOrCreate())
{
  AssertIsOnBackgroundThread();
  mService->RegisterActor(this);
}

SyncManagerParent::~SyncManagerParent()
{
  AssertIsOnBackgroundThread();
}

void SyncManagerParent::ActorDestroy(ActorDestroyReason aWhy)
{
  AssertIsOnBackgroundThread();

  if (mService) {
    mService->UnregisterActor(this);
  }
}

bool SyncManagerParent::RecvRequest(const nsID& aRequestId,
                                    const SyncOp& aOp)
{
  AssertIsOnBackgroundThread();

  if (NS_WARN_IF(!mService)) {
    return false;
  }

  switch(aOp.mArgs().type()) {
    case SyncOpArgs::TSyncRegisterArgs:
    {
      // XXX this needs to be async
      mService->Register(aOp.mPrincipal(),
          aOp.mArgs().get_SyncRegisterArgs().mScope(),
          aOp.mArgs().get_SyncRegisterArgs().mTag());
      const SyncRegisterResponse response(true);
      //const SyncOpError response(static_cast<uint32_t>(NS_ERROR_FAILURE));
      Unused << SendResponse(aRequestId, response);
      break;
    }
    case SyncOpArgs::TSyncGetTagsArgs:
    {
      //XXX Do GetTags.

  }
  return true;
}

bool SyncManagerParent::RecvShutdown()
{
  AssertIsOnBackgroundThread();

  if (NS_WARN_IF(!mService)) {
    return false;
  }

  Unused << Send__delete__(this);

  return true;
}

} // namespace dom
} // namespace mozilla





namespace mozilla {

namespace ipc {
class BackgroundParentImpl;
} // namespace ipc

namespace dom {

class SyncService;

class SyncManagerParent final : public PSyncManagerParent
{
  friend class mozilla::ipc::BackgroundParentImpl;

public:
  virtual bool RecvRequest(const nsID& aRequestId,
                           const SyncOp& aOp) override;

  virtual bool RecvShutdown() override;
private:
  SyncManagerParent();
  ~SyncManagerParent();

  virtual void ActorDestroy(ActorDestroyReason aWhy) override;

  RefPtr<SyncService> mService;
};

} // namespace dom
} // namespace mozilla

#endif // mozilla_dom_SyncManagerParent_h



-      Line
+  Link Here
-      Line 0
+  Link Here
+/* -*- 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 "SyncService.h"
+#include "SyncManagerParent.h"
+namespace mozilla {
+namespace dom {
+namespace {
+  SyncService* sInstance = nullptr;
+} // namespace
+SyncService::SyncService()
+{
+  AssertIsOnBackgroundThread();
+  // sInstance is a raw SyncService*.
+  MOZ_ASSERT(!sInstance);
+  sInstance = this;
+}
+SyncService::~SyncService()
+{
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(sInstance == this);
+  MOZ_ASSERT(mSyncManagerActors.Count() == 0);
+  sInstance = nullptr;
+}
+// static
+already_AddRefed<SyncService>
+SyncService::GetOrCreate()
+{
+  AssertIsOnBackgroundThread();
+  RefPtr<SyncService> instance = sInstance;
+  if (!instance) {
+    instance = new SyncService();
+  }
+  return instance.forget();
+}
+void
+SyncService::RegisterActor(SyncManagerParent* aParent)
+{
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(aParent);
+  MOZ_ASSERT(!mSyncManagerActors.Contains(aParent));
+  mSyncManagerActors.PutEntry(aParent);
+}
+void
+SyncService::UnregisterActor(SyncManagerParent* aParent)
+{
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(aParent);
+  MOZ_ASSERT(mSyncManagerActors.Contains(aParent));
+  mSyncManagerActors.RemoveEntry(aParent);
+}
+void
+SyncService::RegisterActor(workers::ServiceWorkerManagerParent* aParent)
+{
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(aParent);
+  MOZ_ASSERT(!mServiceWorkerManagerActors.Contains(aParent));
+  mServiceWorkerManagerActors.PutEntry(aParent);
+}
+void
+SyncService::UnregisterActor(workers::ServiceWorkerManagerParent* aParent)
+{
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(aParent);
+  MOZ_ASSERT(mServiceWorkerManagerActors.Contains(aParent));
+  mServiceWorkerManagerActors.RemoveEntry(aParent);
+}
+bool
+SyncService::Register(const PrincipalInfo& aPrincipal,
+                      const nsString& aScope,
+                      const nsString& aTag)
+{
+  // XXX implement me.
+  //XXX REMOVE ME - Sync event test.
+  for (auto iter = mServiceWorkerManagerActors.Iter(); !iter.Done(); iter.Next()) {
+    RefPtr<ServiceWorkerManagerParent> parent = iter.Get()->GetKey();
+    MOZ_ASSERT(parent);
+    Unused << parent->SendNotifySyncEvent(aPrincipal, aScope, aTag, false);
+  }
+  return true;
+}
+void
+SyncService::GetTags(const PrincipalInfo& aPrincipal,
+                     const nsString& aScope,
+                     nsTArray<nsString>& aTags)
+{
+  // XXX implement me.
+}
+} // namespace dom
+} // namespace mozilla

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* -*- 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_SyncService_h
+#define mozilla_dom_SyncService_h
+#include "nsISupportsImpl.h"
+#include "nsHashKeys.h"
+#include "nsTHashtable.h"
+#include "ServiceWorkerManagerParent.h"
+namespace mozilla {
+namespace dom {
+namespace workers {
+class ServiceWorkerManagerParent;
+} // namespace workers
+class SyncManagerParent;
+class SyncService final
+{
+public:
+  NS_INLINE_DECL_REFCOUNTING(SyncService)
+  static already_AddRefed<SyncService> GetOrCreate();
+  void RegisterActor(SyncManagerParent* aParent);
+  void UnregisterActor(SyncManagerParent* aParent);
+  void RegisterActor(workers::ServiceWorkerManagerParent* aParent);
+  void UnregisterActor(workers::ServiceWorkerManagerParent* aParent);
+  bool Register(const PrincipalInfo& aPrincipal,
+                const nsString& aScope,
+                const nsString& aTag);
+  void GetTags(const PrincipalInfo& aPrincipal,
+               const nsString& aScope,
+               nsTArray<nsString>& aTags);
+private:
+  SyncService();
+  ~SyncService();
+  nsTHashtable<nsPtrHashKey<SyncManagerParent>> mSyncManagerActors;
+  nsTHashtable<nsPtrHashKey<workers::ServiceWorkerManagerParent>>
+    mServiceWorkerManagerActors;
+};
+} // namespace dom
+} // namespace mozilla
+#endif // mozilla_dom_SyncService_h






EXPORTS.mozilla.dom += [
    'SyncManager.h'
]

UNIFIED_SOURCES += [
    'SyncManager.cpp',
    'SyncManagerChild.cpp',
    'SyncManagerParent.cpp',
    'SyncService.cpp'
]

IPDL_SOURCES += [
    'PSyncManager.ipdl',
    'SyncIPCTypes.ipdlh'
]

LOCAL_INCLUDES += [





/* -*- 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 "ServiceWorkerManagerParent.h"
#include "ServiceWorkerManagerService.h"
#include "SyncService.h"
#include "mozilla/AppProcessChecker.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/ServiceWorkerRegistrar.h"
#include "mozilla/ipc/BackgroundParent.h"
#include "mozilla/ipc/BackgroundUtils.h"
#include "mozilla/unused.h"
#include "nsThreadUtils.h"


  PrincipalInfo mPrincipalInfo;
  RefPtr<nsRunnable> mCallback;
  nsCOMPtr<nsIThread> mBackgroundThread;
};

} // namespace

ServiceWorkerManagerParent::ServiceWorkerManagerParent()
  : mServiceWorkerService(ServiceWorkerManagerService::GetOrCreate())
  , mSyncService(SyncService::GetOrCreate())
  , mID(++sServiceWorkerManagerParentID)
  , mActorDestroyed(false)
{
  AssertIsOnBackgroundThread();
  mServiceWorkerService->RegisterActor(this);
  mSyncService->RegisterActor(this);
}

ServiceWorkerManagerParent::~ServiceWorkerManagerParent()
{
  AssertIsOnBackgroundThread();
}

already_AddRefed<ContentParent>

}

bool
ServiceWorkerManagerParent::RecvPropagateSoftUpdate(const PrincipalOriginAttributes& aOriginAttributes,
                                                    const nsString& aScope)
{
  AssertIsOnBackgroundThread();

  if (NS_WARN_IF(!mServiceWorkerService)) {
    return false;
  }

  mServiceWorkerService->PropagateSoftUpdate(mID, aOriginAttributes, aScope);
  return true;
}

bool
ServiceWorkerManagerParent::RecvPropagateUnregister(const PrincipalInfo& aPrincipalInfo,
                                                    const nsString& aScope)
{
  AssertIsOnBackgroundThread();

  if (NS_WARN_IF(!mServiceWorkerService)) {
    return false;
  }

  mServiceWorkerService->PropagateUnregister(mID, aPrincipalInfo, aScope);
  return true;
}

bool
ServiceWorkerManagerParent::RecvPropagateRemove(const nsCString& aHost)
{
  AssertIsOnBackgroundThread();

  if (NS_WARN_IF(!mServiceWorkerService)) {
    return false;
  }

  mServiceWorkerService->PropagateRemove(mID, aHost);
  return true;
}

bool
ServiceWorkerManagerParent::RecvPropagateRemoveAll()
{
  AssertIsOnBackgroundThread();

  if (NS_WARN_IF(!mServiceWorkerService)) {
    return false;
  }

  mServiceWorkerService->PropagateRemoveAll(mID);
  return true;
}

bool
ServiceWorkerManagerParent::RecvShutdown()
{
  AssertIsOnBackgroundThread();

  if (NS_WARN_IF(!mServiceWorkerService)) {
    return false;
  }

  mServiceWorkerService->UnregisterActor(this);
  mServiceWorkerService = nullptr;

  Unused << Send__delete__(this);
  return true;
}

void
ServiceWorkerManagerParent::ActorDestroy(ActorDestroyReason aWhy)
{
  AssertIsOnBackgroundThread();

  mActorDestroyed = true;

  if (mServiceWorkerService) {
    // This object is about to be released and with it, also mServiceWorkerService will be
    // released too.
    mServiceWorkerService->UnregisterActor(this);
  }
}

} // namespace workers
} // namespace dom
} // namespace mozilla






class PrincipalOriginAttributes;

namespace ipc {
class BackgroundParentImpl;
} // namespace ipc

namespace dom {

class SyncService;

namespace workers {

class ServiceWorkerManagerService;

class ServiceWorkerManagerParent final : public PServiceWorkerManagerParent
{
  friend class mozilla::ipc::BackgroundParentImpl;


  virtual bool RecvPropagateRemove(const nsCString& aHost) override;

  virtual bool RecvPropagateRemoveAll() override;

  virtual bool RecvShutdown() override;

  virtual void ActorDestroy(ActorDestroyReason aWhy) override;

  RefPtr<ServiceWorkerManagerService> mServiceWorkerService;
  RefPtr<SyncService> mSyncService;

  // We use this ID in the Service in order to avoid the sending of messages to
  // ourself.
  uint64_t mID;

  bool mActorDestroyed;
};






    'PServiceWorkerManager.ipdl',
    'ServiceWorkerRegistrarTypes.ipdlh',
]

LOCAL_INCLUDES += [
    '../base',
    '../system',
    '/dom/base',
    '/dom/sync',
    '/xpcom/build',
    '/xpcom/threads',
]

include('/ipc/chromium/chromium-config.mozbuild')

FINAL_LIBRARY = 'xul'


Return to bug 1217544