Clear HTTP auth data on clearing browsing data

chrome/browser/browsing_data/browsing_data_remover.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 "chrome/browser/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 54 matching lines @@
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_data_remover.h"
 #include "content/public/browser/ssl_host_state_delegate.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/user_metrics.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_store.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/http/transport_security_state.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "url/origin.h"
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
@@ skipping 91 matching lines @@
     const ContentSettingsPattern& secondary_pattern) {
   return predicate.Run(primary_pattern);
 }
 
 void ClearHostnameResolutionCacheOnIOThread(IOThread* io_thread) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   io_thread->ClearHostCache();
 }
 
+void ClearHttpAuthCacheOnIOThread(
+    scoped_refptr<net::URLRequestContextGetter> context_getter,
+    base::Time delete_begin,
+    base::Time delete_end) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  net::HttpNetworkSession* http_session = context_getter->GetURLRequestContext()
+                                              ->http_transaction_factory()
+                                              ->GetSession();
+  DCHECK(http_session);
+  http_session->http_auth_cache()->Clear(delete_begin, delete_end);
+}
+
 void ClearNetworkPredictorOnIOThread(chrome_browser_net::Predictor* predictor) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(predictor);
 
   predictor->DiscardInitialNavigationHistory();
   predictor->DiscardAllResults();
 }
 
 #if !defined(DISABLE_NACL)
 void ClearNaClCacheOnIOThread(const base::Closure& callback) {
@@ skipping 697 matching lines @@
 
     // When clearing cache, wipe accumulated network related data
     // (TransportSecurityState and HttpServerPropertiesManager data).
     waiting_for_clear_networking_history_ = true;
     profile_->ClearNetworkingHistorySince(
         delete_begin_,
         base::Bind(&BrowsingDataRemover::OnClearedNetworkingHistory,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
+  if (remove_mask & REMOVE_CACHE || remove_mask & REMOVE_COOKIES ||
+      remove_mask & REMOVE_PASSWORDS && g_browser_process->io_thread()) {

[msramek, 2016/07/01 13:19:40]

The g_browser_process->io_thread() is not necessary -
BrowserProcessImpl::io_thread() DCHECKs that it's not null.

[Tomasz Moniuszko, 2016/07/01 14:54:40]

Done.

+    scoped_refptr<net::URLRequestContextGetter> request_context =

[msramek, 2016/07/01 13:19:40]

This is not really related to storage partition, so it would be cleaner to do
just:

profile_->GetRequestContext()->GetURLRequestContext()

[Tomasz Moniuszko, 2016/07/01 14:54:40]

Done.

+        content::BrowserContext::GetDefaultStoragePartition(profile_)
+            ->GetURLRequestContext();
+    waiting_for_clear_http_auth_cache_ = true;
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ClearHttpAuthCacheOnIOThread, std::move(request_context),
+                   delete_begin_, delete_end_),
+        base::Bind(&BrowsingDataRemover::OnClearedHttpAuthCache,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
   if (remove_mask & REMOVE_WEBRTC_IDENTITY) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY;
   }
 
   if (storage_partition_remove_mask) {
     waiting_for_clear_storage_partition_data_ = true;
 
     content::StoragePartition* storage_partition;
     if (storage_partition_for_testing_)
@@ skipping 188 matching lines @@
   return delete_begin_time - diff;
 }
 
 bool BrowsingDataRemover::AllDone() {
   return !waiting_for_clear_autofill_origin_urls_ &&
          !waiting_for_clear_cache_ && !waiting_for_clear_content_licenses_ &&
          !waiting_for_clear_channel_ids_ && !waiting_for_clear_cookies_count_ &&
          !waiting_for_clear_domain_reliability_monitor_ &&
          !waiting_for_clear_form_ && !waiting_for_clear_history_ &&
          !waiting_for_clear_hostname_resolution_cache_ &&
+         !waiting_for_clear_http_auth_cache_ &&
          !waiting_for_clear_keyword_data_ && !waiting_for_clear_nacl_cache_ &&
          !waiting_for_clear_network_predictor_ &&
          !waiting_for_clear_networking_history_ &&
          !waiting_for_clear_passwords_ && !waiting_for_clear_passwords_stats_ &&
          !waiting_for_clear_platform_keys_ && !waiting_for_clear_plugin_data_ &&
          !waiting_for_clear_pnacl_cache_ &&
 #if BUILDFLAG(ANDROID_JAVA_UI)
          !waiting_for_clear_precache_history_ &&
          !waiting_for_clear_webapp_data_ &&
          !waiting_for_clear_webapp_history_ &&
@@ skipping 52 matching lines @@
   waiting_for_clear_history_ = false;
   NotifyIfDone();
 }
 
 void BrowsingDataRemover::OnClearedHostnameResolutionCache() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_hostname_resolution_cache_ = false;
   NotifyIfDone();
 }
 
+void BrowsingDataRemover::OnClearedHttpAuthCache() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  waiting_for_clear_http_auth_cache_ = false;
+  NotifyIfDone();
+}
+
 void BrowsingDataRemover::OnClearedNetworkPredictor() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_network_predictor_ = false;
   NotifyIfDone();
 }
 
 void BrowsingDataRemover::OnClearedNetworkingHistory() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_networking_history_ = false;
   NotifyIfDone();
@@ skipping 143 matching lines @@
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyIfDone();
 }
 
 // static
 BrowsingDataRemover::CallbackSubscription
     BrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
         const BrowsingDataRemover::Callback& callback) {
   return GetOnBrowsingDataRemovedCallbacks()->Add(callback);
 }