IPC messages and changes to ResourceLoaderBridge to support resource loading for media

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2006-2008 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/cert_store.h"
 #include "chrome/browser/cross_site_request_manager.h"
 #include "chrome/browser/download/download_file.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_request_manager.h"
 #include "chrome/browser/download/save_file_manager.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/renderer_host/async_resource_handler.h"
 #include "chrome/browser/renderer_host/buffered_resource_handler.h"
 #include "chrome/browser/renderer_host/cross_site_resource_handler.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
+#include "chrome/browser/renderer_host/media_resource_handler.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/renderer_security_policy.h"
 #include "chrome/browser/renderer_host/resource_request_details.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
 #include "chrome/browser/renderer_host/save_file_resource_handler.h"
 #include "chrome/browser/renderer_host/sync_resource_handler.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tab_contents/web_contents.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/render_messages.h"
@@ skipping 206 matching lines @@
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
     handler = new SyncResourceHandler(receiver, request_data.url, sync_result);
   } else {
     handler = new AsyncResourceHandler(receiver,
                                        process_id,
                                        route_id,
                                        process_handle,
                                        request_data.url,
                                        this);
+    // If the resource type is ResourceType::MEDIA and LOAD_ENABLE_DOWNLOAD_FILE
+    // is enabled we insert a media resource handler.
+    if (request_data.resource_type == ResourceType::MEDIA &&
+        (request_data.load_flags & net::LOAD_ENABLE_DOWNLOAD_FILE)) {
+      handler = new MediaResourceHandler(handler,
+                                         receiver,
+                                         process_id,
+                                         route_id,
+                                         process_handle,
+                                         this);
+    }
   }
 
   if (HandleExternalProtocol(request_id, process_id, route_id,
                              request_data.url, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
   URLRequest* request = new URLRequest(request_data.url, this);
@@ skipping 245 matching lines @@
   if (info->pending_data_count == kMaxPendingDataMessages) {
     // Decrement the pending data count one more time because we also
     // incremented it before pausing the request.
     info->pending_data_count--;
 
     // Resume the request.
     PauseRequest(process_id, request_id, false);
   }
 }
 
+void ResourceDispatcherHost::OnDownloadProgressACK(int process_id,
+                                                   int request_id) {
+  // TODO(hclam): do something to help rate limiting the message.
+}
+
 void ResourceDispatcherHost::OnUploadProgressACK(int process_id,
                                                  int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(process_id, request_id));
   if (i == pending_requests_.end())
     return;
 
   ExtraRequestInfo* info = ExtraInfoForRequest(i->second);
   info->waiting_for_upload_progress_ack = false;
 }
@@ skipping 278 matching lines @@
 
   response->response_head.status = request->status();
   response->response_head.request_time = request->request_time();
   response->response_head.response_time = request->response_time();
   response->response_head.headers = request->response_headers();
   request->GetCharset(&response->response_head.charset);
   response->response_head.filter_policy = info->filter_policy;
   response->response_head.content_length = request->GetExpectedContentSize();
   request->GetMimeType(&response->response_head.mime_type);
 
+  // Make sure we don't get a file handle if LOAD_ENABLE_FILE is not set.
+  DCHECK((request->load_flags() & net::LOAD_ENABLE_DOWNLOAD_FILE) ||
+         request->response_data_file() == base::kInvalidPlatformFileValue);
+#if defined(OS_POSIX)
+  response->response_head.response_data_file.fd = request->response_data_file();
+#elif defined(OS_WIN)
+  response->response_head.response_data_file = request->response_data_file();
+#endif
+
   if (request->ssl_info().cert) {
     int cert_id =
         CertStore::GetSharedInstance()->StoreCert(
             request->ssl_info().cert,
             info->process_id);
     int cert_status = request->ssl_info().cert_status;
     // EV certificate verification could be expensive.  We don't want to spend
     // time performing EV certificate verification on all resources because
     // EV status is irrelevant to sub-frames and sub-resources.  So we call
     // IsEV here rather than in the network layer because the network layer
@@ skipping 601 matching lines @@
     IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost,
                                            info->process_id);
     if (cancel_requests)
       delete req_iter->url_request;
     else
       BeginRequestInternal(req_iter->url_request, req_iter->mixed_content);
   }
 
   delete requests;
 }