Make BrowsingDataHandler observe WebHistoryService deletions

chrome/browser/ui/webui/browsing_history_handler.cc

 // Copyright 2015 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/ui/webui/browsing_history_handler.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <utility>
@@ skipping 32 matching lines @@
 #include "components/favicon/core/fallback_url_util.h"
 #include "components/favicon/core/large_icon_service.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/history/core/browser/web_history_service.h"
 #include "components/keyed_service/core/service_access_type.h"
 #include "components/prefs/pref_service.h"
 #include "components/query_parser/snippet.h"
 #include "components/sync/device_info/device_info.h"
 #include "components/sync/device_info/device_info_tracker.h"
+#include "components/sync/driver/sync_service_observer.h"
 #include "components/sync/protocol/history_delete_directive_specifics.pb.h"
 #include "components/sync/protocol/sync_enums.pb.h"
 #include "components/url_formatter/url_formatter.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 
 #if defined(ENABLE_EXTENSIONS)
@@ skipping 246 matching lines @@
 
 bool BrowsingHistoryHandler::HistoryEntry::SortByTimeDescending(
     const BrowsingHistoryHandler::HistoryEntry& entry1,
     const BrowsingHistoryHandler::HistoryEntry& entry2) {
   return entry1.time > entry2.time;
 }
 
 BrowsingHistoryHandler::BrowsingHistoryHandler()
     : has_pending_delete_request_(false),
       history_service_observer_(this),
+      web_history_service_observer_(this),
+      sync_service_observer_(this),
       has_synced_results_(false),
       has_other_forms_of_browsing_history_(false),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 BrowsingHistoryHandler::~BrowsingHistoryHandler() {
   query_task_tracker_.TryCancelAll();
   web_history_request_.reset();
 }
 
 void BrowsingHistoryHandler::RegisterMessages() {
   // Create our favicon data source.
   Profile* profile = Profile::FromWebUI(web_ui());
 
 #if defined(OS_ANDROID)
   favicon::FallbackIconService* fallback_icon_service =
       FallbackIconServiceFactory::GetForBrowserContext(profile);
   favicon::LargeIconService* large_icon_service =
       LargeIconServiceFactory::GetForBrowserContext(profile);
   content::URLDataSource::Add(
       profile, new LargeIconSource(fallback_icon_service, large_icon_service));
 #else
   content::URLDataSource::Add(
       profile, new FaviconSource(profile, FaviconSource::ANY));
 #endif
 
   // Get notifications when history is cleared.
-  history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
+  history::HistoryService* local_history = HistoryServiceFactory::GetForProfile(
       profile, ServiceAccessType::EXPLICIT_ACCESS);
-  if (hs)
-    history_service_observer_.Add(hs);
+  if (local_history)
+    history_service_observer_.Add(local_history);
+
+  // Get notifications when web history is deleted.
+  history::WebHistoryService* web_history =
+      WebHistoryServiceFactory::GetForProfile(profile);
+  if (web_history) {
+    web_history_service_observer_.Add(web_history);
+  } else {
+    // If |web_history| is not available, it means that the history sync is
+    // disabled. Observe |sync_service| so that we can attach the listener
+    // in case it gets enabled later.
+    ProfileSyncService* sync_service =
+        ProfileSyncServiceFactory::GetForProfile(profile);
+    if (sync_service)
+      sync_service_observer_.Add(sync_service);
+  }
 
   web_ui()->RegisterMessageCallback("queryHistory",
       base::Bind(&BrowsingHistoryHandler::HandleQueryHistory,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("removeVisits",
       base::Bind(&BrowsingHistoryHandler::HandleRemoveVisits,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("clearBrowsingData",
       base::Bind(&BrowsingHistoryHandler::HandleClearBrowsingData,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("removeBookmark",
       base::Bind(&BrowsingHistoryHandler::HandleRemoveBookmark,
                  base::Unretained(this)));
 }
 
 bool BrowsingHistoryHandler::ExtractIntegerValueAtIndex(
     const base::ListValue* value,
     int index,
     int* out_int) {
   double double_value;
   if (value->GetDouble(index, &double_value)) {
     *out_int = static_cast<int>(double_value);
     return true;
   }
   NOTREACHED();
   return false;
 }
 
+void BrowsingHistoryHandler::OnStateChanged() {
+  // If the history sync was enabled, start observing WebHistoryService.
+  // This method should not be called after we already added the observer.
+  history::WebHistoryService* web_history =
+      WebHistoryServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()));
+  if (web_history) {
+    DCHECK(!web_history_service_observer_.IsObserving(web_history));
+    web_history_service_observer_.Add(web_history);
+    sync_service_observer_.RemoveAll();
+  }
+}
+
 void BrowsingHistoryHandler::WebHistoryTimeout() {
   // TODO(dubroy): Communicate the failure to the front end.
   if (!query_task_tracker_.HasTrackedTasks())
     ReturnResultsToFrontEnd();
 
   UMA_HISTOGRAM_ENUMERATION(
       "WebHistory.QueryCompletion",
       WEB_HISTORY_QUERY_TIMED_OUT, NUM_WEB_HISTORY_QUERY_BUCKETS);
 }
 
@@ skipping 565 matching lines @@
 
 void BrowsingHistoryHandler::OnURLsDeleted(
     history::HistoryService* history_service,
     bool all_history,
     bool expired,
     const history::URLRows& deleted_rows,
     const std::set<GURL>& favicon_urls) {
   if (all_history || DeletionsDiffer(deleted_rows, urls_to_be_deleted_))
     web_ui()->CallJavascriptFunctionUnsafe("historyDeleted");
 }
+
+void BrowsingHistoryHandler::OnWebHistoryDeleted() {
+  web_ui()->CallJavascriptFunctionUnsafe("historyDeleted");

[Dan Beam, 2016/08/25 19:20:10]

note: if the page is in the middle of a reload when this is called, the message
may be dropped (and might eventually crash chrome if we re-instate a CHECK()
that once was here)

we've slowly been changing things to OnJavascript{Allowed,Disallowed} throughout
webui.

just FYI, that's why it's named "Unsafe"

[msramek, 2016/08/25 20:21:34]

Thanks for checking.

On the JS side, "historyDeleted" should do exactly that - reload the page. If
the request is dropped during a reload, that's not a problem - it's already
doing what it's supposed to.

If it doesn't cause a crash for other reasons, I would still prefer to go
forward with this CL, as I'm trying to fix a long-standing user complaint. I'm
happy to work with you on a followup where we apply
OnJavascript{Allowed,Disallowed}.

+}