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

chrome/browser/renderer_host/media_resource_handler.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.
+
+#include "chrome/browser/renderer_host/media_resource_handler.h"
+
+#include "base/process.h"
+#include "chrome/common/render_messages.h"
+#include "net/base/load_flags.h"
+
+MediaResourceHandler::MediaResourceHandler(
+    ResourceHandler* resource_handler,
+    ResourceDispatcherHost::Receiver* receiver,
+    int render_process_host_id,
+    int routing_id,
+    base::ProcessHandle render_process,
+    ResourceDispatcherHost* resource_dispatcher_host)
+    : receiver_(receiver),
+      render_process_host_id_(render_process_host_id),
+      routing_id_(routing_id),
+      render_process_(render_process),
+      handler_(resource_handler),
+      rdh_(resource_dispatcher_host),
+      has_file_handle_(false),
+      position_(0),
+      size_(-1) {
+}
+
+bool MediaResourceHandler::OnUploadProgress(int request_id,
+                                            uint64 position,
+                                            uint64 size) {
+  return handler_->OnUploadProgress(request_id, position, size);
+}
+
+bool MediaResourceHandler::OnRequestRedirected(int request_id,
+                                               const GURL& new_url) {
+  return handler_->OnRequestRedirected(request_id, new_url);
+}
+
+bool MediaResourceHandler::OnResponseStarted(int request_id,
+                                             ResourceResponse* response) {
+#if defined(OS_POSIX)
+  if (response->response_head.response_data_file.fd !=
+      base::kInvalidPlatformFileValue) {
+    // On POSIX, we will just set auto_close to true, and the IPC infrastructure
+    // will send this file handle through and close it automatically.
+    response->response_head.response_data_file.auto_close = true;
+    has_file_handle_ = true;
+  }
+#elif defined(OS_WIN)
+  if (response->response_head.response_data_file !=
+      base::kInvalidPlatformFileValue) {
+    // On Windows, we duplicate the file handle for the renderer process and
+    // close the original manually.
+    base::PlatformFile foreign_handle;
+    if (DuplicateHandle(GetCurrentProcess(),
+                        response->response_head.response_data_file,
+                        render_process_,
+                        &foreign_handle,
+                        FILE_READ_DATA,  // Only allow read access to data.
+                        false,           // Foreign handle is not inheritable.
+                        // Close the file handle after duplication.
+                        DUPLICATE_CLOSE_SOURCE)){
+      response->response_head.response_data_file = foreign_handle;
+      has_file_handle_ = true;
+    } else {
+      has_file_handle_ = false;
+    }
+  }
+#endif
+  size_ = response->response_head.content_length;
+  return handler_->OnResponseStarted(request_id, response);
+}
+
+bool MediaResourceHandler::OnWillRead(int request_id,
+                                      net::IOBuffer** buf, int* buf_size,
+                                      int min_size) {
+  return handler_->OnWillRead(request_id, buf, buf_size, min_size);
+}
+
+bool MediaResourceHandler::OnReadCompleted(int request_id, int* bytes_read) {
+  if (has_file_handle_) {
+    // If we have received a file handle before we will be sending a progress
+    // update for download.
+    // TODO(hclam): rate limit this message so we won't be sending too much to
+    // the renderer process.
+    receiver_->Send(
+        new ViewMsg_Resource_DownloadProgress(routing_id_, request_id,
+                                              position_, size_));
+    position_ += *bytes_read;
+  }
+  return handler_->OnReadCompleted(request_id, bytes_read);
+}
+
+bool MediaResourceHandler::OnResponseCompleted(int request_id,
+    const URLRequestStatus& status, const std::string& security_info) {
+  return handler_->OnResponseCompleted(request_id, status, security_info);
+}