Remove RawPtr from Source/web/

third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 54 matching lines @@
 #include "public/web/modules/serviceworker/WebServiceWorkerContextClient.h"
 #include "web/WebEmbeddedWorkerImpl.h"
 #include "wtf/Assertions.h"
 #include "wtf/Functional.h"
 #include "wtf/PassOwnPtr.h"
 
 #include <utility>
 
 namespace blink {
 
-RawPtr<ServiceWorkerGlobalScopeProxy> ServiceWorkerGlobalScopeProxy::create(WebEmbeddedWorkerImpl& embeddedWorker, Document& document, WebServiceWorkerContextClient& client)
+ServiceWorkerGlobalScopeProxy* ServiceWorkerGlobalScopeProxy::create(WebEmbeddedWorkerImpl& embeddedWorker, Document& document, WebServiceWorkerContextClient& client)
 {
     return new ServiceWorkerGlobalScopeProxy(embeddedWorker, document, client);
 }
 
 ServiceWorkerGlobalScopeProxy::~ServiceWorkerGlobalScopeProxy()
 {
     // Verify that the proxy has been detached.
     DCHECK(!m_embeddedWorker);
 }
 
 DEFINE_TRACE(ServiceWorkerGlobalScopeProxy)
 {
     visitor->trace(m_document);
     visitor->trace(m_workerGlobalScope);
 }
 
 void ServiceWorkerGlobalScopeProxy::setRegistration(std::unique_ptr<WebServiceWorkerRegistration::Handle> handle)
 {
     workerGlobalScope()->setRegistration(std::move(handle));
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchActivateEvent(int eventID)
 {
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Activate, eventID);
-    RawPtr<Event> event(ExtendableEvent::create(EventTypeNames::activate, ExtendableEventInit(), observer));
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    Event* event = ExtendableEvent::create(EventTypeNames::activate, ExtendableEventInit(), observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchExtendableMessageEvent(int eventID, const WebString& message, const WebSecurityOrigin& sourceOrigin, const WebMessagePortChannelArray& webChannels, const WebServiceWorkerClientInfo& client)
 {
     DCHECK(RuntimeEnabledFeatures::serviceWorkerExtendableMessageEventEnabled());
 
     WebSerializedScriptValue value = WebSerializedScriptValue::fromString(message);
     MessagePortArray* ports = MessagePort::toMessagePortArray(m_workerGlobalScope, webChannels);
     String origin;
     if (!sourceOrigin.isUnique())
         origin = sourceOrigin.toString();
     ServiceWorkerClient* source = nullptr;
     if (client.clientType == WebServiceWorkerClientTypeWindow)
         source = ServiceWorkerWindowClient::create(client);
     else
         source = ServiceWorkerClient::create(client);
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Message, eventID);
 
-    RawPtr<Event> event(ExtendableMessageEvent::create(value, origin, ports, source, observer));
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    Event* event = ExtendableMessageEvent::create(value, origin, ports, source, observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchExtendableMessageEvent(int eventID, const WebString& message, const WebSecurityOrigin& sourceOrigin, const WebMessagePortChannelArray& webChannels, std::unique_ptr<WebServiceWorker::Handle> handle)
 {
     DCHECK(RuntimeEnabledFeatures::serviceWorkerExtendableMessageEventEnabled());
 
     WebSerializedScriptValue value = WebSerializedScriptValue::fromString(message);
     MessagePortArray* ports = MessagePort::toMessagePortArray(m_workerGlobalScope, webChannels);
     String origin;
     if (!sourceOrigin.isUnique())
         origin = sourceOrigin.toString();
     ServiceWorker* source = ServiceWorker::from(m_workerGlobalScope->getExecutionContext(), adoptPtr(handle.release()));
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Message, eventID);
 
-    RawPtr<Event> event(ExtendableMessageEvent::create(value, origin, ports, source, observer));
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    Event* event = ExtendableMessageEvent::create(value, origin, ports, source, observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchFetchEvent(int eventID, const WebServiceWorkerRequest& webRequest)
 {
     RespondWithObserver* observer = RespondWithObserver::create(workerGlobalScope(), eventID, webRequest.url(), webRequest.mode(), webRequest.frameType(), webRequest.requestContext());
     Request* request = Request::create(workerGlobalScope(), webRequest);
     request->getHeaders()->setGuard(Headers::ImmutableGuard);
     FetchEventInit eventInit;
     eventInit.setCancelable(true);
     eventInit.setRequest(request);
@@ skipping 19 matching lines @@
 
 void ServiceWorkerGlobalScopeProxy::dispatchGeofencingEvent(int eventID, WebGeofencingEventType eventType, const WebString& regionID, const WebCircularGeofencingRegion& region)
 {
     const AtomicString& type = eventType == WebGeofencingEventTypeEnter ? EventTypeNames::geofenceenter : EventTypeNames::geofenceleave;
     workerGlobalScope()->dispatchEvent(GeofencingEvent::create(type, regionID, CircularGeofencingRegion::create(regionID, region)));
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchInstallEvent(int eventID)
 {
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Install, eventID);
-    RawPtr<Event> event;
+    Event* event;
     if (RuntimeEnabledFeatures::foreignFetchEnabled())
         event = InstallEvent::create(EventTypeNames::install, ExtendableEventInit(), observer);
     else
         event = ExtendableEvent::create(EventTypeNames::install, ExtendableEventInit(), observer);
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchMessageEvent(const WebString& message, const WebMessagePortChannelArray& webChannels)
 {
     MessagePortArray* ports = MessagePort::toMessagePortArray(workerGlobalScope(), webChannels);
     WebSerializedScriptValue value = WebSerializedScriptValue::fromString(message);
     workerGlobalScope()->dispatchEvent(MessageEvent::create(ports, value));
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchNotificationClickEvent(int eventID, int64_t notificationID, const WebNotificationData& data, int actionIndex)
 {
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::NotificationClick, eventID);
     NotificationEventInit eventInit;
     eventInit.setNotification(Notification::create(workerGlobalScope(), notificationID, data, true /* showing */));
     if (0 <= actionIndex && actionIndex < static_cast<int>(data.actions.size()))
         eventInit.setAction(data.actions[actionIndex].action);
-    RawPtr<Event> event(NotificationEvent::create(EventTypeNames::notificationclick, eventInit, observer));
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    Event* event = NotificationEvent::create(EventTypeNames::notificationclick, eventInit, observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchNotificationCloseEvent(int eventID, int64_t notificationID, const WebNotificationData& data)
 {
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::NotificationClose, eventID);
     NotificationEventInit eventInit;
     eventInit.setAction(WTF::String()); // initialize as null.
     eventInit.setNotification(Notification::create(workerGlobalScope(), notificationID, data, false /* showing */));
-    RawPtr<Event> event(NotificationEvent::create(EventTypeNames::notificationclose, eventInit, observer));
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    Event* event = NotificationEvent::create(EventTypeNames::notificationclose, eventInit, observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchPushEvent(int eventID, const WebString& data)
 {
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Push, eventID);
-    RawPtr<Event> event(PushEvent::create(EventTypeNames::push, PushMessageData::create(data), observer));
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    Event* event = PushEvent::create(EventTypeNames::push, PushMessageData::create(data), observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchSyncEvent(int eventID, const WebString& tag, LastChanceOption lastChance)
 {
     if (!RuntimeEnabledFeatures::backgroundSyncEnabled()) {
         ServiceWorkerGlobalScopeClient::from(workerGlobalScope())->didHandleSyncEvent(eventID, WebServiceWorkerEventResultCompleted);
         return;
     }
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Sync, eventID);
-    RawPtr<Event> event(SyncEvent::create(EventTypeNames::sync, tag, lastChance == IsLastChance, observer));
-    workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
+    Event* event = SyncEvent::create(EventTypeNames::sync, tag, lastChance == IsLastChance, observer);
+    workerGlobalScope()->dispatchExtendableEvent(event, observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::reportException(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL, int)
 {
     client().reportException(errorMessage, lineNumber, columnNumber, sourceURL);
 }
 
-void ServiceWorkerGlobalScopeProxy::reportConsoleMessage(RawPtr<ConsoleMessage> consoleMessage)
+void ServiceWorkerGlobalScopeProxy::reportConsoleMessage(ConsoleMessage* consoleMessage)
 {
     client().reportConsoleMessage(consoleMessage->source(), consoleMessage->level(), consoleMessage->message(), consoleMessage->lineNumber(), consoleMessage->url());
 }
 
 void ServiceWorkerGlobalScopeProxy::postMessageToPageInspector(const String& message)
 {
     DCHECK(m_embeddedWorker);
     document().postInspectorTask(BLINK_FROM_HERE, createCrossThreadTask(&WebEmbeddedWorkerImpl::postMessageToPageInspector, m_embeddedWorker, message));
 }
 
@@ skipping 61 matching lines @@
     return *m_document;
 }
 
 ServiceWorkerGlobalScope* ServiceWorkerGlobalScopeProxy::workerGlobalScope() const
 {
     DCHECK(m_workerGlobalScope);
     return m_workerGlobalScope;
 }
 
 } // namespace blink