Oilpan: make DOMWindowProperty a GC mixin.

Source/core/loader/appcache/ApplicationCacheHost.h

 /*
  * Copyright (c) 2009, 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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR 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.
  */
 
 #ifndef ApplicationCacheHost_h
 #define ApplicationCacheHost_h
 
+#include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/WebApplicationCacheHostClient.h"
-#include "wtf/Deque.h"
 #include "wtf/OwnPtr.h"
-#include "wtf/PassRefPtr.h"
-#include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace blink {
     class ApplicationCache;
     class DocumentLoader;
     class LocalFrame;
     class ResourceLoader;
     class ResourceError;
     class ResourceRequest;
     class ResourceResponse;
     class SubstituteData;
 
-    class ApplicationCacheHost : public blink::WebApplicationCacheHostClient {
+    class ApplicationCacheHost FINAL : public NoBaseWillBeGarbageCollectedFinalized<ApplicationCacheHost>, public WebApplicationCacheHostClient {
         WTF_MAKE_NONCOPYABLE(ApplicationCacheHost);
     public:
+        static PassOwnPtrWillBeRawPtr<ApplicationCacheHost> create(DocumentLoader* loader)
+        {
+            return adoptPtrWillBeNoop(new ApplicationCacheHost(loader));
+        }
+        virtual ~ApplicationCacheHost();
+
         // The Status numeric values are specified in the HTML5 spec.
         enum Status {
             UNCACHED = 0,
             IDLE = 1,
             CHECKING = 2,
             DOWNLOADING = 3,
             UPDATEREADY = 4,
             OBSOLETE = 5
         };
 
@@ skipping 33 matching lines @@
             bool m_isMaster;
             bool m_isManifest;
             bool m_isFallback;
             bool m_isForeign;
             bool m_isExplicit;
             long long m_size;
         };
 
         typedef Vector<ResourceInfo> ResourceInfoList;
 
-        explicit ApplicationCacheHost(DocumentLoader*);
-        virtual ~ApplicationCacheHost();
-
         void selectCacheWithoutManifest();
         void selectCacheWithManifest(const KURL& manifestURL);
 
         void willStartLoadingMainResource(ResourceRequest&);
         void didReceiveResponseForMainResource(const ResourceResponse&);
         void mainResourceDataReceived(const char* data, int length);
         void finishedLoadingMainResource();
         void failedLoadingMainResource();
 
         void willStartLoadingResource(ResourceRequest&);
 
         Status status() const;
         bool update();
         bool swapCache();
         void abort();
 
         void setApplicationCache(ApplicationCache*);
-        void notifyApplicationCache(EventID, int progressTotal, int progressDone, blink::WebApplicationCacheHost::ErrorReason, const String& errorURL, int errorStatus, const String& errorMessage);
+        void notifyApplicationCache(EventID, int progressTotal, int progressDone, WebApplicationCacheHost::ErrorReason, const String& errorURL, int errorStatus, const String& errorMessage);
 
         void stopDeferringEvents(); // Also raises the events that have been queued up.
 
         void fillResourceList(ResourceInfoList*);
         CacheInfo applicationCacheInfo();
 
+        void trace(Visitor*);
+
     private:
+        explicit ApplicationCacheHost(DocumentLoader*);
+
         // WebApplicationCacheHostClient implementation
         virtual void didChangeCacheAssociation() OVERRIDE FINAL;
-        virtual void notifyEventListener(blink::WebApplicationCacheHost::EventID) OVERRIDE FINAL;
-        virtual void notifyProgressEventListener(const blink::WebURL&, int progressTotal, int progressDone) OVERRIDE FINAL;
-        virtual void notifyErrorEventListener(blink::WebApplicationCacheHost::ErrorReason, const blink::WebURL&, int status, const blink::WebString& message) OVERRIDE FINAL;
+        virtual void notifyEventListener(WebApplicationCacheHost::EventID) OVERRIDE FINAL;
+        virtual void notifyProgressEventListener(const WebURL&, int progressTotal, int progressDone) OVERRIDE FINAL;
+        virtual void notifyErrorEventListener(WebApplicationCacheHost::ErrorReason, const WebURL&, int status, const WebString& message) OVERRIDE FINAL;
 
         bool isApplicationCacheEnabled();
         DocumentLoader* documentLoader() const { return m_documentLoader; }
 
         struct DeferredEvent {
             EventID eventID;
             int progressTotal;
             int progressDone;
-            blink::WebApplicationCacheHost::ErrorReason errorReason;
+            WebApplicationCacheHost::ErrorReason errorReason;
             String errorURL;
             int errorStatus;
             String errorMessage;
-            DeferredEvent(EventID id, int progressTotal, int progressDone, blink::WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
+            DeferredEvent(EventID id, int progressTotal, int progressDone, WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
                 : eventID(id)
                 , progressTotal(progressTotal)
                 , progressDone(progressDone)
                 , errorReason(errorReason)
                 , errorURL(errorURL)
                 , errorStatus(errorStatus)
                 , errorMessage(errorMessage)
             {
             }
         };
 
-        ApplicationCache* m_domApplicationCache;
+        RawPtrWillBeWeakMember<ApplicationCache> m_domApplicationCache;

[haraken, 2014/09/10 02:49:36]

I'm a bit behind. Why is making this a weak member solve the problem that
ApplicationCache can access a stale m_frame?

[sof, 2014/09/10 05:49:40]

If the host outlives the appcache, someone needs to clear the frame reference.
As the appcache will not be informed of the frame disappearing (now or later),
we cannot perform the unregistration from its (==appcache) side.

[haraken, 2014/09/10 07:46:53]

Thanks, makes sense.

Can we remove willDestroyGlobalObjectInFrame from oilpan builds?

[sof, 2014/09/10 08:21:37]

No. You can still be informed of this if e.g., the frame is reused.

         DocumentLoader* m_documentLoader;
         bool m_defersEvents; // Events are deferred until after document onload.
         Vector<DeferredEvent> m_deferredEvents;
 
-        void dispatchDOMEvent(EventID, int progressTotal, int progressDone, blink::WebApplicationCacheHost::ErrorReason, const String& errorURL, int errorStatus, const String& errorMessage);
+        void dispatchDOMEvent(EventID, int progressTotal, int progressDone, WebApplicationCacheHost::ErrorReason, const String& errorURL, int errorStatus, const String& errorMessage);
 
-        OwnPtr<blink::WebApplicationCacheHost> m_host;
+        OwnPtr<WebApplicationCacheHost> m_host;
     };
 
 }  // namespace blink
 
 #endif  // ApplicationCacheHost_h