Implement logging of the Credential Manager API calls to chrome://password-manager-internals.

components/password_manager/content/browser/credential_manager_impl.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_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/content/browser/content_password_manager_driver.h"
 #include "components/password_manager/content/browser/content_password_manager_driver_factory.h"
 #include "components/password_manager/core/browser/affiliated_match_helper.h"
+#include "components/password_manager/core/browser/credential_manager_logger.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "components/password_manager/core/browser/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"
 
 namespace password_manager {
 
 namespace {
 
@@ skipping 18 matching lines @@
 
 void CredentialManagerImpl::BindRequest(
     mojom::CredentialManagerRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 void CredentialManagerImpl::Store(const CredentialInfo& credential,
                                   const StoreCallback& callback) {
   DCHECK_NE(CredentialType::CREDENTIAL_TYPE_EMPTY, credential.type);
 
+  CredentialManagerLogger(client_->GetLogManager())

[vabr (Chromium), 2016/08/29 13:10:44]

For all the current logging the code checks LogManager::IsLoggingActive() as
soon as possible, so that the performance impact on the code is minimised in
cases when the internals page is not open. Please follow that pattern here as
well, do not construct the logger before you know you need it.

[vasilii, 2016/08/29 15:12:39]

Done.

+      .LogStoreCredential(web_contents()->GetLastCommittedURL(),
+                          credential.type);
+
   // Send acknowledge response back.
   callback.Run();
 
   if (!client_->IsSavingAndFillingEnabledForCurrentPage())
     return;
 
   client_->NotifyStorePasswordCalled();
 
   GURL origin = web_contents()->GetLastCommittedURL().GetOrigin();
   std::unique_ptr<autofill::PasswordForm> form(
@@ skipping 32 matching lines @@
   }
 
   // Otherwise, this is a new form, so as the user if they'd like to save.
   client_->PromptUserToSaveOrUpdatePassword(
       std::move(form_manager_), CredentialSourceType::CREDENTIAL_SOURCE_API,
       false);
 }
 
 void CredentialManagerImpl::RequireUserMediation(
     const RequireUserMediationCallback& callback) {
+  CredentialManagerLogger(client_->GetLogManager())
+      .LogRequireUserMediation(web_contents()->GetLastCommittedURL());
   PasswordStore* store = GetPasswordStore();
   if (!store || !IsUpdatingCredentialAllowed()) {
     callback.Run();
     return;
   }
 
   if (store->affiliated_match_helper()) {
     store->affiliated_match_helper()->GetAffiliatedAndroidRealms(
         GetSynthesizedFormForOrigin(),
         base::Bind(&CredentialManagerImpl::ScheduleRequireMediationTask,
@@ skipping 26 matching lines @@
 
   // Send acknowledge response back.
   callback.Run();
 }
 
 void CredentialManagerImpl::Get(bool zero_click_only,
                                 bool include_passwords,
                                 const std::vector<GURL>& federations,
                                 const GetCallback& callback) {
   PasswordStore* store = GetPasswordStore();
+  CredentialManagerLogger(client_->GetLogManager())
+      .LogRequestCredential(web_contents()->GetLastCommittedURL(),
+                            zero_click_only, federations);
   if (pending_request_ || !store) {
     // Callback error.
     callback.Run(pending_request_
                      ? mojom::CredentialManagerError::PENDINGREQUEST
                      : mojom::CredentialManagerError::PASSWORDSTOREUNAVAILABLE,
                  base::nullopt);
     return;
   }
 
   // Return an empty credential if zero-click is required but disabled, or if
@@ skipping 55 matching lines @@
       driver_factory->GetDriverForFrame(web_contents()->GetMainFrame());
   return driver->AsWeakPtr();
 }
 
 void CredentialManagerImpl::SendCredential(
     const SendCredentialCallback& send_callback,
     const CredentialInfo& info) {
   DCHECK(pending_request_);
   DCHECK(send_callback.Equals(pending_request_->send_callback()));
 
+  CredentialManagerLogger(client_->GetLogManager())
+      .LogSendCredential(web_contents()->GetLastCommittedURL(), info.type);
   send_callback.Run(info);
   pending_request_.reset();
 }
 
 void CredentialManagerImpl::SendPasswordForm(
     const SendCredentialCallback& send_callback,
     const autofill::PasswordForm* form) {
   CredentialInfo info;
   if (form) {
     password_manager::CredentialType type_to_return =
@@ skipping 35 matching lines @@
   DCHECK(pending_require_user_mediation_);
   pending_require_user_mediation_.reset();
 }
 
 bool CredentialManagerImpl::IsUpdatingCredentialAllowed() const {
   return !client_->DidLastPageLoadEncounterSSLErrors() &&
          !client_->IsOffTheRecord();
 }
 
 }  // namespace password_manager