Reland: [Autofill] Migrate ContentPasswordManagerDriver<-->Password{Autofill,Generation}Agent IPCs …

components/autofill/content/renderer/password_autofill_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_autofill_agent.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/i18n/case_conversion.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.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/content/renderer/renderer_save_password_progress_logger.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/autofill_util.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
+#include "services/shell/public/cpp/interface_provider.h"
+#include "services/shell/public/cpp/interface_registry.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebAutofillClient.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
@@ skipping 528 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, public:
 
 PasswordAutofillAgent::PasswordAutofillAgent(content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       logging_state_active_(false),
       was_username_autofilled_(false),
-      was_password_autofilled_(false) {
-  Send(new AutofillHostMsg_PasswordAutofillAgentConstructed(routing_id()));
+      was_password_autofilled_(false),
+      binding_(this) {
+  // PasswordAutofillAgent is guaranteed to outlive |render_frame|.
+  render_frame->GetInterfaceRegistry()->AddInterface(
+      base::Bind(&PasswordAutofillAgent::BindRequest, base::Unretained(this)));
+  GetPasswordManagerDriver()->PasswordAutofillAgentConstructed();
 }
 
 PasswordAutofillAgent::~PasswordAutofillAgent() {
 }
 
+void PasswordAutofillAgent::BindRequest(
+    mojom::PasswordAutofillAgentRequest request) {
+  binding_.Bind(std::move(request));
+}
+
 void PasswordAutofillAgent::SetAutofillAgent(AutofillAgent* autofill_agent) {
   autofill_agent_ = autofill_agent;
 }
 
 PasswordAutofillAgent::PasswordValueGatekeeper::PasswordValueGatekeeper()
     : was_user_gesture_seen_(false) {
 }
 
 PasswordAutofillAgent::PasswordValueGatekeeper::~PasswordValueGatekeeper() {
 }
@@ skipping 314 matching lines @@
   if (form_util::IsFormVisible(frame, provisionally_saved_form_->action,
                                provisionally_saved_form_->origin,
                                provisionally_saved_form_->form_data) ||
       IsUnownedPasswordFormVisible(frame, provisionally_saved_form_->action,
                                    provisionally_saved_form_->origin,
                                    provisionally_saved_form_->form_data,
                                    form_predictions_)) {
     return;
   }
 
-  Send(new AutofillHostMsg_InPageNavigation(routing_id(),
-                                            *provisionally_saved_form_));
+  GetPasswordManagerDriver()->InPageNavigation(*provisionally_saved_form_);
   provisionally_saved_form_.reset();
 }
 
 void PasswordAutofillAgent::FirstUserGestureObserved() {
   gatekeeper_.OnUserGesture();
 }
 
 void PasswordAutofillAgent::SendPasswordForms(bool only_visible) {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_SEND_PASSWORD_FORMS_METHOD);
     logger->LogBoolean(Logger::STRING_ONLY_VISIBLE, only_visible);
   }
 
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   // Make sure that this security origin is allowed to use password manager.
   blink::WebSecurityOrigin origin = frame->document().getSecurityOrigin();
   if (logger) {
     logger->LogURL(Logger::STRING_SECURITY_ORIGIN,
                    GURL(origin.toString().utf8()));
@@ skipping 74 matching lines @@
   if (password_forms.empty() && !only_visible) {
     // We need to send the PasswordFormsRendered message regardless of whether
     // there are any forms visible, as this is also the code path that triggers
     // showing the infobar.
     return;
   }
 
   if (only_visible) {
     blink::WebFrame* main_frame = render_frame()->GetWebFrame()->top();
     bool did_stop_loading = !main_frame || !main_frame->isLoading();
-    Send(new AutofillHostMsg_PasswordFormsRendered(routing_id(), password_forms,
-                                                   did_stop_loading));
+    GetPasswordManagerDriver()->PasswordFormsRendered(password_forms,
+                                                      did_stop_loading);
   } else {
-    Send(new AutofillHostMsg_PasswordFormsParsed(routing_id(), password_forms));
+    GetPasswordManagerDriver()->PasswordFormsParsed(password_forms);
   }
 }
 
