History: Add UMA collection for full history sync.

chrome/browser/ui/webui/history_ui.cc

 // 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.
 
 #include "chrome/browser/ui/webui/history_ui.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "base/string16.h"
 #include "base/string_piece.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
@@ skipping 42 matching lines @@
 using content::WebContents;
 
 static const char kStringsJsFile[] = "strings.js";
 static const char kHistoryJsFile[] = "history.js";
 
 // The amount of time to wait for a response from the WebHistoryService.
 static const int kWebHistoryTimeoutSeconds = 3;
 
 namespace {
 
+// Buckets for UMA histograms.
+enum WebHistoryQueryBuckets {
+  WEB_HISTORY_QUERY_FAILED = 0,
+  WEB_HISTORY_QUERY_SUCCEEDED,
+  WEB_HISTORY_QUERY_TIMED_OUT,
+  NUM_WEB_HISTORY_QUERY_BUCKETS
+};
+
 #if defined(OS_MACOSX)
 const char kIncognitoModeShortcut[] = "("
     "\xE2\x87\xA7"  // Shift symbol (U+21E7 'UPWARDS WHITE ARROW').
     "\xE2\x8C\x98"  // Command symbol (U+2318 'PLACE OF INTEREST SIGN').
     "N)";
 #elif defined(OS_WIN)
 const char kIncognitoModeShortcut[] = "(Ctrl+Shift+N)";
 #else
 const char kIncognitoModeShortcut[] = "(Shift+Ctrl+N)";
 #endif
@@ skipping 94 matching lines @@
 
   if (result->GetAsDictionary(&result_dict) &&
       result_dict->GetDouble("time", &timestamp) &&
       result_dict->GetString("url", url)) {
     *time = base::Time::FromJsTime(timestamp);
     return true;
   }
   return false;
 }
 
