Use a new Supplement constructor for ServiceWorkerRegistration supplements

third_party/WebKit/Source/modules/notifications/ServiceWorkerRegistrationNotifications.cpp

 // 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.
 
 #include "modules/notifications/ServiceWorkerRegistrationNotifications.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 37 matching lines @@
     return notifications;
   }
 
  private:
   NotificationArray() = delete;
 };
 
 }  // namespace
 
 ServiceWorkerRegistrationNotifications::ServiceWorkerRegistrationNotifications(
-    ExecutionContext* executionContext,
-    ServiceWorkerRegistration* registration)
-    : ContextLifecycleObserver(executionContext),
-      m_registration(registration) {}
+    ServiceWorkerRegistration& registration,
+    ExecutionContext* executionContext)
+    : Supplement<ServiceWorkerRegistration>(registration),
+      ContextLifecycleObserver(executionContext) {}
 
 ScriptPromise ServiceWorkerRegistrationNotifications::showNotification(
     ScriptState* scriptState,
     ServiceWorkerRegistration& registration,
     const String& title,
     const NotificationOptions& options,
     ExceptionState& exceptionState) {
   ExecutionContext* executionContext = scriptState->getExecutionContext();
 
   // If context object's active worker is null, reject the promise with a
@@ skipping 63 matching lines @@
   return promise;
 }
 
 void ServiceWorkerRegistrationNotifications::contextDestroyed(
     ExecutionContext*) {
   for (auto loader : m_loaders)
     loader->stop();
 }
 
 DEFINE_TRACE(ServiceWorkerRegistrationNotifications) {
-  visitor->trace(m_registration);
   visitor->trace(m_loaders);
   Supplement<ServiceWorkerRegistration>::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 const char* ServiceWorkerRegistrationNotifications::supplementName() {
   return "ServiceWorkerRegistrationNotifications";
 }
 
 ServiceWorkerRegistrationNotifications&
 ServiceWorkerRegistrationNotifications::from(
     ExecutionContext* executionContext,
     ServiceWorkerRegistration& registration) {
   ServiceWorkerRegistrationNotifications* supplement =
       static_cast<ServiceWorkerRegistrationNotifications*>(
           Supplement<ServiceWorkerRegistration>::from(registration,
                                                       supplementName()));
   if (!supplement) {
-    supplement = new ServiceWorkerRegistrationNotifications(executionContext,
-                                                            &registration);
+    supplement = new ServiceWorkerRegistrationNotifications(registration,
+                                                            executionContext);
     provideTo(registration, supplementName(), supplement);
   }
   return *supplement;
 }
 
 void ServiceWorkerRegistrationNotifications::prepareShow(
     const WebNotificationData& data,
     std::unique_ptr<WebNotificationShowCallbacks> callbacks) {
   RefPtr<SecurityOrigin> origin = getExecutionContext()->getSecurityOrigin();
   NotificationResourcesLoader* loader = new NotificationResourcesLoader(
@@ skipping 10 matching lines @@
     std::unique_ptr<WebNotificationShowCallbacks> callbacks,
     NotificationResourcesLoader* loader) {
   DCHECK(m_loaders.contains(loader));
 
   WebNotificationManager* notificationManager =
       Platform::current()->notificationManager();
   DCHECK(notificationManager);
 
   notificationManager->showPersistent(
       WebSecurityOrigin(origin.get()), data, loader->getResources(),
-      m_registration->webRegistration(), std::move(callbacks));
+      supplementable()->webRegistration(), std::move(callbacks));
   m_loaders.remove(loader);
 }
 
 }  // namespace blink