Oilpan: Ship Oilpan for serviceworkers/

Source/platform/serviceworkers/ServiceWorkerRegistrationProxy.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ServiceWorkerRegistrationProxy_h
+#define ServiceWorkerRegistrationProxy_h
+
+#include "platform/heap/Handle.h"
+#include "public/platform/WebServiceWorkerRegistrationProxy.h"
+
+namespace blink {
+
+class ServiceWorkerRegistration;
+
+class PLATFORM_EXPORT ServiceWorkerRegistrationProxy FINAL : public GarbageCollected<ServiceWorkerRegistrationProxy> {
+public:
+    static ServiceWorkerRegistrationProxy* create(ServiceWorkerRegistration* registration)
+    {
+        return new ServiceWorkerRegistrationProxy(registration);
+    }
+
+    ServiceWorkerRegistration* registration() const { return m_registration; }
+
+    void trace(Visitor* visitor) { }
+
+private:
+    explicit ServiceWorkerRegistrationProxy(ServiceWorkerRegistration* registration)
+        : m_registration(registration)
+    {
+    }
+
+    // Ideally we want to make this a Member<ServiceWorkerRegistration>, but we cannot do it
+    // because it requires to include modules/serviceworkers/ServiceWorkerRegistration.h.
+    // This violates the include dependency rule.
+    // Using a raw pointer is safe, because the ServiceWorkerRegistrationProxy object is kept
+    // alive by the ServiceWorkerRegistration object.
+    GC_PLUGIN_IGNORE("")
+    ServiceWorkerRegistration* m_registration;

[Mads Ager (chromium), 2014/09/03 08:17:34]

If we are not tracing this pointer I don't understand why we have the
ServiceWorkerRegistrationProxy? It seems to me that this just means that
WebServiceWorkerRegistration does not keep the ServiceWorkerRegistration alive
and that sounds dangerous?

Does it lead to a Persistent/RefPtr cycle if we have a
WebPrivatePtr<ServiceWorkerRegistration> in WebServiceWorkerRegistration?

Am I right that we currently have:

WebSWRegistration --- Persistent -->
SWRegistrationProxy --- Raw -->
SWRegistration?

That would mean that if someone holds on to a WebSWRegistration that will not
actually keep the registration alive? Am I missing something?

[haraken, 2014/09/03 08:26:53]

The relationship is as follows:

WebSWRegistrationProxy --- Persistent -->
SWRegistrationProxy --- Raw -->
SWRegistration

and the SWRegistration and the WebSWRegistrationProxy are the same object
(SWRegistration inherits from WebSWRegistrationProxy).

Thus we _should_not_ trace the SWRegistration from SWRegistrationProxy. If we
trace it, it will produce a leak.

+};
+
+} // namespace blink
+
+#endif // ServiceWorkerRegistrationProxy_h