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

chrome/plugin/webplugin_delegate_stub.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/plugin/webplugin_delegate_stub.h"
 
 #include "base/command_line.h"
 #include "base/time.h"
 #include "base/gfx/platform_device_win.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 208 matching lines @@
   gfx::PlatformDeviceWin::InitializeDC(hdc);
   delegate_->Print(hdc);
   if (!emf.CloseDc()) {
     NOTREACHED();
     return;
   }
 
   size_t size = emf.GetDataSize();
   DCHECK(size);
   params->size = size;
-  SharedMemory shared_buf;
+  base::SharedMemory shared_buf;
   CreateSharedBuffer(size, &shared_buf, &params->shared_memory);
 
   // Retrieve a copy of the data.
   bool success = emf.GetData(shared_buf.memory(), size);
   DCHECK(success);
 }
 
 void WebPluginDelegateStub::OnUpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect,
     const std::vector<gfx::Rect>& cutout_rects,
     bool visible,
-    const SharedMemoryHandle& windowless_buffer,
-    const SharedMemoryHandle& background_buffer) {
+    const base::SharedMemoryHandle& windowless_buffer,
+    const base::SharedMemoryHandle& background_buffer) {
   webplugin_->UpdateGeometry(
       window_rect, clip_rect, cutout_rects, visible, windowless_buffer, 
       background_buffer);
 }
 
 void WebPluginDelegateStub::OnGetPluginScriptableObject(int* route_id,
                                                         void** npobject_ptr) {
   NPObject* object = delegate_->GetPluginScriptableObject();
   if (!object) {
     *route_id = MSG_ROUTING_NONE;
@@ skipping 40 matching lines @@
 void WebPluginDelegateStub::OnDidManualLoadFail() {
   delegate_->DidManualLoadFail();
 }
 
 void WebPluginDelegateStub::OnInstallMissingPlugin() {
   delegate_->InstallMissingPlugin();
 }
 
 void WebPluginDelegateStub::CreateSharedBuffer(
     size_t size,
-    SharedMemory* shared_buf,
-    SharedMemoryHandle* remote_handle) {
+    base::SharedMemory* shared_buf,
+    base::SharedMemoryHandle* remote_handle) {
   if (!shared_buf->Create(std::wstring(), false, false, size)) {
     NOTREACHED();
     return;
   }
   if (!shared_buf->Map(size)) {
     NOTREACHED();
     shared_buf->Close();
     return;
   }
 
   BOOL result = DuplicateHandle(GetCurrentProcess(),
                                 shared_buf->handle(),
                                 channel_->renderer_handle(),
                                 remote_handle, 0, FALSE,
                                 DUPLICATE_SAME_ACCESS);
   DCHECK_NE(result, 0);
+
   // If the calling function's shared_buf is on the stack, its destructor will
   // close the shared memory buffer handle. This is fine since we already
   // duplicated the handle to the renderer process so it will stay "alive".
 }
 
 void WebPluginDelegateStub::OnHandleURLRequestReply(
     const PluginMsg_URLRequestReply_Params& params) {
   WebPluginResourceClient* resource_client =
       delegate_->CreateResourceClient(params.resource_id, params.url,
                                       params.notify_needed,
                                       params.notify_data,
                                       params.stream);
   webplugin_->OnResourceCreated(params.resource_id, resource_client);
 }
 
 void WebPluginDelegateStub::OnURLRequestRouted(const std::string& url,
                                                bool notify_needed,
                                                HANDLE notify_data) {
   delegate_->URLRequestRouted(url, notify_needed, notify_data);
 }