move file access permission logic to DownloadResourceThrottle

chrome/browser/download/download_resource_throttle.cc

Index: chrome/browser/download/download_resource_throttle.cc
diff --git a/chrome/browser/download/download_resource_throttle.cc b/chrome/browser/download/download_resource_throttle.cc
index a8e2afa02b153b8f36aa26d8c0ec260aabac9a95..fd8529e711e5c2102b47d93f3a28728ecc2b95ad 100644
--- a/chrome/browser/download/download_resource_throttle.cc
+++ b/chrome/browser/download/download_resource_throttle.cc
@@ -8,8 +8,39 @@
 #include "chrome/browser/download/download_stats.h"
 #include "content/public/browser/resource_controller.h"
 
+#if defined(OS_ANDROID)
+#include "content/public/browser/android/download_controller_android.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_view_host.h"
+
+using content::BrowserThread;
+using content::DownloadControllerAndroid;
+
+namespace {
+
+void OnAcquireFileAccessPermissionDone(
+    const DownloadControllerAndroid::AcquireFileAccessPermissionCallback& cb,
+    bool granted) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE, base::Bind(cb, granted));
+}
+
+void AcquireFileAccessPermission(
+    int render_process_id,
+    int render_view_id,
+    const DownloadControllerAndroid::AcquireFileAccessPermissionCallback& cb) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  content::DownloadControllerAndroid::Get()->AcquireFileAccessPermission(
+      render_process_id, render_view_id,
+      base::Bind(&OnAcquireFileAccessPermissionDone, cb));
+}
+
+}  // namespace
+#endif
+
 DownloadResourceThrottle::DownloadResourceThrottle(
-    DownloadRequestLimiter* limiter,
+    scoped_refptr<DownloadRequestLimiter> limiter,
     int render_process_id,
     int render_view_id,
     const GURL& url,
@@ -17,13 +48,19 @@ DownloadResourceThrottle::DownloadResourceThrottle(
     : querying_limiter_(true),
       request_allowed_(false),
       request_deferred_(false) {
-  limiter->CanDownloadOnIOThread(
-      render_process_id,
-      render_view_id,
-      url,
-      request_method,
-      base::Bind(&DownloadResourceThrottle::ContinueDownload,
-                 AsWeakPtr()));
+#if defined(OS_ANDROID)
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,base::Bind(
+          &AcquireFileAccessPermission, render_process_id, render_view_id,
+          base::Bind(
+              &DownloadResourceThrottle::FileAccessPermissionGranted,
+              AsWeakPtr(), limiter, render_process_id, render_view_id,
+              url, request_method)));

[asanka, 2015/07/13 19:13:42]

Let's try to reduce thread hopping.

Currently we start on the IO thread.
  1. IO: DownloadResourceThrottle created. Post to UI thread.
  2. UI: AcquireFileAccessPermission invokes DCA::AcquireFileAccessPermission().
  3. UI: response received from call in 2.
  4. IO: replay response on IO thread by invoking FileAccessPermissionGranted.
  5. IO: Invoke DownloadRequestLimiter::CanDownloadOnIOThread() which posts to
UI thread.
  6. UI: DownloadRequestLimiter::CanDownload() invoked here.
  7. UI: Response from DRL posted to IO thread.
  8. IO: DRT::ContinueDownload() invoked with result from DRL.

How about:
  1. IO: DownloadResourceThrottle created. Post to UI thread.
  2. UI: AcquireFileAccessPermission invokes DCA::AcquireFileAccessPermission().
  3. UI: response received from call in 2.
  4. UI: If response is positive, invoke DownloadRequestLimiter::CanDownload().
  5. UI: Response from DRL posted to IO thread.
  6. IO: DRT::ContinueDownload() invoked with result from DRL.

?

This involves changing DownloadRequestLimiter so that it can be invoked on the
UI thread. This should make it simpler since it's doing all its work on the UI
thread.

DownloadResourceThrottler could then post a task to the UI thread on creation to
do all the work and then invoke ContinueDownload() on the IO thread once a
result is available.

[qinmin, 2015/07/14 00:30:57]

Done.

+#else
+  FileAccessPermissionGranted(
+      limiter, render_process_id, render_view_id, url, request_method, true);
+#endif
 }
 
 DownloadResourceThrottle::~DownloadResourceThrottle() {
@@ -47,6 +84,26 @@ const char* DownloadResourceThrottle::GetNameForLogging() const {
   return "DownloadResourceThrottle";
 }
 
+void DownloadResourceThrottle::FileAccessPermissionGranted(
+    scoped_refptr<DownloadRequestLimiter> limiter,
+    int render_process_id,
+    int render_view_id,
+    const GURL& url,
+    const std::string& request_method,
+    bool granted) {
+  if (granted) {
+    limiter->CanDownloadOnIOThread(
+        render_process_id,
+        render_view_id,
+        url,
+        request_method,
+        base::Bind(&DownloadResourceThrottle::ContinueDownload,
+                   AsWeakPtr()));
+  } else {
+    controller()->Cancel();
+  }
+}
+
 void DownloadResourceThrottle::WillDownload(bool* defer) {
   DCHECK(!request_deferred_);