-bool PasswordAutofillAgent::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PasswordAutofillAgent, message)
-    IPC_MESSAGE_HANDLER(AutofillMsg_FillPasswordForm, OnFillPasswordForm)
-    IPC_MESSAGE_HANDLER(AutofillMsg_SetLoggingState, OnSetLoggingState)
-    IPC_MESSAGE_HANDLER(AutofillMsg_AutofillUsernameAndPasswordDataReceived,
-                        OnAutofillUsernameAndPasswordDataReceived)
-    IPC_MESSAGE_HANDLER(AutofillMsg_FindFocusedPasswordForm,
-                        OnFindFocusedPasswordForm)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
 void PasswordAutofillAgent::DidFinishDocumentLoad() {
   // The |frame| contents have been parsed, but not yet rendered.  Let the
   // PasswordManager know that forms are loaded, even though we can't yet tell
   // whether they're visible.
   form_util::ScopedLayoutPreventer layout_preventer;
   SendPasswordForms(false);
 }
 
 void PasswordAutofillAgent::DidFinishLoad() {
   // The |frame| contents have been rendered.  Let the PasswordManager know
@@ skipping 13 matching lines @@
     OnSamePageNavigationCompleted();
   }
 }
 
 void PasswordAutofillAgent::FrameDetached() {
   // If a sub frame has been destroyed while the user was entering information
   // into a password form, try to save the data. See https://crbug.com/450806
   // for examples of sites that perform login using this technique.
   if (render_frame()->GetWebFrame()->parent() &&
       ProvisionallySavedPasswordIsValid()) {
-    Send(new AutofillHostMsg_InPageNavigation(routing_id(),
-                                              *provisionally_saved_form_));
+    GetPasswordManagerDriver()->InPageNavigation(*provisionally_saved_form_);
   }
   FrameClosing();
 }
 
 void PasswordAutofillAgent::WillSendSubmitEvent(
     const blink::WebFormElement& form) {
   // Forms submitted via XHR are not seen by WillSubmitForm if the default
   // onsubmit handler is overridden. Such submission first gets detected in
   // DidStartProvisionalLoad, which no longer knows about the particular form,
   // and uses the candidate stored in |provisionally_saved_form_|.
   //
   // User-typed password will get stored to |provisionally_saved_form_| in
   // TextDidChangeInTextField. Autofilled or JavaScript-copied passwords need to
   // be saved here.
   //
   // Only non-empty passwords are saved here. Empty passwords were likely
   // cleared by some scripts (http://crbug.com/28910, http://crbug.com/391693).
   // Had the user cleared the password, |provisionally_saved_form_| would
   // already have been updated in TextDidChangeInTextField.
   std::unique_ptr<PasswordForm> password_form = CreatePasswordFormFromWebForm(
       form, &field_value_and_properties_map_, &form_predictions_);
   ProvisionallySavePassword(std::move(password_form),
                             RESTRICTION_NON_EMPTY_PASSWORD);
 }
 
 void PasswordAutofillAgent::WillSubmitForm(const blink::WebFormElement& form) {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_WILL_SUBMIT_FORM_METHOD);
     LogHTMLForm(logger.get(), Logger::STRING_HTML_FORM_FOR_SUBMIT, form);
   }
 
   std::unique_ptr<PasswordForm> submitted_form = CreatePasswordFormFromWebForm(
       form, &field_value_and_properties_map_, &form_predictions_);
 
   // If there is a provisionally saved password, copy over the previous
   // password value so we get the user's typed password, not the value that
   // may have been transformed for submit.
@@ skipping 13 matching lines @@
       submitted_form->new_password_value =
           provisionally_saved_form_->new_password_value;
       submitted_form->username_value =
           provisionally_saved_form_->username_value;
     }
 
     // Some observers depend on sending this information now instead of when
     // the frame starts loading. If there are redirects that cause a new
     // RenderView to be instantiated (such as redirects to the WebStore)
     // we will never get to finish the load.
