When user clears data cache/cookies, clear search prefetches

This clears all prefetches and timers in the search prefetch service
when the user clears their data (time is not considered in determining
which prefetches to clear).

Added a couple of nullptr checks to prefetch service as well.

Bug: 1138645, 1138644
Change-Id: Icbfbd0c7363e55f758c801faa91b100eaa7a365f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2493727Reviewed-by: Justin Donnelly <jdonnelly@chromium.org>
Reviewed-by: Christian Dullweber <dullweber@chromium.org>
Reviewed-by: Moe Ahmadi <mahmadi@chromium.org>
Reviewed-by: Robert Ogden <robertogden@chromium.org>
Commit-Queue: Ryan Sturm <ryansturm@chromium.org>
Cr-Commit-Position: refs/heads/master@{#822667}

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.cc

@@ -60,11 +60,14 @@
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/permissions/adaptive_quiet_notification_permission_ui_enabler.h"
 #include "chrome/browser/permissions/permission_decision_auto_blocker_factory.h"
+#include "chrome/browser/prefetch/search_prefetch/search_prefetch_service.h"
+#include "chrome/browser/prefetch/search_prefetch/search_prefetch_service_factory.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/previews/previews_service.h"
 #include "chrome/browser/previews/previews_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
 #include "chrome/browser/translate/chrome_translate_client.h"
@@ -106,6 +109,7 @@
 #include "components/prefs/pref_service.h"
 #include "components/prerender/browser/prerender_manager.h"
 #include "components/previews/content/previews_ui_service.h"
+#include "components/search_engines/template_url_service.h"
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "components/webrtc_logging/browser/log_cleanup.h"
 #include "components/webrtc_logging/browser/text_log_list.h"
@@ -1096,13 +1100,41 @@ void ChromeBrowsingDataRemoverDelegate::RemoveEmbedderData(
   }
 
   //////////////////////////////////////////////////////////////////////////////
-  // Zero suggest.
-  // Remove omnibox zero-suggest cache results. Filtering is not supported.
-  // This is not a problem, as deleting more data than necessary will just cause
-  // another server round-trip; no data is actually lost.
+  // Zero suggest and Search prefetch.
+  // Remove omnibox zero-suggest cache results and Search Prefetch cached
+  // results, we only delete when the default search engine is in the filter.
   if ((remove_mask & (content::BrowsingDataRemover::DATA_TYPE_CACHE |
                       content::BrowsingDataRemover::DATA_TYPE_COOKIES))) {
-    prefs->SetString(omnibox::kZeroSuggestCachedResults, std::string());
+    // If there is no template service or DSE, clear the caches.
+    bool should_clear_zero_suggest = true;
+    bool should_clear_search_prefetch = true;
+
+    auto* template_url_service =
+        TemplateURLServiceFactory::GetForProfile(profile_);
+
+    // If there is no default search engine, clearing the cache is fine.
+    if (template_url_service &&
+        template_url_service->GetDefaultSearchProvider()) {
+      // The suggest URL is used for zero suggest.
+      GURL suggest_url(
+          template_url_service->GetDefaultSearchProvider()->suggestions_url());
+      should_clear_zero_suggest =
+          nullable_filter.is_null() || nullable_filter.Run(suggest_url);
+
+      // The search URL is used for search prefetch.
+      GURL search_url(template_url_service->GetDefaultSearchProvider()->url());
+      should_clear_search_prefetch =
+          nullable_filter.is_null() || nullable_filter.Run(search_url);
+    }
+
+    if (should_clear_zero_suggest)
+      prefs->SetString(omnibox::kZeroSuggestCachedResults, std::string());
+
+    // |search_prefetch_service| is null if |profile_| is off the record.
+    auto* search_prefetch_service =
+        SearchPrefetchServiceFactory::GetForProfile(profile_);
+    if (should_clear_search_prefetch && search_prefetch_service)
+      search_prefetch_service->ClearPrefetches();
   }
 
   //////////////////////////////////////////////////////////////////////////////

chrome/browser/prefetch/search_prefetch/search_prefetch_service.cc

@@ -150,7 +150,8 @@ bool SearchPrefetchService::MaybePrefetchURL(const GURL& url) {
 
   auto* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile_);
-  if (!template_url_service)
+  if (!template_url_service ||
+      !template_url_service->GetDefaultSearchProvider())
     return false;
   base::string16 search_terms;
 
@@ -201,7 +202,8 @@ std::unique_ptr<PrefetchedResponseContainer>
 SearchPrefetchService::TakePrefetchResponse(const GURL& url) {
   auto* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile_);
-  if (!template_url_service)
+  if (!template_url_service ||
+      !template_url_service->GetDefaultSearchProvider())
     return nullptr;
 
   base::string16 search_terms;
@@ -244,6 +246,11 @@ SearchPrefetchService::TakePrefetchResponse(const GURL& url) {
   return response;
 }
 
+void SearchPrefetchService::ClearPrefetches() {
+  prefetches_.clear();
+  prefetch_expiry_timers_.clear();
+}
+
 void SearchPrefetchService::DeletePrefetch(base::string16 search_terms) {
   DCHECK(prefetches_.find(search_terms) != prefetches_.end());
   DCHECK(prefetch_expiry_timers_.find(search_terms) !=

chrome/browser/prefetch/search_prefetch/search_prefetch_service.h

@@ -46,6 +46,9 @@ class SearchPrefetchService : public KeyedService {
   // Returns whether the prefetch started or not.
   bool MaybePrefetchURL(const GURL& url);
 
+  // Clear all prefetches from the service.
+  void ClearPrefetches();
+
   // Takes the response from this object if |url| matches a prefetched URL.
   std::unique_ptr<PrefetchedResponseContainer> TakePrefetchResponse(
       const GURL& url);

chrome/browser/prefetch/search_prefetch/search_prefetch_service_browsertest.cc

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
@@ -26,8 +27,11 @@
 #include "components/prefs/pref_service.h"
 #include "components/search_engines/template_url_service.h"
 #include "content/public/browser/browser_task_traits.h"
+#include "content/public/browser/browsing_data_filter_builder.h"
+#include "content/public/browser/browsing_data_remover.h"
 #include "content/public/test/browser_test.h"
 #include "content/public/test/browser_test_utils.h"
+#include "content/public/test/browsing_data_remover_test_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_status_code.h"
 #include "net/test/embedded_test_server/default_handlers.h"
@@ -118,6 +122,10 @@ class SearchPrefetchBaseBrowserTest : public InProcessBrowserTest {
     return search_server_->GetURL(kSearchDomain, path);
   }
 
+  GURL GetSuggestServerURL(const std::string& path) const {
+    return search_suggest_server_->GetURL(kSuggestDomain, path);
+  }
+
   void WaitUntilStatusChanges(base::string16 search_terms) {
     auto* search_prefetch_service =
         SearchPrefetchServiceFactory::GetForProfile(browser()->profile());
@@ -168,6 +176,22 @@ class SearchPrefetchBaseBrowserTest : public InProcessBrowserTest {
 
   void set_phi_is_one(bool phi_is_one) { phi_is_one_ = phi_is_one; }
 
+  void ClearBrowsingCacheData(base::Optional<GURL> url_origin) {
+    auto filter = content::BrowsingDataFilterBuilder::Create(
+        url_origin ? content::BrowsingDataFilterBuilder::Mode::kDelete
+                   : content::BrowsingDataFilterBuilder::Mode::kPreserve);
+    if (url_origin)
+      filter->AddOrigin(url::Origin::Create(url_origin.value()));
+    content::BrowsingDataRemover* remover =
+        content::BrowserContext::GetBrowsingDataRemover(browser()->profile());
+    content::BrowsingDataRemoverCompletionObserver completion_observer(remover);
+    remover->RemoveWithFilterAndReply(
+        base::Time(), base::Time::Max(),
+        content::BrowsingDataRemover::DATA_TYPE_CACHE,
+        content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
+        std::move(filter), &completion_observer);
+  }
+
  private:
   std::unique_ptr<net::test_server::HttpResponse> HandleSearchRequest(
       const net::test_server::HttpRequest& request) {
@@ -794,6 +818,75 @@ IN_PROC_BROWSER_TEST_F(SearchPrefetchServiceEnabledBrowserTest,
   EXPECT_EQ(SearchPrefetchStatus::kRequestCancelled, prefetch_status.value());
 }
 
+IN_PROC_BROWSER_TEST_F(SearchPrefetchServiceEnabledBrowserTest,
+                       ClearCacheRemovesPrefetch) {
+  auto* search_prefetch_service =
+      SearchPrefetchServiceFactory::GetForProfile(browser()->profile());
+  EXPECT_NE(nullptr, search_prefetch_service);
+
+  std::string search_terms = "prefetch_content";
+
+  GURL prefetch_url = GetSearchServerQueryURL(search_terms);
+
+  EXPECT_TRUE(search_prefetch_service->MaybePrefetchURL(prefetch_url));
+
+  auto prefetch_status =
+      search_prefetch_service->GetSearchPrefetchStatusForTesting(
+          base::ASCIIToUTF16(search_terms));
+  EXPECT_TRUE(prefetch_status.has_value());
+
+  ClearBrowsingCacheData(base::nullopt);
+  prefetch_status = search_prefetch_service->GetSearchPrefetchStatusForTesting(
+      base::ASCIIToUTF16(search_terms));
+  EXPECT_FALSE(prefetch_status.has_value());
+}
+
+IN_PROC_BROWSER_TEST_F(SearchPrefetchServiceEnabledBrowserTest,
+                       ClearCacheSearchRemovesPrefetch) {
+  auto* search_prefetch_service =
+      SearchPrefetchServiceFactory::GetForProfile(browser()->profile());
+  EXPECT_NE(nullptr, search_prefetch_service);
+
+  std::string search_terms = "prefetch_content";
+
+  GURL prefetch_url = GetSearchServerQueryURL(search_terms);
+
+  EXPECT_TRUE(search_prefetch_service->MaybePrefetchURL(prefetch_url));
+
+  auto prefetch_status =
+      search_prefetch_service->GetSearchPrefetchStatusForTesting(
+          base::ASCIIToUTF16(search_terms));
+  EXPECT_TRUE(prefetch_status.has_value());
+
+  ClearBrowsingCacheData(GURL(GetSearchServerQueryURLWithNoQuery("/")));
+  prefetch_status = search_prefetch_service->GetSearchPrefetchStatusForTesting(
+      base::ASCIIToUTF16(search_terms));
+  EXPECT_FALSE(prefetch_status.has_value());
+}
+
+IN_PROC_BROWSER_TEST_F(SearchPrefetchServiceEnabledBrowserTest,
+                       ClearCacheOtherSavesCache) {
+  auto* search_prefetch_service =
+      SearchPrefetchServiceFactory::GetForProfile(browser()->profile());
+  EXPECT_NE(nullptr, search_prefetch_service);
+
+  std::string search_terms = "prefetch_content";
+
+  GURL prefetch_url = GetSearchServerQueryURL(search_terms);
+
+  EXPECT_TRUE(search_prefetch_service->MaybePrefetchURL(prefetch_url));
+
+  auto prefetch_status =
+      search_prefetch_service->GetSearchPrefetchStatusForTesting(
+          base::ASCIIToUTF16(search_terms));
+  EXPECT_TRUE(prefetch_status.has_value());
+
+  ClearBrowsingCacheData(GetSuggestServerURL("/"));
+  prefetch_status = search_prefetch_service->GetSearchPrefetchStatusForTesting(
+      base::ASCIIToUTF16(search_terms));
+  EXPECT_TRUE(prefetch_status.has_value());
+}
+
 class SearchPrefetchServiceZeroCacheTimeBrowserTest
     : public SearchPrefetchBaseBrowserTest {
  public: