Lazily generate HistoryItem's serialized form state

Source/core/html/forms/FormController.cpp

 /*
  * Copyright (C) 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010, 2011, 2012 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 356 matching lines @@
 }
 
 void FormKeyGenerator::willDeleteForm(HTMLFormElement* form)
 {
     ASSERT(form);
     m_formToKeyMap.remove(form);
 }
 
 // ----------------------------------------------------------------------------
 
-FormController::FormController()
+PassRefPtr<DocumentState> DocumentState::create()
+{
+    return adoptRef(new DocumentState);
+}
+
+DocumentState::~DocumentState()
 {
 }
 
-FormController::~FormController()
+void DocumentState::addControl(HTMLFormControlElementWithState* control)
 {
+    ASSERT(!m_formControls.contains(control));
+    m_formControls.add(control);
+}
+
+void DocumentState::removeControl(HTMLFormControlElementWithState* control)
+{
+    RELEASE_ASSERT(m_formControls.contains(control));

[abarth-chromium, 2014/04/17 23:41:24]

Why RELEASE_ASSERT and not just ASSERT?

[Nate Chapin, 2014/04/17 23:48:19]

I copy/pasted it without understanding the history :) Will investigate before
landing.

+    m_formControls.remove(control);
 }
 
 static String formStateSignature()
 {
     // In the legacy version of serialized state, the first item was a name
     // attribute value of a form control. The following string literal should
     // contain some characters which are rarely used for name attribute values.
     DEFINE_STATIC_LOCAL(String, signature, ("\n\r?% WebKit serialized form state version 8 \n\r=&"));
     return signature;
 }
 
-PassOwnPtr<FormController::SavedFormStateMap> FormController::createSavedFormStateMap(const FormElementListHashSet& controlList)
+Vector<String> DocumentState::toStateVector()
 {
     OwnPtr<FormKeyGenerator> keyGenerator = FormKeyGenerator::create();
     OwnPtr<SavedFormStateMap> stateMap = adoptPtr(new SavedFormStateMap);
-    for (FormElementListHashSet::const_iterator it = controlList.begin(); it != controlList.end(); ++it) {
+    for (FormElementListHashSet::const_iterator it = m_formControls.begin(); it != m_formControls.end(); ++it) {
         HTMLFormControlElementWithState* control = (*it).get();
         ASSERT(control->inDocument());
         if (!control->shouldSaveAndRestoreFormControlState())
             continue;
         SavedFormStateMap::AddResult result = stateMap->add(keyGenerator->formKey(*control), nullptr);
         if (result.isNewEntry)
             result.storedValue->value = SavedFormState::create();
         result.storedValue->value->appendControlState(control->name(), control->type(), control->saveFormControlState());
     }
-    return stateMap.release();
-}
 
-Vector<String> FormController::formElementsState() const
-{
-    OwnPtr<SavedFormStateMap> stateMap = createSavedFormStateMap(m_formControls);
     Vector<String> stateVector;
     stateVector.reserveInitialCapacity(m_formControls.size() * 4);
     stateVector.append(formStateSignature());
     for (SavedFormStateMap::const_iterator it = stateMap->begin(); it != stateMap->end(); ++it) {
         stateVector.append(it->key);
         it->value->serializeTo(stateVector);
     }
     bool hasOnlySignature = stateVector.size() == 1;
     if (hasOnlySignature)
         stateVector.clear();
     return stateVector;
 }
 
+// ----------------------------------------------------------------------------
+
+FormController::FormController()
+    : m_documentState(DocumentState::create())
+{
+}
+
+FormController::~FormController()
+{
+}
+
+DocumentState* FormController::formElementsState() const
+{
+    return m_documentState.get();
+}
+
 void FormController::setStateForNewFormElements(const Vector<String>& stateVector)
 {
     formStatesFromStateVector(stateVector, m_savedFormStateMap);
 }
 
 FormControlState FormController::takeStateForFormElement(const HTMLFormControlElementWithState& control)
 {
     if (m_savedFormStateMap.isEmpty())
         return FormControlState();
     if (!m_formKeyGenerator)
@@ skipping 70 matching lines @@
     Vector<String> toReturn;
     SavedFormStateMap map;
     formStatesFromStateVector(stateVector, map);
     for (SavedFormStateMap::const_iterator it = map.begin(); it != map.end(); ++it)
         toReturn.appendVector(it->value->getReferencedFilePaths());
     return toReturn;
 }
 
 void FormController::registerStatefulFormControl(HTMLFormControlElementWithState& control)
 {
-    ASSERT(!m_formControls.contains(&control));
-    m_formControls.add(&control);
+    m_documentState->addControl(&control);
 }
 
 void FormController::unregisterStatefulFormControl(HTMLFormControlElementWithState& control)
 {
-    RELEASE_ASSERT(m_formControls.contains(&control));
-    m_formControls.remove(&control);
+    m_documentState->removeControl(&control);
 }
 
 } // namespace WebCore