src/controls/FWebCtrl_WebStorageManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FWebCtrl_WebStorageManagerImpl.cpp
  20  * @brief               The file contains the definition of _WebStorageManagerImpl class.
  21  */
  22 #include <EWebKit2.h>
  23 #include <FBaseColAllElementsDeleter.h>
  24 #include <FBaseColArrayList.h>
  25 #include <FBaseColIList.h>
  26 #include <FBaseSysLog.h>
  27 #include "FWebCtrl_Utility.h"
  28 #include "FWebCtrl_WebPresenter.h"
  29 #include "FWebCtrl_WebStorageManagerImpl.h"
  30
  31
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34
  35
  36 namespace Tizen { namespace Web { namespace Controls
  37 {
  38
  39
  40 void
  41 OnOriginReceived(Eina_List* pOrigins, void* pUserData)
  42 {
  43         _WebPresenter* pPresenter = reinterpret_cast< _WebPresenter* >(pUserData);
  44
  45         pPresenter->EndAsyncProcess(pOrigins);
  46 }
  47
  48
  49 void
  50 OnIntReceived(int64_t integer, void* pUserData)
  51 {
  52         _WebPresenter* pPresenter = reinterpret_cast< _WebPresenter* >(pUserData);
  53
  54         pPresenter->EndAsyncProcess((long)integer);
  55 }
  56
  57
  58 void
  59 OnUIntReceived(uint64_t integer, void* pUserData)
  60 {
  61         _WebPresenter* pPresenter = reinterpret_cast< _WebPresenter* >(pUserData);
  62
  63         pPresenter->EndAsyncProcess((long)integer);
  64 }
  65
  66
  67 _WebStorageManagerImpl::_WebStorageManagerImpl(void)
  68 {
  69 }
  70
  71
  72 _WebStorageManagerImpl::~_WebStorageManagerImpl(void)
  73 {
  74 }
  75
  76
  77 IList*
  78 _WebStorageManagerImpl::GetOriginListN(WebStorageType storageType)
  79 {
  80         result r = E_SUCCESS;
  81
  82         Ewk_Context* pDefaultContext = ewk_context_default_get();
  83         Eina_List* pOriginEinaList = null;
  84
  85         _WebPresenter presenter;
  86         presenter.InitAsyncProcess();
  87
  88         switch (storageType)
  89         {
  90         case WEB_STORAGE_TYPE_APPLICATION_CACHE:
  91                 ewk_context_application_cache_origins_get(pDefaultContext, OnOriginReceived, &presenter);
  92                 break;
  93
  94         case WEB_STORAGE_TYPE_WEB_SQL_DATABASE:
  95                 ewk_context_web_database_origins_get(pDefaultContext, OnOriginReceived, &presenter);
  96                 break;
  97
  98         case WEB_STORAGE_TYPE_WEB_STORAGE:
  99                 ewk_context_web_storage_origins_get(pDefaultContext, OnOriginReceived, &presenter);
 100                 break;
 101
 102         case WEB_STORAGE_TYPE_FILE_SYSTEM:
 103                 ewk_context_local_file_system_origins_get(pDefaultContext, OnOriginReceived, &presenter);
 104                 break;
 105
 106         default:
 107                 break;
 108         }
 109
 110         presenter.WaitAsyncProcess(pOriginEinaList);
 111
 112         if (eina_list_count(pOriginEinaList) == 0)
 113         {
 114                 return null;
 115         }
 116
 117         std::unique_ptr<ArrayList, AllElementsDeleter> pOriginList(new (std::nothrow) ArrayList());
 118         SysTryReturn(NID_WEB_CTRL, pOriginList.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 119
 120         r = pOriginList->Construct();
 121         SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 122
 123         for(; pOriginEinaList; pOriginEinaList = eina_list_next(pOriginEinaList))
 124         {
 125                 Ewk_Security_Origin* pOrigin = static_cast<Ewk_Security_Origin*>(eina_list_data_get(pOriginEinaList));
 126                 std::unique_ptr<String> pStringOrigin(new (std::nothrow) String(_Utility::CreateOrigin(pOrigin)));
 127                 SysTryReturn(NID_WEB_CTRL, pStringOrigin.get(), null, E_OUT_OF_MEMORY, "[%s] Memory Allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 128
 129                 r = pOriginList->Add(pStringOrigin.get());
 130                 SysTryReturn(NID_WEB_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 131                 pStringOrigin.release();
 132         }
 133
 134         return pOriginList.release();
 135 }
 136
 137
 138 result
 139 _WebStorageManagerImpl::SetQuotaForOrigin(WebStorageType storageType, const String& origin, long quota)
 140 {
 141         Ewk_Context* pDefaultContext = ewk_context_default_get();
 142         Ewk_Security_Origin* pOrigin = null;
 143
 144         switch (storageType)
 145         {
 146         case WEB_STORAGE_TYPE_APPLICATION_CACHE:
 147                 pOrigin = CompareOrigin(WEB_STORAGE_TYPE_APPLICATION_CACHE, origin);
 148                 SysTryReturnResult(NID_WEB_CTRL, pOrigin, E_INVALID_ARG, "This origin does not exist.");
 149
 150                 ewk_context_application_cache_quota_for_origin_set(pDefaultContext, pOrigin, quota);
 151                 break;
 152
 153         case WEB_STORAGE_TYPE_WEB_SQL_DATABASE:
 154                 pOrigin = CompareOrigin(WEB_STORAGE_TYPE_WEB_SQL_DATABASE, origin);
 155                 SysTryReturnResult(NID_WEB_CTRL, pOrigin, E_INVALID_ARG, "This origin does not exist.");
 156
 157                 ewk_context_web_database_quota_for_origin_set(pDefaultContext, pOrigin, quota);
 158                 break;
 159
 160         default:
 161                 SysLogException(NID_WEB_CTRL, E_UNSUPPORTED_TYPE, "This storage type %d is not supported.", storageType);
 162                 return E_UNSUPPORTED_TYPE;
 163         }
 164         return E_SUCCESS;
 165 }
 166
 167
 168 long
 169 _WebStorageManagerImpl::GetQuotaForOrigin(WebStorageType storageType, const String& origin)
 170 {
 171         Ewk_Context* pDefaultContext = ewk_context_default_get();
 172         long quota = 0;
 173
 174         SysTryReturn(NID_WEB_CTRL, storageType == WEB_STORAGE_TYPE_WEB_SQL_DATABASE, -1, E_UNSUPPORTED_TYPE, "[%s] This storage type is not supported.", GetErrorMessage(E_UNSUPPORTED_TYPE));
 175
 176         Ewk_Security_Origin* pOrigin = CompareOrigin(storageType, origin);
 177         SysTryReturn(NID_WEB_CTRL, pOrigin, -1, E_INVALID_ARG, "[%s] This origin does not exist.", GetErrorMessage(E_INVALID_ARG));
 178
 179         _WebPresenter presenter;
 180         presenter.InitAsyncProcess();
 181
 182         ewk_context_web_database_quota_for_origin_get(pDefaultContext, OnUIntReceived, &presenter, pOrigin);
 183
 184         presenter.WaitAsyncProcess(quota);
 185
 186         return quota;
 187 }
 188
 189
 190 long
 191 _WebStorageManagerImpl::GetUsageForOrigin(WebStorageType storageType, const String& origin)
 192 {
 193         Ewk_Context* pDefaultContext = ewk_context_default_get();
 194         long usage = 0;
 195
 196         SysTryReturn(NID_WEB_CTRL, (storageType != WEB_STORAGE_TYPE_INDEXED_DATABASE) && (storageType != WEB_STORAGE_TYPE_FILE_SYSTEM), -1, E_UNSUPPORTED_TYPE, "[%s] This storage type is not supported.", GetErrorMessage(E_UNSUPPORTED_TYPE));
 197
 198         Ewk_Security_Origin* pOrigin = CompareOrigin(storageType, origin);
 199         SysTryReturn(NID_WEB_CTRL, pOrigin, -1, E_INVALID_ARG, "[%s] This origin does not exist.", GetErrorMessage(E_INVALID_ARG));
 200
 201         _WebPresenter presenter;
 202         presenter.InitAsyncProcess();
 203
 204         switch (storageType)
 205         {
 206         case WEB_STORAGE_TYPE_APPLICATION_CACHE:
 207 //              ewk_context_application_cache_usage_for_origin_get(pDefaultContext, pOrigin, OnIntReceived, &presenter);
 208                 break;
 209
 210         case WEB_STORAGE_TYPE_WEB_SQL_DATABASE:
 211                 ewk_context_web_database_usage_for_origin_get(pDefaultContext, OnUIntReceived, &presenter, pOrigin);
 212                 break;
 213
 214         case WEB_STORAGE_TYPE_WEB_STORAGE :
 215                 ewk_context_web_storage_usage_for_origin_get(pDefaultContext, pOrigin, OnUIntReceived, &presenter);
 216                 break;
 217
 218         default:
 219                 break;
 220         }
 221
 222         presenter.WaitAsyncProcess(usage);
 223
 224         return usage;
 225 }
 226
 227
 228 result
 229 _WebStorageManagerImpl::Remove(WebStorageType storageType, const String& origin)
 230 {
 231         Ewk_Context* pDefaultContext = ewk_context_default_get();
 232
 233         SysTryReturnResult(NID_WEB_CTRL, storageType != WEB_STORAGE_TYPE_INDEXED_DATABASE, E_UNSUPPORTED_TYPE, "This storage type is not supported.");
 234
 235         Ewk_Security_Origin* pOrigin = CompareOrigin(storageType, origin);
 236         SysTryReturnResult(NID_WEB_CTRL, pOrigin, E_INVALID_ARG, "This origin does not exist.");
 237
 238         switch (storageType)
 239         {
 240         case WEB_STORAGE_TYPE_APPLICATION_CACHE:
 241                 ewk_context_application_cache_delete(pDefaultContext, pOrigin);
 242                 break;
 243
 244         case WEB_STORAGE_TYPE_WEB_SQL_DATABASE:
 245                 ewk_context_web_database_delete(pDefaultContext, pOrigin);
 246                 break;
 247
 248         case WEB_STORAGE_TYPE_WEB_STORAGE :
 249                 ewk_context_web_storage_origin_delete(pDefaultContext, pOrigin);
 250                 break;
 251
 252         case WEB_STORAGE_TYPE_FILE_SYSTEM:
 253                 ewk_context_local_file_system_delete(pDefaultContext, pOrigin);
 254                 break;
 255
 256         default:
 257                 break;
 258         }
 259
 260         return E_SUCCESS;
 261 }
 262
 263
 264 result
 265 _WebStorageManagerImpl::RemoveAll(WebStorageType storageType)
 266 {
 267         Ewk_Context* pDefaultContext = ewk_context_default_get();
 268
 269         switch (storageType)
 270         {
 271         case WEB_STORAGE_TYPE_APPLICATION_CACHE:
 272                 ewk_context_application_cache_delete_all(pDefaultContext);
 273                 break;
 274
 275         case WEB_STORAGE_TYPE_INDEXED_DATABASE :
 276                 ewk_context_web_indexed_database_delete_all(pDefaultContext);
 277                 break;
 278
 279         case WEB_STORAGE_TYPE_WEB_SQL_DATABASE:
 280                 ewk_context_web_database_delete_all(pDefaultContext);
 281                 break;
 282
 283         case WEB_STORAGE_TYPE_WEB_STORAGE :
 284                 ewk_context_web_storage_delete_all(pDefaultContext);
 285                 break;
 286
 287         case WEB_STORAGE_TYPE_FILE_SYSTEM:
 288                 ewk_context_local_file_system_all_delete(pDefaultContext);
 289                 break;
 290
 291         default:
 292                 break;
 293         }
 294
 295         return E_SUCCESS;
 296 }
 297
 298
 299 Ewk_Security_Origin*
 300 _WebStorageManagerImpl::CompareOrigin(WebStorageType storageType, const String& origin)
 301 {
 302         Ewk_Context* pDefaultContext = ewk_context_default_get();
 303         _WebPresenter presenter;
 304         Eina_List* pOriginList = null;
 305         presenter.InitAsyncProcess();
 306
 307         switch (storageType)
 308         {
 309         case WEB_STORAGE_TYPE_APPLICATION_CACHE:
 310                 ewk_context_application_cache_origins_get(pDefaultContext, OnOriginReceived, &presenter);
 311                 break;
 312
 313         case WEB_STORAGE_TYPE_WEB_SQL_DATABASE:
 314                 ewk_context_web_database_origins_get(pDefaultContext, OnOriginReceived, &presenter);
 315                 break;
 316
 317         case WEB_STORAGE_TYPE_WEB_STORAGE:
 318                 ewk_context_web_storage_origins_get(pDefaultContext, OnOriginReceived, &presenter);
 319                 break;
 320
 321         case WEB_STORAGE_TYPE_FILE_SYSTEM:
 322                 ewk_context_local_file_system_origins_get(pDefaultContext, OnOriginReceived, &presenter);
 323                 break;
 324
 325         default:
 326                 break;
 327         }
 328
 329         presenter.WaitAsyncProcess(pOriginList);
 330
 331         for(; pOriginList; pOriginList = eina_list_next(pOriginList))
 332         {
 333                 Ewk_Security_Origin* pOrigin = static_cast<Ewk_Security_Origin*>(eina_list_data_get(pOriginList));
 334                 SysTryReturn(NID_WEB_CTRL, pOrigin, null, E_INVALID_ARG, "[%s] This origin does not exist.", GetErrorMessage(E_INVALID_ARG));
 335
 336                 int cmp = origin.CompareTo(_Utility::CreateOrigin(pOrigin));
 337
 338                 if (cmp ==0)
 339                 {
 340                         return pOrigin;
 341                 }
 342         }
 343         return null;
 344 }
 345 }}} // Tizen::Web::Controls