Changeset 109205 in webkit


Ignore:
Timestamp:
Feb 29, 2012 12:58:22 AM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[EFL] Replace malloc/calloc/free to new/delete.
​https://bugs.webkit.org/show_bug.cgi?id=75848

Patch by Tomasz Morawski <​t.morawski@samsung.com> on 2012-02-29
Reviewed by Hajime Morita.

Replaced almost all malloc/calloc/free to new/delete operator and where it was possible smart pointers were also
used. Left few c memory allocation by intention to not mix c and c++ memory managment. Left malloc for Ewk_Tile
object due to const fields present in Ewk_tile structure.

  • ewk/ewk_auth_soup.cpp:
  • ewk/ewk_contextmenu.cpp:

(ewk_context_menu_unref):
(ewk_context_menu_item_new):
(ewk_context_menu_item_free):
(ewk_context_menu_new):

  • ewk/ewk_cookies.cpp:

(ewk_cookies_get_all):
(ewk_cookies_cookie_free):

  • ewk/ewk_frame.cpp:

(ewk_frame_hit_test_free):
(ewk_frame_hit_test_new):

  • ewk/ewk_history.cpp:

(ewk_history_item_new_from_core):
(_ewk_history_item_free):
(ewk_history_new):
(ewk_history_free):

  • ewk/ewk_tiled_backing_store.cpp:

(_Ewk_Tiled_Backing_Store_Item):
(_ewk_tiled_backing_store_pre_render_request_add):
(_ewk_tiled_backing_store_pre_render_request_del):
(_ewk_tiled_backing_store_pre_render_request_flush):
(_ewk_tiled_backing_store_pre_render_request_clear):
(_ewk_tiled_backing_store_item_add):
(_ewk_tiled_backing_store_item_del):

  • ewk/ewk_tiled_matrix.cpp:

(_ewk_tile_matrix_tile_free):
(ewk_tile_matrix_new):
(ewk_tile_matrix_zoom_level_set):
(ewk_tile_matrix_invalidate):
(ewk_tile_matrix_free):

  • ewk/ewk_tiled_model.cpp:

(tile_account):
(ewk_tile_unused_cache_new):
(_ewk_tile_unused_cache_free):
(ewk_tile_unused_cache_clear):
(ewk_tile_unused_cache_flush):
(ewk_tile_unused_cache_tile_get):
(ewk_tile_unused_cache_tile_put):

  • ewk/ewk_tiled_private.h:
  • ewk/ewk_view.cpp:

(_Ewk_View_Private_Data):
(_ewk_view_core_frame_new):
(_ewk_view_priv_new):
(_ewk_view_priv_del):
(ewk_view_core_page_get):
(ewk_view_popup_new):
(ewk_view_popup_destroy):
(EWKPrivate::corePage):

  • ewk/ewk_window_features.cpp:

(ewk_window_features_unref):
(ewk_window_features_new_from_core):

