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

chrome/browser/download/chrome_download_manager_delegate_unittest.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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/observer_list.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/value_conversions.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_delegate.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_renderer_host.h"
+#include "content/public/test/web_contents_tester.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::DownloadItem;
 using safe_browsing::DownloadProtectionService;
 using ::testing::AtMost;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::ReturnPointee;
 using ::testing::ReturnRef;
 using ::testing::ReturnRefOfCopy;
 using ::testing::WithArg;
 using ::testing::_;
 
 namespace {
 
+class MockWebContentsDelegate : public content::WebContentsDelegate {
+ public:
+  virtual ~MockWebContentsDelegate() {}
+};
+
 // Google Mock action that posts a task to the current message loop that invokes
 // the first argument of the mocked method as a callback. Said argument must be
 // a base::Callback<void(ParamType)>. |result| must be of |ParamType| and is
 // bound as that parameter.
 // Example:
 //   class FooClass {
 //    public:
 //     virtual void Foo(base::Callback<void(bool)> callback);
 //   };
 //   ...
@@ skipping 154 matching lines @@
 #endif
 
  private:
   ~TestChromeDownloadManagerDelegate() {}
 
 #if defined(ENABLE_SAFE_BROWSING)
   scoped_ptr<TestDownloadProtectionService> download_protection_service_;
 #endif
 };
 
-class ChromeDownloadManagerDelegateTest : public ::testing::Test {
+class ChromeDownloadManagerDelegateTest :
+    public ChromeRenderViewHostTestHarness {
  public:
   ChromeDownloadManagerDelegateTest();
 
   // ::testing::Test
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   // Verifies and clears test expectations for |delegate_| and
   // |download_manager_|.
   void VerifyAndClearExpectations();
@@ skipping 34 matching lines @@
 
  private:
   // Verifies that |target_path|, |disposition|, |danger_type| and
   // |intermediate_path| matches the expectations of |test_case|.
   void DownloadTargetVerifier(const DownloadTestCase* test_case,
                               const FilePath& target_path,
                               DownloadItem::TargetDisposition disposition,
                               content::DownloadDangerType danger_type,
                               const FilePath& intermediate_path);
 
-  MessageLoopForUI message_loop_;
   TestingPrefService* pref_service_;
   ScopedTempDir test_download_dir_;
-  TestingProfile profile_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   scoped_refptr<content::MockDownloadManager> download_manager_;
   scoped_refptr<TestChromeDownloadManagerDelegate> delegate_;
+  MockWebContentsDelegate web_contents_delegate_;
 };
 
 ChromeDownloadManagerDelegateTest::ChromeDownloadManagerDelegateTest()
-    : ui_thread_(content::BrowserThread::UI, &message_loop_),
+    : ChromeRenderViewHostTestHarness(),
+      ui_thread_(content::BrowserThread::UI, &message_loop_),
       file_thread_(content::BrowserThread::FILE, &message_loop_),
-      download_manager_(new content::MockDownloadManager),
-      delegate_(new TestChromeDownloadManagerDelegate(&profile_)) {
-  delegate_->SetDownloadManager(download_manager_.get());
-  pref_service_ = profile_.GetTestingPrefService();
+      download_manager_(new content::MockDownloadManager) {
 }
 
 void ChromeDownloadManagerDelegateTest::SetUp() {
+  ChromeRenderViewHostTestHarness::SetUp();
+
+  CHECK(profile());
+  delegate_ = new TestChromeDownloadManagerDelegate(profile());
+  delegate_->SetDownloadManager(download_manager_.get());
+  pref_service_ = profile()->GetTestingPrefService();
+  contents()->SetDelegate(&web_contents_delegate_);
+
   ASSERT_TRUE(test_download_dir_.CreateUniqueTempDir());
   SetDefaultDownloadPath(test_download_dir_.path());
 }
 
 void ChromeDownloadManagerDelegateTest::TearDown() {
   message_loop_.RunAllPending();
   delegate_->Shutdown();
+  ChromeRenderViewHostTestHarness::TearDown();
 }
 
 void ChromeDownloadManagerDelegateTest::VerifyAndClearExpectations() {
   ::testing::Mock::VerifyAndClearExpectations(delegate_);
   ::testing::Mock::VerifyAndClearExpectations(download_manager_);
 }
 
 content::MockDownloadItem*
     ChromeDownloadManagerDelegateTest::CreateActiveDownloadItem(int32 id) {
   content::MockDownloadItem* item =
       new ::testing::NiceMock<content::MockDownloadItem>();
   ON_CALL(*item, GetFullPath())
       .WillByDefault(ReturnRefOfCopy(FilePath()));
   ON_CALL(*item, GetHash())
       .WillByDefault(ReturnRefOfCopy(std::string()));
   ON_CALL(*item, GetReferrerUrl())
       .WillByDefault(ReturnRefOfCopy(GURL()));
   ON_CALL(*item, GetTransitionType())
       .WillByDefault(Return(content::PAGE_TRANSITION_LINK));
   ON_CALL(*item, HasUserGesture())
       .WillByDefault(Return(false));
   ON_CALL(*item, IsDangerous())
       .WillByDefault(Return(false));
   ON_CALL(*item, IsTemporary())
       .WillByDefault(Return(false));
+  ON_CALL(*item, GetWebContents())
+      .WillByDefault(Return(contents()));
   EXPECT_CALL(*item, GetId())
       .WillRepeatedly(Return(id));
   EXPECT_CALL(*download_manager_, GetActiveDownloadItem(id))
       .WillRepeatedly(Return(item));
   return item;
 }
 
 void ChromeDownloadManagerDelegateTest::EnableAutoOpenBasedOnExtension(
     const FilePath& path) {
   EXPECT_TRUE(
@@ skipping 537 matching lines @@
   RunTestCases(kLastSavePathTestCases, arraysize(kLastSavePathTestCases));
 
   // Now clear the last download path.
   delegate()->ClearLastDownloadPath();
 
   // Run the first test case again. Since the last download path was cleared,
   // this test case should behave identically to the first time it was run.
   RunTestCases(kLastSavePathTestCases, 1);
 }
 
+TEST_F(ChromeDownloadManagerDelegateTest, StartDownload_WebIntents) {
+  const DownloadTestCase kWebIntentsTestCases[] = {
+    {
+      // 1: A file which would be dangerous, but is handled by web intents.
+      // The name will be unaltered (the actual save name will have the
+      // .webintents extension).
+      AUTOMATIC,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      "http://example.com/feed.exe", "application/rss+xml",
+      FILE_PATH_LITERAL(""),
+
+      FILE_PATH_LITERAL("feed.exe.webintents"),
+      FILE_PATH_LITERAL(""),
+      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+
+      EXPECT_CRDOWNLOAD
+    },
+
+    {
+      // 2: A download with a forced path won't be handled by web intents.
+      FORCED,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      "http://example.com/feed.exe", "application/rss+xml",
+      FILE_PATH_LITERAL("forced.feed.exe"),
+
+      FILE_PATH_LITERAL("forced.feed.exe"),
+      FILE_PATH_LITERAL(""),
+      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+
+      EXPECT_CRDOWNLOAD
+    },
+  };
+
+  RunTestCases(kWebIntentsTestCases, arraysize(kWebIntentsTestCases));
+}
+
 // TODO(asanka): Add more tests.
 // * Default download path is not writable.
 // * Download path doesn't exist.
 // * IsDangerousFile().
 // * Filename generation.