Implement chrome.downloads.onDeterminingFilename()

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 <algorithm>
 #include <cctype>
 #include <iterator>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_file_icon_extractor.h"
 #include "chrome/browser/download/download_query.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
+#include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/icon_loader.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/cancelable_task_tracker.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/api/downloads.h"
 #include "content/public/browser/download_interrupt_reasons.h"
@@ skipping 126 matching lines @@
 }
 
 DownloadItem::DownloadState StateEnumFromString(const std::string& state) {
   for (size_t i = 0; i < arraysize(kStateStrings); ++i) {
     if ((kStateStrings[i] != NULL) && (state == kStateStrings[i]))
       return static_cast<DownloadItem::DownloadState>(i);
   }
   return DownloadItem::MAX_DOWNLOAD_STATE;
 }
 
-bool ValidateFilename(const string16& filename) {
-  // TODO(benjhayden): More robust validation of filename.
-  if ((filename.find('/') != string16::npos) ||
-      (filename.find('\\') != string16::npos))
-    return false;
-  if (filename.size() >= 2u && filename[0] == L'.' && filename[1] == L'.')
-    return false;
-  return true;
+bool ValidateFilename(const FilePath& filename) {
+  return !filename.empty() &&
+         (filename.BaseName().value() != FilePath::kCurrentDirectory) &&
+         !filename.ReferencesParent() &&
+         !filename.IsAbsolute();
 }
 
 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);
 }
@@ skipping 51 matching lines @@
 };
 
 bool DownloadFileIconExtractorImpl::ExtractIconURLForPath(
     const FilePath& path,
     IconLoader::IconSize icon_size,
     IconURLCallback callback) {
   callback_ = callback;
   IconManager* im = g_browser_process->icon_manager();
   // The contents of the file at |path| may have changed since a previous
   // request, in which case the associated icon may also have changed.
-  // Therefore, for the moment we always call LoadIcon instead of attempting
-  // a LookupIcon.
+  // Therefore, always call LoadIcon instead of attempting a LookupIcon.
   im->LoadIcon(path,
                icon_size,
                base::Bind(&DownloadFileIconExtractorImpl::OnIconLoadComplete,
                           base::Unretained(this)),
                &cancelable_task_tracker_);
   return true;
 }
 
 void DownloadFileIconExtractorImpl::OnIconLoadComplete(gfx::Image* icon) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 125 matching lines @@
   // TODO(benjhayden): Consider switching from LazyInstance to explicit string
   // comparisons.
   static base::LazyInstance<SortTypeMap> sorter_types =
     LAZY_INSTANCE_INITIALIZER;
   if (sorter_types.Get().size() == 0)
     InitSortTypeMap(sorter_types.Get());
 
   std::vector<std::string> order_by_strs;
   base::SplitString(order_by_str, ' ', &order_by_strs);
   for (std::vector<std::string>::const_iterator iter = order_by_strs.begin();
-      iter != order_by_strs.end(); ++iter) {
+       iter != order_by_strs.end(); ++iter) {
     std::string term_str = *iter;
     if (term_str.empty())
       continue;
     DownloadQuery::SortDirection direction = DownloadQuery::ASCENDING;
     if (term_str[0] == '-') {
       direction = DownloadQuery::DESCENDING;
       term_str = term_str.substr(1);
     }
     SortTypeMap::const_iterator sorter_type =
         sorter_types.Get().find(term_str);
@@ skipping 114 matching lines @@
     base::SupportsUserData::Data* data = download_item->GetUserData(kKey);
     return (data == NULL) ? NULL :
         static_cast<ExtensionDownloadsEventRouterData*>(data);
   }
 
   explicit ExtensionDownloadsEventRouterData(
       DownloadItem* download_item,
       scoped_ptr<base::DictionaryValue> json_item)
       : updated_(0),
         changed_fired_(0),
