Fix password manager internals renderer reporting

chrome/browser/password_manager/chrome_password_manager_client_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 "chrome/browser/password_manager/chrome_password_manager_client.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/password_manager/content/browser/password_manager_internals_service_factory.h"
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/core/browser/credentials_filter.h"
+#include "components/password_manager/core/browser/log_manager.h"
 #include "components/password_manager/core/browser/log_receiver.h"
+#include "components/password_manager/core/browser/log_router.h"
 #include "components/password_manager/core/browser/password_manager_internals_service.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/password_manager/core/common/password_manager_switches.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserContext;
 using content::WebContents;
 using testing::Return;
 using testing::_;
 
 namespace {
 
 const char kPasswordManagerSettingsBehaviourChangeFieldTrialName[] =
     "PasswordManagerSettingsBehaviourChange";
 const char kPasswordManagerSettingsBehaviourChangeEnabledGroupName[] =
     "PasswordManagerSettingsBehaviourChange.Active";
 const char kPasswordManagerSettingsBehaviourChangeDisabledGroupName[] =
     "PasswordManagerSettingsBehaviourChange.NotActive";
 
-const char kTestText[] = "abcd1234";
-
-class MockLogReceiver : public password_manager::LogReceiver {
- public:
-  MOCK_METHOD1(LogSavePasswordProgress, void(const std::string&));
-};
-
 // TODO(vabr): Get rid of the mocked client in the client's own test, see
 // http://crbug.com/474577.
 class MockChromePasswordManagerClient : public ChromePasswordManagerClient {
  public:
   MOCK_CONST_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
 
   explicit MockChromePasswordManagerClient(content::WebContents* web_contents)
       : ChromePasswordManagerClient(web_contents, nullptr) {
     ON_CALL(*this, DidLastPageLoadEncounterSSLErrors())
         .WillByDefault(testing::Return(false));
   }
   ~MockChromePasswordManagerClient() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockChromePasswordManagerClient);
 };
 
+class DummyLogReceiver : public password_manager::LogReceiver {
+ public:
+  DummyLogReceiver() = default;
+
+  void LogSavePasswordProgress(const std::string& text) override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DummyLogReceiver);
+};
+
 }  // namespace
 
 class ChromePasswordManagerClientTest : public ChromeRenderViewHostTestHarness {
  public:
-  ChromePasswordManagerClientTest()
-      : service_(nullptr), field_trial_list_(nullptr) {}
+  ChromePasswordManagerClientTest() : field_trial_list_(nullptr) {}
   void SetUp() override;
 
   syncable_prefs::TestingPrefServiceSyncable* prefs() {
     return profile()->GetTestingPrefService();
   }
 
   void EnforcePasswordManagerSettingsBehaviourChangeExperimentGroup(
       const char* name) {
     ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
         kPasswordManagerSettingsBehaviourChangeFieldTrialName, name));
   }
 
  protected:
   ChromePasswordManagerClient* GetClient();
 
   // If the test IPC sink contains an AutofillMsg_SetLoggingState message, then
   // copies its argument into |activation_flag| and returns true. Otherwise
   // returns false.
   bool WasLoggingActivationMessageSent(bool* activation_flag);
 
-  password_manager::PasswordManagerInternalsService* service_;
-
-  testing::StrictMock<MockLogReceiver> receiver_;
   TestingPrefServiceSimple prefs_;
   base::FieldTrialList field_trial_list_;
 };
 
 void ChromePasswordManagerClientTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
   prefs_.registry()->RegisterBooleanPref(
       password_manager::prefs::kPasswordManagerSavingEnabled, true);
   ChromePasswordManagerClient::CreateForWebContentsWithAutofillClient(
       web_contents(), nullptr);
