diff options
Diffstat (limited to 'components')
12 files changed, 538 insertions, 13 deletions
diff --git a/components/autofill.gypi b/components/autofill.gypi index dd2d78a..c2e54d1 100644 --- a/components/autofill.gypi +++ b/components/autofill.gypi @@ -74,6 +74,8 @@ 'autofill/core/common/password_form_fill_data.h', 'autofill/core/common/password_generation_util.cc', 'autofill/core/common/password_generation_util.h', + 'autofill/core/common/save_password_progress_logger.cc', + 'autofill/core/common/save_password_progress_logger.h', 'autofill/core/common/web_element_descriptor.cc', 'autofill/core/common/web_element_descriptor.h', ], diff --git a/components/autofill/core/common/save_password_progress_logger.cc b/components/autofill/core/common/save_password_progress_logger.cc new file mode 100644 index 0000000..cdb8dd7 --- /dev/null +++ b/components/autofill/core/common/save_password_progress_logger.cc @@ -0,0 +1,138 @@ +// 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/autofill/core/common/save_password_progress_logger.h" + +#include "base/json/json_writer.h" +#include "base/logging.h" +#include "base/numerics/safe_conversions.h" +#include "base/values.h" +#include "components/autofill/core/common/password_form.h" + +using base::checked_cast; +using base::Value; +using base::DictionaryValue; +using base::FundamentalValue; +using base::StringValue; + +namespace autofill { + +namespace { + +// Removes privacy sensitive parts of |url| (currently all but host and scheme). +std::string ScrubURL(const GURL& url) { + if (url.is_valid()) + return url.GetWithEmptyPath().spec(); + return std::string(); +} + +std::string FormSchemeToString(PasswordForm::Scheme scheme) { + switch (scheme) { + case PasswordForm::SCHEME_HTML: + return "HTML"; + case PasswordForm::SCHEME_BASIC: + return "BASIC"; + case PasswordForm::SCHEME_DIGEST: + return "DIGEST"; + case PasswordForm::SCHEME_OTHER: + return "OTHER"; + } + NOTREACHED(); // Win compilers don't believe this is unreachable. + return std::string(); +} + +StringValue DecisionToStringValue( + SavePasswordProgressLogger::Decision decision) { + switch (decision) { + case SavePasswordProgressLogger::DECISION_SAVE: + return StringValue("SAVE the password"); + case SavePasswordProgressLogger::DECISION_ASK: + return StringValue("ASK the user whether to save the password"); + case SavePasswordProgressLogger::DECISION_DROP: + return StringValue("DROP the password"); + } + NOTREACHED(); // Win compilers don't believe this is unreachable. + return StringValue(std::string()); +} + +} // namespace + +SavePasswordProgressLogger::SavePasswordProgressLogger() {} + +SavePasswordProgressLogger::~SavePasswordProgressLogger() {} + +void SavePasswordProgressLogger::LogPasswordForm(const std::string& message, + const PasswordForm& form) { + DictionaryValue log; + // Do not use the "<<" operator for PasswordForms, because it also prints + // passwords. Also, that operator is only for testing. + log.SetString("scheme", FormSchemeToString(form.scheme)); + log.SetString("signon realm", ScrubURL(GURL(form.signon_realm))); + log.SetString("original signon realm", + ScrubURL(GURL(form.original_signon_realm))); + log.SetString("origin", ScrubURL(form.origin)); + log.SetString("action", ScrubURL(form.action)); + log.SetString("username element", form.username_element); + log.SetString("password element", form.password_element); + log.SetBoolean("password autocomplete set", form.password_autocomplete_set); + log.SetString("old password element", form.old_password_element); + log.SetBoolean("ssl valid", form.ssl_valid); + log.SetBoolean("password generated", + form.type == PasswordForm::TYPE_GENERATED); + log.SetInteger("times used", form.times_used); + log.SetBoolean("use additional authentication", + form.use_additional_authentication); + log.SetBoolean("is PSL match", form.IsPublicSuffixMatch()); + LogValue(message, log); +} + +void SavePasswordProgressLogger::LogHTMLForm(const std::string& message, + const std::string& name_or_id, + const std::string& method, + const GURL& action) { + DictionaryValue log; + log.SetString("name_or_id", name_or_id); + log.SetString("method", method); + log.SetString("action", ScrubURL(action)); + LogValue(message, log); +} + +void SavePasswordProgressLogger::LogURL(const std::string& message, + const GURL& url) { + LogValue(message, StringValue(ScrubURL(url))); +} + +void SavePasswordProgressLogger::LogBoolean(const std::string& message, + bool value) { + LogValue(message, FundamentalValue(value)); +} + +void SavePasswordProgressLogger::LogNumber(const std::string& message, + int value) { + LogValue(message, FundamentalValue(value)); +} + +void SavePasswordProgressLogger::LogNumber(const std::string& message, + size_t value) { + LogValue(message, FundamentalValue(checked_cast<int, size_t>(value))); +} + +void SavePasswordProgressLogger::LogFinalDecision(Decision decision) { + LogValue("Final decision taken", DecisionToStringValue(decision)); +} + +void SavePasswordProgressLogger::LogMessage(const std::string& message) { + LogValue("Message", StringValue(message)); +} + +void SavePasswordProgressLogger::LogValue(const std::string& name, + const Value& log) { + std::string log_string; + bool conversion_to_string_successful = base::JSONWriter::WriteWithOptions( + &log, base::JSONWriter::OPTIONS_PRETTY_PRINT, &log_string); + DCHECK(conversion_to_string_successful); + SendLog(name + ": " + log_string); +} + +} // namespace autofill diff --git a/components/autofill/core/common/save_password_progress_logger.h b/components/autofill/core/common/save_password_progress_logger.h new file mode 100644 index 0000000..63f1075 --- /dev/null +++ b/components/autofill/core/common/save_password_progress_logger.h @@ -0,0 +1,74 @@ +// 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. + +#ifndef COMPONENTS_AUTOFILL_CORE_COMMON_SAVE_PASSWORD_PROGRESS_LOGGER_H_ +#define COMPONENTS_AUTOFILL_CORE_COMMON_SAVE_PASSWORD_PROGRESS_LOGGER_H_ + +#include <string> + +#include "url/gurl.h" + +namespace base { +class Value; +} + +namespace autofill { + +struct PasswordForm; + +// When logging decisions made by password management code about whether to +// offer user-entered credentials for saving or not, do use this class. It +// offers a suite of convenience methods to format and scrub logs. The methods +// have built-in privacy protections (never include a password, scrub URLs), so +// that the result is appropriate for display on the internals page. +// +// To use this class, the method SendLog needs to be overriden to send the logs +// for display as appropriate. +// +// TODO(vabr): Logically, this class belongs to the password_manager component. +// But the PasswordAutofillAgent needs to use it, so until that agent is in a +// third component, shared by autofill and password_manager, this helper needs +// to stay in autofill as well. +class SavePasswordProgressLogger { + public: + // All three possible decisions about saving a password. Call LogFinalDecision + // as soon as one is taken by the password management code. + enum Decision { DECISION_SAVE, DECISION_ASK, DECISION_DROP }; + + SavePasswordProgressLogger(); + virtual ~SavePasswordProgressLogger(); + + // Logging: specialized methods (for logging forms, URLs, etc.) take care of + // proper removing of sensitive data where appropriate. + void LogPasswordForm(const std::string& message, + const autofill::PasswordForm& form); + void LogHTMLForm(const std::string& message, + const std::string& name_or_id, + const std::string& method, + const GURL& action); + void LogURL(const std::string& message, const GURL& url); + void LogWhetherObjectExists(const std::string& message, const void* object); + void LogBoolean(const std::string& message, bool value); + void LogNumber(const std::string& message, int value); + void LogNumber(const std::string& message, size_t value); + void LogFinalDecision(Decision decision); + // Do not use LogMessage when there is an appropriate specialized method + // above. LogMessage performs no scrubbing of sensitive data. + void LogMessage(const std::string& message); + + protected: + // Sends |log| immediately for display. + virtual void SendLog(const std::string& log) = 0; + + private: + // Takes a structured |log|, converts it to a string suitable for plain text + // output, adds the |name| as a caption, and sends out via SendLog. + void LogValue(const std::string& name, const base::Value& log); + + DISALLOW_COPY_AND_ASSIGN(SavePasswordProgressLogger); +}; + +} // namespace autofill + +#endif // COMPONENTS_AUTOFILL_CORE_COMMON_SAVE_PASSWORD_PROGRESS_LOGGER_H_ diff --git a/components/autofill/core/common/save_password_progress_logger_unittest.cc b/components/autofill/core/common/save_password_progress_logger_unittest.cc new file mode 100644 index 0000000..9c09505 --- /dev/null +++ b/components/autofill/core/common/save_password_progress_logger_unittest.cc @@ -0,0 +1,153 @@ +// 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/autofill/core/common/save_password_progress_logger.h" + +#include <limits> + +#include "base/bind.h" +#include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/strings/stringprintf.h" +#include "base/strings/utf_string_conversions.h" +#include "components/autofill/core/common/password_form.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "url/gurl.h" + +using base::UTF8ToUTF16; + +namespace autofill { + +namespace { + +const char kTestString[] = "Test"; + +class TestLogger : public SavePasswordProgressLogger { + public: + bool LogsContainSubstring(const std::string& substring) { + return accumulated_log_.find(substring) != std::string::npos; + } + + std::string accumulated_log() { return accumulated_log_; } + + private: + virtual void SendLog(const std::string& log) OVERRIDE { + accumulated_log_.append(log); + } + + std::string accumulated_log_; +}; + +}; // namespace + +TEST(SavePasswordProgressLoggerTest, LogPasswordForm) { + TestLogger logger; + PasswordForm form; + form.action = GURL("http://example.org/verysecret?verysecret"); + form.password_value = UTF8ToUTF16("verysecret"); + form.username_value = UTF8ToUTF16("verysecret"); + logger.LogPasswordForm(kTestString, form); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); + EXPECT_TRUE(logger.LogsContainSubstring("http://example.org")); + EXPECT_FALSE(logger.LogsContainSubstring("verysecret")); +} + +TEST(SavePasswordProgressLoggerTest, LogHTMLForm) { + TestLogger logger; + logger.LogHTMLForm(kTestString, + "form_name", + "form_method", + GURL("http://example.org/verysecret?verysecret")); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); + EXPECT_TRUE(logger.LogsContainSubstring("form_name")); + EXPECT_TRUE(logger.LogsContainSubstring("form_method")); + EXPECT_TRUE(logger.LogsContainSubstring("http://example.org")); + EXPECT_FALSE(logger.LogsContainSubstring("verysecret")); +} + +TEST(SavePasswordProgressLoggerTest, LogURL) { + TestLogger logger; + logger.LogURL(kTestString, GURL("http://example.org/verysecret?verysecret")); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); + EXPECT_TRUE(logger.LogsContainSubstring("http://example.org")); + EXPECT_FALSE(logger.LogsContainSubstring("verysecret")); +} + +TEST(SavePasswordProgressLoggerTest, LogBooleanTrue) { + TestLogger logger; + logger.LogBoolean(kTestString, true); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); + EXPECT_TRUE(logger.LogsContainSubstring("true")); +} + +TEST(SavePasswordProgressLoggerTest, LogBooleanFalse) { + TestLogger logger; + logger.LogBoolean(kTestString, false); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); + EXPECT_TRUE(logger.LogsContainSubstring("false")); +} + +TEST(SavePasswordProgressLoggerTest, LogSignedNumber) { + TestLogger logger; + int signed_number = -12345; + logger.LogNumber(kTestString, signed_number); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); + EXPECT_TRUE(logger.LogsContainSubstring("-12345")); +} + +TEST(SavePasswordProgressLoggerTest, LogUnsignedNumber) { + TestLogger logger; + size_t unsigned_number = 654321; + logger.LogNumber(kTestString, unsigned_number); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); + EXPECT_TRUE(logger.LogsContainSubstring("654321")); +} + +TEST(SavePasswordProgressLoggerTest, LogFinalDecisionSave) { + TestLogger logger; + logger.LogFinalDecision(SavePasswordProgressLogger::DECISION_SAVE); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring("SAVE")); +} + +TEST(SavePasswordProgressLoggerTest, LogFinalDecisionAsk) { + TestLogger logger; + logger.LogFinalDecision(SavePasswordProgressLogger::DECISION_ASK); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring("ASK")); +} + +TEST(SavePasswordProgressLoggerTest, LogFinalDecisionDrop) { + TestLogger logger; + logger.LogFinalDecision(SavePasswordProgressLogger::DECISION_DROP); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring("DROP")); +} + +TEST(SavePasswordProgressLoggerTest, LogMessage) { + TestLogger logger; + logger.LogMessage(kTestString); + SCOPED_TRACE(testing::Message() << "Log string = [" + << logger.accumulated_log() << "]"); + EXPECT_TRUE(logger.LogsContainSubstring(kTestString)); +} + +} // namespace autofill diff --git a/components/components_tests.gyp b/components/components_tests.gyp index 956e14b..0576db7 100644 --- a/components/components_tests.gyp +++ b/components/components_tests.gyp @@ -63,6 +63,7 @@ 'autofill/core/common/form_data_unittest.cc', 'autofill/core/common/form_field_data_unittest.cc', 'autofill/core/common/password_form_fill_data_unittest.cc', + 'autofill/core/common/save_password_progress_logger_unittest.cc', 'cloud_devices/printer_description_unittest.cc', 'dom_distiller/core/article_entry_unittest.cc', 'dom_distiller/core/distiller_unittest.cc', @@ -92,6 +93,7 @@ 'os_crypt/ie7_password_win_unittest.cc', 'os_crypt/keychain_password_mac_unittest.mm', 'os_crypt/os_crypt_unittest.cc', + 'password_manager/core/browser/browser_save_password_progress_logger_unittest.cc', 'password_manager/core/browser/login_database_unittest.cc', 'password_manager/core/browser/password_form_manager_unittest.cc', 'password_manager/core/browser/password_generation_manager_unittest.cc', diff --git a/components/password_manager.gypi b/components/password_manager.gypi index cb1c04b..0c26b73 100644 --- a/components/password_manager.gypi +++ b/components/password_manager.gypi @@ -20,6 +20,8 @@ '..', ], 'sources': [ + 'password_manager/core/browser/browser_save_password_progress_logger.cc', + 'password_manager/core/browser/browser_save_password_progress_logger.h', 'password_manager/core/browser/login_database.cc', 'password_manager/core/browser/login_database.h', 'password_manager/core/browser/login_database_mac.cc', @@ -104,6 +106,8 @@ 'password_manager/core/browser/mock_password_store.h', 'password_manager/core/browser/password_form_data.cc', 'password_manager/core/browser/password_form_data.h', + 'password_manager/core/browser/stub_password_manager_client.cc', + 'password_manager/core/browser/stub_password_manager_client.h', 'password_manager/core/browser/test_password_store.cc', 'password_manager/core/browser/test_password_store.h', ], diff --git a/components/password_manager/core/browser/browser_save_password_progress_logger.cc b/components/password_manager/core/browser/browser_save_password_progress_logger.cc new file mode 100644 index 0000000..1994646 --- /dev/null +++ b/components/password_manager/core/browser/browser_save_password_progress_logger.cc @@ -0,0 +1,23 @@ +// 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/core/browser/browser_save_password_progress_logger.h" + +#include "components/password_manager/core/browser/password_manager_client.h" + +namespace password_manager { + +BrowserSavePasswordProgressLogger::BrowserSavePasswordProgressLogger( + PasswordManagerClient* client) + : client_(client) { + DCHECK(client_); +} + +BrowserSavePasswordProgressLogger::~BrowserSavePasswordProgressLogger() {} + +void BrowserSavePasswordProgressLogger::SendLog(const std::string& log) { + client_->LogSavePasswordProgress(log); +} + +} // namespace password_manager diff --git a/components/password_manager/core/browser/browser_save_password_progress_logger.h b/components/password_manager/core/browser/browser_save_password_progress_logger.h new file mode 100644 index 0000000..8740635 --- /dev/null +++ b/components/password_manager/core/browser/browser_save_password_progress_logger.h @@ -0,0 +1,38 @@ +// 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. + +#ifndef COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_BROWSER_SAVE_PASSWORD_PROGRESS_LOGGER_H_ +#define COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_BROWSER_SAVE_PASSWORD_PROGRESS_LOGGER_H_ + +#include <string> + +#include "components/autofill/core/common/save_password_progress_logger.h" + +class PasswordManagerClient; + +namespace password_manager { + +// This is the SavePasswordProgressLogger specialization for the browser code, +// where the PasswordManagerClient can be directly called. +class BrowserSavePasswordProgressLogger + : public autofill::SavePasswordProgressLogger { + public: + explicit BrowserSavePasswordProgressLogger(PasswordManagerClient* client); + virtual ~BrowserSavePasswordProgressLogger(); + + protected: + // autofill::SavePasswordProgressLogger: + virtual void SendLog(const std::string& log) OVERRIDE; + + private: + // The PasswordManagerClient to which logs can be sent for display. The client + // must outlive this logger. + PasswordManagerClient* const client_; + + DISALLOW_COPY_AND_ASSIGN(BrowserSavePasswordProgressLogger); +}; + +} // namespace password_manager + +#endif // COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_BROWSER_SAVE_PASSWORD_PROGRESS_LOGGER_H_ diff --git a/components/password_manager/core/browser/browser_save_password_progress_logger_unittest.cc b/components/password_manager/core/browser/browser_save_password_progress_logger_unittest.cc new file mode 100644 index 0000000..8693e6a --- /dev/null +++ b/components/password_manager/core/browser/browser_save_password_progress_logger_unittest.cc @@ -0,0 +1,40 @@ +// 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/core/browser/browser_save_password_progress_logger.h" + +#include "components/password_manager/core/browser/stub_password_manager_client.h" +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace password_manager { + +namespace { + +const char kTestText[] = "test"; + +// The only purpose of TestLogger is to expose SendLog for the test. +class TestLogger : public BrowserSavePasswordProgressLogger { + public: + TestLogger(PasswordManagerClient* client) + : BrowserSavePasswordProgressLogger(client) {} + + using BrowserSavePasswordProgressLogger::SendLog; +}; + +class MockPasswordManagerClient : public StubPasswordManagerClient { + public: + MOCK_METHOD1(LogSavePasswordProgress, void(const std::string& text)); +}; + +} // namespace + +TEST(BrowserSavePasswordProgressLoggerTest, SendLog) { + MockPasswordManagerClient client; + TestLogger logger(&client); + EXPECT_CALL(client, LogSavePasswordProgress(kTestText)).Times(1); + logger.SendLog(kTestText); +} + +} // namespace password_manager diff --git a/components/password_manager/core/browser/password_manager_unittest.cc b/components/password_manager/core/browser/password_manager_unittest.cc index 44a5f39..a788cd5 100644 --- a/components/password_manager/core/browser/password_manager_unittest.cc +++ b/components/password_manager/core/browser/password_manager_unittest.cc @@ -12,9 +12,9 @@ #include "base/strings/utf_string_conversions.h" #include "components/password_manager/core/browser/mock_password_store.h" #include "components/password_manager/core/browser/password_manager.h" -#include "components/password_manager/core/browser/password_manager_client.h" #include "components/password_manager/core/browser/password_manager_driver.h" #include "components/password_manager/core/browser/password_store.h" +#include "components/password_manager/core/browser/stub_password_manager_client.h" #include "components/password_manager/core/common/password_manager_pref_names.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" @@ -23,6 +23,8 @@ class PasswordGenerationManager; using autofill::PasswordForm; using base::ASCIIToUTF16; +// TODO(vabr): Remove the next line once http://crbug.com/348523 is fixed. +using password_manager::StubPasswordManagerClient; using testing::_; using testing::AnyNumber; using testing::DoAll; @@ -36,23 +38,12 @@ class AutofillManager; namespace { -class MockPasswordManagerClient : public PasswordManagerClient { +class MockPasswordManagerClient : public StubPasswordManagerClient { public: MOCK_METHOD1(PromptUserToSavePassword, void(PasswordFormManager*)); MOCK_METHOD0(GetPasswordStore, PasswordStore*()); MOCK_METHOD0(GetPrefs, PrefService*()); MOCK_METHOD0(GetDriver, PasswordManagerDriver*()); - MOCK_METHOD1(GetProbabilityForExperiment, - base::FieldTrial::Probability(const std::string&)); - - // The following is required because GMock does not support move-only - // parameters. - MOCK_METHOD1(AuthenticateAutofillAndFillFormPtr, - void(autofill::PasswordFormFillData* fill_data)); - virtual void AuthenticateAutofillAndFillForm( - scoped_ptr<autofill::PasswordFormFillData> fill_data) OVERRIDE { - return AuthenticateAutofillAndFillFormPtr(fill_data.release()); - } }; class MockPasswordManagerDriver : public PasswordManagerDriver { diff --git a/components/password_manager/core/browser/stub_password_manager_client.cc b/components/password_manager/core/browser/stub_password_manager_client.cc new file mode 100644 index 0000000..9fd666a --- /dev/null +++ b/components/password_manager/core/browser/stub_password_manager_client.cc @@ -0,0 +1,25 @@ +// 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/core/browser/stub_password_manager_client.h" + +namespace password_manager { + +StubPasswordManagerClient::StubPasswordManagerClient() {} + +StubPasswordManagerClient::~StubPasswordManagerClient() {} + +void StubPasswordManagerClient::PromptUserToSavePassword( + PasswordFormManager* form_to_save) {} + +void StubPasswordManagerClient::AuthenticateAutofillAndFillForm( + scoped_ptr<autofill::PasswordFormFillData> fill_data) {} + +PrefService* StubPasswordManagerClient::GetPrefs() { return NULL; } + +PasswordStore* StubPasswordManagerClient::GetPasswordStore() { return NULL; } + +PasswordManagerDriver* StubPasswordManagerClient::GetDriver() { return NULL; } + +} // namespace password_manager diff --git a/components/password_manager/core/browser/stub_password_manager_client.h b/components/password_manager/core/browser/stub_password_manager_client.h new file mode 100644 index 0000000..bf00387 --- /dev/null +++ b/components/password_manager/core/browser/stub_password_manager_client.h @@ -0,0 +1,35 @@ +// 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. + +#ifndef COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_STUB_PASSWORD_MANAGER_CLIENT_H_ +#define COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_STUB_PASSWORD_MANAGER_CLIENT_H_ + +#include "components/password_manager/core/browser/password_manager_client.h" + +namespace password_manager { + +// Use this class as a base for mock or test clients to avoid stubbing +// uninteresting pure virtual methods. All the implemented methods are just +// trivial stubs. Do NOT use in production, only use in tests. +class StubPasswordManagerClient : public PasswordManagerClient { + public: + StubPasswordManagerClient(); + virtual ~StubPasswordManagerClient(); + + // PasswordManagerClient: + virtual void PromptUserToSavePassword(PasswordFormManager* form_to_save) + OVERRIDE; + virtual void AuthenticateAutofillAndFillForm( + scoped_ptr<autofill::PasswordFormFillData> fill_data) OVERRIDE; + virtual PrefService* GetPrefs() OVERRIDE; + virtual PasswordStore* GetPasswordStore() OVERRIDE; + virtual PasswordManagerDriver* GetDriver() OVERRIDE; + + private: + DISALLOW_COPY_AND_ASSIGN(StubPasswordManagerClient); +}; + +} // namespace password_manager + +#endif // COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_STUB_PASSWORD_MANAGER_CLIENT_H_ |