-        json_(json_item.Pass()) {
+        json_(json_item.Pass()),
+        determiner_index_(-1),
+        determined_overwrite_(false) {
     download_item->SetUserData(kKey, this);
   }
 
   virtual ~ExtensionDownloadsEventRouterData() {
     if (updated_ > 0) {
       UMA_HISTOGRAM_PERCENTAGE("Download.OnChanged",
                                (changed_fired_ * 100 / updated_));
     }
   }
 
   const base::DictionaryValue& json() const { return *json_.get(); }
   void set_json(scoped_ptr<base::DictionaryValue> json_item) {
     json_ = json_item.Pass();
   }
 
   void OnItemUpdated() { ++updated_; }
   void OnChangedFired() { ++changed_fired_; }
 
+  void set_filename_change_callbacks(
+      const base::Closure& no_change,
+      const ExtensionDownloadsEventRouter::FilenameChangedCallback& change) {
+    filename_no_change_ = no_change;
+    filename_change_ = change;
+  }
+
+  void ClearPendingDeterminers() {
+    determiners_.clear();
+  }
+
+  void ExtensionUnloaded(const std::string& extension_id) {
+    if (determiners_.empty())

[Randy Smith (Not in Mondays), 2013/01/17 19:15:42]

When I first read through this, I spent a couple of minutes being confused about
why this statement was here, since a loop traversal should do nothing if the
list was empty.  I eventually realized that it was a guard against EDERDs that
weren't currently involved in a call out to extensions getting their callbacks
calls.  But I could easily imagine future code writers thinking it was an
optimization.  Comment?

[benjhayden, 2013/01/18 20:59:50]

Done.

+      return;
+    // Remove this extension from |determiners_|.
+    for (DeterminerInfoVector::iterator iter = determiners_.begin();
+         iter != determiners_.end();) {
+      if (iter->extension_id == extension_id) {
+        iter = determiners_.erase(iter);
+      } else {
+        ++iter;
+      }
+    }
+    CheckAllDeterminersCalled();
+  }
+
+  void AddPendingDeterminer(const std::string& extension_id,
+                            const std::string& sub_event_id,
+                            const base::Time& installed) {
+    determiners_.push_back(DeterminerInfo(
+        extension_id, sub_event_id, installed));
+  }
+
+  bool DeterminerCallback(
+      const std::string& extension_id,
+      const std::string& sub_event_id,
+      const FilePath& filename,
+      bool overwrite) {
+    bool filename_valid = ValidateFilename(filename);
+    bool found_info = false;
+    for (int index = 0; index < static_cast<int>(determiners_.size());
+         ++index) {
+      if ((determiners_[index].extension_id == extension_id) &&
+          (determiners_[index].sub_event_id == sub_event_id)) {
+        found_info = true;
+        DCHECK(!determiners_[index].reported);
+        determiners_[index].reported = true;
+        DCHECK_NE(index, determiner_index_);
+        // Do not use filename if another determiner has already overridden the
+        // filename and they take precedence. Extensions that were installed
+        // later take precedence over previous extensions, and listeners that
+        // were added later take precedence over previous listeners.
+        if (filename_valid &&
+            ((determiner_index_ < 0) ||
+             ((determiners_[index].extension_id ==
+               determiners_[determiner_index_].extension_id) ?
+              (determiners_[index].sub_event_id >
+               determiners_[determiner_index_].sub_event_id) :
+              (determiners_[index].install_time >
+               determiners_[determiner_index_].install_time)))) {
+          determined_filename_ = filename;
+          determined_overwrite_ = overwrite;
+          determiner_index_ = index;
+        }
+      }
+    }
+    if (!found_info)
+      return false;
+    CheckAllDeterminersCalled();
+    return filename.empty() || filename_valid;
+  }
+
  private:
+  struct DeterminerInfo {
+    DeterminerInfo(const std::string& e_id,
+                   const std::string& sub_id,
+                   const base::Time& installed);
+    ~DeterminerInfo();
+
+    std::string extension_id;
+    std::string sub_event_id;
+    base::Time install_time;
+    bool reported;
+  };
+  typedef std::vector<DeterminerInfo> DeterminerInfoVector;
+
   static const char kKey[];
 
+  void CheckAllDeterminersCalled() {
+    for (DeterminerInfoVector::iterator iter = determiners_.begin();
+         iter != determiners_.end(); ++iter) {
+      if (!iter->reported)
+        return;
+    }
+    ClearPendingDeterminers();
+    if (determined_filename_.empty()) {
+      filename_no_change_.Run();
+    } else {
+      filename_change_.Run(determined_filename_, determined_overwrite_);
+    }
+  }
+
   int updated_;
   int changed_fired_;
   scoped_ptr<base::DictionaryValue> json_;
 
+  base::Closure filename_no_change_;
+  ExtensionDownloadsEventRouter::FilenameChangedCallback filename_change_;
+
+  DeterminerInfoVector determiners_;
+
+  int determiner_index_;
+  FilePath determined_filename_;

[Randy Smith (Not in Mondays), 2013/01/17 19:15:42]

I may have missed it, but where do you reset these values?  I'm specifically
thinking of the interrupt->resume case where we call back into this code; if
determiner_index_ is somewhat high, won't that result in results from some
extensions being dropped on the floor?  And if the second time through no-one
overrides, won't we re-use determined_filename_?

[benjhayden, 2013/01/18 20:59:50]

Good catch. Added that to right after where filename_change_ is run.

+  bool determined_overwrite_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionDownloadsEventRouterData);
 };
 
+ExtensionDownloadsEventRouterData::DeterminerInfo::DeterminerInfo(
+    const std::string& e_id,
+    const std::string& sub_id,
+    const base::Time& installed)
+    : extension_id(e_id),
+      sub_event_id(sub_id),
+      install_time(installed),
+      reported(false) {
+}
+
+ExtensionDownloadsEventRouterData::DeterminerInfo::~DeterminerInfo() {}
+
 const char ExtensionDownloadsEventRouterData::kKey[] =
   "DownloadItem ExtensionDownloadsEventRouterData";
 
 class ManagerDestructionObserver : public DownloadManager::Observer {
  public:
   static void CheckForHistoryFilesRemoval(DownloadManager* manager) {
     if (!manager)
       return;
     if (!manager_file_existence_last_checked_)
       manager_file_existence_last_checked_ =
@@ skipping 42 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ManagerDestructionObserver);
 };
 
 std::map<DownloadManager*, ManagerDestructionObserver*>*
   ManagerDestructionObserver::manager_file_existence_last_checked_ = NULL;
 
 }  // namespace
 
 DownloadsDownloadFunction::DownloadsDownloadFunction() {}
+
 DownloadsDownloadFunction::~DownloadsDownloadFunction() {}
 
 bool DownloadsDownloadFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Download::Params> params(
       extensions::api::downloads::Download::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const extensions::api::downloads::DownloadOptions& options = params->options;
   GURL download_url(options.url);
   if (!download_url.is_valid() ||
       (!download_url.SchemeIs("data") &&
@@ skipping 16 matching lines @@
 
   if (options.filename.get()) {
     // TODO(benjhayden): Make json_schema_compiler generate string16s instead of
     // std::strings. Can't get filename16 from options.ToValue() because that
     // converts it from std::string.
     base::DictionaryValue* options_value = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options_value));
     string16 filename16;
     EXTENSION_FUNCTION_VALIDATE(options_value->GetString(
         kFilenameKey, &filename16));
-    if (!ValidateFilename(filename16)) {
+#if defined(OS_WIN)
+    FilePath file_path(filename16);

[Randy Smith (Not in Mondays), 2013/01/17 19:15:42]

nit: Move everything that's only relevant to creating filename16 inside the if,
to make the conditionalization clearer.

[benjhayden, 2013/01/18 20:59:50]

No, filename16 is used on L803 of this PS.

+#elif defined(OS_POSIX)
+    FilePath file_path(*options.filename.get());
+#endif
+    if (!ValidateFilename(file_path) ||
+        (file_path.DirName().value() != FilePath::kCurrentDirectory)) {
       error_ = download_extension_errors::kGenericError;
       return false;
     }
     // TODO(benjhayden) Ensure that this filename is interpreted as a path
     // relative to the default downloads directory without allowing '..'.
     download_params->set_suggested_name(filename16);
   }
 
   if (options.save_as.get())
     download_params->set_prompt(*options.save_as.get());
@@ skipping 39 matching lines @@
     DCHECK_EQ(net::OK, error);
     SetResult(base::Value::CreateIntegerValue(item->GetId()));
   } else {
     DCHECK_NE(net::OK, error);
     error_ = net::ErrorToString(error);
   }
   SendResponse(error_.empty());
 }
 
 DownloadsSearchFunction::DownloadsSearchFunction() {}
