src/chrome/browser/ui/webui/history_ui.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_UI_WEBUI_HISTORY_UI_H_
   6 #define CHROME_BROWSER_UI_WEBUI_HISTORY_UI_H_
   7
   8 #include <string>
   9
  10 #include "base/strings/string16.h"
  11 #include "base/timer/timer.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/common/cancelable_request.h"
  14 #include "chrome/browser/history/history_service.h"
  15 #include "chrome/browser/history/web_history_service.h"
  16 #include "chrome/common/cancelable_task_tracker.h"
  17 #include "content/public/browser/notification_registrar.h"
  18 #include "content/public/browser/web_ui_controller.h"
  19 #include "content/public/browser/web_ui_message_handler.h"
  20
  21 class BookmarkModel;
  22 class ManagedUserService;
  23 class ProfileSyncService;
  24
  25 // The handler for Javascript messages related to the "history" view.
  26 class BrowsingHistoryHandler : public content::WebUIMessageHandler,
  27                                public content::NotificationObserver {
  28  public:
  29   // Represents a history entry to be shown to the user, representing either
  30   // a local or remote visit. A single entry can represent multiple visits,
  31   // since only the most recent visit on a particular day is shown.
  32   struct HistoryEntry {
  33     // Values indicating whether an entry represents only local visits, only
  34     // remote visits, or a mixture of both.
  35     enum EntryType {
  36       EMPTY_ENTRY = 0,
  37       LOCAL_ENTRY,
  38       REMOTE_ENTRY,
  39       COMBINED_ENTRY
  40     };
  41
  42     HistoryEntry(EntryType type, const GURL& url, const string16& title,
  43                  base::Time time, const std::string& client_id,
  44                  bool is_search_result, const string16& snippet,
  45                  bool blocked_visit, const std::string& accept_languages);
  46     HistoryEntry();
  47     virtual ~HistoryEntry();
  48
  49     // Formats this entry's URL and title and adds them to |result|.
  50     void SetUrlAndTitle(DictionaryValue* result) const;
  51
  52     // Converts the entry to a DictionaryValue to be owned by the caller.
  53     scoped_ptr<DictionaryValue> ToValue(
  54         BookmarkModel* bookmark_model,
  55         ManagedUserService* managed_user_service,
  56         const ProfileSyncService* sync_service) const;
  57
  58     // Comparison function for sorting HistoryEntries from newest to oldest.
  59     static bool SortByTimeDescending(
  60         const HistoryEntry& entry1, const HistoryEntry& entry2);
  61
  62     // The type of visits this entry represents: local, remote, or both.
  63     EntryType entry_type;
  64
  65     GURL url;
  66     string16 title;  // Title of the entry. May be empty.
  67
  68     // The time of the entry. Usually this will be the time of the most recent
  69     // visit to |url| on a particular day as defined in the local timezone.
  70     base::Time time;
  71
  72     // The sync ID of the client on which the most recent visit occurred.
  73     std::string client_id;
  74
  75     // Timestamps of all local or remote visits the same URL on the same day.
  76     std::set<int64> all_timestamps;
  77
  78     // If true, this entry is a search result.
  79     bool is_search_result;
  80
  81     // The entry's search snippet, if this entry is a search result.
  82     string16 snippet;
  83
  84     // Whether this entry was blocked when it was attempted.
  85     bool blocked_visit;
  86
  87     // kAcceptLanguages pref value.
  88     std::string accept_languages;
  89   };
  90
  91   BrowsingHistoryHandler();
  92   virtual ~BrowsingHistoryHandler();
  93
  94   // WebUIMessageHandler implementation.
  95   virtual void RegisterMessages() OVERRIDE;
  96
  97   // Handler for the "queryHistory" message.
  98   void HandleQueryHistory(const base::ListValue* args);
  99
 100   // Handler for the "removeVisits" message.
 101   void HandleRemoveVisits(const base::ListValue* args);
 102
 103   // Handler for "clearBrowsingData" message.
 104   void HandleClearBrowsingData(const base::ListValue* args);
 105
 106   // Handler for "removeBookmark" message.
 107   void HandleRemoveBookmark(const base::ListValue* args);
 108
 109   // content::NotificationObserver implementation.
 110   virtual void Observe(int type,
 111                        const content::NotificationSource& source,
 112                        const content::NotificationDetails& details) OVERRIDE;
 113
 114   // Merges duplicate entries from the query results, only retaining the most
 115   // recent visit to a URL on a particular day. That visit contains the
 116   // timestamps of the other visits.
 117   static void MergeDuplicateResults(
 118       std::vector<BrowsingHistoryHandler::HistoryEntry>* results);
 119
 120  private:
 121   // The range for which to return results:
 122   // - ALLTIME: allows access to all the results in a paginated way.
 123   // - WEEK: the last 7 days.
 124   // - MONTH: the last calendar month.
 125   enum Range {
 126     ALL_TIME = 0,
 127     WEEK = 1,
 128     MONTH = 2
 129   };
 130
 131   // Core implementation of history querying.
 132   void QueryHistory(string16 search_text, const history::QueryOptions& options);
 133
 134   // Combines the query results from the local history database and the history
 135   // server, and sends the combined results to the front end.
 136   void ReturnResultsToFrontEnd();
 137
 138   // Callback from |web_history_timer_| when a response from web history has
 139   // not been received in time.
 140   void WebHistoryTimeout();
 141
 142   // Callback from the history system when a history query has completed.
 143   void QueryComplete(const string16& search_text,
 144                      const history::QueryOptions& options,
 145                      HistoryService::Handle request_handle,
 146                      history::QueryResults* results);
 147
 148   // Callback from the WebHistoryService when a query has completed.
 149   void WebHistoryQueryComplete(const string16& search_text,
 150                                const history::QueryOptions& options,
 151                                base::TimeTicks start_time,
 152                                history::WebHistoryService::Request* request,
 153                                const base::DictionaryValue* results_value);
 154
 155   // Callback from the history system when visits were deleted.
 156   void RemoveComplete();
 157
 158   // Callback from history server when visits were deleted.
 159   void RemoveWebHistoryComplete(history::WebHistoryService::Request* request,
 160                                 bool success);
 161
 162   bool ExtractIntegerValueAtIndex(
 163       const base::ListValue* value, int index, int* out_int);
 164
 165   // Sets the query options for a week-wide query, |offset| weeks ago.
 166   void SetQueryTimeInWeeks(int offset, history::QueryOptions* options);
 167
 168   // Sets the query options for a monthly query, |offset| months ago.
 169   void SetQueryTimeInMonths(int offset, history::QueryOptions* options);
 170
 171   // kAcceptLanguages pref value.
 172   std::string GetAcceptLanguages() const;
 173
 174   content::NotificationRegistrar registrar_;
 175
 176   // Consumer for search requests to the history service.
 177   CancelableRequestConsumerT<int, 0> history_request_consumer_;
 178
 179   // The currently-executing request for synced history results.
 180   // Deleting the request will cancel it.
 181   scoped_ptr<history::WebHistoryService::Request> web_history_request_;
 182
 183   // The currently-executing delete request for synced history.
 184   // Deleting the request will cancel it.
 185   scoped_ptr<history::WebHistoryService::Request> web_history_delete_request_;
 186
 187   // Tracker for delete requests to the history service.
 188   CancelableTaskTracker delete_task_tracker_;
 189
 190   // The list of URLs that are in the process of being deleted.
 191   std::set<GURL> urls_to_be_deleted_;
 192
 193   // The info value that is returned to the front end with the query results.
 194   base::DictionaryValue results_info_value_;
 195
 196   // The list of query results received from the history service.
 197   std::vector<HistoryEntry> query_results_;
 198
 199   // The list of query results received from the history server.
 200   std::vector<HistoryEntry> web_history_query_results_;
 201
 202   // Timer used to implement a timeout on a Web History response.
 203   base::OneShotTimer<BrowsingHistoryHandler> web_history_timer_;
 204
 205   DISALLOW_COPY_AND_ASSIGN(BrowsingHistoryHandler);
 206 };
 207
 208 class HistoryUI : public content::WebUIController {
 209  public:
 210   explicit HistoryUI(content::WebUI* web_ui);
 211
 212   // Return the URL for a given search term.
 213   static const GURL GetHistoryURLWithSearchText(const string16& text);
 214
 215   static base::RefCountedMemory* GetFaviconResourceBytes(
 216       ui::ScaleFactor scale_factor);
 217
 218  private:
 219   DISALLOW_COPY_AND_ASSIGN(HistoryUI);
 220 };
 221
 222 #endif  // CHROME_BROWSER_UI_WEBUI_HISTORY_UI_H_