Changeset 140655 in webkit


Ignore:
Timestamp:
Jan 23, 2013, 10:08:03 PM (12 years ago)
Author:
tkent@chromium.org
Message:

Add form-related instrumentations, and support 33+ features in FeatureObserver
​https://bugs.webkit.org/show_bug.cgi?id=107770

Reviewed by Kentaro Hara.

No new tests. This doesn't make behavior changes.

  • page/FeatureObserver.h:
  • Add form-related features.
  • Add a Document* version of observe().
  • Use BitVector to represent features to support 33+ features.

(WebCore::FeatureObserver::didObserve):
(FeatureObserver):

  • page/FeatureObserver.cpp:

(WebCore::FeatureObserver::FeatureObserver):
(WebCore::FeatureObserver::~FeatureObserver):
(WebCore::FeatureObserver::observe):

  • html/ColorInputType.cpp:

(WebCore::ColorInputType::create): Calls FeatureObserver::observe.

  • html/DateInputType.cpp:

(WebCore::DateInputType::create): Ditto.

  • html/DateTimeInputType.cpp:

(WebCore::DateTimeInputType::create): Ditto.

  • html/DateTimeLocalInputType.cpp:

(WebCore::DateTimeLocalInputType::create): Ditto.

  • html/EmailInputType.cpp:

(WebCore::EmailInputType::create): Ditto.

  • html/HTMLDataListElement.cpp:

(WebCore::HTMLDataListElement::create): Ditto.

  • html/HTMLFormControlElement.cpp:

(WebCore::HTMLFormControlElement::parseAttribute): Ditto.

  • html/HTMLInputElement.cpp:

(WebCore::HTMLInputElement::parseAttribute): Ditto.

  • html/HTMLTextFormControlElement.cpp:

(WebCore::HTMLTextFormControlElement::parseAttribute): Ditto.

  • html/InputType.cpp:

(WebCore::InputType::create):
Record type=datetime and type=week even if these types are not enabled.

  • html/MonthInputType.cpp:

(WebCore::MonthInputType::create): Calls FeatureObserver::observe.

  • html/NumberInputType.cpp:

(WebCore::NumberInputType::create): Ditto.

  • html/RangeInputType.cpp:

(WebCore::RangeInputType::create): Ditto.

  • html/SearchInputType.cpp:

(WebCore::SearchInputType::create): Ditto.

  • html/TelephoneInputType.cpp:

(WebCore::TelephoneInputType::create): Ditto.

  • html/TimeInputType.cpp:

(WebCore::TimeInputType::create): Ditto.

  • html/URLInputType.cpp:

(WebCore::URLInputType::create): Ditto.

  • html/WeekInputType.cpp:

(WebCore::WeekInputType::create): Ditto.

