Oilpan: make DOMWindowProperty a GC mixin.

Source/core/loader/appcache/ApplicationCacheHost.cpp

 /*
  * 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 43 matching lines @@
 
 using namespace blink;
 
 namespace blink {
 
 // We provide a custom implementation of this class that calls out to the
 // embedding application instead of using WebCore's built in appcache system.
 // This file replaces webcore/appcache/ApplicationCacheHost.cpp in our build.
 
 ApplicationCacheHost::ApplicationCacheHost(DocumentLoader* documentLoader)
-    : m_domApplicationCache(0)
+    : m_domApplicationCache(nullptr)
     , m_documentLoader(documentLoader)
     , m_defersEvents(true)
 {
     ASSERT(m_documentLoader);
 }
 
 ApplicationCacheHost::~ApplicationCacheHost()
 {
 }
 
@@ skipping 36 matching lines @@
         m_host->selectCacheWithoutManifest();
 }
 
 void ApplicationCacheHost::selectCacheWithManifest(const KURL& manifestURL)
 {
     if (m_host && !m_host->selectCacheWithManifest(manifestURL)) {
         // It's a foreign entry, restart the current navigation from the top
         // of the navigation algorithm. The navigation will not result in the
         // same resource being loaded, because "foreign" entries are never picked
         // during navigation.
-        // see blink::ApplicationCacheGroup::selectCache()
+        // see ApplicationCacheGroup::selectCache()
         LocalFrame* frame = m_documentLoader->frame();
         frame->navigationScheduler().scheduleLocationChange(frame->document(), frame->document()->url(), Referrer(frame->document()->referrer(), frame->document()->referrerPolicy()));
     }
 }
 
 void ApplicationCacheHost::didReceiveResponseForMainResource(const ResourceResponse& response)
 {
     if (m_host) {
         WrappedResourceResponse wrapped(response);
         m_host->didReceiveResponseForMainResource(wrapped);
@@ skipping 25 matching lines @@
         m_host->willStartSubResourceRequest(wrapped);
     }
 }
 
 void ApplicationCacheHost::setApplicationCache(ApplicationCache* domApplicationCache)
 {
     ASSERT(!m_domApplicationCache || !domApplicationCache);
     m_domApplicationCache = domApplicationCache;
 }
 
-void ApplicationCacheHost::notifyApplicationCache(EventID id, int progressTotal, int progressDone, blink::WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
+void ApplicationCacheHost::notifyApplicationCache(EventID id, int progressTotal, int progressDone, WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
 {
     if (id != PROGRESS_EVENT)
         InspectorInstrumentation::updateApplicationCacheStatus(m_documentLoader->frame());
 
     if (m_defersEvents) {
         // Event dispatching is deferred until document.onload has fired.
         m_deferredEvents.append(DeferredEvent(id, progressTotal, progressDone, errorReason, errorURL, errorStatus, errorMessage));
         return;
     }
     dispatchDOMEvent(id, progressTotal, progressDone, errorReason, errorURL, errorStatus, errorMessage);
 }
 
 ApplicationCacheHost::CacheInfo ApplicationCacheHost::applicationCacheInfo()
 {
     if (!m_host)
         return CacheInfo(KURL(), 0, 0, 0);
 
-    blink::WebApplicationCacheHost::CacheInfo webInfo;
+    WebApplicationCacheHost::CacheInfo webInfo;
     m_host->getAssociatedCacheInfo(&webInfo);
     return CacheInfo(webInfo.manifestURL, webInfo.creationTime, webInfo.updateTime, webInfo.totalSize);
 }
 
 void ApplicationCacheHost::fillResourceList(ResourceInfoList* resources)
 {
     if (!m_host)
         return;
 
-    blink::WebVector<blink::WebApplicationCacheHost::ResourceInfo> webResources;
+    WebVector<WebApplicationCacheHost::ResourceInfo> webResources;
     m_host->getResourceList(&webResources);
     for (size_t i = 0; i < webResources.size(); ++i) {
         resources->append(ResourceInfo(
             webResources[i].url, webResources[i].isMaster, webResources[i].isManifest, webResources[i].isFallback,
             webResources[i].isForeign, webResources[i].isExplicit, webResources[i].size));
     }
 }
 
 void ApplicationCacheHost::stopDeferringEvents()
 {
     RefPtr<DocumentLoader> protect(documentLoader());
     for (unsigned i = 0; i < m_deferredEvents.size(); ++i) {
         const DeferredEvent& deferred = m_deferredEvents[i];
         dispatchDOMEvent(deferred.eventID, deferred.progressTotal, deferred.progressDone, deferred.errorReason, deferred.errorURL, deferred.errorStatus, deferred.errorMessage);
     }
     m_deferredEvents.clear();
     m_defersEvents = false;
 }
 
-void ApplicationCacheHost::dispatchDOMEvent(EventID id, int progressTotal, int progressDone, blink::WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
+void ApplicationCacheHost::dispatchDOMEvent(EventID id, int progressTotal, int progressDone, WebApplicationCacheHost::ErrorReason errorReason, const String& errorURL, int errorStatus, const String& errorMessage)
 {
     if (m_domApplicationCache) {
         const AtomicString& eventType = ApplicationCache::toEventType(id);
         RefPtrWillBeRawPtr<Event> event = nullptr;
         if (id == PROGRESS_EVENT)
             event = ProgressEvent::create(eventType, true, progressDone, progressTotal);
         else if (id == ERROR_EVENT)
             event = ApplicationCacheErrorEvent::create(errorReason, errorURL, errorStatus, errorMessage);
         else
             event = Event::create(eventType);
@@ skipping 29 matching lines @@
 {
     ASSERT(m_documentLoader->frame());
     return m_documentLoader->frame()->settings() && m_documentLoader->frame()->settings()->offlineWebApplicationCacheEnabled();
 }
 
 void ApplicationCacheHost::didChangeCacheAssociation()
 {
     // FIXME: Prod the inspector to update its notion of what cache the page is using.
 }
 
-void ApplicationCacheHost::notifyEventListener(blink::WebApplicationCacheHost::EventID eventID)
+void ApplicationCacheHost::notifyEventListener(WebApplicationCacheHost::EventID eventID)
 {
-    notifyApplicationCache(static_cast<ApplicationCacheHost::EventID>(eventID), 0, 0, blink::WebApplicationCacheHost::UnknownError, String(), 0, String());
+    notifyApplicationCache(static_cast<ApplicationCacheHost::EventID>(eventID), 0, 0, WebApplicationCacheHost::UnknownError, String(), 0, String());
 }
 
-void ApplicationCacheHost::notifyProgressEventListener(const blink::WebURL&, int progressTotal, int progressDone)
+void ApplicationCacheHost::notifyProgressEventListener(const WebURL&, int progressTotal, int progressDone)
 {
-    notifyApplicationCache(PROGRESS_EVENT, progressTotal, progressDone, blink::WebApplicationCacheHost::UnknownError, String(), 0, String());
+    notifyApplicationCache(PROGRESS_EVENT, progressTotal, progressDone, WebApplicationCacheHost::UnknownError, String(), 0, String());
 }
 
-void ApplicationCacheHost::notifyErrorEventListener(blink::WebApplicationCacheHost::ErrorReason reason, const blink::WebURL& url, int status, const blink::WebString& message)
+void ApplicationCacheHost::notifyErrorEventListener(WebApplicationCacheHost::ErrorReason reason, const WebURL& url, int status, const WebString& message)
 {
     notifyApplicationCache(ERROR_EVENT, 0, 0, reason, url.string(), status, message);
 }
 
+void ApplicationCacheHost::trace(Visitor* visitor)
+{
+    visitor->trace(m_domApplicationCache);
+}
+
 } // namespace blink