Change policy to not trigger dangerous download UI for web intents dispatched files.

chrome/browser/download/chrome_download_manager_delegate.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/chrome_download_manager_delegate.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 29 matching lines @@
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_intents_dispatcher.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/web_intent_data.h"
+#include "webkit/glue/web_intent_reply_data.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/gdata/drive_download_observer.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_util.h"
 #include "chrome/browser/download/download_file_picker_chromeos.h"
 #include "chrome/browser/download/save_package_file_picker_chromeos.h"
 #endif
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::WebContents;
 using safe_browsing::DownloadProtectionService;
 
 namespace {
 
 // String pointer used for identifying safebrowing data associated with
 // a download item.
 static const char safe_browsing_id[] = "Safe Browsing ID";
 
+// String pointer used to set the local file extension to be used when a
+// download is going to be dispatched with web intents.
+static const FilePath::CharType kWebIntentsFileExtension[] =
+    FILE_PATH_LITERAL(".webintents");
+
 // The state of a safebrowsing check.
 class SafeBrowsingState : public DownloadCompletionBlocker {
  public:
   SafeBrowsingState()
     : verdict_(DownloadProtectionService::SAFE) {
   }
 
   virtual ~SafeBrowsingState();
 
   // The verdict that we got from calling CheckClientDownload. Only valid to
@@ skipping 24 matching lines @@
       l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME));
 
   *generated_name = net::GenerateFileName(download_item.GetURL(),
                                           download_item.GetContentDisposition(),
                                           download_item.GetReferrerCharset(),
                                           download_item.GetSuggestedFilename(),
                                           download_item.GetMimeType(),
                                           default_file_name);
 }
 
+// Needed to give PostTask a void closure in OnWebIntentDispatchCompleted.
+void DeleteFile(const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  file_util::Delete(file_path, false);
+}
+
+// Called when the web intents dispatch has completed. Deletes the |file_path|.
+void OnWebIntentDispatchCompleted(
+    const FilePath& file_path,
+    webkit_glue::WebIntentReplyType intent_reply) {
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                          base::Bind(&DeleteFile, file_path));
+}
+
 }  // namespace
 
 ChromeDownloadManagerDelegate::ChromeDownloadManagerDelegate(Profile* profile)
     : profile_(profile),
       next_download_id_(0),
       download_prefs_(new DownloadPrefs(profile)) {
 }
 
 ChromeDownloadManagerDelegate::~ChromeDownloadManagerDelegate() {
 }
@@ skipping 233 matching lines @@
     return false;
   }
 
   return true;
 }
 
 bool ChromeDownloadManagerDelegate::ShouldOpenWithWebIntents(
     const DownloadItem* item) {
   if (!item->GetWebContents() || !item->GetWebContents()->GetDelegate())
     return false;
+  if (!item->GetForcedFilePath().empty())
+    return false;
 
   std::string mime_type = item->GetMimeType();
   if (mime_type == "application/rss+xml" ||
       mime_type == "application/atom+xml") {
     return true;
   }
 
 #if defined(OS_CHROMEOS)
   if (mime_type == "application/msword" ||
       mime_type == "application/vnd.ms-powerpoint" ||
@@ skipping 45 matching lines @@
   intent_data.extra_data.insert(make_pair(
       ASCIIToUTF16("url"), ASCIIToUTF16(item->GetURL().spec())));
 
   // Pass the downloaded filename to the service app as the name hint.
   intent_data.extra_data.insert(
       make_pair(ASCIIToUTF16("filename"),
                 item->GetFileNameToReportUser().LossyDisplayName()));
 
   content::WebIntentsDispatcher* dispatcher =
       content::WebIntentsDispatcher::Create(intent_data);
+  dispatcher->RegisterReplyNotification(
+      base::Bind(&OnWebIntentDispatchCompleted, item->GetFullPath()));
   // TODO(gbillock): try to get this to be able to delegate to the Browser
   // object directly, passing a NULL WebContents?
   item->GetWebContents()->GetDelegate()->WebIntentDispatch(
       item->GetWebContents(), dispatcher);
 }
 
 bool ChromeDownloadManagerDelegate::GenerateFileHash() {
 #if defined(ENABLE_SAFE_BROWSING)
   return profile_->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled) &&
       g_browser_process->safe_browsing_service()->DownloadBinHashNeeded();
@@ skipping 268 matching lines @@
     if (should_prompt && !last_download_path_.empty())
       target_directory = last_download_path_;
     else
       target_directory = download_prefs_->DownloadPath();
     suggested_path = target_directory.Append(generated_name);
   } else {
     DCHECK(!should_prompt);
     suggested_path = download->GetForcedFilePath();
   }
 
+  // If we will open the file with a web intents dispatch,
+  // give it a name that will not allow the OS to open it using usual
+  // associated apps.
+  if (ShouldOpenWithWebIntents(download)) {
+    download->SetDisplayName(suggested_path.BaseName());
+    suggested_path = suggested_path.AddExtension(kWebIntentsFileExtension);
+  }
+
   // If the download hasn't already been marked dangerous (could be
   // DANGEROUS_URL), check if it is a dangerous file.
   if (danger_type == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS) {
     if (!should_prompt && !is_forced_path &&
         IsDangerousFile(*download, suggested_path, visited_referrer_before)) {
       danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
     }
 
 #if defined(ENABLE_SAFE_BROWSING)
     DownloadProtectionService* service = GetDownloadProtectionService();
@@ skipping 119 matching lines @@
     int32 download_id, int64 db_handle) {
   // It's not immediately obvious, but HistoryBackend::CreateDownload() can
   // call this function with an invalid |db_handle|. For instance, this can
   // happen when the history database is offline. We cannot have multiple
   // DownloadItems with the same invalid db_handle, so we need to assign a
   // unique |db_handle| here.
   if (db_handle == DownloadItem::kUninitializedHandle)
     db_handle = download_history_->GetNextFakeDbHandle();
   download_manager_->OnItemAddedToPersistentStore(download_id, db_handle);
 }