Prompt user for file access permission before download starts

chrome/browser/download/download_target_determiner_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/at_exit.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_service.h"
@@ skipping 29 matching lines @@
 #if defined(ENABLE_PLUGINS)
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/plugin_service_filter.h"
 #include "content/public/common/webplugininfo.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/common/extension.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include "content/public/browser/android/download_controller_android.h"
+#include "content/public/common/context_menu_params.h"
+using content::WebContents;
+using content::ContextMenuParams;
+#endif
+
 using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Ref;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::ReturnRefOfCopy;
 using ::testing::Truly;
 using ::testing::WithArg;
 using ::testing::_;
 using content::DownloadItem;
 
 namespace {
 
 // No-op delegate.
 class NullWebContentsDelegate : public content::WebContentsDelegate {
  public:
   NullWebContentsDelegate() {}
   ~NullWebContentsDelegate() override {}
 };
 
+#if defined(OS_ANDROID)
+class MockDownloadControllerAndroid
+    : public content::DownloadControllerAndroid {
+ public:
+  MockDownloadControllerAndroid()
+      : require_user_permission_prompt_(false),
+        approve_user_request_(true) {}
+  ~MockDownloadControllerAndroid() override {}
+
+  void CreateGETDownload(int render_process_id, int render_view_id,
+                         int request_id) override {};
+  void OnDownloadStarted(DownloadItem* download_item) override {};
+  void StartContextMenuDownload(
+      const ContextMenuParams& params, WebContents* web_contents,
+      bool is_link, const std::string& extra_headers) override {};
+  void DangerousDownloadValidated(
+      WebContents* web_contents, int download_id, bool accept) override {};
+  bool RequireUserPermissionPrompt(WebContents* web_contents) override {
+    return require_user_permission_prompt_;
+  }
+  void PromptUserForPermission(
+      WebContents* web_contents,
+      const UserPermissionPromptCallback& callback) override {
+    ASSERT_TRUE(require_user_permission_prompt_);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, approve_user_request_));
+  }
+
+  void set_require_user_permission_prompt(bool require_user_permission_prompt) {
+    require_user_permission_prompt_ = require_user_permission_prompt;
+  }
+  void set_approve_user_request(bool approve_user_request) {
+    approve_user_request_ = approve_user_request;
+  }
+ private:
+  bool require_user_permission_prompt_;
+  bool approve_user_request_;
+};
+#endif
+
 // 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 170 matching lines @@
   }
 
   MockDownloadTargetDeterminerDelegate* delegate() {
     return &delegate_;
   }
 
   DownloadPrefs* download_prefs() {
     return download_prefs_.get();
   }
 
+  #if defined(OS_ANDROID)
+  MockDownloadControllerAndroid* download_controller() {
+    return &download_controller_;
+  }
+  #endif
+
  private:
   scoped_ptr<DownloadPrefs> download_prefs_;
   ::testing::NiceMock<MockDownloadTargetDeterminerDelegate> delegate_;
   NullWebContentsDelegate web_contents_delegate_;
   base::ScopedTempDir test_download_dir_;
   base::FilePath test_virtual_dir_;
+#if defined(OS_ANDROID)
+  MockDownloadControllerAndroid download_controller_;
+#endif
 };
 
 void DownloadTargetDeterminerTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
   CHECK(profile());
   download_prefs_.reset(new DownloadPrefs(profile()));
   web_contents()->SetDelegate(&web_contents_delegate_);
   ASSERT_TRUE(test_download_dir_.CreateUniqueTempDir());
   test_virtual_dir_ = test_download_dir().Append(FILE_PATH_LITERAL("virtual"));
   download_prefs_->SetDownloadPath(test_download_dir());
   delegate_.SetupDefaults();
+#if defined(OS_ANDROID)
+  DownloadTargetDeterminer::SetDownloadControllerAndroidForTestings(
+      &download_controller_);

[asanka, 2015/07/06 21:09:41]

You are setting a global pointer to a temporary variable and leaving it as is.
You should reset it to nullptr at TearDown(). unit_tests can invoke multiple
tests during a single invocation.

[qinmin, 2015/07/07 00:54:22]

Done.

+#endif
 }
 
 void DownloadTargetDeterminerTest::TearDown() {
   download_prefs_.reset();
   ChromeRenderViewHostTestHarness::TearDown();
 }
 
 content::MockDownloadItem*
 DownloadTargetDeterminerTest::CreateActiveDownloadItem(
     int32 id,
@@ skipping 860 matching lines @@
     },
   };
 
   SetPromptForDownload(true);
   EnableAutoOpenBasedOnExtension(
       base::FilePath(FILE_PATH_LITERAL("dummy.dummy")));
   RunTestCasesWithActiveItem(kPromptingTestCases,
                              arraysize(kPromptingTestCases));
 }
 
+#if defined(OS_ANDROID)
+TEST_F(DownloadTargetDeterminerTest,
+       TargetDeterminer_ApprovePromptForUserPermission) {
+  const DownloadTestCase kUserPermissionTestCases[] = {
+    {
+      // 0: Automatic Safe
+      AUTOMATIC,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      "http://example.com/foo.txt", "text/plain",
+      FILE_PATH_LITERAL(""),
+
+      FILE_PATH_LITERAL("foo.txt"),
+      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+
+      EXPECT_CRDOWNLOAD
+    },
+  };
+  download_controller()->set_require_user_permission_prompt(true);
+  RunTestCasesWithActiveItem(kUserPermissionTestCases,
+                             arraysize(kUserPermissionTestCases));
+}
+
+TEST_F(DownloadTargetDeterminerTest,
+       TargetDeterminer_DisapprovePromptForUserPermission) {
+  const DownloadTestCase kUserPermissionTestCases[] = {
+    {
+      // 0: Automatic Safe
+      AUTOMATIC,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      "http://example.com/foo.txt", "text/plain",
+      FILE_PATH_LITERAL(""),
+
+      FILE_PATH_LITERAL(""),
+      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+
+      EXPECT_LOCAL_PATH
+    },
+  };
+  download_controller()->set_require_user_permission_prompt(true);
+  download_controller()->set_approve_user_request(false);
+  RunTestCasesWithActiveItem(kUserPermissionTestCases,
+                             arraysize(kUserPermissionTestCases));
+}
+#endif
+
 #if defined(ENABLE_EXTENSIONS)
 // These test cases are run with "Prompt for download" user preference set to
 // true. Automatic extension downloads shouldn't cause prompting.
 // Android doesn't support extensions.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_PromptAlways_Extension) {
   const DownloadTestCase kPromptingTestCases[] = {
     {
       // 0: Automatic Browser Extension download. - Shouldn't prompt for browser
       //    extension downloads even if "Prompt for download" preference is set.
       AUTOMATIC,
@@ skipping 1072 matching lines @@
   EXPECT_CALL(mock_plugin_filter_, MockPluginAvailable(npapi_plugin.path()))
       .WillRepeatedly(Return(true));
 
   target_info = RunDownloadTargetDeterminer(
       GetPathInDownloadDir(kInitialPath), item.get());
   EXPECT_FALSE(target_info->is_filetype_handled_safely);
 }
 #endif  // defined(ENABLE_PLUGINS)
 
 }  // namespace