History: Add UMA collection for full history sync.

chrome/browser/ui/webui/history_ui.h

 // Copyright (c) 2012 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_HISTORY_UI_H_
 #define CHROME_BROWSER_UI_WEBUI_HISTORY_UI_H_
 
 #include <string>
 
 #include "base/string16.h"
@@ skipping 12 matching lines @@
 class ManagedUserService;
 
 // The handler for Javascript messages related to the "history" view.
 class BrowsingHistoryHandler : public content::WebUIMessageHandler,
                                public content::NotificationObserver {
  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 {
-    HistoryEntry(const GURL& url, const string16& title, base::Time time,
-        const std::set<int64>& timestamps, bool is_search_result,
-        const string16& snippet);
+    // Values indicating whether an entry represents only local visits, only
+    // remote visits, or a mixture of both.
+    enum EntryType {
+      LOCAL_ENTRY,
+      REMOTE_ENTRY,
+      COMBINED_ENTRY
+    };
+
+    HistoryEntry(EntryType type, const GURL& url, const string16& title,
+                 base::Time time, const std::set<int64>& timestamps,
+                 bool is_search_result, const string16& snippet);
     HistoryEntry();
     virtual ~HistoryEntry();
 
     // Formats this entry's URL and title and adds them to |result|.
-    void SetUrlAndTitle(DictionaryValue* result);
+    void SetUrlAndTitle(DictionaryValue* result) const;
 
     // Converts the entry to a DictionaryValue to be owned by the caller.
     scoped_ptr<DictionaryValue> ToValue(
         BookmarkModel* bookmark_model,
-        ManagedUserService* managed_user_service);
+        ManagedUserService* managed_user_service) 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;
     string16 title;  // Title of the entry. May be empty.
 
     // The time of the entry. Usually this will be the time of the most recent
     // visit to |url| on a particular day as defined in the local timezone.
     base::Time time;
 
     // Timestamps of all local or remote visits the same URL on the same day.
     std::set<int64> all_timestamps;
 
@@ skipping 60 matching lines @@
   // - MONTH: the last calendar month.
   enum Range {
     ALL_TIME = 0,
     WEEK = 1,
     MONTH = 2
   };
 
   // Core implementation of history querying.
   void QueryHistory(string16 search_text, const history::QueryOptions& options);
 
-  // Sends the accumulated results of the query to the front end, truncating
-  // the number to |max_count| if necessary. If |max_count| is 0, the results
-  // are not truncated.
-  // If |remove_duplicates| is true, duplicate visits on the same day are
-  // removed.
-  void ReturnResultsToFrontEnd(bool remove_duplicates, int max_count);
+  // Combines the query results from the local history database and the history
+  // server, and sends the combined results to the front end.
+  void ReturnResultsToFrontEnd();
 
   // Callback from |web_history_timer_| when a response from web history has
   // not been received in time.
   void WebHistoryTimeout();
 
   // Callback from the history system when a history query has completed.
   void QueryComplete(const string16& search_text,
                      const history::QueryOptions& options,
                      HistoryService::Handle request_handle,
                      history::QueryResults* results);
 
   // Callback from the WebHistoryService when a query has completed.
   void WebHistoryQueryComplete(const string16& search_text,
                                const history::QueryOptions& options,
+                               base::TimeTicks start_time,
                                history::WebHistoryService::Request* request,
                                const base::DictionaryValue* results_value);
 
   // Callback from the history system when visits were deleted.
   void RemoveComplete();
 
   // Callback from history server when visits were deleted.
   void RemoveWebHistoryComplete(history::WebHistoryService::Request* request,
                                 bool success);
 
@@ skipping 26 matching lines @@
 
   // Tracker for delete requests to the history service.
   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 list of query results that is returned to the front end.
+  // 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<BrowsingHistoryHandler> web_history_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingHistoryHandler);
 };
 
 class HistoryUI : public content::WebUIController {
  public:
   explicit HistoryUI(content::WebUI* web_ui);
 
   // Return the URL for a given search term.
   static const GURL GetHistoryURLWithSearchText(const string16& text);
 
   static base::RefCountedMemory* GetFaviconResourceBytes(
       ui::ScaleFactor scale_factor);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryUI);
 };
 
 #endif  // CHROME_BROWSER_UI_WEBUI_HISTORY_UI_H_