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 27 matching lines @@
 
 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),
+#if defined(OS_ANDROID)
+      download_controller_(content::DownloadControllerAndroid::Get()),

[asanka, 2015/07/07 05:03:33]

A member variable is unnecessary for this.

[qinmin, 2015/07/07 06:14:05]

Done.

+#endif
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(download_);
   DCHECK(delegate);
   download_->AddObserver(this);
 
   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);
+  next_state_ = STATE_GENERATE_TARGET_PATH;
+#if defined(OS_ANDROID)
+  content::WebContents* web_contents = download_->GetWebContents();
+  download_controller_->AcquireFileAccessPermission(
+      web_contents,
+      base::Bind(&DownloadTargetDeterminer::PromptUserForPermissionDone,
+                 weak_ptr_factory_.GetWeakPtr()));
+  return QUIT_DOLOOP;
+#endif

[asanka, 2015/07/07 05:03:33]

#else
  return CONTINUE;
#endif

[qinmin, 2015/07/07 06:14:05]

Done.

+  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;
 
@@ skipping 710 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