Scrub the vestigal breakpad crash dump attempts metrics code.

components/crash/content/app/breakpad_win.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/content/app/breakpad_win.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <stddef.h>
 #include <tchar.h>
@@ skipping 181 matching lines @@
   return profile_type;
 }
 
 namespace {
 
 // This callback is used when we want to get a dump without crashing the
 // process.
 bool DumpDoneCallbackWhenNoCrash(const wchar_t*, const wchar_t*, void*,
                                  EXCEPTION_POINTERS* ex_info,
                                  MDRawAssertionInfo*, bool succeeded) {
-  GetCrashReporterClient()->RecordCrashDumpAttemptResult(
-      false /* is_real_crash */, succeeded);
   return true;
 }
 
 // This callback is executed when the browser process has crashed, after
 // the crash dump has been created. We need to minimize the amount of work
 // done here since we have potentially corrupted process. Our job is to
 // spawn another instance of chrome which will show a 'chrome has crashed'
 // dialog. This code needs to live in the exe and thus has no access to
 // facilities such as the i18n helpers.
 bool DumpDoneCallback(const wchar_t*, const wchar_t*, void*,
                       EXCEPTION_POINTERS* ex_info,
                       MDRawAssertionInfo*, bool succeeded) {
-  GetCrashReporterClient()->RecordCrashDumpAttemptResult(
-      true /* is_real_crash */, succeeded);
   // Check if the exception is one of the kind which would not be solved
   // by simply restarting chrome. In this case we show a message box with
   // and exit silently. Remember that chrome is in a crashed state so we
   // can't show our own UI from this process.
   if (HardErrorHandler(ex_info))
     return true;
 
   if (!GetCrashReporterClient()->AboutToRestart())
     return true;
 
@@ skipping 11 matching lines @@
 }
 
 // flag to indicate that we are already handling an exception.
 volatile LONG handling_exception = 0;
 
 // This callback is used when there is no crash. Note: Unlike the
 // |FilterCallback| below this does not do dupe detection. It is upto the caller
 // to implement it.
 bool FilterCallbackWhenNoCrash(
     void*, EXCEPTION_POINTERS*, MDRawAssertionInfo*) {
-  GetCrashReporterClient()->RecordCrashDumpAttempt(false);
   return true;
 }
 
 // This callback is executed when the Chrome process has crashed and *before*
 // the crash dump is created. To prevent duplicate crash reports we
 // make every thread calling this method, except the very first one,
 // go to sleep.
 bool FilterCallback(void*, EXCEPTION_POINTERS*, MDRawAssertionInfo*) {
   // Capture every thread except the first one in the sleep. We don't
   // want multiple threads to concurrently report exceptions.
   if (::InterlockedCompareExchange(&handling_exception, 1, 0) == 1) {
     ::Sleep(INFINITE);
   }
-  GetCrashReporterClient()->RecordCrashDumpAttempt(true);
   return true;
 }
 
 // Previous unhandled filter. Will be called if not null when we
 // intercept a crash.
 LPTOP_LEVEL_EXCEPTION_FILTER previous_filter = NULL;
 
 // Exception filter used when breakpad is not enabled. We just display
 // the "Do you want to restart" message and then we call the previous filter.
 long WINAPI ChromeExceptionFilter(EXCEPTION_POINTERS* info) {
@@ skipping 300 matching lines @@
     callback = &DumpDoneCallback;
     default_filter = &ChromeExceptionFilter;
   } else if (process_type == L"service") {
     callback = &DumpDoneCallback;
     default_filter = &ServiceExceptionFilter;
   }
 
   if (GetCrashReporterClient()->ShouldCreatePipeName(process_type))
     InitPipeNameEnvVar(is_per_user_install);
 
-  if (process_type == L"browser")
-    GetCrashReporterClient()->InitBrowserCrashDumpsRegKey();
-
   std::unique_ptr<base::Environment> env(base::Environment::Create());
   std::string pipe_name_ascii;
   if (!env->GetVar(kPipeNameVar, &pipe_name_ascii)) {
     // Breakpad is not enabled.  Configuration is managed or the user
     // did not allow Google Update to send crashes.  We need to use
     // our default crash handler instead, but only for the
     // browser/service processes.
     if (default_filter)
       InitDefaultCrashCallback(default_filter);
     return;
@@ skipping 142 matching lines @@
 extern "C" void __declspec(dllexport) __cdecl
 UnregisterNonABICompliantCodeRange(void* start) {
   ExceptionHandlerRecord* record =
       reinterpret_cast<ExceptionHandlerRecord*>(start);
 
   CHECK(RtlDeleteFunctionTable(&record->runtime_function));
 }
 #endif
 
 }  // namespace breakpad