MD History: truncate title to 300 chars in C++ instead of JS

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
+#include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/favicon/fallback_icon_service_factory.h"
@@ skipping 42 matching lines @@
 #include "chrome/browser/supervised_user/supervised_user_navigation_observer.h"
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #endif
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 #include "chrome/browser/android/chrome_application.h"
 #endif
 
+#if !defined(OS_ANDROID)
+#include "chrome/browser/ui/webui/md_history_ui.h"
+#endif
+
 // The amount of time to wait for a response from the WebHistoryService.
 static const int kWebHistoryTimeoutSeconds = 3;
 
+// Number of chars to truncate titles when making them "short".
+static const size_t kShortTitleLength = 300;
+
 using bookmarks::BookmarkModel;
 
 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
@@ skipping 96 matching lines @@
     : entry_type(EMPTY_ENTRY), is_search_result(false), blocked_visit(false) {
 }
 
 BrowsingHistoryHandler::HistoryEntry::HistoryEntry(const HistoryEntry& other) =
     default;
 
 BrowsingHistoryHandler::HistoryEntry::~HistoryEntry() {
 }
 
 void BrowsingHistoryHandler::HistoryEntry::SetUrlAndTitle(
-    base::DictionaryValue* result) const {
+    base::DictionaryValue* result,
+    bool limit_title_length) const {
   result->SetString("url", url.spec());
 
   bool using_url_as_the_title = false;
   base::string16 title_to_set(title);
   if (title.empty()) {
     using_url_as_the_title = true;
     title_to_set = base::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);
+
+  result->SetString("title",
+      limit_title_length ? title_to_set.substr(0, kShortTitleLength)
+                         : title_to_set);
 }
 
 std::unique_ptr<base::DictionaryValue>
 BrowsingHistoryHandler::HistoryEntry::ToValue(
     BookmarkModel* bookmark_model,
     SupervisedUserService* supervised_user_service,
-    const ProfileSyncService* sync_service) const {
+    const ProfileSyncService* sync_service,
+    bool limit_title_length) const {
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
-  SetUrlAndTitle(result.get());
+  SetUrlAndTitle(result.get(), limit_title_length);
 
   base::string16 domain = url_formatter::IDNToUnicode(url.host());
   // When the domain is empty, use the scheme instead. This allows for a
   // sensible treatment of e.g. file: URLs when group by domain is on.
   if (domain.empty())
     domain = base::UTF8ToUTF16(url.scheme() + ":");
 
   // The items which are to be written into result are also described in
   // chrome/browser/resources/history/history.js in @typedef for
   // HistoryEntry. Please update it whenever you add or remove
@@ skipping 454 matching lines @@
 
       if (entry->entry_type != it->entry_type) {
         entry->entry_type =
             BrowsingHistoryHandler::HistoryEntry::COMBINED_ENTRY;
       }
     }
   }
   results->swap(new_results);
 }
 
+void BrowsingHistoryHandler::QueryComplete(
+    const base::string16& search_text,
+    const history::QueryOptions& options,
+    history::QueryResults* results) {
+  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];
+    // TODO(dubroy): Use sane time (crbug.com/146090) here when it's ready.
+    query_results_.push_back(
+        HistoryEntry(
+            HistoryEntry::LOCAL_ENTRY,
+            page.url(),
+            page.title(),
+            page.visit_time(),
+            std::string(),
+            !search_text.empty(),
+            page.snippet().text(),
+            page.blocked_visit()));
+  }
+
+  // The items which are to be written into results_info_value_ are also
+  // described in chrome/browser/resources/history/history.js in @typedef for
+  // HistoryQuery. Please update it whenever you add or remove any keys in
+  // results_info_value_.
+  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();
+}
+
 void BrowsingHistoryHandler::ReturnResultsToFrontEnd() {
   Profile* profile = Profile::FromWebUI(web_ui());
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForBrowserContext(profile);
   SupervisedUserService* supervised_user_service = NULL;
 #if defined(ENABLE_SUPERVISED_USERS)
   if (profile->IsSupervised())
     supervised_user_service =
         SupervisedUserServiceFactory::GetForProfile(profile);
 #endif
@@ skipping 12 matching lines @@
     if (local_result_count) {
       // In the best case, we expect that all local results are duplicated on
       // the server. Keep track of how many are missing.
       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);
     }
   }
 
+  bool is_md = false;
+#if !defined(OS_ANDROID)
+  is_md = MdHistoryUI::IsEnabled(profile);
+#endif
+
   // Convert the result vector into a ListValue.
   base::ListValue results_value;
   for (std::vector<BrowsingHistoryHandler::HistoryEntry>::iterator it =
            query_results_.begin(); it != query_results_.end(); ++it) {
-    std::unique_ptr<base::Value> value(
-        it->ToValue(bookmark_model, supervised_user_service, sync_service));
+    std::unique_ptr<base::Value> value(it->ToValue(
+        bookmark_model, supervised_user_service, sync_service, is_md));
     results_value.Append(std::move(value));
   }
 
   web_ui()->CallJavascriptFunctionUnsafe("historyResult", results_info_value_,
                                          results_value);
   web_ui()->CallJavascriptFunctionUnsafe(
       "showNotification", base::FundamentalValue(has_synced_results_),
       base::FundamentalValue(has_other_forms_of_browsing_history_));
   results_info_value_.Clear();
   query_results_.clear();
   web_history_query_results_.clear();
 }
 
-void BrowsingHistoryHandler::QueryComplete(
-    const base::string16& search_text,
-    const history::QueryOptions& options,
-    history::QueryResults* results) {
-  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];
-    // TODO(dubroy): Use sane time (crbug.com/146090) here when it's ready.
-    query_results_.push_back(
-        HistoryEntry(
-            HistoryEntry::LOCAL_ENTRY,
-            page.url(),
-            page.title(),
-            page.visit_time(),
-            std::string(),
-            !search_text.empty(),
-            page.snippet().text(),
-            page.blocked_visit()));
-  }
-
-  // The items which are to be written into results_info_value_ are also
-  // described in chrome/browser/resources/history/history.js in @typedef for
-  // HistoryQuery. Please update it whenever you add or remove any keys in
-  // results_info_value_.
-  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();
-}
-
 void BrowsingHistoryHandler::WebHistoryQueryComplete(
     const base::string16& search_text,
     const history::QueryOptions& options,
     base::TimeTicks start_time,
     history::WebHistoryService::Request* request,
     const base::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.
@@ skipping 179 matching lines @@
     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");
 }