+
 DownloadsSearchFunction::~DownloadsSearchFunction() {}
 
 bool DownloadsSearchFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Search::Params> params(
       extensions::api::downloads::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
   GetManagers(profile(), include_incognito(), &manager, &incognito_manager);
   ManagerDestructionObserver::CheckForHistoryFilesRemoval(manager);
@@ skipping 17 matching lines @@
     scoped_ptr<base::DictionaryValue> json_item(DownloadItemToJSON(
         *it, off_record));
     json_results->Append(json_item.release());
   }
   SetResult(json_results);
   RecordApiFunctions(DOWNLOADS_FUNCTION_SEARCH);
   return true;
 }
 
 DownloadsPauseFunction::DownloadsPauseFunction() {}
+
 DownloadsPauseFunction::~DownloadsPauseFunction() {}
 
 bool DownloadsPauseFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Pause::Params> params(
       extensions::api::downloads::Pause::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownloadIfInProgress(
       profile(), include_incognito(), params->download_id);
   if (download_item == NULL) {
     // This could be due to an invalid download ID, or it could be due to the
     // download not being currently active.
     error_ = download_extension_errors::kInvalidOperationError;
   } else {
     // If the item is already paused, this is a no-op and the
     // operation will silently succeed.
     download_item->Pause();
   }
   if (error_.empty())
     RecordApiFunctions(DOWNLOADS_FUNCTION_PAUSE);
   return error_.empty();
 }
 
 DownloadsResumeFunction::DownloadsResumeFunction() {}
+
 DownloadsResumeFunction::~DownloadsResumeFunction() {}
 
 bool DownloadsResumeFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Resume::Params> params(
       extensions::api::downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownloadIfInProgress(
       profile(), include_incognito(), params->download_id);
   if (download_item == NULL) {
     // This could be due to an invalid download ID, or it could be due to the
     // download not being currently active.
     error_ = download_extension_errors::kInvalidOperationError;
   } else {
     // Note that if the item isn't paused, this will be a no-op, and
-    // we will silently treat the extension call as a success.
+    // the extension call will seem successful.
     download_item->Resume();
   }
   if (error_.empty())
     RecordApiFunctions(DOWNLOADS_FUNCTION_RESUME);
   return error_.empty();
 }
 
 DownloadsCancelFunction::DownloadsCancelFunction() {}
+
 DownloadsCancelFunction::~DownloadsCancelFunction() {}
 
 bool DownloadsCancelFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Resume::Params> params(
       extensions::api::downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownloadIfInProgress(
       profile(), include_incognito(), params->download_id);
   if (download_item != NULL)
     download_item->Cancel(true);
   // |download_item| can be NULL if the download ID was invalid or if the
-  // download is not currently active.  Either way, we don't consider it a
-  // failure.
+  // download is not currently active.  Either way, it's not a failure.
   RecordApiFunctions(DOWNLOADS_FUNCTION_CANCEL);
   return true;
 }
 
 DownloadsEraseFunction::DownloadsEraseFunction() {}
+
 DownloadsEraseFunction::~DownloadsEraseFunction() {}
 
 bool DownloadsEraseFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Erase::Params> params(
       extensions::api::downloads::Erase::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
   GetManagers(profile(), include_incognito(), &manager, &incognito_manager);
   DownloadQuery::DownloadVector results;
   RunDownloadQuery(params->query,
                    manager,
                    incognito_manager,
                    &error_,
                    &results);
   if (!error_.empty())
     return false;
   base::ListValue* json_results = new base::ListValue();
   for (DownloadManager::DownloadVector::const_iterator it = results.begin();
        it != results.end(); ++it) {
     json_results->Append(base::Value::CreateIntegerValue((*it)->GetId()));
     (*it)->Remove();
   }
   SetResult(json_results);
   RecordApiFunctions(DOWNLOADS_FUNCTION_ERASE);
   return true;
 }
 
-DownloadsSetDestinationFunction::DownloadsSetDestinationFunction() {}
-DownloadsSetDestinationFunction::~DownloadsSetDestinationFunction() {}
+DownloadsAcceptDangerFunction::DownloadsAcceptDangerFunction() {}
 
