Add possibility to ignore unregistered crash keys. Use this from WebView

base/debug/crash_logging.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.
 
 #include "base/debug/crash_logging.h"
 
 #include <cmath>
 #include <unordered_map>
 
 #include "base/debug/stack_trace.h"
@@ skipping 14 matching lines @@
 typedef std::unordered_map<base::StringPiece, CrashKey, base::StringPieceHash>
     CrashKeyMap;
 CrashKeyMap* g_crash_keys_ = NULL;
 
 // The maximum length of a single chunk.
 size_t g_chunk_max_length_ = 0;
 
 // String used to format chunked key names.
 const char kChunkFormatString[] = "%s-%" PRIuS;
 
+bool g_ignore_unregistered_keys_ = false;
+
 // The functions that are called to actually set the key-value pairs in the
 // crash reportng system.
 SetCrashKeyValueFuncT g_set_key_func_ = NULL;
 ClearCrashKeyValueFuncT g_clear_key_func_ = NULL;
 
 // For a given |length|, computes the number of chunks a value of that size
 // will occupy.
 size_t NumChunksForLength(size_t length) {
   // Compute (length / g_chunk_max_length_), rounded up.
   return (length + g_chunk_max_length_ - 1) / g_chunk_max_length_;
 }
 
 // The longest max_length allowed by the system.
 const size_t kLargestValueAllowed = 2048;
 
 }  // namespace
 
 void SetCrashKeyValue(const base::StringPiece& key,
                       const base::StringPiece& value) {
   if (!g_set_key_func_ || !g_crash_keys_)
     return;
 
   const CrashKey* crash_key = LookupCrashKey(key);
 
+  if (g_ignore_unregistered_keys_ && !crash_key) {
+    return;
+  }
+
   DCHECK(crash_key) << "All crash keys must be registered before use "
                     << "(key = " << key << ")";
 
   // Handle the un-chunked case.
   if (!crash_key || crash_key->max_length <= g_chunk_max_length_) {
     g_set_key_func_(key, value);
     return;
   }
 
   // Unset the unused chunks.
@@ skipping 68 matching lines @@
     : key_(key.as_string()) {
   SetCrashKeyValue(key, value);
 }
 
 ScopedCrashKey::~ScopedCrashKey() {
   ClearCrashKey(key_);
 }
 
 size_t InitCrashKeys(const CrashKey* const keys, size_t count,
                      size_t chunk_max_length) {
+  return InitCrashKeys(keys, count, chunk_max_length,
+                       false /* ignore_unregistered_keys */);
+}
+
+size_t InitCrashKeys(const CrashKey* const keys,
+                     size_t count,
+                     size_t chunk_max_length,
+                     bool ignore_unregistered_keys) {
   DCHECK(!g_crash_keys_) << "Crash logging may only be initialized once";
+  g_ignore_unregistered_keys_ = ignore_unregistered_keys;
   if (!keys) {
     delete g_crash_keys_;
     g_crash_keys_ = NULL;
     return 0;
   }
 
   g_crash_keys_ = new CrashKeyMap;
   g_chunk_max_length_ = chunk_max_length;
 
   size_t total_keys = 0;
@@ skipping 36 matching lines @@
   }
   return chunks;
 }
 
 void ResetCrashLoggingForTesting() {
   delete g_crash_keys_;
   g_crash_keys_ = NULL;
   g_chunk_max_length_ = 0;
   g_set_key_func_ = NULL;
   g_clear_key_func_ = NULL;
+  g_ignore_unregistered_keys_ = false;
 }
 
 }  // namespace debug
 }  // namespace base