Warn when extensions suggest conflicting download filenames

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>
@@ skipping 26 matching lines @@
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_shelf.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_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/extension_warning_service.h"
+#include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/icon_loader.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/cancelable_task_tracker.h"
 #include "chrome/common/extensions/api/downloads.h"
@@ skipping 528 matching lines @@
   explicit ExtensionDownloadsEventRouterData(
       DownloadItem* download_item,
       scoped_ptr<base::DictionaryValue> json_item)
       : updated_(0),
         changed_fired_(0),
         json_(json_item.Pass()),
         creator_conflict_action_(
             extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY),
         determined_conflict_action_(
             extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     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) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     filename_no_change_ = no_change;
     filename_change_ = change;
     determined_filename_ = creator_suggested_filename_;
     determined_conflict_action_ = creator_conflict_action_;
     // determiner_.install_time should default to 0 so that creator suggestions
     // should be lower priority than any actual onDeterminingFilename listeners.
   }
 
   void ClearPendingDeterminers() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     determined_filename_.clear();
     determined_conflict_action_ =
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY;
     determiner_ = DeterminerInfo();
     filename_no_change_ = base::Closure();
     filename_change_ = ExtensionDownloadsEventRouter::FilenameChangedCallback();
     weak_ptr_factory_.reset();
     determiners_.clear();
   }
 
   void DeterminerRemoved(const std::string& extension_id) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     for (DeterminerInfoVector::iterator iter = determiners_.begin();
          iter != determiners_.end();) {
       if (iter->extension_id == extension_id) {
         iter = determiners_.erase(iter);
       } else {
         ++iter;
       }
     }
     // If we just removed the last unreported determiner, then we need to call a
     // callback.
     CheckAllDeterminersCalled();
   }
 
   void AddPendingDeterminer(const std::string& extension_id,
                             const base::Time& installed) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     for (size_t index = 0; index < determiners_.size(); ++index) {
       if (determiners_[index].extension_id == extension_id) {
         DCHECK(false) << extension_id;
         return;
       }
     }
     determiners_.push_back(DeterminerInfo(extension_id, installed));
   }
 
   bool DeterminerAlreadyReported(const std::string& extension_id) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     for (size_t index = 0; index < determiners_.size(); ++index) {
       if (determiners_[index].extension_id == extension_id) {
         return determiners_[index].reported;
       }
     }
     return false;
   }
 
   void CreatorSuggestedFilename(
       const base::FilePath& filename,
       extensions::api::downloads::FilenameConflictAction conflict_action) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     creator_suggested_filename_ = filename;
     creator_conflict_action_ = conflict_action;
   }
 
   base::FilePath creator_suggested_filename() const {
     return creator_suggested_filename_;
   }
 
   extensions::api::downloads::FilenameConflictAction
   creator_conflict_action() const {
     return creator_conflict_action_;
   }
 
   void ResetCreatorSuggestion() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     creator_suggested_filename_.clear();
     creator_conflict_action_ =
       extensions::api::downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY;
   }
 
   // Returns false if this |extension_id| was not expected or if this
   // |extension_id| has already reported. The caller is responsible for
   // validating |filename|.
   bool DeterminerCallback(
+      Profile* profile,
       const std::string& extension_id,
       const base::FilePath& filename,
       extensions::api::downloads::FilenameConflictAction conflict_action) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     bool found_info = false;
     for (size_t index = 0; index < determiners_.size(); ++index) {
       if (determiners_[index].extension_id == extension_id) {
         found_info = true;
         if (determiners_[index].reported)
           return false;
         determiners_[index].reported = true;
         // 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.
-        if (!filename.empty() &&
-            (determiner_.extension_id.empty() ||
-             (determiners_[index].install_time > determiner_.install_time))) {
-          determined_filename_ = filename;
-          determined_conflict_action_ = conflict_action;
-          determiner_ = determiners_[index];
+        if (!filename.empty()) {
+          extensions::ExtensionWarningSet warnings;
+          std::string winner_extension_id;
+          ExtensionDownloadsEventRouter::DetermineFilenameInternal(
+              filename,
+              conflict_action,
+              determiners_[index].extension_id,
+              determiners_[index].install_time,
+              determiner_.extension_id,
+              determiner_.install_time,
+              &winner_extension_id,
+              &determined_filename_,
+              &determined_conflict_action_,
+              &warnings);
+          if (!warnings.empty())
+            extensions::ExtensionWarningService::NotifyWarningsOnUI(
+                profile, warnings);
+          if (winner_extension_id == determiners_[index].extension_id)
+            determiner_ = determiners_[index];
         }
         break;
       }
     }
     if (!found_info)
       return false;
     CheckAllDeterminersCalled();
     return true;
   }
 
