Refactor Autofill for out of process iframes (OOPIF).

components/autofill/content/renderer/autofill_agent.h

 // 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.
 
 #ifndef COMPONENTS_AUTOFILL_CONTENT_RENDERER_AUTOFILL_AGENT_H_
 #define COMPONENTS_AUTOFILL_CONTENT_RENDERER_AUTOFILL_AGENT_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "components/autofill/content/renderer/form_cache.h"
 #include "components/autofill/content/renderer/page_click_listener.h"
+#include "components/autofill/content/renderer/page_click_tracker.h"
+#include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/render_view_observer.h"
 #include "third_party/WebKit/public/web/WebAutofillClient.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 
 namespace blink {
 class WebNode;
 class WebView;
 }
 
 namespace autofill {
 
 struct FormData;
 struct FormFieldData;
 struct WebElementDescriptor;
 class PasswordAutofillAgent;
 class PasswordGenerationAgent;
 
 // AutofillAgent deals with Autofill related communications between WebKit and
-// the browser.  There is one AutofillAgent per RenderView.
-// This code was originally part of RenderView.
+// the browser.  There is one AutofillAgent per RenderFrame.
 // Note that Autofill encompasses:
 // - single text field suggestions, that we usually refer to as Autocomplete,
 // - password form fill, refered to as Password Autofill, and
 // - entire form fill based on one field entry, referred to as Form Autofill.
 
-class AutofillAgent : public content::RenderViewObserver,
+class AutofillAgent : public content::RenderFrameObserver,
                       public PageClickListener,
                       public blink::WebAutofillClient {
  public:
   // PasswordAutofillAgent is guaranteed to outlive AutofillAgent.
   // PasswordGenerationAgent may be NULL. If it is not, then it is also
   // guaranteed to outlive AutofillAgent.
-  AutofillAgent(content::RenderView* render_view,
+  AutofillAgent(content::RenderFrame* render_frame,
                 PasswordAutofillAgent* password_autofill_manager,
                 PasswordGenerationAgent* password_generation_agent);
   virtual ~AutofillAgent();
 
  private:
-  // content::RenderViewObserver:
+  // Thunk class for RenderViewObserver methods that haven't yet been migrated
+  // to RenderFrameObserver. Should eventually be removed.
+  // http://crbug.com/433486
+  class LegacyAutofillAgent : public content::RenderViewObserver {
+   public:
+    LegacyAutofillAgent(content::RenderView* render_view, AutofillAgent* agent);
+    ~LegacyAutofillAgent() override;
+
+   private:
+    // content::RenderViewObserver:
+    void OnDestruct() override;
+    void FrameDetached(blink::WebFrame* frame) override;
+    void WillSubmitForm(blink::WebLocalFrame* frame,
+                        const blink::WebFormElement& form) override;
+    void DidChangeScrollOffset(blink::WebLocalFrame* frame) override;
+    void FocusedNodeChanged(const blink::WebNode& node) override;
+    void OrientationChangeEvent() override;
+    void Resized() override;
+    void FrameWillClose(blink::WebFrame* frame) override;
+
+    AutofillAgent* agent_;
+
+    DISALLOW_COPY_AND_ASSIGN(LegacyAutofillAgent);
+  };
+  friend class LegacyAutofillAgent;
+
+  // content::RenderFrameObserver:
   bool OnMessageReceived(const IPC::Message& message) override;
-  void DidFinishDocumentLoad(blink::WebLocalFrame* frame) override;
-  void DidCommitProvisionalLoad(blink::WebLocalFrame* frame,
-                                bool is_new_navigation) override;
-  void FrameDetached(blink::WebFrame* frame) override;
-  void FrameWillClose(blink::WebFrame* frame) override;
+  void DidCommitProvisionalLoad(bool is_new_navigation) override;
+  void DidFinishDocumentLoad() override;
+
+  // Pass-throughs from LegacyAutofillAgent. These correlate with
+  // RenderViewObserver methods.
+  void FrameDetached(blink::WebFrame* frame);
   void WillSubmitForm(blink::WebLocalFrame* frame,
-                      const blink::WebFormElement& form) override;
-  void DidChangeScrollOffset(blink::WebLocalFrame* frame) override;
-  void FocusedNodeChanged(const blink::WebNode& node) override;
-  void OrientationChangeEvent() override;
-  void Resized() override;
+                      const blink::WebFormElement& form);
+  void DidChangeScrollOffset(blink::WebLocalFrame* frame);
+  void FocusedNodeChanged(const blink::WebNode& node);
+  void OrientationChangeEvent();
+  void Resized();
+  void LegacyFrameWillClose(blink::WebFrame* frame);
 
   // PageClickListener:
   void FormControlElementClicked(const blink::WebFormControlElement& element,
                                  bool was_focused) override;
 
   // blink::WebAutofillClient:
   virtual void textFieldDidEndEditing(
       const blink::WebInputElement& element);
   virtual void textFieldDidChange(
       const blink::WebFormControlElement& element);
   virtual void textFieldDidReceiveKeyDown(
       const blink::WebInputElement& element,
       const blink::WebKeyboardEvent& event);
   virtual void didRequestAutocomplete(
       const blink::WebFormElement& form);
   virtual void setIgnoreTextChanges(bool ignore);
   virtual void didAssociateFormControls(
       const blink::WebVector<blink::WebNode>& nodes);
   virtual void openTextDataListChooser(const blink::WebInputElement& element);
   virtual void firstUserGestureObserved();
 
   void OnFieldTypePredictionsAvailable(
       const std::vector<FormDataPredictions>& forms);
   void OnFillForm(int query_id, const FormData& form);
+  void OnFirstUserGestureObservedInTab();
   void OnPing();
   void OnPreviewForm(int query_id, const FormData& form);
 
   // For external Autofill selection.
   void OnClearForm();
   void OnClearPreviewedForm();
   void OnFillFieldWithValue(const base::string16& value);
   void OnPreviewFieldWithValue(const base::string16& value);
   void OnAcceptDataListSuggestion(const base::string16& value);
   void OnFillPasswordSuggestion(const base::string16& username,
@@ skipping 62 matching lines @@
   // Set |node| to display the given |value|.
   void FillFieldWithValue(const base::string16& value,
                           blink::WebInputElement* node);
 
   // Set |node| to display the given |value| as a preview.  The preview is
   // visible on screen to the user, but not visible to the page via the DOM or
   // JavaScript.
   void PreviewFieldWithValue(const base::string16& value,
                              blink::WebInputElement* node);
 
-  // Notifies browser of new fillable forms in |frame|.
-  void ProcessForms(const blink::WebLocalFrame& frame);
+  // Notifies browser of new fillable forms in |render_frame|.
+  void ProcessForms();
 
   // Hides any currently showing Autofill popup.
   void HidePopup();
 
+  // Formerly cached forms for all frames, now only caches forms for the current
+  // frame. TODO(estade): simplify |FormCache| to only work with a single frame.
   FormCache form_cache_;
 
   PasswordAutofillAgent* password_autofill_agent_;  // Weak reference.
   PasswordGenerationAgent* password_generation_agent_;  // Weak reference.
 
+  // Passes through RenderViewObserver methods to |this|.
+  LegacyAutofillAgent legacy_;
+
+  // Tracks clicks on the RenderViewHost, informs |this|.
+  PageClickTracker page_click_tracker_;
+
   // The ID of the last request sent for form field Autofill.  Used to ignore
   // out of date responses.
   int autofill_query_id_;
 
   // The element corresponding to the last request sent for form field Autofill.
   blink::WebFormControlElement element_;
 
   // The form element currently requesting an interactive autocomplete.
   blink::WebFormElement in_flight_request_form_;
 
-  // Pointer to the WebView. Used to access page scale factor.
-  blink::WebView* web_view_;
-
   // Should we display a warning if autofill is disabled?
   bool display_warning_if_disabled_;
 
   // Was the query node autofilled prior to previewing the form?
   bool was_query_node_autofilled_;
 
   // Have we already shown Autofill suggestions for the field the user is
   // currently editing?  Used to keep track of state for metrics logging.
   bool has_shown_autofill_popup_for_current_edit_;
 
   // If true we just set the node text so we shouldn't show the popup.
   bool did_set_node_text_;
 
   // Whether or not to ignore text changes.  Useful for when we're committing
   // a composition when we are defocusing the WebView and we don't want to
   // trigger an autofill popup to show.
   bool ignore_text_changes_;
 
   // Whether the Autofill popup is possibly visible.  This is tracked as a
   // performance improvement, so that the IPC channel isn't flooded with
   // messages to close the Autofill popup when it can't possibly be showing.
   bool is_popup_possibly_visible_;
 
-  // True if a message has already been sent about forms for the main frame.
-  // When the main frame is first loaded, a message is sent even if no forms
-  // exist in the frame. Otherwise, such messages are supressed.
-  bool main_frame_processed_;
-
   base::WeakPtrFactory<AutofillAgent> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AutofillAgent);
 };
 
 }  // namespace autofill
 
 #endif  // COMPONENTS_AUTOFILL_CONTENT_RENDERER_AUTOFILL_AGENT_H_