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

chrome/browser/chrome_plugin_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/chrome_plugin_host.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 127 matching lines @@
 // This class manages a network request made by the plugin, also acting as
 // the URLRequest delegate.
 // NOTE: All methods must be called on the IO thread.
 class PluginRequestHandler : public PluginHelper, public URLRequest::Delegate {
  public:
   static PluginRequestHandler* FromCPRequest(CPRequest* request) {
     return ScopableCPRequest::GetData<PluginRequestHandler*>(request);
   }
 
   PluginRequestHandler(ChromePluginLib* plugin, ScopableCPRequest* cprequest)
-      : PluginHelper(plugin), cprequest_(cprequest) {
+      : PluginHelper(plugin), cprequest_(cprequest), user_buffer_(NULL) {
     cprequest_->data = this;  // see FromCPRequest().
 
     URLRequestContext* context = CPBrowsingContextManager::Instance()->
         ToURLRequestContext(cprequest_->context);
     // TODO(mpcomplete): remove fallback case when Gears support is prevalent.
     if (!context)
       context = Profile::GetDefaultRequestContext();
 
     GURL gurl(cprequest_->url);
     request_.reset(new URLRequest(gurl, this));
     request_->set_context(context);
     request_->set_method(cprequest_->method);
     request_->set_load_flags(PluginResponseUtils::CPLoadFlagsToNetFlags(0));
   }
 
   URLRequest* request() { return request_.get(); }
 
+  // Wraper of URLRequest::Read()
+  bool Read(char* dest, int dest_size, int *bytes_read) {
+    CHECK(!my_buffer_.get());
+    // We'll use our own buffer until the read actually completes.
+    user_buffer_ = dest;
+    my_buffer_ = new net::IOBuffer(dest_size);
+
+    if (request_->Read(my_buffer_, dest_size, bytes_read)) {
+      memcpy(dest, my_buffer_->data(), *bytes_read);
+      my_buffer_ = NULL;
+      return true;
+    }
+
+    if (!request_->status().is_io_pending())
+      my_buffer_ = NULL;
+
+    return false;
+  }
+
   // URLRequest::Delegate
   virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url) {
     plugin_->functions().response_funcs->received_redirect(
         cprequest_.get(), new_url.spec().c_str());
   }
 
   virtual void OnResponseStarted(URLRequest* request) {
     // TODO(mpcomplete): better error codes
     CPError result =
         request_->status().is_success() ? CPERR_SUCCESS : CPERR_FAILURE;
     plugin_->functions().response_funcs->start_completed(
         cprequest_.get(), result);
   }
 
   virtual void OnReadCompleted(URLRequest* request, int bytes_read) {
-    // TODO(mpcomplete): better error codes
-    if (bytes_read < 0)
+    CHECK(my_buffer_.get());
+    CHECK(user_buffer_);
+    if (bytes_read > 0) {
+      memcpy(user_buffer_, my_buffer_->data(), bytes_read);
+    } else if (bytes_read < 0) {
+      // TODO(mpcomplete): better error codes
       bytes_read = CPERR_FAILURE;
+    }
+    my_buffer_ = NULL;
     plugin_->functions().response_funcs->read_completed(
-      cprequest_.get(), bytes_read);
+        cprequest_.get(), bytes_read);
   }
 
  private:
   scoped_ptr<ScopableCPRequest> cprequest_;
   scoped_ptr<URLRequest> request_;
+  scoped_refptr<net::IOBuffer> my_buffer_;
+  char* user_buffer_;
 };
 
 // This class manages plugins that want to handle UI commands.  Right now, we
 // only allow 1 plugin to do this, so there's only ever 1 instance of this
 // class at once.
 // NOTE: All methods must be called on the IO thread.
 class PluginCommandHandler : public PluginHelper {
  public:
   static void HandleCommand(int command,
                             CPCommandInterface* data,
@@ skipping 406 matching lines @@
   return PluginResponseUtils::GetResponseInfo(
       handler->request()->response_headers(), type, buf, buf_size);
 }
 
 int STDCALL CPR_Read(CPRequest* request, void* buf, uint32 buf_size) {
   CHECK(ChromePluginLib::IsPluginThread());
   PluginRequestHandler* handler = PluginRequestHandler::FromCPRequest(request);
   CHECK(handler);
 
   int bytes_read;
-  if (handler->request()->Read(static_cast<char*>(buf), buf_size, &bytes_read))
+  if (handler->Read(static_cast<char*>(buf), buf_size, &bytes_read))
     return bytes_read;  // 0 == CPERR_SUCESS
 
   if (handler->request()->status().is_io_pending())
     return CPERR_IO_PENDING;
 
   return CPERR_FAILURE;
 }
 
 CPBool STDCALL CPB_IsPluginProcessRunning(CPID id) {
   CHECK(ChromePluginLib::IsPluginThread());
@@ skipping 136 matching lines @@
 void CPHandleCommand(int command, CPCommandInterface* data,
                      CPBrowsingContext context) {
   // Sadly if we try and pass context through, we seem to break cl's little
   // brain trying to compile the Tuple3 ctor. This cast works.
   int32 context_as_int32 = static_cast<int32>(context);
   // Plugins can only be accessed on the IO thread.
   g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
       NewRunnableFunction(PluginCommandHandler::HandleCommand,
                           command, data, context_as_int32));
 }