Prompt user for file access permission before download starts

chrome/browser/download/download_target_determiner.cc

 // Copyright 2013 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/download_target_determiner.h"
 
 #include "base/location.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 21 matching lines @@
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "extensions/common/feature_switch.h"
 #endif
 
 #if defined(ENABLE_PLUGINS)
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/common/webplugininfo.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include "content/public/browser/android/download_controller_android.h"
+#endif
+
 #if defined(OS_WIN)
 #include "chrome/browser/ui/pdf/adobe_reader_info_win.h"
 #endif
 
 using content::BrowserThread;
 using content::DownloadItem;
 
 namespace {
 
 const base::FilePath::CharType kCrdownloadSuffix[] =
@@ skipping 11 matching lines @@
   callback.Run(
       found_visits && count > 0 &&
       (first_visit.LocalMidnight() < base::Time::Now().LocalMidnight()));
 }
 
 #if defined(OS_WIN)
 // Keeps track of whether Adobe Reader is up to date.
 bool g_is_adobe_reader_up_to_date_ = false;
 #endif
 
+#if defined(OS_ANDROID)
+  // Download controller for file access prompt.

[Ted C, 2015/07/06 20:03:39]

these two lines shouldn't be indented.

[qinmin, 2015/07/06 20:36:02]

Done.

+  content::DownloadControllerAndroid* g_download_controller_;

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

I know this'll end up being nullptr, but please initialize it explicitly.

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

Done. make this a member variable and initialize it in the initializer list.

+#endif
 }  // namespace
 
 DownloadTargetInfo::DownloadTargetInfo()
     : is_filetype_handled_safely(false) {}
 
 DownloadTargetInfo::~DownloadTargetInfo() {}
 
 DownloadTargetDeterminerDelegate::~DownloadTargetDeterminerDelegate() {
 }
 
 DownloadTargetDeterminer::DownloadTargetDeterminer(
     DownloadItem* download,
     const base::FilePath& initial_virtual_path,
     DownloadPrefs* download_prefs,
     DownloadTargetDeterminerDelegate* delegate,
     const CompletionCallback& callback)
-    : next_state_(STATE_GENERATE_TARGET_PATH),
+    : next_state_(STATE_PROMPT_USER_FOR_PERMISSION),
       should_prompt_(false),
       should_notify_extensions_(false),
       create_target_directory_(false),
       conflict_action_(DownloadPathReservationTracker::OVERWRITE),
       danger_type_(download->GetDangerType()),
       is_dangerous_file_(false),
       virtual_path_(initial_virtual_path),
       is_filetype_handled_safely_(false),
       download_(download),
       is_resumption_(download_->GetLastReason() !=
                          content::DOWNLOAD_INTERRUPT_REASON_NONE &&
                      !initial_virtual_path.empty()),
       download_prefs_(download_prefs),
       delegate_(delegate),
       completion_callback_(callback),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(download_);
   DCHECK(delegate);
   download_->AddObserver(this);
-
+#if defined(OS_ANDROID)
+  if (!g_download_controller_)
+    g_download_controller_ = content::DownloadControllerAndroid::Get();
+#endif
   DoLoop();
 }
 
 DownloadTargetDeterminer::~DownloadTargetDeterminer() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(download_);
   DCHECK(completion_callback_.is_null());
   download_->RemoveObserver(this);
 }
 
 void DownloadTargetDeterminer::DoLoop() {
   Result result = CONTINUE;
   do {
     State current_state = next_state_;
     next_state_ = STATE_NONE;
 
     switch (current_state) {
+      case STATE_PROMPT_USER_FOR_PERMISSION:
+        result = DoPromptUserForPermission();
+        break;
       case STATE_GENERATE_TARGET_PATH:
         result = DoGenerateTargetPath();
         break;
       case STATE_NOTIFY_EXTENSIONS:
         result = DoNotifyExtensions();
         break;
       case STATE_RESERVE_VIRTUAL_PATH:
         result = DoReserveVirtualPath();
         break;
       case STATE_PROMPT_USER_FOR_DOWNLOAD_PATH:
@@ skipping 27 matching lines @@
   } while (result == CONTINUE);
   // Note that if a callback completes synchronously, the handler will still
   // return QUIT_DOLOOP. In this case, an inner DoLoop() may complete the target
   // determination and delete |this|.
 
   if (result == COMPLETE)
     ScheduleCallbackAndDeleteSelf();
 }
 
 DownloadTargetDeterminer::Result
+    DownloadTargetDeterminer::DoPromptUserForPermission() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(local_path_.empty());

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

Why are you checking these (here and below)?

In general you should only DCHECK dependencies for this state.

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

Ok, removed.

On 2015/07/06 21:09:41, asanka wrote:

+  DCHECK(!should_prompt_);
+  DCHECK(!should_notify_extensions_);
+  DCHECK_EQ(DownloadPathReservationTracker::OVERWRITE, conflict_action_);
+  next_state_ = STATE_GENERATE_TARGET_PATH;
+#if defined(OS_ANDROID)
+  content::WebContents* web_contents = download_->GetWebContents();
+  if (g_download_controller_->RequireUserPermissionPrompt(web_contents)) {
+    g_download_controller_->PromptUserForPermission(
+        web_contents,
+        base::Bind(&DownloadTargetDeterminer::PromptUserForPermissionDone,
+                   weak_ptr_factory_.GetWeakPtr()));
+    return QUIT_DOLOOP;
+  }
+#endif
+  return CONTINUE;
+}
+
+void DownloadTargetDeterminer::PromptUserForPermissionDone(bool granted) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_EQ(STATE_GENERATE_TARGET_PATH, next_state_);
+  if (!granted) {
+    CancelOnFailureAndDeleteSelf();
+    return;
+  }
+
+  DoLoop();
+}
+
+DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoGenerateTargetPath() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(local_path_.empty());
   DCHECK(!should_prompt_);
   DCHECK(!should_notify_extensions_);
   DCHECK_EQ(DownloadPathReservationTracker::OVERWRITE, conflict_action_);
+
   bool is_forced_path = !download_->GetForcedFilePath().empty();
 
   next_state_ = STATE_NOTIFY_EXTENSIONS;
 
   if (!virtual_path_.empty() && HasPromptedForPath() && !is_forced_path) {
     // The download is being resumed and the user has already been prompted for
     // a path. Assume that it's okay to overwrite the file if there's a conflict
     // and reuse the selection.
     should_prompt_ = ShouldPromptForDownload(virtual_path_);
   } else if (!is_forced_path) {
@@ skipping 704 matching lines @@
     const base::FilePath& suggested_path) {
   return base::FilePath(suggested_path.value() + kCrdownloadSuffix);
 }
 
 #if defined(OS_WIN)
 // static
 bool DownloadTargetDeterminer::IsAdobeReaderUpToDate() {
   return g_is_adobe_reader_up_to_date_;
 }
 #endif
+
+#if defined(OS_ANDROID)
+// static
+void DownloadTargetDeterminer::SetDownloadControllerAndroidForTestings(

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

Rather than setting a global override here just for DTD, what about having an
override for DownloadControllerAndroid? It seems fragile that a global is
overridden this way just for a single consumer since other consumers or other
code paths might use the real object. Also any tests performed at a higher level
that'll depend on mocking this dependency will need to reach into each consuming
class that might be invoked during testing.

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

Done. DownloadControllerAndroid::Get() will now returns a mock class by calling
UseMockControllerForTesting() in setup

+    content::DownloadControllerAndroid* download_controller) {
+  g_download_controller_ = download_controller;
+}
+#endif