permissionrequest API for guest Download.

content/browser/browser_plugin/browser_plugin_guest.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 "content/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_plugin/browser_plugin_embedder.h"
 #include "content/browser/browser_plugin/browser_plugin_guest_helper.h"
 #include "content/browser/browser_plugin/browser_plugin_guest_manager.h"
 #include "content/browser/browser_plugin/browser_plugin_host_factory.h"
+#include "content/browser/browser_thread_impl.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view_guest.h"
 #include "content/common/browser_plugin/browser_plugin_constants.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/drag_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_view_host_delegate_view.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/geolocation_permission_context.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/public/common/result_codes.h"
 #include "net/base/net_errors.h"
+#include "net/url_request/url_request.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "ui/surface/transport_dib.h"
 #include "webkit/glue/resource_type.h"
 #include "webkit/glue/webdropdata.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/browser_plugin/browser_plugin_popup_menu_helper_mac.h"
 #endif
 
 namespace content {
@@ skipping 20 matching lines @@
       case NEW_WINDOW:
         return "new_window";
       case NEW_POPUP:
         return "new_popup";
       default:
         NOTREACHED() << "Unknown Window Open Disposition";
         return "ignore";
   }
 }
 
+// Called on IO thread.
+static std::string RetrieveDownloadURLFromRequestId(
+    RenderViewHost* render_view_host,
+    int url_request_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  int render_process_id = render_view_host->GetProcess()->GetID();
+  GlobalRequestID global_id(render_process_id, url_request_id);
+  net::URLRequest* url_request =
+      ResourceDispatcherHostImpl::Get()->GetURLRequest(global_id);
+  if (url_request)
+    return url_request->url().possibly_invalid_spec();
+  return "";
+}
+
 }
 
 class BrowserPluginGuest::EmbedderRenderViewHostObserver
     : public RenderViewHostObserver {
  public:
   explicit EmbedderRenderViewHostObserver(BrowserPluginGuest* guest)
       : RenderViewHostObserver(
           guest->embedder_web_contents()->GetRenderViewHost()),
         browser_plugin_guest_(guest) {
   }
@@ skipping 212 matching lines @@
                                         WebContents* new_contents,
                                         WindowOpenDisposition disposition,
                                         const gfx::Rect& initial_pos,
                                         bool user_gesture,
                                         bool* was_blocked) {
   *was_blocked = false;
   RequestNewWindowPermission(static_cast<WebContentsImpl*>(new_contents),
                              disposition, initial_pos, user_gesture);
 }
 
-bool BrowserPluginGuest::CanDownload(RenderViewHost* render_view_host,
-                                    int request_id,
-                                    const std::string& request_method) {
-  // TODO(fsamuel): We disable downloads in guests for now, but we will later
-  // expose API to allow embedders to handle them.
-  // Note: it seems content_shell ignores this. This should be fixed
-  // for debugging and test purposes.
-  return false;
+void BrowserPluginGuest::CanDownload(
+    RenderViewHost* render_view_host,
+    int request_id,
+    const std::string& request_method,
+    const base::Callback<void(bool)>& callback) {
+  if (download_request_callback_map_.size() >=
+          kNumMaxOutstandingPermissionRequests) {
+    // Deny the download request.
+    callback.Run(false);
+    return;
+  }
+
+  // TODO(lazyboy): Remove download specific map
+  // |download_request_callback_map_| once we have generalized request items for
+  // all permission types.
+  int permission_request_id = next_permission_request_id_++;
+  download_request_callback_map_[permission_request_id] = callback;
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&RetrieveDownloadURLFromRequestId,
+                 render_view_host, request_id),
+      base::Bind(&BrowserPluginGuest::DidRetrieveDownloadURLFromRequestId,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 request_method,
+                 permission_request_id));
 }
 
 bool BrowserPluginGuest::HandleContextMenu(
     const ContextMenuParams& params) {
   // TODO(fsamuel): We have a do nothing context menu handler for now until
   // we implement the Apps Context Menu API for Browser Plugin (see
   // http://crbug.com/140315).
   return true;
 }
 
@@ skipping 621 matching lines @@
 void BrowserPluginGuest::OnStop(int instance_id) {
   GetWebContents()->Stop();
 }
 
 void BrowserPluginGuest::OnRespondPermission(
     int instance_id,
     BrowserPluginPermissionType permission_type,
     int request_id,
     bool should_allow) {
   switch (permission_type) {
+    case BrowserPluginPermissionTypeDownload:
+      OnRespondPermissionDownload(request_id, should_allow);
+      break;
     case BrowserPluginPermissionTypeGeolocation:
       OnRespondPermissionGeolocation(request_id, should_allow);
       break;
     case BrowserPluginPermissionTypeMedia:
       OnRespondPermissionMedia(request_id, should_allow);
       break;
     case BrowserPluginPermissionTypeNewWindow:
       OnRespondPermissionNewWindow(request_id, should_allow);
       break;
     default:
@@ skipping 192 matching lines @@
   relay_params.damage_buffer_sequence_id = damage_buffer_sequence_id_;
   relay_params.bitmap_rect = params.bitmap_rect;
   relay_params.scroll_delta = params.scroll_delta;
   relay_params.scroll_rect = params.scroll_rect;
   relay_params.copy_rects = params.copy_rects;
 
   SendMessageToEmbedder(
       new BrowserPluginMsg_UpdateRect(instance_id(), relay_params));
 }
 
+void BrowserPluginGuest::OnRespondPermissionDownload(int request_id,
+                                                     bool should_allow) {
+  DownloadRequestMap::iterator download_request_iter =
+      download_request_callback_map_.find(request_id);
+  if (download_request_iter == download_request_callback_map_.end()) {
+    LOG(INFO) << "Not a valid request ID.";
+    return;
+  }
+
+  const base::Callback<void(bool)>& can_download_callback =
+    download_request_iter->second;
+  can_download_callback.Run(should_allow);
+}
+
 void BrowserPluginGuest::OnRespondPermissionGeolocation(
     int request_id, bool should_allow) {
   if (should_allow && embedder_web_contents_) {
     // If renderer side embedder decides to allow gelocation, we need to check
     // if the app/embedder itself has geolocation access.
     BrowserContext* browser_context =
         embedder_web_contents_->GetBrowserContext();
     if (browser_context) {
       GeolocationPermissionContext* geolocation_context =
           browser_context->GetGeolocationPermissionContext();
@@ skipping 59 matching lines @@
   if (!guest) {
     LOG(INFO) << "Guest not found. Instance ID: " << instance_id;
     return;
   }
   if (!should_allow)
     guest->Destroy();
   // If we do not destroy the guest then we allow the new window.
   new_window_request_map_.erase(new_window_request_iter);
 }
 
+void BrowserPluginGuest::DidRetrieveDownloadURLFromRequestId(
+    const std::string& request_method,
+    int permission_request_id,
+    const std::string& url) {
+  if (url.empty()) {
+    OnRespondPermissionDownload(permission_request_id,
+                                false /* should_allow */);
+    return;
+  }
+
+  base::DictionaryValue request_info;
+  request_info.Set(browser_plugin::kRequestMethod,
+                   base::Value::CreateStringValue(request_method));
+  request_info.Set(browser_plugin::kURL, base::Value::CreateStringValue(url));
+
+  SendMessageToEmbedder(
+      new BrowserPluginMsg_RequestPermission(instance_id(),
+          BrowserPluginPermissionTypeDownload, permission_request_id,
+          request_info));
+}
+
 }  // namespace content