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 102 matching lines @@
 }
 
 static std::string GetFilenameUTF8(const DownloadItem& item) {
   return base::UTF16ToUTF8(GetFilename(item));
 }
 
 static std::string GetUrl(const DownloadItem& item) {
   return item.GetOriginalUrl().spec();
 }
 
+static std::string GetFinalUrl(const DownloadItem& item) {

[asanka, 2016/02/18 15:32:27]

"static" unnecessary for functions defined within an anonymous namespace.

+  return item.GetURL().spec();
+}
+
 static DownloadItem::DownloadState GetState(const DownloadItem& item) {
   return item.GetState();
 }
 
 static DownloadDangerType GetDangerType(const DownloadItem& item) {
   return item.GetDangerType();
 }
 
 static int GetReceivedBytes(const DownloadItem& item) {
   return item.GetReceivedBytes();
@@ skipping 79 matching lines @@
 }  // 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;
+  base::string16 final_url_raw(base::UTF8ToUTF16(item.GetURL().spec()));
+  base::string16 final_url_formatted = final_url_raw;
   if (item.GetBrowserContext()) {
     Profile* profile = Profile::FromBrowserContext(item.GetBrowserContext());
     url_formatted = url_formatter::FormatUrl(
         item.GetOriginalUrl(),
         profile->GetPrefs()->GetString(prefs::kAcceptLanguages));
+    final_url_formatted = url_formatter::FormatUrl(
+        item.GetURL(), profile->GetPrefs()->GetString(prefs::kAcceptLanguages));
   }
   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, url_raw, NULL, NULL) &&
         !base::i18n::StringSearchIgnoringCaseAndAccents(
             term, url_formatted, NULL, NULL) &&
         !base::i18n::StringSearchIgnoringCaseAndAccents(
+            term, final_url_raw, NULL, NULL) &&
+        !base::i18n::StringSearchIgnoringCaseAndAccents(
+            term, final_url_formatted, NULL, NULL) &&
+        !base::i18n::StringSearchIgnoringCaseAndAccents(
             term, path, NULL, NULL)) {
       return false;
     }
   }
   return true;
 }
 
 DownloadQuery::DownloadQuery() : limit_(std::numeric_limits<uint32_t>::max()) {}
 DownloadQuery::~DownloadQuery() {}
 
@@ skipping 56 matching lines @@
     case FILTER_TOTAL_BYTES:
       return AddFilter(BuildFilter<int>(value, EQ, &GetTotalBytes));
     case FILTER_TOTAL_BYTES_GREATER:
       return AddFilter(BuildFilter<int>(value, GT, &GetTotalBytes));
     case FILTER_TOTAL_BYTES_LESS:
       return AddFilter(BuildFilter<int>(value, LT, &GetTotalBytes));
     case FILTER_URL:
       return AddFilter(BuildFilter<std::string>(value, EQ, &GetUrl));
     case FILTER_URL_REGEX:
       return AddFilter(BuildRegexFilter(value, &GetUrl));
+    case FILTER_FINAL_URL:
+      return AddFilter(BuildFilter<std::string>(value, EQ, &GetFinalUrl));
+    case FILTER_FINAL_URL_REGEX:
+      return AddFilter(BuildRegexFilter(value, &GetFinalUrl));
   }
   return false;
 }
 
 bool DownloadQuery::Matches(const DownloadItem& item) const {
   for (FilterCallbackVector::const_iterator filter = filters_.begin();
         filter != filters_.end(); ++filter) {
     if (!filter->Run(item))
       return false;
   }
@@ skipping 69 matching lines @@
     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_URL:
       sorters_.push_back(Sorter::Build<std::string>(direction, &GetUrl));
       break;
+    case SORT_FINAL_URL:
+      sorters_.push_back(Sorter::Build<std::string>(direction, &GetFinalUrl));
+      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));
       break;
     case SORT_DANGER_ACCEPTED:
       sorters_.push_back(Sorter::Build<bool>(direction, &GetDangerAccepted));
@@ skipping 24 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_);
 }