Reviewed by Darin and Geoff
authorbeidson <beidson@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 12 May 2007 21:22:08 +0000 (21:22 +0000)
committerbeidson <beidson@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 12 May 2007 21:22:08 +0000 (21:22 +0000)
        Fix for http://bugs.webkit.org/show_bug.cgi?id=13630
        and
        <rdar://problem/4873628>

        Back/Forward cache should work with pages with login fields.

        First change is to relocate the "useSecureKeyboardEntry" flag to the document.  This lets
        it persist through page cache transitions and it is truly a per-document concept more than
        per-frame anyways since its the document that has a password field, not the frame.

        Second change is to introduce the concept of an Element getting a "didRestoreFromCache()" callback.
        The idea is for elements to register with the document if they need work to be done when the
        page comes out of the back/forward cache.  Currently the only client of this service is
        HTMLInputElements that are input type == PASSWORD.  Such an element's implementation for this
        method is to call reset()

        Finally, after a page is restored from the cache we have the document send the didRestoreFromCache()
        callback to its registered Elements.  The whole design is to clear the password fields after
        restoring the page instead of when caching the page because we want to defer work for the common
        case - there shouldn't be extra work here just to navigate away from a page when the common case
        is that you'll never go back!

        No layout tests possible until http://bugs.webkit.org/show_bug.cgi?id=13672 is resolved

        * dom/Document.cpp:
        (WebCore::Document::Document):
        (WebCore::Document::registerForDidRestoreFromCacheCallback): Add an Element to the special page-restoration callback list
        (WebCore::Document::unregisterForDidRestoreFromCacheCallback): Remove such an element
        (WebCore::Document::didRestoreFromCache): Called by FrameLoader - dispatch to all the registered elements
        (WebCore::Document::setUseSecureKeyboardEntryWhenActive): Set the local flag and call updateSecureKeyboardEntryIfActive
          on the Frame
        (WebCore::Document::useSecureKeyboardEntryWhenActive): Return the flag

        * dom/Document.h:
        (WebCore::Document::unregisterFormElementWithState): Renamed

        * dom/Element.h:
        (WebCore::Element::didRestoreFromCache): Added virtual base method

        * html/HTMLInputElement.cpp:
        (WebCore::HTMLInputElement::~HTMLInputElement): Deregister from the document if inputType == PASSWORD
        (WebCore::HTMLInputElement::dispatchFocusEvent): Set the flag on the document, not the frame
        (WebCore::HTMLInputElement::dispatchBlurEvent): Ditto
        (WebCore::HTMLInputElement::setInputType): If changing to/from PASSWORD, register/deregister in the document accordingly
        (WebCore::HTMLInputElement::attach): Call registerForDidRestoreFromCacheCallback(this) instead of passwordFieldAdded()
        (WebCore::HTMLInputElement::didRestoreFromCache): Call reset();
        * html/HTMLInputElement.h:

        * html/HTMLSelectElement.cpp:
        (WebCore::HTMLSelectElement::~HTMLSelectElement): Renamed deregisterFormElementWithState to unregisterFormElementWithState
        * html/HTMLTextAreaElement.cpp:
        (WebCore::HTMLTextAreaElement::~HTMLTextAreaElement): Ditto

        * loader/FrameLoader.cpp:
        (WebCore::FrameLoader::canCachePage): Remove the check for password fields - they're allowed now!
        (WebCore::FrameLoader::opened): Tell the document to dispatch to the registered elements
        (WebCore::FrameLoader::saveDocumentState): Remove the check for password fields.  Turns out that when we grab a copy a the
          form state we're only copying the state of form elements that are registered with the Document - and that set
          explicitly excludes Password elements

        * page/Frame.cpp:
        (WebCore::Frame::setDocument): If the frame is active, set the setUseSecureKeyboardEntry based on the setting contained
          in the new document
        (WebCore::Frame::updateSecureKeyboardEntryIfActive): Notification for the secure entry flag changing - if the Frame is
          active, then update to the new setting from the document
        (WebCore::Frame::setIsActive): Grab the useSecureKeyboardEntry flag from the document instead of FramePrivate
        (WebCore::FramePrivate::FramePrivate):
        * page/Frame.h:
        * page/FramePrivate.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@21430 268f45cc-cd09-0410-ab3c-d52691b4dbfc

