Move AutofillMsg_ClearPreviewedForm IPC send to AutofillDriverImpl

components/autofill/core/browser/autofill_external_delegate_unittest.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 <vector>
 
 #include "base/compiler_specific.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
@@ skipping 24 matching lines @@
 const int kAutofillProfileId = 1;
 
 class MockAutofillDriver : public TestAutofillDriver {
  public:
   explicit MockAutofillDriver(content::WebContents* web_contents)
       : TestAutofillDriver(web_contents) {}
 
   // Mock methods to enable testability.
   MOCK_METHOD1(SetRendererActionOnFormDataReception,
                void(RendererFormDataAction action));
-  MOCK_METHOD0(RendererShouldClearForm, void());
+  MOCK_METHOD0(RendererShouldClearFilledForm, void());
+  MOCK_METHOD0(RendererShouldClearPreviewedForm, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
 };
 
-class MockAutofillExternalDelegate : public AutofillExternalDelegate {
- public:
-  MockAutofillExternalDelegate(content::WebContents* web_contents,
-                               AutofillManager* autofill_manger,
-                               AutofillDriver* autofill_driver)
-      : AutofillExternalDelegate(web_contents, autofill_manger,
-                                 autofill_driver) {}
-
-  ~MockAutofillExternalDelegate() {}
-
-  MOCK_METHOD0(ClearPreviewedForm, void());
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockAutofillExternalDelegate);
-};
-
 class MockAutofillManagerDelegate
     : public autofill::TestAutofillManagerDelegate {
  public:
   MockAutofillManagerDelegate() {}
 
   MOCK_METHOD7(ShowAutofillPopup,
                void(const gfx::RectF& element_bounds,
                     base::i18n::TextDirection text_direction,
                     const std::vector<base::string16>& values,
                     const std::vector<base::string16>& labels,
@@ skipping 32 matching lines @@
 class AutofillExternalDelegateUnitTest
     : public ChromeRenderViewHostTestHarness {
  protected:
   virtual void SetUp() OVERRIDE {
     ChromeRenderViewHostTestHarness::SetUp();
     autofill_driver_.reset(new MockAutofillDriver(web_contents()));
     autofill_manager_.reset(
         new MockAutofillManager(autofill_driver_.get(),
                                 &manager_delegate_));
     external_delegate_.reset(
-        new testing::NiceMock<MockAutofillExternalDelegate>(
+        new AutofillExternalDelegate(
             web_contents(),
             autofill_manager_.get(), autofill_driver_.get()));
   }
 
   virtual void TearDown() OVERRIDE {
     // Order of destruction is important as AutofillManager relies on
     // PersonalDataManager to be around when it gets destroyed. Also, a real
     // AutofillManager is tied to the lifetime of the WebContents, so it must
     // be destroyed at the destruction of the WebContents.
     autofill_manager_.reset();
     external_delegate_.reset();
     autofill_driver_.reset();
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
   // Issue an OnQuery call with the given |query_id|.
   void IssueOnQuery(int query_id) {
     const FormData form;
     FormFieldData field;
     field.is_focusable = true;
     field.should_autocomplete = true;
     const gfx::RectF element_bounds;
 
     external_delegate_->OnQuery(query_id, form, field, element_bounds, true);
   }
 
   MockAutofillManagerDelegate manager_delegate_;
   scoped_ptr<MockAutofillDriver> autofill_driver_;
   scoped_ptr<MockAutofillManager> autofill_manager_;
-  scoped_ptr<testing::NiceMock<MockAutofillExternalDelegate> >
-      external_delegate_;
+  scoped_ptr<AutofillExternalDelegate> external_delegate_;
 };
 
 // Test that our external delegate called the virtual methods at the right time.
 TEST_F(AutofillExternalDelegateUnitTest, TestExternalDelegateVirtualCalls) {
   IssueOnQuery(kQueryId);
 
   // The enums must be cast to ints to prevent compile errors on linux_rel.
   EXPECT_CALL(manager_delegate_,
               ShowAutofillPopup(
                   _, _, _, _, _,
@@ skipping 142 matching lines @@
                                             autofill_ids);
 }
 
 // Test that the Autofill delegate doesn't try and fill a form with a
 // negative unique id.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateInvalidUniqueId) {
   // Ensure it doesn't try to preview the negative id.
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _)).Times(0);
   EXPECT_CALL(*autofill_driver_,
               SetRendererActionOnFormDataReception(_)).Times(0);
-  EXPECT_CALL(*external_delegate_, ClearPreviewedForm()).Times(1);
+  EXPECT_CALL(*autofill_driver_, RendererShouldClearPreviewedForm()).Times(1);
   external_delegate_->DidSelectSuggestion(-1);
 
   // Ensure it doesn't try to fill the form in with the negative id.
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _)).Times(0);
   EXPECT_CALL(*autofill_driver_,
               SetRendererActionOnFormDataReception(_)).Times(0);
   external_delegate_->DidAcceptSuggestion(base::string16(), -1);
 }
 
-// Test that the ClearPreview IPC is only sent the form was being previewed
+// Test that the ClearPreview call is only sent if the form was being previewed
 // (i.e. it isn't autofilling a password).
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateClearPreviewedForm) {
   // Called by DidSelectSuggestion, add expectation to remove warning.
   EXPECT_CALL(*autofill_manager_, OnFillAutofillFormData(_, _, _, _));
 
   // Ensure selecting a new password entries or Autofill entries will
   // cause any previews to get cleared.
-  EXPECT_CALL(*external_delegate_, ClearPreviewedForm()).Times(1);
+  EXPECT_CALL(*autofill_driver_, RendererShouldClearPreviewedForm()).Times(1);
   external_delegate_->DidSelectSuggestion(
       WebAutofillClient::MenuItemIDPasswordEntry);
 
-  EXPECT_CALL(*external_delegate_, ClearPreviewedForm()).Times(1);
+  EXPECT_CALL(*autofill_driver_, RendererShouldClearPreviewedForm()).Times(1);
   EXPECT_CALL(*autofill_driver_, SetRendererActionOnFormDataReception(
       AutofillDriver::FORM_DATA_ACTION_PREVIEW));
   external_delegate_->DidSelectSuggestion(1);
 }
 
 // Test that the popup is hidden once we are done editing the autofill field.
 TEST_F(AutofillExternalDelegateUnitTest,
        ExternalDelegateHidePopupAfterEditing) {
   EXPECT_CALL(manager_delegate_, ShowAutofillPopup(_, _, _, _, _, _, _));
   autofill::GenerateTestAutofillPopup(external_delegate_.get());
@@ skipping 43 matching lines @@
   // we've selected an option.
   external_delegate_->DidAcceptSuggestion(
       suggestions[0],
       WebAutofillClient::MenuItemIDPasswordEntry);
 }
 
 // Test that the driver is directed to clear the form after being notified that
 // the user accepted the suggestion to clear the form.
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateClearForm) {
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
-  EXPECT_CALL(*autofill_driver_, RendererShouldClearForm());
+  EXPECT_CALL(*autofill_driver_, RendererShouldClearFilledForm());
 
   external_delegate_->DidAcceptSuggestion(
       base::string16(),
       WebAutofillClient::MenuItemIDClearForm);
 }
 
 TEST_F(AutofillExternalDelegateUnitTest, ExternalDelegateHideWarning) {
   // Set up a field that shouldn't get autocompleted or display warnings.
   const FormData form;
   FormFieldData field;
@@ skipping 13 matching lines @@
   EXPECT_CALL(manager_delegate_, HideAutofillPopup());
 
   external_delegate_->OnSuggestionsReturned(kQueryId,
                                             autofill_items,
                                             autofill_items,
                                             autofill_items,
                                             autofill_ids);
 }
 
 }  // namespace autofill