Source/WebKit2/UIProcess/WebApplicationCacheManagerProxy.cpp

   1 /*
   2  * Copyright (C) 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "WebApplicationCacheManagerProxy.h"
  28
  29 #include "SecurityOriginData.h"
  30 #include "WebApplicationCacheManagerMessages.h"
  31 #include "WebContext.h"
  32 #include "WebSecurityOrigin.h"
  33
  34 namespace WebKit {
  35
  36 PassRefPtr<WebApplicationCacheManagerProxy> WebApplicationCacheManagerProxy::create(WebContext* context)
  37 {
  38     return adoptRef(new WebApplicationCacheManagerProxy(context));
  39 }
  40
  41 WebApplicationCacheManagerProxy::WebApplicationCacheManagerProxy(WebContext* context)
  42     : m_webContext(context)
  43 {
  44 }
  45
  46 WebApplicationCacheManagerProxy::~WebApplicationCacheManagerProxy()
  47 {
  48 }
  49
  50 void WebApplicationCacheManagerProxy::invalidate()
  51 {
  52     invalidateCallbackMap(m_arrayCallbacks);
  53 }
  54
  55 bool WebApplicationCacheManagerProxy::shouldTerminate(WebProcessProxy*) const
  56 {
  57     return m_arrayCallbacks.isEmpty();
  58 }
  59
  60 void WebApplicationCacheManagerProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
  61 {
  62     didReceiveWebApplicationCacheManagerProxyMessage(connection, messageID, arguments);
  63 }
  64
  65 void WebApplicationCacheManagerProxy::getApplicationCacheOrigins(PassRefPtr<ArrayCallback> prpCallback)
  66 {
  67     RefPtr<ArrayCallback> callback = prpCallback;
  68
  69     uint64_t callbackID = callback->callbackID();
  70     m_arrayCallbacks.set(callbackID, callback.release());
  71
  72     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
  73     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::GetApplicationCacheOrigins(callbackID));
  74 }
  75
  76 void WebApplicationCacheManagerProxy::didGetApplicationCacheOrigins(const Vector<SecurityOriginData>& originDatas, uint64_t callbackID)
  77 {
  78     RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID);
  79     performAPICallbackWithSecurityOriginDataVector(originDatas, callback.get());
  80 }
  81
  82 void WebApplicationCacheManagerProxy::deleteEntriesForOrigin(WebSecurityOrigin* origin)
  83 {
  84     SecurityOriginData securityOriginData;
  85     securityOriginData.protocol = origin->protocol();
  86     securityOriginData.host = origin->host();
  87     securityOriginData.port = origin->port();
  88
  89     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
  90     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::DeleteEntriesForOrigin(securityOriginData));
  91 }
  92
  93 void WebApplicationCacheManagerProxy::deleteAllEntries()
  94 {
  95     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
  96     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::DeleteAllEntries());
  97 }
  98
  99 #if ENABLE(TIZEN_APPLICATION_CACHE)
 100 void WebApplicationCacheManagerProxy::getApplicationCachePath(PassRefPtr<AppCacheStringCallback> prpCallback)
 101 {
 102     RefPtr<AppCacheStringCallback> callback = prpCallback;
 103
 104     uint64_t callbackID = callback->callbackID();
 105     m_appCacheStringCallbacks.set(callbackID, callback.release());
 106
 107     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
 108     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::GetApplicationCachePath(callbackID));
 109 }
 110
 111 void WebApplicationCacheManagerProxy::didGetApplicationCachePath(const String& Path, uint64_t callbackID)
 112 {
 113     RefPtr<AppCacheStringCallback> callback = m_appCacheStringCallbacks.take(callbackID);
 114     if (!callback) {
 115         // FIXME: Log error or assert.
 116         // this can validly happen if a load invalidated the callback, though
 117         return;
 118     }
 119
 120     callback->performCallbackWithReturnValue(Path.impl());
 121 }
 122
 123 #if ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
 124 void WebApplicationCacheManagerProxy::getApplicationCacheQuota(PassRefPtr<AppCacheInt64Callback> prpCallback)
 125 {
 126     RefPtr<AppCacheInt64Callback> callback = prpCallback;
 127
 128     uint64_t callbackID = callback->callbackID();
 129     m_appCacheInt64Callbacks.set(callbackID, callback.release());
 130
 131     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
 132     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::GetApplicationCacheQuota(callbackID));
 133 }
 134
 135 void WebApplicationCacheManagerProxy::didGetApplicationCacheQuota(const int64_t quota, uint64_t callbackID)
 136 {
 137     RefPtr<AppCacheInt64Callback> callback = m_appCacheInt64Callbacks.take(callbackID);
 138     if (!callback) {
 139         // FIXME: Log error or assert.
 140         // this can validly happen if a load invalidated the callback, though
 141         return;
 142     }
 143
 144     RefPtr<WebInt64> int64Object = WebInt64::create(quota);
 145     callback->performCallbackWithReturnValue(int64Object.release().leakRef());
 146 }
 147
 148 void WebApplicationCacheManagerProxy::getApplicationCacheUsageForOrigin(PassRefPtr<AppCacheInt64Callback> prpCallback, WebSecurityOrigin* origin)
 149 {
 150     RefPtr<AppCacheInt64Callback> callback = prpCallback;
 151     uint64_t callbackID = callback->callbackID();
 152     m_appCacheInt64Callbacks.set(callbackID, callback.release());
 153
 154     SecurityOriginData securityOriginData;
 155     securityOriginData.protocol = origin->protocol();
 156     securityOriginData.host = origin->host();
 157     securityOriginData.port = origin->port();
 158
 159     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
 160     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::GetApplicationCacheUsageForOrigin(callbackID, securityOriginData));
 161 }
 162
 163 void WebApplicationCacheManagerProxy::didGetApplicationCacheUsageForOrigin(const int64_t usage, uint64_t callbackID)
 164 {
 165     RefPtr<AppCacheInt64Callback> callback = m_appCacheInt64Callbacks.take(callbackID);
 166     if (!callback) {
 167         // FIXME: Log error or assert.
 168         // this can validly happen if a load invalidated the callback, though
 169         return;
 170     }
 171
 172     RefPtr<WebInt64> int64Object = WebInt64::create(usage);
 173     callback->performCallbackWithReturnValue(int64Object.release().leakRef());
 174 }
 175 #endif
 176
 177 void WebApplicationCacheManagerProxy::setApplicationCacheQuota(int64_t quota)
 178 {
 179     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
 180     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::SetApplicationCacheQuota(quota));
 181 }
 182
 183 void WebApplicationCacheManagerProxy::setApplicationCacheQuotaForOrigin(WebSecurityOrigin* origin, int64_t quota)
 184 {
 185     SecurityOriginData securityOriginData;
 186     securityOriginData.protocol = origin->protocol();
 187     securityOriginData.host = origin->host();
 188     securityOriginData.port = origin->port();
 189
 190     // FIXME (Multi-WebProcess): The application cache shouldn't be stored in the web process.
 191     m_webContext->sendToAllProcessesRelaunchingThemIfNecessary(Messages::WebApplicationCacheManager::SetApplicationCacheQuotaForOrigin(securityOriginData, quota));
 192 }
 193
 194 #endif
 195
 196 } // namespace WebKit