12 files changed:
WebCore/ChangeLog
WebCore/dom/Document.cpp
WebCore/dom/Document.h
WebCore/dom/Element.h
WebCore/html/HTMLInputElement.cpp
WebCore/html/HTMLInputElement.h
WebCore/html/HTMLSelectElement.cpp
WebCore/html/HTMLTextAreaElement.cpp
WebCore/loader/FrameLoader.cpp
WebCore/page/Frame.cpp
WebCore/page/Frame.h
WebCore/page/FramePrivate.h

index 8c48db5690c64bf5be79eadc0c4c3129b554ddf6..f245458158f0f23a40bb891b6edfca8330f82ec1 100644 (file)
@@ -1,3 +1,77 @@
+2007-05-11  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Darin and Geoff
+
+        Fix for http://bugs.webkit.org/show_bug.cgi?id=13630
+        and
+        <rdar://problem/4873628>
+
+        Back/Forward cache should work with pages with login fields.
+
+        First change is to relocate the "useSecureKeyboardEntry" flag to the document.  This lets
+        it persist through page cache transitions and it is truly a per-document concept more than
+        per-frame anyways since its the document that has a password field, not the frame.
+
+        Second change is to introduce the concept of an Element getting a "didRestoreFromCache()" callback.
+        The idea is for elements to register with the document if they need work to be done when the
+        page comes out of the back/forward cache.  Currently the only client of this service is 
+        HTMLInputElements that are input type == PASSWORD.  Such an element's implementation for this
+        method is to call reset()
+
+        Finally, after a page is restored from the cache we have the document send the didRestoreFromCache()
+        callback to its registered Elements.  The whole design is to clear the password fields after 
+        restoring the page instead of when caching the page because we want to defer work for the common
+        case - there shouldn't be extra work here just to navigate away from a page when the common case
+        is that you'll never go back!
+
+        No layout tests possible until http://bugs.webkit.org/show_bug.cgi?id=13672 is resolved
+
+        * dom/Document.cpp:
+        (WebCore::Document::Document):
+        (WebCore::Document::registerForDidRestoreFromCacheCallback): Add an Element to the special page-restoration callback list
+        (WebCore::Document::unregisterForDidRestoreFromCacheCallback): Remove such an element
+        (WebCore::Document::didRestoreFromCache): Called by FrameLoader - dispatch to all the registered elements
+        (WebCore::Document::setUseSecureKeyboardEntryWhenActive): Set the local flag and call updateSecureKeyboardEntryIfActive
+          on the Frame
+        (WebCore::Document::useSecureKeyboardEntryWhenActive): Return the flag
+
+        * dom/Document.h:
+        (WebCore::Document::unregisterFormElementWithState): Renamed
+
+        * dom/Element.h:
+        (WebCore::Element::didRestoreFromCache): Added virtual base method
+
+        * html/HTMLInputElement.cpp:
+        (WebCore::HTMLInputElement::~HTMLInputElement): Deregister from the document if inputType == PASSWORD
+        (WebCore::HTMLInputElement::dispatchFocusEvent): Set the flag on the document, not the frame
+        (WebCore::HTMLInputElement::dispatchBlurEvent): Ditto
+        (WebCore::HTMLInputElement::setInputType): If changing to/from PASSWORD, register/deregister in the document accordingly
+        (WebCore::HTMLInputElement::attach): Call registerForDidRestoreFromCacheCallback(this) instead of passwordFieldAdded()
+        (WebCore::HTMLInputElement::didRestoreFromCache): Call reset();
+        * html/HTMLInputElement.h:
+
+        * html/HTMLSelectElement.cpp:
+        (WebCore::HTMLSelectElement::~HTMLSelectElement): Renamed deregisterFormElementWithState to unregisterFormElementWithState
+        * html/HTMLTextAreaElement.cpp:
+        (WebCore::HTMLTextAreaElement::~HTMLTextAreaElement): Ditto
+
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::canCachePage): Remove the check for password fields - they're allowed now!
+        (WebCore::FrameLoader::opened): Tell the document to dispatch to the registered elements
+        (WebCore::FrameLoader::saveDocumentState): Remove the check for password fields.  Turns out that when we grab a copy a the
+          form state we're only copying the state of form elements that are registered with the Document - and that set 
+          explicitly excludes Password elements
+
+        * page/Frame.cpp:
+        (WebCore::Frame::setDocument): If the frame is active, set the setUseSecureKeyboardEntry based on the setting contained
+          in the new document
+        (WebCore::Frame::updateSecureKeyboardEntryIfActive): Notification for the secure entry flag changing - if the Frame is
+          active, then update to the new setting from the document
+        (WebCore::Frame::setIsActive): Grab the useSecureKeyboardEntry flag from the document instead of FramePrivate
+        (WebCore::FramePrivate::FramePrivate):
+        * page/Frame.h:
+        * page/FramePrivate.h:
+
 2007-05-12  David Hyatt  <hyatt@apple.com>
 
         Fix for bug 12740, bmw.com doesn't work.  We were missing a rule that is covered by the HTML5
