Remove autocheckout code.

components/autofill/content/renderer/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/autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
@@ skipping 45 matching lines @@
 namespace {
 
 // The size above which we stop triggering autofill for an input text field
 // (so to avoid sending long strings through IPC).
 const size_t kMaximumTextSizeForAutofill = 1000;
 
 // The maximum number of data list elements to send to the browser process
 // via IPC (to prevent long IPC messages).
 const size_t kMaximumDataListSizeForAutofill = 30;
 
-const int kAutocheckoutClickTimeout = 3;
-
 
 // Gets all the data list values (with corresponding label) for the given
 // element.
 void GetDataListSuggestions(const WebKit::WebInputElement& element,
                             std::vector<base::string16>* values,
                             std::vector<base::string16>* labels) {
   WebNodeCollection options = element.dataListOptions();
   if (options.isNull())
     return;
 
@@ skipping 45 matching lines @@
 }  // namespace
 
 namespace autofill {
 
 AutofillAgent::AutofillAgent(content::RenderView* render_view,
                              PasswordAutofillAgent* password_autofill_agent)
     : content::RenderViewObserver(render_view),
       password_autofill_agent_(password_autofill_agent),
       autofill_query_id_(0),
       autofill_action_(AUTOFILL_NONE),
-      topmost_frame_(NULL),
       web_view_(render_view->GetWebView()),
       display_warning_if_disabled_(false),
       was_query_node_autofilled_(false),
       has_shown_autofill_popup_for_current_edit_(false),
       did_set_node_text_(false),
-      autocheckout_click_in_progress_(false),
-      is_autocheckout_supported_(false),
       has_new_forms_for_browser_(false),
       ignore_text_changes_(false),
       weak_ptr_factory_(this) {
   render_view->GetWebView()->setAutofillClient(this);
 
   // The PageClickTracker is a RenderViewObserver, and hence will be freed when
   // the RenderView is destroyed.
   new PageClickTracker(render_view, this);
 }
 
 AutofillAgent::~AutofillAgent() {}
 
 bool AutofillAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AutofillAgent, message)
-    IPC_MESSAGE_HANDLER(AutofillMsg_GetAllForms, OnGetAllForms)
     IPC_MESSAGE_HANDLER(AutofillMsg_FormDataFilled, OnFormDataFilled)
     IPC_MESSAGE_HANDLER(AutofillMsg_FieldTypePredictionsAvailable,
                         OnFieldTypePredictionsAvailable)
     IPC_MESSAGE_HANDLER(AutofillMsg_SetAutofillActionFill,
                         OnSetAutofillActionFill)
     IPC_MESSAGE_HANDLER(AutofillMsg_ClearForm,
                         OnClearForm)
     IPC_MESSAGE_HANDLER(AutofillMsg_SetAutofillActionPreview,
                         OnSetAutofillActionPreview)
     IPC_MESSAGE_HANDLER(AutofillMsg_ClearPreviewedForm,
                         OnClearPreviewedForm)
     IPC_MESSAGE_HANDLER(AutofillMsg_SetNodeText,
                         OnSetNodeText)
     IPC_MESSAGE_HANDLER(AutofillMsg_AcceptDataListSuggestion,
                         OnAcceptDataListSuggestion)
     IPC_MESSAGE_HANDLER(AutofillMsg_AcceptPasswordAutofillSuggestion,
                         OnAcceptPasswordAutofillSuggestion)
     IPC_MESSAGE_HANDLER(AutofillMsg_RequestAutocompleteResult,
                         OnRequestAutocompleteResult)
-    IPC_MESSAGE_HANDLER(AutofillMsg_FillFormsAndClick,
-                        OnFillFormsAndClick)
-    IPC_MESSAGE_HANDLER(AutofillMsg_AutocheckoutSupported,
-                        OnAutocheckoutSupported)
     IPC_MESSAGE_HANDLER(AutofillMsg_PageShown,
                         OnPageShown)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void AutofillAgent::DidFinishDocumentLoad(WebFrame* frame) {
   // Record timestamp on document load. This is used to record overhead of
   // Autofill feature.
   forms_seen_timestamp_ = base::TimeTicks::Now();
 
   // The document has now been fully loaded.  Scan for forms to be sent up to
   // the browser.
   std::vector<FormData> forms;
   bool has_more_forms = false;
   if (!frame->parent()) {
-    topmost_frame_ = frame;
     form_elements_.clear();
     has_more_forms = form_cache_.ExtractFormsAndFormElements(
         *frame, kRequiredAutofillFields, &forms, &form_elements_);
   } else {
     form_cache_.ExtractForms(*frame, &forms);
   }
 
   autofill::FormsSeenState state = has_more_forms ?
       autofill::PARTIAL_FORMS_SEEN : autofill::NO_SPECIAL_FORMS_SEEN;
 
   // Always communicate to browser process for topmost frame.
   if (!forms.empty() || !frame->parent()) {
     Send(new AutofillHostMsg_FormsSeen(routing_id(), forms,
                                        forms_seen_timestamp_,
                                        state));
   }
 }
 
-void AutofillAgent::DidStartProvisionalLoad(WebFrame* frame) {
-  if (!frame->parent()) {
-    is_autocheckout_supported_ = false;
-    topmost_frame_ = NULL;
-    if (click_timer_.IsRunning()) {
-      click_timer_.Stop();
-      autocheckout_click_in_progress_ = true;
-    }
-  }
-}
-
-void AutofillAgent::DidFailProvisionalLoad(WebFrame* frame,
-                                           const WebKit::WebURLError& error) {
-  if (!frame->parent() && autocheckout_click_in_progress_) {
-    autocheckout_click_in_progress_ = false;
-    ClickFailed();
-  }
-}
-
 void AutofillAgent::DidCommitProvisionalLoad(WebFrame* frame,
                                              bool is_new_navigation) {
   in_flight_request_form_.reset();
-  if (!frame->parent() && autocheckout_click_in_progress_) {
-    autocheckout_click_in_progress_ = false;
-    CompleteAutocheckoutPage(SUCCESS);
-  }
 }
 
 void AutofillAgent::FrameDetached(WebFrame* frame) {
   form_cache_.ResetFrame(*frame);
-  if (!frame->parent()) {
-    // |frame| is about to be destroyed so we need to clear |top_most_frame_|.
-    topmost_frame_ = NULL;
-    click_timer_.Stop();
-  }
 }
 
 void AutofillAgent::WillSubmitForm(WebFrame* frame,
                                    const WebFormElement& form) {
   FormData form_data;
   if (WebFormElementToFormData(form,
                                WebFormControlElement(),
                                REQUIRE_AUTOCOMPLETE,
                                static_cast<ExtractMask>(
                                    EXTRACT_VALUE | EXTRACT_OPTION_TEXT),
@@ skipping 20 matching lines @@
   if (!web_element.document().frame())
       return;
 
   const WebInputElement* element = toWebInputElement(&web_element);
 
   if (!element || !element->isEnabled() || element->isReadOnly() ||
       !element->isTextField() || element->isPasswordField())
     return;
 
   element_ = *element;
-
-  MaybeShowAutocheckoutBubble();
 }
 
 void AutofillAgent::OrientationChangeEvent(int orientation) {
   HideAutofillUI();
 }
 
-void AutofillAgent::MaybeShowAutocheckoutBubble() {
-  if (element_.isNull() || !element_.focused())
-    return;
-
-  FormData form;
-  FormFieldData field;
-  // This must be called to short circuit this method if it fails.
-  if (!FindFormAndFieldForInputElement(element_, &form, &field, REQUIRE_NONE))
-    return;
-
-  Send(new AutofillHostMsg_MaybeShowAutocheckoutBubble(
-      routing_id(),
-      form,
-      GetScaledBoundingBox(web_view_->pageScaleFactor(), &element_)));
-}
-
 void AutofillAgent::DidChangeScrollOffset(WebKit::WebFrame*) {
   HideAutofillUI();
 }
 
 void AutofillAgent::didRequestAutocomplete(WebKit::WebFrame* frame,
                                            const WebFormElement& form) {
   GURL url(frame->document().url());
   content::SSLStatus ssl_status = render_view()->GetSSLStatusOfFrame(frame);
   FormData form_data;
   if (!in_flight_request_form_.isNull() ||
@@ skipping 196 matching lines @@
     const base::string16& value) {
   // We need to make sure this is handled here because the browser process
   // skipped it handling because it believed it would be handled here. If it
   // isn't handled here then the browser logic needs to be updated.
   bool handled = password_autofill_agent_->DidAcceptAutofillSuggestion(
       element_,
       value);
   DCHECK(handled);
 }
 
-void AutofillAgent::OnGetAllForms() {
-  form_elements_.clear();
-
-  // Force fetch all non empty forms.
-  std::vector<FormData> forms;
-  form_cache_.ExtractFormsAndFormElements(
-      *topmost_frame_, 0, &forms, &form_elements_);
-
-  // OnGetAllForms should only be called if AutofillAgent reported to
-  // AutofillManager that there are more forms
-  DCHECK(!forms.empty());
-
-  // Report to AutofillManager that all forms are being sent.
-  Send(new AutofillHostMsg_FormsSeen(routing_id(), forms,
-                                     forms_seen_timestamp_,
-                                     NO_SPECIAL_FORMS_SEEN));
-}
-
 void AutofillAgent::OnRequestAutocompleteResult(
     WebFormElement::AutocompleteResult result, const FormData& form_data) {
   if (in_flight_request_form_.isNull())
     return;
 
   if (result == WebFormElement::AutocompleteResultSuccess) {
     FillFormIncludingNonFocusableElements(form_data, in_flight_request_form_);
     if (!in_flight_request_form_.checkValidityWithoutDispatchingEvents())
       result = WebFormElement::AutocompleteResultErrorInvalid;
   }
 
   in_flight_request_form_.finishRequestAutocomplete(result);
   in_flight_request_form_.reset();
 }
 
-void AutofillAgent::OnFillFormsAndClick(
-    const std::vector<FormData>& forms,
-    const std::vector<WebElementDescriptor>& click_elements_before_form_fill,
-    const std::vector<WebElementDescriptor>& click_elements_after_form_fill,
-    const WebElementDescriptor& click_element_descriptor) {
-  DCHECK_EQ(forms.size(), form_elements_.size());
-
-  // Click elements in click_elements_before_form_fill.
-  for (size_t i = 0; i < click_elements_before_form_fill.size(); ++i) {
-    if (!ClickElement(topmost_frame_->document(),
-                      click_elements_before_form_fill[i])) {
-      CompleteAutocheckoutPage(MISSING_CLICK_ELEMENT_BEFORE_FORM_FILLING);
-      return;
-    }
-  }
-
-  // Fill the form.
-  for (size_t i = 0; i < forms.size(); ++i)
-    FillFormForAllElements(forms[i], form_elements_[i]);
-
-  // Click elements in click_elements_after_form_fill.
-  for (size_t i = 0; i < click_elements_after_form_fill.size(); ++i) {
-    if (!ClickElement(topmost_frame_->document(),
-                      click_elements_after_form_fill[i])) {
-      CompleteAutocheckoutPage(MISSING_CLICK_ELEMENT_AFTER_FORM_FILLING);
-      return;
-    }
-  }
-
-  // Exit early if there is nothing to click.
-  if (click_element_descriptor.retrieval_method == WebElementDescriptor::NONE) {
-    CompleteAutocheckoutPage(SUCCESS);
-    return;
-  }
-
-  // It's possible that clicking the element to proceed in an Autocheckout
-  // flow will not actually proceed to the next step in the flow, e.g. there
-  // is a new required field that Autocheckout does not know how to fill.  In
-  // order to capture this case and present the user with an error a timer is
-  // set that informs the browser of the error. |click_timer_| has to be started
-  // before clicking so it can start before DidStartProvisionalLoad started.
-  click_timer_.Start(FROM_HERE,
-                     base::TimeDelta::FromSeconds(kAutocheckoutClickTimeout),
-                     this,
-                     &AutofillAgent::ClickFailed);
-  if (!ClickElement(topmost_frame_->document(),
-                    click_element_descriptor)) {
-    CompleteAutocheckoutPage(MISSING_ADVANCE);
-  }
-}
-
-void AutofillAgent::OnAutocheckoutSupported() {
-  is_autocheckout_supported_ = true;
-  if (has_new_forms_for_browser_)
-    MaybeSendDynamicFormsSeen();
-  MaybeShowAutocheckoutBubble();
-}
-
 void AutofillAgent::OnPageShown() {
-  if (is_autocheckout_supported_)
-    MaybeShowAutocheckoutBubble();
-}
-
-void AutofillAgent::CompleteAutocheckoutPage(
-    autofill::AutocheckoutStatus status) {
-  click_timer_.Stop();
-  Send(new AutofillHostMsg_AutocheckoutPageCompleted(routing_id(), status));
-}
-
-void AutofillAgent::ClickFailed() {
-  CompleteAutocheckoutPage(CANNOT_PROCEED);
 }
 
 void AutofillAgent::ShowSuggestions(const WebInputElement& element,
                                     bool autofill_on_empty_values,
                                     bool requires_caret_at_end,
                                     bool display_warning_if_disabled) {
   if (!element.isEnabled() || element.isReadOnly() || !element.isTextField() ||
       element.isPasswordField() || !element.suggestedValue().isEmpty())
     return;
 
@@ skipping 100 matching lines @@
   base::string16 substring = value;
   substring = substring.substr(0, node->maxLength());
 
   node->setEditingValue(substring);
 }
 
 void AutofillAgent::HideAutofillUI() {
   Send(new AutofillHostMsg_HideAutofillUI(routing_id()));
 }
 
+// TODO(isherman): Decide if we want to support autofill with AJAX.
 void AutofillAgent::didAssociateFormControls(
     const WebKit::WebVector<WebKit::WebNode>& nodes) {
-  for (size_t i = 0; i < nodes.size(); ++i) {
-    WebKit::WebNode node = nodes[i];
-    if (node.document().frame() == topmost_frame_) {
-      forms_seen_timestamp_ = base::TimeTicks::Now();
-      has_new_forms_for_browser_ = true;
-      break;
-    }
-  }
-
-  if (has_new_forms_for_browser_ && is_autocheckout_supported_)
-    MaybeSendDynamicFormsSeen();
-}
-
-void AutofillAgent::MaybeSendDynamicFormsSeen() {
-  has_new_forms_for_browser_ = false;
-  form_elements_.clear();
-  std::vector<FormData> forms;
-  // This will only be called for Autocheckout flows, so send all forms to
-  // save an IPC.
-  form_cache_.ExtractFormsAndFormElements(
-      *topmost_frame_, 0, &forms, &form_elements_);
-  autofill::FormsSeenState state = autofill::DYNAMIC_FORMS_SEEN;
-
-  if (!forms.empty()) {
-    if (click_timer_.IsRunning())
-      click_timer_.Stop();
-    Send(new AutofillHostMsg_FormsSeen(routing_id(), forms,
-                                       forms_seen_timestamp_,
-                                       state));
-  }
 }
 
 }  // namespace autofill