+// Removes all entries in |entry_list| that are older than the |cutoff|.
+// |entry_list| must already be sorted in reverse chronological order.
+void RemoveOlderEntries(
+    std::vector<BrowsingHistoryHandler::HistoryEntry>* entry_list,
+    base::Time cutoff) {
+  for (std::vector<BrowsingHistoryHandler::HistoryEntry>::iterator it =
+      entry_list->begin(); it != entry_list->end(); ++it) {
+    if (it->time < cutoff) {
+      entry_list->erase(it, entry_list->end());
+      break;
+    }
+  }
+}
+
+// Returns true if |entry| represents a local visit that had no corresponding
+// visit on the server.
+bool IsLocalOnlyResult(const BrowsingHistoryHandler::HistoryEntry& entry) {
+  return entry.entry_type == BrowsingHistoryHandler::HistoryEntry::LOCAL_ENTRY;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // BrowsingHistoryHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 BrowsingHistoryHandler::HistoryEntry::HistoryEntry(
+    BrowsingHistoryHandler::HistoryEntry::EntryType entry_type,
     const GURL& url, const string16& title, base::Time time,
-    const std::set<int64>& timestamps, bool is_search_result,
-    const string16& snippet) : all_timestamps(timestamps) {
+    const std::set<int64>& timestamps,
+    bool is_search_result, const string16& snippet)
+      : all_timestamps(timestamps) {
+  this->entry_type = entry_type;
   this->url = url;
   this->title = title;
   this->time = time;
   this->is_search_result = is_search_result;
   this->snippet = snippet;
 }
 
 BrowsingHistoryHandler::HistoryEntry::HistoryEntry()
     : is_search_result(false) {
 }
 
 BrowsingHistoryHandler::HistoryEntry::~HistoryEntry() {
 }
 
 void BrowsingHistoryHandler::HistoryEntry::SetUrlAndTitle(
-    DictionaryValue* result) {
+    DictionaryValue* result) const {
   result->SetString("url", url.spec());
 
   bool using_url_as_the_title = false;
   string16 title_to_set(title);
   if (title.empty()) {
     using_url_as_the_title = true;
     title_to_set = UTF8ToUTF16(url.spec());
   }
 
   // Since the title can contain BiDi text, we need to mark the text as either
   // RTL or LTR, depending on the characters in the string. If we use the URL
   // as the title, we mark the title as LTR since URLs are always treated as
   // left to right strings.
   if (base::i18n::IsRTL()) {
     if (using_url_as_the_title)
       base::i18n::WrapStringWithLTRFormatting(&title_to_set);
     else
       base::i18n::AdjustStringForLocaleDirection(&title_to_set);
   }
   result->SetString("title", title_to_set);
 }
 
 scoped_ptr<DictionaryValue> BrowsingHistoryHandler::HistoryEntry::ToValue(
-    BookmarkModel* bookmark_model, ManagedUserService* managed_user_service) {
+    BookmarkModel* bookmark_model,
+    ManagedUserService* managed_user_service) const {
   scoped_ptr<DictionaryValue> result(new DictionaryValue());
   SetUrlAndTitle(result.get());
   result->SetDouble("time", time.ToJsTime());
 
   // Pass the timestamps in a list.
   scoped_ptr<ListValue> timestamps(new ListValue);
   for (std::set<int64>::const_iterator it = all_timestamps.begin();
        it != all_timestamps.end(); ++it) {
     timestamps->AppendDouble(base::Time::FromInternalValue(*it).ToJsTime());
   }
@@ skipping 106 matching lines @@
     *out_int = static_cast<int>(double_value);
     return true;
   }
   NOTREACHED();
   return false;
 }
 
 void BrowsingHistoryHandler::WebHistoryTimeout() {
   // TODO(dubroy): Communicate the failure to the front end.
   if (!results_info_value_.empty())
-    ReturnResultsToFrontEnd(false, 0);
+    ReturnResultsToFrontEnd();
+
+  UMA_HISTOGRAM_ENUMERATION(
+      "WebHistory.QueryCompletion",
+      WEB_HISTORY_QUERY_TIMED_OUT, NUM_WEB_HISTORY_QUERY_BUCKETS);
 }
 
 void BrowsingHistoryHandler::QueryHistory(
     string16 search_text, const history::QueryOptions& options) {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   // Anything in-flight is invalid.
   history_request_consumer_.CancelAllRequests();
   web_history_request_.reset();
 
   query_results_.clear();
   results_info_value_.Clear();
 
   HistoryService* hs = HistoryServiceFactory::GetForProfile(
       profile, Profile::EXPLICIT_ACCESS);
   hs->QueryHistory(search_text,
       options,
       &history_request_consumer_,
       base::Bind(&BrowsingHistoryHandler::QueryComplete,
                  base::Unretained(this), search_text, options));
 
   history::WebHistoryService* web_history =
       WebHistoryServiceFactory::GetForProfile(profile);
   if (web_history) {
+    web_history_query_results_.clear();
     web_history_request_ = web_history->QueryHistory(
         search_text,
         options,
         base::Bind(&BrowsingHistoryHandler::WebHistoryQueryComplete,
-                   base::Unretained(this), search_text, options));
+                   base::Unretained(this),
+                   search_text, options,
+                   base::TimeTicks::Now()));
     // Start a timer so we know when to give up.
     web_history_timer_.Start(
         FROM_HERE, base::TimeDelta::FromSeconds(kWebHistoryTimeoutSeconds),
         this, &BrowsingHistoryHandler::WebHistoryTimeout);
   }
 }
 
 void BrowsingHistoryHandler::HandleQueryHistory(const ListValue* args) {
   history::QueryOptions options;
 
@@ skipping 330 matching lines @@
       current_day_midnight = it->time.LocalMidnight();
     }
 
     // Keep this visit if it's the first visit to this URL on the current day.
     if (current_day_entries.count(it->url) == 0) {
       current_day_entries.insert(
           std::pair<GURL,BrowsingHistoryHandler::HistoryEntry>(it->url, *it));
       new_results.push_back(*it);
     } else {
       // Keep track of the timestamps of all visits to the URL on the same day.
-      current_day_entries[it->url].all_timestamps.insert(
+      BrowsingHistoryHandler::HistoryEntry* entry =
+          &current_day_entries[it->url];
+      entry->all_timestamps.insert(
           it->all_timestamps.begin(), it->all_timestamps.end());
+
+      if (entry->entry_type != it->entry_type) {
+        entry->entry_type =
+            BrowsingHistoryHandler::HistoryEntry::COMBINED_ENTRY;
+      }
     }
   }
   results->swap(new_results);
 }
 
