Enable Oilpan for modules/geolocation by default.

Source/modules/geolocation/Geolocation.cpp

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  * Copyright 2010, The Android Open Source Project
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 11 matching lines @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/geolocation/Geolocation.h"
 
 #include "core/dom/Document.h"
-#include "wtf/CurrentTime.h"
-
 #include "modules/geolocation/Coordinates.h"
 #include "modules/geolocation/GeolocationController.h"
 #include "modules/geolocation/GeolocationError.h"
 #include "modules/geolocation/GeolocationPosition.h"
+#include "wtf/CurrentTime.h"
 
 namespace WebCore {
 
 static const char permissionDeniedErrorMessage[] = "User denied Geolocation";
 static const char failedToStartServiceErrorMessage[] = "Failed to start Geolocation service";
 static const char framelessDocumentErrorMessage[] = "Geolocation cannot be used in frameless documents";
 
-static PassRefPtrWillBeRawPtr<Geoposition> createGeoposition(GeolocationPosition* position)
+static Geoposition* createGeoposition(GeolocationPosition* position)
 {
     if (!position)
         return nullptr;
 
-    RefPtrWillBeRawPtr<Coordinates> coordinates = Coordinates::create(
+    Coordinates* coordinates = Coordinates::create(
         position->latitude(),
         position->longitude(),
         position->canProvideAltitude(),
         position->altitude(),
         position->accuracy(),
         position->canProvideAltitudeAccuracy(),
         position->altitudeAccuracy(),
         position->canProvideHeading(),
         position->heading(),
         position->canProvideSpeed(),
         position->speed());
-    return Geoposition::create(coordinates.release(), convertSecondsToDOMTimeStamp(position->timestamp()));
+    return Geoposition::create(coordinates, convertSecondsToDOMTimeStamp(position->timestamp()));
 }
 
-static PassRefPtrWillBeRawPtr<PositionError> createPositionError(GeolocationError* error)
+static PositionError* createPositionError(GeolocationError* error)
 {
     PositionError::ErrorCode code = PositionError::POSITION_UNAVAILABLE;
     switch (error->code()) {
     case GeolocationError::PermissionDenied:
         code = PositionError::PERMISSION_DENIED;
         break;
     case GeolocationError::PositionUnavailable:
         code = PositionError::POSITION_UNAVAILABLE;
         break;
     }
 
     return PositionError::create(code, error->message());
 }
 
-Geolocation::GeoNotifier::GeoNotifier(Geolocation* geolocation, PassOwnPtr<PositionCallback> successCallback, PassOwnPtr<PositionErrorCallback> errorCallback, PassRefPtrWillBeRawPtr<PositionOptions> options)
+Geolocation::GeoNotifier::GeoNotifier(Geolocation* geolocation, PassOwnPtr<PositionCallback> successCallback, PassOwnPtr<PositionErrorCallback> errorCallback, PositionOptions* options)
     : m_geolocation(geolocation)
     , m_successCallback(successCallback)
     , m_errorCallback(errorCallback)
     , m_options(options)
     , m_timer(this, &Geolocation::GeoNotifier::timerFired)
     , m_useCachedPosition(false)
 {
     ASSERT(m_geolocation);
     ASSERT(m_successCallback);
     // If no options were supplied from JS, we should have created a default set
     // of options in JSGeolocationCustom.cpp.
     ASSERT(m_options);
 }
 
 void Geolocation::GeoNotifier::trace(Visitor* visitor)
 {
     visitor->trace(m_geolocation);
     visitor->trace(m_options);
     visitor->trace(m_fatalError);
 }
 
-void Geolocation::GeoNotifier::setFatalError(PassRefPtrWillBeRawPtr<PositionError> error)
+void Geolocation::GeoNotifier::setFatalError(PositionError* error)
 {
     // If a fatal error has already been set, stick with it. This makes sure that
     // when permission is denied, this is the error reported, as required by the
     // spec.
     if (m_fatalError)
         return;
 
     m_fatalError = error;
     // An existing timer may not have a zero timeout.
     m_timer.stop();
@@ skipping 29 matching lines @@
 
 void Geolocation::GeoNotifier::stopTimer()
 {
     m_timer.stop();
 }
 
 void Geolocation::GeoNotifier::timerFired(Timer<GeoNotifier>*)
 {
     m_timer.stop();
 
-    // Protect this GeoNotifier object, since it
-    // could be deleted by a call to clearWatch in a callback.
-    RefPtrWillBeRawPtr<GeoNotifier> protect(this);
-
     // Test for fatal error first. This is required for the case where the LocalFrame is
     // disconnected and requests are cancelled.
     if (m_fatalError) {
         runErrorCallback(m_fatalError.get());
         // This will cause this notifier to be deleted.
         m_geolocation->fatalErrorOccurred(this);
         return;
     }
 
     if (m_useCachedPosition) {
         // Clear the cached position flag in case this is a watch request, which
         // will continue to run.
         m_useCachedPosition = false;
         m_geolocation->requestUsesCachedPosition(this);
         return;
     }
 
-    if (m_errorCallback) {
-        RefPtrWillBeRawPtr<PositionError> error = PositionError::create(PositionError::TIMEOUT, "Timeout expired");
-        m_errorCallback->handleEvent(error.get());
-    }
+    if (m_errorCallback)
+        m_errorCallback->handleEvent(PositionError::create(PositionError::TIMEOUT, "Timeout expired"));
     m_geolocation->requestTimedOut(this);
 }
 
 void Geolocation::Watchers::trace(Visitor* visitor)
 {
     visitor->trace(m_idToNotifierMap);
     visitor->trace(m_notifierToIdMap);
 }
 
-bool Geolocation::Watchers::add(int id, PassRefPtrWillBeRawPtr<GeoNotifier> prpNotifier)
+bool Geolocation::Watchers::add(int id, GeoNotifier* notifier)
 {
     ASSERT(id > 0);
-    RefPtrWillBeRawPtr<GeoNotifier> notifier = prpNotifier;
-
-    if (!m_idToNotifierMap.add(id, notifier.get()).isNewEntry)
+    if (!m_idToNotifierMap.add(id, notifier).isNewEntry)
         return false;
-    m_notifierToIdMap.set(notifier.release(), id);
+    m_notifierToIdMap.set(notifier, id);
     return true;
 }
 
 Geolocation::GeoNotifier* Geolocation::Watchers::find(int id)
 {
     ASSERT(id > 0);
     IdToNotifierMap::iterator iter = m_idToNotifierMap.find(id);
     if (iter == m_idToNotifierMap.end())
         return 0;
     return iter->value.get();
@@ skipping 32 matching lines @@
 bool Geolocation::Watchers::isEmpty() const
 {
     return m_idToNotifierMap.isEmpty();
 }
 
 void Geolocation::Watchers::getNotifiersVector(GeoNotifierVector& copy) const
 {
     copyValuesToVector(m_idToNotifierMap, copy);
 }
 
-PassRefPtrWillBeRawPtr<Geolocation> Geolocation::create(ExecutionContext* context)
+Geolocation* Geolocation::create(ExecutionContext* context)
 {
-    RefPtrWillBeRawPtr<Geolocation> geolocation = adoptRefWillBeNoop(new Geolocation(context));
+    Geolocation* geolocation = new Geolocation(context);
     geolocation->suspendIfNeeded();
-    return geolocation.release();
+    return geolocation;
 }
 
 Geolocation::Geolocation(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_allowGeolocation(Unknown)
 {
     ScriptWrappable::init(this);
 }
 
 Geolocation::~Geolocation()
@@ skipping 36 matching lines @@
 {
     LocalFrame* frame = this->frame();
     if (!frame)
         return 0;
 
     m_lastPosition = createGeoposition(GeolocationController::from(frame)->lastPosition());
 
     return m_lastPosition.get();
 }
 
-void Geolocation::getCurrentPosition(PassOwnPtr<PositionCallback> successCallback, PassOwnPtr<PositionErrorCallback> errorCallback, PassRefPtrWillBeRawPtr<PositionOptions> options)
+void Geolocation::getCurrentPosition(PassOwnPtr<PositionCallback> successCallback, PassOwnPtr<PositionErrorCallback> errorCallback, PositionOptions* options)
 {
     if (!frame())
         return;
 
-    RefPtrWillBeRawPtr<GeoNotifier> notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
-    startRequest(notifier.get());
+    GeoNotifier* notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
+    startRequest(notifier);
 
     m_oneShots.add(notifier);
 }
 
-int Geolocation::watchPosition(PassOwnPtr<PositionCallback> successCallback, PassOwnPtr<PositionErrorCallback> errorCallback, PassRefPtrWillBeRawPtr<PositionOptions> options)
+int Geolocation::watchPosition(PassOwnPtr<PositionCallback> successCallback, PassOwnPtr<PositionErrorCallback> errorCallback, PositionOptions* options)
 {
     if (!frame())
         return 0;
 
-    RefPtrWillBeRawPtr<GeoNotifier> notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
-    startRequest(notifier.get());
+    GeoNotifier* notifier = GeoNotifier::create(this, successCallback, errorCallback, options);
+    startRequest(notifier);
 
     int watchID;
     // Keep asking for the next id until we're given one that we don't already have.
     do {
         watchID = executionContext()->circularSequentialID();
     } while (!m_watchers.add(watchID, notifier));
     return watchID;
 }
 
 void Geolocation::startRequest(GeoNotifier *notifier)
@@ skipping 103 matching lines @@
     if (GeoNotifier* notifier = m_watchers.find(watchID))
         m_pendingForPermissionNotifiers.remove(notifier);
     m_watchers.remove(watchID);
 
     if (!hasListeners())
         stopUpdating();
 }
 
 void Geolocation::setIsAllowed(bool allowed)
 {
-    // Protect the Geolocation object from garbage collection during a callback.
-    RefPtrWillBeRawPtr<Geolocation> protect(this);
-
     // This may be due to either a new position from the service, or a cached
     // position.
     m_allowGeolocation = allowed ? Yes : No;
 
     // Permission request was made during the startRequest process
     if (!m_pendingForPermissionNotifiers.isEmpty()) {
         handlePendingPermissionNotifiers();
         m_pendingForPermissionNotifiers.clear();
         return;
     }
 
     if (!isAllowed()) {
-        RefPtrWillBeRawPtr<PositionError> error = PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage);
+        PositionError* error = PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage);
         error->setIsFatal(true);
-        handleError(error.get());
+        handleError(error);
         m_requestsAwaitingCachedPosition.clear();
         return;
     }
 
     // If the service has a last position, use it to call back for all requests.
     // If any of the requests are waiting for permission for a cached position,
     // the position from the service will be at least as fresh.
     if (lastPosition())
         makeSuccessCallbacks();
     else
@@ skipping 167 matching lines @@
     ASSERT(isAllowed());
 
     // Stop all currently running timers.
     stopTimers();
 
     makeSuccessCallbacks();
 }
 
 void Geolocation::setError(GeolocationError* error)
 {
-    RefPtrWillBeRawPtr<PositionError> positionError = createPositionError(error);
-    handleError(positionError.get());
+    handleError(createPositionError(error));
 }
 
 bool Geolocation::startUpdating(GeoNotifier* notifier)
 {
     LocalFrame* frame = this->frame();
     if (!frame)
         return false;
 
     GeolocationController::from(frame)->addObserver(this, notifier->options()->enableHighAccuracy());
     return true;
@@ skipping 23 matching lines @@
                 notifier->startTimer();
             else
                 notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, failedToStartServiceErrorMessage));
         } else {
             notifier->setFatalError(PositionError::create(PositionError::PERMISSION_DENIED, permissionDeniedErrorMessage));
         }
     }
 }
 
 } // namespace WebCore