Change URLRequest to use a ref-counted buffer for actual IO....

chrome/browser/plugin_process_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.
 
 #include "chrome/browser/plugin_process_host.h"
 
 #include <windows.h>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 18 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/debug_flags.h"
 #include "chrome/common/ipc_logging.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/process_watcher.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/win_util.h"
 #include "net/base/cookie_monster.h"
+#include "net/base/io_buffer.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "sandbox/src/sandbox.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 
 static const char kDefaultPluginFinderURL[] =
     "http://dl.google.com/chrome/plugins/plugins2.xml";
 
 // The NotificationTask is used to notify about plugin process connection/
 // disconnection. It is needed because the notifications in the
@@ skipping 71 matching lines @@
  protected:
   void DownloadCompletedHelper(bool success);
 
   // The download file request initiated by the plugin.
   URLRequest* download_file_request_;
   // Handle to the downloaded file.
   HANDLE download_file_;
   // The full path of the downloaded file.
   std::wstring download_file_path_;
   // The buffer passed off to URLRequest::Read.
-  char download_file_buffer_[kDownloadFileBufferSize];
+  scoped_refptr<net::IOBuffer> download_file_buffer_;
   // The window handle for sending the WM_COPYDATA notification,
   // indicating that the download completed.
   HWND download_file_caller_window_;
 
   std::string download_url_;
   int download_source_pid_;
 
   DISALLOW_EVIL_CONSTRUCTORS(PluginDownloadUrlHelper);
 };
 
 PluginDownloadUrlHelper::PluginDownloadUrlHelper(
     const std::string& download_url,
     int source_pid, HWND caller_window)
     : download_url_(download_url),
+      download_file_request_(NULL),
+      download_file_(INVALID_HANDLE_VALUE),
+      download_file_buffer_(new net::IOBuffer(kDownloadFileBufferSize)),
       download_file_caller_window_(caller_window),
-      download_source_pid_(source_pid),
-      download_file_request_(NULL),
-      download_file_(INVALID_HANDLE_VALUE) {
+      download_source_pid_(source_pid) {
   DCHECK(::IsWindow(caller_window));
-  memset(download_file_buffer_, 0, arraysize(download_file_buffer_));
+  memset(download_file_buffer_->data(), 0, kDownloadFileBufferSize);
 }
 
 PluginDownloadUrlHelper::~PluginDownloadUrlHelper() {
   if (download_file_request_) {
     delete download_file_request_;
     download_file_request_ = NULL;
   }
 
   if (download_file_ != INVALID_HANDLE_VALUE) {
     ::CloseHandle(INVALID_HANDLE_VALUE);
@@ skipping 42 matching lines @@
       NOTREACHED();
       OnDownloadCompleted(request);
       return;
     }
   }
   if (!request->status().is_success()) {
     OnDownloadCompleted(request);
   } else {
     // Initiate a read.
     int bytes_read = 0;
-    if (!request->Read(download_file_buffer_, arraysize(download_file_buffer_),
+    if (!request->Read(download_file_buffer_, kDownloadFileBufferSize,
                        &bytes_read)) {
       // If the error is not an IO pending, then we're done
       // reading.
       if (!request->status().is_io_pending()) {
         OnDownloadCompleted(request);
       }
     } else if (bytes_read == 0) {
       OnDownloadCompleted(request);
     } else {
       OnReadCompleted(request, bytes_read);
     }
   }
 }
 
 void PluginDownloadUrlHelper::OnReadCompleted(URLRequest* request,
                                               int bytes_read) {
   DCHECK(download_file_ != INVALID_HANDLE_VALUE);
 
   if (bytes_read == 0) {
     OnDownloadCompleted(request);
     return;
   }
 
   int request_bytes_read = bytes_read;
 
   while (request->status().is_success()) {
     unsigned long bytes_written = 0;
-    BOOL write_result = WriteFile(download_file_, download_file_buffer_,
+    BOOL write_result = WriteFile(download_file_,
+                                  download_file_buffer_->data(),
                                   request_bytes_read, &bytes_written, NULL);
     DCHECK(!write_result || (bytes_written == request_bytes_read));
 
     if (!write_result || (bytes_written != request_bytes_read)) {
       DownloadCompletedHelper(false);
       break;
     }
 
     // Start reading
     request_bytes_read = 0;
-    if (!request->Read(download_file_buffer_, arraysize(download_file_buffer_),
+    if (!request->Read(download_file_buffer_, kDownloadFileBufferSize,
                        &request_bytes_read)) {
       if (!request->status().is_io_pending()) {
         // If the error is not an IO pending, then we're done
         // reading.
         OnDownloadCompleted(request);
       }
       break;
     } else if (request_bytes_read == 0) {
       OnDownloadCompleted(request);
       break;
@@ skipping 668 matching lines @@
 void PluginProcessHost::OnDestroyWindow(HWND window) {
   plugin_service_->main_message_loop()->PostTask(FROM_HERE,
       new DestroyWindowTask(window));
 }
 
 void PluginProcessHost::Shutdown() {
 
   Send(new PluginProcessMsg_BrowserShutdown);
 }