Don't cache WebFrame pointers for Autofill, as these can become stale.

chrome/renderer/autofill/form_cache.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/autofill/form_cache.h"
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/renderer/autofill/form_autofill_util.h"
 #include "grit/generated_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormControlElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSelectElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVector.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_data_predictions.h"
 #include "webkit/glue/form_field.h"
 #include "webkit/glue/form_field_predictions.h"
 
+using WebKit::WebDocument;
 using WebKit::WebFormControlElement;
 using WebKit::WebFormElement;
 using WebKit::WebFrame;
 using WebKit::WebInputElement;
 using WebKit::WebSelectElement;
 using WebKit::WebString;
 using WebKit::WebVector;
 using webkit_glue::FormData;
 using webkit_glue::FormDataPredictions;
 
@@ skipping 17 matching lines @@
 namespace autofill {
 
 FormCache::FormCache() {
 }
 
 FormCache::~FormCache() {
 }
 
 void FormCache::ExtractForms(const WebFrame& frame,
                              std::vector<FormData>* forms) {
-  // Reset the vector of FormElements for this frame.
+  // Reset the cache for this frame.
   ResetFrame(frame);
-  web_frames_.insert(&frame);
+
+  WebDocument document = frame.document();
+  if (document.isNull())
+    return;
+
+  web_documents_.insert(document);
 
   WebVector<WebFormElement> web_forms;
-  frame.document().forms(web_forms);
+  document.forms(web_forms);
 
   size_t num_fields_seen = 0;
   for (size_t i = 0; i < web_forms.size(); ++i) {
     WebFormElement form_element = web_forms[i];
 
     std::vector<WebFormControlElement> control_elements;
     ExtractAutofillableElements(form_element, &control_elements);
     for (size_t j = 0; j < control_elements.size(); ++j) {
       WebFormControlElement element = control_elements[j];
 
@@ skipping 20 matching lines @@
     num_fields_seen += form.fields.size();
     if (num_fields_seen > kMaxParseableFields)
       break;
 
     if (form.fields.size() >= kRequiredAutofillFields)
       forms->push_back(form);
   }
 }
 
 void FormCache::ResetFrame(const WebFrame& frame) {
-  web_frames_.erase(&frame);
+  std::vector<WebDocument> documents_to_delete;
+  for (std::set<WebDocument>::const_iterator it = web_documents_.begin();
+       it != web_documents_.end(); ++it) {
+    const WebFrame* document_frame = it->frame();
+    if (!document_frame || document_frame == &frame)
+      documents_to_delete.push_back(*it);
+  }
 
-  std::vector<WebSelectElement> to_delete;
+  for (std::vector<WebDocument>::const_iterator it =
+           documents_to_delete.begin();
+       it != documents_to_delete.end(); ++it) {
+    web_documents_.erase(*it);
+  }
+
+  std::vector<WebSelectElement> select_values_to_delete;
   for (std::map<const WebSelectElement, string16>::const_iterator it =
            initial_select_values_.begin();
        it != initial_select_values_.end(); ++it) {
     WebFormElement form_element = it->first.form();
-    if (form_element.isNull() || form_element.document().frame() == &frame)
-      to_delete.push_back(it->first);
+    if (form_element.isNull()) {
+      select_values_to_delete.push_back(it->first);
+    } else {
+      const WebFrame* element_frame = form_element.document().frame();
+      if (!element_frame || element_frame == &frame)
+        select_values_to_delete.push_back(it->first);
+    }
   }
 
   for (std::vector<WebSelectElement>::const_iterator it =
-           to_delete.begin();
-       it != to_delete.end(); ++it) {
+           select_values_to_delete.begin();
+       it != select_values_to_delete.end(); ++it) {
     initial_select_values_.erase(*it);
   }
 }
 
 bool FormCache::ClearFormWithElement(const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
@@ skipping 31 matching lines @@
 
   return true;
 }
 
 bool FormCache::ShowPredictions(const FormDataPredictions& form) {
   DCHECK_EQ(form.data.fields.size(), form.fields.size());
 
   // Find the form.
   bool found_form = false;
   WebFormElement form_element;
-  for (std::set<const WebFrame*>::const_iterator it = web_frames_.begin();
-       it != web_frames_.end() && !found_form; ++it) {
+  for (std::set<WebDocument>::const_iterator it = web_documents_.begin();
+       it != web_documents_.end() && !found_form; ++it) {
     WebVector<WebFormElement> web_forms;
-    (*it)->document().forms(web_forms);
+    it->forms(web_forms);
 
     for (size_t i = 0; i < web_forms.size(); ++i) {
       form_element = web_forms[i];
 
       // Note: matching on the form name here which is not guaranteed to be
       // unique for the page, nor is it guaranteed to be non-empty.  Ideally, we
       // would have a way to uniquely identify the form cross-process.  For now,
       // we'll check form name and form action for identity.
       // Also note that WebString() == WebString(string16()) does not evaluate
       // to |true| -- WebKit distinguishes between a "null" string (lhs) and an
@@ skipping 38 matching lines @@
         UTF8ToUTF16(form.experiment_id));
     if (!element->hasAttribute("placeholder"))
       element->setAttribute("placeholder", WebString(UTF8ToUTF16(placeholder)));
     element->setAttribute("title", WebString(title));
   }
 
   return true;
 }
 
 }  // namespace autofill