-  service_ = password_manager::PasswordManagerInternalsServiceFactory::
-      GetForBrowserContext(profile());
-  ASSERT_TRUE(service_);
 }
 
 ChromePasswordManagerClient* ChromePasswordManagerClientTest::GetClient() {
   return ChromePasswordManagerClient::FromWebContents(web_contents());
 }
 
 bool ChromePasswordManagerClientTest::WasLoggingActivationMessageSent(
     bool* activation_flag) {
   const uint32 kMsgID = AutofillMsg_SetLoggingState::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   if (!message)
     return false;
   base::Tuple<bool> param;
   AutofillMsg_SetLoggingState::Read(message, &param);
   *activation_flag = base::get<0>(param);
   process()->sink().ClearMessages();
   return true;
 }
 
-TEST_F(ChromePasswordManagerClientTest, LogSavePasswordProgressNoReceiver) {
-  ChromePasswordManagerClient* client = GetClient();
-
-  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText)).Times(0);
-  // Before attaching the receiver, no text should be passed.
-  client->LogSavePasswordProgress(kTestText);
-  EXPECT_FALSE(client->IsLoggingActive());
-}
-
-TEST_F(ChromePasswordManagerClientTest, LogSavePasswordProgressAttachReceiver) {
-  ChromePasswordManagerClient* client = GetClient();
-  EXPECT_FALSE(client->IsLoggingActive());
-
-  // After attaching the logger, text should be passed.
-  service_->RegisterReceiver(&receiver_);
-  EXPECT_TRUE(client->IsLoggingActive());
-  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText)).Times(1);
-  client->LogSavePasswordProgress(kTestText);
-  service_->UnregisterReceiver(&receiver_);
-  EXPECT_FALSE(client->IsLoggingActive());
-}
-
-TEST_F(ChromePasswordManagerClientTest, LogSavePasswordProgressDetachReceiver) {
-  ChromePasswordManagerClient* client = GetClient();
-
-  service_->RegisterReceiver(&receiver_);
-  EXPECT_TRUE(client->IsLoggingActive());
-  service_->UnregisterReceiver(&receiver_);
-  EXPECT_FALSE(client->IsLoggingActive());
-
-  // After detaching the logger, no text should be passed.
-  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText)).Times(0);
-  client->LogSavePasswordProgress(kTestText);
-}
-
 TEST_F(ChromePasswordManagerClientTest, LogSavePasswordProgressNotifyRenderer) {
-  ChromePasswordManagerClient* client = GetClient();
-  bool logging_active = false;
+  bool logging_active = true;
+  // Ensure the existence of a driver, which will send the IPCs we listen for
+  // below.
+  NavigateAndCommit(GURL("about:blank"));
 
   // Initially, the logging should be off, so no IPC messages.
-  EXPECT_FALSE(WasLoggingActivationMessageSent(&logging_active));
+  EXPECT_TRUE(!WasLoggingActivationMessageSent(&logging_active) ||
+              !logging_active)
+      << "logging_active=" << logging_active;
 
-  service_->RegisterReceiver(&receiver_);
-  EXPECT_TRUE(client->IsLoggingActive());
+  DummyLogReceiver log_receiver;
+  password_manager::LogRouter* log_router = password_manager::
+      PasswordManagerInternalsServiceFactory::GetForBrowserContext(profile());
+  EXPECT_EQ(std::string(), log_router->RegisterReceiver(&log_receiver));
   EXPECT_TRUE(WasLoggingActivationMessageSent(&logging_active));
   EXPECT_TRUE(logging_active);
 
-  service_->UnregisterReceiver(&receiver_);
-  EXPECT_FALSE(client->IsLoggingActive());
+  log_router->UnregisterReceiver(&log_receiver);
   EXPECT_TRUE(WasLoggingActivationMessageSent(&logging_active));
   EXPECT_FALSE(logging_active);
 }
