Move HISTORY and PASSWORDS from BrowsingDataRemover to the delegate

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.cc

 // Copyright 2016 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/chrome_browsing_data_remover_delegate.h"
 
 #include <set>
 #include <string>
 #include <utility>
 
@@ skipping 46 matching lines @@
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/pnacl_host.h"
 #include "components/ntp_snippets/bookmarks/bookmark_last_visit_utils.h"
 #include "components/ntp_snippets/content_suggestions_service.h"
 #include "components/omnibox/browser/omnibox_pref_names.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/prefs/pref_service.h"
 #include "components/previews/core/previews_ui_service.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/sessions/core/tab_restore_service.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/cookies/cookie_store.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/webapps/webapp_registry.h"
 #include "chrome/browser/precache/precache_manager_factory.h"
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/offline_page_model.h"
 #include "components/precache/content/precache_manager.h"
@@ skipping 121 matching lines @@
 }
 
 void ClearHostnameResolutionCacheOnIOThread(
     IOThread* io_thread,
     base::Callback<bool(const std::string&)> host_filter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   io_thread->ClearHostCache(host_filter);
 }
 
+void ClearHttpAuthCacheOnIOThread(
+    scoped_refptr<net::URLRequestContextGetter> context_getter,
+    base::Time delete_begin) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  net::HttpNetworkSession* http_session = context_getter->GetURLRequestContext()
+                                              ->http_transaction_factory()
+                                              ->GetSession();
+  DCHECK(http_session);
+  http_session->http_auth_cache()->ClearEntriesAddedWithin(base::Time::Now() -
+                                                           delete_begin);
+  http_session->CloseAllConnections();
+}
+
 }  // namespace
 
 ChromeBrowsingDataRemoverDelegate::SubTask::SubTask(
     const base::Closure& forward_callback)
     : is_pending_(false),
       forward_callback_(forward_callback),
       weak_ptr_factory_(this) {
   DCHECK(!forward_callback_.is_null());
 }
 
@@ skipping 33 matching lines @@
       clear_keyword_data_(sub_task_forward_callback_),
 #if !defined(DISABLE_NACL)
       clear_nacl_cache_(sub_task_forward_callback_),
       clear_pnacl_cache_(sub_task_forward_callback_),
 #endif
       clear_hostname_resolution_cache_(sub_task_forward_callback_),
       clear_network_predictor_(sub_task_forward_callback_),
       clear_networking_history_(sub_task_forward_callback_),
       clear_passwords_(sub_task_forward_callback_),
       clear_passwords_stats_(sub_task_forward_callback_),
+      clear_http_auth_cache_(sub_task_forward_callback_),
       clear_platform_keys_(sub_task_forward_callback_),
 #if defined(OS_ANDROID)
       clear_precache_history_(sub_task_forward_callback_),
       clear_offline_page_data_(sub_task_forward_callback_),
 #endif
 #if BUILDFLAG(ENABLE_WEBRTC)
       clear_webrtc_logs_(sub_task_forward_callback_),
 #endif
       clear_auto_sign_in_(sub_task_forward_callback_),
 #if defined(OS_ANDROID)
@@ skipping 29 matching lines @@
   base::Callback<bool(const GURL&)> nullable_filter =
       filter_builder.IsEmptyBlacklist() ? base::Callback<bool(const GURL&)>()
                                         : filter;
 
   // Managed devices and supervised users can have restrictions on history
   // deletion.
   PrefService* prefs = profile_->GetPrefs();
   bool may_delete_history = prefs->GetBoolean(
       prefs::kAllowDeletingBrowserHistory);
 
