Move ownership of Password(Generation)Manager to ContentPasswordDriver.

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"
 #include "chrome/browser/password_manager/password_manager.h"
 #include "chrome/browser/password_manager/password_manager_delegate.h"
 #include "chrome/browser/password_manager/password_manager_driver.h"
 #include "chrome/browser/password_manager/password_store.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+class PasswordGenerationManager;
+
 using autofill::PasswordForm;
 using base::ASCIIToUTF16;
 using testing::_;
 using testing::DoAll;
 using testing::Exactly;
 using testing::Return;
 using testing::WithArg;
 
 namespace {
 
 class MockPasswordManagerDelegate : public PasswordManagerDelegate {
  public:
   MOCK_METHOD1(AddSavePasswordInfoBarIfPermitted, void(PasswordFormManager*));
   MOCK_METHOD0(GetProfile, Profile*());
   MOCK_METHOD0(GetDriver, PasswordManagerDriver*());
 };
 
 class MockPasswordManagerDriver : public PasswordManagerDriver {
  public:
   MOCK_METHOD1(FillPasswordForm, void(const autofill::PasswordFormFillData&));
   MOCK_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
+  MOCK_METHOD0(GetPasswordGenerationManager, PasswordGenerationManager*());
+  MOCK_METHOD0(GetPasswordManager, PasswordManager*());
 };
 
 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()));
     EXPECT_CALL(delegate_, GetDriver()).WillRepeatedly(Return(&driver_));
-    manager_ = TestPasswordManager::CreateForWebContentsAndDelegate(
-        web_contents(), &delegate_);
+
+    manager_.reset(new TestPasswordManager(web_contents(), &delegate_));
+
     EXPECT_CALL(driver_, DidLastPageLoadEncounterSSLErrors())
         .WillRepeatedly(Return(false));
+    EXPECT_CALL(driver_, GetPasswordGenerationManager())
+        .WillRepeatedly(Return(static_cast<PasswordGenerationManager*>(NULL)));
+    EXPECT_CALL(driver_, GetPasswordManager())
+        .WillRepeatedly(Return(manager_.get()));
   }
 
   virtual void TearDown() {
     store_ = NULL;
+
+    // Destroy the PasswordManager before tearing down the Profile to avoid
+    // crashes due to prefs accesses.
+    manager_.reset();
     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");
@@ skipping 52 matching lines @@
       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_;
-  }
+  TestPasswordManager* manager() { return manager_.get(); }
 
   void OnPasswordFormSubmitted(const autofill::PasswordForm& form) {
     manager()->OnPasswordFormSubmitted(form);
   }
 
   PasswordManager::PasswordSubmittedCallback SubmissionCallback() {
     return base::Bind(&PasswordManagerTest::FormSubmitted,
                       base::Unretained(this));
   }
 
   void FormSubmitted(const autofill::PasswordForm& form) {
     submitted_form_ = form;
   }
 
   scoped_refptr<MockPasswordStore> store_;
-  TestPasswordManager* manager_;
-  MockPasswordManagerDelegate delegate_;  // Owned by manager_.
+  MockPasswordManagerDelegate delegate_;
   MockPasswordManagerDriver driver_;
+  scoped_ptr<TestPasswordManager> 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 ==
@@ skipping 392 matching lines @@
   manager()->ProvisionallySavePassword(login_form);
 
   PasswordForm failed_login_form(MakeTwitterFailedLoginForm());
   observed.clear();
   observed.push_back(failed_login_form);
   // A PasswordForm appears, and is visible in the layout:
   // No expected calls to the PasswordStore...
   manager()->OnPasswordFormsParsed(observed);
   manager()->OnPasswordFormsRendered(observed);
 }