index 013fe5d902d28249a08527c86739fd038519f6e5..e4b27aef47eb79ce25a2b4ce612288f300fc7f80 100644 (file)
@@ -286,7 +286,6 @@ Document::Document(DOMImplementation* impl, Frame* frame)
     , m_bindingManager(new XBLBindingManager(this))
 #endif
     , m_savedRenderer(0)
-    , m_passwordFields(0)
     , m_secureForms(0)
     , m_designMode(inherit)
     , m_selfOnlyRefCount(0)
@@ -299,6 +298,7 @@ Document::Document(DOMImplementation* impl, Frame* frame)
     , m_createRenderers(true)
     , m_inPageCache(false)
     , m_isAllowedToLoadLocalResources(false)
+    , m_useSecureKeyboardEntryWhenActive(false)
 #if USE(LOW_BANDWIDTH_DISPLAY)
     , m_inLowBandwidthDisplay(false)
 #endif    
@@ -2683,20 +2683,21 @@ void Document::setInPageCache(bool flag)
     }
 }
 
-void Document::passwordFieldAdded()
+void Document::registerForDidRestoreFromCacheCallback(Element* e)
 {
-    m_passwordFields++;
+    m_didRestorePageCallbackSet.add(e);
 }
 
-void Document::passwordFieldRemoved()
+void Document::unregisterForDidRestoreFromCacheCallback(Element* e)
 {
-    ASSERT(m_passwordFields > 0);
-    m_passwordFields--;
+    m_didRestorePageCallbackSet.remove(e);
 }
 
-bool Document::hasPasswordField() const
+void Document::didRestoreFromCache()
 {
-    return m_passwordFields > 0;
+    HashSet<Element*>::iterator it = m_didRestorePageCallbackSet.begin();
+    for (; it != m_didRestorePageCallbackSet.end(); ++it) 
+        (*it)->didRestoreFromCache();
 }
 
 void Document::secureFormAdded()
@@ -3604,4 +3605,18 @@ void Document::setIconURL(const String& iconURL, const String& type)
         m_iconURL = iconURL;
 }
 
+void Document::setUseSecureKeyboardEntryWhenActive(bool usesSecureKeyboard)
+{
+    if (m_useSecureKeyboardEntryWhenActive == usesSecureKeyboard)
+        return;
+        
+    m_useSecureKeyboardEntryWhenActive = usesSecureKeyboard;
+    m_frame->updateSecureKeyboardEntryIfActive();
+}
+
+bool Document::useSecureKeyboardEntryWhenActive() const
+{
+    return m_useSecureKeyboardEntryWhenActive;
+}
+
 }
index 90a51b4869676ac80fb2c6c9291b5dd8a0461435..3752efeea74c826cfed2370a7387caf8f91c8bea 100644 (file)
@@ -290,7 +290,7 @@ public:
 
     // Machinery for saving and restoring state when you leave and then go back to a page.
     void registerFormElementWithState(HTMLGenericFormElement* e) { m_formElementsWithState.add(e); }
-    void deregisterFormElementWithState(HTMLGenericFormElement* e) { m_formElementsWithState.remove(e); }
+    void unregisterFormElementWithState(HTMLGenericFormElement* e) { m_formElementsWithState.remove(e); }
     Vector<String> formElementsState() const;
     void setStateForNewFormElements(const Vector<String>&);
     bool hasStateForNewFormElements() const;
@@ -634,6 +634,9 @@ public:
 
     bool isAllowedToLoadLocalResources() const { return m_isAllowedToLoadLocalResources; }
 
+    void setUseSecureKeyboardEntryWhenActive(bool);
+    bool useSecureKeyboardEntryWhenActive() const;
+    
 #if USE(LOW_BANDWIDTH_DISPLAY)
     void setDocLoader(DocLoader* loader) { m_docLoader = loader; }
     bool inLowBandwidthDisplay() const { return m_inLowBandwidthDisplay; }
