Changeset 136565 in webkit


Ignore:
Timestamp:
Dec 4, 2012 2:04:41 PM (11 years ago)
Author:
simonjam@chromium.org
Message:

[User Timing] Fix clang build by removing need for exit time destructor
​https://bugs.webkit.org/show_bug.cgi?id=104036

Reviewed by Tony Gentilcore.

Modeled after r99588.

No new tests. No change in functionality.

  • page/PerformanceUserTiming.cpp:

(WebCore::UserTiming::UserTiming):
(WebCore::UserTiming::mark):
(WebCore::UserTiming::findExistingMarkStartTime):

  • page/PerformanceUserTiming.h:

(UserTiming):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r136561 r136565  
     12012-12-04  James Simonsen  <simonjam@chromium.org>
     2
     3        [User Timing] Fix clang build by removing need for exit time destructor
     4        https://bugs.webkit.org/show_bug.cgi?id=104036
     5
     6        Reviewed by Tony Gentilcore.
     7
     8        Modeled after r99588.
     9
     10        No new tests. No change in functionality.
     11
     12        * page/PerformanceUserTiming.cpp:
     13        (WebCore::UserTiming::UserTiming):
     14        (WebCore::UserTiming::mark):
     15        (WebCore::UserTiming::findExistingMarkStartTime):
     16        * page/PerformanceUserTiming.h:
     17        (UserTiming):
     18
    1192012-12-04  James Simonsen  <simonjam@chromium.org>
    220

  • trunk/Source/WebCore/page/PerformanceUserTiming.cpp

    r136561 r136565  
    3737namespace WebCore {
    3838
    39 HashMap<String, NavigationTimingFunction> UserTiming::m_restrictedKeyMap;
     39namespace {
     40
     41typedef HashMap<String, NavigationTimingFunction> RestrictedKeyMap;
     42static RestrictedKeyMap restrictedKeyMap()
     43{
     44    DEFINE_STATIC_LOCAL(RestrictedKeyMap, map, ());
     45    if (map.isEmpty()) {
     46        map.add("navigationStart", &PerformanceTiming::navigationStart);
     47        map.add("unloadEventStart", &PerformanceTiming::unloadEventStart);
     48        map.add("unloadEventEnd", &PerformanceTiming::unloadEventEnd);
     49        map.add("redirectStart", &PerformanceTiming::redirectStart);
     50        map.add("redirectEnd", &PerformanceTiming::redirectEnd);
     51        map.add("fetchStart", &PerformanceTiming::fetchStart);
     52        map.add("domainLookupStart", &PerformanceTiming::domainLookupStart);
     53        map.add("domainLookupEnd", &PerformanceTiming::domainLookupEnd);
     54        map.add("connectStart", &PerformanceTiming::connectStart);
     55        map.add("connectEnd", &PerformanceTiming::connectEnd);
     56        map.add("secureConnectionStart", &PerformanceTiming::secureConnectionStart);
     57        map.add("requestStart", &PerformanceTiming::requestStart);
     58        map.add("responseStart", &PerformanceTiming::responseStart);
     59        map.add("responseEnd", &PerformanceTiming::responseEnd);
     60        map.add("domLoading", &PerformanceTiming::domLoading);
     61        map.add("domInteractive", &PerformanceTiming::domInteractive);
     62        map.add("domContentLoadedEventStart", &PerformanceTiming::domContentLoadedEventStart);
     63        map.add("domContentLoadedEventEnd", &PerformanceTiming::domContentLoadedEventEnd);
     64        map.add("domComplete", &PerformanceTiming::domComplete);
     65        map.add("loadEventStart", &PerformanceTiming::loadEventStart);
     66        map.add("loadEventEnd", &PerformanceTiming::loadEventEnd);
     67    }
     68    return map;
     69}
     70
     71} // namespace anonymous
    4072
    4173UserTiming::UserTiming(Performance* performance)
    4274    : m_performance(performance)
    4375{
    44     static const struct RestrictedField {
    45         String key;
    46         NavigationTimingFunction navigationTimingFunction;
    47     } defaultRestrictions[] = {
    48         {"navigationStart", &PerformanceTiming::navigationStart},
    49         {"unloadEventStart", &PerformanceTiming::unloadEventStart},
    50         {"unloadEventEnd", &PerformanceTiming::unloadEventEnd},
    51         {"redirectStart", &PerformanceTiming::redirectStart},
    52         {"redirectEnd", &PerformanceTiming::redirectEnd},
    53         {"fetchStart", &PerformanceTiming::fetchStart},
    54         {"domainLookupStart", &PerformanceTiming::domainLookupStart},
    55         {"domainLookupEnd", &PerformanceTiming::domainLookupEnd},
    56         {"connectStart", &PerformanceTiming::connectStart},
    57         {"connectEnd", &PerformanceTiming::connectEnd},
    58         {"secureConnectionStart", &PerformanceTiming::secureConnectionStart},
    59         {"requestStart", &PerformanceTiming::requestStart},
    60         {"responseStart", &PerformanceTiming::responseStart},
    61         {"responseEnd", &PerformanceTiming::responseEnd},
    62         {"domLoading", &PerformanceTiming::domLoading},
    63         {"domInteractive", &PerformanceTiming::domInteractive},
    64         {"domContentLoadedEventStart", &PerformanceTiming::domContentLoadedEventStart},
    65         {"domContentLoadedEventEnd", &PerformanceTiming::domContentLoadedEventEnd},
    66         {"domComplete", &PerformanceTiming::domComplete},
    67         {"loadEventStart", &PerformanceTiming::loadEventStart},
    68         {"loadEventEnd", &PerformanceTiming::loadEventEnd}
    69     };
    70 
    71     if (!m_restrictedKeyMap.isEmpty())
    72         return;
    73 
    74     for (const struct RestrictedField* restriction = defaultRestrictions;
    75         static_cast<unsigned>(restriction - defaultRestrictions) < ARRAY_SIZE(defaultRestrictions);
    76         ++restriction) {
    77         m_restrictedKeyMap.add(restriction->key, restriction->navigationTimingFunction);
    78     }
    7976}
    8077
    … …  
    106103{
    107104    ec = 0;
    108     if (m_restrictedKeyMap.contains(markName)) {
     105    if (restrictedKeyMap().contains(markName)) {
    109106        ec = SYNTAX_ERR;
    110107        return;
    … …  
    127124        return m_marksMap.get(markName).last()->startTime();
    128125
    129     if (m_restrictedKeyMap.contains(markName))
    130         return static_cast<double>((m_performance->timing()->*(m_restrictedKeyMap.get(markName)))()) - m_performance->timing()->navigationStart();
     126    if (restrictedKeyMap().contains(markName))
     127        return static_cast<double>((m_performance->timing()->*(restrictedKeyMap().get(markName)))()) - m_performance->timing()->navigationStart();
    131128
    132129    ec = SYNTAX_ERR;

  • trunk/Source/WebCore/page/PerformanceUserTiming.h

    r132147 r136565  
    5050public:
    5151    static PassRefPtr<UserTiming> create(Performance* performance) { return adoptRef(new UserTiming(performance)); }
     52
    5253    void mark(const String& markName, ExceptionCode&);
    5354    void clearMarks(const String& markName);
    … …  
    6465private:
    6566    explicit UserTiming(Performance*);
    66     static HashMap<String, NavigationTimingFunction> m_restrictedKeyMap;
    67    
     67
    6868    double findExistingMarkStartTime(const String& markName, ExceptionCode&);
    6969    Performance* m_performance;
Note: See TracChangeset for help on using the changeset viewer.