Ignore kill termination status when shutting down a child process.

content/common/child_process_host_impl.cc

 // Copyright (c) 2012 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 "content/common/child_process_host_impl.h"
 
 #include <limits>
 
 #include "base/atomic_sequence_num.h"
 #include "base/command_line.h"
@@ skipping 67 matching lines @@
 
   // On most platforms, the child executable is the same as the current
   // executable.
   if (child_path.empty())
     PathService::Get(CHILD_PROCESS_EXE, &child_path);
   return child_path;
 }
 
 ChildProcessHostImpl::ChildProcessHostImpl(ChildProcessHostDelegate* delegate)
     : delegate_(delegate),
-      opening_channel_(false) {
+      opening_channel_(false),
+      is_shutting_down_(false) {
 #if defined(OS_WIN)
   AddFilter(new FontCacheDispatcher());
 #endif
 
 #if USE_ATTACHMENT_BROKER
 #if defined(OS_MACOSX)
   // On Mac, the privileged AttachmentBroker needs a reference to the Mach port
   // Provider, which is only available in the chrome/ module. The attachment
   // broker must already be created.
   DCHECK(IPC::AttachmentBroker::GetGlobal());
@@ skipping 24 matching lines @@
 
 void ChildProcessHostImpl::AddFilter(IPC::MessageFilter* filter) {
   filters_.push_back(filter);
 
   if (channel_)
     filter->OnFilterAdded(channel_.get());
 }
 
 void ChildProcessHostImpl::ForceShutdown() {
   Send(new ChildProcessMsg_Shutdown());
+  is_shutting_down_ = true;
+}
+
+bool ChildProcessHostImpl::IsShuttingDown() {
+  return is_shutting_down_;
 }
 
 std::string ChildProcessHostImpl::CreateChannelMojo(
     const std::string& child_token) {
   DCHECK(channel_id_.empty());
   channel_id_ = mojo::edk::GenerateRandomToken();
   mojo::ScopedMessagePipeHandle host_handle =
       mojo::edk::CreateParentMessagePipe(channel_id_, child_token);
   channel_ = IPC::ChannelMojo::Create(std::move(host_handle),
                                       IPC::Channel::MODE_SERVER, this);
@@ skipping 180 matching lines @@
   delegate_->OnBadMessageReceived(message);
 }
 
 void ChildProcessHostImpl::OnAllocateSharedMemory(
     uint32_t buffer_size,
     base::SharedMemoryHandle* handle) {
   AllocateSharedMemory(buffer_size, peer_process_.Handle(), handle);
 }
 
 void ChildProcessHostImpl::OnShutdownRequest() {
-  if (delegate_->CanShutdown())
+  if (delegate_->CanShutdown()) {
     Send(new ChildProcessMsg_Shutdown());
+    is_shutting_down_ = true;
+  }
 }
 
 void ChildProcessHostImpl::OnAllocateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     uint32_t width,
     uint32_t height,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gfx::GpuMemoryBufferHandle* handle) {
   // TODO(reveman): Add support for other types of GpuMemoryBuffers.
 
   // AllocateForChildProcess() will check if |width| and |height| are valid
   // and handle failure in a controlled way when not. We just need to make
   // sure |usage| is supported here.
   if (gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage)) {
     *handle = gpu::GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
         id, gfx::Size(width, height), format, peer_process_.Handle());
   }
 }
 
 void ChildProcessHostImpl::OnDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gpu::SyncToken& sync_token) {
   // Note: Nothing to do here as ownership of shared memory backed
   // GpuMemoryBuffers is passed with IPC.
 }
 
 }  // namespace content