Location:
trunk/Source/WebCore
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r140649 r140655  
     12013-01-23  Kent Tamura  <tkent@chromium.org>
     2
     3        Add form-related instrumentations, and support 33+ features in FeatureObserver
     4        https://bugs.webkit.org/show_bug.cgi?id=107770
     5
     6        Reviewed by Kentaro Hara.
     7
     8        No new tests. This doesn't make behavior changes.
     9
     10        * page/FeatureObserver.h:
     11        - Add form-related features.
     12        - Add a Document* version of observe().
     13        - Use BitVector to represent features to support 33+ features.
     14        (WebCore::FeatureObserver::didObserve):
     15        (FeatureObserver):
     16        * page/FeatureObserver.cpp:
     17        (WebCore::FeatureObserver::FeatureObserver):
     18        (WebCore::FeatureObserver::~FeatureObserver):
     19        (WebCore::FeatureObserver::observe):
     20
     21        * html/ColorInputType.cpp:
     22        (WebCore::ColorInputType::create): Calls FeatureObserver::observe.
     23        * html/DateInputType.cpp:
     24        (WebCore::DateInputType::create): Ditto.
     25        * html/DateTimeInputType.cpp:
     26        (WebCore::DateTimeInputType::create): Ditto.
     27        * html/DateTimeLocalInputType.cpp:
     28        (WebCore::DateTimeLocalInputType::create): Ditto.
     29        * html/EmailInputType.cpp:
     30        (WebCore::EmailInputType::create): Ditto.
     31        * html/HTMLDataListElement.cpp:
     32        (WebCore::HTMLDataListElement::create): Ditto.
     33        * html/HTMLFormControlElement.cpp:
     34        (WebCore::HTMLFormControlElement::parseAttribute): Ditto.
     35        * html/HTMLInputElement.cpp:
     36        (WebCore::HTMLInputElement::parseAttribute): Ditto.
     37        * html/HTMLTextFormControlElement.cpp:
     38        (WebCore::HTMLTextFormControlElement::parseAttribute): Ditto.
     39        * html/InputType.cpp:
     40        (WebCore::InputType::create):
     41        Record type=datetime and type=week even if these types are not enabled.
     42        * html/MonthInputType.cpp:
     43        (WebCore::MonthInputType::create): Calls FeatureObserver::observe.
     44        * html/NumberInputType.cpp:
     45        (WebCore::NumberInputType::create): Ditto.
     46        * html/RangeInputType.cpp:
     47        (WebCore::RangeInputType::create): Ditto.
     48        * html/SearchInputType.cpp:
     49        (WebCore::SearchInputType::create): Ditto.
     50        * html/TelephoneInputType.cpp:
     51        (WebCore::TelephoneInputType::create): Ditto.
     52        * html/TimeInputType.cpp:
     53        (WebCore::TimeInputType::create): Ditto.
     54        * html/URLInputType.cpp:
     55        (WebCore::URLInputType::create): Ditto.
     56        * html/WeekInputType.cpp:
     57        (WebCore::WeekInputType::create): Ditto.
     58
    1592013-01-23  Ken Kania  <kkania@chromium.org>
    260

  • trunk/Source/WebCore/html/ColorInputType.cpp

    r137124 r140655  
    3636#include "Color.h"
    3737#include "ElementShadow.h"
     38#include "FeatureObserver.h"
    3839#include "HTMLDataListElement.h"
    3940#include "HTMLDivElement.h"
    … …  
    7273PassOwnPtr<InputType> ColorInputType::create(HTMLInputElement* element)
    7374{
     75    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeColor);
    7476    return adoptPtr(new ColorInputType(element));
    7577}

  • trunk/Source/WebCore/html/DateInputType.cpp

    r138254 r140655  
    3535#include "DateComponents.h"
    3636#include "DateTimeFieldsState.h"
     37#include "FeatureObserver.h"
    3738#include "HTMLInputElement.h"
    3839#include "HTMLNames.h"
    … …  
    5960PassOwnPtr<InputType> DateInputType::create(HTMLInputElement* element)
    6061{
     62    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeDate);
    6163    return adoptPtr(new DateInputType(element));
    6264}

  • trunk/Source/WebCore/html/DateTimeInputType.cpp

    r140308 r140655  
    3333
    3434#include "DateComponents.h"
     35#include "FeatureObserver.h"
    3536#include "HTMLInputElement.h"
    3637#include "HTMLNames.h"
    … …  
    5960PassOwnPtr<InputType> DateTimeInputType::create(HTMLInputElement* element)
    6061{
     62    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeDateTime);
    6163    return adoptPtr(new DateTimeInputType(element));
    6264}

  • trunk/Source/WebCore/html/DateTimeLocalInputType.cpp

    r140308 r140655  
    3333
    3434#include "DateComponents.h"
     35#include "FeatureObserver.h"
    3536#include "HTMLInputElement.h"
    3637#include "HTMLNames.h"
    … …  
    5859PassOwnPtr<InputType> DateTimeLocalInputType::create(HTMLInputElement* element)
    5960{
     61    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeDateTimeLocal);
    6062    return adoptPtr(new DateTimeLocalInputType(element));
    6163}

  • trunk/Source/WebCore/html/EmailInputType.cpp

    r131969 r140655  
    2525#include "EmailInputType.h"
    2626
     27#include "FeatureObserver.h"
    2728#include "HTMLInputElement.h"
    2829#include "HTMLParserIdioms.h"
    … …  
    5657PassOwnPtr<InputType> EmailInputType::create(HTMLInputElement* element)
    5758{
     59    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeEmail);
    5860    return adoptPtr(new EmailInputType(element));
    5961}

  • trunk/Source/WebCore/html/HTMLDataListElement.cpp

    r123283 r140655  
    3434
    3535#if ENABLE(DATALIST_ELEMENT)
     36#include "FeatureObserver.h"
    3637#include "HTMLNames.h"
    3738#include "IdTargetObserverRegistry.h"
    … …  
    4647PassRefPtr<HTMLDataListElement> HTMLDataListElement::create(const QualifiedName& tagName, Document* document)
    4748{
     49    FeatureObserver::observe(document, FeatureObserver::DataListElement);
    4850    return adoptRef(new HTMLDataListElement(tagName, document));
    4951}

  • trunk/Source/WebCore/html/HTMLFormControlElement.cpp

    r139064 r140655  
    3131#include "EventHandler.h"
    3232#include "EventNames.h"
     33#include "FeatureObserver.h"
    3334#include "Frame.h"
    3435#include "HTMLFieldSetElement.h"
    … …  
    123124void HTMLFormControlElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
    124125{
    125     if (name == formAttr)
     126    if (name == formAttr) {
    126127        formAttributeChanged();
    127     else if (name == disabledAttr) {
     128        FeatureObserver::observe(document(), FeatureObserver::FormAttribute);
     129    } else if (name == disabledAttr) {
    128130        bool oldDisabled = m_disabled;
    129131        m_disabled = !value.isNull();
    … …  
    144146        if (wasRequired != m_isRequired)
    145147            requiredAttributeChanged();
     148        FeatureObserver::observe(document(), FeatureObserver::RequiredAttribute);
     149    } else if (name == autofocusAttr) {
     150        HTMLElement::parseAttribute(name, value);
     151        FeatureObserver::observe(document(), FeatureObserver::AutoFocusAttribute);
    146152    } else
    147153        HTMLElement::parseAttribute(name, value);

  • trunk/Source/WebCore/html/HTMLInputElement.cpp

    r139663 r140655  
    3939#include "EventNames.h"
    4040#include "ExceptionCode.h"
     41#include "FeatureObserver.h"
    4142#include "FileInputType.h"
    4243#include "FileList.h"
    … …  
    698699            reattachIfAttached();
    699700        setNeedsStyleRecalc();
    700     } else if (name == autosaveAttr || name == incrementalAttr)
     701        FeatureObserver::observe(document(), FeatureObserver::ResultsAttribute);
     702    } else if (name == autosaveAttr) {
    701703        setNeedsStyleRecalc();
    702     else if (name == minAttr || name == maxAttr) {
     704        FeatureObserver::observe(document(), FeatureObserver::AutoSaveAttribute);
     705    } else if (name == incrementalAttr) {
     706        setNeedsStyleRecalc();
     707        FeatureObserver::observe(document(), FeatureObserver::IncrementalAttribute);
     708    } else if (name == minAttr) {
    703709        m_inputType->minOrMaxAttributeChanged();
    704710        setNeedsValidityCheck();
     711        FeatureObserver::observe(document(), FeatureObserver::MinAttribute);
     712    } else if (name == maxAttr) {
     713        m_inputType->minOrMaxAttributeChanged();
     714        setNeedsValidityCheck();
     715        FeatureObserver::observe(document(), FeatureObserver::MaxAttribute);
    705716    } else if (name == multipleAttr) {
    706717        m_inputType->multipleAttributeChanged();
    … …  
    709720        m_inputType->stepAttributeChanged();
    710721        setNeedsValidityCheck();
    711     } else if (name == patternAttr || name == precisionAttr)
     722        FeatureObserver::observe(document(), FeatureObserver::StepAttribute);
     723    } else if (name == patternAttr) {
    712724        setNeedsValidityCheck();
    713     else if (name == disabledAttr) {
     725        FeatureObserver::observe(document(), FeatureObserver::PatternAttribute);
     726    } else if (name == precisionAttr) {
     727        setNeedsValidityCheck();
     728        FeatureObserver::observe(document(), FeatureObserver::PrecisionAttribute);
     729    } else if (name == disabledAttr) {
    714730        HTMLTextFormControlElement::parseAttribute(name, value);
    715731        m_inputType->disabledAttributeChanged();
    … …  
    725741            listAttributeTargetChanged();
    726742        }
     743        FeatureObserver::observe(document(), FeatureObserver::ListAttribute);
    727744    }
    728745#endif
    … …  
    743760        setFormControlValueMatchesRenderer(false);
    744761        setNeedsStyleRecalc();
     762        FeatureObserver::observe(document(), FeatureObserver::PrefixedSpeechAttribute);
    745763    } else if (name == onwebkitspeechchangeAttr)
    746764        setAttributeEventListener(eventNames().webkitspeechchangeEvent, createAttributeEventListener(this, name, value));
     765#endif
     766#if ENABLE(DIRECTORY_UPLOAD)
     767    else if (name == webkitdirectoryAttr) {
     768        HTMLTextFormControlElement::parseAttribute(name, value);
     769        FeatureObserver::observe(document(), FeatureObserver::PrefixedDirectoryAttribute);
     770    }
    747771#endif
    748772    else

  • trunk/Source/WebCore/html/HTMLTextFormControlElement.cpp

    r140215 r140655  
    3232#include "Event.h"
    3333#include "EventNames.h"
     34#include "FeatureObserver.h"
    3435#include "Frame.h"
    3536#include "HTMLBRElement.h"
    … …  
    511512void HTMLTextFormControlElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
    512513{
    513     if (name == placeholderAttr)
     514    if (name == placeholderAttr) {
    514515        updatePlaceholderVisibility(true);
    515     else if (name == onselectAttr)
     516        FeatureObserver::observe(document(), FeatureObserver::PlaceholderAttribute);
     517    } else if (name == onselectAttr)
    516518        setAttributeEventListener(eventNames().selectEvent, createAttributeEventListener(this, name, value));
    517519    else if (name == onchangeAttr)

  • trunk/Source/WebCore/html/InputType.cpp

    r140385 r140655  
    141141    static const InputTypeFactoryMap* factoryMap = createInputTypeFactoryMap().leakPtr();
    142142    PassOwnPtr<InputType> (*factory)(HTMLInputElement*) = typeName.isEmpty() ? 0 : factoryMap->get(typeName);
    143     if (!factory)
     143    if (!factory) {
    144144        factory = TextInputType::create;
     145        if (typeName == InputTypeNames::datetime())
     146            FeatureObserver::observe(element->document(), FeatureObserver::InputTypeDateTimeFallback);
     147        else if (typeName == InputTypeNames::week())
     148            FeatureObserver::observe(element->document(), FeatureObserver::InputTypeWeekFallback);
     149    }
    145150    return factory(element);
    146151}

  • trunk/Source/WebCore/html/MonthInputType.cpp

    r140308 r140655  
    3333
    3434#include "DateComponents.h"
     35#include "FeatureObserver.h"
    3536#include "HTMLInputElement.h"
    3637#include "HTMLNames.h"
    … …  
    6061PassOwnPtr<InputType> MonthInputType::create(HTMLInputElement* element)
    6162{
     63    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeMonth);
    6264    return adoptPtr(new MonthInputType(element));
    6365}

  • trunk/Source/WebCore/html/NumberInputType.cpp

    r139151 r140655  
    3535#include "BeforeTextInsertedEvent.h"
    3636#include "ExceptionCode.h"
     37#include "FeatureObserver.h"
    3738#include "HTMLInputElement.h"
    3839#include "HTMLNames.h"
    … …  
    99100PassOwnPtr<InputType> NumberInputType::create(HTMLInputElement* element)
    100101{
     102    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeNumber);
    101103    return adoptPtr(new NumberInputType(element));
    102104}

  • trunk/Source/WebCore/html/RangeInputType.cpp

    r137124 r140655  
    3535#include "AXObjectCache.h"
    3636#include "ElementShadow.h"
     37#include "FeatureObserver.h"
    3738#include "HTMLDivElement.h"
    3839#include "HTMLInputElement.h"
    … …  
    8283PassOwnPtr<InputType> RangeInputType::create(HTMLInputElement* element)
    8384{
     85    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeRange);
    8486    return adoptPtr(new RangeInputType(element));
    8587}

  • trunk/Source/WebCore/html/SearchInputType.cpp

    r137124 r140655  
    3232#include "SearchInputType.h"
    3333
     34#include "FeatureObserver.h"
    3435#include "HTMLInputElement.h"
    3536#include "HTMLNames.h"
    … …  
    5556PassOwnPtr<InputType> SearchInputType::create(HTMLInputElement* element)
    5657{
     58    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeSearch);
    5759    return adoptPtr(new SearchInputType(element));
    5860}

  • trunk/Source/WebCore/html/TelephoneInputType.cpp

    r128149 r140655  
    3232#include "TelephoneInputType.h"
    3333
     34#include "FeatureObserver.h"
     35#include "HTMLInputElement.h"
    3436#include "InputTypeNames.h"
    3537#include <wtf/PassOwnPtr.h>
    … …  
    3941PassOwnPtr<InputType> TelephoneInputType::create(HTMLInputElement* element)
    4042{
     43    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeTel);
    4144    return adoptPtr(new TelephoneInputType(element));
    4245}

  • trunk/Source/WebCore/html/TimeInputType.cpp

    r132774 r140655  
    3333
    3434#include "DateComponents.h"
     35#include "FeatureObserver.h"
    3536#include "HTMLInputElement.h"
    3637#include "HTMLNames.h"
    … …  
    6465PassOwnPtr<InputType> TimeInputType::create(HTMLInputElement* element)
    6566{
     67    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeTime);
    6668    return adoptPtr(new TimeInputType(element));
    6769}

  • trunk/Source/WebCore/html/URLInputType.cpp

    r128149 r140655  
    3232#include "URLInputType.h"
    3333
     34#include "FeatureObserver.h"
    3435#include "HTMLInputElement.h"
    3536#include "InputTypeNames.h"
    … …  
    4243PassOwnPtr<InputType> URLInputType::create(HTMLInputElement* element)
    4344{
     45    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeURL);
    4446    return adoptPtr(new URLInputType(element));
    4547}

  • trunk/Source/WebCore/html/WeekInputType.cpp

    r140308 r140655  
    3333
    3434#include "DateComponents.h"
     35#include "FeatureObserver.h"
    3536#include "HTMLInputElement.h"
    3637#include "HTMLNames.h"
    … …  
    5657PassOwnPtr<InputType> WeekInputType::create(HTMLInputElement* element)
    5758{
     59    FeatureObserver::observe(element->document(), FeatureObserver::InputTypeWeek);
    5860    return adoptPtr(new WeekInputType(element));
    5961}

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

    r130657 r140655  
    3535
    3636FeatureObserver::FeatureObserver()
    37     : m_featureMask(0)
    3837{
    3938}
    … …  
    4443    HistogramSupport::histogramEnumeration("WebCore.FeatureObserver", PageDestruction, NumberOfFeatures);
    4544
    46     if (!m_featureMask)
     45    if (!m_featureBits)
    4746        return;
    4847
    49     for (int i = 0; i < NumberOfFeatures; ++i) {
    50         if (m_featureMask & (1 << i))
     48    for (unsigned i = 0; i < NumberOfFeatures; ++i) {
     49        if (m_featureBits->quickGet(i))
    5150            HistogramSupport::histogramEnumeration("WebCore.FeatureObserver", i, NumberOfFeatures);
    5251    }
    5352}
    5453
    55 void FeatureObserver::observe(DOMWindow* domWindow, Feature feature)
     54void FeatureObserver::observe(Document* document, Feature feature)
    5655{
    57     ASSERT(domWindow);
    58 
    59     Document* document = domWindow->document();
    6056    if (!document)
    6157        return;
    … …  
    6864}
    6965
     66void FeatureObserver::observe(DOMWindow* domWindow, Feature feature)
     67{
     68    ASSERT(domWindow);
     69    observe(domWindow->document(), feature);
     70}
     71
    7072} // namespace WebCore

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

    r139922 r140655  
    2727#define FeatureObserver_h
    2828
     29#include <wtf/BitVector.h>
    2930#include <wtf/Noncopyable.h>
     31#include <wtf/OwnPtr.h>
     32#include <wtf/PassOwnPtr.h>
    3033
    3134namespace WebCore {
    3235
    3336class DOMWindow;
     37class Document;
    3438
    3539class FeatureObserver {
    … …  
    6165        UnprefixedTransitionEndEvent,
    6266        PrefixedAndUnprefixedTransitionEndEvent,
    63         // Add new features above this line.
     67        AutoFocusAttribute,
     68        AutoSaveAttribute,
     69        DataListElement,
     70        FormAttribute,
     71        IncrementalAttribute,
     72        InputTypeColor,
     73        InputTypeDate,
     74        InputTypeDateTime,
     75        InputTypeDateTimeFallback,
     76        InputTypeDateTimeLocal,
     77        InputTypeEmail,
     78        InputTypeMonth,
     79        InputTypeNumber,
     80        InputTypeRange,
     81        InputTypeSearch,
     82        InputTypeTel,
     83        InputTypeTime,
     84        InputTypeURL,
     85        InputTypeWeek,
     86        InputTypeWeekFallback,
     87        ListAttribute,
     88        MaxAttribute,
     89        MinAttribute,
     90        PatternAttribute,
     91        PlaceholderAttribute,
     92        PrecisionAttribute,
     93        PrefixedDirectoryAttribute,
     94        PrefixedSpeechAttribute,
     95        RequiredAttribute,
     96        ResultsAttribute,
     97        StepAttribute,
     98        // Add new features above this line. Don't change assigned numbers of each items.
    6499        NumberOfFeatures, // This enum value must be last.
    65100    };
    66101
     102    static void observe(Document*, Feature);
    67103    static void observe(DOMWindow*, Feature);
    68104
    … …  
    70106    void didObserve(Feature feature)
    71107    {
    72         COMPILE_ASSERT(sizeof(m_featureMask) * 8 >= NumberOfFeatures, FeaturesMustNotOverflowBitmask);
    73108        ASSERT(feature != PageDestruction); // PageDestruction is reserved as a scaling factor.
    74109        ASSERT(feature < NumberOfFeatures);
    75         m_featureMask |= 1 << static_cast<int>(feature);
     110        if (!m_featureBits) {
     111            m_featureBits = adoptPtr(new BitVector(NumberOfFeatures));
     112            m_featureBits->clearAll();
     113        }
     114        m_featureBits->quickSet(feature);
    76115    }
    77116
    78     int m_featureMask;
     117    OwnPtr<BitVector> m_featureBits;
    79118};
    80119
Note: See TracChangeset for help on using the changeset viewer.