@@ -701,6 +704,8 @@ protected:
     ListHashSet<HTMLGenericFormElement*> m_formElementsWithState;
     FormElementStateMap m_stateForNewFormElements;
 
+    HashSet<Element*> m_didRestorePageCallbackSet;
+    
     Color m_linkColor;
     Color m_visitedLinkColor;
     Color m_activeLinkColor;
@@ -766,9 +771,12 @@ public:
     bool inPageCache();
     void setInPageCache(bool flag);
 
-    void passwordFieldAdded();
-    void passwordFieldRemoved();
-    bool hasPasswordField() const;
+    // Elements can register themselves for the "didRestoreFromCache()" callback which will be
+    // called if the document is restored from the Page Cache
+    void registerForDidRestoreFromCacheCallback(Element*);
+    void unregisterForDidRestoreFromCacheCallback(Element*);
+    
+    void didRestoreFromCache();
 
     void secureFormAdded();
     void secureFormRemoved();
@@ -815,7 +823,6 @@ private:
 
     mutable String m_domain;
     RenderObject* m_savedRenderer;
-    int m_passwordFields;
     int m_secureForms;
     
     RefPtr<TextResourceDecoder> m_decoder;
@@ -853,6 +860,8 @@ private:
     String m_iconURL;
 
     bool m_isAllowedToLoadLocalResources;
+    
+    bool m_useSecureKeyboardEntryWhenActive;
 
 #if USE(LOW_BANDWIDTH_DISPLAY)
     bool m_inLowBandwidthDisplay;
index c2ddd4ce9a79cac3e10e3f42608e4fd7c94443b2..f22ab6f7a59b908b63ccece667e6c3dfc13556ca 100644 (file)
@@ -182,6 +182,10 @@ public:
     IntSize minimumSizeForResizing() const;
     void setMinimumSizeForResizing(const IntSize&);
 
+    // The following method is called when a Document is restored from the page cache
+    // and the element has registered itself with the Document via registerForDidRestorePageCallback()
+    virtual void didRestoreFromCache() { }
+    
 private:
     ElementRareData* rareData();
     const ElementRareData* rareData() const;
index b028789b17289b2639fea18404a609b107617e5b..a4c8994630ed8404818d3926666cde9988134e61 100644 (file)
@@ -136,7 +136,8 @@ void HTMLInputElement::init()
 
 HTMLInputElement::~HTMLInputElement()
 {
-    document()->deregisterFormElementWithState(this);
+    document()->unregisterFormElementWithState(this);
+    document()->unregisterForDidRestoreFromCacheCallback(this);
     delete m_imageLoader;
 }
 
@@ -232,7 +233,7 @@ void HTMLInputElement::dispatchFocusEvent()
     if (isTextField()) {
         setAutofilled(false);
         if (inputType() == PASSWORD && document()->frame())
-            document()->frame()->setUseSecureKeyboardEntryWhenActive(true);
+            document()->setUseSecureKeyboardEntryWhenActive(true);
     }
     HTMLGenericFormElement::dispatchFocusEvent();
 }
@@ -241,7 +242,7 @@ void HTMLInputElement::dispatchBlurEvent()
 {
     if (isTextField() && document()->frame()) {
         if (inputType() == PASSWORD)
-            document()->frame()->setUseSecureKeyboardEntryWhenActive(false);
+            document()->setUseSecureKeyboardEntryWhenActive(false);
         document()->frame()->textFieldDidEndEditing(this);
     }
     HTMLGenericFormElement::dispatchBlurEvent();
@@ -305,11 +306,11 @@ void HTMLInputElement::setInputType(const String& t)
                 detach();
 
             bool didStoreValue = storesValueSeparateFromAttribute();
-            bool didMaintainState = inputType() != PASSWORD;
+            bool wasPasswordField = inputType() == PASSWORD;
             bool didRespectHeightAndWidth = respectHeightAndWidthAttrs();
             m_type = newType;
             bool willStoreValue = storesValueSeparateFromAttribute();
-            bool willMaintainState = inputType() != PASSWORD;
+            bool isPasswordField = inputType() == PASSWORD;
             bool willRespectHeightAndWidth = respectHeightAndWidthAttrs();
 
             if (didStoreValue && !willStoreValue && !m_value.isNull()) {
@@ -321,10 +322,13 @@ void HTMLInputElement::setInputType(const String& t)
             else
                 recheckValue();
 
-            if (willMaintainState && !didMaintainState)
+            if (wasPasswordField && !isPasswordField) {
                 document()->registerFormElementWithState(this);
-            else if (!willMaintainState && didMaintainState)
-                document()->deregisterFormElementWithState(this);
+                document()->unregisterForDidRestoreFromCacheCallback(this);
+            } else if (!wasPasswordField && isPasswordField) {
+                document()->unregisterFormElementWithState(this);
+                document()->registerForDidRestoreFromCacheCallback(this);
+            }
 
             if (didRespectHeightAndWidth != willRespectHeightAndWidth) {
                 NamedMappedAttrMap* map = mappedAttributes();
@@ -758,10 +762,8 @@ void HTMLInputElement::attach()
         }
     }
 
-    // note we don't deal with calling passwordFieldRemoved() on detach, because the timing
-    // was such that it cleared our state too early
     if (inputType() == PASSWORD)
-        document()->passwordFieldAdded();
+        document()->unregisterForDidRestoreFromCacheCallback(this);
 }
 
 void HTMLInputElement::detach()
