move file access permission logic to DownloadResourceThrottle

chrome/browser/download/download_resource_throttle.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 "chrome/browser/download/download_resource_throttle.h"
 
 #include "base/bind.h"
 #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,
     const std::string& request_method)
     : 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() {
 }
 
 void DownloadResourceThrottle::WillStartRequest(bool* defer) {
   WillDownload(defer);
 }
 
 void DownloadResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
   WillDownload(defer);
 }
 
 void DownloadResourceThrottle::WillProcessResponse(bool* defer) {
   WillDownload(defer);
 }
 
 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_);
 
   // Defer the download until we have the DownloadRequestLimiter result.
   if (querying_limiter_) {
     request_deferred_ = true;
     *defer = true;
     return;
   }
 
@@ skipping 15 matching lines @@
 
   if (request_deferred_) {
     request_deferred_ = false;
     if (allow) {
       controller()->Resume();
     } else {
       controller()->Cancel();
     }
   }
 }