Move the CrashKeysWin class to a pair of files as first step.

components/breakpad/app/crash_keys_win.cc

+// Copyright 2014 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/breakpad/app/crash_keys_win.h"
+
+#include <algorithm>
+
+#include "base/base_switches.h"
+#include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "components/breakpad/app/breakpad_client.h"
+
+
+namespace breakpad {
+
+namespace {
+
+const size_t kMaxPluginPathLength = 256;
+const size_t kMaxDynamicEntries = 256;
+
+}  // namespace
+
+CrashKeysWin* CrashKeysWin::keeper_;
+
+CrashKeysWin::CrashKeysWin() : dynamic_keys_offset_(0) {
+  DCHECK_EQ(static_cast<CrashKeysWin*>(NULL), keeper_);
+  keeper_ = this;
+}
+
+CrashKeysWin::~CrashKeysWin() {
+  DCHECK_EQ(this, keeper_);
+  keeper_ = NULL;
+}
+
+// Appends the plugin path to |g_custom_entries|.
+void CrashKeysWin::SetPluginPath(const std::wstring& path) {
+  if (path.size() > kMaxPluginPathLength) {
+    // If the path is too long, truncate from the start rather than the end,
+    // since we want to be able to recover the DLL name.
+    SetPluginPath(path.substr(path.size() - kMaxPluginPathLength));
+    return;
+  }
+
+  // The chunk size without terminator.
+  const size_t kChunkSize = static_cast<size_t>(
+      google_breakpad::CustomInfoEntry::kValueMaxLength - 1);
+
+  int chunk_index = 0;
+  size_t chunk_start = 0;  // Current position inside |path|
+
+  for (chunk_start = 0; chunk_start < path.size(); chunk_index++) {
+    size_t chunk_length = std::min(kChunkSize, path.size() - chunk_start);
+
+    custom_entries_.push_back(google_breakpad::CustomInfoEntry(
+        base::StringPrintf(L"plugin-path-chunk-%i", chunk_index + 1).c_str(),
+        path.substr(chunk_start, chunk_length).c_str()));
+
+    chunk_start += chunk_length;
+  }
+}
+
+// Appends the breakpad dump path to |g_custom_entries|.
+void CrashKeysWin::SetBreakpadDumpPath(BreakpadClient* breakpad_client) {
+
+  base::FilePath crash_dumps_dir_path;
+  if (breakpad_client->GetAlternativeCrashDumpLocation(
+          &crash_dumps_dir_path)) {
+    custom_entries_.push_back(google_breakpad::CustomInfoEntry(
+        L"breakpad-dump-location", crash_dumps_dir_path.value().c_str()));
+  }
+}
+
+// Returns the custom info structure based on the dll in parameter and the
+// process type.
+google_breakpad::CustomClientInfo*
+CrashKeysWin::GetCustomInfo(const std::wstring& exe_path,
+                            const std::wstring& type,
+                            const std::wstring& profile_type,
+                            base::CommandLine* cmd_line,
+                            BreakpadClient* breakpad_client) {
+  base::string16 version, product;
+  base::string16 special_build;
+  base::string16 channel_name;
+
+  breakpad_client->GetProductNameAndVersion(
+      base::FilePath(exe_path),
+      &product,
+      &version,
+      &special_build,
+      &channel_name);
+
+  // We only expect this method to be called once per process.
+  // Common enties
+  custom_entries_.push_back(
+      google_breakpad::CustomInfoEntry(L"ver",
+                                       base::UTF16ToWide(version).c_str()));
+  custom_entries_.push_back(
+      google_breakpad::CustomInfoEntry(L"prod",
+                                       base::UTF16ToWide(product).c_str()));
+  custom_entries_.push_back(
+      google_breakpad::CustomInfoEntry(L"plat", L"Win32"));
+  custom_entries_.push_back(
+      google_breakpad::CustomInfoEntry(L"ptype", type.c_str()));
+  custom_entries_.push_back(google_breakpad::CustomInfoEntry(
+      L"pid", base::StringPrintf(L"%d", ::GetCurrentProcessId()).c_str()));
+  custom_entries_.push_back(google_breakpad::CustomInfoEntry(
+      L"channel", base::UTF16ToWide(channel_name).c_str()));
+  custom_entries_.push_back(google_breakpad::CustomInfoEntry(
+      L"profile-type", profile_type.c_str()));
+
+  if (!special_build.empty())
+    custom_entries_.push_back(google_breakpad::CustomInfoEntry(
+        L"special", base::UTF16ToWide(special_build).c_str()));
+
+  if (type == L"plugin" || type == L"ppapi") {
+    std::wstring plugin_path = cmd_line->GetSwitchValueNative("plugin-path");
+    if (!plugin_path.empty())
+      SetPluginPath(plugin_path);
+  }
+
+
+  // Check whether configuration management controls crash reporting.
+  bool crash_reporting_enabled = true;
+  bool controlled_by_policy = breakpad_client->ReportingIsEnforcedByPolicy(
+      &crash_reporting_enabled);
+  bool use_crash_service = !controlled_by_policy &&
+      (cmd_line->HasSwitch(switches::kNoErrorDialogs) ||
+          breakpad_client->IsRunningUnattended());
+  if (use_crash_service)
+    SetBreakpadDumpPath(breakpad_client);
+
+  // Create space for dynamic ad-hoc keys. The names and values are set using
+  // the API defined in base/debug/crash_logging.h.
+  dynamic_keys_offset_ = custom_entries_.size();
+  for (size_t i = 0; i < kMaxDynamicEntries; ++i) {
+    // The names will be mutated as they are set. Un-numbered since these are
+    // merely placeholders. The name cannot be empty because Breakpad's
+    // HTTPUpload will interpret that as an invalid parameter.
+    custom_entries_.push_back(
+        google_breakpad::CustomInfoEntry(L"unspecified-crash-key", L""));
+  }
+
+  static google_breakpad::CustomClientInfo custom_client_info;
+  custom_client_info.entries = &custom_entries_.front();
+  custom_client_info.count = custom_entries_.size();
+
+  return &custom_client_info;
+}
+
+void CrashKeysWin::SetCrashKeyValue(
+    const std::wstring& key, const std::wstring& value) {
+  // CustomInfoEntry limits the length of key and value. If they exceed
+  // their maximum length the underlying string handling functions raise
+  // an exception and prematurely trigger a crash. Truncate here.
+  std::wstring safe_key(std::wstring(key).substr(
+      0, google_breakpad::CustomInfoEntry::kNameMaxLength  - 1));
+  std::wstring safe_value(std::wstring(value).substr(
+      0, google_breakpad::CustomInfoEntry::kValueMaxLength - 1));
+
+  // If we already have a value for this key, update it; otherwise, insert
+  // the new value if we have not exhausted the pre-allocated slots for dynamic
+  // entries.
+  base::AutoLock lock(lock_);
+
+  DynamicEntriesMap::iterator it = dynamic_entries_.find(safe_key);
+  google_breakpad::CustomInfoEntry* entry = NULL;
+  if (it == dynamic_entries_.end()) {
+    if (dynamic_entries_.size() >= kMaxDynamicEntries)
+      return;
+    entry = &custom_entries_[dynamic_keys_offset_++];
+    dynamic_entries_.insert(std::make_pair(safe_key, entry));
+  } else {
+    entry = it->second;
+  }
+
+  entry->set(safe_key.data(), safe_value.data());
+}
+
+void CrashKeysWin::ClearCrashKeyValue(const std::wstring& key) {
+  base::AutoLock lock(lock_);
+
+  std::wstring key_string(key);
+  DynamicEntriesMap::iterator it = dynamic_entries_.find(key_string);
+  if (it == dynamic_entries_.end())
+    return;
+
+  it->second->set_value(NULL);
+}
+
+}  // namespace breakpad