Changeset 159117 in webkit


Ignore:
Timestamp:
Nov 12, 2013 9:40:47 AM (10 years ago)
Author:
andersca@apple.com
Message:

Begin cleaning up handling of ImmutableArray vectors
​https://bugs.webkit.org/show_bug.cgi?id=124208

Reviewed by Andreas Kling.

Use range based for to iterate the loops. Use reserveInitialCapacity + uncheckedAppend
when appending vector elements.

  • Shared/SecurityOriginData.cpp:

(WebKit::performAPICallbackWithSecurityOriginDataVector):

  • Shared/WebArchive.cpp:

(WebKit::WebArchive::subresources):
(WebKit::WebArchive::subframeArchives):

  • Shared/WebContextMenuItem.cpp:

(WebKit::WebContextMenuItem::submenuItemsAsImmutableArray):

  • Shared/WebOpenPanelParameters.cpp:

(WebKit::WebOpenPanelParameters::acceptMIMETypes):
(WebKit::WebOpenPanelParameters::selectedFileNames):

  • UIProcess/API/C/mac/WKContextPrivateMac.mm:

(WKContextGetInfoForInstalledPlugIns):

  • UIProcess/Plugins/WebPluginSiteDataManager.cpp:

(WebKit::WebPluginSiteDataManager::didGetSitesWithData):

  • UIProcess/StatisticsRequest.cpp:

(WebKit::StatisticsRequest::completedRequest):

  • UIProcess/WebContext.cpp:

(WebKit::WebContext::pluginInfoStoreDidLoadPlugins):

  • UIProcess/WebCookieManagerProxy.cpp:

(WebKit::WebCookieManagerProxy::didGetHostnamesWithCookies):

  • UIProcess/WebDatabaseManagerProxy.cpp:

(WebKit::WebDatabaseManagerProxy::didGetDatabasesByOrigin):
(WebKit::WebDatabaseManagerProxy::didGetDatabaseOrigins):

  • UIProcess/WebMediaCacheManagerProxy.cpp:

(WebKit::WebMediaCacheManagerProxy::didGetHostnamesWithMediaCache):

  • UIProcess/WebPageContextMenuClient.cpp:

(WebKit::WebPageContextMenuClient::showContextMenu):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::relatedPages):
(WebKit::WebPageProxy::didFindStringMatches):

  • WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::InjectedBundle::originsWithApplicationCache):

  • WebProcess/InjectedBundle/InjectedBundleBackForwardListItem.cpp:

(WebKit::InjectedBundleBackForwardListItem::children):

  • WebProcess/InjectedBundle/InjectedBundlePageFormClient.cpp:

(WebKit::InjectedBundlePageFormClient::didAssociateFormControls):

  • WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp:

(WebKit::InjectedBundlePageLoaderClient::featuresUsedInPage):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::trackedRepaintRects):

