Fix password manager internals renderer reporting

components/password_manager/content/browser/credential_manager_dispatcher_unittest.cc

 // Copyright 2014 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/password_manager/content/browser/credential_manager_dispatcher.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/core/browser/credential_manager_password_form_manager.h"
 #include "components/password_manager/core/browser/mock_affiliated_match_helper.h"
-#include "components/password_manager/core/browser/password_manager.h"
+#include "components/password_manager/core/browser/stub_log_manager.h"
 #include "components/password_manager/core/browser/stub_password_manager_client.h"
 #include "components/password_manager/core/browser/stub_password_manager_driver.h"
 #include "components/password_manager/core/browser/test_password_store.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_renderer_host.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 21 matching lines @@
   MOCK_CONST_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
   MOCK_METHOD1(NotifyUserAutoSigninPtr,
                bool(const std::vector<autofill::PasswordForm*>& local_forms));
   MOCK_METHOD2(PromptUserToSavePasswordPtr,
                void(PasswordFormManager*, CredentialSourceType type));
   MOCK_METHOD4(PromptUserToChooseCredentialsPtr,
                bool(const std::vector<autofill::PasswordForm*>& local_forms,
                     const std::vector<autofill::PasswordForm*>& federated_forms,
                     const GURL& origin,
                     base::Callback<void(const CredentialInfo&)> callback));
+  MOCK_CONST_METHOD0(GetLogManager, const LogManager*());
 
   explicit MockPasswordManagerClient(PasswordStore* store) : store_(store) {
     prefs_.registry()->RegisterBooleanPref(prefs::kPasswordManagerAutoSignin,
                                            true);
   }
   ~MockPasswordManagerClient() override {}
 
   bool PromptUserToSaveOrUpdatePassword(scoped_ptr<PasswordFormManager> manager,
                                         CredentialSourceType type,
                                         bool update_password) override {
@@ skipping 60 matching lines @@
     PasswordManagerClient* client,
     PasswordManagerDriver* driver)
     : CredentialManagerDispatcher(web_contents, client),
       driver_(driver->AsWeakPtr()) {}
 
 base::WeakPtr<PasswordManagerDriver>
 TestCredentialManagerDispatcher::GetDriver() {
   return driver_;
 }
 
-class MockPasswordManagerDriver : public StubPasswordManagerDriver {
- public:
-  MOCK_METHOD0(GetPasswordManager, PasswordManager*());
-};
-
 void RunAllPendingTasks() {
   base::RunLoop run_loop;
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   run_loop.Run();
 }
 
 }  // namespace
 
 class CredentialManagerDispatcherTest
     : public content::RenderViewHostTestHarness {
  public:
   CredentialManagerDispatcherTest() {}
 
   void SetUp() override {
     content::RenderViewHostTestHarness::SetUp();
     store_ = new TestPasswordStore;
     client_.reset(new MockPasswordManagerClient(store_.get()));
-    password_manager_.reset(new PasswordManager(client_.get()));
-    ON_CALL(mock_driver_, GetPasswordManager())
-        .WillByDefault(testing::Return(password_manager_.get()));
+    ON_CALL(*client_, GetLogManager())
+        .WillByDefault(testing::Return(&log_manager_));
     dispatcher_.reset(new TestCredentialManagerDispatcher(
-        web_contents(), client_.get(), &mock_driver_));
+        web_contents(), client_.get(), &stub_driver_));
     ON_CALL(*client_, IsSavingAndFillingEnabledForCurrentPage())
         .WillByDefault(testing::Return(true));
     ON_CALL(*client_, IsOffTheRecord()).WillByDefault(testing::Return(false));
     ON_CALL(*client_, DidLastPageLoadEncounterSSLErrors())
         .WillByDefault(testing::Return(false));
 
     NavigateAndCommit(GURL("https://example.com/test.html"));
 
     form_.username_value = base::ASCIIToUTF16("Username");
     form_.display_name = base::ASCIIToUTF16("Display Name");
@@ skipping 88 matching lines @@
   CredentialManagerDispatcher* dispatcher() { return dispatcher_.get(); }
 
  protected:
   autofill::PasswordForm form_;
   autofill::PasswordForm affiliated_form1_;
   autofill::PasswordForm affiliated_form2_;
   autofill::PasswordForm origin_path_form_;
   autofill::PasswordForm cross_origin_form_;
   scoped_refptr<TestPasswordStore> store_;
   scoped_ptr<MockPasswordManagerClient> client_;
-  MockPasswordManagerDriver mock_driver_;
+  StubPasswordManagerDriver stub_driver_;
   scoped_ptr<CredentialManagerDispatcher> dispatcher_;
-  scoped_ptr<PasswordManager> password_manager_;
+  StubLogManager log_manager_;
 };
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnStore) {
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(1));
 
   dispatcher()->OnStore(kRequestId, info);
 
@@ skipping 502 matching lines @@
 TEST_F(CredentialManagerDispatcherTest, GetSynthesizedFormForOrigin) {
   autofill::PasswordForm synthesized =
       dispatcher_->GetSynthesizedFormForOrigin();
   EXPECT_EQ(kTestWebOrigin, synthesized.origin.spec());
   EXPECT_EQ(kTestWebOrigin, synthesized.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, synthesized.scheme);
   EXPECT_TRUE(synthesized.ssl_valid);
 }
 
 }  // namespace password_manager