Add Terminate() to the Process object, have RenderProcessHost use this to avo...

chrome/browser/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://wiki.corp.google.com/twiki/bin/view/Main/ChromeMultiProcessResourceLoading
 
 #include <vector>
 
 #include "chrome/browser/resource_dispatcher_host.h"
 
@@ skipping 103 matching lines @@
     return true;
   }
 
   bool OnWillRead(int request_id, char** buf, int* buf_size, int min_size) {
     DCHECK(min_size == -1);
     static const int kReadBufSize = 32768;
     if (spare_read_buffer_) {
       read_buffer_.reset(spare_read_buffer_);
       spare_read_buffer_ = NULL;
     } else {
-      read_buffer_.reset(new SharedMemory);
+      read_buffer_.reset(new base::SharedMemory);
       if (!read_buffer_->Create(std::wstring(), false, false, kReadBufSize))
         return false;
       if (!read_buffer_->Map(kReadBufSize))
         return false;
     }
     *buf = static_cast<char*>(read_buffer_->memory());
     *buf_size = kReadBufSize;
     return true;
   }
 
   bool OnReadCompleted(int request_id, int* bytes_read) {
     if (!*bytes_read)
       return true;
     DCHECK(read_buffer_.get());
 
     if (!rdh_->WillSendData(render_process_host_id_, request_id)) {
       // We should not send this data now, we have too many pending requests.
       return true;
     }
 
-    SharedMemoryHandle handle;
+    base::SharedMemoryHandle handle;
     if (!read_buffer_->GiveToProcess(render_process_, &handle)) {
       // We wrongfully incremented the pending data count. Fake an ACK message
       // to fix this. We can't move this call above the WillSendData because
       // it's killing our read_buffer_, and we don't want that when we pause
       // the request.
       rdh_->OnDataReceivedACK(render_process_host_id_, request_id);
       return false;
     }
 
     receiver_->Send(new ViewMsg_Resource_DataReceived(
@@ skipping 12 matching lines @@
     } else if (read_buffer_.get() && read_buffer_->memory()) {
       spare_read_buffer_ = read_buffer_.release();
     }
     return true;
   }
 
  private:
   // When reading, we don't know if we are going to get EOF (0 bytes read), so
   // we typically have a buffer that we allocated but did not use.  We keep
   // this buffer around for the next read as a small optimization.
-  static SharedMemory* spare_read_buffer_;
+  static base::SharedMemory* spare_read_buffer_;
 
-  scoped_ptr<SharedMemory> read_buffer_;
+  scoped_ptr<base::SharedMemory> read_buffer_;
   ResourceDispatcherHost::Receiver* receiver_;
   int render_process_host_id_;
   int routing_id_;
   HANDLE render_process_;
   ResourceDispatcherHost* rdh_;
 };
-SharedMemory* ResourceDispatcherHost::AsyncEventHandler::spare_read_buffer_;
+
+base::SharedMemory*
+    ResourceDispatcherHost::AsyncEventHandler::spare_read_buffer_;
 
 // ----------------------------------------------------------------------------
 // ResourceDispatcherHost::SyncEventHandler
 
 // Used to complete a synchronous resource request in response to resource load
 // events from the resource dispatcher host.
 class ResourceDispatcherHost::SyncEventHandler
     : public ResourceDispatcherHost::EventHandler {
  public:
   SyncEventHandler(ResourceDispatcherHost::Receiver* receiver,
@@ skipping 2300 matching lines @@
   bool enough_new_progress = (amt_since_last > (size / kHalfPercentIncrements));
   bool too_much_time_passed = time_since_last > kOneSecond;
 
   if (is_finished || enough_new_progress || too_much_time_passed) {
     info->event_handler->OnUploadProgress(info->request_id, position, size);
     info->waiting_for_upload_progress_ack = true;
     info->last_upload_ticks = TimeTicks::Now();
     info->last_upload_position = position;
   }
 }