src/third_party/WebKit/Source/core/html/forms/FormController.cpp

   1 /*
   2  * Copyright (C) 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
   3  * Copyright (C) 2010, 2011, 2012 Google Inc. All rights reserved.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "core/html/forms/FormController.h"
  23
  24 #include "core/html/HTMLFormControlElementWithState.h"
  25 #include "core/html/HTMLFormElement.h"
  26 #include "core/html/HTMLInputElement.h"
  27 #include "platform/FileChooser.h"
  28 #include "wtf/Deque.h"
  29 #include "wtf/HashTableDeletedValueType.h"
  30 #include "wtf/text/StringBuilder.h"
  31
  32 namespace WebCore {
  33
  34 using namespace HTMLNames;
  35
  36 static inline HTMLFormElement* ownerFormForState(const HTMLFormControlElementWithState& control)
  37 {
  38     // Assume controls with form attribute have no owners because we restore
  39     // state during parsing and form owners of such controls might be
  40     // indeterminate.
  41     return control.fastHasAttribute(formAttr) ? 0 : control.form();
  42 }
  43
  44 // ----------------------------------------------------------------------------
  45
  46 // Serilized form of FormControlState:
  47 //  (',' means strings around it are separated in stateVector.)
  48 //
  49 // SerializedControlState ::= SkipState | RestoreState
  50 // SkipState ::= '0'
  51 // RestoreState ::= UnsignedNumber, ControlValue+
  52 // UnsignedNumber ::= [0-9]+
  53 // ControlValue ::= arbitrary string
  54 //
  55 // RestoreState has a sequence of ControlValues. The length of the
  56 // sequence is represented by UnsignedNumber.
  57
  58 void FormControlState::serializeTo(Vector<String>& stateVector) const
  59 {
  60     ASSERT(!isFailure());
  61     stateVector.append(String::number(m_values.size()));
  62     for (size_t i = 0; i < m_values.size(); ++i)
  63         stateVector.append(m_values[i].isNull() ? emptyString() : m_values[i]);
  64 }
  65
  66 FormControlState FormControlState::deserialize(const Vector<String>& stateVector, size_t& index)
  67 {
  68     if (index >= stateVector.size())
  69         return FormControlState(TypeFailure);
  70     size_t valueSize = stateVector[index++].toUInt();
  71     if (!valueSize)
  72         return FormControlState();
  73     if (index + valueSize > stateVector.size())
  74         return FormControlState(TypeFailure);
  75     FormControlState state;
  76     state.m_values.reserveCapacity(valueSize);
  77     for (size_t i = 0; i < valueSize; ++i)
  78         state.append(stateVector[index++]);
  79     return state;
  80 }
  81
  82 // ----------------------------------------------------------------------------
  83
  84 class FormElementKey {
  85 public:
  86     FormElementKey(StringImpl* = 0, StringImpl* = 0);
  87     ~FormElementKey();
  88     FormElementKey(const FormElementKey&);
  89     FormElementKey& operator=(const FormElementKey&);
  90
  91     StringImpl* name() const { return m_name; }
  92     StringImpl* type() const { return m_type; }
  93
  94     // Hash table deleted values, which are only constructed and never copied or destroyed.
  95     FormElementKey(WTF::HashTableDeletedValueType) : m_name(hashTableDeletedValue()) { }
  96     bool isHashTableDeletedValue() const { return m_name == hashTableDeletedValue(); }
  97
  98 private:
  99     void ref() const;
 100     void deref() const;
 101
 102     static StringImpl* hashTableDeletedValue() { return reinterpret_cast<StringImpl*>(-1); }
 103
 104     StringImpl* m_name;
 105     StringImpl* m_type;
 106 };
 107
 108 FormElementKey::FormElementKey(StringImpl* name, StringImpl* type)
 109     : m_name(name)
 110     , m_type(type)
 111 {
 112     ref();
 113 }
 114
 115 FormElementKey::~FormElementKey()
 116 {
 117     deref();
 118 }
 119
 120 FormElementKey::FormElementKey(const FormElementKey& other)
 121     : m_name(other.name())
 122     , m_type(other.type())
 123 {
 124     ref();
 125 }
 126
 127 FormElementKey& FormElementKey::operator=(const FormElementKey& other)
 128 {
 129     other.ref();
 130     deref();
 131     m_name = other.name();
 132     m_type = other.type();
 133     return *this;
 134 }
 135
 136 void FormElementKey::ref() const
 137 {
 138     if (name())
 139         name()->ref();
 140     if (type())
 141         type()->ref();
 142 }
 143
 144 void FormElementKey::deref() const
 145 {
 146     if (name())
 147         name()->deref();
 148     if (type())
 149         type()->deref();
 150 }
 151
 152 inline bool operator==(const FormElementKey& a, const FormElementKey& b)
 153 {
 154     return a.name() == b.name() && a.type() == b.type();
 155 }
 156
 157 struct FormElementKeyHash {
 158     static unsigned hash(const FormElementKey&);
 159     static bool equal(const FormElementKey& a, const FormElementKey& b) { return a == b; }
 160     static const bool safeToCompareToEmptyOrDeleted = true;
 161 };
 162
 163 unsigned FormElementKeyHash::hash(const FormElementKey& key)
 164 {
 165     return StringHasher::hashMemory<sizeof(FormElementKey)>(&key);
 166 }
 167
 168 struct FormElementKeyHashTraits : WTF::GenericHashTraits<FormElementKey> {
 169     static void constructDeletedValue(FormElementKey& slot) { new (NotNull, &slot) FormElementKey(WTF::HashTableDeletedValue); }
 170     static bool isDeletedValue(const FormElementKey& value) { return value.isHashTableDeletedValue(); }
 171 };
 172
 173 // ----------------------------------------------------------------------------
 174
 175 class SavedFormState {
 176     WTF_MAKE_NONCOPYABLE(SavedFormState);
 177     WTF_MAKE_FAST_ALLOCATED;
 178
 179 public:
 180     static PassOwnPtr<SavedFormState> create();
 181     static PassOwnPtr<SavedFormState> deserialize(const Vector<String>&, size_t& index);
 182     void serializeTo(Vector<String>&) const;
 183     bool isEmpty() const { return m_stateForNewFormElements.isEmpty(); }
 184     void appendControlState(const AtomicString& name, const AtomicString& type, const FormControlState&);
 185     FormControlState takeControlState(const AtomicString& name, const AtomicString& type);
 186
 187     Vector<String> getReferencedFilePaths() const;
 188
 189 private:
 190     SavedFormState() : m_controlStateCount(0) { }
 191
 192     typedef HashMap<FormElementKey, Deque<FormControlState>, FormElementKeyHash, FormElementKeyHashTraits> FormElementStateMap;
 193     FormElementStateMap m_stateForNewFormElements;
 194     size_t m_controlStateCount;
 195 };
 196
 197 PassOwnPtr<SavedFormState> SavedFormState::create()
 198 {
 199     return adoptPtr(new SavedFormState);
 200 }
 201
 202 static bool isNotFormControlTypeCharacter(UChar ch)
 203 {
 204     return ch != '-' && (ch > 'z' || ch < 'a');
 205 }
 206
 207 PassOwnPtr<SavedFormState> SavedFormState::deserialize(const Vector<String>& stateVector, size_t& index)
 208 {
 209     if (index >= stateVector.size())
 210         return nullptr;
 211     // FIXME: We need String::toSizeT().
 212     size_t itemCount = stateVector[index++].toUInt();
 213     if (!itemCount)
 214         return nullptr;
 215     OwnPtr<SavedFormState> savedFormState = adoptPtr(new SavedFormState);
 216     while (itemCount--) {
 217         if (index + 1 >= stateVector.size())
 218             return nullptr;
 219         String name = stateVector[index++];
 220         String type = stateVector[index++];
 221         FormControlState state = FormControlState::deserialize(stateVector, index);
 222         if (type.isEmpty() || type.find(isNotFormControlTypeCharacter) != kNotFound || state.isFailure())
 223             return nullptr;
 224         savedFormState->appendControlState(AtomicString(name), AtomicString(type), state);
 225     }
 226     return savedFormState.release();
 227 }
 228
 229 void SavedFormState::serializeTo(Vector<String>& stateVector) const
 230 {
 231     stateVector.append(String::number(m_controlStateCount));
 232     for (FormElementStateMap::const_iterator it = m_stateForNewFormElements.begin(); it != m_stateForNewFormElements.end(); ++it) {
 233         const FormElementKey& key = it->key;
 234         const Deque<FormControlState>& queue = it->value;
 235         for (Deque<FormControlState>::const_iterator queIterator = queue.begin(); queIterator != queue.end(); ++queIterator) {
 236             stateVector.append(key.name());
 237             stateVector.append(key.type());
 238             queIterator->serializeTo(stateVector);
 239         }
 240     }
 241 }
 242
 243 void SavedFormState::appendControlState(const AtomicString& name, const AtomicString& type, const FormControlState& state)
 244 {
 245     FormElementKey key(name.impl(), type.impl());
 246     FormElementStateMap::iterator it = m_stateForNewFormElements.find(key);
 247     if (it != m_stateForNewFormElements.end()) {
 248         it->value.append(state);
 249     } else {
 250         Deque<FormControlState> stateList;
 251         stateList.append(state);
 252         m_stateForNewFormElements.set(key, stateList);
 253     }
 254     m_controlStateCount++;
 255 }
 256
 257 FormControlState SavedFormState::takeControlState(const AtomicString& name, const AtomicString& type)
 258 {
 259     if (m_stateForNewFormElements.isEmpty())
 260         return FormControlState();
 261     FormElementStateMap::iterator it = m_stateForNewFormElements.find(FormElementKey(name.impl(), type.impl()));
 262     if (it == m_stateForNewFormElements.end())
 263         return FormControlState();
 264     ASSERT(it->value.size());
 265     FormControlState state = it->value.takeFirst();
 266     m_controlStateCount--;
 267     if (!it->value.size())
 268         m_stateForNewFormElements.remove(it);
 269     return state;
 270 }
 271
 272 Vector<String> SavedFormState::getReferencedFilePaths() const
 273 {
 274     Vector<String> toReturn;
 275     for (FormElementStateMap::const_iterator it = m_stateForNewFormElements.begin(); it != m_stateForNewFormElements.end(); ++it) {
 276         const FormElementKey& key = it->key;
 277         if (!equal(key.type(), "file", 4))
 278             continue;
 279         const Deque<FormControlState>& queue = it->value;
 280         for (Deque<FormControlState>::const_iterator queIterator = queue.begin(); queIterator != queue.end(); ++queIterator) {
 281             const Vector<FileChooserFileInfo>& selectedFiles = HTMLInputElement::filesFromFileInputFormControlState(*queIterator);
 282             for (size_t i = 0; i < selectedFiles.size(); ++i)
 283                 toReturn.append(selectedFiles[i].path);
 284         }
 285     }
 286     return toReturn;
 287 }
 288
 289 // ----------------------------------------------------------------------------
 290
 291 class FormKeyGenerator {
 292     WTF_MAKE_NONCOPYABLE(FormKeyGenerator);
 293     WTF_MAKE_FAST_ALLOCATED;
 294
 295 public:
 296     static PassOwnPtr<FormKeyGenerator> create() { return adoptPtr(new FormKeyGenerator); }
 297     const AtomicString& formKey(const HTMLFormControlElementWithState&);
 298     void willDeleteForm(HTMLFormElement*);
 299
 300 private:
 301     FormKeyGenerator() { }
 302
 303     typedef HashMap<HTMLFormElement*, AtomicString> FormToKeyMap;
 304     typedef HashMap<String, unsigned> FormSignatureToNextIndexMap;
 305     FormToKeyMap m_formToKeyMap;
 306     FormSignatureToNextIndexMap m_formSignatureToNextIndexMap;
 307 };
 308
 309 static inline void recordFormStructure(const HTMLFormElement& form, StringBuilder& builder)
 310 {
 311     // 2 is enough to distinguish forms in webkit.org/b/91209#c0
 312     const size_t namedControlsToBeRecorded = 2;
 313     const Vector<FormAssociatedElement*>& controls = form.associatedElements();
 314     builder.append(" [");
 315     for (size_t i = 0, namedControls = 0; i < controls.size() && namedControls < namedControlsToBeRecorded; ++i) {
 316         if (!controls[i]->isFormControlElementWithState())
 317             continue;
 318         HTMLFormControlElementWithState* control = toHTMLFormControlElementWithState(controls[i]);
 319         if (!ownerFormForState(*control))
 320             continue;
 321         AtomicString name = control->name();
 322         if (name.isEmpty())
 323             continue;
 324         namedControls++;
 325         builder.append(name);
 326         builder.append(" ");
 327     }
 328     builder.append("]");
 329 }
 330
 331 static inline String formSignature(const HTMLFormElement& form)
 332 {
 333     KURL actionURL = form.getURLAttribute(actionAttr);
 334     // Remove the query part because it might contain volatile parameters such
 335     // as a session key.
 336     actionURL.setQuery(String());
 337     StringBuilder builder;
 338     if (!actionURL.isEmpty())
 339         builder.append(actionURL.string());
 340
 341     recordFormStructure(form, builder);
 342     return builder.toString();
 343 }
 344
 345 const AtomicString& FormKeyGenerator::formKey(const HTMLFormControlElementWithState& control)
 346 {
 347     HTMLFormElement* form = ownerFormForState(control);
 348     if (!form) {
 349         DEFINE_STATIC_LOCAL(const AtomicString, formKeyForNoOwner, ("No owner", AtomicString::ConstructFromLiteral));
 350         return formKeyForNoOwner;
 351     }
 352     FormToKeyMap::const_iterator it = m_formToKeyMap.find(form);
 353     if (it != m_formToKeyMap.end())
 354         return it->value;
 355
 356     String signature = formSignature(*form);
 357     ASSERT(!signature.isNull());
 358     FormSignatureToNextIndexMap::AddResult result = m_formSignatureToNextIndexMap.add(signature, 0);
 359     unsigned nextIndex = result.iterator->value++;
 360
 361     StringBuilder formKeyBuilder;
 362     formKeyBuilder.append(signature);
 363     formKeyBuilder.appendLiteral(" #");
 364     formKeyBuilder.appendNumber(nextIndex);
 365     FormToKeyMap::AddResult addFormKeyresult = m_formToKeyMap.add(form, formKeyBuilder.toAtomicString());
 366     return addFormKeyresult.iterator->value;
 367 }
 368
 369 void FormKeyGenerator::willDeleteForm(HTMLFormElement* form)
 370 {
 371     ASSERT(form);
 372     m_formToKeyMap.remove(form);
 373 }
 374
 375 // ----------------------------------------------------------------------------
 376
 377 FormController::FormController()
 378 {
 379 }
 380
 381 FormController::~FormController()
 382 {
 383 }
 384
 385 static String formStateSignature()
 386 {
 387     // In the legacy version of serialized state, the first item was a name
 388     // attribute value of a form control. The following string literal should
 389     // contain some characters which are rarely used for name attribute values.
 390     DEFINE_STATIC_LOCAL(String, signature, ("\n\r?% WebKit serialized form state version 8 \n\r=&"));
 391     return signature;
 392 }
 393
 394 PassOwnPtr<FormController::SavedFormStateMap> FormController::createSavedFormStateMap(const FormElementListHashSet& controlList)
 395 {
 396     OwnPtr<FormKeyGenerator> keyGenerator = FormKeyGenerator::create();
 397     OwnPtr<SavedFormStateMap> stateMap = adoptPtr(new SavedFormStateMap);
 398     for (FormElementListHashSet::const_iterator it = controlList.begin(); it != controlList.end(); ++it) {
 399         HTMLFormControlElementWithState* control = (*it).get();
 400         ASSERT(control->inDocument());
 401         if (!control->shouldSaveAndRestoreFormControlState())
 402             continue;
 403         SavedFormStateMap::AddResult result = stateMap->add(keyGenerator->formKey(*control), nullptr);
 404         if (result.isNewEntry)
 405             result.iterator->value = SavedFormState::create();
 406         result.iterator->value->appendControlState(control->name(), control->type(), control->saveFormControlState());
 407     }
 408     return stateMap.release();
 409 }
 410
 411 Vector<String> FormController::formElementsState() const
 412 {
 413     OwnPtr<SavedFormStateMap> stateMap = createSavedFormStateMap(m_formControls);
 414     Vector<String> stateVector;
 415     stateVector.reserveInitialCapacity(m_formControls.size() * 4);
 416     stateVector.append(formStateSignature());
 417     for (SavedFormStateMap::const_iterator it = stateMap->begin(); it != stateMap->end(); ++it) {
 418         stateVector.append(it->key);
 419         it->value->serializeTo(stateVector);
 420     }
 421     bool hasOnlySignature = stateVector.size() == 1;
 422     if (hasOnlySignature)
 423         stateVector.clear();
 424     return stateVector;
 425 }
 426
 427 void FormController::setStateForNewFormElements(const Vector<String>& stateVector)
 428 {
 429     formStatesFromStateVector(stateVector, m_savedFormStateMap);
 430 }
 431
 432 FormControlState FormController::takeStateForFormElement(const HTMLFormControlElementWithState& control)
 433 {
 434     if (m_savedFormStateMap.isEmpty())
 435         return FormControlState();
 436     if (!m_formKeyGenerator)
 437         m_formKeyGenerator = FormKeyGenerator::create();
 438     SavedFormStateMap::iterator it = m_savedFormStateMap.find(m_formKeyGenerator->formKey(control));
 439     if (it == m_savedFormStateMap.end())
 440         return FormControlState();
 441     FormControlState state = it->value->takeControlState(control.name(), control.type());
 442     if (it->value->isEmpty())
 443         m_savedFormStateMap.remove(it);
 444     return state;
 445 }
 446
 447 void FormController::formStatesFromStateVector(const Vector<String>& stateVector, SavedFormStateMap& map)
 448 {
 449     map.clear();
 450
 451     size_t i = 0;
 452     if (stateVector.size() < 1 || stateVector[i++] != formStateSignature())
 453         return;
 454
 455     while (i + 1 < stateVector.size()) {
 456         AtomicString formKey = AtomicString(stateVector[i++]);
 457         OwnPtr<SavedFormState> state = SavedFormState::deserialize(stateVector, i);
 458         if (!state) {
 459             i = 0;
 460             break;
 461         }
 462         map.add(formKey, state.release());
 463     }
 464     if (i != stateVector.size())
 465         map.clear();
 466 }
 467
 468 void FormController::willDeleteForm(HTMLFormElement* form)
 469 {
 470     if (m_formKeyGenerator)
 471         m_formKeyGenerator->willDeleteForm(form);
 472 }
 473
 474 void FormController::restoreControlStateFor(HTMLFormControlElementWithState& control)
 475 {
 476     // We don't save state of a control with shouldSaveAndRestoreFormControlState()
 477     // == false. But we need to skip restoring process too because a control in
 478     // another form might have the same pair of name and type and saved its state.
 479     if (!control.shouldSaveAndRestoreFormControlState())
 480         return;
 481     if (ownerFormForState(control))
 482         return;
 483     FormControlState state = takeStateForFormElement(control);
 484     if (state.valueSize() > 0)
 485         control.restoreFormControlState(state);
 486 }
 487
 488 void FormController::restoreControlStateIn(HTMLFormElement& form)
 489 {
 490     const Vector<FormAssociatedElement*>& elements = form.associatedElements();
 491     for (size_t i = 0; i < elements.size(); ++i) {
 492         if (!elements[i]->isFormControlElementWithState())
 493             continue;
 494         HTMLFormControlElementWithState* control = toHTMLFormControlElementWithState(elements[i]);
 495         if (!control->shouldSaveAndRestoreFormControlState())
 496             continue;
 497         if (ownerFormForState(*control) != &form)
 498             continue;
 499         FormControlState state = takeStateForFormElement(*control);
 500         if (state.valueSize() > 0)
 501             control->restoreFormControlState(state);
 502     }
 503 }
 504
 505 Vector<String> FormController::getReferencedFilePaths(const Vector<String>& stateVector)
 506 {
 507     Vector<String> toReturn;
 508     SavedFormStateMap map;
 509     formStatesFromStateVector(stateVector, map);
 510     for (SavedFormStateMap::const_iterator it = map.begin(); it != map.end(); ++it)
 511         toReturn.append(it->value->getReferencedFilePaths());
 512     return toReturn;
 513 }
 514
 515 void FormController::registerStatefulFormControl(HTMLFormControlElementWithState& control)
 516 {
 517     ASSERT(!m_formControls.contains(&control));
 518     m_formControls.add(&control);
 519 }
 520
 521 void FormController::unregisterStatefulFormControl(HTMLFormControlElementWithState& control)
 522 {
 523     RELEASE_ASSERT(m_formControls.contains(&control));
 524     m_formControls.remove(&control);
 525 }
 526
 527 } // namespace WebCore