@@ -1470,5 +1472,11 @@ Selection HTMLInputElement::selection() const
         return Selection();
    return static_cast<RenderTextControl*>(renderer())->selection(cachedSelStart, cachedSelEnd);
 }
+
+void HTMLInputElement::didRestoreFromCache()
+{
+    ASSERT(inputType() == PASSWORD);
+    reset();
+}
     
 } // namespace
index b4ad0d8c17572a0330ab04da5ed10ce16ee7e0e9..08911061d8734e20c6d8952a5f5b86da72d47daf 100644 (file)
@@ -183,6 +183,8 @@ public:
 
     String constrainValue(const String& proposedValue) const;
 
+    virtual void didRestoreFromCache();
+    
 protected:
     AtomicString m_name;
 
index 7dd5e0f9f1137f03d92bafb5b3fd4277632a775a..dd9fec129c128954e14e8dfa89e4b29d522831d9 100644 (file)
@@ -96,7 +96,7 @@ HTMLSelectElement::HTMLSelectElement(const QualifiedName& tagName, Document* doc
 
 HTMLSelectElement::~HTMLSelectElement()
 {
-    document()->deregisterFormElementWithState(this);
+    document()->unregisterFormElementWithState(this);
 }
 
 bool HTMLSelectElement::checkDTD(const Node* newChild)
index 5d3c63fbeb1e6a9139b1073057806f22b961a26a..c71d4e2c911d311c2ef1755c8fc420e11088b612 100644 (file)
@@ -60,7 +60,7 @@ HTMLTextAreaElement::HTMLTextAreaElement(Document *doc, HTMLFormElement *f)
 
 HTMLTextAreaElement::~HTMLTextAreaElement()
 {
-    document()->deregisterFormElementWithState(this);
+    document()->unregisterFormElementWithState(this);
 }
 
 const AtomicString& HTMLTextAreaElement::type() const
index ea3fcd3e51d0e85263fe283f13af216863043609..7065b661c48ad0b296e51f7d08c65f720a74a95b 100644 (file)
@@ -1616,10 +1616,6 @@ bool FrameLoader::canCachePage()
         && m_frame->document()
         && !m_frame->document()->applets()->length()
         && !m_frame->document()->hasWindowEventListener(unloadEvent)
-        // If you change the following to allow caching of documents with password fields,
-        // you also need to make sure that Frame::setDocument turns on secure keyboard
-        // entry mode if the document's focused node requires it.
-        && !m_frame->document()->hasPasswordField()
         && m_frame->page() 
         && m_frame->page()->backForwardList()->pageCacheSize() != 0
         && m_currentHistoryItem
@@ -3244,6 +3240,8 @@ void FrameLoader::opened()
         updateHistoryForClientRedirect();
 
     if (m_documentLoader->isLoadingFromCachedPage()) {
+        m_frame->document()->didRestoreFromCache();
+        
         // Force a layout to update view size and thereby update scrollbars.
         m_client->forceLayout();
 
@@ -3742,12 +3740,13 @@ void FrameLoader::saveDocumentState()
     if (m_creatingInitialEmptyDocument)
         return;
 
-    // Do not save doc state if the page has a password field and a form that would be submitted via https.
+    // Do not save doc state if the page has a form that would be submitted via https.
     Document* document = m_frame->document();
     ASSERT(document);
-    if (document->hasPasswordField() && document->hasSecureForm())
-        return;
         
+    if (document->hasSecureForm())
+         return;
+         
     // For a standard page load, we will have a previous item set, which will be used to
     // store the form state.  However, in some cases we will have no previous item, and
     // the current item is the right place to save the state.  One example is when we
index 31e3f7d6cdb9f03f1f1ee7e4cfdc88f3629a8fe5..fdc8a2ca57d39df654675bcd36269256552210f0 100644 (file)
@@ -307,20 +307,15 @@ Document *Frame::document() const
 
 void Frame::setDocument(PassRefPtr<Document> newDoc)
 {
-    if (d) {
-        if (d->m_doc) {
-            if (d->m_doc->attached())
-                d->m_doc->detach();
-            // The old document's focused node may have turned on secure keyboard entry.
-            // Now that it's going away, turn it off. Documents containing a password
-            // field cannot enter the page cache, therefore |newDoc| cannot contain a
-            // focused password field, and hence we can always set to false.
-            setUseSecureKeyboardEntryWhenActive(false);
-        }
-        d->m_doc = newDoc;
-        if (d->m_doc && !d->m_doc->attached())
-            d->m_doc->attach();
-    }
+    if (d->m_doc && d->m_doc->attached())
+        d->m_doc->detach();
+
+    d->m_doc = newDoc;
+    if (d->m_doc && d->m_isActive)
+        setUseSecureKeyboardEntry(d->m_doc->useSecureKeyboardEntryWhenActive());
+        
+    if (d->m_doc && !d->m_doc->attached())
+        d->m_doc->attach();
 }
 
 const Settings *Frame::settings() const
@@ -789,14 +784,10 @@ void Frame::setUseSecureKeyboardEntry(bool)
 
 #endif
 
-void Frame::setUseSecureKeyboardEntryWhenActive(bool usesSecureKeyboard)
+void Frame::updateSecureKeyboardEntryIfActive()
 {
-    if (d->m_useSecureKeyboardEntryWhenActive == usesSecureKeyboard)
-        return;
-    d->m_useSecureKeyboardEntryWhenActive = usesSecureKeyboard;
-
     if (d->m_isActive)
-        setUseSecureKeyboardEntry(usesSecureKeyboard);
+        setUseSecureKeyboardEntry(d->m_doc->useSecureKeyboardEntryWhenActive());
 }
 
 CSSMutableStyleDeclaration *Frame::typingStyle() const
@@ -1517,7 +1508,7 @@ void Frame::setIsActive(bool flag)
     }
 
     // Secure keyboard entry is set by the active frame.
-    if (d->m_useSecureKeyboardEntryWhenActive)
+    if (d->m_doc->useSecureKeyboardEntryWhenActive())
         setUseSecureKeyboardEntry(flag);
 }
 
