Expose final download URL (actual url after redirects) in the extension API.

chrome/browser/download/download_query.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/download/download_query.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 52 matching lines @@
       return false;
     }
     out->push_back(element);
   }
   return true;
 }
 
 // The next several functions are helpers for making Callbacks that access
 // DownloadItem fields.
 
-static int64_t GetStartTimeMsEpoch(const DownloadItem& item) {
+int64_t GetStartTimeMsEpoch(const DownloadItem& item) {
   return (item.GetStartTime() - base::Time::UnixEpoch()).InMilliseconds();
 }
 
-static int64_t GetEndTimeMsEpoch(const DownloadItem& item) {
+int64_t GetEndTimeMsEpoch(const DownloadItem& item) {
   return (item.GetEndTime() - base::Time::UnixEpoch()).InMilliseconds();
 }
 
 std::string TimeToISO8601(const base::Time& t) {
   base::Time::Exploded exploded;
   t.UTCExplode(&exploded);
   return base::StringPrintf(
       "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", exploded.year, exploded.month,
       exploded.day_of_month, exploded.hour, exploded.minute, exploded.second,
       exploded.millisecond);
 }
 
-static std::string GetStartTime(const DownloadItem& item) {
+std::string GetStartTime(const DownloadItem& item) {
   return TimeToISO8601(item.GetStartTime());
 }
 
-static std::string GetEndTime(const DownloadItem& item) {
+std::string GetEndTime(const DownloadItem& item) {
   return TimeToISO8601(item.GetEndTime());
 }
 
-static bool GetDangerAccepted(const DownloadItem& item) {
+bool GetDangerAccepted(const DownloadItem& item) {
   return (item.GetDangerType() ==
           content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED);
 }
 
-static bool GetExists(const DownloadItem& item) {
+bool GetExists(const DownloadItem& item) {
   return !item.GetFileExternallyRemoved();
 }
 
-static base::string16 GetFilename(const DownloadItem& item) {
+base::string16 GetFilename(const DownloadItem& item) {
   // This filename will be compared with strings that could be passed in by the
   // user, who only sees LossyDisplayNames.
   return item.GetTargetFilePath().LossyDisplayName();
 }
 
-static std::string GetFilenameUTF8(const DownloadItem& item) {
+std::string GetFilenameUTF8(const DownloadItem& item) {
   return base::UTF16ToUTF8(GetFilename(item));
 }
 
-static std::string GetUrl(const DownloadItem& item) {
+std::string GetOriginalUrl(const DownloadItem& item) {
   return item.GetOriginalUrl().spec();
 }
 
-static DownloadItem::DownloadState GetState(const DownloadItem& item) {
+std::string GetUrl(const DownloadItem& item) {
+  return item.GetURL().spec();
+}
+
+DownloadItem::DownloadState GetState(const DownloadItem& item) {
   return item.GetState();
 }
 
-static DownloadDangerType GetDangerType(const DownloadItem& item) {
+DownloadDangerType GetDangerType(const DownloadItem& item) {
   return item.GetDangerType();
 }
 
-static double GetReceivedBytes(const DownloadItem& item) {
+double GetReceivedBytes(const DownloadItem& item) {
   return item.GetReceivedBytes();
 }
 
-static double GetTotalBytes(const DownloadItem& item) {
+double GetTotalBytes(const DownloadItem& item) {
   return item.GetTotalBytes();
 }
 
-static std::string GetMimeType(const DownloadItem& item) {
+std::string GetMimeType(const DownloadItem& item) {
   return item.GetMimeType();
 }
 
-static bool IsPaused(const DownloadItem& item) {
+bool IsPaused(const DownloadItem& item) {
   return item.IsPaused();
 }
 
 enum ComparisonType {LT, EQ, GT};
 
 // Returns true if |item| matches the filter specified by |value|, |cmptype|,
 // and |accessor|. |accessor| is conceptually a function that takes a
 // DownloadItem and returns one of its fields, which is then compared to
 // |value|.
 template<typename ValueType>
-static bool FieldMatches(
+bool FieldMatches(
     const ValueType& value,
     ComparisonType cmptype,
     const base::Callback<ValueType(const DownloadItem&)>& accessor,
     const DownloadItem& item) {
   switch (cmptype) {
     case LT: return accessor.Run(item) < value;
     case EQ: return accessor.Run(item) == value;
     case GT: return accessor.Run(item) > value;
   }
   NOTREACHED();
   return false;
 }
 
 // Helper for building a Callback to FieldMatches<>().
 template <typename ValueType> DownloadQuery::FilterCallback BuildFilter(
     const base::Value& value, ComparisonType cmptype,
     ValueType (*accessor)(const DownloadItem&)) {
   ValueType cpp_value;
   if (!GetAs(value, &cpp_value)) return DownloadQuery::FilterCallback();
   return base::Bind(&FieldMatches<ValueType>, cpp_value, cmptype,
                     base::Bind(accessor));
 }
 
 // Returns true if |accessor.Run(item)| matches |pattern|.
-static bool FindRegex(
+bool FindRegex(
     RE2* pattern,
     const base::Callback<std::string(const DownloadItem&)>& accessor,
     const DownloadItem& item) {
   return RE2::PartialMatch(accessor.Run(item), *pattern);
 }
 
 // Helper for building a Callback to FindRegex().
 DownloadQuery::FilterCallback BuildRegexFilter(
     const base::Value& regex_value,
     std::string (*accessor)(const DownloadItem&)) {
   std::string regex_str;
   if (!GetAs(regex_value, &regex_str)) return DownloadQuery::FilterCallback();
   std::unique_ptr<RE2> pattern(new RE2(regex_str));
   if (!pattern->ok()) return DownloadQuery::FilterCallback();
   return base::Bind(&FindRegex, base::Owned(pattern.release()),
                     base::Bind(accessor));
 }
 
 // Returns a ComparisonType to indicate whether a field in |left| is less than,
 // greater than or equal to the same field in |right|.
 template<typename ValueType>
-static ComparisonType Compare(
+ComparisonType Compare(
     const base::Callback<ValueType(const DownloadItem&)>& accessor,
     const DownloadItem& left, const DownloadItem& right) {
   ValueType left_value = accessor.Run(left);
   ValueType right_value = accessor.Run(right);
   if (left_value > right_value) return GT;
   if (left_value < right_value) return LT;
   DCHECK_EQ(left_value, right_value);
   return EQ;
 }
 
 }  // anonymous namespace
 
 // static
 bool DownloadQuery::MatchesQuery(const std::vector<base::string16>& query_terms,
                                  const DownloadItem& item) {
   if (query_terms.empty())
     return true;
 
-  base::string16 url_raw(base::UTF8ToUTF16(item.GetOriginalUrl().spec()));
-  base::string16 url_formatted = url_raw;
-  if (item.GetBrowserContext())
-    url_formatted = url_formatter::FormatUrl(item.GetOriginalUrl());
+  base::string16 original_url_raw(
+      base::UTF8ToUTF16(item.GetOriginalUrl().spec()));
+  base::string16 url_raw(base::UTF8ToUTF16(item.GetURL().spec()));
+  // Try to also match query with above URLs formatted in user display friendly
+  // way. This will unescape characters (including spaces) and trim all extra
+  // data (like username and password) from raw url so that for example raw url
+  // "http://some.server.org/example%20download/file.zip" will be matched with
+  // search term "example download".
+  base::string16 original_url_formatted(
+      url_formatter::FormatUrl(item.GetOriginalUrl()));
+  base::string16 url_formatted(url_formatter::FormatUrl(item.GetURL()));
   base::string16 path(item.GetTargetFilePath().LossyDisplayName());
 
   for (std::vector<base::string16>::const_iterator it = query_terms.begin();
        it != query_terms.end(); ++it) {
     base::string16 term = base::i18n::ToLower(*it);
     if (!base::i18n::StringSearchIgnoringCaseAndAccents(
+            term, original_url_raw, NULL, NULL) &&
+        !base::i18n::StringSearchIgnoringCaseAndAccents(
+            term, original_url_formatted, NULL, NULL) &&
+        !base::i18n::StringSearchIgnoringCaseAndAccents(
             term, url_raw, NULL, NULL) &&
         !base::i18n::StringSearchIgnoringCaseAndAccents(
             term, url_formatted, NULL, NULL) &&
         !base::i18n::StringSearchIgnoringCaseAndAccents(
             term, path, NULL, NULL)) {
       return false;
     }
   }
   return true;
 }
@@ skipping 56 matching lines @@
     case FILTER_STARTED_BEFORE:
       return AddFilter(BuildFilter<std::string>(value, LT, &GetStartTime));
     case FILTER_START_TIME:
       return AddFilter(BuildFilter<std::string>(value, EQ, &GetStartTime));
     case FILTER_TOTAL_BYTES:
       return AddFilter(BuildFilter<double>(value, EQ, &GetTotalBytes));
     case FILTER_TOTAL_BYTES_GREATER:
       return AddFilter(BuildFilter<double>(value, GT, &GetTotalBytes));
     case FILTER_TOTAL_BYTES_LESS:
       return AddFilter(BuildFilter<double>(value, LT, &GetTotalBytes));
+    case FILTER_ORIGINAL_URL:
+      return AddFilter(BuildFilter<std::string>(value, EQ, &GetOriginalUrl));
+    case FILTER_ORIGINAL_URL_REGEX:
+      return AddFilter(BuildRegexFilter(value, &GetOriginalUrl));
     case FILTER_URL:
       return AddFilter(BuildFilter<std::string>(value, EQ, &GetUrl));
     case FILTER_URL_REGEX:
       return AddFilter(BuildRegexFilter(value, &GetUrl));
   }
   return false;
 }
 
 bool DownloadQuery::Matches(const DownloadItem& item) const {
   for (FilterCallbackVector::const_iterator filter = filters_.begin();
@@ skipping 70 matching lines @@
 void DownloadQuery::AddSorter(DownloadQuery::SortType type,
                               DownloadQuery::SortDirection direction) {
   switch (type) {
     case SORT_END_TIME:
       sorters_.push_back(Sorter::Build<int64_t>(direction, &GetEndTimeMsEpoch));
       break;
     case SORT_START_TIME:
       sorters_.push_back(
           Sorter::Build<int64_t>(direction, &GetStartTimeMsEpoch));
       break;
+    case SORT_ORIGINAL_URL:
+      sorters_.push_back(
+          Sorter::Build<std::string>(direction, &GetOriginalUrl));
+      break;
     case SORT_URL:
       sorters_.push_back(Sorter::Build<std::string>(direction, &GetUrl));
       break;
     case SORT_FILENAME:
       sorters_.push_back(
           Sorter::Build<base::string16>(direction, &GetFilename));
       break;
     case SORT_DANGER:
       sorters_.push_back(Sorter::Build<DownloadDangerType>(
           direction, &GetDangerType));
@@ skipping 27 matching lines @@
  if (!sorters_.empty()) {
     std::partial_sort(results->begin(),
                       results->begin() + std::min(limit_, results->size()),
                       results->end(),
                       DownloadComparator(sorters_));
   }
 
   if (results->size() > limit_)
     results->resize(limit_);
 }