Refactor Autofill for out of process iframes (OOPIF).

components/autofill/content/renderer/password_generation_agent.cc

 // Copyright 2013 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 "components/autofill/content/renderer/password_generation_agent.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_generation_util.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/gfx/rect.h"
@@ skipping 70 matching lines @@
     std::vector<blink::WebInputElement>* elements) {
   for (std::vector<blink::WebInputElement>::iterator it = elements->begin();
        it != elements->end(); ++it) {
     it->setValue(value, true /* sendEvents */);
   }
 }
 
 }  // namespace
 
 PasswordGenerationAgent::PasswordGenerationAgent(
-    content::RenderView* render_view)
-    : content::RenderViewObserver(render_view),
-      render_view_(render_view),
+    content::RenderFrame* render_frame)
+    : content::RenderFrameObserver(render_frame),
       password_is_generated_(false),
       password_edited_(false),
       generation_popup_shown_(false),
       editing_popup_shown_(false),
       enabled_(password_generation::IsPasswordGenerationEnabled()) {
   DVLOG(2) << "Password Generation is " << (enabled_ ? "Enabled" : "Disabled");
 }
 PasswordGenerationAgent::~PasswordGenerationAgent() {}
 
-void PasswordGenerationAgent::DidFinishDocumentLoad(
-    blink::WebLocalFrame* frame) {
+void PasswordGenerationAgent::DidFinishDocumentLoad() {
   // In every navigation, the IPC message sent by the password autofill manager
   // to query whether the current form is blacklisted or not happens when the
   // document load finishes, so we need to clear previous states here before we
-  // hear back from the browser. We only clear this state on main frame load
-  // as we don't want subframe loads to clear state that we have received from
-  // the main frame. Note that we assume there is only one account creation
-  // form, but there could be multiple password forms in each frame.
-  if (!frame->parent()) {
-    not_blacklisted_password_form_origins_.clear();
-    generation_enabled_forms_.clear();
-    generation_element_.reset();
-    possible_account_creation_form_.reset(new PasswordForm());
+  // hear back from the browser. Note that we assume there is only one account
+  // creation form, but there could be multiple password forms in each frame.
+  not_blacklisted_password_form_origins_.clear();

[vabr (Chromium), 2014/11/10 14:34:40]

Again, the old code only acted upon main frames, while the new one seems to act
on all frames. That should not be changed.

[Garrett Casto, 2014/11/12 08:09:55]

Confirmed.

[Evan Stade, 2014/11/14 23:25:50]

Reverted. The reason I changed this was that the comment suggested subframe
loads should not clear main frame state. But since state is now per-frame, that
wouldn't happen even without the early return for non-main frames.

+  generation_enabled_forms_.clear();
+  generation_element_.reset();
+  possible_account_creation_form_.reset(new PasswordForm());
 
-    // Log statistics after navigation so that we only log once per page.
-    if (password_elements_.empty()) {
-      password_generation::LogPasswordGenerationEvent(
-          password_generation::NO_SIGN_UP_DETECTED);
-    } else {
-      password_generation::LogPasswordGenerationEvent(
-          password_generation::SIGN_UP_DETECTED);
-    }
-    password_elements_.clear();
-    password_is_generated_ = false;
-    if (password_edited_) {
-      password_generation::LogPasswordGenerationEvent(
-          password_generation::PASSWORD_EDITED);
-    }
-    password_edited_ = false;
+  // Log statistics after navigation so that we only log once per page.
+  if (password_elements_.empty()) {
+    password_generation::LogPasswordGenerationEvent(
+        password_generation::NO_SIGN_UP_DETECTED);
+  } else {
+    password_generation::LogPasswordGenerationEvent(
+        password_generation::SIGN_UP_DETECTED);
+  }
+  password_elements_.clear();
+  password_is_generated_ = false;
+  if (password_edited_) {
+    password_generation::LogPasswordGenerationEvent(
+        password_generation::PASSWORD_EDITED);
+  }
+  password_edited_ = false;
 
-    if (generation_popup_shown_) {
-      password_generation::LogPasswordGenerationEvent(
-          password_generation::GENERATION_POPUP_SHOWN);
-    }
-    generation_popup_shown_ = false;
+  if (generation_popup_shown_) {
+    password_generation::LogPasswordGenerationEvent(
+        password_generation::GENERATION_POPUP_SHOWN);
+  }
+  generation_popup_shown_ = false;
 
-    if (editing_popup_shown_) {
-      password_generation::LogPasswordGenerationEvent(
-          password_generation::EDITING_POPUP_SHOWN);
-    }
-    editing_popup_shown_ = false;
+  if (editing_popup_shown_) {
+    password_generation::LogPasswordGenerationEvent(
+        password_generation::EDITING_POPUP_SHOWN);
   }
+  editing_popup_shown_ = false;
 }
 
-void PasswordGenerationAgent::OnDynamicFormsSeen(blink::WebLocalFrame* frame) {
-  FindPossibleGenerationForm(frame);
+void PasswordGenerationAgent::OnDynamicFormsSeen() {
+  FindPossibleGenerationForm();
 }
 
-void PasswordGenerationAgent::DidFinishLoad(blink::WebLocalFrame* frame) {
-  FindPossibleGenerationForm(frame);
+void PasswordGenerationAgent::DidFinishLoad() {
+  FindPossibleGenerationForm();
 }
 
-void PasswordGenerationAgent::FindPossibleGenerationForm(
-    blink::WebLocalFrame* frame) {
+void PasswordGenerationAgent::FindPossibleGenerationForm() {
   if (!enabled_)
     return;
 
   // We don't want to generate passwords if the browser won't store or sync
   // them.
-  if (!ShouldAnalyzeDocument(frame->document()))
+  if (!ShouldAnalyzeDocument())
     return;
 
   // If we have already found a signup form for this page, no need to continue.
   if (!password_elements_.empty())
     return;
 
   blink::WebVector<blink::WebFormElement> forms;
-  frame->document().forms(forms);
+  render_frame()->GetWebFrame()->document().forms(forms);
   for (size_t i = 0; i < forms.size(); ++i) {
     if (forms[i].isNull())
       continue;
 
     // If we can't get a valid PasswordForm, we skip this form because the
     // the password won't get saved even if we generate it.
     scoped_ptr<PasswordForm> password_form(
         CreatePasswordForm(forms[i]));
     if (!password_form.get()) {
       DVLOG(2) << "Skipping form as it would not be saved";
@@ skipping 11 matching lines @@
       DVLOG(2) << "Account creation form detected";
       password_elements_ = passwords;
       possible_account_creation_form_.swap(password_form);
       DetermineGenerationElement();
       // We assume that there is only one account creation field per URL.
       return;
     }
   }
 }
 
-bool PasswordGenerationAgent::ShouldAnalyzeDocument(
-    const blink::WebDocument& document) const {
+bool PasswordGenerationAgent::ShouldAnalyzeDocument() const {
   // Make sure that this security origin is allowed to use password manager.
   // Generating a password that can't be saved is a bad idea.
-  blink::WebSecurityOrigin origin = document.securityOrigin();
+  blink::WebSecurityOrigin origin =
+      render_frame()->GetWebFrame()->document().securityOrigin();
   if (!origin.canAccessPasswordManager()) {
     DVLOG(1) << "No PasswordManager access";
     return false;
   }
 
   return true;
 }
 
 bool PasswordGenerationAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 19 matching lines @@
   password_is_generated_ = true;
   password_generation::LogPasswordGenerationEvent(
       password_generation::PASSWORD_ACCEPTED);
   for (std::vector<blink::WebInputElement>::iterator it =
            password_elements_.begin();
        it != password_elements_.end(); ++it) {
     it->setValue(password, true /* sendEvents */);
     it->setAutofilled(true);
     // Advance focus to the next input field. We assume password fields in
     // an account creation form are always adjacent.
-    render_view_->GetWebView()->advanceFocus(false);
+    render_frame()->GetRenderView()->GetWebView()->advanceFocus(false);
   }
 }
 
 void PasswordGenerationAgent::OnAccountCreationFormsDetected(
     const std::vector<autofill::FormData>& forms) {
   generation_enabled_forms_.insert(
       generation_enabled_forms_.end(), forms.begin(), forms.end());
   DetermineGenerationElement();
 }
 
@@ skipping 97 matching lines @@
     // Password isn't generated and there are fewer than kMaximumOfferSize
     // characters typed, so keep offering the password. Note this function
     // will just keep the previous popup if one is already showing.
     ShowGenerationPopup();
   }
 
   return true;
 }
 
 void PasswordGenerationAgent::ShowGenerationPopup() {
-  gfx::RectF bounding_box_scaled =
-      GetScaledBoundingBox(render_view_->GetWebView()->pageScaleFactor(),
-                           &generation_element_);
+  gfx::RectF bounding_box_scaled = GetScaledBoundingBox(
+      render_frame()->GetRenderView()->GetWebView()->pageScaleFactor(),
+      &generation_element_);
 
   Send(new AutofillHostMsg_ShowPasswordGenerationPopup(
       routing_id(),
       bounding_box_scaled,
       generation_element_.maxLength(),
       *possible_account_creation_form_));
 
   generation_popup_shown_ = true;
 }
 
 void PasswordGenerationAgent::ShowEditingPopup() {
-  gfx::RectF bounding_box_scaled =
-      GetScaledBoundingBox(render_view_->GetWebView()->pageScaleFactor(),
-                           &generation_element_);
+  gfx::RectF bounding_box_scaled = GetScaledBoundingBox(
+      render_frame()->GetRenderView()->GetWebView()->pageScaleFactor(),
+      &generation_element_);
 
   Send(new AutofillHostMsg_ShowPasswordEditingPopup(
       routing_id(),
       bounding_box_scaled,
       *possible_account_creation_form_));
 
   editing_popup_shown_ = true;
 }
 
 void PasswordGenerationAgent::HidePopup() {
   Send(new AutofillHostMsg_HidePasswordGenerationPopup(routing_id()));
 }
 
 }  // namespace autofill