• file
• revisions
• annotate
• diff
• comparison
• raw

toolkit/crashreporter/google-breakpad/src/common/unique_string.cc@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/unique_string.cc

Sat, 03 Jan 2015 20:18:00 +0100

author

Michael Schloh von Bennewitz <michael@schloh.com>

date

Sat, 03 Jan 2015 20:18:00 +0100

branch

TOR_BUG_3246

changeset 7

129ffea94266

permissions

-rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

michael@0	1	// Copyright (c) 2013 Google Inc.
michael@0	2	// All rights reserved.
michael@0	3	//
michael@0	4	// Redistribution and use in source and binary forms, with or without
michael@0	5	// modification, are permitted provided that the following conditions are
michael@0	6	// met:
michael@0	7	//
michael@0	8	// * Redistributions of source code must retain the above copyright
michael@0	9	// notice, this list of conditions and the following disclaimer.
michael@0	10	// * Redistributions in binary form must reproduce the above
michael@0	11	// copyright notice, this list of conditions and the following disclaimer
michael@0	12	// in the documentation and/or other materials provided with the
michael@0	13	// distribution.
michael@0	14	// * Neither the name of Google Inc. nor the names of its
michael@0	15	// contributors may be used to endorse or promote products derived from
michael@0	16	// this software without specific prior written permission.
michael@0	17	//
michael@0	18	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
michael@0	19	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
michael@0	20	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
michael@0	21	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
michael@0	22	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
michael@0	23	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
michael@0	24	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
michael@0	25	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
michael@0	26	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
michael@0	27	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
michael@0	28	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
michael@0	29
michael@0	30	#include <string>
michael@0	31	#include <map>
michael@0	32
michael@0	33	#include <stdlib.h>
michael@0	34	#include <string.h>
michael@0	35
michael@0	36	#include "common/unique_string.h"
michael@0	37
michael@0	38	namespace google_breakpad {
michael@0	39
michael@0	40	///////////////////////////////////////////////////////////////////
michael@0	41	// UniqueString
michael@0	42	//
michael@0	43	class UniqueString {
michael@0	44	public:
michael@0	45	UniqueString(string str) { str_ = strdup(str.c_str()); }
michael@0	46	~UniqueString() { free(reinterpret_cast<void*>(const_cast<char*>(str_))); }
michael@0	47	const char* str_;
michael@0	48	};
michael@0	49
michael@0	50	class UniqueStringUniverse {
michael@0	51	public:
michael@0	52	UniqueStringUniverse() {};
michael@0	53	const UniqueString* FindOrCopy(string str) {
michael@0	54	std::map<string, UniqueString*>::iterator it = map_.find(str);
michael@0	55	if (it == map_.end()) {
michael@0	56	UniqueString* ustr = new UniqueString(str);
michael@0	57	map_[str] = ustr;
michael@0	58	return ustr;
michael@0	59	} else {
michael@0	60	return it->second;
michael@0	61	}
michael@0	62	}
michael@0	63	private:
michael@0	64	std::map<string, UniqueString*> map_;
michael@0	65	};
michael@0	66
michael@0	67	//
michael@0	68	///////////////////////////////////////////////////////////////////
michael@0	69
michael@0	70
michael@0	71	static UniqueStringUniverse* sUSU = NULL;
michael@0	72
michael@0	73
michael@0	74	// This isn't threadsafe.
michael@0	75	const UniqueString* ToUniqueString(string str) {
michael@0	76	if (!sUSU) {
michael@0	77	sUSU = new UniqueStringUniverse();
michael@0	78	}
michael@0	79	return sUSU->FindOrCopy(str);
michael@0	80	}
michael@0	81
michael@0	82	// This isn't threadsafe.
michael@0	83	const UniqueString* ToUniqueString_n(const char* str, size_t n) {
michael@0	84	if (!sUSU) {
michael@0	85	sUSU = new UniqueStringUniverse();
michael@0	86	}
michael@0	87	string key(str, n);
michael@0	88	return sUSU->FindOrCopy(key);
michael@0	89	}
michael@0	90
michael@0	91	const char Index(const UniqueString* us, int ix)
michael@0	92	{
michael@0	93	return us->str_[ix];
michael@0	94	}
michael@0	95
michael@0	96	const char* const FromUniqueString(const UniqueString* ustr)
michael@0	97	{
michael@0	98	return ustr->str_;
michael@0	99	}
michael@0	100
michael@0	101	int StrcmpUniqueString(const UniqueString* us1, const UniqueString* us2) {
michael@0	102	return strcmp(us1->str_, us2->str_);
michael@0	103	}
michael@0	104
michael@0	105	bool LessThan_UniqueString(const UniqueString* us1, const UniqueString* us2) {
michael@0	106	int r = StrcmpUniqueString(us1, us2);
michael@0	107	return r < 0;
michael@0	108	}
michael@0	109
michael@0	110	} // namespace google_breakpad