text: // Copyright 2013 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/browser/crash_dump_manager_android.h"
  
  #include "base/bind.h"
  #include "base/file_util.h"
  #include "base/format_macros.h"
  #include "base/logging.h"
  #include "base/posix/global_descriptors.h"
  #include "base/process/process.h"
  #include "base/rand_util.h"
  #include "base/stl_util.h"
  #include "base/strings/stringprintf.h"
  #include "content/public/browser/browser_thread.h"
  #include "content/public/browser/child_process_data.h"
  #include "content/public/browser/file_descriptor_info.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 {
  
  // static
  CrashDumpManager* CrashDumpManager::instance_ = NULL;
  
  // static
  CrashDumpManager* CrashDumpManager::GetInstance() {
    return instance_;
  }
  
  CrashDumpManager::CrashDumpManager(const base::FilePath& crash_dump_dir)
      : crash_dump_dir_(crash_dump_dir) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    DCHECK(!instance_);
  
    instance_ = this;
  
    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);
  }
  
  CrashDumpManager::~CrashDumpManager() {
    instance_ = NULL;
  
    BrowserChildProcessObserver::Remove(this);
  }
  
  base::File CrashDumpManager::CreateMinidumpFile(int child_process_id) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER));
    base::FilePath minidump_path;
    if (!base::CreateTemporaryFile(&minidump_path))
      return base::File();
  
    // We need read permission as the minidump is generated in several phases
    // and needs to be read at some point.
    int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
                base::File::FLAG_WRITE;
    base::File minidump_file(minidump_path, flags);
    if (!minidump_file.IsValid()) {
      LOG(ERROR) << "Failed to create temporary file, crash won't be reported.";
      return base::File();
    }
  
    {
      base::AutoLock auto_lock(child_process_id_to_minidump_path_lock_);
      DCHECK(!ContainsKey(child_process_id_to_minidump_path_, child_process_id));
      child_process_id_to_minidump_path_[child_process_id] = minidump_path;
    }
    return minidump_file.Pass();
  }
  
  // static
  void CrashDumpManager::ProcessMinidump(const base::FilePath& minidump_path,
                                         base::ProcessHandle pid) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
    int64 file_size = 0;
    int r = base::GetFileSize(minidump_path, &file_size);
    DCHECK(r) << "Failed to retrieve size for minidump "
              << minidump_path.value();
  
    if (file_size == 0) {
      // Empty minidump, this process did not crash. Just remove the file.
      r = base::DeleteFile(minidump_path, false);
      DCHECK(r) << "Failed to delete temporary minidump file "
                << minidump_path.value();
      return;
    }
  
    // We are dealing with a valid minidump. Copy it to the crash report
    // directory from where Java code will upload it later on.
    if (instance_->crash_dump_dir_.empty()) {
      NOTREACHED() << "Failed to retrieve the crash dump directory.";
      return;
    }
    const uint64 rand = base::RandUint64();
    const std::string filename =
        base::StringPrintf("chromium-renderer-minidump-%016" PRIx64 ".dmp%d",
                           rand, pid);
    base::FilePath dest_path = instance_->crash_dump_dir_.Append(filename);
    r = base::Move(minidump_path, dest_path);
    if (!r) {
      LOG(ERROR) << "Failed to move crash dump from " << minidump_path.value()
                 << " to " << dest_path.value();
      base::DeleteFile(minidump_path, false);
      return;
    }
    VLOG(1) << "Crash minidump successfully generated: " <<
        instance_->crash_dump_dir_.Append(filename).value();
  }
  
  void CrashDumpManager::BrowserChildProcessHostDisconnected(
      const content::ChildProcessData& data) {
    OnChildExit(data.id, data.handle);
  }
  
  void CrashDumpManager::BrowserChildProcessCrashed(
      const content::ChildProcessData& data) {
    OnChildExit(data.id, data.handle);
  }
  
  void CrashDumpManager::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
    switch (type) {
      case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
        // NOTIFICATION_RENDERER_PROCESS_TERMINATED is sent when the renderer
        // process is cleanly shutdown. However, we need to fallthrough so that
        // we close the minidump_fd we kept open.
      case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
        content::RenderProcessHost* rph =
            content::Source<content::RenderProcessHost>(source).ptr();
        OnChildExit(rph->GetID(), rph->GetHandle());
        break;
      }
      default:
        NOTREACHED();
        return;
    }
  }
  
  void CrashDumpManager::OnChildExit(int child_process_id,
                                     base::ProcessHandle pid) {
    base::FilePath minidump_path;
    {
      base::AutoLock auto_lock(child_process_id_to_minidump_path_lock_);
      ChildProcessIDToMinidumpPath::iterator iter =
          child_process_id_to_minidump_path_.find(child_process_id);
      if (iter == child_process_id_to_minidump_path_.end()) {
        // We might get a NOTIFICATION_RENDERER_PROCESS_TERMINATED and a
        // NOTIFICATION_RENDERER_PROCESS_CLOSED.
        return;
      }
      minidump_path = iter->second;
      child_process_id_to_minidump_path_.erase(iter);
    }
    BrowserThread::PostTask(
        BrowserThread::FILE, FROM_HERE,
        base::Bind(&CrashDumpManager::ProcessMinidump, minidump_path, pid));
  }
  
  }  // namespace breakpad
  