Location:
trunk/Source/WebKit/efl
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/efl/ChangeLog

    r108991 r109205  
     12012-02-29  Tomasz Morawski  <t.morawski@samsung.com>
     2
     3        [EFL] Replace malloc/calloc/free to new/delete.
     4        https://bugs.webkit.org/show_bug.cgi?id=75848
     5
     6        Reviewed by Hajime Morita.
     7
     8        Replaced almost all malloc/calloc/free to new/delete operator and where it was possible smart pointers were also
     9        used. Left few c memory allocation by intention to not mix c and c++ memory managment. Left malloc for Ewk_Tile
     10        object due to const fields present in Ewk_tile structure.
     11
     12        * ewk/ewk_auth_soup.cpp:
     13        * ewk/ewk_contextmenu.cpp:
     14        (ewk_context_menu_unref):
     15        (ewk_context_menu_item_new):
     16        (ewk_context_menu_item_free):
     17        (ewk_context_menu_new):
     18        * ewk/ewk_cookies.cpp:
     19        (ewk_cookies_get_all):
     20        (ewk_cookies_cookie_free):
     21        * ewk/ewk_frame.cpp:
     22        (ewk_frame_hit_test_free):
     23        (ewk_frame_hit_test_new):
     24        * ewk/ewk_history.cpp:
     25        (ewk_history_item_new_from_core):
     26        (_ewk_history_item_free):
     27        (ewk_history_new):
     28        (ewk_history_free):
     29        * ewk/ewk_tiled_backing_store.cpp:
     30        (_Ewk_Tiled_Backing_Store_Item):
     31        (_ewk_tiled_backing_store_pre_render_request_add):
     32        (_ewk_tiled_backing_store_pre_render_request_del):
     33        (_ewk_tiled_backing_store_pre_render_request_flush):
     34        (_ewk_tiled_backing_store_pre_render_request_clear):
     35        (_ewk_tiled_backing_store_item_add):
     36        (_ewk_tiled_backing_store_item_del):
     37        * ewk/ewk_tiled_matrix.cpp:
     38        (_ewk_tile_matrix_tile_free):
     39        (ewk_tile_matrix_new):
     40        (ewk_tile_matrix_zoom_level_set):
     41        (ewk_tile_matrix_invalidate):
     42        (ewk_tile_matrix_free):
     43        * ewk/ewk_tiled_model.cpp:
     44        (tile_account):
     45        (ewk_tile_unused_cache_new):
     46        (_ewk_tile_unused_cache_free):
     47        (ewk_tile_unused_cache_clear):
     48        (ewk_tile_unused_cache_flush):
     49        (ewk_tile_unused_cache_tile_get):
     50        (ewk_tile_unused_cache_tile_put):
     51        * ewk/ewk_tiled_private.h:
     52        * ewk/ewk_view.cpp:
     53        (_Ewk_View_Private_Data):
     54        (_ewk_view_core_frame_new):
     55        (_ewk_view_priv_new):
     56        (_ewk_view_priv_del):
     57        (ewk_view_core_page_get):
     58        (ewk_view_popup_new):
     59        (ewk_view_popup_destroy):
     60        (EWKPrivate::corePage):
     61        * ewk/ewk_window_features.cpp:
     62        (ewk_window_features_unref):
     63        (ewk_window_features_new_from_core):
     64
    1652012-02-27  JungJik Lee  <jungjik.lee@samsung.com>
    266

  • trunk/Source/WebKit/efl/ewk/ewk_auth_soup.cpp

    r101744 r109205  
    9494        return;
    9595
    96     authenticationData = static_cast<Ewk_Auth_Data*>(calloc(1, sizeof(Ewk_Auth_Data)));
    97 
    98     if (!authenticationData) {
    99         CRITICAL("could not allocate Ewk_Auth_Data");
    100         return;
    101     }
    102 
    10396    soup_session_pause_message(session, message);
    10497    // We need to make sure the message sticks around when pausing it.
    … …  
    107100    g_object_ref(auth);
    108101
     102    authenticationData = new Ewk_Auth_Data;
    109103    authenticationData->message = message;
    110104    authenticationData->auth = auth;
    … …  
    123117    g_object_unref(authData->session);
    124118    g_object_unref(authData->auth);
    125     free(authData);
     119    delete authData;
    126120}
    127121

  • trunk/Source/WebKit/efl/ewk/ewk_contextmenu.cpp

    r101744 r109205  
    7676        ewk_context_menu_item_free(static_cast<Ewk_Context_Menu_Item*>(item));
    7777
    78     free(menu);
     78    delete menu;
    7979}
    8080
    … …  
    102102                                                 const char* title, Eina_Bool checked, Eina_Bool enabled)
    103103{
    104     Ewk_Context_Menu_Item* item = static_cast<Ewk_Context_Menu_Item*>(malloc(sizeof(*item)));
    105     if (!item)
    106         return 0;
    107 
     104    Ewk_Context_Menu_Item* item = new Ewk_Context_Menu_Item;
    108105    item->type = type;
    109106    item->action = action;
    … …  
    138135
    139136    eina_stringshare_del(item->title);
    140     free(item);
     137    delete item;
    141138}
    142139
    … …  
    227224    EINA_SAFETY_ON_NULL_RETURN_VAL(controller, 0);
    228225
    229     menu = static_cast<Ewk_Context_Menu*>(malloc(sizeof(*menu)));
    230     if (!menu) {
    231         CRITICAL("Could not allocate context menu memory.");
    232         return 0;
    233     }
     226    menu = new Ewk_Context_Menu;
    234227
    235228    menu->__ref = 1;

  • trunk/Source/WebKit/efl/ewk/ewk_cookies.cpp

    r107562 r109205  
    7777    for (p = list; p; p = p->next) {
    7878        SoupCookie* cookie = static_cast<SoupCookie*>(p->data);
    79         Ewk_Cookie* ewkCookie = static_cast<Ewk_Cookie*>(malloc(sizeof(*ewkCookie)));
     79        Ewk_Cookie* ewkCookie = new Ewk_Cookie;
    8080        ewkCookie->name = strdup(cookie->name);
    8181        ewkCookie->value = strdup(cookie->value);
    … …  
    122122    free(cookie->domain);
    123123    free(cookie->path);
    124     free(cookie);
     124    delete cookie;
    125125}
    126126

  • trunk/Source/WebKit/efl/ewk/ewk_frame.cpp

    r107562 r109205  
    660660    eina_stringshare_del(hitTest->image_uri);
    661661    eina_stringshare_del(hitTest->media_uri);
    662     free(hitTest);
     662    delete hitTest;
    663663}
    664664
    … …  
    681681        return 0;
    682682
    683     Ewk_Hit_Test* hitTest = static_cast<Ewk_Hit_Test*>(calloc(1, sizeof(Ewk_Hit_Test)));
    684     if (!hitTest) {
    685         CRITICAL("Could not allocate memory for hit test.");
    686         return 0;
    687     }
    688 
     683    Ewk_Hit_Test* hitTest = new Ewk_Hit_Test;
    689684    hitTest->x = result.point().x();
    690685    hitTest->y = result.point().y();

  • trunk/Source/WebKit/efl/ewk/ewk_history.cpp

    r106904 r109205  
    242242    }
    243243
    244     item = (Ewk_History_Item*)calloc(1, sizeof(Ewk_History_Item));
    245     if (!item) {
    246         CRITICAL("Could not allocate item memory.");
    247         return 0;
    248     }
    249 
    250244    core->ref();
     245
     246    item = new Ewk_History_Item;
     247    memset(item, 0, sizeof(*item));
    251248    item->core = core;
    252249
    … …  
    266263{
    267264    core->deref();
    268     free(item);
     265    delete item;
    269266}
    270267
    … …  
    400397    DBG("core=%p", core);
    401398
    402     history = static_cast<Ewk_History*>(malloc(sizeof(Ewk_History)));
    403     if (!history) {
    404         CRITICAL("Could not allocate history memory.");
    405         return 0;
    406     }
    407 
     399    history = new Ewk_History;
     400    history->core = core;
    408401    core->ref();
    409     history->core = core;
    410402
    411403    return history;
    … …  
    424416    DBG("history=%p", history);
    425417    history->core->deref();
    426     free(history);
     418    delete history;
    427419}
    428420

  • trunk/Source/WebKit/efl/ewk/ewk_tiled_backing_store.cpp

    r106904 r109205  
    2727#include <Ecore.h>
    2828#include <Eina.h>
     29#include <OwnPtr.h>
     30#include <PassOwnPtr.h>
    2931#include <algorithm>
    3032#include <errno.h>
    … …  
    250252static inline Eina_Bool _ewk_tiled_backing_store_pre_render_request_add(Ewk_Tiled_Backing_Store_Data* priv, unsigned long column, unsigned long row, float zoom)
    251253{
    252     Ewk_Tiled_Backing_Store_Pre_Render_Request* request;
    253 
    254     request = static_cast<Ewk_Tiled_Backing_Store_Pre_Render_Request*>(malloc(sizeof(*request)));
    255     if (!request)
    256         return false;
     254    Ewk_Tiled_Backing_Store_Pre_Render_Request* request = new Ewk_Tiled_Backing_Store_Pre_Render_Request;
    257255
    258256    priv->render.preRenderRequests = eina_inlist_append
    … …  
    270268    priv->render.preRenderRequests = eina_inlist_remove
    271269                                           (priv->render.preRenderRequests, EINA_INLIST_GET(request));
    272     free(request);
     270    delete request;
    273271}
    274272
    … …  
    287285        request = _ewk_tiled_backing_store_pre_render_request_first(priv);
    288286        *preRenderList = eina_inlist_remove(*preRenderList, *preRenderList);
    289         free(request);
     287        delete request;
    290288    }
    291289}
    … …  
    302300        *preRenderList = eina_inlist_remove(*preRenderList, iter);
    303301        iter = next;
    304         free(request);
     302        delete request;
    305303    }
    306304}
    … …  
    472470static Ewk_Tiled_Backing_Store_Item* _ewk_tiled_backing_store_item_add(Ewk_Tiled_Backing_Store_Data* priv, unsigned long column, unsigned long row)
    473471{
    474     Ewk_Tiled_Backing_Store_Item* item;
    475472    Evas_Coord x, y, tileWidth, tileHeight;
    476473
    477474    DBG("ewkBackingStore=%p", priv->self);
    478 
    479     item = static_cast<Ewk_Tiled_Backing_Store_Item*>(malloc(sizeof(*item)));
    480     if (!item)
    481         return 0;
    482475
    483476    tileWidth = priv->view.tile.width;
    … …  
    486479    y = priv->view.offset.base.y + priv->view.y + tileHeight * row;
    487480
     481    OwnPtr<Ewk_Tiled_Backing_Store_Item> item = adoptPtr(new Ewk_Tiled_Backing_Store_Item);
    488482    item->tile = 0;
    489 
    490483    item->smoothScale = priv->view.tile.zoomWeakSmoothScale;
    491     _ewk_tiled_backing_store_item_move(item, x, y);
    492     _ewk_tiled_backing_store_item_resize(item, tileWidth, tileHeight);
    493     if (!_ewk_tiled_backing_store_item_fill(priv, item, column, row)) {
    494         free(item);
     484
     485    _ewk_tiled_backing_store_item_move(item.get(), x, y);
     486    _ewk_tiled_backing_store_item_resize(item.get(), tileWidth, tileHeight);
     487    if (!_ewk_tiled_backing_store_item_fill(priv, item.get(), column, row))
    495488        return 0;
    496     }
    497 
    498     return item;
     489
     490    return item.leakPtr();
    499491}
    500492
    … …  
    506498    }
    507499
    508     free(item);
     500    delete item;
    509501}
    510502

  • trunk/Source/WebKit/efl/ewk/ewk_tiled_matrix.cpp

    r106904 r109205  
    2626#include "ewk_tiled_private.h"
    2727#include <Eina.h>
     28#include <OwnPtr.h>
     29#include <PassOwnPtr.h>
    2830#include <errno.h>
    2931#include <inttypes.h>
    … …  
    171173        eina_matrixsparse_free(entry->matrix);
    172174        tileMatrix->matrices = eina_inlist_remove(tileMatrix->matrices, EINA_INLIST_GET(entry));
    173         free(entry);
     175        delete entry;
    174176    }
    175177
    … …  
    198200Ewk_Tile_Matrix* ewk_tile_matrix_new(Ewk_Tile_Unused_Cache* tileUnusedCache, unsigned long columns, unsigned long rows, float zoomLevel, Evas_Colorspace colorSpace, void (*renderCallback)(void* data, Ewk_Tile* tile, const Eina_Rectangle* update), const void* renderData)
    199201{
    200     Ewk_Tile_Matrix* tileMatrix = static_cast<Ewk_Tile_Matrix*>(calloc(1, sizeof(Ewk_Tile_Matrix)));
    201     if (!tileMatrix)
    202         return 0;
    203 
    204     tileMatrix->matrix = eina_matrixsparse_new(rows, columns, _ewk_tile_matrix_cell_free, tileMatrix);
     202    OwnPtr<Ewk_Tile_Matrix> tileMatrix = adoptPtr(new Ewk_Tile_Matrix);
     203
     204    tileMatrix->matrix = eina_matrixsparse_new(rows, columns, _ewk_tile_matrix_cell_free, tileMatrix.get());
    205205    if (!tileMatrix->matrix) {
    206206        ERR("could not create sparse matrix.");
    207         free(tileMatrix);
    208207        return 0;
    209208    }
    210209
    211     ewk_tile_matrix_zoom_level_set(tileMatrix, zoomLevel);
     210    tileMatrix->matrices = 0;
     211    ewk_tile_matrix_zoom_level_set(tileMatrix.get(), zoomLevel);
    212212
    213213    if (tileUnusedCache)
    … …  
    218218            ERR("no cache of unused tile!");
    219219            eina_matrixsparse_free(tileMatrix->matrix);
    220             free(tileMatrix);
    221220            return 0;
    222221        }
    … …  
    228227    tileMatrix->tile.width = defaultTileWidth;
    229228    tileMatrix->tile.height = defaultTileHeigth;
    230 
    231     return tileMatrix;
     229    tileMatrix->frozen = 0;
     230    tileMatrix->updates = 0;
     231
     232#ifdef DEBUG_MEM_LEAKS
     233    tileMatrix->stats.tiles.allocated = 0;
     234    tileMatrix->stats.tiles.freed = 0;
     235    tileMatrix->stats.bytes.allocated = 0;
     236    tileMatrix->stats.bytes.freed = 0;
     237#endif
     238    return tileMatrix.leakPtr();
    232239}
    233240
    … …  
    250257
    251258    if (!entry) {
    252         entry = static_cast<Ewk_Tile_Matrix_Entry*>(calloc(1, sizeof(Ewk_Tile_Matrix_Entry)));
     259        entry = new Ewk_Tile_Matrix_Entry;
     260        memset(entry, 0, sizeof(Ewk_Tile_Matrix_Entry));
     261        entry->matrix = eina_matrixsparse_new(rows, columns, _ewk_tile_matrix_cell_free, tileMatrix);
     262        entry->count = 0;
    253263        entry->zoom = zoom;
    254         entry->matrix = eina_matrixsparse_new(rows, columns, _ewk_tile_matrix_cell_free, tileMatrix);
    255264        if (!entry->matrix) {
    256265            ERR("could not create sparse matrix.");
    257             free(entry);
     266            delete entry;
    258267            return;
    259268        }
    … …  
    278287            eina_matrixsparse_free(iterator->matrix);
    279288            tileMatrix->matrices = eina_inlist_remove(tileMatrix->matrices, matrixList);
    280             free(iterator);
     289            delete iterator;
    281290        }
    282291
    … …  
    304313    eina_matrixsparse_free(entry->matrix);
    305314    tileMatrix->matrices = eina_inlist_remove(tileMatrix->matrices, reinterpret_cast<Eina_Inlist*>(entry));
    306     free(entry);
    307315    tileMatrix->matrices = 0;
     316    delete entry;
    308317
    309318    ewk_tile_unused_cache_thaw(tileMatrix->tileUnusedCache);
    … …  
    336345#endif
    337346
    338     free(tileMatrix);
     347    delete tileMatrix;
    339348}
    340349

  • trunk/Source/WebKit/efl/ewk/ewk_tiled_model.cpp

    r108991 r109205  
    440440    Ewk_Tile_Unused_Cache* tileUnusedCache;
    441441
    442     tileUnusedCache = static_cast<Ewk_Tile_Unused_Cache*>(calloc(1, sizeof(Ewk_Tile_Unused_Cache)));
    443     if (!tileUnusedCache)
    444         return 0;
     442    tileUnusedCache = new Ewk_Tile_Unused_Cache;
     443    memset(tileUnusedCache, 0, sizeof(Ewk_Tile_Unused_Cache));
    445444
    446445    DBG("tileUnusedCache=%p", tileUnusedCache);
    … …  
    492491
    493492    ewk_tile_unused_cache_clear(tileUnusedCache);
    494     free(tileUnusedCache);
     493    delete tileUnusedCache;
    495494}
    496495
    … …  
    512511        Ewk_Tile_Unused_Cache_Entry* itr = static_cast<Ewk_Tile_Unused_Cache_Entry*>(item);
    513512        itr->tile_free.callback(itr->tile_free.data, itr->tile);
    514         free(itr);
     513        delete itr;
    515514    }
    516515
    … …  
    605604        itr->tile_free.callback(itr->tile_free.data, itr->tile);
    606605        tileUnusedCache->entries.list = eina_list_remove_list(tileUnusedCache->entries.list, list);
    607         free(itr);
     606        delete itr;
    608607        count++;
    609608    }
    … …  
    670669Eina_Bool ewk_tile_unused_cache_tile_get(Ewk_Tile_Unused_Cache* tileUnusedCache, Ewk_Tile* tile)
    671670{
    672     Eina_List* foundEntry, *iterateEntry;
    673 
     671    Eina_List* iterateEntry;
    674672    void* item;
    675     foundEntry = 0;
     673
    676674    EINA_LIST_FOREACH(tileUnusedCache->entries.list, iterateEntry, item) {
    677675        Ewk_Tile_Unused_Cache_Entry* entry = static_cast<Ewk_Tile_Unused_Cache_Entry*>(item);
    678676        if (entry->tile == tile) {
    679             foundEntry = iterateEntry;
    680             break;
     677            tileUnusedCache->entries.count--;
     678            tileUnusedCache->memory.used -= ewk_tile_memory_size_get(tile);
     679            tileUnusedCache->entries.list = eina_list_remove_list(tileUnusedCache->entries.list, iterateEntry);
     680            delete entry;
     681
     682            return true;
    681683        }
    682684    }
    683     if (!foundEntry) {
    684         ERR("tile %p not found in cache %p", tile, tileUnusedCache);
    685         return false;
    686     }
    687 
    688     tileUnusedCache->entries.count--;
    689     tileUnusedCache->memory.used -= ewk_tile_memory_size_get(tile);
    690     tileUnusedCache->entries.list = eina_list_remove_list(tileUnusedCache->entries.list, foundEntry);
    691     free(item);
    692 
    693     return true;
     685
     686    ERR("tile %p not found in cache %p", tile, tileUnusedCache);
     687    return false;
    694688}
    695689
    … …  
    725719    }
    726720
    727     unusedCacheEntry = static_cast<Ewk_Tile_Unused_Cache_Entry*>(malloc(sizeof(Ewk_Tile_Unused_Cache_Entry)));
    728     if (!unusedCacheEntry)
    729         return false;
     721    unusedCacheEntry = new Ewk_Tile_Unused_Cache_Entry;
    730722
    731723    tileUnusedCache->entries.list = eina_list_append(tileUnusedCache->entries.list, unusedCacheEntry);

  • trunk/Source/WebKit/efl/ewk/ewk_tiled_private.h

    r95901 r109205  
    3030#define INF(...) EINA_LOG_DOM_INFO(_ewk_tiled_log_dom, __VA_ARGS__)
    3131#define DBG(...) EINA_LOG_DOM_DBG(_ewk_tiled_log_dom, __VA_ARGS__)
    32 #define OOM(op, size) CRITICAL("could not %s %zd bytes: %s", op, size, strerror(errno))
    33 #define MALLOC_OR_OOM_RET(ptr, size, ...)       \
    34     do {                                        \
    35         ptr = malloc(size);                     \
    36         if (!ptr && (size) > 0) {               \
    37             OOM("malloc", (size));              \
    38             return __VA_ARGS__;                 \
    39         }                                       \
    40     } while (0)
    41 
    42 #define CALLOC_OR_OOM_RET(ptr, size, ...)       \
    43     do {                                        \
    44         ptr = calloc(1, size);                  \
    45         if (!ptr && (size) > 0) {               \
    46             OOM("calloc", (size));              \
    47             return __VA_ARGS__;                 \
    48         }                                       \
    49     } while (0)
    50 
    51 #define REALLOC_OR_OOM_RET(ptr, size, ...)      \
    52     do {                                        \
    53         void* __tmp_ptr;                        \
    54         __tmp_ptr = realloc(ptr, size);         \
    55         if (!__tmp_ptr && (size) > 0) {         \
    56             OOM("realloc", (size));             \
    57             return __VA_ARGS__;                 \
    58         }                                       \
    59         ptr = __tmp_ptr;                        \
    60     } while (0)
    61 
    6232#endif // ewk_tiled_private_h

  • trunk/Source/WebKit/efl/ewk/ewk_view.cpp

    r108272 r109205  
    134134 */
    135135struct _Ewk_View_Private_Data {
    136     WebCore::Page* page;
     136    OwnPtr<WebCore::Page> page;
    137137    WebCore::Settings* pageSettings;
    138138    WebCore::Frame* mainFrame;
    … …  
    590590    frameLoaderClient->setCustomUserAgent(String::fromUTF8(priv->settings.userAgent));
    591591
    592     return WebCore::Frame::create(priv->page, owner, frameLoaderClient);
     592    return WebCore::Frame::create(priv->page.get(), owner, frameLoaderClient);
    593593}
    594594
    … …  
    597597static Ewk_View_Private_Data* _ewk_view_priv_new(Ewk_View_Smart_Data* smartData)
    598598{
    599     Ewk_View_Private_Data* priv =
    600         static_cast<Ewk_View_Private_Data*>(calloc(1, sizeof(Ewk_View_Private_Data)));
     599    Ewk_View_Private_Data* priv = new Ewk_View_Private_Data;
     600    memset(priv, 0, sizeof(Ewk_View_Private_Data));
    601601    AtomicString string;
    602602    WebCore::KURL url;
    603 
    604     if (!priv) {
    605         CRITICAL("could not allocate Ewk_View_Private_Data");
    606         return 0;
    607     }
    608603
    609604    WebCore::Page::PageClients pageClients;
    … …  
    612607    pageClients.dragClient = new WebCore::DragClientEfl;
    613608    pageClients.inspectorClient = new WebCore::InspectorClientEfl;
    614     priv->page = new WebCore::Page(pageClients);
    615     if (!priv->page) {
    616         CRITICAL("Could not create WebKit Page");
    617         goto error_page;
    618     }
     609
     610    priv->page = adoptPtr(new WebCore::Page(pageClients));
     611
    619612#if ENABLE(DEVICE_ORIENTATION)
    620     WebCore::provideDeviceMotionTo(priv->page, new WebCore::DeviceMotionClientEfl);
    621     WebCore::provideDeviceOrientationTo(priv->page, new WebCore::DeviceOrientationClientEfl);
     613    WebCore::provideDeviceMotionTo(priv->page.get(), new WebCore::DeviceMotionClientEfl);
     614    WebCore::provideDeviceOrientationTo(priv->page.get(), new WebCore::DeviceOrientationClientEfl);
    622615#endif
    623616
    624617#if ENABLE(VIBRATION)
    625     WebCore::provideVibrationTo(priv->page, new WebCore::VibrationClientEfl(smartData->self));
     618    WebCore::provideVibrationTo(priv->page.get(), new WebCore::VibrationClientEfl(smartData->self));
    626619#endif
    627620
    628621    priv->pageSettings = priv->page->settings();
    629     if (!priv->pageSettings) {
    630         CRITICAL("Could not get page settings.");
    631         goto error_settings;
    632     }
    633622
    634623    priv->viewportArguments.width = WebCore::ViewportArguments::ValueAuto;
    … …  
    715704
    716705    priv->mainFrame = _ewk_view_core_frame_new(smartData, priv, 0).get();
    717     if (!priv->mainFrame) {
    718         CRITICAL("Could not create main frame.");
    719         goto error_main_frame;
    720     }
    721706
    722707    priv->history = ewk_history_new(static_cast<WebCore::BackForwardListImpl*>(priv->page->backForwardList()));
    723     if (!priv->history) {
    724         CRITICAL("Could not create history instance for view.");
    725         goto error_history;
    726     }
    727708
    728709    priv->soupSession = WebCore::ResourceHandle::defaultSession();
    729710
    730711    return priv;
    731 
    732 error_history:
    733     // delete priv->main_frame; /* do not delete priv->main_frame */
    734 error_main_frame:
    735 error_settings:
    736     delete priv->page;
    737 error_page:
    738     free(priv);
    739     return 0;
    740712}
    741713
    … …  
    767739    ewk_history_free(priv->history);
    768740
    769     delete priv->page;
    770     free(priv);
     741    delete priv;
    771742}
    772743
    … …  
    33963367    EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData, 0);
    33973368    EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv, 0);
    3398     return priv->page;
     3369    return priv->page.get();
    33993370}
    34003371
    … …  
    34753446    const int size = client->listSize();
    34763447    for (int i = 0; i < size; ++i) {
    3477         Ewk_Menu_Item* item = static_cast<Ewk_Menu_Item*>(malloc(sizeof(*item)));
     3448        Ewk_Menu_Item* item = new Ewk_Menu_Item;
    34783449        if (client->itemIsSeparator(i))
    34793450            item->type = EWK_MENU_SEPARATOR;
    … …  
    35093480        Ewk_Menu_Item* item = static_cast<Ewk_Menu_Item*>(itemv);
    35103481        eina_stringshare_del(item->text);
    3511         free(item);
     3482        delete item;
    35123483    }
    35133484    priv->popup.menuClient->popupDidHide();
    … …  
    39523923    EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData, 0);
    39533924    EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv, 0);
    3954     return priv->page;
     3925    return priv->page.get();
    39553926}
    39563927

  • trunk/Source/WebKit/efl/ewk/ewk_window_features.cpp

    r101744 r109205  
    4646    delete windowFeatures->core;
    4747    windowFeatures->core = 0;
    48     free(windowFeatures);
     48    delete windowFeatures;
    4949}
    5050
    … …  
    110110Ewk_Window_Features* ewk_window_features_new_from_core(const WebCore::WindowFeatures* core)
    111111{
    112     Ewk_Window_Features* window_features = static_cast<Ewk_Window_Features*>(malloc(sizeof(*window_features)));
    113     if (!window_features) {
    114         CRITICAL("Could not allocate Ewk_Window_Features.");
    115         return 0;
    116     }
     112    Ewk_Window_Features* window_features = new Ewk_Window_Features;
    117113
    118114    if (core)
Note: See TracChangeset for help on using the changeset viewer.