[password autofill] Remove references to PasswordForm from RenderViewImpl

chrome/browser/password_manager/password_manager_unittest.cc

 // Copyright (c) 2012 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/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/password_manager/mock_password_store.h"
@@ skipping 12 matching lines @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::PasswordForm;
 using testing::_;
 using testing::DoAll;
 using testing::Exactly;
 using testing::Return;
 using testing::WithArg;
 
+namespace {
+
 class MockPasswordManagerDelegate : public PasswordManagerDelegate {
  public:
   MOCK_METHOD1(FillPasswordForm, void(const autofill::PasswordFormFillData&));
   MOCK_METHOD1(AddSavePasswordInfoBarIfPermitted, void(PasswordFormManager*));
   MOCK_METHOD0(GetProfile, Profile*());
   MOCK_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
 };
 
 ACTION_P(InvokeConsumer, forms) {
   arg0->OnGetPasswordStoreResults(forms);
 }
 
 ACTION_P(SaveToScopedPtr, scoped) {
   scoped->reset(arg0);
 }
 
+class TestPasswordManager : public PasswordManager {
+ public:
+  TestPasswordManager(content::WebContents* contents,
+                      PasswordManagerDelegate* delegate)
+      : PasswordManager(contents, delegate) {}
+  virtual ~TestPasswordManager() {}
+
+  virtual void OnPasswordFormSubmitted(const PasswordForm& form) OVERRIDE {
+    PasswordManager::OnPasswordFormSubmitted(form);
+  }
+
+  static TestPasswordManager* CreateForWebContentsAndDelegate(
+      content::WebContents* contents,
+      PasswordManagerDelegate* delegate) {
+    TestPasswordManager* tpm = new TestPasswordManager(contents, delegate);
+    contents->SetUserData(UserDataKey(), tpm);
+    return tpm;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestPasswordManager);
+};
+
+}  // namespace
+
 class PasswordManagerTest : public ChromeRenderViewHostTestHarness {
  protected:
   virtual void SetUp() {
     ChromeRenderViewHostTestHarness::SetUp();
     store_ = static_cast<MockPasswordStore*>(
         PasswordStoreFactory::GetInstance()->SetTestingFactoryAndUse(
             profile(), MockPasswordStore::Build).get());
 
     EXPECT_CALL(delegate_, GetProfile()).WillRepeatedly(Return(profile()));
-    PasswordManager::CreateForWebContentsAndDelegate(
+    manager_ = TestPasswordManager::CreateForWebContentsAndDelegate(
         web_contents(), &delegate_);
     EXPECT_CALL(delegate_, DidLastPageLoadEncounterSSLErrors())
         .WillRepeatedly(Return(false));
   }
 
   virtual void TearDown() {
     store_ = NULL;
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
   PasswordForm MakeSimpleForm() {
     PasswordForm form;
     form.origin = GURL("http://www.google.com/a/LoginAuth");
     form.action = GURL("http://www.google.com/a/Login");
     form.username_element = ASCIIToUTF16("Email");
     form.password_element = ASCIIToUTF16("Passwd");
     form.username_value = ASCIIToUTF16("google");
     form.password_value = ASCIIToUTF16("password");
     // Default to true so we only need to add tests in autocomplete=off cases.
     form.password_autocomplete_set = true;
     form.submit_element = ASCIIToUTF16("signIn");
     form.signon_realm = "http://www.google.com";
     return form;
   }
 
-  PasswordManager* manager() {
-    return PasswordManager::FromWebContents(web_contents());
+  bool FormsAreEqual(const content::PasswordForm& lhs,
+                     const content::PasswordForm& rhs) {
+    if (lhs.origin != rhs.origin)
+      return false;
+    if (lhs.action != rhs.action)
+      return false;
+    if (lhs.username_element != rhs.username_element)
+      return false;
+    if (lhs.password_element != rhs.password_element)
+      return false;
+    if (lhs.username_value != rhs.username_value)
+      return false;
+    if (lhs.password_value != rhs.password_value)
+      return false;
+    if (lhs.password_autocomplete_set != rhs.password_autocomplete_set)
+      return false;
+    if (lhs.submit_element != rhs.submit_element)
+      return false;
+    if (lhs.signon_realm != rhs.signon_realm)
+      return false;
+    return true;
+  }
+
+  TestPasswordManager* manager() {
+    return manager_;
+  }
+
+  void OnPasswordFormSubmitted(const content::PasswordForm& form) {
+    manager()->OnPasswordFormSubmitted(form);
+  }
+
+  PasswordManager::PasswordSubmittedCallback SubmissionCallback() {
+    return base::Bind(&PasswordManagerTest::FormSubmitted,
+                      base::Unretained(this));
+  }
+
+  void FormSubmitted(const content::PasswordForm& form) {
+    submitted_form_ = form;
   }
 
   scoped_refptr<MockPasswordStore> store_;
+  TestPasswordManager* manager_;
   MockPasswordManagerDelegate delegate_;  // Owned by manager_.
+  PasswordForm submitted_form_;
 };
 
 MATCHER_P(FormMatches, form, "") {
   return form.signon_realm == arg.signon_realm &&
          form.origin == arg.origin &&
          form.action == arg.action &&
          form.username_element == arg.username_element &&
          form.password_element == arg.password_element &&
          form.password_autocomplete_set ==
              arg.password_autocomplete_set &&
@@ skipping 101 matching lines @@
   std::vector<PasswordForm*> result;  // Empty password store.
   EXPECT_CALL(delegate_, FillPasswordForm(_)).Times(Exactly(0));
   EXPECT_CALL(*store_.get(), GetLogins(_, _))
       .WillOnce(DoAll(WithArg<1>(InvokeConsumer(result)), Return(1)));
   std::vector<PasswordForm> observed;
   PasswordForm form(MakeSimpleForm());
   observed.push_back(form);
   manager()->OnPasswordFormsParsed(observed);  // The initial load.
   manager()->OnPasswordFormsRendered(observed);  // The initial layout.
 
-  PasswordForm empty_form(form);
-  empty_form.username_value = string16();
-  empty_form.password_value = string16();
-  content::LoadCommittedDetails details;
-  content::FrameNavigateParams params;
-  params.password_form = empty_form;
-  manager()->DidNavigateAnyFrame(details, params);
-
-  // No expected calls.
+  // No message from the renderer that a password was submitted. No
+  // expected calls.
   EXPECT_CALL(delegate_, AddSavePasswordInfoBarIfPermitted(_)).Times(0);
   observed.clear();
   manager()->OnPasswordFormsParsed(observed);  // The post-navigation load.
   manager()->OnPasswordFormsRendered(observed);  // The post-navigation layout.
 }
 
 TEST_F(PasswordManagerTest, FormSubmitAfterNavigateSubframe) {
   // Test that navigating a subframe does not prevent us from showing the save
   // password infobar.
   std::vector<PasswordForm*> result;  // Empty password store.
   EXPECT_CALL(delegate_, FillPasswordForm(_)).Times(Exactly(0));
   EXPECT_CALL(*store_.get(), GetLogins(_, _))
       .WillOnce(DoAll(WithArg<1>(InvokeConsumer(result)), Return(1)));
   std::vector<PasswordForm> observed;
   PasswordForm form(MakeSimpleForm());
   observed.push_back(form);
   manager()->OnPasswordFormsParsed(observed);  // The initial load.
   manager()->OnPasswordFormsRendered(observed);  // The initial layout.
 
   // Simulate navigating a sub-frame.
   content::LoadCommittedDetails details;
-  details.is_main_frame = false;
   content::FrameNavigateParams params;
   manager()->DidNavigateAnyFrame(details, params);
 
-  // Simulate navigating the real page.
-  details.is_main_frame = true;
-  params.password_form = form;
-  manager()->DidNavigateAnyFrame(details, params);
+  // Simulate submitting the password.
+  OnPasswordFormSubmitted(form);
 
   // Now the password manager waits for the navigation to complete.
   scoped_ptr<PasswordFormManager> form_to_save;
   EXPECT_CALL(delegate_, AddSavePasswordInfoBarIfPermitted(_))
       .WillOnce(WithArg<0>(SaveToScopedPtr(&form_to_save)));
 
   observed.clear();
   manager()->OnPasswordFormsParsed(observed);  // The post-navigation load.
   manager()->OnPasswordFormsRendered(observed);  // The post-navigation layout.
 
@@ skipping 23 matching lines @@
   std::vector<PasswordForm> observed;
   observed.push_back(first_form);
   manager()->OnPasswordFormsParsed(observed);
   observed.clear();
   manager()->OnPasswordFormsRendered(observed);
 
   // Now navigate to a second page.
   content::LoadCommittedDetails details;
   details.is_main_frame = true;
   content::FrameNavigateParams params;
-  manager()->DidNavigateAnyFrame(details, params);
+  manager()->DidNavigateMainFrame(details, params);
 
   // This page contains a form with the same markup, but on a different
   // URL.
   observed.push_back(second_form);
   manager()->OnPasswordFormsParsed(observed);
   manager()->OnPasswordFormsRendered(observed);
 
   // Now submit this form
-  params.password_form = second_form;
-  manager()->DidNavigateAnyFrame(details, params);
+  OnPasswordFormSubmitted(second_form);
 
   // Navigation after form submit.
   scoped_ptr<PasswordFormManager> form_to_save;
   EXPECT_CALL(delegate_, AddSavePasswordInfoBarIfPermitted(_))
       .WillOnce(WithArg<0>(SaveToScopedPtr(&form_to_save)));
   observed.clear();
   manager()->OnPasswordFormsParsed(observed);
   manager()->OnPasswordFormsRendered(observed);
 
   // Make sure that the saved form matches the second form, not the first.
@@ skipping 155 matching lines @@
   // navigation occurs.
   EXPECT_CALL(delegate_,
               AddSavePasswordInfoBarIfPermitted(_)).Times(Exactly(0));
   EXPECT_CALL(*store_.get(), AddLogin(FormMatches(form)));
 
   // Now the password manager waits for the navigation to complete.
   observed.clear();
   manager()->OnPasswordFormsParsed(observed);  // The post-navigation load.
   manager()->OnPasswordFormsRendered(observed);  // The post-navigation layout.
 }
+
+TEST_F(PasswordManagerTest, SubmissionCallbackTest) {
+  manager()->AddSubmissionCallback(SubmissionCallback());
+  PasswordForm form = MakeSimpleForm();
+  OnPasswordFormSubmitted(form);
+  EXPECT_TRUE(FormsAreEqual(form, submitted_form_));
+}