-
-TEST_F(ChromePasswordManagerClientTest, AnswerToPingsAboutLoggingState_Active) {
-  service_->RegisterReceiver(&receiver_);
-
-  process()->sink().ClearMessages();
-
-  // Ping the client for logging activity update.
-  AutofillHostMsg_PasswordAutofillAgentConstructed msg(0);
-  static_cast<content::WebContentsObserver*>(GetClient())->OnMessageReceived(
-      msg, web_contents()->GetMainFrame());
-
-  bool logging_active = false;
-  EXPECT_TRUE(WasLoggingActivationMessageSent(&logging_active));
-  EXPECT_TRUE(logging_active);
-
-  service_->UnregisterReceiver(&receiver_);
-}
-
-TEST_F(ChromePasswordManagerClientTest,
-       AnswerToPingsAboutLoggingState_Inactive) {
-  process()->sink().ClearMessages();
-
-  // Ping the client for logging activity update.
-  AutofillHostMsg_PasswordAutofillAgentConstructed msg(0);
-  static_cast<content::WebContentsObserver*>(GetClient())->OnMessageReceived(
-      msg, web_contents()->GetMainFrame());
-
-  bool logging_active = true;
-  EXPECT_TRUE(WasLoggingActivationMessageSent(&logging_active));
-  EXPECT_FALSE(logging_active);
-}
 
 TEST_F(ChromePasswordManagerClientTest,
        IsAutomaticPasswordSavingEnabledDefaultBehaviourTest) {
   EXPECT_FALSE(GetClient()->IsAutomaticPasswordSavingEnabled());
 }
 
 TEST_F(ChromePasswordManagerClientTest,
        IsAutomaticPasswordSavingEnabledWhenFlagIsSetTest) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       password_manager::switches::kEnableAutomaticPasswordSaving);
   if (chrome::GetChannel() == version_info::Channel::UNKNOWN)
     EXPECT_TRUE(GetClient()->IsAutomaticPasswordSavingEnabled());
   else
     EXPECT_FALSE(GetClient()->IsAutomaticPasswordSavingEnabled());
 }
 
-TEST_F(ChromePasswordManagerClientTest, LogToAReceiver) {
-  ChromePasswordManagerClient* client = GetClient();
-  service_->RegisterReceiver(&receiver_);
-  EXPECT_TRUE(client->IsLoggingActive());
-
-  EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText)).Times(1);
-  client->LogSavePasswordProgress(kTestText);
-
-  service_->UnregisterReceiver(&receiver_);
-  EXPECT_FALSE(client->IsLoggingActive());
-}
-
 TEST_F(ChromePasswordManagerClientTest, GetPasswordSyncState) {
   ChromePasswordManagerClient* client = GetClient();
 
   ProfileSyncServiceMock* mock_sync_service =
       static_cast<ProfileSyncServiceMock*>(
           ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               profile(), ProfileSyncServiceMock::BuildMockProfileSyncService));
 
   syncer::ModelTypeSet active_types;
   active_types.Put(syncer::PASSWORDS);
@@ skipping 140 matching lines @@
   EXPECT_EQ(GURL::EmptyGURL(), GetClient()->GetLastCommittedEntryURL());
 }
 
 TEST_F(ChromePasswordManagerClientTest, GetLastCommittedEntryURL) {
   GURL kUrl(
       "https://accounts.google.com/ServiceLogin?continue="
       "https://passwords.google.com/settings");
   NavigateAndCommit(kUrl);
   EXPECT_EQ(kUrl, GetClient()->GetLastCommittedEntryURL());
 }
+
+TEST_F(ChromePasswordManagerClientTest, WebUINoLogging) {
+  // Make sure that logging is active.
+  password_manager::LogRouter* log_router = password_manager::
+      PasswordManagerInternalsServiceFactory::GetForBrowserContext(profile());
+  DummyLogReceiver log_receiver;
+  EXPECT_EQ(std::string(), log_router->RegisterReceiver(&log_receiver));
+
+  // But then navigate to a WebUI, there the logging should not be active.
+  NavigateAndCommit(GURL("about:password-manager-internals"));
+  EXPECT_FALSE(GetClient()->GetLogManager()->IsLoggingActive());
+
+  log_router->UnregisterReceiver(&log_receiver);
+}