+  // All the UI entry points into the BrowsingDataRemoverImpl should be
+  // disabled, but this will fire if something was missed or added.
+  DCHECK(may_delete_history ||
+         (remove_mask & BrowsingDataRemover::REMOVE_NOCHECKS) ||
+         (!(remove_mask & BrowsingDataRemover::REMOVE_HISTORY) &&
+          !(remove_mask & BrowsingDataRemover::REMOVE_DOWNLOADS)));
+
   //////////////////////////////////////////////////////////////////////////////
   // REMOVE_HISTORY
   if ((remove_mask & BrowsingDataRemover::REMOVE_HISTORY) &&
       may_delete_history) {
     history::HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
     if (history_service) {
       // TODO(dmurph): Support all backends with filter (crbug.com/113621).
       content::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
@@ skipping 186 matching lines @@
       }
     }
 
     // |previews_service| is null if |profile_| is off the record.
     PreviewsService* previews_service =
         PreviewsServiceFactory::GetForProfile(profile_);
     if (previews_service && previews_service->previews_ui_service()) {
       previews_service->previews_ui_service()->ClearBlackList(delete_begin_,
                                                               delete_end_);
     }
+
+    // The SSL Host State that tracks SSL interstitial "proceed" decisions may
+    // include origins that the user has visited, so it must be cleared.
+    // TODO(msramek): We can reuse the plugin filter here, since both plugins
+    // and SSL host state are scoped to hosts and represent them as std::string.
+    // Rename the method to indicate its more general usage.
+    if (profile_->GetSSLHostStateDelegate()) {
+      profile_->GetSSLHostStateDelegate()->Clear(
+          filter_builder.IsEmptyBlacklist()
+              ? base::Callback<bool(const std::string&)>()
+              : filter_builder.BuildPluginFilter());
+    }
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // REMOVE_DOWNLOADS
   if ((remove_mask & BrowsingDataRemover::REMOVE_DOWNLOADS) &&
       may_delete_history) {
     DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
         BrowserContext::GetDownloadManager(profile_));
     download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
   }
@@ skipping 83 matching lines @@
     password_manager::PasswordStore* password_store =
         PasswordStoreFactory::GetForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS).get();
 
     if (password_store) {
       clear_passwords_.Start();
       password_store->RemoveLoginsByURLAndTime(
           filter, delete_begin_, delete_end_,
           clear_passwords_.GetCompletionCallback());
     }
+
+    scoped_refptr<net::URLRequestContextGetter> request_context =
+        BrowserContext::GetDefaultStoragePartition(profile_)
+            ->GetURLRequestContext();
+    clear_http_auth_cache_.Start();
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ClearHttpAuthCacheOnIOThread, std::move(request_context),
+                   delete_begin_),
+        clear_http_auth_cache_.GetCompletionCallback());
   }
 
   if (remove_mask & BrowsingDataRemover::REMOVE_COOKIES) {
     password_manager::PasswordStore* password_store =
         PasswordStoreFactory::GetForProfile(profile_,
                                             ServiceAccessType::EXPLICIT_ACCESS)
             .get();
 
     if (password_store) {
       clear_auto_sign_in_.Start();
@@ skipping 209 matching lines @@
          !clear_form_.is_pending() && !clear_history_.is_pending() &&
          !clear_hostname_resolution_cache_.is_pending() &&
          !clear_keyword_data_.is_pending() &&
 #if !defined(DISABLE_NACL)
          !clear_nacl_cache_.is_pending() && !clear_pnacl_cache_.is_pending() &&
 #endif
          !clear_network_predictor_.is_pending() &&
          !clear_networking_history_.is_pending() &&
          !clear_passwords_.is_pending() &&
          !clear_passwords_stats_.is_pending() &&
+         !clear_http_auth_cache_.is_pending() &&
          !clear_platform_keys_.is_pending() &&
 #if defined(OS_ANDROID)
          !clear_precache_history_.is_pending() &&
          !clear_offline_page_data_.is_pending() &&
 #endif
 #if BUILDFLAG(ENABLE_WEBRTC)
          !clear_webrtc_logs_.is_pending() &&
 #endif
          !clear_auto_sign_in_.is_pending();
 }
@@ skipping 36 matching lines @@
 
 #if defined(OS_CHROMEOS)
 void ChromeBrowsingDataRemoverDelegate::OnClearPlatformKeys(
     chromeos::DBusMethodCallStatus call_status,
     bool result) {
   LOG_IF(ERROR, call_status != chromeos::DBUS_METHOD_CALL_SUCCESS || !result)
       << "Failed to clear platform keys.";
   clear_platform_keys_.GetCompletionCallback().Run();
 }
 #endif