Source/WebKit2/UIProcess/API/efl/ewk_context.cpp

   1 /*
   2  * Copyright (C) 2012 Samsung Electronics
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this program; see the file COPYING.LIB.  If not, write to
  16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  *
  19  */
  20
  21 #include "config.h"
  22 #include "ewk_context.h"
  23
  24 #include "BatteryProvider.h"
  25 #include "ContextHistoryClientEfl.h"
  26 #include "NetworkInfoProvider.h"
  27 #include "RequestManagerClientEfl.h"
  28 #include "VibrationProvider.h"
  29 #include "WKAPICast.h"
  30 #include "WKContextSoup.h"
  31 #include "WKRetainPtr.h"
  32 #include "WKString.h"
  33 #include "WebContext.h"
  34 #include "WebSoupRequestManagerProxy.h"
  35 #include "ewk_context_private.h"
  36 #include "ewk_cookie_manager_private.h"
  37 #include "ewk_favicon_database_private.h"
  38 #include "ewk_url_scheme_request_private.h"
  39 #include <WebCore/FileSystem.h>
  40 #include <WebCore/IconDatabase.h>
  41 #include <wtf/HashMap.h>
  42 #include <wtf/text/WTFString.h>
  43
  44 #if OS(TIZEN)
  45 #include "WKApplicationCacheManager.h"
  46 #include "WKArray.h"
  47 #include "WKContext.h"
  48 #include "WKContextPrivate.h"
  49 #include "WKContextTizen.h"
  50 #include "WKDatabaseManager.h"
  51 #include "WKIconDatabase.h"
  52 #include "WKIconDatabaseTizen.h"
  53 #include "WKKeyValueStorageManager.h"
  54 #if ENABLE(TIZEN_FILE_SYSTEM)
  55 #include "WKLocalFileSystemManager.h"
  56 #endif
  57 #include "WKNumber.h"
  58 #include "WKSecurityOrigin.h"
  59 #include "WKURL.h"
  60 #include "ewk_context_injected_bundle_client.h"
  61 #include "ewk_security_origin.h"
  62 #include "ewk_private.h"
  63 #include <Eina.h>
  64
  65 #if ENABLE(TIZEN_WRT_LAUNCHING_PERFORMANCE)
  66 #include "ProcessLauncher.h"
  67 #include <stdlib.h>
  68 #endif
  69
  70 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
  71 #include "FormDatabase.h"
  72 #include "WKDictionary.h"
  73 #endif
  74 #endif // #if OS(TIZEN)
  75 #if ENABLE(SPELLCHECK)
  76 #include "ewk_settings.h"
  77 #include "ewk_text_checker_private.h"
  78 #endif
  79
  80 #if ENABLE(TIZEN_WEBKIT2_DDK_CHECK)
  81 #include <EGL/egl.h>
  82 #endif
  83
  84 #if ENABLE(TIZEN_HW_MORE_BACK_KEY)
  85 #include <dlfcn.h>
  86 void* EflAssistHandle = 0;
  87 #endif
  88
  89 using namespace WebCore;
  90 using namespace WebKit;
  91
  92 typedef HashMap<WKContextRef, Ewk_Context*> ContextMap;
  93
  94 static inline ContextMap& contextMap()
  95 {
  96     DEFINE_STATIC_LOCAL(ContextMap, map, ());
  97     return map;
  98 }
  99
 100 Ewk_Context::Ewk_Context(WKContextRef context)
 101     : m_context(context)
 102     , m_historyClient(ContextHistoryClientEfl::create(context))
 103 {
 104     ContextMap::AddResult result = contextMap().add(context, this);
 105     ASSERT_UNUSED(result, result.isNewEntry);
 106
 107 #if ENABLE(BATTERY_STATUS)
 108     m_batteryProvider = BatteryProvider::create(context);
 109 #endif
 110
 111 #if ENABLE(NETWORK_INFO)
 112     m_networkInfoProvider = NetworkInfoProvider::create(context);
 113 #endif
 114
 115 #if ENABLE(VIBRATION)
 116     m_vibrationProvider = VibrationProvider::create(context);
 117 #endif
 118
 119 #if ENABLE(MEMORY_SAMPLER)
 120     static bool initializeMemorySampler = false;
 121     static const char environmentVariable[] = "SAMPLE_MEMORY";
 122
 123     if (!initializeMemorySampler && getenv(environmentVariable)) {
 124         WKRetainPtr<WKDoubleRef> interval(AdoptWK, WKDoubleCreate(0.0));
 125         WKContextStartMemorySampler(context, interval.get());
 126         initializeMemorySampler = true;
 127     }
 128 #endif
 129
 130 #if ENABLE(SPELLCHECK)
 131     Ewk_Text_Checker::initialize();
 132     if (ewk_settings_continuous_spell_checking_enabled_get()) {
 133         // Load the default language.
 134         ewk_settings_spell_checking_languages_set(0);
 135     }
 136 #endif
 137
 138     // Initialize WKContext clients.
 139     m_downloadManager = DownloadManagerEfl::create(this);
 140     m_requestManagerClient = RequestManagerClientEfl::create(this);
 141
 142 #if OS(TIZEN)
 143 #if ENABLE(TIZEN_SQL_DATABASE)
 144     m_defaultDatabaseQuota = 5 * 1024 * 1024;
 145 #endif
 146     m_messageFromInjectedBundle.callback = 0;
 147     m_messageFromInjectedBundle.userData = 0;
 148     m_didStartDownload.callback = 0;
 149     m_didStartDownload.userData = 0;
 150 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 151     m_formDatabase = FormDatabase::create();
 152     m_formDatabase->open(FormDatabase::defaultDatabaseDirectoryPath(), FormDatabase::defaultDatabaseFilename());
 153 #endif
 154 #endif
 155
 156 #if ENABLE(TIZEN_HW_MORE_BACK_KEY)
 157     if (!EflAssistHandle)
 158         EflAssistHandle = dlopen("/usr/lib/libefl-assist.so.0", RTLD_LAZY);
 159 #endif
 160 }
 161
 162 Ewk_Context::~Ewk_Context()
 163 {
 164     ASSERT(contextMap().get(m_context.get()) == this);
 165     contextMap().remove(m_context.get());
 166 #if ENABLE(TIZEN_CACHE_DUMP_SYNC)
 167     dumpCache();
 168 #endif
 169 }
 170
 171 PassRefPtr<Ewk_Context> Ewk_Context::create(WKContextRef context)
 172 {
 173     if (contextMap().contains(context))
 174         return contextMap().get(context); // Will be ref-ed automatically.
 175
 176     return adoptRef(new Ewk_Context(context));
 177 }
 178
 179 PassRefPtr<Ewk_Context> Ewk_Context::create()
 180 {
 181     return create(adoptWK(WKContextCreate()).get());
 182 }
 183
 184 PassRefPtr<Ewk_Context> Ewk_Context::create(const String& injectedBundlePath)
 185 {
 186     if (!fileExists(injectedBundlePath))
 187         return 0;
 188
 189     WKRetainPtr<WKStringRef> injectedBundlePathWK = adoptWK(toCopiedAPI(injectedBundlePath));
 190     WKRetainPtr<WKContextRef> contextWK = adoptWK(WKContextCreateWithInjectedBundlePath(injectedBundlePathWK.get()));
 191
 192     return create(contextWK.get());
 193 }
 194
 195 PassRefPtr<Ewk_Context> Ewk_Context::defaultContext()
 196 {
 197     static RefPtr<Ewk_Context> defaultInstance = create(adoptWK(WKContextCreate()).get());
 198
 199     return defaultInstance;
 200 }
 201
 202 Ewk_Cookie_Manager* Ewk_Context::cookieManager()
 203 {
 204     if (!m_cookieManager)
 205         m_cookieManager = Ewk_Cookie_Manager::create(WKContextGetCookieManager(m_context.get()));
 206
 207     return m_cookieManager.get();
 208 }
 209
 210 Ewk_Favicon_Database* Ewk_Context::faviconDatabase()
 211 {
 212 #if ENABLE(TIZEN_ICON_DATABASE)
 213     return 0;
 214 #endif
 215     if (!m_faviconDatabase) {
 216         WKRetainPtr<WKIconDatabaseRef> iconDatabase = WKContextGetIconDatabase(m_context.get());
 217         // Set the database path if it is not open yet.
 218         if (!toImpl(iconDatabase.get())->isOpen()) {
 219             WebContext* webContext = toImpl(m_context.get());
 220             String databasePath = webContext->iconDatabasePath() + "/" + WebCore::IconDatabase::defaultDatabaseFilename();
 221             webContext->setIconDatabasePath(databasePath);
 222         }
 223         m_faviconDatabase = Ewk_Favicon_Database::create(iconDatabase.get());
 224     }
 225
 226     return m_faviconDatabase.get();
 227 }
 228
 229 RequestManagerClientEfl* Ewk_Context::requestManager()
 230 {
 231     return m_requestManagerClient.get();
 232 }
 233
 234 #if ENABLE(VIBRATION)
 235 PassRefPtr<VibrationProvider> Ewk_Context::vibrationProvider()
 236 {
 237     return m_vibrationProvider;
 238 }
 239 #endif
 240
 241 void Ewk_Context::addVisitedLink(const String& visitedURL)
 242 {
 243     toImpl(m_context.get())->addVisitedLink(visitedURL);
 244 }
 245
 246 void Ewk_Context::setCacheModel(Ewk_Cache_Model cacheModel)
 247 {
 248     WKContextSetCacheModel(m_context.get(), static_cast<Ewk_Cache_Model>(cacheModel));
 249 }
 250
 251 Ewk_Cache_Model Ewk_Context::cacheModel() const
 252 {
 253     return static_cast<Ewk_Cache_Model>(WKContextGetCacheModel(m_context.get()));
 254 }
 255
 256 Ewk_Context* ewk_context_ref(Ewk_Context* ewkContext)
 257 {
 258     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
 259
 260     ewkContext->ref();
 261
 262     return ewkContext;
 263 }
 264
 265 void ewk_context_unref(Ewk_Context* ewkContext)
 266 {
 267     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
 268
 269     ewkContext->deref();
 270 }
 271
 272 Ewk_Cookie_Manager* ewk_context_cookie_manager_get(const Ewk_Context* ewkContext)
 273 {
 274     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
 275
 276     return const_cast<Ewk_Context*>(ewkContext)->cookieManager();
 277 }
 278
 279 Ewk_Favicon_Database* ewk_context_favicon_database_get(const Ewk_Context* ewkContext)
 280 {
 281     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
 282
 283     return const_cast<Ewk_Context*>(ewkContext)->faviconDatabase();
 284 }
 285
 286 WKContextRef Ewk_Context::wkContext()
 287 {
 288     return m_context.get();
 289 }
 290
 291 DownloadManagerEfl* Ewk_Context::downloadManager() const
 292 {
 293     return m_downloadManager.get();
 294 }
 295
 296 ContextHistoryClientEfl* Ewk_Context::historyClient()
 297 {
 298     return m_historyClient.get();
 299 }
 300
 301 #if OS(TIZEN)
 302 bool Ewk_Context::setProxyAddress(const char* proxyAddress)
 303 {
 304     if (m_proxyAddress == proxyAddress)
 305         return false;
 306
 307     m_proxyAddress = proxyAddress;
 308     return true;
 309 }
 310
 311 #if ENABLE(TIZEN_CERTIFICATE_HANDLING)
 312 bool Ewk_Context::setCertificateFile(const char* certificateFile)
 313 {
 314     if (m_certificateFile == certificateFile)
 315         return false;
 316
 317     m_certificateFile = certificateFile;
 318     return true;
 319 }
 320 #endif
 321
 322 void Ewk_Context::setDefaultDatabaseQuota(uint64_t defaultDatabaseQuota)
 323 {
 324     m_defaultDatabaseQuota = defaultDatabaseQuota;
 325 }
 326
 327 void Ewk_Context::setMessageFromInjectedBundleCallback(Ewk_Context_Message_From_Injected_Bundle_Callback callback, void* userData)
 328 {
 329     m_messageFromInjectedBundle.callback = callback;
 330     m_messageFromInjectedBundle.userData = userData;
 331 }
 332
 333 void Ewk_Context::didReceiveMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData)
 334 {
 335     if (!m_messageFromInjectedBundle.callback)
 336         return;
 337
 338     CString name = toImpl(messageName)->string().utf8();
 339     CString body;
 340     if (messageBody && WKStringGetTypeID() == WKGetTypeID(messageBody))
 341         body = toImpl(static_cast<WKStringRef>(messageBody))->string().utf8();
 342
 343     if (returnData) {
 344         char* returnString = 0;
 345         m_messageFromInjectedBundle.callback(name.data(), body.data(), &returnString,
 346                                                        m_messageFromInjectedBundle.userData);
 347         if (returnString) {
 348             *returnData = WKStringCreateWithUTF8CString(returnString);
 349             free(returnString);
 350         } else
 351             *returnData = WKStringCreateWithUTF8CString("");
 352     } else
 353         m_messageFromInjectedBundle.callback(name.data(), body.data(), 0, m_messageFromInjectedBundle.userData);
 354 }
 355
 356 void Ewk_Context::setDidStartDownloadCallback(Ewk_Context_Did_Start_Download_Callback callback, void* userData)
 357 {
 358     m_didStartDownload.callback = callback;
 359     m_didStartDownload.userData = userData;
 360 }
 361
 362 void Ewk_Context::didStartDownload(WKStringRef downloadURL)
 363 {
 364     EINA_SAFETY_ON_NULL_RETURN(m_didStartDownload.callback);
 365
 366     m_didStartDownload.callback(toImpl(downloadURL)->string().utf8().data(), m_didStartDownload.userData);
 367 }
 368
 369 #if ENABLE(TIZEN_CACHE_MEMORY_OPTIMIZATION)
 370 void Ewk_Context::clearAllDecodedData()
 371 {
 372     WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(wkContext());
 373     WKResourceCacheManagerClearCacheForAllOrigins(cacheManager, WKResourceCachesToClearInDecodedDataOnly);
 374 }
 375 #endif
 376
 377 #if ENABLE(TIZEN_WEBKIT2_CONTEXT_X_WINDOW)
 378 Ecore_X_Window Ewk_Context::xWindow()
 379 {
 380     return m_xWindow;
 381 }
 382
 383 void Ewk_Context::setXWindow(Ecore_X_Window xWindow)
 384 {
 385     toImpl(wkContext())->setXWindow(xWindow);
 386 }
 387 #endif
 388
 389 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
 390 void Ewk_Context::addFormData(const char* url, WKDictionaryRef& formData, bool isPasswordForm)
 391 {
 392     EINA_SAFETY_ON_NULL_RETURN(url);
 393     if (!m_formDatabase->isOpen())
 394         return;
 395
 396     Vector<std::pair<String, String> > formDataVector;
 397     WKRetainPtr<WKArrayRef> wkKeys(AdoptWK, WKDictionaryCopyKeys(formData));
 398     size_t numKeys = WKArrayGetSize(wkKeys.get());
 399     for (size_t i = 0; i < numKeys; ++i) {
 400         WKStringRef wkKey = static_cast<WKStringRef>(WKArrayGetItemAtIndex(wkKeys.get(), i));
 401         WKStringRef wkValue = static_cast<WKStringRef>(WKDictionaryGetItemForKey(formData, wkKey));
 402
 403         formDataVector.append(pair<String, String>(toImpl(wkKey)->string(), toImpl(wkValue)->string()));
 404     }
 405
 406     m_formDatabase->addFormDataForURL(String::fromUTF8(url), formDataVector, isPasswordForm);
 407 }
 408
 409 void Ewk_Context::passwordFormData(const char* url, Vector<std::pair<String, String> >& passwordFormData)
 410 {
 411     EINA_SAFETY_ON_NULL_RETURN(url);
 412     if (!m_formDatabase->isOpen())
 413         return;
 414     m_formDatabase->getPasswordFormDataForURL(String::fromUTF8(url), passwordFormData);
 415 }
 416
 417 void Ewk_Context::candidateFormData(const String& name, Vector<String>& candidates)
 418 {
 419     if (!m_formDatabase->isOpen())
 420         return;
 421     m_formDatabase->getCandidateFormDataForName(name, candidates);
 422 }
 423
 424 void Ewk_Context::clearPasswordFormData()
 425 {
 426     m_formDatabase->clearPasswordFormData();
 427 }
 428
 429 void Ewk_Context::clearCandidateFormData()
 430 {
 431     m_formDatabase->clearCandidateFormData();
 432 }
 433
 434 #endif
 435
 436 #if ENABLE(TIZEN_CACHE_DUMP_SYNC)
 437 /**
 438  * @internal
 439  * Request WebProcess to dump cache.
 440  *
 441  * This sends sync message to WebProcess to dump memory cache, that is, soup cache.
 442  *
 443  * @param context context object
 444  *
 445  * @return @c EINA_TRUE on success or @c EINA_FALSE on failure
 446  *
 447  * @note This can effect UIProcess's performance because it calls to sync IPC message eventually.
 448  */
 449 void Ewk_Context::dumpCache()
 450 {
 451     WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(wkContext());
 452     toImpl(cacheManager)->dumpCache();
 453 }
 454 #endif
 455 #endif
 456
 457 Ewk_Context* ewk_context_default_get()
 458 {
 459     return Ewk_Context::defaultContext().get();
 460 }
 461
 462 #if OS(TIZEN)
 463 typedef struct Ewk_Context_Callback_Context
 464 {
 465     union {
 466 #if ENABLE(TIZEN_FILE_SYSTEM)
 467         Ewk_Local_File_System_Origins_Get_Callback localFileSystemOriginsCallback;
 468 #endif
 469         Ewk_Web_Application_Cache_Origins_Get_Callback webApplicationCacheOriginsCallback;
 470         Ewk_Web_Application_Cache_Quota_Get_Callback webApplicationCacheQuotaCallback;
 471         Ewk_Web_Application_Cache_Usage_For_Origin_Get_Callback webApplicationCacheUsageForOriginCallback;
 472         Ewk_Web_Application_Cache_Path_Get_Callback webApplicationCachePathCallback;
 473         Ewk_Web_Database_Origins_Get_Callback webDatabaseOriginsCallback;
 474         Ewk_Web_Database_Quota_Get_Callback webDatabaseQuotaCallback;
 475         Ewk_Web_Database_Usage_Get_Callback webDatabaseUsageCallback;
 476         Ewk_Web_Database_Path_Get_Callback webDatabasePathCallback;
 477         Ewk_Web_Storage_Origins_Get_Callback webStorageOriginsCallback;
 478         Ewk_Web_Storage_Usage_Get_Callback webStorageUsageCallback;
 479         Ewk_Web_Storage_Path_Get_Callback webStoragePathCallback;
 480     };
 481     void* userData;
 482 } Ewk_Context_Callback_Context;
 483
 484 #if ENABLE(TIZEN_SQL_DATABASE)
 485 struct Ewk_Context_Exceeded_Quota
 486 {
 487     Ewk_Security_Origin* origin;
 488     const char* databaseName;
 489     const char* displayName;
 490     unsigned long long currentQuota;
 491     unsigned long long currentOriginUsage;
 492     unsigned long long currentDatabaseUsage;
 493     unsigned long long expectedUsage;
 494     unsigned long long newQuota;
 495 };
 496 #endif
 497
 498 #if ENABLE(TIZEN_SQL_DATABASE)
 499 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)
 500 {
 501     Ewk_Context_Exceeded_Quota* exceededQuota = new Ewk_Context_Exceeded_Quota();
 502
 503     int length = WKStringGetMaximumUTF8CStringSize(databaseName);
 504     OwnArrayPtr<char> databaseNameBuffer = adoptArrayPtr(new char[length]);
 505     WKStringGetUTF8CString(databaseName, databaseNameBuffer.get(), length);
 506
 507     length = WKStringGetMaximumUTF8CStringSize(displayName);
 508     OwnArrayPtr<char> displayNameBuffer = adoptArrayPtr(new char[length]);
 509     WKStringGetUTF8CString(displayName, displayNameBuffer.get(), length);
 510
 511     exceededQuota->origin = createSecurityOrigin(origin);
 512     exceededQuota->databaseName = eina_stringshare_add(databaseNameBuffer.get());
 513     exceededQuota->displayName = eina_stringshare_add(displayNameBuffer.get());
 514     exceededQuota->currentQuota = currentQuota;
 515     exceededQuota->currentOriginUsage = currentOriginUsage;
 516     exceededQuota->currentDatabaseUsage = currentDatabaseUsage;
 517     exceededQuota->expectedUsage = expectedUsage;
 518
 519     return exceededQuota;
 520 }
 521
 522 void ewkContextDeleteExceededQuota(Ewk_Context_Exceeded_Quota* exceededQuota)
 523 {
 524     deleteSecurityOrigin(exceededQuota->origin);
 525     eina_stringshare_del(exceededQuota->databaseName);
 526     eina_stringshare_del(exceededQuota->displayName);
 527     delete exceededQuota;
 528 }
 529
 530 unsigned long long ewkContextGetNewQuotaForExceededQuota(Ewk_Context* ewkContext, Ewk_Context_Exceeded_Quota* exceededQuota)
 531 {
 532     if (exceededQuota->newQuota)
 533         return exceededQuota->newQuota + exceededQuota->currentQuota;
 534
 535     if (exceededQuota->currentQuota)
 536         return exceededQuota->currentQuota;
 537
 538     return ewkContext->defaultDatabaseQuota();
 539 }
 540
 541 uint64_t ewkContextGetDatabaseQuota(Ewk_Context* ewkContext)
 542 {
 543     return ewkContext->defaultDatabaseQuota();
 544 }
 545 #endif
 546
 547 /* public */
 548 Ewk_Context* ewk_context_new()
 549 {
 550 #if OS(TIZEN)
 551     Ewk_Context* ewk_context = Ewk_Context::create().leakRef();
 552     ewkContextInjectedBundleClientAttachClient(ewk_context);
 553     return ewk_context;
 554 #endif
 555     return Ewk_Context::create().leakRef();
 556 }
 557
 558 Ewk_Context* ewk_context_new_with_injected_bundle_path(const char* path)
 559 {
 560     EINA_SAFETY_ON_NULL_RETURN_VAL(path, 0);
 561
 562 #if ENABLE(TIZEN_WEBKIT2_DDK_CHECK)
 563     // FIXME : OpenGL check code for WRT before launching WebProcess.
 564     if(!eglGetDisplay(EGL_DEFAULT_DISPLAY)) {
 565         EINA_LOG_CRIT("Fail in initiziling view because No DDK is installed.");
 566         return 0;
 567     }
 568 #endif
 569
 570 #if ENABLE(TIZEN_WRT_LAUNCHING_PERFORMANCE)
 571     char* wrtLaunchingPerformance = getenv("WRT_LAUNCHING_PERFORMANCE");
 572     if (wrtLaunchingPerformance && !strcmp(wrtLaunchingPerformance, "1")) {
 573         static bool firstTime = true;
 574         if (firstTime) {
 575             firstTime = false;
 576
 577             if (ProcessLauncher::isInitialFork())
 578                 ProcessLauncher::setSkipExec(true);
 579             else
 580                 ProcessLauncher::setSkipExec(false);
 581
 582             ProcessLauncher::forkProcess();
 583
 584             if (ProcessLauncher::isParentProcess()) {
 585                 Ewk_Context* ewkContext = ewk_context_new_with_injected_bundle_path(path);
 586                 WKContextRef contextRef = ewkContext->wkContext();
 587                 toImpl(contextRef)->ensureWebProcess();
 588                 return ewkContext;
 589             }
 590             else if (ProcessLauncher::isChildProcess()) {
 591                 ProcessLauncher::callWebProcessMain();
 592                 exit(0);
 593             }
 594
 595             ASSERT_NOT_REACHED();
 596             return 0;
 597         }
 598     }
 599 #endif
 600
 601 #if OS(TIZEN)
 602     Ewk_Context* ewk_context = Ewk_Context::create(String::fromUTF8(path)).leakRef();
 603     ewkContextInjectedBundleClientAttachClient(ewk_context);
 604     return ewk_context;
 605 #endif
 606     return Ewk_Context::create(String::fromUTF8(path)).leakRef();
 607 }
 608
 609 void ewk_context_delete(Ewk_Context* ewkContext)
 610 {
 611     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
 612     if (ewkContext == ewk_context_default_get() && ewkContext->hasOneRef())
 613         return;
 614
 615     delete ewkContext;
 616 }
 617
 618 void ewk_context_proxy_uri_set(Ewk_Context* ewkContext, const char* proxy)
 619 {
 620     if (ewkContext && ewkContext->setProxyAddress(proxy)) {
 621         WKRetainPtr<WKURLRef> proxyAddress(AdoptWK, WKURLCreateWithUTF8CString(proxy));
 622
 623         WKContextRef contextRef = ewkContext->wkContext();
 624         toImpl(contextRef)->setProxy(toWTFString(proxyAddress.get()));
 625     }
 626 }
 627
 628 const char* ewk_context_proxy_uri_get(Ewk_Context* ewkContext)
 629 {
 630 #if ENABLE(TIZEN_WEBKIT2_PATCH_FOR_TC)
 631     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
 632 #endif
 633     return ewkContext->proxyAddress();
 634 }
 635
 636 void ewk_context_network_session_requests_cancel(Ewk_Context* ewkContext)
 637 {
 638     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
 639
 640     WKContextRef contextRef = ewkContext->wkContext();
 641     toImpl(contextRef)->abortSession();
 642 }
 643
 644 Eina_Bool ewk_context_notify_low_memory(Ewk_Context* ewkContext)
 645 {
 646     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 647
 648     WKContextRef contextRef = ewkContext->wkContext();
 649     toImpl(contextRef)->notifyLowMemory();
 650     return true;
 651 }
 652
 653 #if ENABLE(TIZEN_FILE_SYSTEM)
 654 static void didGetLocalFileSystemOrigins(WKArrayRef origins, WKErrorRef error, void* context)
 655 {
 656     Eina_List* originList = 0;
 657     for (size_t i = 0; i < WKArrayGetSize(origins); ++i) {
 658         WKSecurityOriginRef securityOriginRef = static_cast<WKSecurityOriginRef>(WKArrayGetItemAtIndex(origins, i));
 659         Ewk_Security_Origin* origin = createSecurityOrigin(securityOriginRef);
 660         originList = eina_list_append(originList, origin);
 661     }
 662
 663     Ewk_Context_Callback_Context* locaFileSystemContext = static_cast<Ewk_Context_Callback_Context*>(context);
 664     locaFileSystemContext->localFileSystemOriginsCallback(originList, locaFileSystemContext->userData);
 665     delete locaFileSystemContext;
 666 }
 667 #endif
 668
 669 #if ENABLE(TIZEN_APPLICATION_CACHE)
 670 static void didGetWebApplicationOrigins(WKArrayRef origins, WKErrorRef error, void* context)
 671 {
 672     TIZEN_LOGI("origin size(%d)", WKArrayGetSize(origins));
 673     Eina_List* originList = 0;
 674
 675     for(size_t i = 0; i < WKArrayGetSize(origins); i++) {
 676         WKSecurityOriginRef securityOriginRef = static_cast<WKSecurityOriginRef>(WKArrayGetItemAtIndex(origins, i));
 677         Ewk_Security_Origin* origin = createSecurityOrigin(securityOriginRef);
 678         originList = eina_list_append(originList, origin);
 679     }
 680
 681     Ewk_Context_Callback_Context* applicationCacheContext = static_cast<Ewk_Context_Callback_Context*>(context);
 682     applicationCacheContext->webApplicationCacheOriginsCallback(originList, applicationCacheContext->userData);
 683     delete applicationCacheContext;
 684 }
 685
 686 static void didGetWebApplicationPath(WKStringRef path, WKErrorRef error, void* context)
 687 {
 688     Ewk_Context_Callback_Context* applicationCacheContext = static_cast<Ewk_Context_Callback_Context*>(context);
 689
 690     int length = WKStringGetMaximumUTF8CStringSize(path);
 691     OwnArrayPtr<char> applicationCachePath = adoptArrayPtr(new char[length]);
 692     WKStringGetUTF8CString(path, applicationCachePath.get(), length);
 693
 694     TIZEN_LOGI("path (%s)", applicationCachePath.get());
 695     applicationCacheContext->webApplicationCachePathCallback(eina_stringshare_add(applicationCachePath.get()), applicationCacheContext->userData);
 696     delete applicationCacheContext;
 697 }
 698
 699 #if ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
 700 static void didGetWebApplicationQuota(WKInt64Ref quota, WKErrorRef error, void* context)
 701 {
 702     Ewk_Context_Callback_Context* applicationCacheContext = static_cast<Ewk_Context_Callback_Context*>(context);
 703     TIZEN_LOGI("quota (%d)", toImpl(quota)->value());
 704     applicationCacheContext->webApplicationCacheQuotaCallback(toImpl(quota)->value(), applicationCacheContext->userData);
 705     delete applicationCacheContext;
 706 }
 707
 708 static void didGetWebApplicationUsageForOrigin(WKInt64Ref usage, WKErrorRef error, void* context)
 709 {
 710     Ewk_Context_Callback_Context* applicationCacheContext = static_cast<Ewk_Context_Callback_Context*>(context);
 711     TIZEN_LOGI("usage (%d)", toImpl(usage)->value());
 712     applicationCacheContext->webApplicationCacheUsageForOriginCallback(toImpl(usage)->value(), applicationCacheContext->userData);
 713     delete applicationCacheContext;
 714 }
 715 #endif
 716 #endif
 717
 718 #if ENABLE(TIZEN_SQL_DATABASE)
 719 static void didGetWebDatabaseOrigins(WKArrayRef origins, WKErrorRef error, void* context)
 720 {
 721     TIZEN_LOGI("origin size(%d)", WKArrayGetSize(origins));
 722     Eina_List* originList = 0;
 723
 724     for(size_t i = 0; i < WKArrayGetSize(origins); i++) {
 725         WKSecurityOriginRef securityOriginRef = static_cast<WKSecurityOriginRef>(WKArrayGetItemAtIndex(origins, i));
 726         Ewk_Security_Origin* origin = createSecurityOrigin(securityOriginRef);
 727         originList = eina_list_append(originList, origin);
 728     }
 729
 730     Ewk_Context_Callback_Context* webDatabaseContext = static_cast<Ewk_Context_Callback_Context*>(context);
 731     webDatabaseContext->webDatabaseOriginsCallback(originList, webDatabaseContext->userData);
 732     delete webDatabaseContext;
 733 }
 734
 735 static void didGetWebDatabaseQuota(WKUInt64Ref quota, WKErrorRef error, void* context)
 736 {
 737     Ewk_Context_Callback_Context* webDatabaseContext = static_cast<Ewk_Context_Callback_Context*>(context);
 738     TIZEN_LOGI("quota (%d)", toImpl(quota)->value());
 739     webDatabaseContext->webDatabaseQuotaCallback(toImpl(quota)->value(), webDatabaseContext->userData);
 740     delete webDatabaseContext;
 741 }
 742
 743 static void didGetWebDatabaseUsage(WKUInt64Ref usage, WKErrorRef error, void* context)
 744 {
 745     Ewk_Context_Callback_Context* webDatabaseContext = static_cast<Ewk_Context_Callback_Context*>(context);
 746     TIZEN_LOGI("usage (%d)", toImpl(usage)->value());
 747     webDatabaseContext->webDatabaseUsageCallback(toImpl(usage)->value(), webDatabaseContext->userData);
 748     delete webDatabaseContext;
 749 }
 750
 751 static void didGetWebDatabasePath(WKStringRef path, WKErrorRef error, void * context)
 752 {
 753     Ewk_Context_Callback_Context* webDatabaseContext = static_cast<Ewk_Context_Callback_Context*>(context);
 754
 755     int length = WKStringGetMaximumUTF8CStringSize(path);
 756     OwnArrayPtr<char> databasePath = adoptArrayPtr(new char[length]);
 757     WKStringGetUTF8CString(path, databasePath.get(), length);
 758
 759     TIZEN_LOGI("path (%s)", databasePath.get());
 760     webDatabaseContext->webDatabasePathCallback(eina_stringshare_add(databasePath.get()), webDatabaseContext->userData);
 761     delete webDatabaseContext;
 762 }
 763 #endif
 764
 765 #if ENABLE(TIZEN_WEB_STORAGE)
 766 static void didGetWebStorageOrigins(WKArrayRef origins, WKErrorRef error, void* context)
 767 {
 768     TIZEN_LOGI("origin size(%d)", WKArrayGetSize(origins));
 769     Eina_List* originList = 0;
 770
 771     for(size_t i = 0; i < WKArrayGetSize(origins); i++) {
 772         WKSecurityOriginRef securityOriginRef = static_cast<WKSecurityOriginRef>(WKArrayGetItemAtIndex(origins, i));
 773         Ewk_Security_Origin* origin = createSecurityOrigin(securityOriginRef);
 774         originList = eina_list_append(originList, origin);
 775     }
 776
 777     Ewk_Context_Callback_Context* webStorageContext = static_cast<Ewk_Context_Callback_Context*>(context);
 778     webStorageContext->webStorageOriginsCallback(originList, webStorageContext->userData);
 779     delete webStorageContext;
 780 }
 781
 782 static void didGetWebStoragePath(WKStringRef path, WKErrorRef error, void * context)
 783 {
 784     Ewk_Context_Callback_Context* webStorageContext = static_cast<Ewk_Context_Callback_Context*>(context);
 785
 786     int length = WKStringGetMaximumUTF8CStringSize(path);
 787     OwnArrayPtr<char> storagePath = adoptArrayPtr(new char[length]);
 788     WKStringGetUTF8CString(path, storagePath.get(), length);
 789
 790     TIZEN_LOGI("path (%s)", storagePath.get());
 791     webStorageContext->webStoragePathCallback(eina_stringshare_add(storagePath.get()), webStorageContext->userData);
 792     delete webStorageContext;
 793 }
 794
 795 #if ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
 796 static void didGetWebStorageUsage(WKInt64Ref usage, WKErrorRef error, void* context)
 797 {
 798     Ewk_Context_Callback_Context* webStorageContext = static_cast<Ewk_Context_Callback_Context*>(context);
 799
 800     TIZEN_LOGI("usage (%s)", toImpl(usage)->value());
 801     webStorageContext->webStorageUsageCallback(toImpl(usage)->value(), webStorageContext->userData);
 802     delete webStorageContext;
 803 }
 804 #endif
 805
 806 #endif
 807
 808 Eina_Bool ewk_context_origins_free(Eina_List* originList)
 809 {
 810     EINA_SAFETY_ON_NULL_RETURN_VAL(originList, false);
 811
 812     void* currentOrigin;
 813     EINA_LIST_FREE(originList, currentOrigin) {
 814         Ewk_Security_Origin* origin = static_cast<Ewk_Security_Origin*>(currentOrigin);
 815         deleteSecurityOrigin(origin);
 816     }
 817
 818     return true;
 819 }
 820
 821 Eina_Bool ewk_context_application_cache_delete_all(Ewk_Context* ewkContext)
 822 {
 823 #if ENABLE(TIZEN_APPLICATION_CACHE)
 824     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 825
 826     TIZEN_LOGI("ewkContext (%p)", ewkContext);
 827     WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 828     WKApplicationCacheManagerDeleteAllEntries(applicationCache);
 829
 830     return true;
 831 #else
 832     return false;
 833 #endif
 834 }
 835
 836 Eina_Bool ewk_context_application_cache_delete(Ewk_Context* ewkContext, Ewk_Security_Origin* origin)
 837 {
 838 #if ENABLE(TIZEN_APPLICATION_CACHE)
 839     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 840     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
 841
 842     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
 843     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
 844     WKRetainPtr<WKSecurityOriginRef> securityOriginRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
 845     WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 846     WKApplicationCacheManagerDeleteEntriesForOrigin(applicationCacheRef, securityOriginRef.get());
 847
 848     return true;
 849 #else
 850     return false;
 851 #endif
 852 }
 853
 854 Eina_Bool ewk_context_application_cache_origins_get(Ewk_Context* ewkContext, Ewk_Web_Application_Cache_Origins_Get_Callback callback, void *userData)
 855 {
 856 #if ENABLE(TIZEN_APPLICATION_CACHE)
 857     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 858     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
 859
 860     TIZEN_LOGI("ewkContext (%p)", ewkContext);
 861     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
 862     context->webApplicationCacheOriginsCallback = callback;
 863     context->userData = userData;
 864
 865     WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 866     WKApplicationCacheManagerGetApplicationCacheOrigins(applicationCacheRef, context, didGetWebApplicationOrigins);
 867
 868     return true;
 869 #else
 870     return false;
 871 #endif
 872 }
 873
 874 Eina_Bool ewk_context_application_cache_path_set(Ewk_Context* ewkContext, const char* path)
 875 {
 876 #if ENABLE(TIZEN_APPLICATION_CACHE)
 877     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 878     EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
 879
 880     if (!path) {
 881         TIZEN_LOGE("Path value is invalid");
 882         return false;
 883     }
 884
 885     TIZEN_LOGI("path (%s)", path);
 886     WKRetainPtr<WKStringRef> applicationCachePathRef(AdoptWK, WKStringCreateWithUTF8CString(path));
 887     WKContextSetApplicationCacheDirectory(ewkContext->wkContext(), applicationCachePathRef.get());
 888
 889     return true;
 890 #else
 891     return false;
 892 #endif
 893 }
 894
 895 Eina_Bool ewk_context_application_cache_path_get(Ewk_Context* ewkContext, Ewk_Web_Application_Cache_Path_Get_Callback callback, void* userData)
 896 {
 897 #if ENABLE(TIZEN_APPLICATION_CACHE)
 898     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 899     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
 900
 901     TIZEN_LOGI("callback (%p)", callback);
 902     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
 903     context->webApplicationCachePathCallback= callback;
 904     context->userData = userData;
 905
 906     WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 907     WKApplicationCacheManagerGetApplicationCachePath(applicationCacheRef, context, didGetWebApplicationPath);
 908     return true;
 909 #else
 910     return false;
 911 #endif
 912 }
 913
 914 Eina_Bool ewk_context_application_cache_quota_get(Ewk_Context* ewkContext, Ewk_Web_Application_Cache_Quota_Get_Callback callback, void* userData)
 915 {
 916 #if ENABLE(TIZEN_APPLICATION_CACHE) && ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
 917     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 918     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
 919
 920     TIZEN_LOGI("callback (%p)", callback);
 921     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
 922     context->webApplicationCacheQuotaCallback = callback;
 923     context->userData = userData;
 924
 925     WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 926     WKApplicationCacheManagerGetApplicationCacheQuota(applicationCacheRef, context, didGetWebApplicationQuota);
 927
 928     return true;
 929 #else
 930     return false;
 931 #endif
 932 }
 933
 934 Eina_Bool ewk_context_application_cache_usage_for_origin_get(Ewk_Context* ewkContext, const Ewk_Security_Origin* origin, Ewk_Web_Application_Cache_Usage_For_Origin_Get_Callback callback, void* userData)
 935 {
 936 #if ENABLE(TIZEN_APPLICATION_CACHE) && ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
 937     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 938     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
 939     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
 940
 941     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
 942     context->webApplicationCacheUsageForOriginCallback = callback;
 943     context->userData = userData;
 944     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
 945     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
 946     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
 947
 948     WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 949     WKApplicationCacheManagerGetApplicationCacheUsageForOrigin(applicationCache, context, originRef.get(), didGetWebApplicationUsageForOrigin);
 950
 951     return true;
 952 #else
 953     return false;
 954 #endif
 955 }
 956
 957 Eina_Bool ewk_context_application_cache_quota_set(Ewk_Context* ewkContext, int64_t quota)
 958 {
 959 #if ENABLE(TIZEN_APPLICATION_CACHE)
 960     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 961     if (!quota) {
 962         TIZEN_LOGE("Quota value is invalid");
 963         return false;
 964     }
 965
 966     TIZEN_LOGI("quota (%d)", quota);
 967     WKApplicationCacheManagerRef applicationCacheRef = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 968     WKApplicationCacheManagerSetApplicationCacheQuota(applicationCacheRef, quota);
 969
 970     return true;
 971 #else
 972     return false;
 973 #endif
 974 }
 975
 976 Eina_Bool ewk_context_application_cache_quota_for_origin_set(Ewk_Context* ewkContext, const Ewk_Security_Origin* origin, int64_t quota)
 977 {
 978 #if ENABLE(TIZEN_APPLICATION_CACHE)
 979     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
 980     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
 981     if (!quota) {
 982         TIZEN_LOGE("Quota value is invalid");
 983         return false;
 984     }
 985
 986     TIZEN_LOGI("quota (%d)", quota);
 987     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
 988     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
 989     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
 990
 991     WKApplicationCacheManagerRef applicationCache = WKContextGetApplicationCacheManager(ewkContext->wkContext());
 992     WKApplicationCacheManagerSetApplicationCacheQuotaForOrigin(applicationCache, originRef.get(), quota);
 993
 994     return true;
 995 #else
 996     return false;
 997 #endif
 998 }
 999
