Enable Oilpan for modules/geolocation by default.

Source/modules/geolocation/Geolocation.h

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All Rights Reserved.
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 28 matching lines @@
 
 namespace WebCore {
 
 class Document;
 class LocalFrame;
 class GeolocationController;
 class GeolocationError;
 class GeolocationPosition;
 class ExecutionContext;
 
-class Geolocation FINAL : public RefCountedWillBeGarbageCollectedFinalized<Geolocation>, public ScriptWrappable, public ActiveDOMObject
-{
+class Geolocation FINAL
+    : public GarbageCollectedFinalized<Geolocation>
+    , public ScriptWrappable
+    , public ActiveDOMObject {
 public:
-    static PassRefPtrWillBeRawPtr<Geolocation> create(ExecutionContext*);
+    static Geolocation* create(ExecutionContext*);
     virtual ~Geolocation();
     void trace(Visitor*);
 
     virtual void stop() OVERRIDE;
     Document* document() const;
     LocalFrame* frame() const;
 
     // Creates a oneshot and attempts to obtain a position that meets the
     // constraints of the options.
-    void getCurrentPosition(PassOwnPtr<PositionCallback>, PassOwnPtr<PositionErrorCallback>, PassRefPtrWillBeRawPtr<PositionOptions>);
+    void getCurrentPosition(PassOwnPtr<PositionCallback>, PassOwnPtr<PositionErrorCallback>, PositionOptions*);
 
     // Creates a watcher that will be notified whenever a new position is
     // available that meets the constraints of the options.
-    int watchPosition(PassOwnPtr<PositionCallback>, PassOwnPtr<PositionErrorCallback>, PassRefPtrWillBeRawPtr<PositionOptions>);
+    int watchPosition(PassOwnPtr<PositionCallback>, PassOwnPtr<PositionErrorCallback>, PositionOptions*);
 
     // Removes all references to the watcher, it will not be updated again.
     void clearWatch(int watchID);
 
     void setIsAllowed(bool);
 
     bool isAllowed() const { return m_allowGeolocation == Yes; }
 
     // Notifies this that a new position is available. Must never be called
     // before permission is granted by the user.
     void positionChanged();
 
     // Notifies this that an error has occurred, it must be handled immediately.
     void setError(GeolocationError*);
 
 private:
     // Returns the last known position, if any. May return null.
     Geoposition* lastPosition();
 
     bool isDenied() const { return m_allowGeolocation == No; }
 
     explicit Geolocation(ExecutionContext*);
 
     // Holds the success and error callbacks and the options that were provided
     // when a oneshot or watcher were created. Also, if specified in the
     // options, manages a timer to limit the time to wait for the system to
     // obtain a position.
-    class GeoNotifier : public RefCountedWillBeGarbageCollectedFinalized<GeoNotifier> {
+    class GeoNotifier : public GarbageCollectedFinalized<GeoNotifier> {
     public:
-        static PassRefPtrWillBeRawPtr<GeoNotifier> create(Geolocation* geolocation, PassOwnPtr<PositionCallback> positionCallback, PassOwnPtr<PositionErrorCallback> positionErrorCallback, PassRefPtrWillBeRawPtr<PositionOptions> options)
+        static GeoNotifier* create(Geolocation* geolocation, PassOwnPtr<PositionCallback> positionCallback, PassOwnPtr<PositionErrorCallback> positionErrorCallback, PositionOptions* options)
         {
-            return adoptRefWillBeNoop(new GeoNotifier(geolocation, positionCallback, positionErrorCallback, options));
+            return new GeoNotifier(geolocation, positionCallback, positionErrorCallback, options);
         }
         void trace(Visitor*);
 
         PositionOptions* options() const { return m_options.get(); };
 
         // Sets the given error as the fatal error if there isn't one yet.
         // Starts the timer with an interval of 0.
-        void setFatalError(PassRefPtrWillBeRawPtr<PositionError>);
+        void setFatalError(PositionError*);
 
         bool useCachedPosition() const { return m_useCachedPosition; }
 
         // Tells the notifier to use a cached position and starts its timer with
         // an interval of 0.
         void setUseCachedPosition();
 
         void runSuccessCallback(Geoposition*);
         void runErrorCallback(PositionError*);
 
         void startTimer();
         void stopTimer();
 
         // Runs the error callback if there is a fatal error. Otherwise, if a
         // cached position must be used, registers itself for receiving one.
         // Otherwise, the notifier has expired, and its error callback is run.
         void timerFired(Timer<GeoNotifier>*);
 
     private:
-        GeoNotifier(Geolocation*, PassOwnPtr<PositionCallback>, PassOwnPtr<PositionErrorCallback>, PassRefPtrWillBeRawPtr<PositionOptions>);
+        GeoNotifier(Geolocation*, PassOwnPtr<PositionCallback>, PassOwnPtr<PositionErrorCallback>, PositionOptions*);
 
-        RefPtrWillBeMember<Geolocation> m_geolocation;
+        Member<Geolocation> m_geolocation;
         OwnPtr<PositionCallback> m_successCallback;
         OwnPtr<PositionErrorCallback> m_errorCallback;
-        RefPtrWillBeMember<PositionOptions> m_options;
+        Member<PositionOptions> m_options;
         Timer<GeoNotifier> m_timer;
-        RefPtrWillBeMember<PositionError> m_fatalError;
+        Member<PositionError> m_fatalError;
         bool m_useCachedPosition;
     };
 
-    typedef WillBeHeapVector<RefPtrWillBeMember<GeoNotifier> > GeoNotifierVector;
-    typedef WillBeHeapHashSet<RefPtrWillBeMember<GeoNotifier> > GeoNotifierSet;
+    typedef HeapVector<Member<GeoNotifier> > GeoNotifierVector;
+    typedef HeapHashSet<Member<GeoNotifier> > GeoNotifierSet;
 
     class Watchers {
         DISALLOW_ALLOCATION();
     public:
         void trace(Visitor*);
-        bool add(int id, PassRefPtrWillBeRawPtr<GeoNotifier>);
+        bool add(int id, GeoNotifier*);
         GeoNotifier* find(int id);
         void remove(int id);
         void remove(GeoNotifier*);
         bool contains(GeoNotifier*) const;
         void clear();
         bool isEmpty() const;
         void getNotifiersVector(GeoNotifierVector&) const;
     private:
-        typedef WillBeHeapHashMap<int, RefPtrWillBeMember<GeoNotifier> > IdToNotifierMap;
-        typedef WillBeHeapHashMap<RefPtrWillBeMember<GeoNotifier>, int> NotifierToIdMap;
+        typedef HeapHashMap<int, Member<GeoNotifier> > IdToNotifierMap;
+        typedef HeapHashMap<Member<GeoNotifier>, int> NotifierToIdMap;
         IdToNotifierMap m_idToNotifierMap;
         NotifierToIdMap m_notifierToIdMap;
     };
 
     bool hasListeners() const { return !m_oneShots.isEmpty() || !m_watchers.isEmpty(); }
 
     void sendError(GeoNotifierVector&, PositionError*);
     void sendPosition(GeoNotifierVector&, Geoposition*);
 
     // Removes notifiers that use a cached position from |notifiers| and
@@ skipping 55 matching lines @@
 
     bool haveSuitableCachedPosition(PositionOptions*);
 
     // Runs the success callbacks for the set of notifiers awaiting a cached
     // position, the set is then cleared. The oneshots are removed everywhere.
     void makeCachedPositionCallbacks();
 
     GeoNotifierSet m_oneShots;
     Watchers m_watchers;
     GeoNotifierSet m_pendingForPermissionNotifiers;
-    RefPtrWillBeMember<Geoposition> m_lastPosition;
+    Member<Geoposition> m_lastPosition;
 
     enum {
         Unknown,
         InProgress,
         Yes,
         No
     } m_allowGeolocation;
 
     GeoNotifierSet m_requestsAwaitingCachedPosition;
 };
 
 } // namespace WebCore
 
 #endif // Geolocation_h