#include "ewk_context.h"
#include "BatteryProvider.h"
+#include "ContextHistoryClientEfl.h"
#include "NetworkInfoProvider.h"
+#include "RequestManagerClientEfl.h"
#include "VibrationProvider.h"
#include "WKAPICast.h"
#include "WKContextSoup.h"
#include "WKRetainPtr.h"
#include "WKString.h"
-#include "ewk_context_download_client_private.h"
+#include "WebContext.h"
+#include "WebSoupRequestManagerProxy.h"
#include "ewk_context_private.h"
-#include "ewk_context_request_manager_client_private.h"
#include "ewk_cookie_manager_private.h"
-#include "ewk_download_job.h"
-#include "ewk_download_job_private.h"
+#include "ewk_favicon_database_private.h"
+#include "ewk_url_scheme_request_private.h"
+#include <WebCore/FileSystem.h>
+#include <WebCore/IconDatabase.h>
#include <wtf/HashMap.h>
#include <wtf/text/WTFString.h>
#endif
#include "WKNumber.h"
#include "WKSecurityOrigin.h"
-#include "WKString.h"
#include "WKURL.h"
-#include "WebContext.h"
#include "ewk_context_injected_bundle_client.h"
#include "ewk_security_origin.h"
+#include "ewk_private.h"
#include <Eina.h>
-#include <WebCore/FileSystem.h>
-#include <wtf/text/WTFString.h>
#if ENABLE(TIZEN_WRT_LAUNCHING_PERFORMANCE)
#include "ProcessLauncher.h"
#include <stdlib.h>
#endif
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+#include "FormDatabase.h"
+#include "WKDictionary.h"
+#endif
#endif // #if OS(TIZEN)
#if ENABLE(SPELLCHECK)
#include "ewk_settings.h"
#include "ewk_text_checker_private.h"
#endif
-using namespace WebKit;
+#if ENABLE(TIZEN_WEBKIT2_DDK_CHECK)
+#include <EGL/egl.h>
+#endif
-struct _Ewk_Url_Scheme_Handler {
- Ewk_Url_Scheme_Request_Cb callback;
- void* userData;
+#if ENABLE(TIZEN_HW_MORE_BACK_KEY)
+#include <dlfcn.h>
+void* EflAssistHandle = 0;
+#endif
- _Ewk_Url_Scheme_Handler()
- : callback(0)
- , userData(0)
- { }
+using namespace WebCore;
+using namespace WebKit;
- _Ewk_Url_Scheme_Handler(Ewk_Url_Scheme_Request_Cb callback, void* userData)
- : callback(callback)
- , userData(userData)
- { }
-};
+typedef HashMap<WKContextRef, Ewk_Context*> ContextMap;
-typedef HashMap<String, _Ewk_Url_Scheme_Handler> URLSchemeHandlerMap;
+static inline ContextMap& contextMap()
+{
+ DEFINE_STATIC_LOCAL(ContextMap, map, ());
+ return map;
+}
-struct _Ewk_Context {
- WKRetainPtr<WKContextRef> context;
+Ewk_Context::Ewk_Context(WKContextRef context)
+ : m_context(context)
+ , m_historyClient(ContextHistoryClientEfl::create(context))
+{
+ ContextMap::AddResult result = contextMap().add(context, this);
+ ASSERT_UNUSED(result, result.isNewEntry);
- Ewk_Cookie_Manager* cookieManager;
#if ENABLE(BATTERY_STATUS)
- RefPtr<BatteryProvider> batteryProvider;
+ m_batteryProvider = BatteryProvider::create(context);
#endif
+
#if ENABLE(NETWORK_INFO)
- RefPtr<NetworkInfoProvider> networkInfoProvider;
+ m_networkInfoProvider = NetworkInfoProvider::create(context);
#endif
+
#if ENABLE(VIBRATION)
- RefPtr<VibrationProvider> vibrationProvider;
+ m_vibrationProvider = VibrationProvider::create(context);
#endif
- HashMap<uint64_t, Ewk_Download_Job*> downloadJobs;
- WKRetainPtr<WKSoupRequestManagerRef> requestManager;
- URLSchemeHandlerMap urlSchemeHandlers;
+#if ENABLE(MEMORY_SAMPLER)
+ static bool initializeMemorySampler = false;
+ static const char environmentVariable[] = "SAMPLE_MEMORY";
-#if OS(TIZEN)
- const char* proxyAddress;
-#if ENABLE(TIZEN_CERTIFICATE_HANDLING)
- const char* certificateFile;
+ if (!initializeMemorySampler && getenv(environmentVariable)) {
+ WKRetainPtr<WKDoubleRef> interval(AdoptWK, WKDoubleCreate(0.0));
+ WKContextStartMemorySampler(context, interval.get());
+ initializeMemorySampler = true;
+ }
#endif
+
+#if ENABLE(SPELLCHECK)
+ Ewk_Text_Checker::initialize();
+ if (ewk_settings_continuous_spell_checking_enabled_get()) {
+ // Load the default language.
+ ewk_settings_spell_checking_languages_set(0);
+ }
+#endif
+
+ // Initialize WKContext clients.
+ m_downloadManager = DownloadManagerEfl::create(this);
+ m_requestManagerClient = RequestManagerClientEfl::create(this);
+
+#if OS(TIZEN)
#if ENABLE(TIZEN_SQL_DATABASE)
- uint64_t defaultDatabaseQuota;
-#endif
- struct {
- Ewk_Context_Message_From_Injected_Bundle_Callback callback;
- void* userData;
- } messageFromInjectedBundle;
- struct {
- Ewk_Context_Did_Start_Download_Callback callback;
- void* userData;
- } didStartDownload;
-#if ENABLE(TIZEN_WEBKIT2_CONTEXT_X_WINDOW)
- Ecore_X_Window xWindow;
+ m_defaultDatabaseQuota = 5 * 1024 * 1024;
#endif
+ m_messageFromInjectedBundle.callback = 0;
+ m_messageFromInjectedBundle.userData = 0;
+ m_didStartDownload.callback = 0;
+ m_didStartDownload.userData = 0;
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+ m_formDatabase = FormDatabase::create();
+ m_formDatabase->open(FormDatabase::defaultDatabaseDirectoryPath(), FormDatabase::defaultDatabaseFilename());
#endif
-
- _Ewk_Context(WKRetainPtr<WKContextRef> contextRef)
- : context(contextRef)
- , cookieManager(0)
- , requestManager(WKContextGetSoupRequestManager(contextRef.get()))
- {
-#if ENABLE(BATTERY_STATUS)
- batteryProvider = BatteryProvider::create(context.get());
#endif
-#if ENABLE(NETWORK_INFO)
- networkInfoProvider = NetworkInfoProvider::create(context.get());
+#if ENABLE(TIZEN_HW_MORE_BACK_KEY)
+ if (!EflAssistHandle)
+ EflAssistHandle = dlopen("/usr/lib/libefl-assist.so.0", RTLD_LAZY);
#endif
+}
-#if ENABLE(VIBRATION)
- vibrationProvider = VibrationProvider::create(context.get());
+Ewk_Context::~Ewk_Context()
+{
+ ASSERT(contextMap().get(m_context.get()) == this);
+ contextMap().remove(m_context.get());
+#if ENABLE(TIZEN_CACHE_DUMP_SYNC)
+ dumpCache();
#endif
+}
- ewk_context_request_manager_client_attach(this);
- ewk_context_download_client_attach(this);
-#if ENABLE(SPELLCHECK)
- Ewk_Text_Checker::initialize();
- if (ewk_settings_continuous_spell_checking_enabled_get()) {
- // Load the default language.
- ewk_settings_spell_checking_languages_set(0);
- }
-#endif
+PassRefPtr<Ewk_Context> Ewk_Context::create(WKContextRef context)
+{
+ if (contextMap().contains(context))
+ return contextMap().get(context); // Will be ref-ed automatically.
-#if OS(TIZEN)
- this->proxyAddress = 0;
-#if ENABLE(TIZEN_CERTIFICATE_HANDLING)
- this->certificateFile = 0;
-#endif
-#if ENABLE(TIZEN_SQL_DATABASE)
- this->defaultDatabaseQuota = 5 * 1024 * 1024;
-#endif
- this->messageFromInjectedBundle.callback = 0;
- this->messageFromInjectedBundle.userData = 0;
- this->didStartDownload.callback = 0;
- this->didStartDownload.userData = 0;
+ return adoptRef(new Ewk_Context(context));
+}
+
+PassRefPtr<Ewk_Context> Ewk_Context::create()
+{
+ return create(adoptWK(WKContextCreate()).get());
+}
+
+PassRefPtr<Ewk_Context> Ewk_Context::create(const String& injectedBundlePath)
+{
+ if (!fileExists(injectedBundlePath))
+ return 0;
+
+ WKRetainPtr<WKStringRef> injectedBundlePathWK = adoptWK(toCopiedAPI(injectedBundlePath));
+ WKRetainPtr<WKContextRef> contextWK = adoptWK(WKContextCreateWithInjectedBundlePath(injectedBundlePathWK.get()));
+
+ return create(contextWK.get());
+}
+
+PassRefPtr<Ewk_Context> Ewk_Context::defaultContext()
+{
+ static RefPtr<Ewk_Context> defaultInstance = create(adoptWK(WKContextCreate()).get());
+
+ return defaultInstance;
+}
+
+Ewk_Cookie_Manager* Ewk_Context::cookieManager()
+{
+ if (!m_cookieManager)
+ m_cookieManager = Ewk_Cookie_Manager::create(WKContextGetCookieManager(m_context.get()));
+
+ return m_cookieManager.get();
+}
+
+Ewk_Favicon_Database* Ewk_Context::faviconDatabase()
+{
+#if ENABLE(TIZEN_ICON_DATABASE)
+ return 0;
#endif
+ if (!m_faviconDatabase) {
+ WKRetainPtr<WKIconDatabaseRef> iconDatabase = WKContextGetIconDatabase(m_context.get());
+ // Set the database path if it is not open yet.
+ if (!toImpl(iconDatabase.get())->isOpen()) {
+ WebContext* webContext = toImpl(m_context.get());
+ String databasePath = webContext->iconDatabasePath() + "/" + WebCore::IconDatabase::defaultDatabaseFilename();
+ webContext->setIconDatabasePath(databasePath);
+ }
+ m_faviconDatabase = Ewk_Favicon_Database::create(iconDatabase.get());
}
- ~_Ewk_Context()
- {
- if (cookieManager)
- ewk_cookie_manager_free(cookieManager);
+ return m_faviconDatabase.get();
+}
+
+RequestManagerClientEfl* Ewk_Context::requestManager()
+{
+ return m_requestManagerClient.get();
+}
-#if ENABLE(TIZEN_CACHE_DUMP_SYNC)
- ewk_context_cache_dump(this);
+#if ENABLE(VIBRATION)
+PassRefPtr<VibrationProvider> Ewk_Context::vibrationProvider()
+{
+ return m_vibrationProvider;
+}
#endif
- HashMap<uint64_t, Ewk_Download_Job*>::iterator it = downloadJobs.begin();
- HashMap<uint64_t, Ewk_Download_Job*>::iterator end = downloadJobs.end();
- for ( ; it != end; ++it)
- ewk_download_job_unref(it->second);
- }
-};
+void Ewk_Context::addVisitedLink(const String& visitedURL)
+{
+ toImpl(m_context.get())->addVisitedLink(visitedURL);
+}
+
+void Ewk_Context::setCacheModel(Ewk_Cache_Model cacheModel)
+{
+ WKContextSetCacheModel(m_context.get(), static_cast<Ewk_Cache_Model>(cacheModel));
+}
+
+Ewk_Cache_Model Ewk_Context::cacheModel() const
+{
+ return static_cast<Ewk_Cache_Model>(WKContextGetCacheModel(m_context.get()));
+}
+
+Ewk_Context* ewk_context_ref(Ewk_Context* ewkContext)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
+
+ ewkContext->ref();
+
+ return ewkContext;
+}
+
+void ewk_context_unref(Ewk_Context* ewkContext)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ewkContext);
+
+ ewkContext->deref();
+}
Ewk_Cookie_Manager* ewk_context_cookie_manager_get(const Ewk_Context* ewkContext)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
- if (!ewkContext->cookieManager)
- const_cast<Ewk_Context*>(ewkContext)->cookieManager = ewk_cookie_manager_new(WKContextGetCookieManager(ewkContext->context.get()));
+ return const_cast<Ewk_Context*>(ewkContext)->cookieManager();
+}
+
+Ewk_Favicon_Database* ewk_context_favicon_database_get(const Ewk_Context* ewkContext)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
+
+ return const_cast<Ewk_Context*>(ewkContext)->faviconDatabase();
+}
- return ewkContext->cookieManager;
+WKContextRef Ewk_Context::wkContext()
+{
+ return m_context.get();
}
-WKContextRef ewk_context_WKContext_get(const Ewk_Context* ewkContext)
+DownloadManagerEfl* Ewk_Context::downloadManager() const
{
- return ewkContext->context.get();
+ return m_downloadManager.get();
}
-/**
- * @internal
- * Registers that a new download has been requested.
- */
-void ewk_context_download_job_add(Ewk_Context* ewkContext, Ewk_Download_Job* ewkDownload)
+ContextHistoryClientEfl* Ewk_Context::historyClient()
{
- EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- EINA_SAFETY_ON_NULL_RETURN(ewkDownload);
+ return m_historyClient.get();
+}
+
+#if OS(TIZEN)
+bool Ewk_Context::setProxyAddress(const char* proxyAddress)
+{
+ if (m_proxyAddress == proxyAddress)
+ return false;
+
+ m_proxyAddress = proxyAddress;
+ return true;
+}
+
+#if ENABLE(TIZEN_CERTIFICATE_HANDLING)
+bool Ewk_Context::setCertificateFile(const char* certificateFile)
+{
+ if (m_certificateFile == certificateFile)
+ return false;
+
+ m_certificateFile = certificateFile;
+ return true;
+}
+#endif
- uint64_t downloadId = ewk_download_job_id_get(ewkDownload);
- if (ewkContext->downloadJobs.contains(downloadId))
+void Ewk_Context::setDefaultDatabaseQuota(uint64_t defaultDatabaseQuota)
+{
+ m_defaultDatabaseQuota = defaultDatabaseQuota;
+}
+
+void Ewk_Context::setMessageFromInjectedBundleCallback(Ewk_Context_Message_From_Injected_Bundle_Callback callback, void* userData)
+{
+ m_messageFromInjectedBundle.callback = callback;
+ m_messageFromInjectedBundle.userData = userData;
+}
+
+void Ewk_Context::didReceiveMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData)
+{
+ if (!m_messageFromInjectedBundle.callback)
return;
- ewk_download_job_ref(ewkDownload);
- ewkContext->downloadJobs.add(downloadId, ewkDownload);
+ CString name = toImpl(messageName)->string().utf8();
+ CString body;
+ if (messageBody && WKStringGetTypeID() == WKGetTypeID(messageBody))
+ body = toImpl(static_cast<WKStringRef>(messageBody))->string().utf8();
+
+ if (returnData) {
+ char* returnString = 0;
+ m_messageFromInjectedBundle.callback(name.data(), body.data(), &returnString,
+ m_messageFromInjectedBundle.userData);
+ if (returnString) {
+ *returnData = WKStringCreateWithUTF8CString(returnString);
+ free(returnString);
+ } else
+ *returnData = WKStringCreateWithUTF8CString("");
+ } else
+ m_messageFromInjectedBundle.callback(name.data(), body.data(), 0, m_messageFromInjectedBundle.userData);
}
-/**
- * @internal
- * Returns the #Ewk_Download_Job with the given @a downloadId, or
- * @c 0 in case of failure.
- */
-Ewk_Download_Job* ewk_context_download_job_get(const Ewk_Context* ewkContext, uint64_t downloadId)
+void Ewk_Context::setDidStartDownloadCallback(Ewk_Context_Did_Start_Download_Callback callback, void* userData)
{
- EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
+ m_didStartDownload.callback = callback;
+ m_didStartDownload.userData = userData;
+}
+
+void Ewk_Context::didStartDownload(WKStringRef downloadURL)
+{
+ EINA_SAFETY_ON_NULL_RETURN(m_didStartDownload.callback);
- return ewkContext->downloadJobs.get(downloadId);
+ m_didStartDownload.callback(toImpl(downloadURL)->string().utf8().data(), m_didStartDownload.userData);
}
-/**
- * @internal
- * Removes the #Ewk_Download_Job with the given @a downloadId from the internal
- * HashMap.
- */
-void ewk_context_download_job_remove(Ewk_Context* ewkContext, uint64_t downloadId)
+#if ENABLE(TIZEN_CACHE_MEMORY_OPTIMIZATION)
+void Ewk_Context::clearAllDecodedData()
{
- EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- Ewk_Download_Job* download = ewkContext->downloadJobs.take(downloadId);
- if (download)
- ewk_download_job_unref(download);
+ WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(wkContext());
+ WKResourceCacheManagerClearCacheForAllOrigins(cacheManager, WKResourceCachesToClearInDecodedDataOnly);
}
+#endif
-/**
- * Retrieve the request manager for @a ewkContext.
- *
- * @param ewkContext a #Ewk_Context object.
- */
-WKSoupRequestManagerRef ewk_context_request_manager_get(const Ewk_Context* ewkContext)
+#if ENABLE(TIZEN_WEBKIT2_CONTEXT_X_WINDOW)
+Ecore_X_Window Ewk_Context::xWindow()
{
- return ewkContext->requestManager.get();
+ return m_xWindow;
}
-/**
- * @internal
- * A new URL request was received.
- *
- * @param ewkContext a #Ewk_Context object.
- * @param schemeRequest a #Ewk_Url_Scheme_Request object.
- */
-void ewk_context_url_scheme_request_received(Ewk_Context* ewkContext, Ewk_Url_Scheme_Request* schemeRequest)
+void Ewk_Context::setXWindow(Ecore_X_Window xWindow)
{
- EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- EINA_SAFETY_ON_NULL_RETURN(schemeRequest);
+ toImpl(wkContext())->setXWindow(xWindow);
+}
+#endif
- _Ewk_Url_Scheme_Handler handler = ewkContext->urlSchemeHandlers.get(ewk_url_scheme_request_scheme_get(schemeRequest));
- if (!handler.callback)
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+void Ewk_Context::addFormData(const char* url, WKDictionaryRef& formData, bool isPasswordForm)
+{
+ EINA_SAFETY_ON_NULL_RETURN(url);
+ if (!m_formDatabase->isOpen())
return;
- handler.callback(schemeRequest, handler.userData);
+ Vector<std::pair<String, String> > formDataVector;
+ WKRetainPtr<WKArrayRef> wkKeys(AdoptWK, WKDictionaryCopyKeys(formData));
+ size_t numKeys = WKArrayGetSize(wkKeys.get());
+ for (size_t i = 0; i < numKeys; ++i) {
+ WKStringRef wkKey = static_cast<WKStringRef>(WKArrayGetItemAtIndex(wkKeys.get(), i));
+ WKStringRef wkValue = static_cast<WKStringRef>(WKDictionaryGetItemForKey(formData, wkKey));
+
+ formDataVector.append(pair<String, String>(toImpl(wkKey)->string(), toImpl(wkValue)->string()));
+ }
+
+ m_formDatabase->addFormDataForURL(String::fromUTF8(url), formDataVector, isPasswordForm);
}
-static inline Ewk_Context* createDefaultEwkContext()
+void Ewk_Context::passwordFormData(const char* url, Vector<std::pair<String, String> >& passwordFormData)
+{
+ EINA_SAFETY_ON_NULL_RETURN(url);
+ if (!m_formDatabase->isOpen())
+ return;
+ m_formDatabase->getPasswordFormDataForURL(String::fromUTF8(url), passwordFormData);
+}
+
+void Ewk_Context::candidateFormData(const String& name, Vector<String>& candidates)
+{
+ if (!m_formDatabase->isOpen())
+ return;
+ m_formDatabase->getCandidateFormDataForName(name, candidates);
+}
+
+void Ewk_Context::clearPasswordFormData()
+{
+ m_formDatabase->clearPasswordFormData();
+}
+
+void Ewk_Context::clearCandidateFormData()
+{
+ m_formDatabase->clearCandidateFormData();
+}
+
+#endif
+
+#if ENABLE(TIZEN_CACHE_DUMP_SYNC)
+/**
+ * @internal
+ * Request WebProcess to dump cache.
+ *
+ * This sends sync message to WebProcess to dump memory cache, that is, soup cache.
+ *
+ * @param context context object
+ *
+ * @return @c EINA_TRUE on success or @c EINA_FALSE on failure
+ *
+ * @note This can effect UIProcess's performance because it calls to sync IPC message eventually.
+ */
+void Ewk_Context::dumpCache()
{
- return new Ewk_Context(WKContextGetSharedProcessContext());
+ WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(wkContext());
+ toImpl(cacheManager)->dumpCache();
}
+#endif
+#endif
Ewk_Context* ewk_context_default_get()
{
-#if OS(TIZEN)
- static Ewk_Context* defaultContext = ewk_context_new();
- return defaultContext;
-#else // #if OS(TIZEN)
- DEFINE_STATIC_LOCAL(Ewk_Context, defaultContext, (WKContextGetSharedProcessContext()));
- return &defaultContext;
-#endif // #if OS(TIZEN)
+ return Ewk_Context::defaultContext().get();
}
#if OS(TIZEN)
-typedef struct _Ewk_Context_Callback_Context
+typedef struct Ewk_Context_Callback_Context
{
union {
#if ENABLE(TIZEN_FILE_SYSTEM)
Ewk_Web_Storage_Origins_Get_Callback webStorageOriginsCallback;
Ewk_Web_Storage_Usage_Get_Callback webStorageUsageCallback;
Ewk_Web_Storage_Path_Get_Callback webStoragePathCallback;
- Ewk_Cookies_Policy_Get_Callback cookiesPolicyGetCallback;
};
void* userData;
} Ewk_Context_Callback_Context;
#if ENABLE(TIZEN_SQL_DATABASE)
-struct _Ewk_Context_Exceeded_Quota
+struct Ewk_Context_Exceeded_Quota
{
Ewk_Security_Origin* origin;
const char* databaseName;
};
#endif
-#if ENABLE(TIZEN_FILE_SYSTEM)
-struct _Ewk_Context_File_System_Permission
-{
- Ewk_Security_Origin* origin;
- bool isAllowed;
-
- _Ewk_Context_File_System_Permission(WKSecurityOriginRef origin)
- {
- this->origin = createSecurityOrigin(origin);
- this->isAllowed = true;
- }
- ~_Ewk_Context_File_System_Permission()
- {
- deleteSecurityOrigin(this->origin);
- }
-};
-#endif
-
-/**
- * @internal
- * Create Ewk_Context with WKContext.
- */
-Ewk_Context* ewk_context_new_from_WKContext(WKContextRef contextRef)
-{
- EINA_SAFETY_ON_NULL_RETURN_VAL(contextRef, 0);
-
- return new Ewk_Context(contextRef);
-}
-
-#if ENABLE(TIZEN_FILE_SYSTEM)
-Ewk_Context_File_System_Permission* ewkContextCreateFileSystemPermission(WKSecurityOriginRef origin)
-{
- return new Ewk_Context_File_System_Permission(origin);
-}
-
-void ewkContextDeleteFileSystemPermission(Ewk_Context_File_System_Permission* fileSystemPermission)
-{
- delete fileSystemPermission;
-}
-
-bool ewkContextIsAllowedFileSystemPermission(Ewk_Context_File_System_Permission* fileSystemPermission)
-{
- return fileSystemPermission->isAllowed;
-}
-#endif
-
#if ENABLE(TIZEN_SQL_DATABASE)
Ewk_Context_Exceeded_Quota* ewkContextCreateExceededQuota(WKSecurityOriginRef origin, WKStringRef databaseName, WKStringRef displayName, unsigned long long currentQuota, unsigned long long currentOriginUsage, unsigned long long currentDatabaseUsage, unsigned long long expectedUsage)
{
unsigned long long ewkContextGetNewQuotaForExceededQuota(Ewk_Context* ewkContext, Ewk_Context_Exceeded_Quota* exceededQuota)
{
if (exceededQuota->newQuota)
- return exceededQuota->newQuota;
+ return exceededQuota->newQuota + exceededQuota->currentQuota;
if (exceededQuota->currentQuota)
return exceededQuota->currentQuota;
- return ewkContext->defaultDatabaseQuota;
+ return ewkContext->defaultDatabaseQuota();
}
uint64_t ewkContextGetDatabaseQuota(Ewk_Context* ewkContext)
{
- return ewkContext->defaultDatabaseQuota;
+ return ewkContext->defaultDatabaseQuota();
}
#endif
/* public */
Ewk_Context* ewk_context_new()
{
- Ewk_Context* ewk_context = new Ewk_Context(adoptWK(WKContextCreate()));
-
+#if OS(TIZEN)
+ Ewk_Context* ewk_context = Ewk_Context::create().leakRef();
ewkContextInjectedBundleClientAttachClient(ewk_context);
-
return ewk_context;
+#endif
+ return Ewk_Context::create().leakRef();
}
Ewk_Context* ewk_context_new_with_injected_bundle_path(const char* path)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(path, 0);
+#if ENABLE(TIZEN_WEBKIT2_DDK_CHECK)
+ // FIXME : OpenGL check code for WRT before launching WebProcess.
+ if(!eglGetDisplay(EGL_DEFAULT_DISPLAY)) {
+ EINA_LOG_CRIT("Fail in initiziling view because No DDK is installed.");
+ return 0;
+ }
+#endif
+
#if ENABLE(TIZEN_WRT_LAUNCHING_PERFORMANCE)
char* wrtLaunchingPerformance = getenv("WRT_LAUNCHING_PERFORMANCE");
if (wrtLaunchingPerformance && !strcmp(wrtLaunchingPerformance, "1")) {
if (ProcessLauncher::isParentProcess()) {
Ewk_Context* ewkContext = ewk_context_new_with_injected_bundle_path(path);
- WKContextRef contextRef = ewk_context_WKContext_get(ewkContext);
+ WKContextRef contextRef = ewkContext->wkContext();
toImpl(contextRef)->ensureWebProcess();
return ewkContext;
}
}
#endif
- WKRetainPtr<WKStringRef> pathRef(AdoptWK, WKStringCreateWithUTF8CString(path));
- Ewk_Context* ewk_context = new Ewk_Context(adoptWK(WKContextCreateWithInjectedBundlePath(pathRef.get())));
-
+#if OS(TIZEN)
+ Ewk_Context* ewk_context = Ewk_Context::create(String::fromUTF8(path)).leakRef();
ewkContextInjectedBundleClientAttachClient(ewk_context);
-
return ewk_context;
+#endif
+ return Ewk_Context::create(String::fromUTF8(path)).leakRef();
}
void ewk_context_delete(Ewk_Context* ewkContext)
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- if (ewkContext == ewk_context_default_get())
+ if (ewkContext == ewk_context_default_get() && ewkContext->hasOneRef())
return;
- eina_stringshare_del(ewkContext->proxyAddress);
-#if ENABLE(TIZEN_CERTIFICATE_HANDLING)
- eina_stringshare_del(ewkContext->certificateFile);
-#endif
delete ewkContext;
}
void ewk_context_proxy_uri_set(Ewk_Context* ewkContext, const char* proxy)
{
- if (ewkContext && eina_stringshare_replace(&ewkContext->proxyAddress, proxy)) {
+ if (ewkContext && ewkContext->setProxyAddress(proxy)) {
WKRetainPtr<WKURLRef> proxyAddress(AdoptWK, WKURLCreateWithUTF8CString(proxy));
- WKContextRef contextRef = ewk_context_WKContext_get(ewkContext);
+ WKContextRef contextRef = ewkContext->wkContext();
toImpl(contextRef)->setProxy(toWTFString(proxyAddress.get()));
}
}
#if ENABLE(TIZEN_WEBKIT2_PATCH_FOR_TC)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
#endif
- return ewkContext->proxyAddress;
+ return ewkContext->proxyAddress();
}
void ewk_context_network_session_requests_cancel(Ewk_Context* ewkContext)
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- WKContextRef contextRef = ewk_context_WKContext_get(ewkContext);
+ WKContextRef contextRef = ewkContext->wkContext();
toImpl(contextRef)->abortSession();
}
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKContextRef contextRef = ewk_context_WKContext_get(ewkContext);
+ WKContextRef contextRef = ewkContext->wkContext();
toImpl(contextRef)->notifyLowMemory();
return true;
}
#if ENABLE(TIZEN_APPLICATION_CACHE)
static void didGetWebApplicationOrigins(WKArrayRef origins, WKErrorRef error, void* context)
{
+ TIZEN_LOGI("origin size(%d)", WKArrayGetSize(origins));
Eina_List* originList = 0;
for(size_t i = 0; i < WKArrayGetSize(origins); i++) {
OwnArrayPtr<char> applicationCachePath = adoptArrayPtr(new char[length]);
WKStringGetUTF8CString(path, applicationCachePath.get(), length);
+ TIZEN_LOGI("path (%s)", applicationCachePath.get());
applicationCacheContext->webApplicationCachePathCallback(eina_stringshare_add(applicationCachePath.get()), applicationCacheContext->userData);
delete applicationCacheContext;
}
static void didGetWebApplicationQuota(WKInt64Ref quota, WKErrorRef error, void* context)
{
Ewk_Context_Callback_Context* applicationCacheContext = static_cast<Ewk_Context_Callback_Context*>(context);
+ TIZEN_LOGI("quota (%d)", toImpl(quota)->value());
applicationCacheContext->webApplicationCacheQuotaCallback(toImpl(quota)->value(), applicationCacheContext->userData);
delete applicationCacheContext;
}
static void didGetWebApplicationUsageForOrigin(WKInt64Ref usage, WKErrorRef error, void* context)
{
Ewk_Context_Callback_Context* applicationCacheContext = static_cast<Ewk_Context_Callback_Context*>(context);
+ TIZEN_LOGI("usage (%d)", toImpl(usage)->value());
applicationCacheContext->webApplicationCacheUsageForOriginCallback(toImpl(usage)->value(), applicationCacheContext->userData);
delete applicationCacheContext;
}
#if ENABLE(TIZEN_SQL_DATABASE)
static void didGetWebDatabaseOrigins(WKArrayRef origins, WKErrorRef error, void* context)
{
+ TIZEN_LOGI("origin size(%d)", WKArrayGetSize(origins));
Eina_List* originList = 0;
for(size_t i = 0; i < WKArrayGetSize(origins); i++) {
static void didGetWebDatabaseQuota(WKUInt64Ref quota, WKErrorRef error, void* context)
{
Ewk_Context_Callback_Context* webDatabaseContext = static_cast<Ewk_Context_Callback_Context*>(context);
+ TIZEN_LOGI("quota (%d)", toImpl(quota)->value());
webDatabaseContext->webDatabaseQuotaCallback(toImpl(quota)->value(), webDatabaseContext->userData);
delete webDatabaseContext;
}
static void didGetWebDatabaseUsage(WKUInt64Ref usage, WKErrorRef error, void* context)
{
Ewk_Context_Callback_Context* webDatabaseContext = static_cast<Ewk_Context_Callback_Context*>(context);
+ TIZEN_LOGI("usage (%d)", toImpl(usage)->value());
webDatabaseContext->webDatabaseUsageCallback(toImpl(usage)->value(), webDatabaseContext->userData);
delete webDatabaseContext;
}
OwnArrayPtr<char> databasePath = adoptArrayPtr(new char[length]);
WKStringGetUTF8CString(path, databasePath.get(), length);
+ TIZEN_LOGI("path (%s)", databasePath.get());
webDatabaseContext->webDatabasePathCallback(eina_stringshare_add(databasePath.get()), webDatabaseContext->userData);
delete webDatabaseContext;
}
#if ENABLE(TIZEN_WEB_STORAGE)
static void didGetWebStorageOrigins(WKArrayRef origins, WKErrorRef error, void* context)
{
+ TIZEN_LOGI("origin size(%d)", WKArrayGetSize(origins));
Eina_List* originList = 0;
for(size_t i = 0; i < WKArrayGetSize(origins); i++) {
OwnArrayPtr<char> storagePath = adoptArrayPtr(new char[length]);
WKStringGetUTF8CString(path, storagePath.get(), length);
+ TIZEN_LOGI("path (%s)", storagePath.get());
webStorageContext->webStoragePathCallback(eina_stringshare_add(storagePath.get()), webStorageContext->userData);
delete webStorageContext;
}
static void didGetWebStorageUsage(WKInt64Ref usage, WKErrorRef error, void* context)
{
Ewk_Context_Callback_Context* webStorageContext = static_cast<Ewk_Context_Callback_Context*>(context);
+
+ TIZEN_LOGI("usage (%s)", toImpl(usage)->value());
webStorageContext->webStorageUsageCallback(toImpl(usage)->value(), webStorageContext->userData);
delete webStorageContext;
}
#if ENABLE(TIZEN_APPLICATION_CACHE)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ TIZEN_LOGI("ewkContext (%p)", ewkContext);
+ WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerDeleteAllEntries(applicationCache);
return true;
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKSecurityOriginRef> securityOriginRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerDeleteEntriesForOrigin(applicationCacheRef, securityOriginRef.get());
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("ewkContext (%p)", ewkContext);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->webApplicationCacheOriginsCallback = callback;
context->userData = userData;
- WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerGetApplicationCacheOrigins(applicationCacheRef, context, didGetWebApplicationOrigins);
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
+ if (!path) {
+ TIZEN_LOGE("Path value is invalid");
+ return false;
+ }
+
+ TIZEN_LOGI("path (%s)", path);
WKRetainPtr<WKStringRef> applicationCachePathRef(AdoptWK, WKStringCreateWithUTF8CString(path));
- WKContextSetApplicationCacheDirectory(ewk_context_WKContext_get(ewkContext), applicationCachePathRef.get());
+ WKContextSetApplicationCacheDirectory(ewkContext->wkContext(), applicationCachePathRef.get());
return true;
#else
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("callback (%p)", callback);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->webApplicationCachePathCallback= callback;
context->userData = userData;
- WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerGetApplicationCachePath(applicationCacheRef, context, didGetWebApplicationPath);
return true;
#else
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("callback (%p)", callback);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->webApplicationCacheQuotaCallback = callback;
context->userData = userData;
- WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerGetApplicationCacheQuota(applicationCacheRef, context, didGetWebApplicationQuota);
return true;
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerGetApplicationCacheUsageForOrigin(applicationCache, context, originRef.get(), didGetWebApplicationUsageForOrigin);
return true;
{
#if ENABLE(TIZEN_APPLICATION_CACHE)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- if (!quota)
+ if (!quota) {
+ TIZEN_LOGE("Quota value is invalid");
return false;
+ }
- WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ TIZEN_LOGI("quota (%d)", quota);
+ WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerSetApplicationCacheQuota(applicationCacheRef, quota);
return true;
#if ENABLE(TIZEN_APPLICATION_CACHE)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
- if (!quota)
+ if (!quota) {
+ TIZEN_LOGE("Quota value is invalid");
return false;
+ }
+ TIZEN_LOGI("quota (%d)", quota);
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewk_context_WKContext_get(ewkContext));
+ WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewkContext->wkContext());
WKApplicationCacheManagerSetApplicationCacheQuotaForOrigin(applicationCache, originRef.get(), quota);
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
WKRetainPtr<WKStringRef> databasePath(AdoptWK, WKStringCreateWithUTF8CString(path));
- WKContextSetIconDatabasePath(ewk_context_WKContext_get(ewkContext), databasePath.get());
+ WKContextSetIconDatabasePath(ewkContext->wkContext(), databasePath.get());
return true;
}
EINA_SAFETY_ON_NULL_RETURN_VAL(uri, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);
- WKIconDatabaseRef iconDatabase = WKContextGetIconDatabase(ewk_context_WKContext_get(ewkContext));
+ WKIconDatabaseRef iconDatabase = WKContextGetIconDatabase(ewkContext->wkContext());
WKRetainPtr<WKURLRef> urlString(AdoptWK, WKURLCreateWithUTF8CString(uri));
return WKIconDatabaseTryGetImageForURL(iconDatabase, canvas, urlString.get());
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- WKIconDatabaseRef iconDatabase = WKContextGetIconDatabase(ewk_context_WKContext_get(ewkContext));
+ WKIconDatabaseRef iconDatabase = WKContextGetIconDatabase(ewkContext->wkContext());
WKIconDatabaseRemoveAllIcons(iconDatabase);
}
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
+ TIZEN_LOGI("path (%s)", path);
WKRetainPtr<WKStringRef> localFileSystemPathRef(AdoptWK, WKStringCreateWithUTF8CString(path));
- WKContextSetLocalFileSystemDirectory(ewk_context_WKContext_get(ewkContext), localFileSystemPathRef.get());
+ WKContextSetLocalFileSystemDirectory(ewkContext->wkContext(), localFileSystemPathRef.get());
return true;
#else
#if ENABLE(TIZEN_FILE_SYSTEM)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(ewk_context_WKContext_get(ewkContext));
+ TIZEN_LOGI("ewkContex (%p)", ewkContext);
+ WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(ewkContext->wkContext());
WKLocalFileSystemManagerDeleteAllLocalFileSystem(localFileSystemManager);
return true;
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(ewk_context_WKContext_get(ewkContext));
+ WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(ewkContext->wkContext());
WKLocalFileSystemManagerDeleteLocalFileSystem(localFileSystemManager, originRef.get());
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("callback (%p)", callback);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->localFileSystemOriginsCallback= callback;
context->userData = userData;
- WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(ewk_context_WKContext_get(ewkContext));
+ WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(const_cast<Ewk_Context*>(ewkContext)->wkContext());
WKLocalFileSystemManagerGetLocalFileSystemOrigins(localFileSystemManager, context, didGetLocalFileSystemOrigins);
#endif
}
-void ewk_context_file_system_permission_allow_set(Ewk_Context_File_System_Permission* fileSystemPermission, Eina_Bool allow)
-{
-#if ENABLE(TIZEN_FILE_SYSTEM)
- EINA_SAFETY_ON_NULL_RETURN(fileSystemPermission);
-
- fileSystemPermission->isAllowed = allow;
-#endif
-}
-
-Ewk_Security_Origin* ewk_context_file_system_permission_origin_get(Ewk_Context_File_System_Permission* fileSystemPermission)
-{
-#if ENABLE(TIZEN_FILE_SYSTEM)
- EINA_SAFETY_ON_NULL_RETURN_VAL(fileSystemPermission, 0);
-
- return fileSystemPermission->origin;
-#endif
-}
-
Ewk_Security_Origin* ewk_context_web_database_exceeded_quota_security_origin_get(Ewk_Context_Exceeded_Quota* exceededQuota)
{
#if ENABLE(TIZEN_SQL_DATABASE)
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
+ TIZEN_LOGI("name (%s)", exceededQuota->databaseName);
return exceededQuota->databaseName;
#else
return 0;
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
+ TIZEN_LOGI("displayName (%s)", exceededQuota->displayName);
return exceededQuota->displayName;
#else
return 0;
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
+ TIZEN_LOGI("quota (%d)", exceededQuota->currentQuota);
return exceededQuota->currentQuota;
#else
return 0;
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
+ TIZEN_LOGI("currentOriginUsage (%d)", exceededQuota->currentOriginUsage);
return exceededQuota->currentOriginUsage;
#else
return 0;
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
+ TIZEN_LOGI("currentDatabaseUsage (%d)", exceededQuota->currentDatabaseUsage);
return exceededQuota->currentDatabaseUsage;
#else
return 0;
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
+ TIZEN_LOGI("expectedUsage (%d)", exceededQuota->expectedUsage);
return exceededQuota->expectedUsage;
#else
return 0;
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN(exceededQuota);
+ TIZEN_LOGI("quota (%d)", quota);
exceededQuota->newQuota = quota;
#endif
}
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewk_context_WKContext_get(ewkContext));
+ TIZEN_LOGI("ewkContext (%p)", ewkContext);
+ WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
WKDatabaseManagerDeleteAllDatabases(databaseManager);
return true;
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewk_context_WKContext_get(ewkContext));
+ WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
WKDatabaseManagerDeleteDatabasesForOrigin(databaseManager, originRef.get());
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("callback (%p)", callback);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->webDatabaseOriginsCallback = callback;
context->userData = userData;
- WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewk_context_WKContext_get(ewkContext));
+ WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
WKDatabaseManagerGetDatabaseOrigins(databaseManager, context, didGetWebDatabaseOrigins);
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
+ TIZEN_LOGI("path (%s)", path);
WKRetainPtr<WKStringRef> databasePath(AdoptWK, WKStringCreateWithUTF8CString(path));
- WKContextSetDatabaseDirectory(ewk_context_WKContext_get(ewkContext), databasePath.get());
+ WKContextSetDatabaseDirectory(ewkContext->wkContext(), databasePath.get());
return true;
#else
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("callback (%p)", callback);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->webDatabasePathCallback= callback;
context->userData = userData;
- WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewk_context_WKContext_get(ewkContext));
+ WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
WKDatabaseManagerGetDatabasePath(databaseManager, context, didGetWebDatabasePath);
return true;
#else
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewk_context_WKContext_get(ewkContext));
+ WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
WKDatabaseManagerGetQuotaForOrigin(databaseManager, context, didGetWebDatabaseQuota, originRef.get());
return true;
#if ENABLE(TIZEN_SQL_DATABASE)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- ewkContext->defaultDatabaseQuota = quota;
+ TIZEN_LOGI("quota (%d)", quota);
+ ewkContext->setDefaultDatabaseQuota(quota);
return true;
#else
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewk_context_WKContext_get(ewkContext));
+ WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
WKDatabaseManagerSetQuotaForOrigin(databaseManager, originRef.get(), quota);
return true;
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewk_context_WKContext_get(ewkContext));
+ WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
WKDatabaseManagerGetUsageForOrigin(databaseManager, context, didGetWebDatabaseUsage, originRef.get());
return true;
Eina_Bool ewk_context_web_indexed_database_delete_all(Ewk_Context* ewkContext)
{
#if ENABLE(TIZEN_INDEXED_DATABASE)
- EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
-
- DEFINE_STATIC_LOCAL(const String, fileMatchPattern, ("*"));
- DEFINE_STATIC_LOCAL(const String, indexedDatabaseDirectory, ("/opt/apps/com.samsung.browser/data/.webkit/indexedDatabases"));
-
- Vector<String> paths = WebCore::listDirectory(indexedDatabaseDirectory, fileMatchPattern);
- Vector<String>::const_iterator end = paths.end();
- for(Vector<String>::const_iterator it = paths.begin(); it != end; ++it){
- String path = *it;
-#if ENABLE(TIZEN_FILE_SYSTEM)
- WebCore::removeDirectory(path);
-#endif
- }
+ WKContextDeleteIndexedDatabaseAll(ewkContext->wkContext());
return true;
#else
#if ENABLE(TIZEN_WEB_STORAGE)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewk_context_WKContext_get(ewkContext));
+ TIZEN_LOGI("ewkContext (%p)", ewkContext);
+ WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
WKKeyValueStorageManagerDeleteAllEntries(storageManager);
return true;
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
WKRetainPtr<WKSecurityOriginRef> securityOriginRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewk_context_WKContext_get(ewkContext));
+ WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
WKKeyValueStorageManagerDeleteEntriesForOrigin(storageManager, securityOriginRef.get());
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("callback (%p)", callback);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->webStorageOriginsCallback = callback;
context->userData = userData;
- WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewk_context_WKContext_get(ewkContext));
+ WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
WKKeyValueStorageManagerGetKeyValueStorageOrigins(storageManager, context, didGetWebStorageOrigins);
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
+ TIZEN_LOGI("path (%s)", path);
WKRetainPtr<WKStringRef> webStoragePath(AdoptWK, WKStringCreateWithUTF8CString(path));
- WKContextSetLocalStorageDirectory(ewk_context_WKContext_get(ewkContext), webStoragePath.get());
+ WKContextSetLocalStorageDirectory(ewkContext->wkContext(), webStoragePath.get());
return true;
#else
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
+ TIZEN_LOGI("callback (%p)", callback);
Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
context->webStoragePathCallback= callback;
context->userData = userData;
- WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewk_context_WKContext_get(ewkContext));
+ WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
WKKeyValueStorageManagerGetKeyValueStoragePath(storageManager, context, didGetWebStoragePath);
return true;
#else
WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
- WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewk_context_WKContext_get(ewkContext));
+ WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
WKKeyValueStorageManagerGetKeyValueStorageUsageForOrigin(storageManager, context, didGetWebStorageUsage, originRef.get());
return true;
EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
WKRetainPtr<WKStringRef> soupDataDirectory(AdoptWK, WKStringCreateWithUTF8CString(path));
- WKContextSetSoupDataDirectory(ewk_context_WKContext_get(ewkContext), soupDataDirectory.get());
+ WKContextSetSoupDataDirectory(ewkContext->wkContext(), soupDataDirectory.get());
return true;
}
//#endif
-Eina_Bool ewk_context_cache_model_set(Ewk_Context* ewkContext, Ewk_Cache_Model model)
+COMPILE_ASSERT_MATCHING_ENUM(EWK_CACHE_MODEL_DOCUMENT_VIEWER, kWKCacheModelDocumentViewer);
+COMPILE_ASSERT_MATCHING_ENUM(EWK_CACHE_MODEL_DOCUMENT_BROWSER, kWKCacheModelDocumentBrowser);
+COMPILE_ASSERT_MATCHING_ENUM(EWK_CACHE_MODEL_PRIMARY_WEBBROWSER, kWKCacheModelPrimaryWebBrowser);
+
+Eina_Bool ewk_context_cache_model_set(Ewk_Context* ewkContext, Ewk_Cache_Model cacheModel)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- if (model == EWK_CACHE_MODEL_DOCUMENT_VIEWER)
- WKContextSetCacheModel(ewk_context_WKContext_get(ewkContext), kWKCacheModelDocumentViewer);
- else if (model == EWK_CACHE_MODEL_DOCUMENT_BROWSER)
- WKContextSetCacheModel(ewk_context_WKContext_get(ewkContext), kWKCacheModelDocumentBrowser);
- else
- WKContextSetCacheModel(ewk_context_WKContext_get(ewkContext), kWKCacheModelPrimaryWebBrowser);
+
+ ewkContext->setCacheModel(cacheModel);
return true;
}
Ewk_Cache_Model ewk_context_cache_model_get(Ewk_Context* ewkContext)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, EWK_CACHE_MODEL_DOCUMENT_VIEWER);
- WKCacheModel cacheModel = WKContextGetCacheModel(ewk_context_WKContext_get(ewkContext));
- if (cacheModel == kWKCacheModelDocumentViewer)
- return EWK_CACHE_MODEL_DOCUMENT_VIEWER;
- else if (cacheModel == kWKCacheModelDocumentBrowser)
- return EWK_CACHE_MODEL_DOCUMENT_BROWSER;
- else
- return EWK_CACHE_MODEL_PRIMARY_WEBBROWSER;
+ return ewkContext->cacheModel();
}
Eina_Bool ewk_context_cache_disabled_set(Ewk_Context* ewkContext, Eina_Bool cacheDisabled)
{
#if ENABLE(TIZEN_CACHE_CONTROL)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKContextSetCacheDisabled(ewk_context_WKContext_get(ewkContext), cacheDisabled);
+ WKContextSetCacheDisabled(ewkContext->wkContext(), cacheDisabled);
#endif
return true;
{
#if ENABLE(TIZEN_CACHE_CONTROL)
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- return WKContextGetCacheDisabled(ewk_context_WKContext_get(ewkContext));
+ return WKContextGetCacheDisabled(ewkContext->wkContext());
#else
return false;
#endif
EINA_SAFETY_ON_NULL_RETURN_VAL(context, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(certificateFile, false);
#if ENABLE(TIZEN_CERTIFICATE_HANDLING)
- eina_stringshare_replace(&context->certificateFile, certificateFile);
+ if (!context->setCertificateFile(certificateFile))
+ return true;
- if (!fileExists(WTF::String::fromUTF8(certificateFile)))
- LOG_ERROR("[Network] ewk_context_certificate_file_set certificateFile does not exist!\n");
+ if (fileExists(WTF::String::fromUTF8(certificateFile))) {
+ long long fileSize = -1;
+ getFileSize(WTF::String::fromUTF8(certificateFile), fileSize);
+ TIZEN_LOGE("[Network] ewk_context_certificate_file_set certificateFile fileSize [%lld]\n", fileSize);
+ } else
+ TIZEN_LOGE("[Network] ewk_context_certificate_file_set certificateFile does not exist!\n");
WKRetainPtr<WKStringRef> certificateFileRef(AdoptWK, WKStringCreateWithUTF8CString(certificateFile));
- WKContextSetCertificateFile(ewk_context_WKContext_get(context), certificateFileRef.get());
+ WKContextSetCertificateFile(context->wkContext(), certificateFileRef.get());
return true;
#else
UNUSED_PARAM(context);
{
EINA_SAFETY_ON_NULL_RETURN_VAL(context, 0);
#if ENABLE(TIZEN_CERTIFICATE_HANDLING)
- return context->certificateFile;
+ return context->certificateFile();
#else
UNUSED_PARAM(context);
return 0;
Eina_Bool ewk_context_cache_clear(Ewk_Context* ewkContext)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(ewk_context_WKContext_get(ewkContext));
- WKResourceCacheManagerClearCacheForAllOrigins(cacheManager, WKResourceCachesToClearAll);
-
- return true;
-}
-
-#if ENABLE(TIZEN_CACHE_DUMP_SYNC)
-/**
- * @internal
- * Request WebProcess to dump cache.
- *
- * This sends sync message to WebProcess to dump memory cache, that is, soup cache.
- *
- * @param context context object
- *
- * @return @c EINA_TRUE on success or @c EINA_FALSE on failure
- *
- * @note This can effect UIProcess's performance because it calls to sync IPC message eventually.
- */
-void ewk_context_cache_dump(Ewk_Context* ewkContext)
-{
- EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(ewk_context_WKContext_get(ewkContext));
- toImpl(cacheManager)->dumpCache();
-}
+ WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(ewkContext->wkContext());
+#if ENABLE(TIZEN_EWK_CONTEXT_CACHE_MANAGER_NULL_CHECK_WORKAROUND)
+ if (!cacheManager)
+ return false;
#endif
-
-Eina_Bool ewk_context_cookies_clear(Ewk_Context* ewkContext)
-{
- EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKCookieManagerRef cookieManager = WKContextGetCookieManager(ewk_context_WKContext_get(ewkContext));
- WKCookieManagerDeleteAllCookies(cookieManager);
-
- return true;
-}
-
-Eina_Bool ewk_context_cookies_policy_set(Ewk_Context* ewkContext, Ewk_Cookie_Policy cookiePolicy)
-{
- EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKCookieManagerRef cookieManager = WKContextGetCookieManager(ewk_context_WKContext_get(ewkContext));
- if (cookiePolicy == EWK_COOKIE_JAR_ACCEPT_ALWAYS)
- WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, kWKHTTPCookieAcceptPolicyAlways);
- else if (cookiePolicy == EWK_COOKIE_JAR_ACCEPT_NEVER)
- WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, kWKHTTPCookieAcceptPolicyNever);
- else
- WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain);
-
- return true;
-}
-
-static void getCookiesPolicy(WKHTTPCookieAcceptPolicy cookiePolicy, WKErrorRef error, void* context)
-{
- EINA_SAFETY_ON_NULL_RETURN(context);
- Ewk_Context_Callback_Context* callbackContext = static_cast<Ewk_Context_Callback_Context*>(context);
-
- Ewk_Cookie_Policy policy = EWK_COOKIE_JAR_ACCEPT_ALWAYS;
- switch (cookiePolicy) {
- case kWKHTTPCookieAcceptPolicyAlways:
- policy = EWK_COOKIE_JAR_ACCEPT_ALWAYS;
- break;
- case kWKHTTPCookieAcceptPolicyNever:
- policy = EWK_COOKIE_JAR_ACCEPT_NEVER;
- break;
- case kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain:
- default:
- policy = EWK_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
- break;
- }
-
- ASSERT(callbackContext->cookiesPolicyGetCallback);
- callbackContext->cookiesPolicyGetCallback(policy, callbackContext->userData);
-
- delete callbackContext;
-}
-
-Eina_Bool ewk_context_cookies_policy_get(Ewk_Context* ewkContext, Ewk_Cookies_Policy_Get_Callback callback, void* userData)
-{
- EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
-
- Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
- context->cookiesPolicyGetCallback = callback;
- context->userData = userData;
-
- WKCookieManagerRef cookieManager = WKContextGetCookieManager(ewk_context_WKContext_get(ewkContext));
- WKCookieManagerGetHTTPCookieAcceptPolicy(cookieManager, context, getCookiesPolicy);
+ WKResourceCacheManagerClearCacheForAllOrigins(cacheManager, WKResourceCachesToClearAll);
return true;
}
WKRetainPtr<WKStringRef> messageName(AdoptWK, WKStringCreateWithUTF8CString(name));
WKRetainPtr<WKStringRef> messageBody(AdoptWK, WKStringCreateWithUTF8CString(body));
- WKContextPostMessageToInjectedBundle(ewk_context_WKContext_get(ewkContext), messageName.get(), messageBody.get());
+ WKContextPostMessageToInjectedBundle(ewkContext->wkContext(), messageName.get(), messageBody.get());
}
void ewk_context_message_from_injected_bundle_callback_set(Ewk_Context* ewkContext, Ewk_Context_Message_From_Injected_Bundle_Callback callback, void* userData)
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- ewkContext->messageFromInjectedBundle.callback = callback;
- ewkContext->messageFromInjectedBundle.userData = userData;
-}
-
-void ewkContextDidReceiveMessageFromInjectedBundle(Ewk_Context* ewkContext, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData)
-{
- EINA_SAFETY_ON_NULL_RETURN(ewkContext);
-
- if (!ewkContext->messageFromInjectedBundle.callback)
- return;
-
- CString name = toImpl(messageName)->string().utf8();
- CString body;
- if (messageBody && WKStringGetTypeID() == WKGetTypeID(messageBody))
- body = toImpl(static_cast<WKStringRef>(messageBody))->string().utf8();
-
- if (returnData) {
- char* returnString = 0;
- ewkContext->messageFromInjectedBundle.callback(name.data(), body.data(), &returnString,
- ewkContext->messageFromInjectedBundle.userData);
- if (returnString) {
- *returnData = WKStringCreateWithUTF8CString(returnString);
- free(returnString);
- } else {
- *returnData = WKStringCreateWithUTF8CString("");
- }
- } else {
- ewkContext->messageFromInjectedBundle.callback(name.data(), body.data(), 0,
- ewkContext->messageFromInjectedBundle.userData);
- }
+ ewkContext->setMessageFromInjectedBundleCallback(callback, userData);
}
void ewk_context_did_start_download_callback_set(Ewk_Context* ewkContext, Ewk_Context_Did_Start_Download_Callback callback, void* userData)
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- ewkContext->didStartDownload.callback = callback;
- ewkContext->didStartDownload.userData = userData;
-}
-
-void ewkContextDidStartDownload(Ewk_Context* ewkContext, WKStringRef downloadURL)
-{
- EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- EINA_SAFETY_ON_NULL_RETURN(ewkContext->didStartDownload.callback);
-
- ewkContext->didStartDownload.callback(toImpl(downloadURL)->string().utf8().data(), ewkContext->didStartDownload.userData);
+ ewkContext->setDidStartDownloadCallback(callback, userData);
}
#if ENABLE(MEMORY_SAMPLER)
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
WKRetainPtr<WKDoubleRef> interval(AdoptWK, WKDoubleCreate(timerInterval));
- WKContextStartMemorySampler(ewk_context_WKContext_get(ewkContext), interval.get());
+ WKContextStartMemorySampler(ewkContext->wkContext(), interval.get());
}
void ewk_context_memory_sampler_stop(Ewk_Context* ewkContext)
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- WKContextStopMemorySampler(ewk_context_WKContext_get(ewkContext));
-}
-#endif
-
-#if ENABLE(TIZEN_CACHE_MEMORY_OPTIMIZATION)
-Eina_Bool ewk_context_decoded_data_clear_all(Ewk_Context* ewkContext)
-{
- EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
- WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(ewk_context_WKContext_get(ewkContext));
- WKResourceCacheManagerClearCacheForAllOrigins(cacheManager, WKResourceCachesToClearInDecodedDataOnly);
-
- return true;
+ WKContextStopMemorySampler(ewkContext->wkContext());
}
#endif
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
- WKContextSetAdditionalPluginsDirectory(ewk_context_WKContext_get(ewkContext), WKStringCreateWithUTF8CString(path));
+ WKRetainPtr<WKStringRef> pluginPath(AdoptWK, WKStringCreateWithUTF8CString(path));
+ WKContextSetAdditionalPluginsDirectory(ewkContext->wkContext(), pluginPath.get());
return true;
#else
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- WKContextRef contextRef = ewk_context_WKContext_get(ewkContext);
+ WKContextRef contextRef = ewkContext->wkContext();
toImpl(contextRef)->setMemorySavingMode(mode);
}
#endif
-#if ENABLE(TIZEN_WEBKIT2_CONTEXT_X_WINDOW)
-Ecore_X_Window ewk_context_x_window_get(Ewk_Context* ewkContext)
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+void ewk_context_form_password_data_clear(Ewk_Context* ewkContext)
{
- EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
- return ewkContext->xWindow;
+ EINA_SAFETY_ON_NULL_RETURN(ewkContext);
+ ewkContext->clearPasswordFormData();
}
-void ewk_context_x_window_set(Ewk_Context* ewkContext, Ecore_X_Window xWindow)
+void ewk_context_form_candidate_data_clear(Ewk_Context* ewkContext)
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
- WKContextRef contextRef = ewk_context_WKContext_get(ewkContext);
- toImpl(contextRef)->setXWindow(xWindow);
+ ewkContext->clearCandidateFormData();
}
#endif
-
#endif // #if OS(TIZEN)
-Eina_Bool ewk_context_uri_scheme_register(Ewk_Context* ewkContext, const char* scheme, Ewk_Url_Scheme_Request_Cb callback, void* userData)
-{
- return ewk_context_url_scheme_register(ewkContext, scheme, callback, userData);
-}
-
Eina_Bool ewk_context_url_scheme_register(Ewk_Context* ewkContext, const char* scheme, Ewk_Url_Scheme_Request_Cb callback, void* userData)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(scheme, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
- ewkContext->urlSchemeHandlers.set(String::fromUTF8(scheme), _Ewk_Url_Scheme_Handler(callback, userData));
- WKRetainPtr<WKStringRef> wkScheme(AdoptWK, WKStringCreateWithUTF8CString(scheme));
- WKSoupRequestManagerRegisterURIScheme(ewkContext->requestManager.get(), wkScheme.get());
+ ewkContext->requestManager()->registerURLSchemeHandler(String::fromUTF8(scheme), callback, userData);
return true;
}
{
EINA_SAFETY_ON_NULL_RETURN(ewkContext);
+ TIZEN_LOGI("vibrate (%p)", vibrate);
#if ENABLE(VIBRATION)
- ewkContext->vibrationProvider->setVibrationClientCallbacks(vibrate, cancel, data);
+ ewkContext->vibrationProvider()->setVibrationClientCallbacks(vibrate, cancel, data);
#endif
}
+
+Eina_Bool ewk_context_tizen_extensible_api_set(Ewk_Context* ewkContext, Ewk_Extensible_API extensibleAPI, Eina_Bool enable)
+{
+#if ENABLE(TIZEN_EXTENSIBLE_API)
+ EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
+
+ TIZEN_LOGI("extensibleAPI (%d) enable (%d)", extensibleAPI, enable);
+ WKContextSetTizenExtensibleAPI(ewkContext->wkContext(), static_cast<WKTizenExtensibleAPI>(extensibleAPI), enable);
+
+ return true;
+#else
+ UNUSED_PARAM(ewkContext);
+ UNUSED_PARAM(extensibleAPI);
+ UNUSED_PARAM(enable);
+
+ return false;
+#endif
+}
+
+void ewk_context_storage_path_reset(Ewk_Context* ewkContext)
+{
+#if ENABLE(TIZEN_RESET_PATH)
+ EINA_SAFETY_ON_NULL_RETURN(ewkContext);
+
+ TIZEN_LOGI("ewkContext (%p)", ewkContext);
+ WKContextResetStoragePath(ewkContext->wkContext());
+#else
+ UNUSED_PARAM(ewkContext);
+#endif
+}
+
+void ewk_context_history_callbacks_set(Ewk_Context* ewkContext, Ewk_History_Navigation_Cb navigate, Ewk_History_Client_Redirection_Cb clientRedirect, Ewk_History_Server_Redirection_Cb serverRedirect, Ewk_History_Title_Update_Cb titleUpdate, Ewk_History_Populate_Visited_Links_Cb populateVisitedLinks, void* data)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ewkContext);
+
+ ewkContext->historyClient()->setCallbacks(navigate, clientRedirect, serverRedirect, titleUpdate, populateVisitedLinks, data);
+}
+
+void ewk_context_visited_link_add(Ewk_Context* ewkContext, const char* visitedURL)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ewkContext);
+ EINA_SAFETY_ON_NULL_RETURN(visitedURL);
+
+ ewkContext->addVisitedLink(visitedURL);
+}
projects / framework / web / webkit-efl.git / blobdiff