Refactor BrowsingHistoryHandler, create BrowsingHistoryService

chrome/browser/ui/history_ui_service.h

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// 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.
 
-#ifndef CHROME_BROWSER_UI_WEBUI_BROWSING_HISTORY_HANDLER_H_
-#define CHROME_BROWSER_UI_WEBUI_BROWSING_HISTORY_HANDLER_H_
+#ifndef CHROME_BROWSER_UI_HISTORY_UI_SERVICE_H_
+#define CHROME_BROWSER_UI_HISTORY_UI_SERVICE_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/history/core/browser/url_row.h"
 #include "components/history/core/browser/web_history_service.h"
 #include "components/history/core/browser/web_history_service_observer.h"
 #include "components/sync/driver/sync_service_observer.h"
-#include "content/public/browser/web_ui_message_handler.h"
 #include "url/gurl.h"
 
-class SupervisedUserService;
-
-namespace bookmarks {
-class BookmarkModel;
-}  // namespace bookmarks
-
 namespace browser_sync {
 class ProfileSyncService;
 }  // namespace browser_sync
 
 namespace history {
 class HistoryService;
 class QueryResults;
 struct QueryOptions;
 }  // namespace history
 
 namespace syncer {
 class SyncServiceObserver;
 }  // namespace syncer
 
