Changeset 219231 in webkit


Ignore:
Timestamp:
Jul 6, 2017 7:44:15 PM (7 years ago)
Author:
Chris Dumez
Message:

Drop unused ResourceLoadStatistics members
​https://bugs.webkit.org/show_bug.cgi?id=174226

Reviewed by Brent Fulgham.

Source/WebCore:

  • loader/ResourceLoadObserver.cpp:

(WebCore::ResourceLoadObserver::logFrameNavigation):
(WebCore::ResourceLoadObserver::logSubresourceLoading):
(WebCore::ResourceLoadObserver::logWebSocketLoading):
(WebCore::ResourceLoadObserver::isPrevalentResource): Deleted.

  • loader/ResourceLoadObserver.h:
  • loader/ResourceLoadStatistics.cpp:

(WebCore::ResourceLoadStatistics::encode):
(WebCore::ResourceLoadStatistics::decode):
(WebCore::ResourceLoadStatistics::toString):
(WebCore::ResourceLoadStatistics::merge):

  • loader/ResourceLoadStatistics.h:

Source/WebKit2:

  • Shared/WebCoreArgumentCoders.cpp:

(IPC::ArgumentCoder<ResourceLoadStatistics>::encode):
(IPC::ArgumentCoder<ResourceLoadStatistics>::decode):

  • UIProcess/Storage/ResourceLoadStatisticsStore.cpp:

(WebKit::ResourceLoadStatisticsStore::readDataFromDecoder):

