Changing minidump process generation to be in-process on Android.

content/browser/renderer_host/render_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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 477 matching lines @@
 #if !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
     // In-process plugins require this to be a UI message loop.
     options.message_loop_type = MessageLoop::TYPE_UI;
 #else
     // We can't have multiple UI loops on GTK and Android, so we don't support
     // in-process plugins.
     options.message_loop_type = MessageLoop::TYPE_DEFAULT;
 #endif
     in_process_renderer_->StartWithOptions(options);
 
-    OnProcessLaunched();  // Fake a callback that the process is ready.
+    // Fake a callback that the process is ready.
+    OnProcessLaunched(content::FDInfoList());
   } else {
     // Build command line for renderer.  We call AppendRendererCommandLine()
     // first so the process type argument will appear first.
     CommandLine* cmd_line = new CommandLine(renderer_path);
     if (!renderer_prefix.empty())
       cmd_line->PrependWrapper(renderer_prefix);
     AppendRendererCommandLine(cmd_line);
     cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
 
     // Spawn the child process asynchronously to avoid blocking the UI thread.
@@ skipping 1019 matching lines @@
   // intercepted the stack is messed up on return from the interceptor
   // which causes random crashes in the browser process. Our hack for now
   // is to not invoke the SetPriorityClass API if the dll is loaded.
   if (GetModuleHandle(L"cbstext.dll"))
     return;
 #endif  // OS_WIN
 
   child_process_launcher_->SetProcessBackgrounded(backgrounded);
 }
 
-void RenderProcessHostImpl::OnProcessLaunched() {
+void RenderProcessHostImpl::OnProcessLaunched(
+      const content::FDInfoList& mapped_files) {
   // No point doing anything, since this object will be destructed soon.  We
   // especially don't want to send the RENDERER_PROCESS_CREATED notification,
   // since some clients might expect a RENDERER_PROCESS_TERMINATED afterwards to
   // properly cleanup.
   if (deleting_soon_)
     return;
 
   if (child_process_launcher_.get()) {
     if (!child_process_launcher_->GetHandle()) {
       OnChannelError();
       return;
     }
 
     child_process_launcher_->SetProcessBackgrounded(backgrounded_);
   }
 
   // NOTE: This needs to be before sending queued messages because
   // ExtensionService uses this notification to initialize the renderer process
   // with state that must be there before any JavaScript executes.
   //
   // The queued messages contain such things as "navigate". If this notification
   // was after, we can end up executing JavaScript before the initialization
   // happens.
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CREATED,
       Source<RenderProcessHost>(this),
-      NotificationService::NoDetails());
+      Details<const content::FDInfoList>(&mapped_files));

[jam, 2012/10/19 16:39:17]

this seems awkward for two reasons:
-it adds seemingly unrelated data to that notification (even though I understand
why you're doing it this way)
-it gives the embedder information (file mapping) that the embedder originally
gave content.

it seems that the ContentBrowserClient::GetAdditionalMappedFilesForChildProcess
call should just be changed to take the child_process_id so that it can
associate the mapping to the process that way.

[Jay Civelli, 2012/10/22 22:09:48]

Changed per our discussion. Now using the process host ID in the crash handler.

 
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 }
 
 void RenderProcessHostImpl::OnUserMetricsRecordAction(
     const std::string& action) {
   RecordComputedAction(action);
@@ skipping 10 matching lines @@
       const gfx::Size& size,
       int32 gpu_process_host_id) {
   TRACE_EVENT0("renderer_host",
                "RenderWidgetHostImpl::OnCompositorSurfaceBuffersSwappedNoHost");
   RenderWidgetHostImpl::AcknowledgeBufferPresent(route_id,
                                                  gpu_process_host_id,
                                                  0);
 }
 
 }  // namespace content