-bool DownloadsSetDestinationFunction::RunImpl() {
-  scoped_ptr<extensions::api::downloads::SetDestination::Params> params(
-      extensions::api::downloads::SetDestination::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-  error_ = download_extension_errors::kNotImplementedError;
-  if (error_.empty())
-    RecordApiFunctions(DOWNLOADS_FUNCTION_SET_DESTINATION);
-  return error_.empty();
-}
-
-DownloadsAcceptDangerFunction::DownloadsAcceptDangerFunction() {}
 DownloadsAcceptDangerFunction::~DownloadsAcceptDangerFunction() {}
 
 bool DownloadsAcceptDangerFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::AcceptDanger::Params> params(
       extensions::api::downloads::AcceptDanger::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   error_ = download_extension_errors::kNotImplementedError;
   if (error_.empty())
     RecordApiFunctions(DOWNLOADS_FUNCTION_ACCEPT_DANGER);
   return error_.empty();
 }
 
 DownloadsShowFunction::DownloadsShowFunction() {}
+
 DownloadsShowFunction::~DownloadsShowFunction() {}
 
 bool DownloadsShowFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Show::Params> params(
       extensions::api::downloads::Show::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownload(
       profile(), include_incognito(), params->download_id);
   if (!download_item) {
     error_ = download_extension_errors::kInvalidOperationError;
     return false;
   }
   download_item->ShowDownloadInShell();
   RecordApiFunctions(DOWNLOADS_FUNCTION_SHOW);
   return true;
 }
 
 DownloadsOpenFunction::DownloadsOpenFunction() {}
+
 DownloadsOpenFunction::~DownloadsOpenFunction() {}
 
 bool DownloadsOpenFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Open::Params> params(
       extensions::api::downloads::Open::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownload(
       profile(), include_incognito(), params->download_id);
   if (!download_item || !download_item->IsComplete()) {
     error_ = download_extension_errors::kInvalidOperationError;
     return false;
   }
   download_item->OpenDownload();
   RecordApiFunctions(DOWNLOADS_FUNCTION_OPEN);
   return true;
 }
 
 DownloadsDragFunction::DownloadsDragFunction() {}
+
 DownloadsDragFunction::~DownloadsDragFunction() {}
 
 bool DownloadsDragFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Drag::Params> params(
       extensions::api::downloads::Drag::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownload(
       profile(), include_incognito(), params->download_id);
   content::WebContents* web_contents =
       dispatcher()->delegate()->GetAssociatedWebContents();
@@ skipping 34 matching lines @@
   int icon_size = kDefaultIconSize;
   if (options && options->size.get())
     icon_size = *options->size.get();
   DownloadItem* download_item = GetDownload(
       profile(), include_incognito(), params->download_id);
   if (!download_item || download_item->GetTargetFilePath().empty()) {
     error_ = download_extension_errors::kInvalidOperationError;
     return false;
   }
   // In-progress downloads return the intermediate filename for GetFullPath()
-  // which doesn't have the final extension. Therefore we won't be able to
-  // derive a good file icon for it. So we use GetTargetFilePath() instead.
+  // which doesn't have the final extension. Therefore a good file icon can't be
+  // found, so use GetTargetFilePath() instead.
   DCHECK(icon_extractor_.get());
   DCHECK(icon_size == 16 || icon_size == 32);
   EXTENSION_FUNCTION_VALIDATE(icon_extractor_->ExtractIconURLForPath(
       download_item->GetTargetFilePath(),
       IconLoaderSizeFromPixelSize(icon_size),
       base::Bind(&DownloadsGetFileIconFunction::OnIconURLExtracted, this)));
   return true;
 }
 
 void DownloadsGetFileIconFunction::OnIconURLExtracted(const std::string& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (url.empty()) {
     error_ = download_extension_errors::kIconNotFoundError;
   } else {
     RecordApiFunctions(DOWNLOADS_FUNCTION_GET_FILE_ICON);
     SetResult(base::Value::CreateStringValue(url));
   }
   SendResponse(error_.empty());
 }
 
+// The method by which extensions hook into the filename determination process
+// is based on the method by which the webRequest API allows extensions to hook
+// into the resource loading process.  Extensions that wish to play a part in
+// the filename determination process call
+// chrome.downloads.onDeterminingFilename.addListener, which secretly (see
+// chrome/renderer/resources/extensions/downloads_custom_bindings.js) calls
+// DownloadsInternalAddFilenameDeterminerFunction (see ../downloads_internal/),
+// which adds the extension's ID to the profile's ExtensionDownloadsEventRouter
+// (EDER).
+//
+// When a download's filename is being determined,
+// ChromeDownloadManagerDelegate::CheckVisitedReferrerBeforeDone (CVRBD) passes
+// 2 callbacks to EDER::OnDownloadFilenameDetermined (ODFD), which stores the
+// callbacks in the item's ExtensionDownloadsEventRouterData (EDERD) along with
+// all of the extension IDs that are listening for onDeterminingFilename events.
+// ODFD dispatches chrome.downloads.onDeterminingFilename.
+//
+// When the extension's event handler returns, downloads_custom_bindings.js
+// calls DownloadsInternalDetermineFilenameFunction::RunImpl, which notifies the
+// item's EDERD.
+//
+// When the last extension's event handler returns, EDERD calls one of the two
+// callbacks that CVRBD passed to ODFD, allowing CDMD to complete the filename
+// determination process. If multiple extensions wish to override the filename,
+// then the extension that was last installed wins; if multiple determiners
+// within an extension compete, then the determiner that was last added wins.
+
+bool ExtensionDownloadsEventRouter::AddFilenameDeterminer(
+    Profile* profile,
+    const std::string& ext_id,
+    const std::string& sub_event_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // Only incognito/regular renderer processes receive onDeterminingFilename
+  // events for incognito/regular downloads.  Do not automatically add this

[Randy Smith (Not in Mondays), 2013/01/17 19:15:42]

So this seems weird to me.  My understanding (please correct if wrong) is that
everywhere else we give incognito extension full and symmetric visibility to
both incognito and regular downloads (within that profile).  But it sounds like
here we're breaking that symmetry and only allowing interposition for filename
determination for non-incognito profiles by non-incognito extensions.  Why?

[benjhayden, 2013/01/18 20:59:50]

Nope, when incognito extensions' renderers call
onDeterminingFilename.addListener, the |profile| that is passed here is the
incognito profile, so it'll use the incognito EDER.

I agree, it does feel a little weird how onDeterminingFIlename works with
incognito differently from how the other events work with incognito, but
onDeterminingFilename does everything else differently, too.

[Randy Smith (Not in Mondays), 2013/01/22 19:43:08]

Sounds good.  As discussed offline, could you:
* Convince yourself that this pattern (probes from incognito extensions seeing
both regular and incognito data, but inserted listeners just getting events from
their profile) is common and well understood among extensions.
* Failing that, check in with someone Wise In the Ways of Extensions to confirm
it makes sense to do it this way, and make sure to document it in the extensions
API documentation?

+  // determiner to the other (incognito/regular) EDER; if the extension wants to
+  // listen for onDeterminingFilename in those extension renderer processes,
+  // then it will call addListener there, and |profile| will be
+  // incognito/regular for those addListener calls, so they will use the
+  // incognito/regular EDER.
+  ExtensionDownloadsEventRouter* router =
+      DownloadServiceFactory::GetForProfile(profile)->GetExtensionEventRouter();
+  if (!router)
+    return false;
+  for (DeterminerVector::const_iterator iter = router->determiners_.begin();
+       iter != router->determiners_.end(); ++iter) {
+    if (iter->extension_id == ext_id) {
+      DCHECK_NE(iter->sub_event_id, sub_event_id);
+    }
+    if ((iter->extension_id == ext_id) &&
+        (iter->sub_event_id == sub_event_id))
+      return false;
+  }
+  router->determiners_.push_back(DeterminerId(ext_id, sub_event_id));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
+      &ExtensionDownloadsEventRouter::GetInstallTime,
+      ext_id,
+      scoped_refptr<ExtensionInfoMap>(
+          extensions::ExtensionSystem::Get(profile)->info_map()),
+      &router->determiners_[router->determiners_.size() - 1].installed));
+  return true;
+}
+
+void ExtensionDownloadsEventRouter::GetInstallTime(
+    const std::string& ext_id,
+    ExtensionInfoMap* info_map,
+    base::Time* install_time) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  *install_time = info_map->GetInstallTime(ext_id);
+}
+
+ExtensionDownloadsEventRouter::DeterminerId::DeterminerId(

[Randy Smith (Not in Mondays), 2013/01/17 19:15:42]

So there's an officially sanctioned order for methods, which is the same in the
.cc file as it is in the .h file.  I'm not neurotic about that; if there's some
other order that makes sense, go for it.  But I don't see why interrupting the
EDER methods in order to put in some trivial methods for EDER::DeterminerId
would count?

[benjhayden, 2013/01/18 20:59:50]

Done.

+    const std::string& ext_id,
+    const std::string& sub_id)
+    : extension_id(ext_id),
+      sub_event_id(sub_id) {
+}
+
+ExtensionDownloadsEventRouter::DeterminerId::~DeterminerId() {}
+
+bool ExtensionDownloadsEventRouter::RemoveFilenameDeterminer(
+    Profile* profile,
+    const std::string& ext_id,
+    const std::string& sub_event_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ExtensionDownloadsEventRouter* router =
+      DownloadServiceFactory::GetForProfile(profile)->GetExtensionEventRouter();
+  for (DeterminerVector::iterator iter = router->determiners_.begin();
+       iter != router->determiners_.end(); ++iter) {
+    if (iter->extension_id == ext_id && iter->sub_event_id == sub_event_id) {
+      router->determiners_.erase(iter);
+      return true;
+    }
+  }
+  DCHECK(false) << ext_id << " " << sub_event_id;
+  return false;
+}
+
+bool ExtensionDownloadsEventRouter::DetermineFilename(
+    Profile* profile,
+    bool include_incognito,
+    const std::string& ext_id,
+    const std::string& sub_event_id,
+    int download_id,
+    const FilePath& filename,
+    bool overwrite) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DownloadItem* item = GetDownloadIfInProgress(
+      profile, include_incognito, download_id);
+  if (!item)
+    return false;
+  ExtensionDownloadsEventRouterData* data =
+      ExtensionDownloadsEventRouterData::Get(item);
+  if (!data)
+    return false;
+  return data->DeterminerCallback(ext_id, sub_event_id, filename, overwrite);
+}
+
 ExtensionDownloadsEventRouter::ExtensionDownloadsEventRouter(
     Profile* profile,
     DownloadManager* manager)
     : profile_(profile),
       ALLOW_THIS_IN_INITIALIZER_LIST(notifier_(manager, this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile_);
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::Source<Profile>(profile_));
+}
+
+void ExtensionDownloadsEventRouter::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
+      const extensions::Extension* extension = content::Details<
+          extensions::UnloadedExtensionInfo>(details)->extension;
+      // Remove this extension from |determiners_|.
+      for (DeterminerVector::iterator iter = determiners_.begin();
+           iter != determiners_.end();) {
+        if (iter->extension_id == extension->id()) {
+          iter = determiners_.erase(iter);
+        } else {
+          ++iter;
+        }
+      }
+      // Notify any items that may be waiting for callbacks from this extension.
+      DownloadManager* manager = notifier_.GetManager();
+      if (manager) {
+        DownloadManager::DownloadVector items;
+        manager->GetAllDownloads(&items);
+        for (DownloadManager::DownloadVector::const_iterator iter =
+             items.begin();
+             iter != items.end(); ++iter) {
+          ExtensionDownloadsEventRouterData* data =
+              ExtensionDownloadsEventRouterData::Get(*iter);
+          if (data)
+            data->ExtensionUnloaded(extension->id());
+        }
+      }
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
+  }
 }
 
 ExtensionDownloadsEventRouter::~ExtensionDownloadsEventRouter() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadCreated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsTemporary())
     return;
 
   scoped_ptr<base::DictionaryValue> json_item(
       DownloadItemToJSON(download_item, profile_->IsOffTheRecord()));
   DispatchEvent(extensions::event_names::kOnDownloadCreated,
+                true,
                 json_item->DeepCopy());
   if (!ExtensionDownloadsEventRouterData::Get(download_item))
     new ExtensionDownloadsEventRouterData(download_item, json_item.Pass());
 }
 
