permissionrequest API for guest Download.

chrome/browser/download/download_request_limiter.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_request_limiter.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_request_infobar_delegate.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::WebContents;
 
 // TabDownloadState ------------------------------------------------------------
 
@@ skipping 172 matching lines @@
 
   for (size_t i = 0; i < callbacks.size(); ++i)
     host_->ScheduleNotification(callbacks[i], allow);
 
   if (change_status)
     set_download_status(DownloadRequestLimiter::PROMPT_BEFORE_DOWNLOAD);
 }
 
 // DownloadRequestLimiter ------------------------------------------------------
 
-DownloadRequestLimiter::DownloadRequestLimiter() {
+DownloadRequestLimiter::DownloadRequestLimiter()
+    : factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 DownloadRequestLimiter::~DownloadRequestLimiter() {
   // All the tabs should have closed before us, which sends notification and
   // removes from state_map_. As such, there should be no pending callbacks.
   DCHECK(state_map_.empty());
 }
 
 DownloadRequestLimiter::DownloadStatus
     DownloadRequestLimiter::GetDownloadStatus(WebContents* web_contents) {
@@ skipping 44 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   WebContents* originating_contents =
       tab_util::GetWebContentsByID(render_process_host_id, render_view_id);
   if (!originating_contents) {
     // The WebContents was closed, don't allow the download.
     ScheduleNotification(callback, false);
     return;
   }
 
+  if (!originating_contents->GetDelegate()) {
+    ScheduleNotification(callback, false);
+    return;
+  }
+
+  if (originating_contents->GetRenderProcessHost()->IsGuest()) {
+    // Decide asynchronously for BrowserPluginGuest.
+    base::Callback<void(bool)> wrapped_callback = base::Bind(
+        &DownloadRequestLimiter::OnCanDownloadDecidedAsync,
+        factory_.GetWeakPtr(),
+        originating_contents, request_id, request_method, callback);
+    originating_contents->GetDelegate()->CanDownloadAsync(
+        originating_contents->GetRenderViewHost(),
+        request_id,
+        request_method,
+        wrapped_callback);
+    return;
+  } else {
+    // FYI: Chrome Frame overrides CanDownload in ExternalTabContainer in order
+    // to cancel the download operation in chrome and let the host browser
+    // take care of it.
+    if (!originating_contents->GetDelegate()->CanDownload(
+            originating_contents->GetRenderViewHost(),
+            request_id,
+            request_method)) {
+      ScheduleNotification(callback, false);
+      return;
+    }
+  }
+
   CanDownloadImpl(
       originating_contents,
       request_id,
       request_method,
       callback);
 }
 
+void DownloadRequestLimiter::OnCanDownloadDecidedAsync(
+    WebContents* originating_contents,
+    int request_id,
+    const std::string& request_method,
+    const Callback& orig_callback, bool allow) {
+  if (!allow) {
+    ScheduleNotification(orig_callback, false);
+    return;
+  }
+
+  CanDownloadImpl(originating_contents,
+                  request_id,
+                  request_method,
+                  orig_callback);
+}
+
 void DownloadRequestLimiter::CanDownloadImpl(WebContents* originating_contents,
                                              int request_id,
                                              const std::string& request_method,
                                              const Callback& callback) {
   DCHECK(originating_contents);
 
-  // FYI: Chrome Frame overrides CanDownload in ExternalTabContainer in order
-  // to cancel the download operation in chrome and let the host browser
-  // take care of it.
-  if (originating_contents->GetDelegate() &&
-      !originating_contents->GetDelegate()->CanDownload(
-          originating_contents->GetRenderViewHost(),
-          request_id,
-          request_method)) {
-    ScheduleNotification(callback, false);
-    return;
-  }
-
   // If the tab requesting the download is a constrained popup that is not
   // shown, treat the request as if it came from the parent.
   WebContents* effective_contents = originating_contents;
   BlockedContentTabHelper* blocked_content_tab_helper =
       BlockedContentTabHelper::FromWebContents(originating_contents);
   if (blocked_content_tab_helper &&
       blocked_content_tab_helper->delegate()) {
     effective_contents = blocked_content_tab_helper->delegate()->
         GetConstrainingWebContents(originating_contents);
   }
@@ skipping 32 matching lines @@
                                                   bool allow) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(callback, allow));
 }
 
 void DownloadRequestLimiter::Remove(TabDownloadState* state) {
   DCHECK(ContainsKey(state_map_, state->web_contents()));
   state_map_.erase(state->web_contents());
   delete state;
 }