Location:
trunk/Source/WebKit2
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r159112 r159117  
     12013-11-12  Anders Carlsson  <andersca@apple.com>
     2
     3        Begin cleaning up handling of ImmutableArray vectors
     4        https://bugs.webkit.org/show_bug.cgi?id=124208
     5
     6        Reviewed by Andreas Kling.
     7
     8        Use range based for to iterate the loops. Use reserveInitialCapacity + uncheckedAppend
     9        when appending vector elements.
     10
     11        * Shared/SecurityOriginData.cpp:
     12        (WebKit::performAPICallbackWithSecurityOriginDataVector):
     13        * Shared/WebArchive.cpp:
     14        (WebKit::WebArchive::subresources):
     15        (WebKit::WebArchive::subframeArchives):
     16        * Shared/WebContextMenuItem.cpp:
     17        (WebKit::WebContextMenuItem::submenuItemsAsImmutableArray):
     18        * Shared/WebOpenPanelParameters.cpp:
     19        (WebKit::WebOpenPanelParameters::acceptMIMETypes):
     20        (WebKit::WebOpenPanelParameters::selectedFileNames):
     21        * UIProcess/API/C/mac/WKContextPrivateMac.mm:
     22        (WKContextGetInfoForInstalledPlugIns):
     23        * UIProcess/Plugins/WebPluginSiteDataManager.cpp:
     24        (WebKit::WebPluginSiteDataManager::didGetSitesWithData):
     25        * UIProcess/StatisticsRequest.cpp:
     26        (WebKit::StatisticsRequest::completedRequest):
     27        * UIProcess/WebContext.cpp:
     28        (WebKit::WebContext::pluginInfoStoreDidLoadPlugins):
     29        * UIProcess/WebCookieManagerProxy.cpp:
     30        (WebKit::WebCookieManagerProxy::didGetHostnamesWithCookies):
     31        * UIProcess/WebDatabaseManagerProxy.cpp:
     32        (WebKit::WebDatabaseManagerProxy::didGetDatabasesByOrigin):
     33        (WebKit::WebDatabaseManagerProxy::didGetDatabaseOrigins):
     34        * UIProcess/WebMediaCacheManagerProxy.cpp:
     35        (WebKit::WebMediaCacheManagerProxy::didGetHostnamesWithMediaCache):
     36        * UIProcess/WebPageContextMenuClient.cpp:
     37        (WebKit::WebPageContextMenuClient::showContextMenu):
     38        * UIProcess/WebPageProxy.cpp:
     39        (WebKit::WebPageProxy::relatedPages):
     40        (WebKit::WebPageProxy::didFindStringMatches):
     41        * WebProcess/InjectedBundle/InjectedBundle.cpp:
     42        (WebKit::InjectedBundle::originsWithApplicationCache):
     43        * WebProcess/InjectedBundle/InjectedBundleBackForwardListItem.cpp:
     44        (WebKit::InjectedBundleBackForwardListItem::children):
     45        * WebProcess/InjectedBundle/InjectedBundlePageFormClient.cpp:
     46        (WebKit::InjectedBundlePageFormClient::didAssociateFormControls):
     47        * WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp:
     48        (WebKit::InjectedBundlePageLoaderClient::featuresUsedInPage):
     49        * WebProcess/WebPage/WebPage.cpp:
     50        (WebKit::WebPage::trackedRepaintRects):
     51
    1522013-11-12  Csaba Osztrogonác  <ossy@webkit.org>
    253

  • trunk/Source/WebKit2/Shared/SecurityOriginData.cpp

    r149848 r159117  
    7878    }
    7979   
    80     size_t originDataCount = originDatas.size();
    8180    Vector<RefPtr<APIObject>> securityOrigins;
    82     securityOrigins.reserveCapacity(originDataCount);
     81    securityOrigins.reserveInitialCapacity(originDatas.size());
    8382
    84     for (size_t i = 0; i < originDataCount; ++i) {
    85         SecurityOriginData originData = originDatas[i];
     83    for (const auto& originData : originDatas) {
    8684        RefPtr<APIObject> origin = WebSecurityOrigin::create(originData.protocol, originData.host, originData.port);
    8785        if (!origin)
    8886            continue;
    89         securityOrigins.uncheckedAppend(origin);
     87        securityOrigins.uncheckedAppend(std::move(origin));
    9088    }
    9189

  • trunk/Source/WebKit2/Shared/WebArchive.cpp

    r149848 r159117  
    109109    if (!m_cachedSubresources) {
    110110        Vector<RefPtr<APIObject>> subresources;
    111         subresources.reserveCapacity(m_legacyWebArchive->subresources().size());
    112         for (unsigned i = 0; i < m_legacyWebArchive->subresources().size(); ++i)
    113             subresources.append(WebArchiveResource::create(m_legacyWebArchive->subresources()[i].get()));
     111        subresources.reserveInitialCapacity(m_legacyWebArchive->subresources().size());
     112
     113        for (const auto& subresource : m_legacyWebArchive->subresources())
     114            subresources.uncheckedAppend(WebArchiveResource::create(subresource));
    114115
    115116        m_cachedSubresources = ImmutableArray::adopt(subresources);
    … …  
    123124    if (!m_cachedSubframeArchives) {
    124125        Vector<RefPtr<APIObject>> subframeWebArchives;
    125         subframeWebArchives.reserveCapacity(m_legacyWebArchive->subframeArchives().size());
    126         for (unsigned i = 0; i < m_legacyWebArchive->subframeArchives().size(); ++i)
    127             subframeWebArchives.append(WebArchive::create(static_cast<LegacyWebArchive*>(m_legacyWebArchive->subframeArchives()[i].get())));
     126        subframeWebArchives.reserveInitialCapacity(m_legacyWebArchive->subframeArchives().size());
     127
     128        for (const auto& subframeArchive : m_legacyWebArchive->subframeArchives())
     129            subframeWebArchives.uncheckedAppend(WebArchive::create(static_cast<LegacyWebArchive*>(subframeArchive.get())));
    128130
    129131        m_cachedSubframeArchives = ImmutableArray::adopt(subframeWebArchives);

  • trunk/Source/WebKit2/Shared/WebContextMenuItem.cpp

    r149848 r159117  
    6767        return ImmutableArray::create();
    6868
    69     const Vector<WebContextMenuItemData>& submenuVector(m_webContextMenuItemData.submenu());
    70     unsigned size = submenuVector.size();
    71    
    72     Vector<RefPtr<APIObject>> result;
    73     result.reserveCapacity(size);
    74    
    75     for (unsigned i = 0; i < size; ++i)
    76         result.append(WebContextMenuItem::create(submenuVector[i]));
    77    
    78     return ImmutableArray::adopt(result);
     69    Vector<RefPtr<APIObject>> submenuItems;
     70    submenuItems.reserveInitialCapacity(m_webContextMenuItemData.submenu().size());
     71
     72    for (const auto& item : m_webContextMenuItemData.submenu())
     73        submenuItems.uncheckedAppend(WebContextMenuItem::create(item));
     74
     75    return ImmutableArray::adopt(submenuItems);
    7976}
    8077

  • trunk/Source/WebKit2/Shared/WebOpenPanelParameters.cpp

    r149848 r159117  
    5252PassRefPtr<ImmutableArray> WebOpenPanelParameters::acceptMIMETypes() const
    5353{
    54     size_t size = m_settings.acceptMIMETypes.size();
     54    Vector<RefPtr<APIObject>> vector;
     55    vector.reserveInitialCapacity(m_settings.acceptMIMETypes.size());
    5556
    56     Vector<RefPtr<APIObject>> vector;
    57     vector.reserveInitialCapacity(size);
    58    
    59     for (size_t i = 0; i < size; ++i)
    60         vector.uncheckedAppend(WebString::create(m_settings.acceptMIMETypes[i]));
     57    for (const auto& mimeType : m_settings.acceptMIMETypes)
     58        vector.uncheckedAppend(WebString::create(mimeType));
     59
    6160    return ImmutableArray::adopt(vector);
    6261}
    … …  
    7170PassRefPtr<ImmutableArray> WebOpenPanelParameters::selectedFileNames() const
    7271{   
    73     size_t size = m_settings.selectedFiles.size();
     72    Vector<RefPtr<APIObject>> vector;
     73    vector.reserveInitialCapacity(m_settings.selectedFiles.size());
    7474
    75     Vector<RefPtr<APIObject>> vector;
    76     vector.reserveInitialCapacity(size);
     75    for (const auto& selectedFile : m_settings.selectedFiles)
     76        vector.uncheckedAppend(WebString::create(selectedFile));
    7777
    78     for (size_t i = 0; i < size; ++i)
    79         vector.uncheckedAppend(WebString::create(m_settings.selectedFiles[i]));
    8078    return ImmutableArray::adopt(vector);
    8179}
    8280
    83 
    8481} // namespace WebCore

  • trunk/Source/WebKit2/UIProcess/API/C/mac/WKContextPrivateMac.mm

    r150938 r159117  
    7575
    7676    Vector<RefPtr<APIObject>> pluginInfoDictionaries;
     77    pluginInfoDictionaries.reserveInitialCapacity(plugins.size());
     78
    7779    for (const auto& plugin: plugins)
    78         pluginInfoDictionaries.append(createPluginInformationDictionary(plugin));
     80        pluginInfoDictionaries.uncheckedAppend(createPluginInformationDictionary(plugin));
    7981
    8082    RefPtr<ImmutableArray> array = ImmutableArray::adopt(pluginInfoDictionaries);

  • trunk/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.cpp

    r156069 r159117  
    166166    }
    167167
    168     Vector<RefPtr<APIObject>> sitesWK(sites.size());
    169 
    170     for (size_t i = 0; i < sites.size(); ++i)
    171         sitesWK[i] = WebString::create(sites[i]);
    172 
    173     RefPtr<ImmutableArray> resultArray = ImmutableArray::adopt(sitesWK);
    174     callback->performCallbackWithReturnValue(resultArray.get());
     168    Vector<RefPtr<APIObject>> sitesArray;
     169    sitesArray.reserveInitialCapacity(sites.size());
     170
     171    for (const auto& site : sites)
     172        sitesArray.uncheckedAppend(WebString::create(site));
     173
     174    callback->performCallbackWithReturnValue(ImmutableArray::adopt(sitesArray).get());
    175175}
    176176

  • trunk/Source/WebKit2/UIProcess/StatisticsRequest.cpp

    r149848 r159117  
    8484    if (!data.javaScriptObjectTypeCounts.isEmpty())
    8585        m_responseDictionary->set("JavaScriptObjectTypeCounts", createDictionaryFromHashMap(data.javaScriptObjectTypeCounts).get());
    86    
    87     size_t cacheStatisticsCount = data.webCoreCacheStatistics.size();
    88     if (cacheStatisticsCount) {
    89         Vector<RefPtr<APIObject>> cacheStatisticsVector(cacheStatisticsCount);
    90         for (size_t i = 0; i < cacheStatisticsCount; ++i)
    91             cacheStatisticsVector[i] = createDictionaryFromHashMap(data.webCoreCacheStatistics[i]);
    92         m_responseDictionary->set("WebCoreCacheStatistics", ImmutableArray::adopt(cacheStatisticsVector).get());
     86
     87    if (!data.webCoreCacheStatistics.isEmpty()) {
     88        Vector<RefPtr<APIObject>> cacheStatistics;
     89        cacheStatistics.reserveInitialCapacity(data.webCoreCacheStatistics.size());
     90
     91        for (const auto& statistic : data.webCoreCacheStatistics)
     92            cacheStatistics.uncheckedAppend(createDictionaryFromHashMap(statistic));
     93
     94        m_responseDictionary->set("WebCoreCacheStatistics", ImmutableArray::adopt(cacheStatistics).get());
    9395    }
    9496

  • trunk/Source/WebKit2/UIProcess/WebContext.cpp

    r159001 r159117  
    12571257    ASSERT(store == &m_pluginInfoStore);
    12581258
    1259     Vector<RefPtr<APIObject>> pluginArray;
    1260 
    1261     Vector<PluginModuleInfo> plugins = m_pluginInfoStore.plugins();
    1262     for (size_t i = 0; i < plugins.size(); ++i) {
    1263         PluginModuleInfo& plugin = plugins[i];
     1259    Vector<PluginModuleInfo> pluginModules = m_pluginInfoStore.plugins();
     1260
     1261    Vector<RefPtr<APIObject>> plugins;
     1262    plugins.reserveInitialCapacity(pluginModules.size());
     1263
     1264    for (const auto& pluginModule : pluginModules) {
    12641265        ImmutableDictionary::MapType map;
    1265         map.set(ASCIILiteral("path"), WebString::create(plugin.path));
    1266         map.set(ASCIILiteral("name"), WebString::create(plugin.info.name));
    1267         map.set(ASCIILiteral("file"), WebString::create(plugin.info.file));
    1268         map.set(ASCIILiteral("desc"), WebString::create(plugin.info.desc));
    1269         Vector<RefPtr<APIObject>> mimeArray;
    1270         for (size_t j = 0; j <  plugin.info.mimes.size(); ++j)
    1271             mimeArray.append(WebString::create(plugin.info.mimes[j].type));
    1272         map.set(ASCIILiteral("mimes"), ImmutableArray::adopt(mimeArray));
     1266        map.set(ASCIILiteral("path"), WebString::create(pluginModule.path));
     1267        map.set(ASCIILiteral("name"), WebString::create(pluginModule.info.name));
     1268        map.set(ASCIILiteral("file"), WebString::create(pluginModule.info.file));
     1269        map.set(ASCIILiteral("desc"), WebString::create(pluginModule.info.desc));
     1270
     1271        Vector<RefPtr<APIObject>> mimeTypes;
     1272        mimeTypes.reserveInitialCapacity(pluginModule.info.mimes.size());
     1273        for (const auto& mimeClassInfo : pluginModule.info.mimes)
     1274            mimeTypes.uncheckedAppend(WebString::create(mimeClassInfo.type));
     1275        map.set(ASCIILiteral("mimes"), ImmutableArray::adopt(mimeTypes));
     1276
    12731277#if PLATFORM(MAC)
    1274         map.set(ASCIILiteral("bundleId"), WebString::create(plugin.bundleIdentifier));
    1275         map.set(ASCIILiteral("version"), WebString::create(plugin.versionString));
    1276 #endif
    1277 
    1278         pluginArray.append(ImmutableDictionary::adopt(map));
    1279     }
    1280 
    1281     m_client.plugInInformationBecameAvailable(this, ImmutableArray::adopt(pluginArray).get());
     1278        map.set(ASCIILiteral("bundleId"), WebString::create(pluginModule.bundleIdentifier));
     1279        map.set(ASCIILiteral("version"), WebString::create(pluginModule.versionString));
     1280#endif
     1281
     1282        plugins.uncheckedAppend(ImmutableDictionary::adopt(map));
     1283    }
     1284
     1285    m_client.plugInInformationBecameAvailable(this, ImmutableArray::adopt(plugins).get());
    12821286}
    12831287#endif

  • trunk/Source/WebKit2/UIProcess/WebCookieManagerProxy.cpp

    r149848 r159117  
    108108}
    109109   
    110 void WebCookieManagerProxy::didGetHostnamesWithCookies(const Vector<String>& hostnameList, uint64_t callbackID)
     110void WebCookieManagerProxy::didGetHostnamesWithCookies(const Vector<String>& hostnames, uint64_t callbackID)
    111111{
    112112    RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID);
    … …  
    116116    }
    117117
    118     size_t hostnameCount = hostnameList.size();
    119     Vector<RefPtr<APIObject>> hostnames(hostnameCount);
     118    Vector<RefPtr<APIObject>> hostnameStrings;
     119    hostnameStrings.reserveInitialCapacity(hostnames.size());
    120120
    121     for (size_t i = 0; i < hostnameCount; ++i)
    122         hostnames[i] = WebString::create(hostnameList[i]);
     121    for (const auto& hostname : hostnames)
     122        hostnameStrings.uncheckedAppend(WebString::create(hostname));
    123123
    124     callback->performCallbackWithReturnValue(ImmutableArray::adopt(hostnames).get());
     124    callback->performCallbackWithReturnValue(ImmutableArray::adopt(hostnameStrings).get());
    125125}
    126126

  • trunk/Source/WebKit2/UIProcess/WebDatabaseManagerProxy.cpp

    r149848 r159117  
    157157    }
    158158
    159     size_t originAndDatabasesCount = originAndDatabasesVector.size();
    160     Vector<RefPtr<APIObject>> result(originAndDatabasesCount);
    161 
    162     for (size_t i = 0; i < originAndDatabasesCount; ++i) {
    163         const OriginAndDatabases& originAndDatabases = originAndDatabasesVector[i];
    164    
     159    Vector<RefPtr<APIObject>> result;
     160    result.reserveInitialCapacity(originAndDatabasesVector.size());
     161
     162    for (const auto& originAndDatabases : originAndDatabasesVector) {
    165163        RefPtr<APIObject> origin = WebSecurityOrigin::createFromDatabaseIdentifier(originAndDatabases.originIdentifier);
    166    
    167         size_t databasesCount = originAndDatabases.databases.size();
    168         Vector<RefPtr<APIObject>> databases(databasesCount);
    169    
    170         for (size_t j = 0; j < databasesCount; ++j) {
    171             const DatabaseDetails& details = originAndDatabases.databases[i];
     164
     165        Vector<RefPtr<APIObject>> databases;
     166        databases.reserveInitialCapacity(originAndDatabases.databases.size());
     167
     168        for (const auto& databaseDetails : originAndDatabases.databases) {
    172169            HashMap<String, RefPtr<APIObject>> detailsMap;
    173170
    174             detailsMap.set(databaseDetailsNameKey(), WebString::create(details.name()));
    175             detailsMap.set(databaseDetailsDisplayNameKey(), WebString::create(details.displayName()));
    176             detailsMap.set(databaseDetailsExpectedUsageKey(), WebUInt64::create(details.expectedUsage()));
    177             detailsMap.set(databaseDetailsCurrentUsageKey(), WebUInt64::create(details.currentUsage()));
    178             databases.append(ImmutableDictionary::adopt(detailsMap));
     171            detailsMap.set(databaseDetailsNameKey(), WebString::create(databaseDetails.name()));
     172            detailsMap.set(databaseDetailsDisplayNameKey(), WebString::create(databaseDetails.displayName()));
     173            detailsMap.set(databaseDetailsExpectedUsageKey(), WebUInt64::create(databaseDetails.expectedUsage()));
     174            detailsMap.set(databaseDetailsCurrentUsageKey(), WebUInt64::create(databaseDetails.currentUsage()));
     175
     176            databases.uncheckedAppend(ImmutableDictionary::adopt(detailsMap));
    179177        }
    180178
    … …  
    185183        originAndDatabasesMap.set(databaseDetailsKey(), ImmutableArray::adopt(databases));
    186184
    187         result.append(ImmutableDictionary::adopt(originAndDatabasesMap));
     185        result.uncheckedAppend(ImmutableDictionary::adopt(originAndDatabasesMap));
    188186    }
    189187
    190     RefPtr<ImmutableArray> resultArray = ImmutableArray::adopt(result);
    191     callback->performCallbackWithReturnValue(resultArray.get());
     188    callback->performCallbackWithReturnValue(ImmutableArray::adopt(result).get());
    192189}
    193190
    … …  
    209206    }
    210207
    211     size_t originIdentifiersCount = originIdentifiers.size();
    212     Vector<RefPtr<APIObject>> securityOrigins(originIdentifiersCount);
    213 
    214     for (size_t i = 0; i < originIdentifiersCount; ++i)
    215         securityOrigins[i] = WebSecurityOrigin::createFromDatabaseIdentifier(originIdentifiers[i]);
     208    Vector<RefPtr<APIObject>> securityOrigins;
     209    securityOrigins.reserveInitialCapacity(originIdentifiers.size());
     210
     211    for (const auto& originIdentifier : originIdentifiers)
     212        securityOrigins.uncheckedAppend(WebSecurityOrigin::createFromDatabaseIdentifier(originIdentifier));
    216213
    217214    callback->performCallbackWithReturnValue(ImmutableArray::adopt(securityOrigins).get());

  • trunk/Source/WebKit2/UIProcess/WebMediaCacheManagerProxy.cpp

    r149848 r159117  
    9191}
    9292   
    93 void WebMediaCacheManagerProxy::didGetHostnamesWithMediaCache(const Vector<String>& hostnameList, uint64_t callbackID)
     93void WebMediaCacheManagerProxy::didGetHostnamesWithMediaCache(const Vector<String>& hostnames, uint64_t callbackID)
    9494{
    9595    RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID);
    … …  
    9999    }
    100100
    101     size_t hostnameCount = hostnameList.size();
    102     Vector<RefPtr<APIObject>> hostnames(hostnameCount);
     101    Vector<RefPtr<APIObject>> hostnamesArray;
     102    hostnamesArray.reserveInitialCapacity(hostnames.size());
    103103
    104     for (size_t i = 0; i < hostnameCount; ++i)
    105         hostnames[i] = WebString::create(hostnameList[i]);
     104    for (const auto& hostname : hostnames)
     105        hostnamesArray.uncheckedAppend(WebString::create(hostname));
    106106
    107     callback->performCallbackWithReturnValue(ImmutableArray::adopt(hostnames).get());
     107    callback->performCallbackWithReturnValue(ImmutableArray::adopt(hostnamesArray).get());
    108108}
    109109

  • trunk/Source/WebKit2/UIProcess/WebPageContextMenuClient.cpp

    r149848 r159117  
    9999        return false;
    100100
    101     unsigned size = menuItemsVector.size();
     101    Vector<RefPtr<APIObject>> menuItems;
     102    menuItems.reserveInitialCapacity(menuItemsVector.size());
    102103
    103     Vector<RefPtr<APIObject>> menuItems;
    104     menuItems.reserveCapacity(size);
    105 
    106     for (unsigned i = 0; i < size; ++i)
    107         menuItems.uncheckedAppend(WebContextMenuItem::create(menuItemsVector[i]).get());
     104    for (const auto& menuItem : menuItemsVector)
     105        menuItems.uncheckedAppend(WebContextMenuItem::create(menuItem));
    108106
    109107    m_client.showContextMenu(toAPI(page), toAPI(menuLocation), toAPI(ImmutableArray::adopt(menuItems).get()), m_client.clientInfo);

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r159096 r159117  
    394394
    395395    Vector<RefPtr<APIObject>> result;
    396     result.reserveCapacity(pages.size());
    397     for (size_t i = 0; i < pages.size(); ++i) {
    398         if (pages[i] != this)
    399             result.append(pages[i]);
     396    result.reserveInitialCapacity(pages.size());
     397
     398    for (const auto& page : pages) {
     399        if (page != this)
     400            result.uncheckedAppend(page);
    400401    }
    401402
    … …  
    30403041    matches.reserveInitialCapacity(matchRects.size());
    30413042
    3042     for (size_t i = 0; i < matchRects.size(); ++i) {
    3043         const Vector<WebCore::IntRect>& rects = matchRects[i];
    3044         size_t numRects = matchRects[i].size();
     3043    for (const auto& rects : matchRects) {
    30453044        Vector<RefPtr<APIObject>> apiRects;
    3046         apiRects.reserveInitialCapacity(numRects);
    3047 
    3048         for (size_t i = 0; i < numRects; ++i)
    3049             apiRects.uncheckedAppend(WebRect::create(toAPI(rects[i])));
     3045        apiRects.reserveInitialCapacity(rects.size());
     3046
     3047        for (const auto& rect : rects)
     3048            apiRects.uncheckedAppend(WebRect::create(toAPI(rect)));
     3049
    30503050        matches.uncheckedAppend(ImmutableArray::adopt(apiRects));
    30513051    }
     3052
    30523053    m_findMatchesClient.didFindStringMatches(this, string, ImmutableArray::adopt(matches).get(), firstIndexAfterSelection);
    30533054}

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundle.cpp

    r158360 r159117  
    408408    HashSet<RefPtr<SecurityOrigin>> origins;
    409409    cacheStorage().getOriginsWithCache(origins);
    410     Vector< RefPtr<APIObject>> originsVector;
    411 
    412     HashSet<RefPtr<SecurityOrigin>>::iterator it = origins.begin();
    413     HashSet<RefPtr<SecurityOrigin>>::iterator end = origins.end();
    414     for ( ; it != end; ++it)
    415         originsVector.append(WebString::create((*it)->databaseIdentifier()));
    416 
    417     return ImmutableArray::adopt(originsVector);
     410
     411    Vector<RefPtr<APIObject>> originIdentifiers;
     412    originIdentifiers.reserveInitialCapacity(origins.size());
     413
     414    for (const auto& origin : origins)
     415        originIdentifiers.uncheckedAppend(WebString::create(origin->databaseIdentifier()));
     416
     417    return ImmutableArray::adopt(originIdentifiers);
    418418}
    419419

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundleBackForwardListItem.cpp

    r149848 r159117  
    3535PassRefPtr<ImmutableArray> InjectedBundleBackForwardListItem::children() const
    3636{
    37     const HistoryItemVector& children = m_item->children();
    38     size_t size = children.size();
    39     Vector<RefPtr<APIObject>> vector(size);
    40     for (size_t i = 0; i < size; ++i)
    41         vector[i] = InjectedBundleBackForwardListItem::create(children[i]);
    42     return ImmutableArray::adopt(vector);
     37    Vector<RefPtr<APIObject>> children;
     38    children.reserveInitialCapacity(m_item->children().size());
     39
     40    for (const auto& child : m_item->children())
     41        children.uncheckedAppend(InjectedBundleBackForwardListItem::create(child));
     42
     43    return ImmutableArray::adopt(children);
    4344}
    4445

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundlePageFormClient.cpp

    r150441 r159117  
    131131        return;
    132132
    133     size_t size = elements.size();
     133    Vector<RefPtr<APIObject>> elementHandles;
     134    elementHandles.reserveInitialCapacity(elements.size());
    134135
    135     Vector<RefPtr<APIObject>> elementHandles;
    136     elementHandles.reserveCapacity(size);
    137 
    138     for (size_t i = 0; i < size; ++i)
    139         elementHandles.uncheckedAppend(InjectedBundleNodeHandle::getOrCreate(elements[i].get()).get());
     136    for (const auto& element : elements)
     137        elementHandles.uncheckedAppend(InjectedBundleNodeHandle::getOrCreate(element.get()));
    140138
    141139    m_client.didAssociateFormControls(toAPI(page), toAPI(ImmutableArray::adopt(elementHandles).get()), m_client.clientInfo);

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp

    r156769 r159117  
    342342        return;
    343343
    344     Vector<RefPtr<APIObject>> featureStringObjectsVector;
    345 
    346     Vector<String>::const_iterator end = features.end();
    347     for (Vector<String>::const_iterator it = features.begin(); it != end; ++it)
    348         featureStringObjectsVector.append(WebString::create((*it)));
    349 
    350     RefPtr<ImmutableArray> featureStringObjectsArray = ImmutableArray::adopt(featureStringObjectsVector);
    351 
    352     return m_client.featuresUsedInPage(toAPI(page), toAPI(featureStringObjectsArray.get()), m_client.clientInfo);
     344    Vector<RefPtr<APIObject>> featureStrings;
     345    featureStrings.reserveInitialCapacity(features.size());
     346
     347    for (const auto& feature : features)
     348        featureStrings.uncheckedAppend(WebString::create(feature));
     349
     350    return m_client.featuresUsedInPage(toAPI(page), toAPI(ImmutableArray::adopt(featureStrings).get()), m_client.clientInfo);
    353351}
    354352

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r159001 r159117  
    663663        return ImmutableArray::create();
    664664
    665     const Vector<IntRect>& rects = view->trackedRepaintRects();
    666     size_t size = rects.size();
    667     if (!size)
    668         return ImmutableArray::create();
    669 
    670     Vector<RefPtr<APIObject>> vector;
    671     vector.reserveInitialCapacity(size);
    672 
    673     for (size_t i = 0; i < size; ++i)
    674         vector.uncheckedAppend(WebRect::create(toAPI(rects[i])));
    675 
    676     return ImmutableArray::adopt(vector);
     665    Vector<RefPtr<APIObject>> repaintRects;
     666    repaintRects.reserveInitialCapacity(view->trackedRepaintRects().size());
     667
     668    for (const auto& repaintRect : view->trackedRepaintRects())
     669        repaintRects.uncheckedAppend(WebRect::create(toAPI(repaintRect)));
     670
     671    return ImmutableArray::adopt(repaintRects);
    677672}
    678673
Note: See TracChangeset for help on using the changeset viewer.