@@ skipping 827 matching lines @@
       change.Run(data->creator_suggested_filename(),
                  ConvertConflictAction(data->creator_conflict_action()));
       // If all listeners are removed, don't keep |data| around.
       data->ResetCreatorSuggestion();
     } else {
       no_change.Run();
     }
   }
 }
 
+void ExtensionDownloadsEventRouter::DetermineFilenameInternal(
+    const base::FilePath& filename,
+    extensions::api::downloads::FilenameConflictAction conflict_action,
+    const std::string& suggesting_extension_id,
+    const base::Time& suggesting_install_time,
+    const std::string& incumbent_extension_id,
+    const base::Time& incumbent_install_time,
+    std::string* winner_extension_id,
+    base::FilePath* determined_filename,
+    extensions::api::downloads::FilenameConflictAction*
+      determined_conflict_action,
+    extensions::ExtensionWarningSet* warnings) {
+  DCHECK(!filename.empty());
+  DCHECK(!suggesting_extension_id.empty());
+
+  if (incumbent_extension_id.empty()) {
+    *winner_extension_id = suggesting_extension_id;
+    *determined_filename = filename;
+    *determined_conflict_action = conflict_action;
+    return;
+  }
+
+  if (suggesting_install_time < incumbent_install_time) {
+    *winner_extension_id = incumbent_extension_id;
+    warnings->insert(
+        extensions::ExtensionWarning::CreateDownloadFilenameConflictWarning(
+            suggesting_extension_id,
+            incumbent_extension_id,
+            filename,
+            *determined_filename));
+    return;
+  }
+
+  *winner_extension_id = suggesting_extension_id;
+  warnings->insert(
+      extensions::ExtensionWarning::CreateDownloadFilenameConflictWarning(
+          incumbent_extension_id,
+          suggesting_extension_id,
+          *determined_filename,
+          filename));
+  *determined_filename = filename;
+  *determined_conflict_action = conflict_action;
+}
+
 bool ExtensionDownloadsEventRouter::DetermineFilename(
     Profile* profile,
     bool include_incognito,
     const std::string& ext_id,
     int download_id,
     const base::FilePath& const_filename,
     extensions::api::downloads::FilenameConflictAction conflict_action,
     std::string* error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* item = GetDownload(profile, include_incognito, download_id);
@@ skipping 13 matching lines @@
   base::FilePath::StringType filename_str(const_filename.value());
   // Allow windows-style directory separators on all platforms.
   std::replace(filename_str.begin(), filename_str.end(),
                FILE_PATH_LITERAL('\\'), FILE_PATH_LITERAL('/'));
   base::FilePath filename(filename_str);
   bool valid_filename = net::IsSafePortableRelativePath(filename);
   filename = (valid_filename ? filename.NormalizePathSeparators() :
               base::FilePath());
   // If the invalid filename check is moved to before DeterminerCallback(), then
   // it will block forever waiting for this ext_id to report.
-  if (Fault(!data->DeterminerCallback(ext_id, filename, conflict_action),
+  if (Fault(!data->DeterminerCallback(
+                profile, ext_id, filename, conflict_action),
             errors::kUnexpectedDeterminer, error) ||
       Fault((!const_filename.empty() && !valid_filename),
             errors::kInvalidFilename, error))
     return false;
   return true;
 }
 
 void ExtensionDownloadsEventRouter::OnListenerRemoved(
     const extensions::EventListenerInfo& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 178 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
       content_source,
       content::Details<std::string>(&json_args));
 }
 
 void ExtensionDownloadsEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       extensions::UnloadedExtensionInfo* unloaded =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       std::set<const extensions::Extension*>::iterator iter =
         shelf_disabling_extensions_.find(unloaded->extension);
       if (iter != shelf_disabling_extensions_.end())
         shelf_disabling_extensions_.erase(iter);
       break;
     }
   }
 }