Notify SSLManager when all password fields on a page are gone

content/browser/ssl/ssl_manager.cc

 // Copyright (c) 2012 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 "content/browser/ssl/ssl_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 166 matching lines @@
   if (!details.is_main_frame) {
     // If it wasn't a main-frame navigation, then carry over content
     // status flags. (For example, the mixed content flag shouldn't
     // clear because of a frame navigation.)
     NavigationEntryImpl* previous_entry =
         controller_->GetEntryAtIndex(details.previous_entry_index);
     if (previous_entry) {
       content_status_flags = previous_entry->GetSSL().content_status;
     }
   }
-  UpdateEntry(entry, content_status_flags);
+  UpdateEntry(entry, content_status_flags, 0);
   // Always notify the WebContents that the SSL state changed when a
   // load is committed, in case the active navigation entry has changed.
   NotifyDidChangeVisibleSSLState();
 }
 
 void SSLManager::DidDisplayMixedContent() {
-  UpdateLastCommittedEntry(SSLStatus::DISPLAYED_INSECURE_CONTENT);
+  UpdateLastCommittedEntry(SSLStatus::DISPLAYED_INSECURE_CONTENT, 0);
 }
 
 void SSLManager::DidDisplayContentWithCertErrors() {
   NavigationEntryImpl* entry = controller_->GetLastCommittedEntry();
   if (!entry)
     return;
   // Only record information about subresources with cert errors if the
   // main page is HTTPS with a certificate.
   if (entry->GetURL().SchemeIsCryptographic() && entry->GetSSL().certificate) {
-    UpdateLastCommittedEntry(SSLStatus::DISPLAYED_CONTENT_WITH_CERT_ERRORS);
+    UpdateLastCommittedEntry(SSLStatus::DISPLAYED_CONTENT_WITH_CERT_ERRORS, 0);
   }
 }
 
 void SSLManager::DidShowPasswordInputOnHttp() {
-  UpdateLastCommittedEntry(SSLStatus::DISPLAYED_PASSWORD_FIELD_ON_HTTP);
+  UpdateLastCommittedEntry(SSLStatus::DISPLAYED_PASSWORD_FIELD_ON_HTTP, 0);
+}
+
+void SSLManager::DidHideAllPasswordInputsOnHttp() {
+  UpdateLastCommittedEntry(0, SSLStatus::DISPLAYED_PASSWORD_FIELD_ON_HTTP);
 }
 
 void SSLManager::DidShowCreditCardInputOnHttp() {
-  UpdateLastCommittedEntry(SSLStatus::DISPLAYED_CREDIT_CARD_FIELD_ON_HTTP);
+  UpdateLastCommittedEntry(SSLStatus::DISPLAYED_CREDIT_CARD_FIELD_ON_HTTP, 0);
 }
 
 void SSLManager::DidRunMixedContent(const GURL& security_origin) {
   NavigationEntryImpl* entry = controller_->GetLastCommittedEntry();
   if (!entry)
     return;
 
   SiteInstance* site_instance = entry->site_instance();
   if (!site_instance)
     return;
 
   if (ssl_host_state_delegate_) {
     ssl_host_state_delegate_->HostRanInsecureContent(
         security_origin.host(), site_instance->GetProcess()->GetID(),
         SSLHostStateDelegate::MIXED_CONTENT);
   }
-  UpdateEntry(entry, 0);
+  UpdateEntry(entry, 0, 0);
   NotifySSLInternalStateChanged(controller_->GetBrowserContext());
 }
 
 void SSLManager::DidRunContentWithCertErrors(const GURL& security_origin) {
   NavigationEntryImpl* entry = controller_->GetLastCommittedEntry();
   if (!entry)
     return;
 
   SiteInstance* site_instance = entry->site_instance();
   if (!site_instance)
     return;
 
   if (ssl_host_state_delegate_) {
     ssl_host_state_delegate_->HostRanInsecureContent(
         security_origin.host(), site_instance->GetProcess()->GetID(),
         SSLHostStateDelegate::CERT_ERRORS_CONTENT);
   }
-  UpdateEntry(entry, 0);
+  UpdateEntry(entry, 0, 0);
   NotifySSLInternalStateChanged(controller_->GetBrowserContext());
 }
 
 void SSLManager::OnCertError(std::unique_ptr<SSLErrorHandler> handler) {
   bool expired_previous_decision = false;
   // First we check if we know the policy for this error.
   DCHECK(handler->ssl_info().is_valid());
   SSLHostStateDelegate::CertJudgment judgment =
       ssl_host_state_delegate_
           ? ssl_host_state_delegate_->QueryPolicy(
@@ skipping 92 matching lines @@
   const GURL& request_url = handler->request_url();
   ResourceType resource_type = handler->resource_type();
   GetContentClient()->browser()->AllowCertificateError(
       web_contents, cert_error, ssl_info, request_url, resource_type,
       overridable, strict_enforcement, expired_previous_decision,
       base::Bind(&OnAllowCertificate, base::Owned(handler.release()),
                  ssl_host_state_delegate_));
 }
 
 void SSLManager::UpdateEntry(NavigationEntryImpl* entry,
-                             int additional_content_status_flags) {
+                             int add_content_status_flags,
+                             int remove_content_status_flags) {
   // We don't always have a navigation entry to update, for example in the
   // case of the Web Inspector.
   if (!entry)
     return;
 
   SSLStatus original_ssl_status = entry->GetSSL();  // Copy!
   entry->GetSSL().initialized = true;
-  entry->GetSSL().content_status |= additional_content_status_flags;
+  entry->GetSSL().content_status |= add_content_status_flags;
+  entry->GetSSL().content_status &= ~remove_content_status_flags;
 
   SiteInstance* site_instance = entry->site_instance();
   // Note that |site_instance| can be NULL here because NavigationEntries don't
   // necessarily have site instances.  Without a process, the entry can't
   // possibly have insecure content.  See bug https://crbug.com/12423.
   if (site_instance && ssl_host_state_delegate_) {
     std::string host = entry->GetURL().host();
     int process_id = site_instance->GetProcess()->GetID();
     if (ssl_host_state_delegate_->DidHostRunInsecureContent(
             host, process_id, SSLHostStateDelegate::MIXED_CONTENT)) {
       entry->GetSSL().content_status |= SSLStatus::RAN_INSECURE_CONTENT;
     }
 
     // Only record information about subresources with cert errors if the
     // main page is HTTPS with a certificate.
     if (entry->GetURL().SchemeIsCryptographic() &&
         entry->GetSSL().certificate &&
         ssl_host_state_delegate_->DidHostRunInsecureContent(
             host, process_id, SSLHostStateDelegate::CERT_ERRORS_CONTENT)) {
       entry->GetSSL().content_status |= SSLStatus::RAN_CONTENT_WITH_CERT_ERRORS;
     }
   }
 
   if (!entry->GetSSL().Equals(original_ssl_status))
     NotifyDidChangeVisibleSSLState();
 }
 
-void SSLManager::UpdateLastCommittedEntry(int additional_content_status_flags) {
+void SSLManager::UpdateLastCommittedEntry(int add_content_status_flags,
+                                          int remove_content_status_flags) {
   NavigationEntryImpl* entry = controller_->GetLastCommittedEntry();
   if (!entry)
     return;
-  UpdateEntry(entry, additional_content_status_flags);
+  UpdateEntry(entry, add_content_status_flags, remove_content_status_flags);
 }
 
 void SSLManager::NotifyDidChangeVisibleSSLState() {
   WebContentsImpl* contents =
       static_cast<WebContentsImpl*>(controller_->delegate()->GetWebContents());
   contents->DidChangeVisibleSecurityState();
 }
 
 // static
 void SSLManager::NotifySSLInternalStateChanged(BrowserContext* context) {
   SSLManagerSet* managers =
       static_cast<SSLManagerSet*>(context->GetUserData(kSSLManagerKeyName));
 
   for (std::set<SSLManager*>::iterator i = managers->get().begin();
        i != managers->get().end(); ++i) {
-    (*i)->UpdateEntry((*i)->controller()->GetLastCommittedEntry(), 0);
+    (*i)->UpdateEntry((*i)->controller()->GetLastCommittedEntry(), 0, 0);
   }
 }
 
 }  // namespace content