Change crash keys to be registered with a maximum length instead of number of chunks.

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 <map>
 
 #include "base/debug/stack_trace.h"
 #include "base/format_macros.h"
@@ skipping 23 matching lines @@
   if (!g_set_key_func_)
     return;
 
   const CrashKey* crash_key = LookupCrashKey(key);
 
   // TODO(rsesek): Do this:
   //DCHECK(crash_key) << "All crash keys must be registered before use "
   //                  << "(key = " << key << ")";
 
   // Handle the un-chunked case.
-  if (!crash_key || crash_key->num_chunks == 1) {
+  if (!crash_key || crash_key->max_length <= g_chunk_max_length_) {
     g_set_key_func_(key, value);
     return;
   }
 
   // Unset the unused chunks.
   std::vector<std::string> chunks =
       ChunkCrashKeyValue(*crash_key, value, g_chunk_max_length_);
-  for (size_t i = chunks.size(); i < crash_key->num_chunks; ++i) {
+  for (size_t i = chunks.size();
+       i < crash_key->max_length / g_chunk_max_length_;
+       ++i) {
     g_clear_key_func_(base::StringPrintf(kChunkFormatString, key.data(), i+1));
   }
 
   // Set the chunked keys.
   for (size_t i = 0; i < chunks.size(); ++i) {
     g_set_key_func_(base::StringPrintf(kChunkFormatString, key.data(), i+1),
                     chunks[i]);
   }
 }
 
 void ClearCrashKey(const base::StringPiece& key) {
   if (!g_clear_key_func_)
     return;
 
   const CrashKey* crash_key = LookupCrashKey(key);
 
   // Handle the un-chunked case.
-  if (!crash_key || crash_key->num_chunks == 1) {
+  if (!crash_key || crash_key->max_length <= g_chunk_max_length_) {
     g_clear_key_func_(key);
     return;
   }
 
-  for (size_t i = 0; i < crash_key->num_chunks; ++i) {
+  for (size_t i = 0; i < crash_key->max_length / g_chunk_max_length_; ++i) {
     g_clear_key_func_(base::StringPrintf(kChunkFormatString, key.data(), i+1));
   }
 }
 
 void SetCrashKeyToStackTrace(const base::StringPiece& key,
                              const StackTrace& trace) {
   size_t count = 0;
   const void* const* addresses = trace.Addresses(&count);
   SetCrashKeyFromAddresses(key, addresses, count);
 }
@@ skipping 43 matching lines @@
     g_crash_keys_ = NULL;
     return 0;
   }
 
   g_crash_keys_ = new CrashKeyMap;
   g_chunk_max_length_ = chunk_max_length;
 
   size_t total_keys = 0;
   for (size_t i = 0; i < count; ++i) {
     g_crash_keys_->insert(std::make_pair(keys[i].key_name, keys[i]));
-    total_keys += keys[i].num_chunks;
+    total_keys += keys[i].max_length / chunk_max_length;
   }
   DCHECK_EQ(count, g_crash_keys_->size())
       << "Duplicate crash keys were registered";
 
   return total_keys;
 }
 
 const CrashKey* LookupCrashKey(const base::StringPiece& key) {
   CrashKeyMap::const_iterator it = g_crash_keys_->find(key.as_string());
   if (it == g_crash_keys_->end())
     return NULL;
   return &(it->second);
 }
 
 void SetCrashKeyReportingFunctions(
     SetCrashKeyValueFuncT set_key_func,
     ClearCrashKeyValueFuncT clear_key_func) {
   g_set_key_func_ = set_key_func;
   g_clear_key_func_ = clear_key_func;
 }
 
 std::vector<std::string> ChunkCrashKeyValue(const CrashKey& crash_key,
                                             const base::StringPiece& value,
                                             size_t chunk_max_length) {
-  std::string value_string = value.as_string();
+  std::string value_string = value.substr(0, crash_key.max_length).as_string();

[eroman, 2013/02/20 00:08:43]

Is this restriction necessary? Assuming implementations use fixed sized buffers
for the chunks, may as well truncate at a multiple of the chunk size.

[Robert Sesek, 2013/02/27 18:52:49]

At this layer, I think it makes more sense to deal in lengths rather than chunk
sizes since this doesn't know about Breakpad, and thus the sizes, at all. I do
expect in practice that lengths will be multiples of the chunk sizes, which is
why those constants exist in crash_keys.cc.

   std::vector<std::string> chunks;
-  for (size_t i = 0, offset = 0;
-       i < crash_key.num_chunks && offset < value_string.length();
-       ++i) {
+  for (size_t offset = 0; offset < value_string.length(); ) {
     std::string chunk = value_string.substr(offset, chunk_max_length);
     chunks.push_back(chunk);
     offset += chunk.length();
   }
   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;
 }
 
 }  // namespace debug
 }  // namespace base