Initialize Android CrashDumpManager earlier

components/crash/browser/crash_dump_manager_android.cc

 // 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/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 
 using content::BrowserThread;
 
 namespace breakpad {
 
 // static
 CrashDumpManager* CrashDumpManager::instance_ = NULL;
 
 // static
 CrashDumpManager* CrashDumpManager::GetInstance() {
+  CHECK(instance_);
   return instance_;
 }
 
 CrashDumpManager::CrashDumpManager(const base::FilePath& crash_dump_dir)
     : crash_dump_dir_(crash_dump_dir) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!instance_);
+  CHECK(!instance_);

[Lei Zhang, 2015/01/31 01:14:22]

I haven't looked very hard, but are you worried this code isn't getting
exercised enough as is because it's only executed in official builds without
DCHECKs?

[cjhopman, 2015/01/31 01:20:48]

Thinking about it a bit, I think this one could probably just stay a DCHECK, I'm
not really worried about us calling this twice.

I think I'd keep the two added CHECKs though so that if we have these crashes
again sometime, it'll be obvious that it's because this hasn't been initialized.

 
   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());
 
@@ skipping 27 matching lines @@
     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));
+  CHECK(instance_);
   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();
@@ skipping 66 matching lines @@
     }
     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