-    Send(new AutofillHostMsg_PasswordFormSubmitted(routing_id(),
-                                                   *submitted_form));
+    GetPasswordManagerDriver()->PasswordFormSubmitted(*submitted_form);
     provisionally_saved_form_.reset();
   } else if (logger) {
     logger->LogMessage(Logger::STRING_FORM_IS_NOT_PASSWORD);
   }
 }
 
 void PasswordAutofillAgent::OnDestruct() {
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }
 
 void PasswordAutofillAgent::DidStartProvisionalLoad() {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_DID_START_PROVISIONAL_LOAD_METHOD);
   }
 
   const blink::WebLocalFrame* navigated_frame = render_frame()->GetWebFrame();
   if (navigated_frame->parent()) {
     if (logger)
       logger->LogMessage(Logger::STRING_FRAME_NOT_MAIN_FRAME);
     return;
   }
 
   // Bug fix for crbug.com/368690. isProcessingUserGesture() is false when
   // the user is performing actions outside the page (e.g. typed url,
   // history navigation). We don't want to trigger saving in these cases.
   content::DocumentState* document_state =
       content::DocumentState::FromDataSource(
           navigated_frame->provisionalDataSource());
   content::NavigationState* navigation_state =
       document_state->navigation_state();
   ui::PageTransition type = navigation_state->GetTransitionType();
   if (ui::PageTransitionIsWebTriggerable(type) &&
       ui::PageTransitionIsNewNavigation(type) &&
       !blink::WebUserGestureIndicator::isProcessingUserGesture()) {
     // If onsubmit has been called, try and save that form.
     if (provisionally_saved_form_) {
       if (logger) {
         logger->LogPasswordForm(
             Logger::STRING_PROVISIONALLY_SAVED_FORM_FOR_FRAME,
             *provisionally_saved_form_);
       }
-      Send(new AutofillHostMsg_PasswordFormSubmitted(
-          routing_id(), *provisionally_saved_form_));
+      GetPasswordManagerDriver()->PasswordFormSubmitted(
+          *provisionally_saved_form_);
       provisionally_saved_form_.reset();
     } else {
       ScopedVector<PasswordForm> possible_submitted_forms;
       // Loop through the forms on the page looking for one that has been
       // filled out. If one exists, try and save the credentials.
       blink::WebVector<blink::WebFormElement> forms;
       render_frame()->GetWebFrame()->document().forms(forms);
 
       bool password_forms_found = false;
       for (size_t i = 0; i < forms.size(); ++i) {
@@ skipping 13 matching lines @@
               &form_predictions_));
 
       for (const PasswordForm* password_form : possible_submitted_forms) {
         if (password_form && !password_form->username_value.empty() &&
             FormContainsNonDefaultPasswordValue(*password_form)) {
           password_forms_found = true;
           if (logger) {
             logger->LogPasswordForm(Logger::STRING_PASSWORD_FORM_FOUND_ON_PAGE,
                                     *password_form);
           }
-          Send(new AutofillHostMsg_PasswordFormSubmitted(routing_id(),
-                                                         *password_form));
+          GetPasswordManagerDriver()->PasswordFormSubmitted(*password_form);
           break;
         }
       }
 
       if (!password_forms_found && logger)
         logger->LogMessage(Logger::STRING_PASSWORD_FORM_NOT_FOUND_ON_PAGE);
     }
   }
 
   // This is a new navigation, so require a new user gesture before filling in
   // passwords.
   gatekeeper_.Reset();
 }
 
