First fix to minimize copying of image data.

chrome/browser/dom_ui/chrome_url_data_manager.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/dom_ui/chrome_url_data_manager.h"
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 32 matching lines @@
   virtual ~URLRequestChromeJob();
 
   // URLRequestJob implementation.
   virtual void Start();
   virtual void Kill();
   virtual bool ReadRawData(net::IOBuffer* buf, int buf_size, int *bytes_read);
   virtual bool GetMimeType(std::string* mime_type) const;
 
   // Called by ChromeURLDataManager to notify us that the data blob is ready
   // for us.
-  void DataAvailable(RefCountedBytes* bytes);
+  void DataAvailable(RefCountedMemory* bytes);
 
   void SetMimeType(const std::string& mime_type) {
     mime_type_ = mime_type;
   }
 
  private:
   // Helper for Start(), to let us start asynchronously.
   // (This pattern is shared by most URLRequestJob implementations.)
   void StartAsync();
 
   // Do the actual copy from data_ (the data we're serving) into |buf|.
   // Separate from ReadRawData so we can handle async I/O.
   void CompleteRead(net::IOBuffer* buf, int buf_size, int* bytes_read);
 
   // The actual data we're serving.  NULL until it's been fetched.
-  scoped_refptr<RefCountedBytes> data_;
+  scoped_refptr<RefCountedMemory> data_;
   // The current offset into the data that we're handing off to our
   // callers via the Read interfaces.
   int data_offset_;
 
   // For async reads, we keep around a pointer to the buffer that
   // we're reading into.
   scoped_refptr<net::IOBuffer> pending_buf_;
   int pending_buf_size_;
   std::string mime_type_;
 
@@ skipping 171 matching lines @@
        i != pending_requests_.end(); ++i) {
     if (i->second == job) {
       pending_requests_.erase(i);
       return;
     }
   }
 }
 
 void ChromeURLDataManager::DataAvailable(
     RequestID request_id,
-    scoped_refptr<RefCountedBytes> bytes) {
+    scoped_refptr<RefCountedMemory> bytes) {
   // Forward this data on to the pending URLRequest, if it exists.
   PendingRequestMap::iterator i = pending_requests_.find(request_id);
   if (i != pending_requests_.end()) {
     // We acquire a reference to the job so that it doesn't disappear under the
     // feet of any method invoked here (we could trigger a callback).
     scoped_refptr<URLRequestChromeJob> job = i->second;
     pending_requests_.erase(i);
     job->DataAvailable(bytes);
   }
 }
 
 void ChromeURLDataManager::DataSource::SendResponse(
     RequestID request_id,
-    RefCountedBytes* bytes) {
+    RefCountedMemory* bytes) {
   ChromeThread::GetMessageLoop(ChromeThread::IO)->PostTask(FROM_HERE,
       NewRunnableMethod(&chrome_url_data_manager,
                         &ChromeURLDataManager::DataAvailable,
-                        request_id, scoped_refptr<RefCountedBytes>(bytes)));
+                        request_id, scoped_refptr<RefCountedMemory>(bytes)));
 }
 
 MessageLoop* ChromeURLDataManager::DataSource::MessageLoopForRequestPath(
     const std::string& path) const {
   return message_loop_;
 }
 
 // static
 void ChromeURLDataManager::DataSource::SetFontAndTextDirection(
     DictionaryValue* localized_strings) {
@@ skipping 71 matching lines @@
 
 void URLRequestChromeJob::Kill() {
   chrome_url_data_manager.RemoveRequest(this);
 }
 
 bool URLRequestChromeJob::GetMimeType(std::string* mime_type) const {
   *mime_type = mime_type_;
   return !mime_type_.empty();
 }
 
-void URLRequestChromeJob::DataAvailable(RefCountedBytes* bytes) {
+void URLRequestChromeJob::DataAvailable(RefCountedMemory* bytes) {
   if (bytes) {
     // The request completed, and we have all the data.
     // Clear any IO pending status.
     SetStatus(URLRequestStatus());
 
     data_ = bytes;
     int bytes_read;
     if (pending_buf_.get()) {
       CHECK(pending_buf_->data());
       CompleteRead(pending_buf_, pending_buf_size_, &bytes_read);
@@ skipping 17 matching lines @@
     return false;  // Tell the caller we're still waiting for data.
   }
 
   // Otherwise, the data is available.
   CompleteRead(buf, buf_size, bytes_read);
   return true;
 }
 
 void URLRequestChromeJob::CompleteRead(net::IOBuffer* buf, int buf_size,
                                        int* bytes_read) {
-  int remaining = static_cast<int>(data_->data.size()) - data_offset_;
+  int remaining = static_cast<int>(data_->size()) - data_offset_;
   if (buf_size > remaining)
     buf_size = remaining;
   if (buf_size > 0) {
-    memcpy(buf->data(), &data_->data[0] + data_offset_, buf_size);
+    memcpy(buf->data(), data_->front() + data_offset_, buf_size);
     data_offset_ += buf_size;
   }
   *bytes_read = buf_size;
 }
 
 void URLRequestChromeJob::StartAsync() {
   if (!request_)
     return;
 
   if (chrome_url_data_manager.StartRequest(request_->url(), this)) {
     NotifyHeadersComplete();
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED,
                                       net::ERR_INVALID_URL));
   }
 }
 
 URLRequestChromeFileJob::URLRequestChromeFileJob(URLRequest* request,
                                                  const FilePath& path)
     : URLRequestFileJob(request, path) {
 }
 
 URLRequestChromeFileJob::~URLRequestChromeFileJob() { }