@@ -1870,7 +1861,6 @@ FramePrivate::FramePrivate(Page* page, Frame* parent, Frame* thisFrame, HTMLFram
     , m_caretVisible(false)
     , m_caretPaint(true)
     , m_isActive(false)
-    , m_useSecureKeyboardEntryWhenActive(false)
     , m_lifeSupportTimer(thisFrame, &Frame::lifeSupportTimerFired)
     , m_loader(new FrameLoader(thisFrame, frameLoaderClient))
     , m_userStyleSheetLoader(0)
index 3c2b39033657f22fb06a1793200513a1b24e3c8b..5b6b0ac0af3ed93d46a5023d2e899a2292ba1d45 100644 (file)
@@ -316,7 +316,7 @@ public:
 
     bool isContentEditable() const; // if true, everything in frame is editable
 
-    void setUseSecureKeyboardEntryWhenActive(bool);
+    void updateSecureKeyboardEntryIfActive();
 
     CSSMutableStyleDeclaration* typingStyle() const;
     void setTypingStyle(CSSMutableStyleDeclaration*);
index 4660b2e5db26f434d0e7f63bdc17a6da8037cbf5..7558d0646402817492648289b61fdca6ff298097 100644 (file)
@@ -97,7 +97,6 @@ namespace WebCore {
         bool m_caretVisible : 1;
         bool m_caretPaint : 1;
         bool m_isActive : 1;
-        bool m_useSecureKeyboardEntryWhenActive : 1;
 
         RefPtr<CSSMutableStyleDeclaration> m_typingStyle;