-void BrowsingHistoryHandler::ReturnResultsToFrontEnd(
-    bool results_need_merge, int max_count) {
+void BrowsingHistoryHandler::ReturnResultsToFrontEnd() {
   Profile* profile = Profile::FromWebUI(web_ui());
   BookmarkModel* bookmark_model = BookmarkModelFactory::GetForProfile(profile);
   ManagedUserService* managed_user_service = NULL;
 #if defined(ENABLE_MANAGED_USERS)
   managed_user_service = ManagedUserServiceFactory::GetForProfile(profile);
 #endif
 
-  if (results_need_merge)
+  // Combine the local and remote results into |query_results_|, and remove
+  // any duplicates.
+  if (query_results_.size() && web_history_query_results_.size()) {
+    // Each result set covers a particular time range. Determine the
+    // intersection of the two time ranges, discard any entries from either
+    // set the are older than that, and then combine the results.
+    base::Time cutoff_time = std::max(query_results_.back().time,
+                                      web_history_query_results_.back().time);
+    RemoveOlderEntries(&query_results_, cutoff_time);
+    RemoveOlderEntries(&web_history_query_results_, cutoff_time);
+
+    int local_result_count = query_results_.size();
+    query_results_.insert(query_results_.end(),
+                          web_history_query_results_.begin(),
+                          web_history_query_results_.end());
     RemoveDuplicateResults(&query_results_);
 
-  // Convert the result vector into a ListValue with at most |max_count|
-  // elements.
+    // In the best case, we expect that all local results are duplicated on the
+    // server. Keep track of how many are missing.
+    if (local_result_count) {
+      int missing_count = std::count_if(
+          query_results_.begin(), query_results_.end(), IsLocalOnlyResult);
+      UMA_HISTOGRAM_PERCENTAGE("WebHistory.LocalResultMissingOnServer",
+                               missing_count * 100.0 / local_result_count);
+    }
+  }
+
+  // Convert the result vector into a ListValue.
   ListValue results_value;
-  int query_results_size = static_cast<int>(query_results_.size());
-  for (int i = 0; i < query_results_size && i < max_count; ++i) {
+  for (std::vector<BrowsingHistoryHandler::HistoryEntry>::iterator it =
+           query_results_.begin(); it != query_results_.end(); ++it) {
     scoped_ptr<base::Value> value(
-        query_results_[i].ToValue(bookmark_model, managed_user_service));
+        it->ToValue(bookmark_model, managed_user_service));
     results_value.Append(value.release());
   }
 
   web_ui()->CallJavascriptFunction(
       "historyResult", results_info_value_, results_value);
   results_info_value_.Clear();
   query_results_.clear();
+  web_history_query_results_.clear();
 }
 
 void BrowsingHistoryHandler::QueryComplete(
     const string16& search_text,
     const history::QueryOptions& options,
     HistoryService::Handle request_handle,
     history::QueryResults* results) {
-  // If we're appending to existing results, they will need merging.
-  bool needs_merge = query_results_.size() >  0;
+  DCHECK_EQ(0U, query_results_.size());
+  query_results_.reserve(results->size());
 
   for (size_t i = 0; i < results->size(); ++i) {
     history::URLResult const &page = (*results)[i];
 
     std::set<int64> timestamps;
     timestamps.insert(page.visit_time().ToInternalValue());
 
     query_results_.push_back(
-        HistoryEntry(page.url(),
-                     page.title(),
-                     page.visit_time(),
-                     timestamps,
-                     !search_text.empty(),
-                     page.snippet().text()));
+        HistoryEntry(
+            HistoryEntry::LOCAL_ENTRY,
+            page.url(),
+            page.title(),
+            page.visit_time(),
+            timestamps,
+            !search_text.empty(),
+            page.snippet().text()));
   }
 
   results_info_value_.SetString("term", search_text);
   results_info_value_.SetBoolean("finished", results->reached_beginning());
 
   // Add the specific dates that were searched to display them.
   // TODO(sergiu): Put today if the start is in the future.
   results_info_value_.SetString("queryStartTime",
                                 getRelativeDateLocalized(options.begin_time));
   if (!options.end_time.is_null()) {
     results_info_value_.SetString("queryEndTime",
         getRelativeDateLocalized(options.end_time -
                                  base::TimeDelta::FromDays(1)));
   } else {
     results_info_value_.SetString("queryEndTime",
         getRelativeDateLocalized(base::Time::Now()));
   }
   if (!web_history_timer_.IsRunning())
-    ReturnResultsToFrontEnd(needs_merge, options.max_count);
+    ReturnResultsToFrontEnd();
 }
 
 void BrowsingHistoryHandler::WebHistoryQueryComplete(
     const string16& search_text,
     const history::QueryOptions& options,
+    base::TimeTicks start_time,
     history::WebHistoryService::Request* request,
     const DictionaryValue* results_value) {
+  base::TimeDelta delta = base::TimeTicks::Now() - start_time;
+  UMA_HISTOGRAM_TIMES("WebHistory.ResponseTime", delta);
+
+  // If the response came in too late, do nothing.
+  // TODO(dubroy): Maybe show a banner, and prompt the user to reload?
+  if (!web_history_timer_.IsRunning())
+    return;
   web_history_timer_.Stop();
 
+  UMA_HISTOGRAM_ENUMERATION(
+      "WebHistory.QueryCompletion",
+      results_value ? WEB_HISTORY_QUERY_SUCCEEDED : WEB_HISTORY_QUERY_FAILED,
+      NUM_WEB_HISTORY_QUERY_BUCKETS);
+
+  DCHECK_EQ(0U, web_history_query_results_.size());
   const ListValue* events = NULL;
   if (results_value && results_value->GetList("event", &events)) {
+    web_history_query_results_.reserve(events->GetSize());
     for (unsigned int i = 0; i < events->GetSize(); ++i) {
       const DictionaryValue* event = NULL;
       const DictionaryValue* result = NULL;
       const ListValue* results = NULL;
       const ListValue* ids = NULL;
       string16 url;
       string16 title;
       base::Time visit_time;
 
       if (!(events->GetDictionary(i, &event) &&
@@ skipping 27 matching lines @@
         base::Time time = base::Time::UnixEpoch() +
                           base::TimeDelta::FromMicroseconds(timestamp_usec);
         timestamps.insert(time.ToInternalValue());
 
         // Use the first timestamp as the visit time for this result.
         // TODO(dubroy): Use the sane time instead once it is available.
         if (visit_time.is_null())
           visit_time = time;
       }
       GURL gurl(url);
-      query_results_.push_back(
+      web_history_query_results_.push_back(
           HistoryEntry(
+              HistoryEntry::REMOTE_ENTRY,
               gurl,
               title,
               visit_time,
               timestamps,
               !search_text.empty(),
               string16()));
     }
   } else if (results_value) {
     NOTREACHED() << "Failed to parse JSON response.";
   }
   if (!results_info_value_.empty())
-    ReturnResultsToFrontEnd(true, options.max_count);
+    ReturnResultsToFrontEnd();
 }
 
 void BrowsingHistoryHandler::RemoveComplete() {
   urls_to_be_deleted_.clear();
 
   // Notify the page that the deletion request succeeded.
   web_ui()->CallJavascriptFunction("deleteComplete");
 }
 
 void BrowsingHistoryHandler::RemoveWebHistoryComplete(
@@ skipping 96 matching lines @@
   return GURL(std::string(chrome::kChromeUIHistoryURL) + "#q=" +
               net::EscapeQueryParamValue(UTF16ToUTF8(text), true));
 }
 
 // static
 base::RefCountedMemory* HistoryUI::GetFaviconResourceBytes(
       ui::ScaleFactor scale_factor) {
   return ResourceBundle::GetSharedInstance().
       LoadDataResourceBytesForScale(IDR_HISTORY_FAVICON, scale_factor);
 }