The Tor Browser: comparison toolkit/crashreporter/google-breakpad/src/common/mac/SimpleStringDictionary.h

--1:000000000000
+:7b0910d389b9
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//  SimpleStringDictionary.h
+//
+#ifndef SimpleStringDictionary_H__
+#define SimpleStringDictionary_H__
+#import <string>
+#import <vector>
+namespace google_breakpad {
+//==============================================================================
+// SimpleStringDictionary (and associated class KeyValueEntry) implement a very
+// basic dictionary container class.  It has the property of not making any
+// memory allocations when getting and setting values.  But it is not very
+// efficient, with calls to get and set values operating in linear time.
+// It has the additional limitation of having a fairly small fixed capacity of
+// SimpleStringDictionary::MAX_NUM_ENTRIES entries.  An assert() will fire if
+// the client attempts to set more than this number of key/value pairs.
+// Ordinarilly a C++ programmer would use something like the std::map template
+// class, or on the Macintosh would often choose CFDictionary or NSDictionary.
+// But these dictionary classes may call malloc() during get and set operations.
+// Google Breakpad requires that no memory allocations be made in code running
+// in its exception handling thread, so it uses SimpleStringDictionary as the
+// underlying implementation for the GoogleBreakpad.framework APIs:
+// GoogleBreakpadSetKeyValue(),  GoogleBreakpadKeyValue(), and
+// GoogleBreakpadRemoveKeyValue()
+//
+//==============================================================================
+// KeyValueEntry
+//
+// A helper class used by SimpleStringDictionary representing a single
+// storage cell for a key/value pair.  Each key and value string are
+// limited to MAX_STRING_STORAGE_SIZE-1 bytes (not glyphs).  This class
+// performs no memory allocations.  It has methods for setting  and getting
+// key and value strings.
+//
+class KeyValueEntry {
+public:
+KeyValueEntry() {
+Clear();
+}
+KeyValueEntry(const char *key, const char *value) {
+SetKeyValue(key, value);
+}
+void        SetKeyValue(const char *key, const char *value) {
+if (!key) {
+key = "";
+}
+if (!value) {
+value = "";
+}
+strlcpy(key_, key, sizeof(key_));
+strlcpy(value_, value, sizeof(value_));
+}
+void        SetValue(const char *value) {
+if (!value) {
+value = "";
+}
+strlcpy(value_, value, sizeof(value_));
+};
+// Removes the key/value
+void        Clear() {
+memset(key_, 0, sizeof(key_));
+memset(value_, 0, sizeof(value_));
+}
+bool        IsActive() const { return key_[0] != '\0'; }
+const char *GetKey() const { return key_; }
+const char *GetValue() const { return value_; }
+// Don't change this without considering the fixed size
+// of MachMessage (in MachIPC.h)
+// (see also struct KeyValueMessageData in Inspector.h)
+enum {MAX_STRING_STORAGE_SIZE = 256};
+private:
+char key_[MAX_STRING_STORAGE_SIZE];
+char value_[MAX_STRING_STORAGE_SIZE];
+};
+//==============================================================================
+// This class is not an efficient dictionary, but for the purposes of breakpad
+// will be just fine.  We're just dealing with ten or so distinct
+// key/value pairs.  The idea is to avoid any malloc() or free() calls
+// in certain important methods to be called when a process is in a
+// crashed state.  Each key and value string are limited to
+// KeyValueEntry::MAX_STRING_STORAGE_SIZE-1 bytes (not glyphs).  Strings passed
+// in exceeding this length will be truncated.
+//
+class SimpleStringDictionary {
+public:
+SimpleStringDictionary() {};  // entries will all be cleared
+// Returns the number of active key/value pairs.  The upper limit for this
+// is MAX_NUM_ENTRIES.
+int GetCount() const;
+// Given |key|, returns its corresponding |value|.
+// If |key| is NULL, an assert will fire or NULL will be returned.  If |key|
+// is not found or is an empty string, NULL is returned.
+const char *GetValueForKey(const char *key) const;
+// Stores a string |value| represented by |key|.  If |key| is NULL or an empty
+// string, this will assert (or do nothing).  If |value| is NULL then
+// the |key| will be removed.  An empty string is OK for |value|.
+void SetKeyValue(const char *key, const char *value);
+// Given |key|, removes any associated value.  It will assert (or do nothing)
+// if NULL is passed in.  It will do nothing if |key| is not found.
+void RemoveKey(const char *key);
+// This is the maximum number of key/value pairs which may be set in the
+// dictionary.  An assert may fire if more values than this are set.
+// Don't change this without also changing comment in GoogleBreakpad.h
+enum {MAX_NUM_ENTRIES = 64};
+private:
+friend class SimpleStringDictionaryIterator;
+const KeyValueEntry *GetEntry(int i) const;
+KeyValueEntry             entries_[MAX_NUM_ENTRIES];
+};
+//==============================================================================
+class SimpleStringDictionaryIterator {
+public:
+SimpleStringDictionaryIterator(const SimpleStringDictionary &dict)
+: dict_(dict), i_(0) {
+}
+// Initializes iterator to the beginning (may later call Next() )
+void Start() {
+i_ = 0;
+}
+// like the nextObject method of NSEnumerator (in Cocoa)
+// returns NULL when there are no more entries
+//
+const KeyValueEntry* Next() {
+for (; i_ < SimpleStringDictionary::MAX_NUM_ENTRIES; ++i_) {
+const KeyValueEntry *entry = dict_.GetEntry(i_);
+if (entry->IsActive()) {
+i_++;   // move to next entry for next time
+return entry;
+}
+}
+return NULL;  // reached end of array
+}
+private:
+const SimpleStringDictionary&   dict_;
+int                             i_;
+};
+}  // namespace google_breakpad
+#endif  // SimpleStringDictionary_H__

The Tor Browser / file comparison

comparison: toolkit/crashreporter/google-breakpad/src/common/mac/SimpleStringDictionary.h

toolkit/crashreporter/google-breakpad/src/common/mac/SimpleStringDictionary.h