+void ExtensionDownloadsEventRouter::OnDownloadFilenameDetermined(
+    DownloadItem* item,
+    const FilePath& suggested_path,
+    const base::Closure& no_change,
+    const FilenameChangedCallback& change) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (determiners_.empty()) {
+    no_change.Run();
+    return;
+  }
+
+  ExtensionDownloadsEventRouterData* data =
+      ExtensionDownloadsEventRouterData::Get(item);
+  data->set_filename_change_callbacks(no_change, change);
+  data->ClearPendingDeterminers();
+  std::set<std::string> sub_events;
+  for (DeterminerVector::const_iterator iter = determiners_.begin();
+       iter != determiners_.end(); ++iter) {
+    data->AddPendingDeterminer(iter->extension_id,
+                               iter->sub_event_id,
+                               iter->installed);
+    sub_events.insert(iter->sub_event_id);
+  }
+  std::string event_name(
+      extensions::event_names::kOnDownloadDeterminingFilename);
+  event_name += "/";
+  for (std::set<std::string>::const_iterator iter = sub_events.begin();
+       iter != sub_events.end(); ++iter) {
+    base::DictionaryValue* json = DownloadItemToJSON(
+        item, profile_->IsOffTheRecord()).release();
+    json->SetString(kFilenameKey, suggested_path.LossyDisplayName());
+    // If there's a listener in an incognito extension renderer, then it will
+    // have registered its own determiner in the incognito EDER, which will be
+    // called for incognito downloads.
+    DispatchEvent((event_name + (*iter)).c_str(), false, json);
+  }
+}
+
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsTemporary())
     return;
 
   ExtensionDownloadsEventRouterData* data =
     ExtensionDownloadsEventRouterData::Get(download_item);
   if (!data) {
     // The download_item probably transitioned from temporary to not temporary.
     OnDownloadCreated(manager, download_item);
     return;
   }
   scoped_ptr<base::DictionaryValue> new_json(DownloadItemToJSON(
-        download_item, profile_->IsOffTheRecord()));
+      download_item, profile_->IsOffTheRecord()));
   scoped_ptr<base::DictionaryValue> delta(new base::DictionaryValue());
   delta->SetInteger(kIdKey, download_item->GetId());
   std::set<std::string> new_fields;
   bool changed = false;
 
   // For each field in the new json representation of the download_item except
   // the bytesReceived field, if the field has changed from the previous old
   // json, set the differences in the |delta| object and remember that something
   // significant changed.
   for (base::DictionaryValue::Iterator iter(*new_json.get());
@@ skipping 19 matching lines @@
     if (new_fields.find(iter.key()) == new_fields.end()) {
       delta->Set(iter.key() + ".previous", iter.value().DeepCopy());
       changed = true;
     }
   }
 
   // Update the OnChangedStat and dispatch the event if something significant
   // changed. Replace the stored json with the new json.
   data->OnItemUpdated();
   if (changed) {
-    DispatchEvent(extensions::event_names::kOnDownloadChanged, delta.release());
+    DispatchEvent(extensions::event_names::kOnDownloadChanged,
+                  true,
+                  delta.release());
     data->OnChangedFired();
   }
   data->set_json(new_json.Pass());
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadRemoved(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsTemporary())
     return;
   DispatchEvent(extensions::event_names::kOnDownloadErased,
+                true,
                 base::Value::CreateIntegerValue(download_item->GetId()));
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
-    const char* event_name, base::Value* arg) {
+    const char* event_name, bool include_incognito, base::Value* arg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg);
   std::string json_args;
   base::JSONWriter::Write(args.get(), &json_args);
   // There is a one EDER for each on-record Profile, and a separate EDER for
   // each off-record Profile, so there is exactly one EDER for each
   // DownloadManager.  EDER only watches its own DM, so all the items that an