Location:
trunk/Source
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r219230 r219231  
     12017-07-06  Chris Dumez  <cdumez@apple.com>
     2
     3        Drop unused ResourceLoadStatistics members
     4        https://bugs.webkit.org/show_bug.cgi?id=174226
     5
     6        Reviewed by Brent Fulgham.
     7
     8        * loader/ResourceLoadObserver.cpp:
     9        (WebCore::ResourceLoadObserver::logFrameNavigation):
     10        (WebCore::ResourceLoadObserver::logSubresourceLoading):
     11        (WebCore::ResourceLoadObserver::logWebSocketLoading):
     12        (WebCore::ResourceLoadObserver::isPrevalentResource): Deleted.
     13        * loader/ResourceLoadObserver.h:
     14        * loader/ResourceLoadStatistics.cpp:
     15        (WebCore::ResourceLoadStatistics::encode):
     16        (WebCore::ResourceLoadStatistics::decode):
     17        (WebCore::ResourceLoadStatistics::toString):
     18        (WebCore::ResourceLoadStatistics::merge):
     19        * loader/ResourceLoadStatistics.h:
     20
    1212017-07-06  Youenn Fablet  <youenn@apple.com>
    222

  • trunk/Source/WebCore/loader/DocumentLoader.cpp

    r219099 r219231  
    521521    ASSERT(topFrame.document());
    522522
    523     ResourceLoadObserver::shared().logFrameNavigation(*m_frame, topFrame, newRequest, redirectResponse);
     523    ResourceLoadObserver::shared().logFrameNavigation(*m_frame, topFrame, newRequest);
    524524   
    525525    // Update cookie policy base URL as URL changes, except for subframes, which use the

  • trunk/Source/WebCore/loader/ResourceLoadObserver.cpp

    r219207 r219231  
    8080}
    8181
    82 void ResourceLoadObserver::logFrameNavigation(const Frame& frame, const Frame& topFrame, const ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
     82void ResourceLoadObserver::logFrameNavigation(const Frame& frame, const Frame& topFrame, const ResourceRequest& newRequest)
    8383{
    8484    ASSERT(frame.document());
    … …  
    8989        return;
    9090
    91     bool isRedirect = is3xxRedirect(redirectResponse);
    92     bool isMainFrame = frame.isMainFrame();
    9391    auto& sourceURL = frame.document()->url();
    9492    auto& targetURL = newRequest.url();
    … …  
    111109        return;
    112110
    113     auto targetStatistics = takeResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
     111    auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
    114112
    115113    // Always fire if we have previously removed data records for this domain
     114    // FIXME: targetStatistics.dataRecordsRemoved is always 0 in WebCore as it gets populated in the UIProcess.
    116115    bool shouldCallNotificationCallback = targetStatistics.dataRecordsRemoved > 0;
    117116
    118     if (isMainFrame)
    119         targetStatistics.topFrameHasBeenNavigatedToBefore = true;
    120     else {
    121         targetStatistics.subframeHasBeenLoadedBefore = true;
    122 
     117    if (!frame.isMainFrame()) {
    123118        auto subframeUnderTopFrameOriginsResult = targetStatistics.subframeUnderTopFrameOrigins.add(mainFramePrimaryDomain);
    124119        if (subframeUnderTopFrameOriginsResult.isNewEntry)
    125120            shouldCallNotificationCallback = true;
    126121    }
    127 
    128     if (isRedirect) {
    129         auto& redirectingOriginResourceStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
    130 
    131         if (isPrevalentResource(targetPrimaryDomain))
    132             redirectingOriginResourceStatistics.redirectedToOtherPrevalentResourceOrigins.add(targetPrimaryDomain);
    133 
    134         if (isMainFrame) {
    135             ++targetStatistics.topFrameHasBeenRedirectedTo;
    136             ++redirectingOriginResourceStatistics.topFrameHasBeenRedirectedFrom;
    137         } else {
    138             ++targetStatistics.subframeHasBeenRedirectedTo;
    139             ++redirectingOriginResourceStatistics.subframeHasBeenRedirectedFrom;
    140             redirectingOriginResourceStatistics.subframeUniqueRedirectsTo.add(targetPrimaryDomain);
    141 
    142             ++targetStatistics.subframeSubResourceCount;
    143         }
    144     } else {
    145         if (sourcePrimaryDomain.isNull() || sourcePrimaryDomain.isEmpty() || sourcePrimaryDomain == "nullOrigin") {
    146             if (isMainFrame)
    147                 ++targetStatistics.topFrameInitialLoadCount;
    148             else
    149                 ++targetStatistics.subframeSubResourceCount;
    150         } else {
    151             auto& sourceOriginResourceStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
    152 
    153             if (isMainFrame) {
    154                 ++sourceOriginResourceStatistics.topFrameHasBeenNavigatedFrom;
    155                 ++targetStatistics.topFrameHasBeenNavigatedTo;
    156             } else {
    157                 ++sourceOriginResourceStatistics.subframeHasBeenNavigatedFrom;
    158                 ++targetStatistics.subframeHasBeenNavigatedTo;
    159             }
    160         }
    161     }
    162 
    163     m_resourceStatisticsMap.set(targetPrimaryDomain, WTFMove(targetStatistics));
    164122
    165123    if (shouldCallNotificationCallback)
    … …  
    192150        return;
    193151
    194     auto targetStatistics = takeResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
     152    bool shouldCallNotificationCallback = false;
     153
     154    {
     155        auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
     156
     157        // Always fire if we have previously removed data records for this domain
     158        // FIXME: targetStatistics.dataRecordsRemoved is always 0 in WebCore as it gets populated in the UIProcess.
     159        shouldCallNotificationCallback = targetStatistics.dataRecordsRemoved > 0;
     160
     161        auto subresourceUnderTopFrameOriginsResult = targetStatistics.subresourceUnderTopFrameOrigins.add(mainFramePrimaryDomain);
     162        if (subresourceUnderTopFrameOriginsResult.isNewEntry)
     163            shouldCallNotificationCallback = true;
     164    }
     165
     166    if (isRedirect) {
     167        auto& redirectingOriginStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
     168        auto subresourceUniqueRedirectsToResult = redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetPrimaryDomain);
     169        if (subresourceUniqueRedirectsToResult.isNewEntry)
     170            shouldCallNotificationCallback = true;
     171    }
     172
     173    if (shouldCallNotificationCallback)
     174        scheduleNotificationIfNeeded();
     175}
     176
     177void ResourceLoadObserver::logWebSocketLoading(const Frame* frame, const URL& targetURL)
     178{
     179    // FIXME: Web sockets can run in detached frames. Decide how to count such connections.
     180    // See LayoutTests/http/tests/websocket/construct-in-detached-frame.html
     181    if (!frame)
     182        return;
     183
     184    if (!shouldLog(frame->page()))
     185        return;
     186
     187    auto& mainFrameURL = frame->mainFrame().document()->url();
     188
     189    auto targetHost = targetURL.host();
     190    auto mainFrameHost = mainFrameURL.host();
     191   
     192    if (targetHost.isEmpty() || mainFrameHost.isEmpty() || targetHost == mainFrameHost)
     193        return;
     194   
     195    auto targetPrimaryDomain = primaryDomain(targetURL);
     196    auto mainFramePrimaryDomain = primaryDomain(mainFrameURL);
     197   
     198    if (targetPrimaryDomain == mainFramePrimaryDomain)
     199        return;
     200
     201    auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
    195202
    196203    // Always fire if we have previously removed data records for this domain
     204    // FIXME: targetStatistics.dataRecordsRemoved is always 0 in WebCore as it gets populated in the UIProcess.
    197205    bool shouldCallNotificationCallback = targetStatistics.dataRecordsRemoved > 0;
    198206
    … …  
    200208    if (subresourceUnderTopFrameOriginsResult.isNewEntry)
    201209        shouldCallNotificationCallback = true;
    202 
    203     if (isRedirect) {
    204         auto& redirectingOriginStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
    205 
    206         if (isPrevalentResource(targetPrimaryDomain))
    207             redirectingOriginStatistics.redirectedToOtherPrevalentResourceOrigins.add(targetPrimaryDomain);
    208 
    209         ++redirectingOriginStatistics.subresourceHasBeenRedirectedFrom;
    210         ++targetStatistics.subresourceHasBeenRedirectedTo;
    211 
    212         auto subresourceUniqueRedirectsToResult = redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetPrimaryDomain);
    213         if (subresourceUniqueRedirectsToResult.isNewEntry)
    214             shouldCallNotificationCallback = true;
    215 
    216         ++targetStatistics.subresourceHasBeenSubresourceCount;
    217 
    218         auto totalVisited = std::max(m_originsVisitedMap.size(), 1U);
    219 
    220         targetStatistics.subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited = static_cast<double>(targetStatistics.subresourceHasBeenSubresourceCount) / totalVisited;
    221     } else {
    222         ++targetStatistics.subresourceHasBeenSubresourceCount;
    223 
    224         auto totalVisited = std::max(m_originsVisitedMap.size(), 1U);
    225 
    226         targetStatistics.subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited = static_cast<double>(targetStatistics.subresourceHasBeenSubresourceCount) / totalVisited;
    227     }
    228 
    229     m_resourceStatisticsMap.set(targetPrimaryDomain, WTFMove(targetStatistics));
    230 
    231     if (shouldCallNotificationCallback)
    232         scheduleNotificationIfNeeded();
    233 }
    234 
    235 void ResourceLoadObserver::logWebSocketLoading(const Frame* frame, const URL& targetURL)
    236 {
    237     // FIXME: Web sockets can run in detached frames. Decide how to count such connections.
    238     // See LayoutTests/http/tests/websocket/construct-in-detached-frame.html
    239     if (!frame)
    240         return;
    241 
    242     if (!shouldLog(frame->page()))
    243         return;
    244 
    245     auto& mainFrameURL = frame->mainFrame().document()->url();
    246 
    247     auto targetHost = targetURL.host();
    248     auto mainFrameHost = mainFrameURL.host();
    249    
    250     if (targetHost.isEmpty() || mainFrameHost.isEmpty() || targetHost == mainFrameHost)
    251         return;
    252    
    253     auto targetPrimaryDomain = primaryDomain(targetURL);
    254     auto mainFramePrimaryDomain = primaryDomain(mainFrameURL);
    255    
    256     if (targetPrimaryDomain == mainFramePrimaryDomain)
    257         return;
    258 
    259     auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
    260 
    261     // Always fire if we have previously removed data records for this domain
    262     bool shouldCallNotificationCallback = targetStatistics.dataRecordsRemoved > 0;
    263 
    264     auto subresourceUnderTopFrameOriginsResult = targetStatistics.subresourceUnderTopFrameOrigins.add(mainFramePrimaryDomain);
    265     if (subresourceUnderTopFrameOriginsResult.isNewEntry)
    266         shouldCallNotificationCallback = true;
    267 
    268     ++targetStatistics.subresourceHasBeenSubresourceCount;
    269 
    270     auto totalVisited = std::max(m_originsVisitedMap.size(), 1U);
    271 
    272     targetStatistics.subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited = static_cast<double>(targetStatistics.subresourceHasBeenSubresourceCount) / totalVisited;
    273210
    274211    if (shouldCallNotificationCallback)
    … …  
    311248}
    312249
    313 ResourceLoadStatistics ResourceLoadObserver::takeResourceStatisticsForPrimaryDomain(const String& primaryDomain)
    314 {
    315     auto statististics = m_resourceStatisticsMap.take(primaryDomain);
    316     if (statististics.highLevelDomain.isNull())
    317         statististics.highLevelDomain = primaryDomain;
    318     ASSERT(statististics.highLevelDomain == primaryDomain);
    319     return statististics;
    320 }
    321 
    322 bool ResourceLoadObserver::isPrevalentResource(const String& primaryDomain) const
    323 {
    324     auto mapEntry = m_resourceStatisticsMap.find(primaryDomain);
    325     if (mapEntry == m_resourceStatisticsMap.end())
    326         return false;
    327     return mapEntry->value.isPrevalentResource;
    328 }
    329 
    330250void ResourceLoadObserver::scheduleNotificationIfNeeded()
    331251{

  • trunk/Source/WebCore/loader/ResourceLoadObserver.h

    r219207 r219231  
    5252    WEBCORE_EXPORT static ResourceLoadObserver& shared();
    5353   
    54     void logFrameNavigation(const Frame& frame, const Frame& topFrame, const ResourceRequest& newRequest, const ResourceResponse& redirectResponse);
     54    void logFrameNavigation(const Frame&, const Frame& topFrame, const ResourceRequest& newRequest);
    5555    void logSubresourceLoading(const Frame*, const ResourceRequest& newRequest, const ResourceResponse& redirectResponse);
    5656    void logWebSocketLoading(const Frame*, const URL&);
    … …  
    6666    bool shouldLog(Page*) const;
    6767    ResourceLoadStatistics& ensureResourceStatisticsForPrimaryDomain(const String&);
    68     ResourceLoadStatistics takeResourceStatisticsForPrimaryDomain(const String& primaryDomain);
    69     bool isPrevalentResource(const String& primaryDomain) const;
    7068
    7169    void scheduleNotificationIfNeeded();
    … …  
    7674    WTF::Function<void (Vector<ResourceLoadStatistics>&&)> m_notificationCallback;
    7775    Timer m_notificationTimer;
    78     HashMap<String, size_t> m_originsVisitedMap;
    7976};
    8077   

  • trunk/Source/WebCore/loader/ResourceLoadStatistics.cpp

    r219010 r219231  
    5656    encoder.encodeBool("grandfathered", grandfathered);
    5757   
    58     // Top frame stats
    59     encoder.encodeBool("topFrameHasBeenNavigatedToBefore", topFrameHasBeenNavigatedToBefore);
    60     encoder.encodeUInt32("topFrameHasBeenRedirectedTo", topFrameHasBeenRedirectedTo);
    61     encoder.encodeUInt32("topFrameHasBeenRedirectedFrom", topFrameHasBeenRedirectedFrom);
    62     encoder.encodeUInt32("topFrameInitialLoadCount", topFrameInitialLoadCount);
    63     encoder.encodeUInt32("topFrameHasBeenNavigatedTo", topFrameHasBeenNavigatedTo);
    64     encoder.encodeUInt32("topFrameHasBeenNavigatedFrom", topFrameHasBeenNavigatedFrom);
    65    
    66     // Subframe stats
    67     encoder.encodeBool("subframeHasBeenLoadedBefore", subframeHasBeenLoadedBefore);
    68     encoder.encodeUInt32("subframeHasBeenRedirectedTo", subframeHasBeenRedirectedTo);
    69     encoder.encodeUInt32("subframeHasBeenRedirectedFrom", subframeHasBeenRedirectedFrom);
    70     encoder.encodeUInt32("subframeSubResourceCount", subframeSubResourceCount);
     58    // Subframe stats
    7159    encodeHashCountedSet(encoder, "subframeUnderTopFrameOrigins", subframeUnderTopFrameOrigins);
    72     encodeHashCountedSet(encoder, "subframeUniqueRedirectsTo", subframeUniqueRedirectsTo);
    73     encoder.encodeUInt32("subframeHasBeenNavigatedTo", subframeHasBeenNavigatedTo);
    74     encoder.encodeUInt32("subframeHasBeenNavigatedFrom", subframeHasBeenNavigatedFrom);
    75    
    76     // Subresource stats
    77     encoder.encodeUInt32("subresourceHasBeenRedirectedFrom", subresourceHasBeenRedirectedFrom);
    78     encoder.encodeUInt32("subresourceHasBeenRedirectedTo", subresourceHasBeenRedirectedTo);
    79     encoder.encodeUInt32("subresourceHasBeenSubresourceCount", subresourceHasBeenSubresourceCount);
    80     encoder.encodeDouble("subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited", subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited);
     60   
     61    // Subresource stats
    8162    encodeHashCountedSet(encoder, "subresourceUnderTopFrameOrigins", subresourceUnderTopFrameOrigins);
    8263    encodeHashCountedSet(encoder, "subresourceUniqueRedirectsTo", subresourceUniqueRedirectsTo);
    8364   
    8465    // Prevalent Resource
    85     encodeHashCountedSet(encoder, "redirectedToOtherPrevalentResourceOrigins", redirectedToOtherPrevalentResourceOrigins);
    8666    encoder.encodeBool("isPrevalentResource", isPrevalentResource);
    8767    encoder.encodeUInt32("dataRecordsRemoved", dataRecordsRemoved);
    … …  
    10484}
    10585
    106 bool ResourceLoadStatistics::decode(KeyedDecoder& decoder, unsigned version)
     86bool ResourceLoadStatistics::decode(KeyedDecoder& decoder)
    10787{
    10888    if (!decoder.decodeString("PrevalentResourceOrigin", highLevelDomain))
    … …  
    11393        return false;
    11494   
    115     // Top frame stats
    116     if (!decoder.decodeBool("topFrameHasBeenNavigatedToBefore", topFrameHasBeenNavigatedToBefore))
    117         return false;
    118    
    119     if (!decoder.decodeUInt32("topFrameHasBeenRedirectedTo", topFrameHasBeenRedirectedTo))
    120         return false;
    121    
    122     if (!decoder.decodeUInt32("topFrameHasBeenRedirectedFrom", topFrameHasBeenRedirectedFrom))
    123         return false;
    124    
    125     if (!decoder.decodeUInt32("topFrameInitialLoadCount", topFrameInitialLoadCount))
    126         return false;
    127    
    128     if (!decoder.decodeUInt32("topFrameHasBeenNavigatedTo", topFrameHasBeenNavigatedTo))
    129         return false;
    130    
    131     if (!decoder.decodeUInt32("topFrameHasBeenNavigatedFrom", topFrameHasBeenNavigatedFrom))
    132         return false;
    133    
    134     // Subframe stats
    135     if (!decoder.decodeBool("subframeHasBeenLoadedBefore", subframeHasBeenLoadedBefore))
    136         return false;
    137    
    138     if (!decoder.decodeUInt32("subframeHasBeenRedirectedTo", subframeHasBeenRedirectedTo))
    139         return false;
    140    
    141     if (!decoder.decodeUInt32("subframeHasBeenRedirectedFrom", subframeHasBeenRedirectedFrom))
    142         return false;
    143    
    144     if (!decoder.decodeUInt32("subframeSubResourceCount", subframeSubResourceCount))
    145         return false;
    146 
     95    // Subframe stats
    14796    decodeHashCountedSet(decoder, "subframeUnderTopFrameOrigins", subframeUnderTopFrameOrigins);
    148     decodeHashCountedSet(decoder, "subframeUniqueRedirectsTo", subframeUniqueRedirectsTo);
    149    
    150     if (!decoder.decodeUInt32("subframeHasBeenNavigatedTo", subframeHasBeenNavigatedTo))
    151         return false;
    152    
    153     if (!decoder.decodeUInt32("subframeHasBeenNavigatedFrom", subframeHasBeenNavigatedFrom))
    154         return false;
    155    
    156     // Subresource stats
    157     if (!decoder.decodeUInt32("subresourceHasBeenRedirectedFrom", subresourceHasBeenRedirectedFrom))
    158         return false;
    159    
    160     if (!decoder.decodeUInt32("subresourceHasBeenRedirectedTo", subresourceHasBeenRedirectedTo))
    161         return false;
    162    
    163     if (!decoder.decodeUInt32("subresourceHasBeenSubresourceCount", subresourceHasBeenSubresourceCount))
    164         return false;
    165    
    166     if (!decoder.decodeDouble("subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited", subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited))
    167         return false;
    168 
     97   
     98    // Subresource stats
    16999    decodeHashCountedSet(decoder, "subresourceUnderTopFrameOrigins", subresourceUnderTopFrameOrigins);
    170100    decodeHashCountedSet(decoder, "subresourceUniqueRedirectsTo", subresourceUniqueRedirectsTo);
    171101   
    172102    // Prevalent Resource
    173     decodeHashCountedSet(decoder, "redirectedToOtherPrevalentResourceOrigins", redirectedToOtherPrevalentResourceOrigins);
    174    
    175103    if (!decoder.decodeBool("isPrevalentResource", isPrevalentResource))
    176104        return false;
    177105
    178     if (version < 2)
    179         return true;
    180 
    181106    if (!decoder.decodeUInt32("dataRecordsRemoved", dataRecordsRemoved))
    182107        return false;
    183 
    184     if (version < 3)
    185         return true;
    186108
    187109    double mostRecentUserInteractionTimeAsDouble;
    … …  
    235157    builder.append('\n');
    236158   
    237     // Top frame stats
    238     appendBoolean(builder, "topFrameHasBeenNavigatedToBefore", topFrameHasBeenNavigatedToBefore);
    239     builder.append('\n');
    240     builder.appendLiteral("    topFrameHasBeenRedirectedTo: ");
    241     builder.appendNumber(topFrameHasBeenRedirectedTo);
    242     builder.append('\n');
    243     builder.appendLiteral("    topFrameHasBeenRedirectedFrom: ");
    244     builder.appendNumber(topFrameHasBeenRedirectedFrom);
    245     builder.append('\n');
    246     builder.appendLiteral("    topFrameInitialLoadCount: ");
    247     builder.appendNumber(topFrameInitialLoadCount);
    248     builder.append('\n');
    249     builder.appendLiteral("    topFrameHasBeenNavigatedTo: ");
    250     builder.appendNumber(topFrameHasBeenNavigatedTo);
    251     builder.append('\n');
    252     builder.appendLiteral("    topFrameHasBeenNavigatedFrom: ");
    253     builder.appendNumber(topFrameHasBeenNavigatedFrom);
    254     builder.append('\n');
    255    
    256     // Subframe stats
    257     appendBoolean(builder, "subframeHasBeenLoadedBefore", subframeHasBeenLoadedBefore);
    258     builder.append('\n');
    259     builder.appendLiteral("    subframeHasBeenRedirectedTo: ");
    260     builder.appendNumber(subframeHasBeenRedirectedTo);
    261     builder.append('\n');
    262     builder.appendLiteral("    subframeHasBeenRedirectedFrom: ");
    263     builder.appendNumber(subframeHasBeenRedirectedFrom);
    264     builder.append('\n');
    265     builder.appendLiteral("    subframeSubResourceCount: ");
    266     builder.appendNumber(subframeSubResourceCount);
    267     builder.append('\n');
     159    // Subframe stats
    268160    appendHashCountedSet(builder, "subframeUnderTopFrameOrigins", subframeUnderTopFrameOrigins);
    269     appendHashCountedSet(builder, "subframeUniqueRedirectsTo", subframeUniqueRedirectsTo);
    270     builder.appendLiteral("    subframeHasBeenNavigatedTo: ");
    271     builder.appendNumber(subframeHasBeenNavigatedTo);
    272     builder.append('\n');
    273     builder.appendLiteral("    subframeHasBeenNavigatedFrom: ");
    274     builder.appendNumber(subframeHasBeenNavigatedFrom);
    275     builder.append('\n');
    276    
    277     // Subresource stats
    278     builder.appendLiteral("    subresourceHasBeenRedirectedFrom: ");
    279     builder.appendNumber(subresourceHasBeenRedirectedFrom);
    280     builder.append('\n');
    281     builder.appendLiteral("    subresourceHasBeenRedirectedTo: ");
    282     builder.appendNumber(subresourceHasBeenRedirectedTo);
    283     builder.append('\n');
    284     builder.appendLiteral("    subresourceHasBeenSubresourceCount: ");
    285     builder.appendNumber(subresourceHasBeenSubresourceCount);
    286     builder.append('\n');
    287     builder.appendLiteral("    subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited: ");
    288     builder.appendNumber(subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited);
    289     builder.append('\n');
     161   
     162    // Subresource stats
    290163    appendHashCountedSet(builder, "subresourceUnderTopFrameOrigins", subresourceUnderTopFrameOrigins);
    291164    appendHashCountedSet(builder, "subresourceUniqueRedirectsTo", subresourceUniqueRedirectsTo);
    292165   
    293166    // Prevalent Resource
    294     appendHashCountedSet(builder, "redirectedToOtherPrevalentResourceOrigins", redirectedToOtherPrevalentResourceOrigins);
    295167    appendBoolean(builder, "isPrevalentResource", isPrevalentResource);
    296168    builder.appendLiteral("    dataRecordsRemoved: ");
    … …  
    332204    grandfathered |= other.grandfathered;
    333205   
    334     // Top frame stats
    335     topFrameHasBeenRedirectedTo += other.topFrameHasBeenRedirectedTo;
    336     topFrameHasBeenRedirectedFrom += other.topFrameHasBeenRedirectedFrom;
    337     topFrameInitialLoadCount += other.topFrameInitialLoadCount;
    338     topFrameHasBeenNavigatedTo += other.topFrameHasBeenNavigatedTo;
    339     topFrameHasBeenNavigatedFrom += other.topFrameHasBeenNavigatedFrom;
    340     topFrameHasBeenNavigatedToBefore |= other.topFrameHasBeenNavigatedToBefore;
    341    
    342206    // Subframe stats
    343207    mergeHashCountedSet(subframeUnderTopFrameOrigins, other.subframeUnderTopFrameOrigins);
    344     subframeHasBeenRedirectedTo += other.subframeHasBeenRedirectedTo;
    345     subframeHasBeenRedirectedFrom += other.subframeHasBeenRedirectedFrom;
    346     mergeHashCountedSet(subframeUniqueRedirectsTo, other.subframeUniqueRedirectsTo);
    347     subframeSubResourceCount += other.subframeSubResourceCount;
    348     subframeHasBeenNavigatedTo += other.subframeHasBeenNavigatedTo;
    349     subframeHasBeenNavigatedFrom += other.subframeHasBeenNavigatedFrom;
    350     subframeHasBeenLoadedBefore |= other.subframeHasBeenLoadedBefore;
    351208   
    352209    // Subresource stats
    353210    mergeHashCountedSet(subresourceUnderTopFrameOrigins, other.subresourceUnderTopFrameOrigins);
    354     subresourceHasBeenSubresourceCount += other.subresourceHasBeenSubresourceCount;
    355     subresourceHasBeenRedirectedFrom += other.subresourceHasBeenRedirectedFrom;
    356     subresourceHasBeenRedirectedTo += other.subresourceHasBeenRedirectedTo;
    357211    mergeHashCountedSet(subresourceUniqueRedirectsTo, other.subresourceUniqueRedirectsTo);
    358212   
    359213    // Prevalent resource stats
    360     mergeHashCountedSet(redirectedToOtherPrevalentResourceOrigins, other.redirectedToOtherPrevalentResourceOrigins);
    361214    isPrevalentResource |= other.isPrevalentResource;
    362215    dataRecordsRemoved += other.dataRecordsRemoved;

  • trunk/Source/WebCore/loader/ResourceLoadStatistics.h

    r219010 r219231  
    5454
    5555    WEBCORE_EXPORT void encode(KeyedEncoder&) const;
    56     WEBCORE_EXPORT bool decode(KeyedDecoder&, unsigned version);
     56    WEBCORE_EXPORT bool decode(KeyedDecoder&);
    5757
    5858    String toString() const;
    … …  
    6767    WallTime mostRecentUserInteractionTime { WallTime::fromRawSeconds(-1) };
    6868    bool grandfathered { false };
    69 
    70     // Top frame stats
    71     unsigned topFrameHasBeenRedirectedTo { 0 };
    72     unsigned topFrameHasBeenRedirectedFrom { 0 };
    73     unsigned topFrameInitialLoadCount { 0 };
    74     unsigned topFrameHasBeenNavigatedTo { 0 };
    75     unsigned topFrameHasBeenNavigatedFrom { 0 };
    76     bool topFrameHasBeenNavigatedToBefore { false };
    7769   
    7870    // Subframe stats
    7971    HashCountedSet<String> subframeUnderTopFrameOrigins;
    80     unsigned subframeHasBeenRedirectedTo { 0 };
    81     unsigned subframeHasBeenRedirectedFrom { 0 };
    82     HashCountedSet<String> subframeUniqueRedirectsTo;
    83     unsigned subframeSubResourceCount { 0 };
    84     unsigned subframeHasBeenNavigatedTo { 0 };
    85     unsigned subframeHasBeenNavigatedFrom { 0 };
    86     bool subframeHasBeenLoadedBefore { false };
    8772   
    8873    // Subresource stats
    8974    HashCountedSet<String> subresourceUnderTopFrameOrigins;
    90     unsigned subresourceHasBeenSubresourceCount { 0 };
    91     double subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited { 0.0 };
    92     unsigned subresourceHasBeenRedirectedFrom { 0 };
    93     unsigned subresourceHasBeenRedirectedTo { 0 };
    9475    HashCountedSet<String> subresourceUniqueRedirectsTo;
    9576   
    9677    // Prevalent resource stats
    97     HashCountedSet<String> redirectedToOtherPrevalentResourceOrigins;
    9878    bool isPrevalentResource { false };
    9979    unsigned dataRecordsRemoved { 0 };

  • trunk/Source/WebKit2/ChangeLog

    r219225 r219231  
     12017-07-06  Chris Dumez  <cdumez@apple.com>
     2
     3        Drop unused ResourceLoadStatistics members
     4        https://bugs.webkit.org/show_bug.cgi?id=174226
     5
     6        Reviewed by Brent Fulgham.
     7
     8        * Shared/WebCoreArgumentCoders.cpp:
     9        (IPC::ArgumentCoder<ResourceLoadStatistics>::encode):
     10        (IPC::ArgumentCoder<ResourceLoadStatistics>::decode):
     11        * UIProcess/Storage/ResourceLoadStatisticsStore.cpp:
     12        (WebKit::ResourceLoadStatisticsStore::readDataFromDecoder):
     13
    1142017-07-06  Wenson Hsieh  <wenson_hsieh@apple.com>
    215

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

    r218953 r219231  
    22482248    encoder << statistics.grandfathered;
    22492249   
    2250     // Top frame stats
    2251     encoder << statistics.topFrameHasBeenNavigatedToBefore;
    2252     encoder << statistics.topFrameHasBeenRedirectedTo;
    2253     encoder << statistics.topFrameHasBeenRedirectedFrom;
    2254     encoder << statistics.topFrameInitialLoadCount;
    2255     encoder << statistics.topFrameHasBeenNavigatedTo;
    2256     encoder << statistics.topFrameHasBeenNavigatedFrom;
    2257    
    22582250    // Subframe stats
    2259     encoder << statistics.subframeHasBeenLoadedBefore;
    2260     encoder << statistics.subframeHasBeenRedirectedTo;
    2261     encoder << statistics.subframeHasBeenRedirectedFrom;
    2262     encoder << statistics.subframeSubResourceCount;
    22632251    encoder << statistics.subframeUnderTopFrameOrigins;
    2264     encoder << statistics.subframeUniqueRedirectsTo;
    2265     encoder << statistics.subframeHasBeenNavigatedTo;
    2266     encoder << statistics.subframeHasBeenNavigatedFrom;
    22672252   
    22682253    // Subresource stats
    2269     encoder << statistics.subresourceHasBeenRedirectedFrom;
    2270     encoder << statistics.subresourceHasBeenRedirectedTo;
    2271     encoder << statistics.subresourceHasBeenSubresourceCount;
    2272     encoder << statistics.subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited;
    22732254    encoder << statistics.subresourceUnderTopFrameOrigins;
    22742255    encoder << statistics.subresourceUniqueRedirectsTo;
    22752256   
    22762257    // Prevalent Resource
    2277     encoder << statistics.redirectedToOtherPrevalentResourceOrigins;
    22782258    encoder << statistics.isPrevalentResource;
    22792259    encoder << statistics.dataRecordsRemoved;
    … …  
    22972277        return false;
    22982278   
    2299     // Top frame stats
    2300     if (!decoder.decode(statistics.topFrameHasBeenNavigatedToBefore))
    2301         return false;
    2302    
    2303     if (!decoder.decode(statistics.topFrameHasBeenRedirectedTo))
    2304         return false;
    2305    
    2306     if (!decoder.decode(statistics.topFrameHasBeenRedirectedFrom))
    2307         return false;
    2308    
    2309     if (!decoder.decode(statistics.topFrameInitialLoadCount))
    2310         return false;
    2311    
    2312     if (!decoder.decode(statistics.topFrameHasBeenNavigatedTo))
    2313         return false;
    2314    
    2315     if (!decoder.decode(statistics.topFrameHasBeenNavigatedFrom))
    2316         return false;
    2317    
    23182279    // Subframe stats
    2319     if (!decoder.decode(statistics.subframeHasBeenLoadedBefore))
    2320         return false;
    2321    
    2322     if (!decoder.decode(statistics.subframeHasBeenRedirectedTo))
    2323         return false;
    2324    
    2325     if (!decoder.decode(statistics.subframeHasBeenRedirectedFrom))
    2326         return false;
    2327    
    2328     if (!decoder.decode(statistics.subframeSubResourceCount))
    2329         return false;
    2330    
    23312280    if (!decoder.decode(statistics.subframeUnderTopFrameOrigins))
    23322281        return false;
    2333 
    2334     if (!decoder.decode(statistics.subframeUniqueRedirectsTo))
    2335         return false;
    2336    
    2337     if (!decoder.decode(statistics.subframeHasBeenNavigatedTo))
    2338         return false;
    2339    
    2340     if (!decoder.decode(statistics.subframeHasBeenNavigatedFrom))
    2341         return false;
    23422282   
    23432283    // Subresource stats
    2344     if (!decoder.decode(statistics.subresourceHasBeenRedirectedFrom))
    2345         return false;
    2346    
    2347     if (!decoder.decode(statistics.subresourceHasBeenRedirectedTo))
    2348         return false;
    2349    
    2350     if (!decoder.decode(statistics.subresourceHasBeenSubresourceCount))
    2351         return false;
    2352    
    2353     if (!decoder.decode(statistics.subresourceHasBeenSubresourceCountDividedByTotalNumberOfOriginsVisited))
    2354         return false;
    2355    
    23562284    if (!decoder.decode(statistics.subresourceUnderTopFrameOrigins))
    23572285        return false;
    … …  
    23612289   
    23622290    // Prevalent Resource
    2363     if (!decoder.decode(statistics.redirectedToOtherPrevalentResourceOrigins))
    2364         return false;
    2365    
    23662291    if (!decoder.decode(statistics.isPrevalentResource))
    23672292        return false;

  • trunk/Source/WebKit2/UIProcess/Storage/ResourceLoadStatisticsStore.cpp

    r219220 r219231  
    4040using namespace WebCore;
    4141
    42 static const auto statisticsModelVersion = 4;
     42static const auto statisticsModelVersion = 5;
    4343static Seconds timeToLiveUserInteraction { 24_h * 30. };
    4444static Seconds timeToLiveCookiePartitionFree { 24_h };
    … …  
    103103        return;
    104104
    105     unsigned version;
    106     if (!decoder.decodeUInt32("version", version))
    107         version = 1;
    108 
    109     static const auto minimumVersionWithGrandfathering = 3;
    110     if (version > minimumVersionWithGrandfathering) {
    111         double endOfGrandfatheringTimestamp;
    112         if (decoder.decodeDouble("endOfGrandfatheringTimestamp", endOfGrandfatheringTimestamp))
    113             m_endOfGrandfatheringTimestamp = WallTime::fromRawSeconds(endOfGrandfatheringTimestamp);
    114         else
    115             m_endOfGrandfatheringTimestamp = { };
    116     }
     105    unsigned versionOnDisk;
     106    if (!decoder.decodeUInt32("version", versionOnDisk))
     107        return;
     108
     109    if (versionOnDisk != statisticsModelVersion)
     110        return;
     111
     112    double endOfGrandfatheringTimestamp;
     113    if (decoder.decodeDouble("endOfGrandfatheringTimestamp", endOfGrandfatheringTimestamp))
     114        m_endOfGrandfatheringTimestamp = WallTime::fromRawSeconds(endOfGrandfatheringTimestamp);
     115    else
     116        m_endOfGrandfatheringTimestamp = { };
    117117
    118118    Vector<ResourceLoadStatistics> loadedStatistics;
    119     bool succeeded = decoder.decodeObjects("browsingStatistics", loadedStatistics, [version](KeyedDecoder& decoderInner, ResourceLoadStatistics& statistics) {
    120         return statistics.decode(decoderInner, version);
     119    bool succeeded = decoder.decodeObjects("browsingStatistics", loadedStatistics, [](KeyedDecoder& decoderInner, ResourceLoadStatistics& statistics) {
     120        return statistics.decode(decoderInner);
    121121    });
    122122
Note: See TracChangeset for help on using the changeset viewer.