Refactor CrashDump*Manager to use a shared CrashDumpObserver singleton.

components/crash/content/browser/crash_dump_observer_android.cc

+// Copyright 2015 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 "components/crash/content/browser/crash_dump_observer_android.h"
+
+#include <unistd.h>
+
+#include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_data.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
+
+using content::BrowserThread;
+
+namespace breakpad {
+
+CrashDumpObserver::Client::Client() {}
+
+CrashDumpObserver::Client::~Client() {}
+
+namespace {
+base::LazyInstance<CrashDumpObserver> g_instance = LAZY_INSTANCE_INITIALIZER;
+}
+
+// static
+void CrashDumpObserver::Create() {
+  GetInstance();
+}
+
+// static
+CrashDumpObserver* CrashDumpObserver::GetInstance() {
+  return g_instance.Pointer();
+}
+
+CrashDumpObserver::CrashDumpObserver() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                              content::NotificationService::AllSources());
+  notification_registrar_.Add(this,
+                              content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                              content::NotificationService::AllSources());
+  BrowserChildProcessObserver::Add(this);
+}
+
+CrashDumpObserver::~CrashDumpObserver() {
+  BrowserChildProcessObserver::Remove(this);
+}
+
+void CrashDumpObserver::OnChildExit(int child_process_id,
+                                    base::ProcessHandle pid,
+                                    content::ProcessType process_type,
+                                    base::TerminationStatus termination_status,
+                                    base::android::ApplicationState app_state) {
+  base::AutoLock auto_lock(registered_clients_lock_);
+  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
+  base::SequencedWorkerPool::SequenceToken token = pool->GetSequenceToken();
+
+  for (auto& client : registered_clients_) {
+    pool->PostSequencedWorkerTask(

[michaelbai, 2016/11/29 23:31:32]

WebView wants know this immediately, sets all WebView API noop and calls crash
handle API. Code here might pass whether application should be crashed according
the return value of crash handle API.

This doesn't have to be done in this patch.

[Tobias Sargeant, 2016/12/08 16:41:42]

The notifications this code relies upon are already delivered on the UI thread
asynchronously, and the aim of this is to do I/O operations to process minidumps
or to read from the exit code pipe, so must be posted to the FILE thread anyway.

We also need to preserve the ordering of processing steps, once these steps are
chained (we can't terminate the browser process before minidump management has
happened or we lose crashes).

+        token, FROM_HERE,
+        base::Bind(&Client::OnChildExit, client, child_process_id, pid,
+                   process_type, termination_status, app_state));
+  }
+}
+
+void CrashDumpObserver::RegisterClient(scoped_refptr<Client> client) {
+  base::AutoLock auto_lock(registered_clients_lock_);
+  if (!ContainsValue(registered_clients_, client))
+    registered_clients_.push_back(std::move(client));
+}
+
+void CrashDumpObserver::UnregisterClient(scoped_refptr<Client> client) {
+  base::AutoLock auto_lock(registered_clients_lock_);
+  registered_clients_.erase(std::remove(registered_clients_.begin(),
+                                        registered_clients_.end(), client),
+                            registered_clients_.end());
+}
+
+void CrashDumpObserver::BrowserChildProcessStarted(
+    int child_process_id,
+    content::FileDescriptorInfo* mappings) {
+  std::vector<scoped_refptr<Client>> registered_clients_copy;
+  {
+    base::AutoLock auto_lock(registered_clients_lock_);
+    registered_clients_copy = registered_clients_;
+  }
+  for (auto& client : registered_clients_copy) {
+    client->OnChildStart(child_process_id, mappings);
+  }
+}
+
+void CrashDumpObserver::BrowserChildProcessHostDisconnected(
+    const content::ChildProcessData& data) {
+  OnChildExit(data.id, data.handle,
+              static_cast<content::ProcessType>(data.process_type),
+              base::TERMINATION_STATUS_MAX_ENUM,
+              base::android::APPLICATION_STATE_UNKNOWN);
+}
+
+void CrashDumpObserver::BrowserChildProcessCrashed(
+    const content::ChildProcessData& data,
+    int exit_code) {
+  OnChildExit(data.id, data.handle,
+              static_cast<content::ProcessType>(data.process_type),
+              base::TERMINATION_STATUS_ABNORMAL_TERMINATION,
+              base::android::APPLICATION_STATE_UNKNOWN);
+}
+
+void CrashDumpObserver::Observe(int type,
+                                const content::NotificationSource& source,
+                                const content::NotificationDetails& details) {
+  content::RenderProcessHost* rph =
+      content::Source<content::RenderProcessHost>(source).ptr();
+  base::TerminationStatus term_status = base::TERMINATION_STATUS_MAX_ENUM;
+  base::android::ApplicationState app_state =
+      base::android::APPLICATION_STATE_UNKNOWN;
+  switch (type) {
+    case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
+      // NOTIFICATION_RENDERER_PROCESS_TERMINATED is sent when the renderer
+      // process is cleanly shutdown.
+      term_status = base::TERMINATION_STATUS_NORMAL_TERMINATION;
+      break;
+    }
+    case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
+      // We do not care about android fast shutdowns as it is a known case where
+      // the renderer is intentionally killed when we are done with it.
+      if (rph->FastShutdownStarted()) {
+        break;
+      }
+      content::RenderProcessHost::RendererClosedDetails* process_details =
+          content::Details<content::RenderProcessHost::RendererClosedDetails>(
+              details)
+              .ptr();
+      term_status = process_details->status;
+      app_state = base::android::ApplicationStatusListener::GetState();
+      break;
+    }
+    default:
+      NOTREACHED();
+      return;
+  }
+
+  OnChildExit(rph->GetID(), rph->GetHandle(), content::PROCESS_TYPE_RENDERER,
+              term_status, app_state);
+}
+
+}  // namespace breakpad