Add Resource Handler for creating Streams to forward to extensions

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_resource_throttle.h"
 #include "chrome/browser/download/download_util.h"
+#include "chrome/browser/extensions/api/streams_private/streams_private_api.h"
 #include "chrome/browser/extensions/api/streams_private/streams_resource_throttle.h"
+#include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/user_script_listener.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/metrics/variations/variations_http_header_provider.h"
 #include "chrome/browser/net/load_timing_observer.h"
 #include "chrome/browser/net/resource_prefetch_predictor_observer.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/prerender/prerender_util.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/renderer_host/chrome_url_request_user_data.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_throttle_factory.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/auto_login_prompter.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/sync/one_click_signin_helper.h"
 #include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/mime_types_handler.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/resource_request_info.h"
+#include "content/public/browser/stream_handle.h"
+#include "extensions/common/constants.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/url_request/url_request.h"
 
 #if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/managed_mode/managed_mode_resource_throttle.h"
 #endif
 
 #if defined(USE_SYSTEM_PROTOBUF)
 #include <google/protobuf/repeated_field.h>
 #else
 #include "third_party/protobuf/src/google/protobuf/repeated_field.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "components/navigation_interception/intercept_navigation_delegate.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/merge_session_throttle.h"
 // TODO(oshima): Enable this for other platforms.
 #include "chrome/browser/renderer_host/offline_resource_throttle.h"
 #endif
 
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::ResourceDispatcherHostLoginDelegate;
 using content::ResourceRequestInfo;
+using extensions::Extension;
 
 namespace {
 
 void NotifyDownloadInitiatedOnUI(int render_process_id, int render_view_id) {
   RenderViewHost* rvh = RenderViewHost::FromID(render_process_id,
                                                render_view_id);
   if (!rvh)
     return;
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_DOWNLOAD_INITIATED,
       content::Source<RenderViewHost>(rvh),
       content::NotificationService::NoDetails());
 }
 
+// Goes through the extension's file browser handlers and checks if there is one
+// that can handle the |mime_type|.
+// |extension| must not be NULL.
+bool ExtensionCanHandleMimeType(const Extension* extension,
+                                const std::string& mime_type) {
+  MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
+  if (!handler)
+    return false;
+
+  return handler->CanHandleMIMEType(mime_type);
+}
+
+// Retrieves Profile for a render view host specified by |render_process_id| and
+// |render_view_id|.
+Profile* GetProfile(int render_process_id, int render_view_id) {
+  content::RenderViewHost* render_view_host =
+      content::RenderViewHost::FromID(render_process_id, render_view_id);
+  if (!render_view_host)
+    return NULL;
+
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderViewHost(render_view_host);
+  if (!web_contents)
+    return NULL;
+
+  content::BrowserContext* browser_context = web_contents->GetBrowserContext();
+  if (!browser_context)
+    return NULL;
+
+  return Profile::FromBrowserContext(browser_context);
+}
+
+void SendExecuteMimeTypeHandlerEvent(const std::string& mime_type,
+                                     scoped_ptr<content::StreamHandle> stream,
+                                     const GURL& original_url,
+                                     int render_process_id,
+                                     int render_view_id,
+                                     const std::string& extension_id) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  Profile* profile = GetProfile(render_process_id, render_view_id);
+  if (!profile)
+    return;
+
+  extensions::StreamsPrivateAPI::Get(profile)->ExecuteMimeTypeHandler(
+      extension_id,
+      stream.Pass(),
+      mime_type,
+      original_url);
+}
+
 }  // end namespace
 
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate(
     prerender::PrerenderTracker* prerender_tracker)
     : download_request_limiter_(g_browser_process->download_request_limiter()),
       safe_browsing_(g_browser_process->safe_browsing_service()),
       user_script_listener_(new extensions::UserScriptListener()),
       prerender_tracker_(prerender_tracker) {
 }
 
@@ skipping 284 matching lines @@
   }
 }
 #endif
 
 bool ChromeResourceDispatcherHostDelegate::ShouldForceDownloadResource(
     const GURL& url, const std::string& mime_type) {
   // Special-case user scripts to get downloaded instead of viewed.
   return extensions::UserScript::IsURLUserScript(url, mime_type);
 }
 
+bool ChromeResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
+    content::ResourceContext* resource_context,
+    const GURL& url,
+    const std::string& mime_type,
+    GURL* security_origin,
+    std::string* target_id) {
+  ProfileIOData* io_data =
+      ProfileIOData::FromResourceContext(resource_context);
+  bool profile_is_incognito = io_data->is_incognito();
+  const scoped_refptr<const ExtensionInfoMap> extension_info_map(
+      io_data->GetExtensionInfoMap());
+  std::vector<std::string> whitelist = MimeTypesHandler::GetMIMETypeWhitelist();
+  // Go through the white-listed extensions and try to use them to intercept
+  // the URL request.
+  for (size_t i = 0; i < whitelist.size(); ++i) {
+    const char* extension_id = whitelist[i].c_str();
+    const Extension* extension =
+        extension_info_map->extensions().GetByID(extension_id);
+    // The white-listed extension may not be installed, so we have to NULL check
+    // |extension|.
+    if (!extension ||
+        (profile_is_incognito &&
+         !extension_info_map->IsIncognitoEnabled(extension_id))) {
+      continue;
+    }
+
+    if (ExtensionCanHandleMimeType(extension, mime_type)) {
+      *security_origin = Extension::GetBaseURLFromExtensionId(extension_id);
+      *target_id = extension_id;
+      return true;
+    }
+  }
+  return false;
+}
+
+void ChromeResourceDispatcherHostDelegate::OnStreamCreated(
+    content::ResourceContext* resource_context,
+    int render_process_id,
+    int render_view_id,
+    const std::string& target_id,
+    scoped_ptr<content::StreamHandle> stream,
+    const std::string& mime_type,
+    const GURL& original_url) {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&SendExecuteMimeTypeHandlerEvent, mime_type,
+                 base::Passed(&stream), original_url,
+                 render_process_id, render_view_id,
+                 target_id));
+}
+
 void ChromeResourceDispatcherHostDelegate::OnResponseStarted(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::ResourceResponse* response,
     IPC::Sender* sender) {
   LoadTimingObserver::PopulateTimingInfo(request, response);
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 
   if (request->url().SchemeIsSecure()) {
@@ skipping 75 matching lines @@
   int child_id, route_id;
   if (!prerender::PrerenderManager::DoesURLHaveValidScheme(redirect_url) &&
       ResourceRequestInfo::ForRequest(request)->GetAssociatedRenderView(
           &child_id, &route_id) &&
       prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id)) {
     prerender_tracker_->TryCancel(
         child_id, route_id, prerender::FINAL_STATUS_UNSUPPORTED_SCHEME);
     request->Cancel();
   }
 }