-// The handler for Javascript messages related to the "history" view.
-class BrowsingHistoryHandler : public content::WebUIMessageHandler,
-                               public history::HistoryServiceObserver,
-                               public history::WebHistoryServiceObserver,
-                               public syncer::SyncServiceObserver {
+class Profile;
+
+// Interacts with HistoryService, WebHistoryService, and SyncService to query
+// history and provide results to the associated HistoryUiServiceHandler.
+class HistoryUiService : public history::HistoryServiceObserver,

[sky, 2016/11/07 20:42:52]

Is there a reason not to keep this code in the webui directory where it used? I
find this name mildly confusing given there is already a HistoryService. Can
this be named to better indicate it's used for webui?

[Theresa, 2016/11/07 21:02:15]

I'm working on changing Android to have its own history view that uses Android
Views rather than the old webui. This refactoring is the first step. Currently
this class is only used by the webui, but in the near future it will also be
used by the Android history ui, which won't live in the webui directory.
HistoryUiService seemed like a good name since it's going to be used by the
existing webui and the new Android ui, but I'm open to suggestions. Maybe
BrowsingHistoryService (or BrowsingHistoryUiService) to help denote that it
aggregates various kinds of history?

+                         public history::WebHistoryServiceObserver,
+                         public syncer::SyncServiceObserver {
  public:
   // Represents a history entry to be shown to the user, representing either
   // a local or remote visit. A single entry can represent multiple visits,
   // since only the most recent visit on a particular day is shown.
   struct HistoryEntry {
     // Values indicating whether an entry represents only local visits, only
     // remote visits, or a mixture of both.
     enum EntryType {
       EMPTY_ENTRY = 0,
       LOCAL_ENTRY,
       REMOTE_ENTRY,
       COMBINED_ENTRY
     };
 
     HistoryEntry(EntryType type, const GURL& url, const base::string16& title,
                  base::Time time, const std::string& client_id,
                  bool is_search_result, const base::string16& snippet,
                  bool blocked_visit);
     HistoryEntry();
     HistoryEntry(const HistoryEntry& other);
     virtual ~HistoryEntry();
 
-    // Formats this entry's URL and title and adds them to |result|.
-    void SetUrlAndTitle(base::DictionaryValue* result,
-                        bool limit_title_length) const;
-
-    // Converts the entry to a DictionaryValue to be owned by the caller.
-    std::unique_ptr<base::DictionaryValue> ToValue(
-        bookmarks::BookmarkModel* bookmark_model,
-        SupervisedUserService* supervised_user_service,
-        const browser_sync::ProfileSyncService* sync_service,
-        bool limit_title_length) const;
-
     // Comparison function for sorting HistoryEntries from newest to oldest.
     static bool SortByTimeDescending(
         const HistoryEntry& entry1, const HistoryEntry& entry2);
 
     // The type of visits this entry represents: local, remote, or both.
     EntryType entry_type;
 
     GURL url;
     base::string16 title;  // Title of the entry. May be empty.
 
@@ skipping 10 matching lines @@
     // If true, this entry is a search result.
     bool is_search_result;
 
     // The entry's search snippet, if this entry is a search result.
     base::string16 snippet;
 
     // Whether this entry was blocked when it was attempted.
     bool blocked_visit;
   };
 
-  BrowsingHistoryHandler();
-  ~BrowsingHistoryHandler() override;
+  // Contains information about a completed history query.
+  struct QueryResultsInfo {
+    QueryResultsInfo();
+    ~QueryResultsInfo();
 
-  // WebUIMessageHandler implementation.
-  void RegisterMessages() override;
+    // The query search text.
+    base::string16 search_text;
+
+    // Whether the query reached the beginning of the database.
+    bool reached_beginning;
+
+    // Whether the last call to Web History returned synced results.
+    bool has_synced_results;
+
+    // The localized query start time.
+    base::Time start_time;
+
+    // The localized query end time.
+    base::Time end_time;
+  };
+
+  // Interface for handling calls from the HistoryUiService.
+  class HistoryUiServiceHandler {
+   public:
+    // Callback for QueryHistory().
+    virtual void OnQueryComplete(
+        std::vector<HistoryUiService::HistoryEntry>* results,
+        HistoryUiService::QueryResultsInfo* query_results_info) = 0;
+
+    // Callback for RemoveVisits().
+    virtual void OnRemoveVisitsComplete() = 0;
+
+    // Callback for RemoveVisits() that fails.
+    virtual void OnRemoveVisitsFailed() = 0;
+
+    // Called when HistoryService or WebHistoryService deletes one or more
+    // items.
+    virtual void HistoryDeleted() = 0;
+
+    // Whether other forms of browsing history were found on the history
+    // service.
+    virtual void HasOtherFormsOfBrowsingHistory(
+        bool has_other_forms, bool has_synced_results) = 0;
+  };
+
+  HistoryUiService(Profile* profile,
+                   HistoryUiService::HistoryUiServiceHandler* handler);
+  ~HistoryUiService() override;
+
+  // Core implementation of history querying.
+  void QueryHistory(const base::string16& search_text,
+                    const history::QueryOptions& options);
+
+  // Removes |items| from history.
+  void RemoveVisits(
+      std::vector<std::unique_ptr<HistoryUiService::HistoryEntry>>* items);
 
   // SyncServiceObserver implementation.
   void OnStateChanged() override;
 
-  // Handler for the "queryHistory" message.
-  void HandleQueryHistory(const base::ListValue* args);
-
-  // Handler for the "removeVisits" message.
-  void HandleRemoveVisits(const base::ListValue* args);
-
-  // Handler for "clearBrowsingData" message.
-  void HandleClearBrowsingData(const base::ListValue* args);
-
-  // Handler for "removeBookmark" message.
-  void HandleRemoveBookmark(const base::ListValue* args);
-
   // Merges duplicate entries from the query results, only retaining the most
   // recent visit to a URL on a particular day. That visit contains the
   // timestamps of the other visits.
   static void MergeDuplicateResults(
-      std::vector<BrowsingHistoryHandler::HistoryEntry>* results);
+      std::vector<HistoryUiService::HistoryEntry>* results);
 
- protected:
   // Callback from the history system when a history query has completed.
   // Exposed for testing.
   void QueryComplete(const base::string16& search_text,
                      const history::QueryOptions& options,
                      history::QueryResults* results);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(BrowsingHistoryHandlerTest,
                            ObservingWebHistoryDeletions);
 
-  // The range for which to return results:
-  // - ALLTIME: allows access to all the results in a paginated way.
-  // - WEEK: the last 7 days.
-  // - MONTH: the last calendar month.
-  enum Range {
-    ALL_TIME = 0,
-    WEEK = 1,
-    MONTH = 2
-  };
-
-  // Core implementation of history querying.
-  void QueryHistory(const base::string16& search_text,
-                    const history::QueryOptions& options);
-
   // Combines the query results from the local history database and the history
-  // server, and sends the combined results to the front end.
-  void ReturnResultsToFrontEnd();
+  // server, and sends the combined results to the HistoryUiServiceHandler.
+  void ReturnResultsToHandler();
 
   // Callback from |web_history_timer_| when a response from web history has
   // not been received in time.
   void WebHistoryTimeout();
 
   // Callback from the WebHistoryService when a query has completed.
   void WebHistoryQueryComplete(const base::string16& search_text,
                                const history::QueryOptions& options,
                                base::TimeTicks start_time,
                                history::WebHistoryService::Request* request,
                                const base::DictionaryValue* results_value);
 
   // Callback telling us whether other forms of browsing history were found
   // on the history server.
   void OtherFormsOfBrowsingHistoryQueryComplete(
       bool found_other_forms_of_browsing_history);
 
   // Callback from the history system when visits were deleted.
   void RemoveComplete();
 
   // Callback from history server when visits were deleted.
   void RemoveWebHistoryComplete(bool success);
 
-  bool ExtractIntegerValueAtIndex(
-      const base::ListValue* value, int index, int* out_int);
-
-  // Sets the query options for a week-wide query, |offset| weeks ago.
-  void SetQueryTimeInWeeks(int offset, history::QueryOptions* options);
-
-  // Sets the query options for a monthly query, |offset| months ago.
-  void SetQueryTimeInMonths(int offset, history::QueryOptions* options);
-
-  // kAcceptLanguages pref value.
-  std::string GetAcceptLanguages() const;
-
   // history::HistoryServiceObserver:
   void OnURLsDeleted(history::HistoryService* history_service,
                      bool all_history,
                      bool expired,
                      const history::URLRows& deleted_rows,
                      const std::set<GURL>& favicon_urls) override;
 
   // history::WebHistoryServiceObserver:
   void OnWebHistoryDeleted() override;
 
   // Tracker for search requests to the history service.
   base::CancelableTaskTracker query_task_tracker_;
 
   // The currently-executing request for synced history results.
   // Deleting the request will cancel it.
   std::unique_ptr<history::WebHistoryService::Request> web_history_request_;
 
   // True if there is a pending delete requests to the history service.
   bool has_pending_delete_request_;
 
   // Tracker for delete requests to the history service.
   base::CancelableTaskTracker delete_task_tracker_;
 
   // The list of URLs that are in the process of being deleted.
   std::set<GURL> urls_to_be_deleted_;
 
-  // The info value that is returned to the front end with the query results.
-  base::DictionaryValue results_info_value_;
+  // The info value that is returned to the handler with the query results.
+  HistoryUiService::QueryResultsInfo query_results_info_;
 
   // The list of query results received from the history service.
   std::vector<HistoryEntry> query_results_;
 
   // The list of query results received from the history server.
   std::vector<HistoryEntry> web_history_query_results_;
 
   // Timer used to implement a timeout on a Web History response.
   base::OneShotTimer web_history_timer_;
 
   // HistoryService (local history) observer.
   ScopedObserver<history::HistoryService, history::HistoryServiceObserver>
       history_service_observer_;
 
   // WebHistoryService (synced history) observer.
   ScopedObserver<history::WebHistoryService, history::WebHistoryServiceObserver>
       web_history_service_observer_;
 
   // ProfileSyncService observer listens to late initialization of history sync.
   ScopedObserver<browser_sync::ProfileSyncService, syncer::SyncServiceObserver>
       sync_service_observer_;
 
   // Whether the last call to Web History returned synced results.
   bool has_synced_results_;
 
   // Whether there are other forms of browsing history on the history server.
   bool has_other_forms_of_browsing_history_;
 
-  base::WeakPtrFactory<BrowsingHistoryHandler> weak_factory_;
+  Profile* profile_;
 
-  DISALLOW_COPY_AND_ASSIGN(BrowsingHistoryHandler);
+  HistoryUiServiceHandler* handler_;
+
+  base::WeakPtrFactory<HistoryUiService> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(HistoryUiService);
 };
 
-#endif  // CHROME_BROWSER_UI_WEBUI_BROWSING_HISTORY_HANDLER_H_
+#endif  // CHROME_BROWSER_UI_HISTORY_UI_SERVICE_H_