Add WebView-specific whitelist for crash keys.

components/crash/content/app/breakpad_linux.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.
 
 // For linux_syscall_support.h. This makes it safe to call embedded system
 // calls when in seccomp mode.
 
 #include "components/crash/content/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 12 matching lines @@
 #include <unistd.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/files/file_path.h"
+#include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/linux_util.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/global_descriptors.h"
 #include "base/process/memory.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/threading/thread_checker.h"
 #include "breakpad/src/client/linux/crash_generation/crash_generation_client.h"
 #include "breakpad/src/client/linux/handler/exception_handler.h"
 #include "breakpad/src/client/linux/minidump_writer/directory_reader.h"
 #include "breakpad/src/common/linux/linux_libc_support.h"
 #include "breakpad/src/common/memory.h"
 #include "build/build_config.h"
 #include "components/crash/content/app/breakpad_linux_impl.h"
 #include "components/crash/content/app/crash_reporter_client.h"
 #include "components/crash/core/common/crash_keys.h"
@@ skipping 1039 matching lines @@
       MinidumpDescriptor("/tmp"),  // Unused but needed or Breakpad will assert.
       nullptr,
       nullptr,
       nullptr,
       true,
       -1);
   g_breakpad->set_crash_generation_client(new NonBrowserCrashHandler());
 }
 #endif  // defined(OS_ANDROID)
 
+bool g_use_crash_keys_whitelist;
+std::vector<const char*> g_crash_keys_whitelist;
+
+void SetupCrashKeysWhiteList(bool use_white_list,
+                             const std::vector<const char*>& keys) {
+  g_use_crash_keys_whitelist = use_white_list;
+  g_crash_keys_whitelist = keys;
+  LOG(ERROR) << "in SetupCrashKeysWhiteList, whitelist length: " << keys.size();
+  for (size_t i = 0; i < keys.size(); ++i) {
+    LOG(ERROR) << "in SetupCrashKeysWhiteList, entry: "
+               << g_crash_keys_whitelist.data()[i];
+  }
+}
+
+bool IsInWhiteList(const base::StringPiece& key) {
+  for (size_t i = 0; i < g_crash_keys_whitelist.size(); ++i) {
+    LOG(ERROR) << "in SetupCrashKeysWhiteList, entry: "
+               << g_crash_keys_whitelist.data()[i];
+    if (0 == my_strcmp(g_crash_keys_whitelist.data()[i], key.data())) {
+      return true;
+    }
+  }
+  return false;
+}
+
 void SetCrashKeyValue(const base::StringPiece& key,
                       const base::StringPiece& value) {
-  g_crash_keys->SetKeyValue(key.data(), value.data());
+  LOG(ERROR) << "in SetCrashKeyValue for key " << key.data();
+  if (!g_use_crash_keys_whitelist || IsInWhiteList(key)) {
+    LOG(ERROR) << "in SetCrashKeyValue for key " << key.data()
+               << " it is in the whitelist :D";
+    g_crash_keys->SetKeyValue(key.data(), value.data());
+  } else {
+    LOG(ERROR) << "in SetCrashKeyValue for key " << key.data()
+               << ", not in the whitelist";
+  }
 }
 
 void ClearCrashKey(const base::StringPiece& key) {
   g_crash_keys->RemoveKey(key.data());
 }
 
 // GetCrashReporterClient() cannot call any Set methods until after
 // InitCrashKeys().
 void InitCrashKeys() {
   g_crash_keys = new CrashKeyStorage;
   GetCrashReporterClient()->RegisterCrashKeys();
+  SetupCrashKeysWhiteList(GetCrashReporterClient()->UseCrashKeysWhiteList(),
+                          GetCrashReporterClient()->GetWhiteListedCrashKeys());
   base::debug::SetCrashKeyReportingFunctions(&SetCrashKeyValue, &ClearCrashKey);
 }
 
 // Miscellaneous initialization functions to call after Breakpad has been
 // enabled.
 void PostEnableBreakpadInitialization() {
   SetProcessStartTime();
   g_pid = getpid();
 
   base::debug::SetDumpWithoutCrashingFunction(&DumpProcess);
@@ skipping 773 matching lines @@
 
 #if defined(OS_ANDROID)
 // In Android WebView, microdumps are generated conditionally (depending on the
 // cause of the crash) and can be sanitized to prevent exposing unnecessary data
 // from the embedding application.
 void InitCrashReporter(const std::string& process_type) {
   SanitizationInfo sanitization_info;
   InitCrashReporter(process_type, sanitization_info);
 }
 
+void InitCrashKeysForTesting() {
+  InitCrashKeys();
+}
+
 void InitCrashReporter(const std::string& process_type,
                        const SanitizationInfo& sanitization_info) {
 #else
 void InitCrashReporter(const std::string& process_type) {
 #endif  // defined(OS_ANDROID)
   // The maximum lengths specified by breakpad include the trailing NULL, so the
   // actual length of the chunk is one less.
   static_assert(crash_keys::kChunkMaxLength == 63, "kChunkMaxLength mismatch");
   static_assert(crash_keys::kSmallSize <= crash_keys::kChunkMaxLength,
                 "crash key chunk size too small");
@@ skipping 141 matching lines @@
 void SuppressDumpGeneration() {
   g_dumps_suppressed = G_DUMPS_SUPPRESSED_MAGIC;
 }
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad