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_manager_util.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 {
 
 void RunMojoGetCallback(const mojom::CredentialManager::GetCallback& callback,
@@ skipping 17 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);
 
+  if (password_manager_util::IsLoggingActive(client_)) {
+    CredentialManagerLogger(client_->GetLogManager())
+        .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) {
+  if (password_manager_util::IsLoggingActive(client_)) {
+    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();
+  if (password_manager_util::IsLoggingActive(client_)) {
+    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()));
 
+  if (password_manager_util::IsLoggingActive(client_)) {
+    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