-  // EDER sees are either all on-record or all off-record. However, we want
-  // extensions in off-record contexts to see on-record items. So, if this EDER
-  // is watching an on-record DM, and there is a corresponding off-record
-  // Profile, then dispatch this event to both the on-record Profile and the
-  // off-record Profile.  There may or may not be an off-record Profile, so send
-  // a *copy* of |args| to the off-record Profile, and Pass() |args|
-  // to the Profile that we know is there.
-  if (profile_->HasOffTheRecordProfile() &&
+  // EDER sees are either all on-record or all off-record. However, extensions
+  // in off-record contexts should see on-record items. So, if this EDER is
+  // watching an on-record DM, and there is a corresponding off-record Profile,
+  // then dispatch this event to both the on-record Profile and the off-record
+  // Profile.  There may or may not be an off-record Profile, so send a *copy*
+  // of |args| to the off-record Profile, and Pass() |args| to the Profile that
+  // is certainly there.
+  if (include_incognito &&
+      profile_->HasOffTheRecordProfile() &&
       !profile_->IsOffTheRecord()) {
     DispatchEventInternal(
         profile_->GetOffTheRecordProfile(),
         event_name,
         json_args,
         scoped_ptr<base::ListValue>(args->DeepCopy()));
   }
   DispatchEventInternal(profile_, event_name, json_args, args.Pass());
 }