-void PasswordAutofillAgent::OnFillPasswordForm(
+// mojom::PasswordAutofillAgent:
+void PasswordAutofillAgent::FillPasswordForm(
     int key,
     const PasswordFormFillData& form_data) {
   std::vector<blink::WebInputElement> elements;
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
-    logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
+    logger.reset(new RendererSavePasswordProgressLogger(
+        GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_ON_FILL_PASSWORD_FORM_METHOD);
   }
   GetFillableElementFromFormData(key, form_data, logger.get(), &elements);
 
   // If wait_for_username is true, we don't want to initially fill the form
   // until the user types in a valid username.
   if (form_data.wait_for_username)
     return;
 
   for (auto element : elements) {
@@ skipping 99 matching lines @@
   const blink::WebElement web_element = node.toConst<blink::WebElement>();
   if (!web_element.isFormControlElement())
     return;
   const blink::WebFormControlElement control_element =
       web_element.toConst<blink::WebFormControlElement>();
   UpdateFieldValueAndPropertiesMaskMap(control_element, nullptr,
                                        FieldPropertiesFlags::HAD_FOCUS,
                                        &field_value_and_properties_map_);
 }
 
-void PasswordAutofillAgent::OnSetLoggingState(bool active) {
+// mojom::PasswordAutofillAgent:
+void PasswordAutofillAgent::SetLoggingState(bool active) {
   logging_state_active_ = active;
 }
 
-void PasswordAutofillAgent::OnAutofillUsernameAndPasswordDataReceived(
+void PasswordAutofillAgent::AutofillUsernameAndPasswordDataReceived(
     const FormsPredictionsMap& predictions) {
   form_predictions_.insert(predictions.begin(), predictions.end());
 }
 
-void PasswordAutofillAgent::OnFindFocusedPasswordForm() {
+void PasswordAutofillAgent::FindFocusedPasswordForm(
+    const FindFocusedPasswordFormCallback& callback) {
   std::unique_ptr<PasswordForm> password_form;
 
   blink::WebElement element =
       render_frame()->GetWebFrame()->document().focusedElement();
   if (!element.isNull() && element.hasHTMLTagName("input")) {
     blink::WebInputElement input = element.to<blink::WebInputElement>();
     if (input.isPasswordField() && !input.form().isNull()) {
       if (!input.form().isNull()) {
         password_form = CreatePasswordFormFromWebForm(
             input.form(), &field_value_and_properties_map_, &form_predictions_);
       } else {
         password_form = CreatePasswordFormFromUnownedInputElements(
             *render_frame()->GetWebFrame(), &field_value_and_properties_map_,
             &form_predictions_);
         // Only try to use this form if |input| is one of the password elements
         // for |password_form|.
         if (password_form->password_element != input.nameForAutofill() &&
             password_form->new_password_element != input.nameForAutofill())
           password_form.reset();
       }
     }
   }
 
   if (!password_form)
     password_form.reset(new PasswordForm());
 
-  Send(new AutofillHostMsg_FocusedPasswordFormFound(
-      routing_id(), *password_form));
+  callback.Run(*password_form);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, private:
 
 bool PasswordAutofillAgent::ShowSuggestionPopup(
     const PasswordInfo& password_info,
     const blink::WebInputElement& user_input,
     bool show_all,
     bool show_on_password_field) {
@@ skipping 20 matching lines @@
   if (show_all)
     options |= SHOW_ALL;
   if (show_on_password_field)
     options |= IS_PASSWORD_FIELD;
 
   base::string16 username_string(
       user_input.isPasswordField()
           ? base::string16()
           : static_cast<base::string16>(user_input.value()));
 
-  Send(new AutofillHostMsg_ShowPasswordSuggestions(
-      routing_id(), password_info.key, field.text_direction, username_string,
-      options,
-      render_frame()->GetRenderView()->ElementBoundsInWindow(user_input)));
+  GetPasswordManagerDriver()->ShowPasswordSuggestions(
+      password_info.key, field.text_direction, username_string, options,
+      render_frame()->GetRenderView()->ElementBoundsInWindow(user_input));
   username_query_prefix_ = username_string;
   return CanShowSuggestion(password_info.fill_data, username_string, show_all);
 }
 
 void PasswordAutofillAgent::FrameClosing() {
   for (auto const& iter : web_input_to_password_info_) {
     password_to_username_.erase(iter.second.password_field);
   }
   web_input_to_password_info_.clear();
   provisionally_saved_form_.reset();
@@ skipping 31 matching lines @@
          !provisionally_saved_form_->username_value.empty() &&
          !(provisionally_saved_form_->password_value.empty() &&
          provisionally_saved_form_->new_password_value.empty());
 }
 
 const mojom::AutofillDriverPtr& PasswordAutofillAgent::GetAutofillDriver() {
   DCHECK(autofill_agent_);
   return autofill_agent_->GetAutofillDriver();
 }
 
+const mojom::PasswordManagerDriverPtr&
+PasswordAutofillAgent::GetPasswordManagerDriver() {
+  if (!password_manager_driver_) {
+    render_frame()->GetRemoteInterfaces()->GetInterface(
+        mojo::GetProxy(&password_manager_driver_));
+  }
+
+  return password_manager_driver_;
+}
+
 }  // namespace autofill