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

chrome/browser/extensions/api/downloads/downloads_api.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/extensions/api/downloads/downloads_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <set>
@@ skipping 155 matching lines @@
 const char kStartedBeforeKey[] = "startedBefore";
 const char kStateComplete[] = "complete";
 const char kStateInProgress[] = "in_progress";
 const char kStateInterrupted[] = "interrupted";
 const char kStateKey[] = "state";
 const char kTotalBytesGreaterKey[] = "totalBytesGreater";
 const char kTotalBytesKey[] = "totalBytes";
 const char kTotalBytesLessKey[] = "totalBytesLess";
 const char kUrlKey[] = "url";
 const char kUrlRegexKey[] = "urlRegex";
+const char kFinalUrlKey[] = "finalUrl";
+const char kFinalUrlRegexKey[] = "finalUrlRegex";
 
 // Note: Any change to the danger type strings, should be accompanied by a
 // corresponding change to downloads.json.
 const char* const kDangerStrings[] = {
   kDangerSafe,
   kDangerFile,
   kDangerUrl,
   kDangerContent,
   kDangerSafe,
   kDangerUncommon,
@@ skipping 61 matching lines @@
 }
 
 std::unique_ptr<base::DictionaryValue> DownloadItemToJSON(
     DownloadItem* download_item,
     Profile* profile) {
   base::DictionaryValue* json = new base::DictionaryValue();
   json->SetBoolean(kExistsKey, !download_item->GetFileExternallyRemoved());
   json->SetInteger(kIdKey, download_item->GetId());
   const GURL& url = download_item->GetOriginalUrl();
   json->SetString(kUrlKey, (url.is_valid() ? url.spec() : std::string()));
+  const GURL& finalUrl = download_item->GetURL();
+  json->SetString(kFinalUrlKey,
+                  (finalUrl.is_valid() ? finalUrl.spec() : std::string()));
   const GURL& referrer = download_item->GetReferrerUrl();
   json->SetString(kReferrerUrlKey, (referrer.is_valid() ? referrer.spec()
                                                         : std::string()));
   json->SetString(kFilenameKey,
                   download_item->GetTargetFilePath().LossyDisplayName());
   json->SetString(kDangerKey, DangerString(download_item->GetDangerType()));
   json->SetString(kStateKey, StateString(download_item->GetState()));
   json->SetBoolean(kCanResumeKey, download_item->CanResume());
   json->SetBoolean(kPausedKey, download_item->IsPaused());
   json->SetString(kMimeKey, download_item->GetMimeType());
@@ skipping 101 matching lines @@
   filter_types[kEndedAfterKey] = DownloadQuery::FILTER_ENDED_AFTER;
   filter_types[kEndedBeforeKey] = DownloadQuery::FILTER_ENDED_BEFORE;
   filter_types[kEndTimeKey] = DownloadQuery::FILTER_END_TIME;
   filter_types[kStartedAfterKey] = DownloadQuery::FILTER_STARTED_AFTER;
   filter_types[kStartedBeforeKey] = DownloadQuery::FILTER_STARTED_BEFORE;
   filter_types[kStartTimeKey] = DownloadQuery::FILTER_START_TIME;
   filter_types[kTotalBytesKey] = DownloadQuery::FILTER_TOTAL_BYTES;
   filter_types[kTotalBytesGreaterKey] =
     DownloadQuery::FILTER_TOTAL_BYTES_GREATER;
   filter_types[kTotalBytesLessKey] = DownloadQuery::FILTER_TOTAL_BYTES_LESS;
-  filter_types[kUrlKey] = DownloadQuery::FILTER_URL;
-  filter_types[kUrlRegexKey] = DownloadQuery::FILTER_URL_REGEX;
+  filter_types[kUrlKey] = DownloadQuery::FILTER_ORIGINAL_URL;
+  filter_types[kUrlRegexKey] = DownloadQuery::FILTER_ORIGINAL_URL_REGEX;
+  filter_types[kFinalUrlKey] = DownloadQuery::FILTER_URL;
+  filter_types[kFinalUrlRegexKey] = DownloadQuery::FILTER_URL_REGEX;
 }
 
 typedef base::hash_map<std::string, DownloadQuery::SortType> SortTypeMap;
 
 void InitSortTypeMap(SortTypeMap* sorter_types_ptr) {
   SortTypeMap& sorter_types = *sorter_types_ptr;
   sorter_types[kBytesReceivedKey] = DownloadQuery::SORT_BYTES_RECEIVED;
   sorter_types[kDangerKey] = DownloadQuery::SORT_DANGER;
   sorter_types[kEndTimeKey] = DownloadQuery::SORT_END_TIME;
   sorter_types[kExistsKey] = DownloadQuery::SORT_EXISTS;
   sorter_types[kFilenameKey] = DownloadQuery::SORT_FILENAME;
   sorter_types[kMimeKey] = DownloadQuery::SORT_MIME;
   sorter_types[kPausedKey] = DownloadQuery::SORT_PAUSED;
   sorter_types[kStartTimeKey] = DownloadQuery::SORT_START_TIME;
   sorter_types[kStateKey] = DownloadQuery::SORT_STATE;
   sorter_types[kTotalBytesKey] = DownloadQuery::SORT_TOTAL_BYTES;
-  sorter_types[kUrlKey] = DownloadQuery::SORT_URL;
+  sorter_types[kUrlKey] = DownloadQuery::SORT_ORIGINAL_URL;
+  sorter_types[kFinalUrlKey] = DownloadQuery::SORT_URL;
 }
 
 bool IsNotTemporaryDownloadFilter(const DownloadItem& download_item) {
   return !download_item.IsTemporary();
 }
 
 // Set |manager| to the on-record DownloadManager, and |incognito_manager| to
 // the off-record DownloadManager if one exists and is requested via
 // |include_incognito|. This should work regardless of whether |profile| is
 // original or incognito.
@@ skipping 492 matching lines @@
   *message_out = message_in;
   return true;
 }
 
 bool InvalidId(DownloadItem* valid_item, std::string* message_out) {
   return Fault(!valid_item, errors::kInvalidId, message_out);
 }
 
 bool IsDownloadDeltaField(const std::string& field) {
   return ((field == kUrlKey) ||
+          (field == kFinalUrlKey) ||
           (field == kFilenameKey) ||
           (field == kDangerKey) ||
           (field == kMimeKey) ||
           (field == kStartTimeKey) ||
           (field == kEndTimeKey) ||
           (field == kStateKey) ||
           (field == kCanResumeKey) ||
           (field == kPausedKey) ||
           (field == kErrorKey) ||
           (field == kTotalBytesKey) ||
@@ skipping 983 matching lines @@
     return;
   base::Time now(base::Time::Now());
   int delta = now.ToTimeT() - last_checked_removal_.ToTimeT();
   if (delta <= kFileExistenceRateLimitSeconds)
     return;
   last_checked_removal_ = now;
   manager->CheckForHistoryFilesRemoval();
 }
 
 }  // namespace extensions