1000
1001 Eina_Bool ewk_context_icon_database_path_set(Ewk_Context* ewkContext, const char* path)
1002 {
1003     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1004     EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
1005
1006     WKRetainPtr<WKStringRef> databasePath(AdoptWK, WKStringCreateWithUTF8CString(path));
1007     WKContextSetIconDatabasePath(ewkContext->wkContext(), databasePath.get());
1008
1009     return true;
1010 }
1011
1012 Evas_Object* ewk_context_icon_database_icon_object_add(Ewk_Context* ewkContext, const char* uri, Evas* canvas)
1013 {
1014     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, 0);
1015     EINA_SAFETY_ON_NULL_RETURN_VAL(uri, 0);
1016     EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);
1017
1018     WKIconDatabaseRef iconDatabase = WKContextGetIconDatabase(ewkContext->wkContext());
1019     WKRetainPtr<WKURLRef> urlString(AdoptWK, WKURLCreateWithUTF8CString(uri));
1020
1021     return WKIconDatabaseTryGetImageForURL(iconDatabase, canvas, urlString.get());
1022 }
1023
1024 void ewk_context_icon_database_delete_all(Ewk_Context* ewkContext)
1025 {
1026     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1027
1028     WKIconDatabaseRef iconDatabase = WKContextGetIconDatabase(ewkContext->wkContext());
1029     WKIconDatabaseRemoveAllIcons(iconDatabase);
1030 }
1031
1032 Eina_Bool ewk_context_local_file_system_path_set(Ewk_Context* ewkContext, const char* path)
1033 {
1034 #if ENABLE(TIZEN_FILE_SYSTEM)
1035     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1036     EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
1037
1038     TIZEN_LOGI("path (%s)", path);
1039     WKRetainPtr<WKStringRef> localFileSystemPathRef(AdoptWK, WKStringCreateWithUTF8CString(path));
1040     WKContextSetLocalFileSystemDirectory(ewkContext->wkContext(), localFileSystemPathRef.get());
1041
1042     return true;
1043 #else
1044     return false;
1045 #endif
1046 }
1047
1048 Eina_Bool ewk_context_local_file_system_all_delete(Ewk_Context* ewkContext)
1049 {
1050 #if ENABLE(TIZEN_FILE_SYSTEM)
1051     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1052
1053     TIZEN_LOGI("ewkContex (%p)", ewkContext);
1054     WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(ewkContext->wkContext());
1055     WKLocalFileSystemManagerDeleteAllLocalFileSystem(localFileSystemManager);
1056
1057     return true;
1058 #else
1059     UNUSED_PARAM(ewkContext);
1060
1061     return false;
1062 #endif
1063 }
1064
1065 Eina_Bool ewk_context_local_file_system_delete(Ewk_Context* ewkContext, Ewk_Security_Origin* origin)
1066 {
1067 #if ENABLE(TIZEN_FILE_SYSTEM)
1068     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1069     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
1070
1071     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
1072     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
1073     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
1074     WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(ewkContext->wkContext());
1075
1076     WKLocalFileSystemManagerDeleteLocalFileSystem(localFileSystemManager, originRef.get());
1077
1078     return true;
1079 #else
1080     UNUSED_PARAM(ewkContext);
1081     UNUSED_PARAM(origin);
1082
1083     return false;
1084 #endif
1085 }
1086
1087 Eina_Bool ewk_context_local_file_system_origins_get(const Ewk_Context* ewkContext, Ewk_Local_File_System_Origins_Get_Callback callback, void* userData)
1088 {
1089 #if ENABLE(TIZEN_FILE_SYSTEM)
1090     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1091     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1092
1093     TIZEN_LOGI("callback (%p)", callback);
1094     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1095     context->localFileSystemOriginsCallback= callback;
1096     context->userData = userData;
1097     WKLocalFileSystemManagerRef localFileSystemManager = WKContextGetLocalFileSystemManager(const_cast<Ewk_Context*>(ewkContext)->wkContext());
1098
1099     WKLocalFileSystemManagerGetLocalFileSystemOrigins(localFileSystemManager, context, didGetLocalFileSystemOrigins);
1100
1101     return true;
1102 #else
1103     UNUSED_PARAM(ewkContext);
1104     UNUSED_PARAM(callback);
1105     UNUSED_PARAM(userData);
1106
1107     return false;
1108 #endif
1109 }
1110
1111 Ewk_Security_Origin* ewk_context_web_database_exceeded_quota_security_origin_get(Ewk_Context_Exceeded_Quota* exceededQuota)
1112 {
1113 #if ENABLE(TIZEN_SQL_DATABASE)
1114     EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
1115
1116     return exceededQuota->origin;
1117 #else
1118     return 0;
1119 #endif
1120 }
1121
1122 const char* ewk_context_web_database_exceeded_quota_database_name_get(Ewk_Context_Exceeded_Quota* exceededQuota)
1123 {
1124 #if ENABLE(TIZEN_SQL_DATABASE)
1125     EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
1126
1127     TIZEN_LOGI("name (%s)", exceededQuota->databaseName);
1128     return exceededQuota->databaseName;
1129 #else
1130     return 0;
1131 #endif
1132 }
1133
1134 const char* ewk_context_web_database_exceeded_quota_display_name_get(Ewk_Context_Exceeded_Quota* exceededQuota)
1135 {
1136 #if ENABLE(TIZEN_SQL_DATABASE)
1137     EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
1138
1139     TIZEN_LOGI("displayName (%s)", exceededQuota->displayName);
1140     return exceededQuota->displayName;
1141 #else
1142     return 0;
1143 #endif
1144 }
1145
1146 unsigned long long ewk_context_web_database_exceeded_quota_current_quota_get(Ewk_Context_Exceeded_Quota* exceededQuota)
1147 {
1148 #if ENABLE(TIZEN_SQL_DATABASE)
1149     EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
1150
1151     TIZEN_LOGI("quota (%d)", exceededQuota->currentQuota);
1152     return exceededQuota->currentQuota;
1153 #else
1154     return 0;
1155 #endif
1156 }
1157
1158 unsigned long long ewk_context_web_database_exceeded_quota_current_origin_usage_get(Ewk_Context_Exceeded_Quota* exceededQuota)
1159 {
1160 #if ENABLE(TIZEN_SQL_DATABASE)
1161     EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
1162
1163     TIZEN_LOGI("currentOriginUsage (%d)", exceededQuota->currentOriginUsage);
1164     return exceededQuota->currentOriginUsage;
1165 #else
1166     return 0;
1167 #endif
1168 }
1169
1170 unsigned long long ewk_context_web_database_exceeded_quota_current_database_usage_get(Ewk_Context_Exceeded_Quota* exceededQuota)
1171 {
1172 #if ENABLE(TIZEN_SQL_DATABASE)
1173     EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
1174
1175     TIZEN_LOGI("currentDatabaseUsage (%d)", exceededQuota->currentDatabaseUsage);
1176     return exceededQuota->currentDatabaseUsage;
1177 #else
1178     return 0;
1179 #endif
1180 }
1181
1182 unsigned long long ewk_context_web_database_exceeded_quota_expected_usage_get(Ewk_Context_Exceeded_Quota* exceededQuota)
1183 {
1184 #if ENABLE(TIZEN_SQL_DATABASE)
1185     EINA_SAFETY_ON_NULL_RETURN_VAL(exceededQuota, 0);
1186
1187     TIZEN_LOGI("expectedUsage (%d)", exceededQuota->expectedUsage);
1188     return exceededQuota->expectedUsage;
1189 #else
1190     return 0;
1191 #endif
1192 }
1193
1194 void ewk_context_web_database_exceeded_quota_new_quota_set(Ewk_Context_Exceeded_Quota* exceededQuota, unsigned long long quota)
1195 {
1196 #if ENABLE(TIZEN_SQL_DATABASE)
1197     EINA_SAFETY_ON_NULL_RETURN(exceededQuota);
1198
1199     TIZEN_LOGI("quota (%d)", quota);
1200     exceededQuota->newQuota = quota;
1201 #endif
1202 }
1203
1204 Eina_Bool ewk_context_web_database_delete_all(Ewk_Context* ewkContext)
1205 {
1206 #if ENABLE(TIZEN_SQL_DATABASE)
1207     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1208
1209     TIZEN_LOGI("ewkContext (%p)", ewkContext);
1210     WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
1211     WKDatabaseManagerDeleteAllDatabases(databaseManager);
1212
1213     return true;
1214 #else
1215     return false;
1216 #endif
1217 }
1218
1219 Eina_Bool ewk_context_web_database_delete(Ewk_Context* ewkContext, Ewk_Security_Origin* origin)
1220 {
1221 #if ENABLE(TIZEN_SQL_DATABASE)
1222     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1223     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
1224
1225     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
1226     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
1227     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
1228     WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
1229     WKDatabaseManagerDeleteDatabasesForOrigin(databaseManager, originRef.get());
1230
1231     return true;
1232 #else
1233     return false;
1234 #endif
1235 }
1236
1237 Eina_Bool ewk_context_web_database_origins_get(Ewk_Context* ewkContext, Ewk_Web_Database_Origins_Get_Callback callback, void* userData)
1238 {
1239 #if ENABLE(TIZEN_SQL_DATABASE)
1240     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1241     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1242
1243     TIZEN_LOGI("callback (%p)", callback);
1244     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1245     context->webDatabaseOriginsCallback = callback;
1246     context->userData = userData;
1247
1248     WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
1249     WKDatabaseManagerGetDatabaseOrigins(databaseManager, context, didGetWebDatabaseOrigins);
1250
1251     return true;
1252 #else
1253     return false;
1254 #endif
1255 }
1256
1257 Eina_Bool ewk_context_web_database_path_set(Ewk_Context* ewkContext, const char* path)
1258 {
1259 #if ENABLE(TIZEN_SQL_DATABASE)
1260     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1261     EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
1262
1263     TIZEN_LOGI("path (%s)", path);
1264     WKRetainPtr<WKStringRef> databasePath(AdoptWK, WKStringCreateWithUTF8CString(path));
1265     WKContextSetDatabaseDirectory(ewkContext->wkContext(), databasePath.get());
1266
1267     return true;
1268 #else
1269     return false;
1270 #endif
1271 }
1272
1273 Eina_Bool ewk_context_web_database_path_get(Ewk_Context* ewkContext, Ewk_Web_Database_Path_Get_Callback callback, void* userData)
1274 {
1275 #if ENABLE(TIZEN_WEB_STORAGE)
1276     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1277     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1278
1279     TIZEN_LOGI("callback (%p)", callback);
1280     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1281     context->webDatabasePathCallback= callback;
1282     context->userData = userData;
1283
1284     WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
1285     WKDatabaseManagerGetDatabasePath(databaseManager, context, didGetWebDatabasePath);
1286     return true;
1287 #else
1288     return false;
1289 #endif
1290 }
1291 Eina_Bool ewk_context_web_database_quota_for_origin_get(Ewk_Context* ewkContext, Ewk_Web_Database_Quota_Get_Callback callback, void* userData, Ewk_Security_Origin* origin)
1292 {
1293 #if ENABLE(TIZEN_SQL_DATABASE)
1294     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1295     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1296     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
1297
1298     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1299     context->webDatabaseQuotaCallback = callback;
1300     context->userData = userData;
1301
1302     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
1303     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
1304     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
1305     WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
1306     WKDatabaseManagerGetQuotaForOrigin(databaseManager, context, didGetWebDatabaseQuota, originRef.get());
1307
1308     return true;
1309 #else
1310     return false;
1311 #endif
1312 }
1313
1314 Eina_Bool ewk_context_web_database_default_quota_set(Ewk_Context* ewkContext, uint64_t quota)
1315 {
1316 #if ENABLE(TIZEN_SQL_DATABASE)
1317     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1318
1319     TIZEN_LOGI("quota (%d)", quota);
1320     ewkContext->setDefaultDatabaseQuota(quota);
1321
1322     return true;
1323 #else
1324     return false;
1325 #endif
1326 }
1327
1328 Eina_Bool ewk_context_web_database_quota_for_origin_set(Ewk_Context* ewkContext, Ewk_Security_Origin* origin, uint64_t quota)
1329 {
1330 #if ENABLE(TIZEN_SQL_DATABASE)
1331     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1332     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
1333
1334     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
1335     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
1336     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
1337     WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
1338     WKDatabaseManagerSetQuotaForOrigin(databaseManager, originRef.get(), quota);
1339
1340     return true;
1341 #else
1342     return false;
1343 #endif
1344 }
1345
1346 Eina_Bool ewk_context_web_database_usage_for_origin_get(Ewk_Context* ewkContext, Ewk_Web_Database_Quota_Get_Callback callback, void* userData, Ewk_Security_Origin* origin)
1347 {
1348 #if ENABLE(TIZEN_SQL_DATABASE)
1349     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1350     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1351     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
1352
1353     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1354     context->webDatabaseQuotaCallback = callback;
1355     context->userData = userData;
1356
1357     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
1358     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
1359     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
1360     WKDatabaseManagerRef databaseManager = WKContextGetDatabaseManager(ewkContext->wkContext());
1361     WKDatabaseManagerGetUsageForOrigin(databaseManager, context, didGetWebDatabaseUsage, originRef.get());
1362
1363     return true;
1364 #else
1365     return false;
1366 #endif
1367 }
1368
1369 Eina_Bool ewk_context_web_indexed_database_delete_all(Ewk_Context* ewkContext)
1370 {
1371 #if ENABLE(TIZEN_INDEXED_DATABASE)
1372     WKContextDeleteIndexedDatabaseAll(ewkContext->wkContext());
1373
1374     return true;
1375 #else
1376     return false;
1377 #endif
1378 }
1379
1380 Eina_Bool ewk_context_web_storage_delete_all(Ewk_Context* ewkContext)
1381 {
1382 #if ENABLE(TIZEN_WEB_STORAGE)
1383     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1384
1385     TIZEN_LOGI("ewkContext (%p)", ewkContext);
1386     WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
1387     WKKeyValueStorageManagerDeleteAllEntries(storageManager);
1388
1389     return true;
1390 #else
1391     return false;
1392 #endif
1393 }
1394
1395 Eina_Bool ewk_context_web_storage_origin_delete(Ewk_Context* ewkContext, Ewk_Security_Origin* origin)
1396 {
1397 #if ENABLE(TIZEN_WEB_STORAGE)
1398     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1399     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
1400
1401     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
1402     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
1403     WKRetainPtr<WKSecurityOriginRef> securityOriginRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
1404     WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
1405     WKKeyValueStorageManagerDeleteEntriesForOrigin(storageManager, securityOriginRef.get());
1406
1407     return true;
1408 #else
1409     return false;
1410 #endif
1411 }
1412
1413 Eina_Bool ewk_context_web_storage_origins_get(Ewk_Context* ewkContext, Ewk_Web_Storage_Origins_Get_Callback callback, void* userData)
1414 {
1415 #if ENABLE(TIZEN_WEB_STORAGE)
1416     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1417     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1418
1419     TIZEN_LOGI("callback (%p)", callback);
1420     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1421     context->webStorageOriginsCallback = callback;
1422     context->userData = userData;
1423
1424     WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
1425     WKKeyValueStorageManagerGetKeyValueStorageOrigins(storageManager, context, didGetWebStorageOrigins);
1426
1427     return true;
1428 #else
1429     return false;
1430 #endif
1431 }
1432
1433 Eina_Bool ewk_context_web_storage_path_set(Ewk_Context* ewkContext, const char* path)
1434 {
1435 #if ENABLE(TIZEN_WEB_STORAGE)
1436     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1437     EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
1438
1439     TIZEN_LOGI("path (%s)", path);
1440     WKRetainPtr<WKStringRef> webStoragePath(AdoptWK, WKStringCreateWithUTF8CString(path));
1441     WKContextSetLocalStorageDirectory(ewkContext->wkContext(), webStoragePath.get());
1442
1443     return true;
1444 #else
1445     return false;
1446 #endif
1447 }
1448
1449 Eina_Bool ewk_context_web_storage_path_get(Ewk_Context* ewkContext, Ewk_Web_Storage_Path_Get_Callback callback, void* userData)
1450 {
1451 #if ENABLE(TIZEN_WEB_STORAGE)
1452     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1453     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1454
1455     TIZEN_LOGI("callback (%p)", callback);
1456     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1457     context->webStoragePathCallback= callback;
1458     context->userData = userData;
1459
1460     WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
1461     WKKeyValueStorageManagerGetKeyValueStoragePath(storageManager, context, didGetWebStoragePath);
1462     return true;
1463 #else
1464     return false;
1465 #endif
1466 }
1467 Eina_Bool ewk_context_web_storage_usage_for_origin_get(Ewk_Context* ewkContext, Ewk_Security_Origin* origin, Ewk_Web_Storage_Usage_Get_Callback callback, void* userData)
1468 {
1469 #if ENABLE(TIZEN_WEB_STORAGE) && ENABLE(TIZEN_WEBKIT2_NUMBER_TYPE_SUPPORT)
1470     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1471     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1472     EINA_SAFETY_ON_NULL_RETURN_VAL(origin, false);
1473
1474     Ewk_Context_Callback_Context* context = new Ewk_Context_Callback_Context;
1475     context->webStorageUsageCallback = callback;
1476     context->userData = userData;
1477     WKRetainPtr<WKStringRef> protocolRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_protocol_get(origin)));
1478     WKRetainPtr<WKStringRef> hostRef(AdoptWK, WKStringCreateWithUTF8CString(ewk_security_origin_host_get(origin)));
1479     WKRetainPtr<WKSecurityOriginRef> originRef(AdoptWK, WKSecurityOriginCreate(protocolRef.get(), hostRef.get(), ewk_security_origin_port_get(origin)));
1480
1481     WKKeyValueStorageManagerRef storageManager = WKContextGetKeyValueStorageManager(ewkContext->wkContext());
1482     WKKeyValueStorageManagerGetKeyValueStorageUsageForOrigin(storageManager, context, didGetWebStorageUsage, originRef.get());
1483
1484     return true;
1485 #else
1486     return false;
1487 #endif
1488 }
1489
1490 //#if ENABLE(TIZEN_SOUP_COOKIE_CACHE_FOR_WEBKIT2)
1491 Eina_Bool ewk_context_soup_data_directory_set(Ewk_Context* ewkContext, const char* path)
1492 {
1493     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1494     EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
1495
1496     WKRetainPtr<WKStringRef> soupDataDirectory(AdoptWK, WKStringCreateWithUTF8CString(path));
1497     WKContextSetSoupDataDirectory(ewkContext->wkContext(), soupDataDirectory.get());
1498     return true;
1499 }
1500 //#endif
1501
1502 COMPILE_ASSERT_MATCHING_ENUM(EWK_CACHE_MODEL_DOCUMENT_VIEWER, kWKCacheModelDocumentViewer);
1503 COMPILE_ASSERT_MATCHING_ENUM(EWK_CACHE_MODEL_DOCUMENT_BROWSER, kWKCacheModelDocumentBrowser);
1504 COMPILE_ASSERT_MATCHING_ENUM(EWK_CACHE_MODEL_PRIMARY_WEBBROWSER, kWKCacheModelPrimaryWebBrowser);
1505
1506 Eina_Bool ewk_context_cache_model_set(Ewk_Context* ewkContext, Ewk_Cache_Model cacheModel)
1507 {
1508     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1509
1510     ewkContext->setCacheModel(cacheModel);
1511
1512     return true;
1513 }
1514
1515 Ewk_Cache_Model ewk_context_cache_model_get(Ewk_Context* ewkContext)
1516 {
1517     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, EWK_CACHE_MODEL_DOCUMENT_VIEWER);
1518
1519     return ewkContext->cacheModel();
1520 }
1521
1522 Eina_Bool ewk_context_cache_disabled_set(Ewk_Context* ewkContext, Eina_Bool cacheDisabled)
1523 {
1524 #if ENABLE(TIZEN_CACHE_CONTROL)
1525     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1526     WKContextSetCacheDisabled(ewkContext->wkContext(), cacheDisabled);
1527 #endif
1528
1529     return true;
1530 }
1531
1532 Eina_Bool ewk_context_cache_disabled_get(Ewk_Context* ewkContext)
1533 {
1534 #if ENABLE(TIZEN_CACHE_CONTROL)
1535     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1536     return WKContextGetCacheDisabled(ewkContext->wkContext());
1537 #else
1538     return false;
1539 #endif
1540 }
1541
1542 Eina_Bool ewk_context_certificate_file_set(Ewk_Context* context, const char* certificateFile)
1543 {
1544     EINA_SAFETY_ON_NULL_RETURN_VAL(context, false);
1545     EINA_SAFETY_ON_NULL_RETURN_VAL(certificateFile, false);
1546 #if ENABLE(TIZEN_CERTIFICATE_HANDLING)
1547     if (!context->setCertificateFile(certificateFile))
1548         return true;
1549
1550     if (fileExists(WTF::String::fromUTF8(certificateFile))) {
1551         long long fileSize = -1;
1552         getFileSize(WTF::String::fromUTF8(certificateFile), fileSize);
1553         TIZEN_LOGE("[Network] ewk_context_certificate_file_set certificateFile fileSize [%lld]\n", fileSize);
1554     } else
1555         TIZEN_LOGE("[Network] ewk_context_certificate_file_set certificateFile does not exist!\n");
1556
1557     WKRetainPtr<WKStringRef> certificateFileRef(AdoptWK, WKStringCreateWithUTF8CString(certificateFile));
1558     WKContextSetCertificateFile(context->wkContext(), certificateFileRef.get());
1559     return true;
1560 #else
1561     UNUSED_PARAM(context);
1562     UNUSED_PARAM(certificateFile);
1563     return false;
1564 #endif
1565 }
1566
1567 const char* ewk_context_certificate_file_get(const Ewk_Context* context)
1568 {
1569     EINA_SAFETY_ON_NULL_RETURN_VAL(context, 0);
1570 #if ENABLE(TIZEN_CERTIFICATE_HANDLING)
1571     return context->certificateFile();
1572 #else
1573     UNUSED_PARAM(context);
1574     return 0;
1575 #endif
1576 }
1577
1578 Eina_Bool ewk_context_cache_clear(Ewk_Context* ewkContext)
1579 {
1580     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1581     WKResourceCacheManagerRef cacheManager = WKContextGetResourceCacheManager(ewkContext->wkContext());
1582 #if ENABLE(TIZEN_EWK_CONTEXT_CACHE_MANAGER_NULL_CHECK_WORKAROUND)
1583     if (!cacheManager)
1584         return false;
1585 #endif
1586     WKResourceCacheManagerClearCacheForAllOrigins(cacheManager, WKResourceCachesToClearAll);
1587
1588     return true;
1589 }
1590
1591 void ewk_context_message_post_to_injected_bundle(Ewk_Context* ewkContext, const char* name, const char* body)
1592 {
1593     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1594     EINA_SAFETY_ON_NULL_RETURN(name);
1595     EINA_SAFETY_ON_NULL_RETURN(body);
1596
1597     WKRetainPtr<WKStringRef> messageName(AdoptWK, WKStringCreateWithUTF8CString(name));
1598     WKRetainPtr<WKStringRef> messageBody(AdoptWK, WKStringCreateWithUTF8CString(body));
1599     WKContextPostMessageToInjectedBundle(ewkContext->wkContext(), messageName.get(), messageBody.get());
1600 }
1601
1602 void ewk_context_message_from_injected_bundle_callback_set(Ewk_Context* ewkContext, Ewk_Context_Message_From_Injected_Bundle_Callback callback, void* userData)
1603 {
1604     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1605
1606     ewkContext->setMessageFromInjectedBundleCallback(callback, userData);
1607 }
1608
1609 void ewk_context_did_start_download_callback_set(Ewk_Context* ewkContext, Ewk_Context_Did_Start_Download_Callback callback, void* userData)
1610 {
1611     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1612
1613     ewkContext->setDidStartDownloadCallback(callback, userData);
1614 }
1615
1616 #if ENABLE(MEMORY_SAMPLER)
1617 void ewk_context_memory_sampler_start(Ewk_Context* ewkContext, double timerInterval)
1618 {
1619     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1620     WKRetainPtr<WKDoubleRef> interval(AdoptWK, WKDoubleCreate(timerInterval));
1621     WKContextStartMemorySampler(ewkContext->wkContext(), interval.get());
1622 }
1623
1624 void ewk_context_memory_sampler_stop(Ewk_Context* ewkContext)
1625 {
1626     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1627     WKContextStopMemorySampler(ewkContext->wkContext());
1628 }
1629 #endif
1630
1631 Eina_Bool ewk_context_additional_plugin_path_set(Ewk_Context* ewkContext, const char* path)
1632 {
1633 #if ENABLE(TIZEN_SUPPORT_PLUGINS)
1634     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1635     EINA_SAFETY_ON_NULL_RETURN_VAL(path, false);
1636
1637     WKRetainPtr<WKStringRef> pluginPath(AdoptWK, WKStringCreateWithUTF8CString(path));
1638     WKContextSetAdditionalPluginsDirectory(ewkContext->wkContext(), pluginPath.get());
1639
1640     return true;
1641 #else
1642     return false;
1643 #endif
1644 }
1645
1646 #if ENABLE(TIZEN_WEBKIT2_MEMORY_SAVING_MODE)
1647 void ewk_context_memory_saving_mode_set(Ewk_Context* ewkContext, Eina_Bool mode)
1648 {
1649     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1650
1651     WKContextRef contextRef = ewkContext->wkContext();
1652     toImpl(contextRef)->setMemorySavingMode(mode);
1653 }
1654 #endif
1655
1656 #if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
1657 void ewk_context_form_password_data_clear(Ewk_Context* ewkContext)
1658 {
1659     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1660     ewkContext->clearPasswordFormData();
1661 }
1662
1663 void ewk_context_form_candidate_data_clear(Ewk_Context* ewkContext)
1664 {
1665     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1666     ewkContext->clearCandidateFormData();
1667 }
1668 #endif
1669 #endif // #if OS(TIZEN)
1670
1671 Eina_Bool ewk_context_url_scheme_register(Ewk_Context* ewkContext, const char* scheme, Ewk_Url_Scheme_Request_Cb callback, void* userData)
1672 {
1673     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1674     EINA_SAFETY_ON_NULL_RETURN_VAL(scheme, false);
1675     EINA_SAFETY_ON_NULL_RETURN_VAL(callback, false);
1676
1677     ewkContext->requestManager()->registerURLSchemeHandler(String::fromUTF8(scheme), callback, userData);
1678
1679     return true;
1680 }
1681
1682 void ewk_context_vibration_client_callbacks_set(Ewk_Context* ewkContext, Ewk_Vibration_Client_Vibrate_Cb vibrate, Ewk_Vibration_Client_Vibration_Cancel_Cb cancel, void* data)
1683 {
1684     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1685
1686     TIZEN_LOGI("vibrate (%p)", vibrate);
1687 #if ENABLE(VIBRATION)
1688     ewkContext->vibrationProvider()->setVibrationClientCallbacks(vibrate, cancel, data);
1689 #endif
1690 }
1691
1692 Eina_Bool ewk_context_tizen_extensible_api_set(Ewk_Context* ewkContext,  Ewk_Extensible_API extensibleAPI, Eina_Bool enable)
1693 {
1694 #if ENABLE(TIZEN_EXTENSIBLE_API)
1695     EINA_SAFETY_ON_NULL_RETURN_VAL(ewkContext, false);
1696
1697     TIZEN_LOGI("extensibleAPI (%d) enable (%d)", extensibleAPI, enable);
1698     WKContextSetTizenExtensibleAPI(ewkContext->wkContext(), static_cast<WKTizenExtensibleAPI>(extensibleAPI), enable);
1699
1700     return true;
1701 #else
1702     UNUSED_PARAM(ewkContext);
1703     UNUSED_PARAM(extensibleAPI);
1704     UNUSED_PARAM(enable);
1705
1706     return false;
1707 #endif
1708 }
1709
1710 void ewk_context_storage_path_reset(Ewk_Context* ewkContext)
1711 {
1712 #if ENABLE(TIZEN_RESET_PATH)
1713     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1714
1715     TIZEN_LOGI("ewkContext (%p)", ewkContext);
1716     WKContextResetStoragePath(ewkContext->wkContext());
1717 #else
1718     UNUSED_PARAM(ewkContext);
1719 #endif
1720 }
1721
1722 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)
1723 {
1724     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1725
1726     ewkContext->historyClient()->setCallbacks(navigate, clientRedirect, serverRedirect, titleUpdate, populateVisitedLinks, data);
1727 }
1728
1729 void ewk_context_visited_link_add(Ewk_Context* ewkContext, const char* visitedURL)
1730 {
1731     EINA_SAFETY_ON_NULL_RETURN(ewkContext);
1732     EINA_SAFETY_ON_NULL_RETURN(visitedURL);
1733
1734     ewkContext->addVisitedLink(visitedURL);
1735 }