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#include "chrome/browser/ui/webui/history_ui.h"
6
7#include <set>
8
9#include "base/bind.h"
10#include "base/bind_helpers.h"
11#include "base/command_line.h"
12#include "base/i18n/rtl.h"
13#include "base/i18n/time_formatting.h"
14#include "base/memory/singleton.h"
15#include "base/message_loop/message_loop.h"
16#include "base/metrics/histogram.h"
17#include "base/prefs/pref_service.h"
18#include "base/strings/string16.h"
19#include "base/strings/string_number_conversions.h"
20#include "base/strings/utf_string_conversions.h"
21#include "base/time/time.h"
22#include "base/values.h"
23#include "chrome/browser/bookmarks/bookmark_model_factory.h"
24#include "chrome/browser/chrome_notification_types.h"
25#include "chrome/browser/history/history_notifications.h"
26#include "chrome/browser/history/history_service_factory.h"
27#include "chrome/browser/history/web_history_service.h"
28#include "chrome/browser/history/web_history_service_factory.h"
29#include "chrome/browser/profiles/profile.h"
30#include "chrome/browser/sync/profile_sync_service.h"
31#include "chrome/browser/sync/profile_sync_service_factory.h"
32#include "chrome/browser/ui/browser_finder.h"
33#include "chrome/browser/ui/chrome_pages.h"
34#include "chrome/browser/ui/webui/favicon_source.h"
35#include "chrome/browser/ui/webui/metrics_handler.h"
36#include "chrome/common/chrome_switches.h"
37#include "chrome/common/pref_names.h"
38#include "chrome/common/url_constants.h"
39#include "chrome/grit/generated_resources.h"
40#include "components/bookmarks/browser/bookmark_model.h"
41#include "components/bookmarks/browser/bookmark_utils.h"
42#include "components/history/core/browser/history_types.h"
43#include "components/search/search.h"
44#include "components/sync_driver/device_info.h"
45#include "content/public/browser/notification_details.h"
46#include "content/public/browser/notification_source.h"
47#include "content/public/browser/url_data_source.h"
48#include "content/public/browser/web_ui.h"
49#include "content/public/browser/web_ui_data_source.h"
50#include "grit/browser_resources.h"
51#include "grit/theme_resources.h"
52#include "net/base/escape.h"
53#include "net/base/net_util.h"
54#include "sync/protocol/history_delete_directive_specifics.pb.h"
55#include "ui/base/l10n/l10n_util.h"
56#include "ui/base/l10n/time_format.h"
57#include "ui/base/resource/resource_bundle.h"
58#include "ui/base/webui/web_ui_util.h"
59
60#if defined(ENABLE_EXTENSIONS)
61#include "chrome/browser/extensions/activity_log/activity_log.h"
62#endif
63
64#if defined(ENABLE_MANAGED_USERS)
65#include "chrome/browser/supervised_user/supervised_user_navigation_observer.h"
66#include "chrome/browser/supervised_user/supervised_user_service.h"
67#include "chrome/browser/supervised_user/supervised_user_service_factory.h"
68#include "chrome/browser/supervised_user/supervised_user_url_filter.h"
69#endif
70
71#if defined(OS_ANDROID)
72#include "chrome/browser/android/chromium_application.h"
73#endif
74
75#if !defined(OS_ANDROID) && !defined(OS_IOS)
76#include "chrome/browser/ui/webui/ntp/foreign_session_handler.h"
77#include "chrome/browser/ui/webui/ntp/ntp_login_handler.h"
78#endif
79
80static const char kStringsJsFile[] = "strings.js";
81static const char kHistoryJsFile[] = "history.js";
82static const char kOtherDevicesJsFile[] = "other_devices.js";
83
84// The amount of time to wait for a response from the WebHistoryService.
85static const int kWebHistoryTimeoutSeconds = 3;
86
87namespace {
88
89// Buckets for UMA histograms.
90enum WebHistoryQueryBuckets {
91  WEB_HISTORY_QUERY_FAILED = 0,
92  WEB_HISTORY_QUERY_SUCCEEDED,
93  WEB_HISTORY_QUERY_TIMED_OUT,
94  NUM_WEB_HISTORY_QUERY_BUCKETS
95};
96
97#if defined(OS_MACOSX)
98const char kIncognitoModeShortcut[] = "("
99    "\xE2\x87\xA7"  // Shift symbol (U+21E7 'UPWARDS WHITE ARROW').
100    "\xE2\x8C\x98"  // Command symbol (U+2318 'PLACE OF INTEREST SIGN').
101    "N)";
102#elif defined(OS_WIN)
103const char kIncognitoModeShortcut[] = "(Ctrl+Shift+N)";
104#else
105const char kIncognitoModeShortcut[] = "(Shift+Ctrl+N)";
106#endif
107
108// Identifiers for the type of device from which a history entry originated.
109static const char kDeviceTypeLaptop[] = "laptop";
110static const char kDeviceTypePhone[] = "phone";
111static const char kDeviceTypeTablet[] = "tablet";
112
113content::WebUIDataSource* CreateHistoryUIHTMLSource(Profile* profile) {
114  PrefService* prefs = profile->GetPrefs();
115
116  content::WebUIDataSource* source =
117      content::WebUIDataSource::Create(chrome::kChromeUIHistoryFrameHost);
118  source->AddBoolean("isUserSignedIn",
119      !prefs->GetString(prefs::kGoogleServicesUsername).empty());
120  source->AddLocalizedString("collapseSessionMenuItemText",
121      IDS_NEW_TAB_OTHER_SESSIONS_COLLAPSE_SESSION);
122  source->AddLocalizedString("expandSessionMenuItemText",
123      IDS_NEW_TAB_OTHER_SESSIONS_EXPAND_SESSION);
124  source->AddLocalizedString("restoreSessionMenuItemText",
125      IDS_NEW_TAB_OTHER_SESSIONS_OPEN_ALL);
126  source->AddLocalizedString("xMore", IDS_OTHER_DEVICES_X_MORE);
127  source->AddLocalizedString("loading", IDS_HISTORY_LOADING);
128  source->AddLocalizedString("title", IDS_HISTORY_TITLE);
129  source->AddLocalizedString("newest", IDS_HISTORY_NEWEST);
130  source->AddLocalizedString("newer", IDS_HISTORY_NEWER);
131  source->AddLocalizedString("older", IDS_HISTORY_OLDER);
132  source->AddLocalizedString("searchResultsFor", IDS_HISTORY_SEARCHRESULTSFOR);
133  source->AddLocalizedString("history", IDS_HISTORY_BROWSERESULTS);
134  source->AddLocalizedString("cont", IDS_HISTORY_CONTINUED);
135  source->AddLocalizedString("searchButton", IDS_HISTORY_SEARCH_BUTTON);
136  source->AddLocalizedString("noSearchResults", IDS_HISTORY_NO_SEARCH_RESULTS);
137  source->AddLocalizedString("noResults", IDS_HISTORY_NO_RESULTS);
138  source->AddLocalizedString("historyInterval", IDS_HISTORY_INTERVAL);
139  source->AddLocalizedString("removeSelected",
140                             IDS_HISTORY_REMOVE_SELECTED_ITEMS);
141  source->AddLocalizedString("clearAllHistory",
142                             IDS_HISTORY_OPEN_CLEAR_BROWSING_DATA_DIALOG);
143  source->AddString(
144      "deleteWarning",
145      l10n_util::GetStringFUTF16(IDS_HISTORY_DELETE_PRIOR_VISITS_WARNING,
146                                 base::UTF8ToUTF16(kIncognitoModeShortcut)));
147  source->AddLocalizedString("removeBookmark", IDS_HISTORY_REMOVE_BOOKMARK);
148  source->AddLocalizedString("actionMenuDescription",
149                             IDS_HISTORY_ACTION_MENU_DESCRIPTION);
150  source->AddLocalizedString("removeFromHistory", IDS_HISTORY_REMOVE_PAGE);
151  source->AddLocalizedString("moreFromSite", IDS_HISTORY_MORE_FROM_SITE);
152  source->AddLocalizedString("groupByDomainLabel", IDS_GROUP_BY_DOMAIN_LABEL);
153  source->AddLocalizedString("rangeLabel", IDS_HISTORY_RANGE_LABEL);
154  source->AddLocalizedString("rangeAllTime", IDS_HISTORY_RANGE_ALL_TIME);
155  source->AddLocalizedString("rangeWeek", IDS_HISTORY_RANGE_WEEK);
156  source->AddLocalizedString("rangeMonth", IDS_HISTORY_RANGE_MONTH);
157  source->AddLocalizedString("rangeToday", IDS_HISTORY_RANGE_TODAY);
158  source->AddLocalizedString("rangeNext", IDS_HISTORY_RANGE_NEXT);
159  source->AddLocalizedString("rangePrevious", IDS_HISTORY_RANGE_PREVIOUS);
160  source->AddLocalizedString("numberVisits", IDS_HISTORY_NUMBER_VISITS);
161  source->AddLocalizedString("filterAllowed", IDS_HISTORY_FILTER_ALLOWED);
162  source->AddLocalizedString("filterBlocked", IDS_HISTORY_FILTER_BLOCKED);
163  source->AddLocalizedString("inContentPack", IDS_HISTORY_IN_CONTENT_PACK);
164  source->AddLocalizedString("allowItems", IDS_HISTORY_FILTER_ALLOW_ITEMS);
165  source->AddLocalizedString("blockItems", IDS_HISTORY_FILTER_BLOCK_ITEMS);
166  source->AddLocalizedString("lockButton", IDS_HISTORY_LOCK_BUTTON);
167  source->AddLocalizedString("blockedVisitText",
168                             IDS_HISTORY_BLOCKED_VISIT_TEXT);
169  source->AddLocalizedString("unlockButton", IDS_HISTORY_UNLOCK_BUTTON);
170  source->AddLocalizedString("hasSyncedResults",
171                             IDS_HISTORY_HAS_SYNCED_RESULTS);
172  source->AddLocalizedString("noSyncedResults", IDS_HISTORY_NO_SYNCED_RESULTS);
173  source->AddLocalizedString("cancel", IDS_CANCEL);
174  source->AddLocalizedString("deleteConfirm",
175                             IDS_HISTORY_DELETE_PRIOR_VISITS_CONFIRM_BUTTON);
176  source->AddBoolean("isFullHistorySyncEnabled",
177                     WebHistoryServiceFactory::GetForProfile(profile) != NULL);
178  source->AddBoolean("groupByDomain",
179      CommandLine::ForCurrentProcess()->HasSwitch(
180          switches::kHistoryEnableGroupByDomain));
181  source->AddBoolean("allowDeletingHistory",
182                     prefs->GetBoolean(prefs::kAllowDeletingBrowserHistory));
183  source->AddBoolean("isInstantExtendedApiEnabled",
184                     chrome::IsInstantExtendedAPIEnabled());
185
186  source->SetJsonPath(kStringsJsFile);
187  source->AddResourcePath(kHistoryJsFile, IDR_HISTORY_JS);
188  source->AddResourcePath(kOtherDevicesJsFile, IDR_OTHER_DEVICES_JS);
189  source->SetDefaultResource(IDR_HISTORY_HTML);
190  source->SetUseJsonJSFormatV2();
191  source->DisableDenyXFrameOptions();
192  source->AddBoolean("isSupervisedProfile", profile->IsSupervised());
193  source->AddBoolean("showDeleteVisitUI", !profile->IsSupervised());
194
195  return source;
196}
197
198// Returns a localized version of |visit_time| including a relative
199// indicator (e.g. today, yesterday).
200base::string16 getRelativeDateLocalized(const base::Time& visit_time) {
201  base::Time midnight = base::Time::Now().LocalMidnight();
202  base::string16 date_str = ui::TimeFormat::RelativeDate(visit_time, &midnight);
203  if (date_str.empty()) {
204    date_str = base::TimeFormatFriendlyDate(visit_time);
205  } else {
206    date_str = l10n_util::GetStringFUTF16(
207        IDS_HISTORY_DATE_WITH_RELATIVE_TIME,
208        date_str,
209        base::TimeFormatFriendlyDate(visit_time));
210  }
211  return date_str;
212}
213
214
215// Sets the correct year when substracting months from a date.
216void normalizeMonths(base::Time::Exploded* exploded) {
217  // Decrease a year at a time until we have a proper date.
218  while (exploded->month < 1) {
219    exploded->month += 12;
220    exploded->year--;
221  }
222}
223
224// Returns true if |entry| represents a local visit that had no corresponding
225// visit on the server.
226bool IsLocalOnlyResult(const BrowsingHistoryHandler::HistoryEntry& entry) {
227  return entry.entry_type == BrowsingHistoryHandler::HistoryEntry::LOCAL_ENTRY;
228}
229
230// Gets the name and type of a device for the given sync client ID.
231// |name| and |type| are out parameters.
232void GetDeviceNameAndType(const ProfileSyncService* sync_service,
233                          const std::string& client_id,
234                          std::string* name,
235                          std::string* type) {
236  // DeviceInfoTracker becomes available when Sync backend gets initialed.
237  // It must exist in order for remote history entries to be available.
238  if (sync_service && sync_service->GetDeviceInfoTracker()) {
239    scoped_ptr<sync_driver::DeviceInfo> device_info =
240        sync_service->GetDeviceInfoTracker()->GetDeviceInfo(client_id);
241    if (device_info.get()) {
242      *name = device_info->client_name();
243      switch (device_info->device_type()) {
244        case sync_pb::SyncEnums::TYPE_PHONE:
245          *type = kDeviceTypePhone;
246          break;
247        case sync_pb::SyncEnums::TYPE_TABLET:
248          *type = kDeviceTypeTablet;
249          break;
250        default:
251          *type = kDeviceTypeLaptop;
252      }
253      return;
254    }
255  } else {
256    NOTREACHED() << "Got a remote history entry but no DeviceInfoTracker.";
257  }
258  *name = l10n_util::GetStringUTF8(IDS_HISTORY_UNKNOWN_DEVICE);
259  *type = kDeviceTypeLaptop;
260}
261
262}  // namespace
263
264////////////////////////////////////////////////////////////////////////////////
265//
266// BrowsingHistoryHandler
267//
268////////////////////////////////////////////////////////////////////////////////
269
270BrowsingHistoryHandler::HistoryEntry::HistoryEntry(
271    BrowsingHistoryHandler::HistoryEntry::EntryType entry_type,
272    const GURL& url, const base::string16& title, base::Time time,
273    const std::string& client_id, bool is_search_result,
274    const base::string16& snippet, bool blocked_visit,
275    const std::string& accept_languages) {
276  this->entry_type = entry_type;
277  this->url = url;
278  this->title = title;
279  this->time = time;
280  this->client_id = client_id;
281  all_timestamps.insert(time.ToInternalValue());
282  this->is_search_result = is_search_result;
283  this->snippet = snippet;
284  this->blocked_visit = blocked_visit;
285  this->accept_languages = accept_languages;
286}
287
288BrowsingHistoryHandler::HistoryEntry::HistoryEntry()
289    : entry_type(EMPTY_ENTRY), is_search_result(false), blocked_visit(false) {
290}
291
292BrowsingHistoryHandler::HistoryEntry::~HistoryEntry() {
293}
294
295void BrowsingHistoryHandler::HistoryEntry::SetUrlAndTitle(
296    base::DictionaryValue* result) const {
297  result->SetString("url", url.spec());
298
299  bool using_url_as_the_title = false;
300  base::string16 title_to_set(title);
301  if (title.empty()) {
302    using_url_as_the_title = true;
303    title_to_set = base::UTF8ToUTF16(url.spec());
304  }
305
306  // Since the title can contain BiDi text, we need to mark the text as either
307  // RTL or LTR, depending on the characters in the string. If we use the URL
308  // as the title, we mark the title as LTR since URLs are always treated as
309  // left to right strings.
310  if (base::i18n::IsRTL()) {
311    if (using_url_as_the_title)
312      base::i18n::WrapStringWithLTRFormatting(&title_to_set);
313    else
314      base::i18n::AdjustStringForLocaleDirection(&title_to_set);
315  }
316  result->SetString("title", title_to_set);
317}
318
319scoped_ptr<base::DictionaryValue> BrowsingHistoryHandler::HistoryEntry::ToValue(
320    BookmarkModel* bookmark_model,
321    SupervisedUserService* supervised_user_service,
322    const ProfileSyncService* sync_service) const {
323  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
324  SetUrlAndTitle(result.get());
325
326  base::string16 domain = net::IDNToUnicode(url.host(), accept_languages);
327  // When the domain is empty, use the scheme instead. This allows for a
328  // sensible treatment of e.g. file: URLs when group by domain is on.
329  if (domain.empty())
330    domain = base::UTF8ToUTF16(url.scheme() + ":");
331
332  // The items which are to be written into result are also described in
333  // chrome/browser/resources/history/history.js in @typedef for
334  // HistoryEntry. Please update it whenever you add or remove
335  // any keys in result.
336  result->SetString("domain", domain);
337  result->SetDouble("time", time.ToJsTime());
338
339  // Pass the timestamps in a list.
340  scoped_ptr<base::ListValue> timestamps(new base::ListValue);
341  for (std::set<int64>::const_iterator it = all_timestamps.begin();
342       it != all_timestamps.end(); ++it) {
343    timestamps->AppendDouble(base::Time::FromInternalValue(*it).ToJsTime());
344  }
345  result->Set("allTimestamps", timestamps.release());
346
347  // Always pass the short date since it is needed both in the search and in
348  // the monthly view.
349  result->SetString("dateShort", base::TimeFormatShortDate(time));
350
351  // Only pass in the strings we need (search results need a shortdate
352  // and snippet, browse results need day and time information).
353  if (is_search_result) {
354    result->SetString("snippet", snippet);
355  } else {
356    base::Time midnight = base::Time::Now().LocalMidnight();
357    base::string16 date_str = ui::TimeFormat::RelativeDate(time, &midnight);
358    if (date_str.empty()) {
359      date_str = base::TimeFormatFriendlyDate(time);
360    } else {
361      date_str = l10n_util::GetStringFUTF16(
362          IDS_HISTORY_DATE_WITH_RELATIVE_TIME,
363          date_str,
364          base::TimeFormatFriendlyDate(time));
365    }
366    result->SetString("dateRelativeDay", date_str);
367    result->SetString("dateTimeOfDay", base::TimeFormatTimeOfDay(time));
368  }
369  result->SetBoolean("starred", bookmark_model->IsBookmarked(url));
370
371  std::string device_name;
372  std::string device_type;
373  if (!client_id.empty())
374    GetDeviceNameAndType(sync_service, client_id, &device_name, &device_type);
375  result->SetString("deviceName", device_name);
376  result->SetString("deviceType", device_type);
377
378#if defined(ENABLE_MANAGED_USERS)
379  if (supervised_user_service) {
380    const SupervisedUserURLFilter* url_filter =
381        supervised_user_service->GetURLFilterForUIThread();
382    int filtering_behavior =
383        url_filter->GetFilteringBehaviorForURL(url.GetWithEmptyPath());
384    result->SetInteger("hostFilteringBehavior", filtering_behavior);
385
386    result->SetBoolean("blockedVisit", blocked_visit);
387  }
388#endif
389
390  return result.Pass();
391}
392
393bool BrowsingHistoryHandler::HistoryEntry::SortByTimeDescending(
394    const BrowsingHistoryHandler::HistoryEntry& entry1,
395    const BrowsingHistoryHandler::HistoryEntry& entry2) {
396  return entry1.time > entry2.time;
397}
398
399BrowsingHistoryHandler::BrowsingHistoryHandler()
400    : has_pending_delete_request_(false),
401      weak_factory_(this) {
402}
403
404BrowsingHistoryHandler::~BrowsingHistoryHandler() {
405  query_task_tracker_.TryCancelAll();
406  web_history_request_.reset();
407}
408
409void BrowsingHistoryHandler::RegisterMessages() {
410  // Create our favicon data source.
411  Profile* profile = Profile::FromWebUI(web_ui());
412  content::URLDataSource::Add(
413      profile, new FaviconSource(profile, FaviconSource::ANY));
414
415  // Get notifications when history is cleared.
416  registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED,
417      content::Source<Profile>(profile->GetOriginalProfile()));
418
419  web_ui()->RegisterMessageCallback("queryHistory",
420      base::Bind(&BrowsingHistoryHandler::HandleQueryHistory,
421                 base::Unretained(this)));
422  web_ui()->RegisterMessageCallback("removeVisits",
423      base::Bind(&BrowsingHistoryHandler::HandleRemoveVisits,
424                 base::Unretained(this)));
425  web_ui()->RegisterMessageCallback("clearBrowsingData",
426      base::Bind(&BrowsingHistoryHandler::HandleClearBrowsingData,
427                 base::Unretained(this)));
428  web_ui()->RegisterMessageCallback("removeBookmark",
429      base::Bind(&BrowsingHistoryHandler::HandleRemoveBookmark,
430                 base::Unretained(this)));
431}
432
433bool BrowsingHistoryHandler::ExtractIntegerValueAtIndex(
434    const base::ListValue* value,
435    int index,
436    int* out_int) {
437  double double_value;
438  if (value->GetDouble(index, &double_value)) {
439    *out_int = static_cast<int>(double_value);
440    return true;
441  }
442  NOTREACHED();
443  return false;
444}
445
446void BrowsingHistoryHandler::WebHistoryTimeout() {
447  // TODO(dubroy): Communicate the failure to the front end.
448  if (!query_task_tracker_.HasTrackedTasks())
449    ReturnResultsToFrontEnd();
450
451  UMA_HISTOGRAM_ENUMERATION(
452      "WebHistory.QueryCompletion",
453      WEB_HISTORY_QUERY_TIMED_OUT, NUM_WEB_HISTORY_QUERY_BUCKETS);
454}
455
456void BrowsingHistoryHandler::QueryHistory(
457    base::string16 search_text, const history::QueryOptions& options) {
458  Profile* profile = Profile::FromWebUI(web_ui());
459
460  // Anything in-flight is invalid.
461  query_task_tracker_.TryCancelAll();
462  web_history_request_.reset();
463
464  query_results_.clear();
465  results_info_value_.Clear();
466
467  HistoryService* hs = HistoryServiceFactory::GetForProfile(
468      profile, Profile::EXPLICIT_ACCESS);
469  hs->QueryHistory(search_text,
470                   options,
471                   base::Bind(&BrowsingHistoryHandler::QueryComplete,
472                              base::Unretained(this),
473                              search_text,
474                              options),
475                   &query_task_tracker_);
476
477  history::WebHistoryService* web_history =
478      WebHistoryServiceFactory::GetForProfile(profile);
479  if (web_history) {
480    web_history_query_results_.clear();
481    web_history_request_ = web_history->QueryHistory(
482        search_text,
483        options,
484        base::Bind(&BrowsingHistoryHandler::WebHistoryQueryComplete,
485                   base::Unretained(this),
486                   search_text, options,
487                   base::TimeTicks::Now()));
488    // Start a timer so we know when to give up.
489    web_history_timer_.Start(
490        FROM_HERE, base::TimeDelta::FromSeconds(kWebHistoryTimeoutSeconds),
491        this, &BrowsingHistoryHandler::WebHistoryTimeout);
492
493    // Set this to false until the results actually arrive.
494    results_info_value_.SetBoolean("hasSyncedResults", false);
495  }
496}
497
498void BrowsingHistoryHandler::HandleQueryHistory(const base::ListValue* args) {
499  history::QueryOptions options;
500
501  // Parse the arguments from JavaScript. There are five required arguments:
502  // - the text to search for (may be empty)
503  // - the offset from which the search should start (in multiples of week or
504  //   month, set by the next argument).
505  // - the range (BrowsingHistoryHandler::Range) Enum value that sets the range
506  //   of the query.
507  // - the end time for the query. Only results older than this time will be
508  //   returned.
509  // - the maximum number of results to return (may be 0, meaning that there
510  //   is no maximum).
511  base::string16 search_text = ExtractStringValue(args);
512  int offset;
513  if (!args->GetInteger(1, &offset)) {
514    NOTREACHED() << "Failed to convert argument 1. ";
515    return;
516  }
517  int range;
518  if (!args->GetInteger(2, &range)) {
519    NOTREACHED() << "Failed to convert argument 2. ";
520    return;
521  }
522
523  if (range == BrowsingHistoryHandler::MONTH)
524    SetQueryTimeInMonths(offset, &options);
525  else if (range == BrowsingHistoryHandler::WEEK)
526    SetQueryTimeInWeeks(offset, &options);
527
528  double end_time;
529  if (!args->GetDouble(3, &end_time)) {
530    NOTREACHED() << "Failed to convert argument 3. ";
531    return;
532  }
533  if (end_time)
534    options.end_time = base::Time::FromJsTime(end_time);
535
536  if (!ExtractIntegerValueAtIndex(args, 4, &options.max_count)) {
537    NOTREACHED() << "Failed to convert argument 4.";
538    return;
539  }
540
541  options.duplicate_policy = history::QueryOptions::REMOVE_DUPLICATES_PER_DAY;
542  QueryHistory(search_text, options);
543}
544
545void BrowsingHistoryHandler::HandleRemoveVisits(const base::ListValue* args) {
546  Profile* profile = Profile::FromWebUI(web_ui());
547  // TODO(davidben): history.js is not aware of this failure and will still
548  // override |deleteCompleteCallback_|.
549  if (delete_task_tracker_.HasTrackedTasks() ||
550      has_pending_delete_request_ ||
551      !profile->GetPrefs()->GetBoolean(prefs::kAllowDeletingBrowserHistory)) {
552    web_ui()->CallJavascriptFunction("deleteFailed");
553    return;
554  }
555
556  HistoryService* history_service =
557      HistoryServiceFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS);
558  history::WebHistoryService* web_history =
559      WebHistoryServiceFactory::GetForProfile(profile);
560
561  base::Time now = base::Time::Now();
562  std::vector<history::ExpireHistoryArgs> expire_list;
563  expire_list.reserve(args->GetSize());
564
565  DCHECK(urls_to_be_deleted_.empty());
566  for (base::ListValue::const_iterator it = args->begin();
567       it != args->end(); ++it) {
568    base::DictionaryValue* deletion = NULL;
569    base::string16 url;
570    base::ListValue* timestamps = NULL;
571
572    // Each argument is a dictionary with properties "url" and "timestamps".
573    if (!((*it)->GetAsDictionary(&deletion) &&
574        deletion->GetString("url", &url) &&
575        deletion->GetList("timestamps", &timestamps))) {
576      NOTREACHED() << "Unable to extract arguments";
577      return;
578    }
579    DCHECK(timestamps->GetSize() > 0);
580
581    // In order to ensure that visits will be deleted from the server and other
582    // clients (even if they are offline), create a sync delete directive for
583    // each visit to be deleted.
584    sync_pb::HistoryDeleteDirectiveSpecifics delete_directive;
585    sync_pb::GlobalIdDirective* global_id_directive =
586        delete_directive.mutable_global_id_directive();
587
588    double timestamp;
589    history::ExpireHistoryArgs* expire_args = NULL;
590    for (base::ListValue::const_iterator ts_iterator = timestamps->begin();
591         ts_iterator != timestamps->end(); ++ts_iterator) {
592      if (!(*ts_iterator)->GetAsDouble(&timestamp)) {
593        NOTREACHED() << "Unable to extract visit timestamp.";
594        continue;
595      }
596      base::Time visit_time = base::Time::FromJsTime(timestamp);
597      if (!expire_args) {
598        GURL gurl(url);
599        expire_list.resize(expire_list.size() + 1);
600        expire_args = &expire_list.back();
601        expire_args->SetTimeRangeForOneDay(visit_time);
602        expire_args->urls.insert(gurl);
603        urls_to_be_deleted_.insert(gurl);
604      }
605      // The local visit time is treated as a global ID for the visit.
606      global_id_directive->add_global_id(visit_time.ToInternalValue());
607    }
608
609    // Set the start and end time in microseconds since the Unix epoch.
610    global_id_directive->set_start_time_usec(
611        (expire_args->begin_time - base::Time::UnixEpoch()).InMicroseconds());
612
613    // Delete directives shouldn't have an end time in the future.
614    // TODO(dubroy): Use sane time (crbug.com/146090) here when it's ready.
615    base::Time end_time = std::min(expire_args->end_time, now);
616
617    // -1 because end time in delete directives is inclusive.
618    global_id_directive->set_end_time_usec(
619        (end_time - base::Time::UnixEpoch()).InMicroseconds() - 1);
620
621    // TODO(dubroy): Figure out the proper way to handle an error here.
622    if (web_history)
623      history_service->ProcessLocalDeleteDirective(delete_directive);
624  }
625
626  history_service->ExpireHistory(
627      expire_list,
628      base::Bind(&BrowsingHistoryHandler::RemoveComplete,
629                 base::Unretained(this)),
630      &delete_task_tracker_);
631
632  if (web_history) {
633    has_pending_delete_request_ = true;
634    web_history->ExpireHistory(
635        expire_list,
636        base::Bind(&BrowsingHistoryHandler::RemoveWebHistoryComplete,
637                   weak_factory_.GetWeakPtr()));
638  }
639
640#if defined(ENABLE_EXTENSIONS)
641  // If the profile has activity logging enabled also clean up any URLs from
642  // the extension activity log. The extension activity log contains URLS
643  // which websites an extension has activity on so it will indirectly
644  // contain websites that a user has visited.
645  extensions::ActivityLog* activity_log =
646      extensions::ActivityLog::GetInstance(profile);
647  for (std::vector<history::ExpireHistoryArgs>::const_iterator it =
648       expire_list.begin(); it != expire_list.end(); ++it) {
649    activity_log->RemoveURLs(it->urls);
650  }
651#endif
652}
653
654void BrowsingHistoryHandler::HandleClearBrowsingData(
655    const base::ListValue* args) {
656#if defined(OS_ANDROID)
657  chrome::android::ChromiumApplication::OpenClearBrowsingData(
658      web_ui()->GetWebContents());
659#else
660  // TODO(beng): This is an improper direct dependency on Browser. Route this
661  // through some sort of delegate.
662  Browser* browser = chrome::FindBrowserWithWebContents(
663      web_ui()->GetWebContents());
664  chrome::ShowClearBrowsingDataDialog(browser);
665#endif
666}
667
668void BrowsingHistoryHandler::HandleRemoveBookmark(const base::ListValue* args) {
669  base::string16 url = ExtractStringValue(args);
670  Profile* profile = Profile::FromWebUI(web_ui());
671  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile);
672  bookmarks::RemoveAllBookmarks(model, GURL(url));
673}
674
675// static
676void BrowsingHistoryHandler::MergeDuplicateResults(
677    std::vector<BrowsingHistoryHandler::HistoryEntry>* results) {
678  std::vector<BrowsingHistoryHandler::HistoryEntry> new_results;
679  // Pre-reserve the size of the new vector. Since we're working with pointers
680  // later on not doing this could lead to the vector being resized and to
681  // pointers to invalid locations.
682  new_results.reserve(results->size());
683  // Maps a URL to the most recent entry on a particular day.
684  std::map<GURL, BrowsingHistoryHandler::HistoryEntry*> current_day_entries;
685
686  // Keeps track of the day that |current_day_urls| is holding the URLs for,
687  // in order to handle removing per-day duplicates.
688  base::Time current_day_midnight;
689
690  std::sort(
691      results->begin(), results->end(), HistoryEntry::SortByTimeDescending);
692
693  for (std::vector<BrowsingHistoryHandler::HistoryEntry>::const_iterator it =
694           results->begin(); it != results->end(); ++it) {
695    // Reset the list of found URLs when a visit from a new day is encountered.
696    if (current_day_midnight != it->time.LocalMidnight()) {
697      current_day_entries.clear();
698      current_day_midnight = it->time.LocalMidnight();
699    }
700
701    // Keep this visit if it's the first visit to this URL on the current day.
702    if (current_day_entries.count(it->url) == 0) {
703      new_results.push_back(*it);
704      current_day_entries[it->url] = &new_results.back();
705    } else {
706      // Keep track of the timestamps of all visits to the URL on the same day.
707      BrowsingHistoryHandler::HistoryEntry* entry =
708          current_day_entries[it->url];
709      entry->all_timestamps.insert(
710          it->all_timestamps.begin(), it->all_timestamps.end());
711
712      if (entry->entry_type != it->entry_type) {
713        entry->entry_type =
714            BrowsingHistoryHandler::HistoryEntry::COMBINED_ENTRY;
715      }
716    }
717  }
718  results->swap(new_results);
719}
720
721void BrowsingHistoryHandler::ReturnResultsToFrontEnd() {
722  Profile* profile = Profile::FromWebUI(web_ui());
723  BookmarkModel* bookmark_model = BookmarkModelFactory::GetForProfile(profile);
724  SupervisedUserService* supervised_user_service = NULL;
725#if defined(ENABLE_MANAGED_USERS)
726  if (profile->IsSupervised())
727    supervised_user_service =
728        SupervisedUserServiceFactory::GetForProfile(profile);
729#endif
730  ProfileSyncService* sync_service =
731      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
732
733  // Combine the local and remote results into |query_results_|, and remove
734  // any duplicates.
735  if (!web_history_query_results_.empty()) {
736    int local_result_count = query_results_.size();
737    query_results_.insert(query_results_.end(),
738                          web_history_query_results_.begin(),
739                          web_history_query_results_.end());
740    MergeDuplicateResults(&query_results_);
741
742    if (local_result_count) {
743      // In the best case, we expect that all local results are duplicated on
744      // the server. Keep track of how many are missing.
745      int missing_count = std::count_if(
746          query_results_.begin(), query_results_.end(), IsLocalOnlyResult);
747      UMA_HISTOGRAM_PERCENTAGE("WebHistory.LocalResultMissingOnServer",
748                               missing_count * 100.0 / local_result_count);
749    }
750  }
751
752  // Convert the result vector into a ListValue.
753  base::ListValue results_value;
754  for (std::vector<BrowsingHistoryHandler::HistoryEntry>::iterator it =
755           query_results_.begin(); it != query_results_.end(); ++it) {
756    scoped_ptr<base::Value> value(
757        it->ToValue(bookmark_model, supervised_user_service, sync_service));
758    results_value.Append(value.release());
759  }
760
761  web_ui()->CallJavascriptFunction(
762      "historyResult", results_info_value_, results_value);
763  results_info_value_.Clear();
764  query_results_.clear();
765  web_history_query_results_.clear();
766}
767
768void BrowsingHistoryHandler::QueryComplete(
769    const base::string16& search_text,
770    const history::QueryOptions& options,
771    history::QueryResults* results) {
772  DCHECK_EQ(0U, query_results_.size());
773  query_results_.reserve(results->size());
774  const std::string accept_languages = GetAcceptLanguages();
775
776  for (size_t i = 0; i < results->size(); ++i) {
777    history::URLResult const &page = (*results)[i];
778    // TODO(dubroy): Use sane time (crbug.com/146090) here when it's ready.
779    query_results_.push_back(
780        HistoryEntry(
781            HistoryEntry::LOCAL_ENTRY,
782            page.url(),
783            page.title(),
784            page.visit_time(),
785            std::string(),
786            !search_text.empty(),
787            page.snippet().text(),
788            page.blocked_visit(),
789            accept_languages));
790  }
791
792  // The items which are to be written into results_info_value_ are also
793  // described in chrome/browser/resources/history/history.js in @typedef for
794  // HistoryQuery. Please update it whenever you add or remove any keys in
795  // results_info_value_.
796  results_info_value_.SetString("term", search_text);
797  results_info_value_.SetBoolean("finished", results->reached_beginning());
798
799  // Add the specific dates that were searched to display them.
800  // TODO(sergiu): Put today if the start is in the future.
801  results_info_value_.SetString("queryStartTime",
802                                getRelativeDateLocalized(options.begin_time));
803  if (!options.end_time.is_null()) {
804    results_info_value_.SetString("queryEndTime",
805        getRelativeDateLocalized(options.end_time -
806                                 base::TimeDelta::FromDays(1)));
807  } else {
808    results_info_value_.SetString("queryEndTime",
809        getRelativeDateLocalized(base::Time::Now()));
810  }
811  if (!web_history_timer_.IsRunning())
812    ReturnResultsToFrontEnd();
813}
814
815void BrowsingHistoryHandler::WebHistoryQueryComplete(
816    const base::string16& search_text,
817    const history::QueryOptions& options,
818    base::TimeTicks start_time,
819    history::WebHistoryService::Request* request,
820    const base::DictionaryValue* results_value) {
821  base::TimeDelta delta = base::TimeTicks::Now() - start_time;
822  UMA_HISTOGRAM_TIMES("WebHistory.ResponseTime", delta);
823  const std::string accept_languages = GetAcceptLanguages();
824
825  // If the response came in too late, do nothing.
826  // TODO(dubroy): Maybe show a banner, and prompt the user to reload?
827  if (!web_history_timer_.IsRunning())
828    return;
829  web_history_timer_.Stop();
830
831  UMA_HISTOGRAM_ENUMERATION(
832      "WebHistory.QueryCompletion",
833      results_value ? WEB_HISTORY_QUERY_SUCCEEDED : WEB_HISTORY_QUERY_FAILED,
834      NUM_WEB_HISTORY_QUERY_BUCKETS);
835
836  DCHECK_EQ(0U, web_history_query_results_.size());
837  const base::ListValue* events = NULL;
838  if (results_value && results_value->GetList("event", &events)) {
839    web_history_query_results_.reserve(events->GetSize());
840    for (unsigned int i = 0; i < events->GetSize(); ++i) {
841      const base::DictionaryValue* event = NULL;
842      const base::DictionaryValue* result = NULL;
843      const base::ListValue* results = NULL;
844      const base::ListValue* ids = NULL;
845      base::string16 url;
846      base::string16 title;
847      base::Time visit_time;
848
849      if (!(events->GetDictionary(i, &event) &&
850          event->GetList("result", &results) &&
851          results->GetDictionary(0, &result) &&
852          result->GetString("url", &url) &&
853          result->GetList("id", &ids) &&
854          ids->GetSize() > 0)) {
855        LOG(WARNING) << "Improperly formed JSON response from history server.";
856        continue;
857      }
858      // Title is optional, so the return value is ignored here.
859      result->GetString("title", &title);
860
861      // Extract the timestamps of all the visits to this URL.
862      // They are referred to as "IDs" by the server.
863      for (int j = 0; j < static_cast<int>(ids->GetSize()); ++j) {
864        const base::DictionaryValue* id = NULL;
865        std::string timestamp_string;
866        int64 timestamp_usec = 0;
867
868        if (!ids->GetDictionary(j, &id) ||
869            !id->GetString("timestamp_usec", &timestamp_string) ||
870            !base::StringToInt64(timestamp_string, &timestamp_usec)) {
871          NOTREACHED() << "Unable to extract timestamp.";
872          continue;
873        }
874        // The timestamp on the server is a Unix time.
875        base::Time time = base::Time::UnixEpoch() +
876            base::TimeDelta::FromMicroseconds(timestamp_usec);
877
878        // Get the ID of the client that this visit came from.
879        std::string client_id;
880        id->GetString("client_id", &client_id);
881
882        web_history_query_results_.push_back(
883            HistoryEntry(
884                HistoryEntry::REMOTE_ENTRY,
885                GURL(url),
886                title,
887                time,
888                client_id,
889                !search_text.empty(),
890                base::string16(),
891                /* blocked_visit */ false,
892                accept_languages));
893      }
894    }
895  } else if (results_value) {
896    NOTREACHED() << "Failed to parse JSON response.";
897  }
898  results_info_value_.SetBoolean("hasSyncedResults", results_value != NULL);
899  if (!query_task_tracker_.HasTrackedTasks())
900    ReturnResultsToFrontEnd();
901}
902
903void BrowsingHistoryHandler::RemoveComplete() {
904  urls_to_be_deleted_.clear();
905
906  // Notify the page that the deletion request is complete, but only if a web
907  // history delete request is not still pending.
908  if (!has_pending_delete_request_)
909    web_ui()->CallJavascriptFunction("deleteComplete");
910}
911
912void BrowsingHistoryHandler::RemoveWebHistoryComplete(bool success) {
913  has_pending_delete_request_ = false;
914  // TODO(dubroy): Should we handle failure somehow? Delete directives will
915  // ensure that the visits are eventually deleted, so maybe it's not necessary.
916  if (!delete_task_tracker_.HasTrackedTasks())
917    RemoveComplete();
918}
919
920void BrowsingHistoryHandler::SetQueryTimeInWeeks(
921    int offset, history::QueryOptions* options) {
922  // LocalMidnight returns the beginning of the current day so get the
923  // beginning of the next one.
924  base::Time midnight = base::Time::Now().LocalMidnight() +
925                              base::TimeDelta::FromDays(1);
926  options->end_time = midnight -
927      base::TimeDelta::FromDays(7 * offset);
928  options->begin_time = midnight -
929      base::TimeDelta::FromDays(7 * (offset + 1));
930}
931
932void BrowsingHistoryHandler::SetQueryTimeInMonths(
933    int offset, history::QueryOptions* options) {
934  // Configure the begin point of the search to the start of the
935  // current month.
936  base::Time::Exploded exploded;
937  base::Time::Now().LocalMidnight().LocalExplode(&exploded);
938  exploded.day_of_month = 1;
939
940  if (offset == 0) {
941    options->begin_time = base::Time::FromLocalExploded(exploded);
942
943    // Set the end time of this first search to null (which will
944    // show results from the future, should the user's clock have
945    // been set incorrectly).
946    options->end_time = base::Time();
947  } else {
948    // Go back |offset| months in the past. The end time is not inclusive, so
949    // use the first day of the |offset| - 1 and |offset| months (e.g. for
950    // the last month, |offset| = 1, use the first days of the last month and
951    // the current month.
952    exploded.month -= offset - 1;
953    // Set the correct year.
954    normalizeMonths(&exploded);
955    options->end_time = base::Time::FromLocalExploded(exploded);
956
957    exploded.month -= 1;
958    // Set the correct year
959    normalizeMonths(&exploded);
960    options->begin_time = base::Time::FromLocalExploded(exploded);
961  }
962}
963
964// Helper function for Observe that determines if there are any differences
965// between the URLs noticed for deletion and the ones we are expecting.
966static bool DeletionsDiffer(const history::URLRows& deleted_rows,
967                            const std::set<GURL>& urls_to_be_deleted) {
968  if (deleted_rows.size() != urls_to_be_deleted.size())
969    return true;
970  for (history::URLRows::const_iterator i = deleted_rows.begin();
971       i != deleted_rows.end(); ++i) {
972    if (urls_to_be_deleted.find(i->url()) == urls_to_be_deleted.end())
973      return true;
974  }
975  return false;
976}
977
978void BrowsingHistoryHandler::Observe(
979    int type,
980    const content::NotificationSource& source,
981    const content::NotificationDetails& details) {
982  if (type != chrome::NOTIFICATION_HISTORY_URLS_DELETED) {
983    NOTREACHED();
984    return;
985  }
986  history::URLsDeletedDetails* deletedDetails =
987      content::Details<history::URLsDeletedDetails>(details).ptr();
988  if (deletedDetails->all_history ||
989      DeletionsDiffer(deletedDetails->rows, urls_to_be_deleted_))
990    web_ui()->CallJavascriptFunction("historyDeleted");
991}
992
993std::string BrowsingHistoryHandler::GetAcceptLanguages() const {
994  Profile* profile = Profile::FromWebUI(web_ui());
995  return profile->GetPrefs()->GetString(prefs::kAcceptLanguages);
996}
997
998////////////////////////////////////////////////////////////////////////////////
999//
1000// HistoryUI
1001//
1002////////////////////////////////////////////////////////////////////////////////
1003
1004HistoryUI::HistoryUI(content::WebUI* web_ui) : WebUIController(web_ui) {
1005  web_ui->AddMessageHandler(new BrowsingHistoryHandler());
1006  web_ui->AddMessageHandler(new MetricsHandler());
1007
1008// On mobile we deal with foreign sessions differently.
1009#if !defined(OS_ANDROID) && !defined(OS_IOS)
1010  if (chrome::IsInstantExtendedAPIEnabled()) {
1011    web_ui->AddMessageHandler(new browser_sync::ForeignSessionHandler());
1012    web_ui->AddMessageHandler(new NTPLoginHandler());
1013  }
1014#endif
1015
1016  // Set up the chrome://history-frame/ source.
1017  Profile* profile = Profile::FromWebUI(web_ui);
1018  content::WebUIDataSource::Add(profile, CreateHistoryUIHTMLSource(profile));
1019}
1020
1021// static
1022base::RefCountedMemory* HistoryUI::GetFaviconResourceBytes(
1023      ui::ScaleFactor scale_factor) {
1024  return ResourceBundle::GetSharedInstance().
1025      LoadDataResourceBytesForScale(IDR_HISTORY_FAVICON, scale_factor);
1026}
1027