str 566 android_webview/browser/browser_view_renderer.cc std::string str; str 567 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "is_paused: %d ", is_paused_); str 568 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "view_visible: %d ", view_visible_); str 569 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "window_visible: %d ", window_visible_); str 570 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "dip_scale: %f ", dip_scale_); str 571 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_); str 572 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, str 575 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "block_invalidates: %d ", block_invalidates_); str 576 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "view width height: [%d %d] ", width_, height_); str 577 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "attached_to_window: %d ", attached_to_window_); str 578 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, str 582 android_webview/browser/browser_view_renderer.cc &str, "scroll_offset_dip: %s ", scroll_offset_dip_.ToString().c_str()); str 583 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, str 587 android_webview/browser/browser_view_renderer.cc &str, "on_new_picture_enable: %d ", on_new_picture_enable_); str 588 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "clear_view: %d ", clear_view_); str 590 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, str 596 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, str 600 android_webview/browser/browser_view_renderer.cc base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer); str 602 android_webview/browser/browser_view_renderer.cc return str; str 112 android_webview/native/aw_settings.cc ScopedJavaLocalRef<jstring> str = str 114 android_webview/native/aw_settings.cc bool ua_overidden = str.obj() != NULL; str 117 android_webview/native/aw_settings.cc std::string override = base::android::ConvertJavaStringToUTF8(str); str 730 ash/accelerators/accelerator_controller.cc LOG(ERROR) << out.str(); str 50 ash/ime/input_method_menu_item.cc return stream.str(); str 843 ash/sticky_keys/sticky_keys_unittest.cc UpdateDisplay(display_specs.str()); str 891 ash/sticky_keys/sticky_keys_unittest.cc UpdateDisplay(display_specs.str()); str 20 base/android/build_info.cc std::string str = ConvertJavaStringToUTF8(java_string); str 21 base/android/build_info.cc return strdup(str.c_str()); str 115 base/android/jni_array.cc ScopedJavaLocalRef<jstring> str(env, str 117 base/android/jni_array.cc ConvertJavaStringToUTF16(env, str.obj(), &((*out)[back + i])); str 131 base/android/jni_array.cc ScopedJavaLocalRef<jstring> str(env, str 133 base/android/jni_array.cc ConvertJavaStringToUTF8(env, str.obj(), &((*out)[back + i])); str 15 base/android/jni_string.cc const base::StringPiece16& str) { str 16 base/android/jni_string.cc jstring result = env->NewString(str.data(), str.length()); str 26 base/android/jni_string.cc void ConvertJavaStringToUTF8(JNIEnv* env, jstring str, std::string* result) { str 27 base/android/jni_string.cc if (!str) { str 35 base/android/jni_string.cc const jchar* chars = env->GetStringChars(str, NULL); str 37 base/android/jni_string.cc UTF16ToUTF8(chars, env->GetStringLength(str), result); str 38 base/android/jni_string.cc env->ReleaseStringChars(str, chars); str 42 base/android/jni_string.cc std::string ConvertJavaStringToUTF8(JNIEnv* env, jstring str) { str 44 base/android/jni_string.cc ConvertJavaStringToUTF8(env, str, &result); str 48 base/android/jni_string.cc std::string ConvertJavaStringToUTF8(const JavaRef<jstring>& str) { str 49 base/android/jni_string.cc return ConvertJavaStringToUTF8(AttachCurrentThread(), str.obj()); str 54 base/android/jni_string.cc const base::StringPiece& str) { str 63 base/android/jni_string.cc env, UTF8ToUTF16(str))); str 66 base/android/jni_string.cc void ConvertJavaStringToUTF16(JNIEnv* env, jstring str, string16* result) { str 67 base/android/jni_string.cc if (!str) { str 72 base/android/jni_string.cc const jchar* chars = env->GetStringChars(str, NULL); str 76 base/android/jni_string.cc result->assign(chars, env->GetStringLength(str)); str 77 base/android/jni_string.cc env->ReleaseStringChars(str, chars); str 81 base/android/jni_string.cc string16 ConvertJavaStringToUTF16(JNIEnv* env, jstring str) { str 83 base/android/jni_string.cc ConvertJavaStringToUTF16(env, str, &result); str 87 base/android/jni_string.cc string16 ConvertJavaStringToUTF16(const JavaRef<jstring>& str) { str 88 base/android/jni_string.cc return ConvertJavaStringToUTF16(AttachCurrentThread(), str.obj()); str 93 base/android/jni_string.cc const base::StringPiece16& str) { str 95 base/android/jni_string.cc ConvertUTF16ToJavaStringImpl(env, str)); str 20 base/android/jni_string.h jstring str, str 22 base/android/jni_string.h BASE_EXPORT std::string ConvertJavaStringToUTF8(JNIEnv* env, jstring str); str 23 base/android/jni_string.h BASE_EXPORT std::string ConvertJavaStringToUTF8(const JavaRef<jstring>& str); str 28 base/android/jni_string.h const base::StringPiece& str); str 32 base/android/jni_string.h jstring str, str 34 base/android/jni_string.h BASE_EXPORT string16 ConvertJavaStringToUTF16(JNIEnv* env, jstring str); str 35 base/android/jni_string.h BASE_EXPORT string16 ConvertJavaStringToUTF16(const JavaRef<jstring>& str); str 40 base/android/jni_string.h const base::StringPiece16& str); str 46 base/android/linker/linker_jni.cc String(JNIEnv* env, jstring str); str 61 base/android/linker/linker_jni.cc String::String(JNIEnv* env, jstring str) { str 62 base/android/linker/linker_jni.cc size_ = env->GetStringUTFLength(str); str 67 base/android/linker/linker_jni.cc const char* bytes = env->GetStringUTFChars(str, NULL); str 71 base/android/linker/linker_jni.cc env->ReleaseStringUTFChars(str, bytes); str 70 base/android/scoped_java_ref_unittest.cc ScopedJavaLocalRef<jstring> str = ConvertUTF8ToJavaString(env, "string"); str 71 base/android/scoped_java_ref_unittest.cc ScopedJavaGlobalRef<jstring> global(str); str 73 base/android/scoped_java_ref_unittest.cc ScopedJavaGlobalRef<jobject> global_obj(str); str 75 base/android/scoped_java_ref_unittest.cc const JavaRef<jobject>& obj_ref1(str); str 80 base/android/scoped_java_ref_unittest.cc global.Reset(str); str 81 base/android/scoped_java_ref_unittest.cc const JavaRef<jstring>& str_ref = str; str 83 base/android/scoped_java_ref_unittest.cc str.Reset(); str 88 base/android/scoped_java_ref_unittest.cc ScopedJavaLocalRef<jstring> str; str 93 base/android/scoped_java_ref_unittest.cc str.Reset(ConvertUTF8ToJavaString(env, "string")); str 97 base/android/scoped_java_ref_unittest.cc ScopedJavaGlobalRef<jstring> global_str(str); str 102 base/android/scoped_java_ref_unittest.cc ScopedJavaLocalRef<jstring> str2(env, str.Release()); str 37 base/debug/stack_trace.cc return stream.str(); str 44 base/debug/stack_trace_unittest.cc std::string backtrace_message = os.str(); str 126 base/debug/stack_trace_unittest.cc VLOG(1) << os.str(); str 203 base/debug/trace_event.h #define TRACE_STR_COPY(str) \ str 204 base/debug/trace_event.h trace_event_internal::TraceStringWithCopy(str) str 1099 base/debug/trace_event.h explicit TraceStringWithCopy(const char* str) : str_(str) {} str 470 base/debug/trace_event_impl.cc size_t GetAllocLength(const char* str) { return str ? strlen(str) + 1 : 0; } str 1943 base/debug/trace_event_impl.cc return log.str(); str 2193 base/debug/trace_event_impl.cc const std::string& str) { str 2194 base/debug/trace_event_impl.cc return str.empty() || str 2195 base/debug/trace_event_impl.cc str.at(0) == ' ' || str 2196 base/debug/trace_event_impl.cc str.at(str.length() - 1) == ' '; str 346 base/debug/trace_event_impl.h const std::string& str); str 164 base/debug/trace_event_memory_unittest.cc AppendHeapProfileLineAsTraceFormat(input.str().c_str(), &output)); str 184 base/debug/trace_event_memory_unittest.cc AppendHeapProfileLineAsTraceFormat(input2.str().c_str(), &output2)); str 192 base/debug/trace_event_memory_unittest.cc EXPECT_FALSE(AppendHeapProfileLineAsTraceFormat(zero_input.str().c_str(), str 236 base/debug/trace_event_memory_unittest.cc EXPECT_STREQ(kHello, StringFromHexAddress(hex_address.str())); str 2712 base/debug/trace_event_unittest.cc const std::string& str) { str 2715 base/debug/trace_event_unittest.cc g_log_buffer->append(str); str 47 base/debug/trace_event_win_unittest.cc MATCHER_P(BufferStartsWith, str, "Buffer starts with") { str 48 base/debug/trace_event_win_unittest.cc return memcmp(arg, str.c_str(), str.length()) == 0; str 174 base/debug/trace_event_win_unittest.cc std::stringbuf str; str 175 base/debug/trace_event_win_unittest.cc str.sputn(name, name_len + 1); str 176 base/debug/trace_event_win_unittest.cc str.sputn(reinterpret_cast<const char*>(&id), sizeof(id)); str 177 base/debug/trace_event_win_unittest.cc str.sputn(extra, extra_len + 1); str 182 base/debug/trace_event_win_unittest.cc testing::Ge(str.str().length()), str 183 base/debug/trace_event_win_unittest.cc BufferStartsWith(str.str()))); str 120 base/file_version_info_unittest.cc std::wstring str; str 123 base/file_version_info_unittest.cc EXPECT_TRUE(version_info_win->GetValue(L"Custom prop 1", &str)); str 124 base/file_version_info_unittest.cc EXPECT_EQ(L"Un", str); str 127 base/file_version_info_unittest.cc EXPECT_TRUE(version_info_win->GetValue(L"Custom prop 2", &str)); str 128 base/file_version_info_unittest.cc EXPECT_EQ(L"Deux", str); str 131 base/file_version_info_unittest.cc EXPECT_TRUE(version_info_win->GetValue(L"Custom prop 3", &str)); str 132 base/file_version_info_unittest.cc EXPECT_EQ(L"1600 Amphitheatre Parkway Mountain View, CA 94043", str); str 137 base/file_version_info_unittest.cc EXPECT_FALSE(version_info_win->GetValue(L"Unknown property", &str)); str 184 base/file_version_info_win.cc std::wstring str; str 185 base/file_version_info_win.cc if (GetValue(name, &str)) str 186 base/file_version_info_win.cc return str; str 439 base/files/file_path.cc StringType str = path_; str 441 base/files/file_path.cc *(str.end() - 1) != kExtensionSeparator) { str 442 base/files/file_path.cc str.append(1, kExtensionSeparator); str 444 base/files/file_path.cc str.append(extension); str 445 base/files/file_path.cc return FilePath(str); str 457 base/files/file_path.cc StringType str = no_ext.value(); str 459 base/files/file_path.cc str.append(1, kExtensionSeparator); str 460 base/files/file_path.cc str.append(extension); str 461 base/files/file_path.cc return FilePath(str); str 32 base/hash.h inline uint32 Hash(const std::string& str) { str 33 base/hash.h return Hash(str.data(), str.size()); str 15 base/hash_unittest.cc std::string str; str 17 base/hash_unittest.cc str = ""; str 18 base/hash_unittest.cc EXPECT_EQ(0u, Hash(str)); str 21 base/hash_unittest.cc str = "hello world"; str 22 base/hash_unittest.cc EXPECT_EQ(2794219650u, Hash(str)); str 25 base/hash_unittest.cc str = "helmo world"; str 26 base/hash_unittest.cc EXPECT_EQ(1006697176u, Hash(str)); str 29 base/hash_unittest.cc str = "hello world"; str 30 base/hash_unittest.cc str[5] = '\0'; str 31 base/hash_unittest.cc EXPECT_EQ(2319902537u, Hash(str)); str 34 base/hash_unittest.cc str = "hello worle"; str 35 base/hash_unittest.cc str[5] = '\0'; str 36 base/hash_unittest.cc EXPECT_EQ(553904462u, Hash(str)); str 43 base/hash_unittest.cc str.assign(&long_string_buffer.front(), long_string_buffer.size()); str 44 base/hash_unittest.cc EXPECT_EQ(2797962408u, Hash(str)); str 53 base/hash_unittest.cc str = "hello w\xab"; str 54 base/hash_unittest.cc EXPECT_EQ(615571198u, Hash(str)); str 56 base/hash_unittest.cc str = "hello wo\xab"; str 57 base/hash_unittest.cc EXPECT_EQ(623474296u, Hash(str)); str 59 base/hash_unittest.cc str = "hello wor\xab"; str 60 base/hash_unittest.cc EXPECT_EQ(4278562408u, Hash(str)); str 62 base/hash_unittest.cc str = "hello worl\xab"; str 63 base/hash_unittest.cc EXPECT_EQ(3224633008u, Hash(str)); str 67 base/hash_unittest.cc const char* str; str 69 base/hash_unittest.cc str = ""; str 70 base/hash_unittest.cc EXPECT_EQ(0u, Hash(str, strlen(str))); str 73 base/hash_unittest.cc str = "hello world"; str 74 base/hash_unittest.cc EXPECT_EQ(2794219650u, Hash(str, strlen(str))); str 78 base/hash_unittest.cc str = "hello world; don't read this part"; str 79 base/hash_unittest.cc EXPECT_EQ(2794219650u, Hash(str, strlen("hello world"))); str 17 base/i18n/break_iterator.cc BreakIterator::BreakIterator(const string16& str, BreakType break_type) str 19 base/i18n/break_iterator.cc string_(str), str 72 base/i18n/break_iterator.h BreakIterator(const string16& str, BreakType break_type); str 27 base/i18n/break_iterator_unittest.cc string16 str(UTF8ToUTF16(" foo bar! \npouet boom")); str 28 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_WORD); str 68 base/i18n/break_iterator_unittest.cc const string16 str(WideToUTF16( str 71 base/i18n/break_iterator_unittest.cc const string16 word1(str.substr(0, 10)); str 72 base/i18n/break_iterator_unittest.cc const string16 word2(str.substr(11, 5)); str 73 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_WORD); str 93 base/i18n/break_iterator_unittest.cc const string16 str( str 95 base/i18n/break_iterator_unittest.cc const string16 very_wide_word(str.substr(0, 2)); str 97 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_WORD); str 125 base/i18n/break_iterator_unittest.cc string16 str(UTF8ToUTF16(" foo bar! \npouet boom")); str 126 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_SPACE); str 150 base/i18n/break_iterator_unittest.cc string16 str(UTF8ToUTF16(" foo bar! \npouet boom ")); str 151 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_SPACE); str 176 base/i18n/break_iterator_unittest.cc const string16 str(WideToUTF16( str 179 base/i18n/break_iterator_unittest.cc const string16 word1(str.substr(0, 11)); str 180 base/i18n/break_iterator_unittest.cc const string16 word2(str.substr(11, 5)); str 181 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_SPACE); str 198 base/i18n/break_iterator_unittest.cc const string16 str( str 200 base/i18n/break_iterator_unittest.cc const string16 very_wide_word(str.substr(0, 3)); str 202 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_SPACE); str 228 base/i18n/break_iterator_unittest.cc string16 str(UTF8ToUTF16("\nfoo bar!\n\npouet boom")); str 229 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_NEWLINE); str 251 base/i18n/break_iterator_unittest.cc string16 str(UTF8ToUTF16("\nfoo bar!\n\npouet boom\n")); str 252 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_NEWLINE); str 274 base/i18n/break_iterator_unittest.cc const string16 str(WideToUTF16( str 277 base/i18n/break_iterator_unittest.cc const string16 line1(str.substr(0, 11)); str 278 base/i18n/break_iterator_unittest.cc const string16 line2(str.substr(11, 5)); str 279 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_NEWLINE); str 296 base/i18n/break_iterator_unittest.cc const string16 str( str 298 base/i18n/break_iterator_unittest.cc const string16 very_wide_line(str.substr(0, 3)); str 299 base/i18n/break_iterator_unittest.cc BreakIterator iter(str, BreakIterator::BREAK_NEWLINE); str 13 base/i18n/char_iterator.cc UTF8CharIterator::UTF8CharIterator(const std::string* str) str 14 base/i18n/char_iterator.cc : str_(reinterpret_cast<const uint8_t*>(str->data())), str 15 base/i18n/char_iterator.cc len_(str->size()), str 39 base/i18n/char_iterator.cc UTF16CharIterator::UTF16CharIterator(const string16* str) str 40 base/i18n/char_iterator.cc : str_(reinterpret_cast<const char16*>(str->data())), str 41 base/i18n/char_iterator.cc len_(str->size()), str 50 base/i18n/char_iterator.cc UTF16CharIterator::UTF16CharIterator(const char16* str, size_t str_len) str 51 base/i18n/char_iterator.cc : str_(str), str 33 base/i18n/char_iterator.h explicit UTF8CharIterator(const std::string* str); str 79 base/i18n/char_iterator.h explicit UTF16CharIterator(const string16* str); str 80 base/i18n/char_iterator.h UTF16CharIterator(const char16* str, size_t str_len); str 21 base/i18n/char_iterator_unittest.cc std::string str("s\303\273r"); // [u with circumflex] str 22 base/i18n/char_iterator_unittest.cc UTF8CharIterator iter(&str); str 64 base/i18n/char_iterator_unittest.cc string16 str = UTF8ToUTF16("x\303\273\360\235\224\270z"); str 65 base/i18n/char_iterator_unittest.cc UTF16CharIterator iter(&str); str 310 base/json/json_parser.cc void JSONParser::StringBuilder::AppendString(const std::string& str) { str 312 base/json/json_parser.cc string_->append(str); str 117 base/json/json_parser.h void AppendString(const std::string& str); str 53 base/json/json_parser_unittest.cc std::string str; str 54 base/json/json_parser_unittest.cc EXPECT_TRUE(value->GetAsString(&str)); str 55 base/json/json_parser_unittest.cc EXPECT_EQ("test", str); str 83 base/json/json_parser_unittest.cc std::string str; str 84 base/json/json_parser_unittest.cc EXPECT_TRUE(dict->GetString("abc", &str)); str 85 base/json/json_parser_unittest.cc EXPECT_EQ("def", str); str 69 base/json/string_escape.cc bool EscapeJSONStringImpl(const S& str, bool put_in_quotes, std::string* dest) { str 76 base/json/string_escape.cc CHECK_LE(str.length(), static_cast<size_t>(kint32max)); str 77 base/json/string_escape.cc const int32 length = static_cast<int32>(str.length()); str 81 base/json/string_escape.cc if (!ReadUnicodeCharacter(str.data(), length, &i, &code_point)) { str 104 base/json/string_escape.cc bool EscapeJSONString(const StringPiece& str, str 107 base/json/string_escape.cc return EscapeJSONStringImpl(str, put_in_quotes, dest); str 110 base/json/string_escape.cc bool EscapeJSONString(const StringPiece16& str, str 113 base/json/string_escape.cc return EscapeJSONStringImpl(str, put_in_quotes, dest); str 116 base/json/string_escape.cc std::string GetQuotedJSONString(const StringPiece& str) { str 118 base/json/string_escape.cc bool ok = EscapeJSONStringImpl(str, true, &dest); str 123 base/json/string_escape.cc std::string GetQuotedJSONString(const StringPiece16& str) { str 125 base/json/string_escape.cc bool ok = EscapeJSONStringImpl(str, true, &dest); str 130 base/json/string_escape.cc std::string EscapeBytesAsInvalidJSONString(const StringPiece& str, str 137 base/json/string_escape.cc for (StringPiece::const_iterator it = str.begin(); it != str.end(); ++it) { str 28 base/json/string_escape.h BASE_EXPORT bool EscapeJSONString(const StringPiece& str, str 35 base/json/string_escape.h BASE_EXPORT bool EscapeJSONString(const StringPiece16& str, str 41 base/json/string_escape.h BASE_EXPORT std::string GetQuotedJSONString(const StringPiece& str); str 42 base/json/string_escape.h BASE_EXPORT std::string GetQuotedJSONString(const StringPiece16& str); str 55 base/json/string_escape.h BASE_EXPORT std::string EscapeBytesAsInvalidJSONString(const StringPiece& str, str 471 base/logging.cc void DisplayDebugMessageInDialog(const std::string& str) { str 472 base/logging.cc if (str.empty()) str 492 base/logging.cc std::wstring cmdline = base::UTF8ToWide(str); str 567 base/logging.cc std::string str_newline(stream_.str()); str 647 base/logging.cc log_assert_handler(std::string(stream_.str())); str 655 base/logging.cc DisplayDebugMessageInDialog(stream_.str()); str 663 base/logging.cc log_report_handler(std::string(stream_.str())); str 665 base/logging.cc DisplayDebugMessageInDialog(stream_.str()); str 276 base/logging.h typedef void (*LogAssertHandlerFunction)(const std::string& str); str 283 base/logging.h typedef void (*LogReportHandlerFunction)(const std::string& str); str 291 base/logging.h const char* file, int line, size_t message_start, const std::string& str); str 517 base/logging.h std::string* msg = new std::string(ss.str()); str 21 base/logging_unittest.cc void LogSink(const std::string& str) { str 57 base/logging_win.h int line, size_t message_start, const std::string& str); str 364 base/mac/foundation_util.h BASE_EXPORT FilePath NSStringToFilePath(NSString* str); str 377 base/mac/foundation_util.h const CFStringRef str); str 294 base/md5.cc std::string MD5String(const StringPiece& str) { str 296 base/md5.cc MD5Sum(str.data(), str.length(), &digest); str 71 base/md5.h BASE_EXPORT std::string MD5String(const StringPiece& str); str 202 base/memory/shared_memory_unittest.cc std::string test_name = test_name_stream.str(); str 23 base/metrics/user_metrics_action.h explicit UserMetricsAction(const char* str) : str_(str) {} str 307 base/pickle_unittest.cc std::string str(100000, 'A'); str 308 base/pickle_unittest.cc EXPECT_TRUE(source.WriteData(str.c_str(), 100000)); str 20 base/sha1.h BASE_EXPORT std::string SHA1HashString(const std::string& str); str 199 base/sha1_portable.cc std::string SHA1HashString(const std::string& str) { str 201 base/sha1_portable.cc SHA1HashBytes(reinterpret_cast<const unsigned char*>(str.c_str()), str 202 base/sha1_portable.cc str.length(), reinterpret_cast<unsigned char*>(hash)); str 17 base/sha1_win.cc std::string SHA1HashString(const std::string& str) { str 32 base/sha1_win.cc if (!CryptHashData(hash, reinterpret_cast<CONST BYTE*>(str.data()), str 33 base/sha1_win.cc static_cast<DWORD>(str.length()), 0)) { str 118 base/stl_util.h inline char* string_as_array(std::string* str) { str 120 base/stl_util.h return str->empty() ? NULL : &*str->begin(); str 556 base/strings/safe_sprintf.cc i = reinterpret_cast<uintptr_t>(arg.str); str 590 base/strings/safe_sprintf.cc s = arg.str ? arg.str : "<NULL>"; str 154 base/strings/safe_sprintf.h Arg(const char* s) : str(s), type(STRING) { } str 155 base/strings/safe_sprintf.h Arg(char* s) : str(s), type(STRING) { } str 168 base/strings/safe_sprintf.h const char* str; str 741 base/strings/safe_sprintf_unittest.cc char *str = reinterpret_cast<char *>(0x80000000u); str 742 base/strings/safe_sprintf_unittest.cc void *ptr = str; str 744 base/strings/safe_sprintf_unittest.cc EXPECT_EQ(10, SafeSPrintf(buf, "%p", str)); str 70 base/strings/string16.cc std::ostream& operator<<(std::ostream& out, const string16& str) { str 71 base/strings/string16.cc return out << UTF16ToUTF8(str); str 74 base/strings/string16.cc void PrintTo(const string16& str, std::ostream* out) { str 75 base/strings/string16.cc *out << str; str 133 base/strings/string16.h const string16& str); str 136 base/strings/string16.h BASE_EXPORT extern void PrintTo(const string16& str, std::ostream* out); str 25 base/strings/string16_unittest.cc stream.str().c_str()); str 52 base/strings/string16_unittest.cc stream.str().c_str()); str 176 base/strings/string_piece.h BasicStringPiece(const value_type* str) str 177 base/strings/string_piece.h : ptr_(str), str 178 base/strings/string_piece.h length_((str == NULL) ? 0 : STRING_TYPE::traits_type::length(str)) {} str 179 base/strings/string_piece.h BasicStringPiece(const STRING_TYPE& str) str 180 base/strings/string_piece.h : ptr_(str.data()), length_(str.size()) {} str 205 base/strings/string_piece.h void set(const value_type* str) { str 206 base/strings/string_piece.h ptr_ = str; str 207 base/strings/string_piece.h length_ = str ? STRING_TYPE::traits_type::length(str) : 0; str 592 base/strings/string_piece_unittest.cc TypeParam str = s.as_string(); str 593 base/strings/string_piece_unittest.cc ASSERT_EQ(str.length(), 0U); str 594 base/strings/string_piece_unittest.cc ASSERT_EQ(str, TypeParam()); str 670 base/strings/string_piece_unittest.cc TypeParam str(TestFixture::as_string("hello world")); str 673 base/strings/string_piece_unittest.cc ASSERT_TRUE(str == BasicStringPiece<TypeParam>(str)); str 674 base/strings/string_piece_unittest.cc ASSERT_TRUE(str == BasicStringPiece<TypeParam>(str.c_str())); str 676 base/strings/string_piece_unittest.cc BasicStringPiece<TypeParam>(str.c_str(), 5)); str 677 base/strings/string_piece_unittest.cc ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(str.c_str(), str 683 base/strings/string_piece_unittest.cc ASSERT_TRUE(str == BasicStringPiece<TypeParam>(str.begin(), str.end())); str 684 base/strings/string_piece_unittest.cc ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(str.begin(), str.begin())); str 17 base/strings/string_split.cc void SplitStringT(const STR& str, str 23 base/strings/string_split.cc size_t c = str.size(); str 25 base/strings/string_split.cc if (i == c || str[i] == s) { str 26 base/strings/string_split.cc STR tmp(str, last, i - last); str 65 base/strings/string_split.cc void SplitStringUsingSubstrT(const STR& str, str 71 base/strings/string_split.cc const typename STR::size_type end_index = str.find(s, begin_index); str 73 base/strings/string_split.cc const STR term = str.substr(begin_index); str 79 base/strings/string_split.cc const STR term = str.substr(begin_index, end_index - begin_index); str 88 base/strings/string_split.cc void SplitStringAlongWhitespaceT(const STR& str, std::vector<STR>* result) { str 90 base/strings/string_split.cc const size_t length = str.length(); str 97 base/strings/string_split.cc switch (str[i]) { str 108 base/strings/string_split.cc str.substr(last_non_ws_start, i - last_non_ws_start)); str 124 base/strings/string_split.cc str.substr(last_non_ws_start, length - last_non_ws_start)); str 130 base/strings/string_split.cc void SplitString(const string16& str, str 134 base/strings/string_split.cc SplitStringT(str, c, true, r); str 137 base/strings/string_split.cc void SplitString(const std::string& str, str 144 base/strings/string_split.cc SplitStringT(str, c, true, r); str 174 base/strings/string_split.cc void SplitStringUsingSubstr(const string16& str, str 177 base/strings/string_split.cc SplitStringUsingSubstrT(str, s, r); str 180 base/strings/string_split.cc void SplitStringUsingSubstr(const std::string& str, str 183 base/strings/string_split.cc SplitStringUsingSubstrT(str, s, r); str 186 base/strings/string_split.cc void SplitStringDontTrim(const string16& str, str 190 base/strings/string_split.cc SplitStringT(str, c, false, r); str 193 base/strings/string_split.cc void SplitStringDontTrim(const std::string& str, str 196 base/strings/string_split.cc DCHECK(IsStringUTF8(str)); str 201 base/strings/string_split.cc SplitStringT(str, c, false, r); str 204 base/strings/string_split.cc void SplitStringAlongWhitespace(const string16& str, str 206 base/strings/string_split.cc SplitStringAlongWhitespaceT(str, result); str 209 base/strings/string_split.cc void SplitStringAlongWhitespace(const std::string& str, str 211 base/strings/string_split.cc SplitStringAlongWhitespaceT(str, result); str 23 base/strings/string_split.h BASE_EXPORT void SplitString(const string16& str, str 31 base/strings/string_split.h BASE_EXPORT void SplitString(const std::string& str, str 47 base/strings/string_split.h BASE_EXPORT void SplitStringUsingSubstr(const string16& str, str 50 base/strings/string_split.h BASE_EXPORT void SplitStringUsingSubstr(const std::string& str, str 56 base/strings/string_split.h BASE_EXPORT void SplitStringDontTrim(const string16& str, str 63 base/strings/string_split.h BASE_EXPORT void SplitStringDontTrim(const std::string& str, str 75 base/strings/string_split.h BASE_EXPORT void SplitStringAlongWhitespace(const string16& str, str 77 base/strings/string_split.h BASE_EXPORT void SplitStringAlongWhitespace(const std::string& str, str 20 base/strings/string_split_unittest.cc void SplitString(const std::wstring& str, str 24 base/strings/string_split_unittest.cc SplitString(WideToUTF16(str), c, &result16); str 91 base/strings/string_tokenizer.h template <class str, class const_iterator> str 94 base/strings/string_tokenizer.h typedef typename str::value_type char_type; str 104 base/strings/string_tokenizer.h StringTokenizerT(const str& string, str 105 base/strings/string_tokenizer.h const str& delims) { str 111 base/strings/string_tokenizer.h const str& delims) { str 123 base/strings/string_tokenizer.h void set_quote_chars(const str& quotes) { quotes_ = quotes; } str 149 base/strings/string_tokenizer.h str token() const { return str(token_begin_, token_end_); } str 158 base/strings/string_tokenizer.h const str& delims) { str 178 base/strings/string_tokenizer.h if (delims_.find(*token_begin_) == str::npos) str 182 base/strings/string_tokenizer.h while (token_end_ != end_ && delims_.find(*token_end_) == str::npos) str 210 base/strings/string_tokenizer.h return delims_.find(c) != str::npos; str 214 base/strings/string_tokenizer.h return quotes_.find(c) != str::npos; str 246 base/strings/string_tokenizer.h str delims_; str 247 base/strings/string_tokenizer.h str quotes_; str 330 base/strings/string_util.cc static bool DoIsStringASCII(const STR& str) { str 331 base/strings/string_util.cc for (size_t i = 0; i < str.length(); i++) { str 332 base/strings/string_util.cc typename ToUnsigned<typename STR::value_type>::Unsigned c = str[i]; str 339 base/strings/string_util.cc bool IsStringASCII(const base::StringPiece& str) { str 340 base/strings/string_util.cc return DoIsStringASCII(str); str 343 base/strings/string_util.cc bool IsStringASCII(const base::string16& str) { str 344 base/strings/string_util.cc return DoIsStringASCII(str); str 347 base/strings/string_util.cc bool IsStringUTF8(const std::string& str) { str 348 base/strings/string_util.cc const char *src = str.data(); str 349 base/strings/string_util.cc int32 src_len = static_cast<int32>(str.length()); str 415 base/strings/string_util.cc bool StartsWithASCII(const std::string& str, str 419 base/strings/string_util.cc return str.compare(0, search.length(), search) == 0; str 421 base/strings/string_util.cc return base::strncasecmp(str.c_str(), search.c_str(), search.length()) == 0; str 425 base/strings/string_util.cc bool StartsWithT(const STR& str, const STR& search, bool case_sensitive) { str 427 base/strings/string_util.cc return str.compare(0, search.length(), search) == 0; str 429 base/strings/string_util.cc if (search.size() > str.size()) str 431 base/strings/string_util.cc return std::equal(search.begin(), search.end(), str.begin(), str 436 base/strings/string_util.cc bool StartsWith(const string16& str, const string16& search, str 438 base/strings/string_util.cc return StartsWithT(str, search, case_sensitive); str 442 base/strings/string_util.cc bool EndsWithT(const STR& str, const STR& search, bool case_sensitive) { str 443 base/strings/string_util.cc typename STR::size_type str_length = str.length(); str 448 base/strings/string_util.cc return str.compare(str_length - search_length, search_length, search) == 0; str 451 base/strings/string_util.cc str.begin() + (str_length - search_length), str 456 base/strings/string_util.cc bool EndsWith(const std::string& str, const std::string& search, str 458 base/strings/string_util.cc return EndsWithT(str, search, case_sensitive); str 461 base/strings/string_util.cc bool EndsWith(const string16& str, const string16& search, str 463 base/strings/string_util.cc return EndsWithT(str, search, case_sensitive); str 498 base/strings/string_util.cc void DoReplaceSubstringsAfterOffset(StringType* str, str 503 base/strings/string_util.cc if ((start_offset == StringType::npos) || (start_offset >= str->length())) str 507 base/strings/string_util.cc for (typename StringType::size_type offs(str->find(find_this, start_offset)); str 508 base/strings/string_util.cc offs != StringType::npos; offs = str->find(find_this, offs)) { str 509 base/strings/string_util.cc str->replace(offs, find_this.length(), replace_with); str 517 base/strings/string_util.cc void ReplaceFirstSubstringAfterOffset(string16* str, str 521 base/strings/string_util.cc DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with, str 525 base/strings/string_util.cc void ReplaceFirstSubstringAfterOffset(std::string* str, str 529 base/strings/string_util.cc DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with, str 533 base/strings/string_util.cc void ReplaceSubstringsAfterOffset(string16* str, str 537 base/strings/string_util.cc DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with, str 541 base/strings/string_util.cc void ReplaceSubstringsAfterOffset(std::string* str, str 545 base/strings/string_util.cc DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with, str 551 base/strings/string_util.cc static size_t TokenizeT(const STR& str, str 556 base/strings/string_util.cc typename STR::size_type start = str.find_first_not_of(delimiters); str 558 base/strings/string_util.cc typename STR::size_type end = str.find_first_of(delimiters, start + 1); str 560 base/strings/string_util.cc tokens->push_back(str.substr(start)); str 563 base/strings/string_util.cc tokens->push_back(str.substr(start, end - start)); str 564 base/strings/string_util.cc start = str.find_first_not_of(delimiters, end + 1); str 571 base/strings/string_util.cc size_t Tokenize(const string16& str, str 574 base/strings/string_util.cc return TokenizeT(str, delimiters, tokens); str 577 base/strings/string_util.cc size_t Tokenize(const std::string& str, str 580 base/strings/string_util.cc return TokenizeT(str, delimiters, tokens); str 583 base/strings/string_util.cc size_t Tokenize(const base::StringPiece& str, str 586 base/strings/string_util.cc return TokenizeT(str, delimiters, tokens); str 258 base/strings/string_util.h BASE_EXPORT bool IsStringUTF8(const std::string& str); str 259 base/strings/string_util.h BASE_EXPORT bool IsStringASCII(const base::StringPiece& str); str 260 base/strings/string_util.h BASE_EXPORT bool IsStringASCII(const base::string16& str); str 264 base/strings/string_util.h template <class str> inline void StringToLowerASCII(str* s) { str 265 base/strings/string_util.h for (typename str::iterator i = s->begin(); i != s->end(); ++i) str 269 base/strings/string_util.h template <class str> inline str StringToLowerASCII(const str& s) { str 271 base/strings/string_util.h str output(s); str 278 base/strings/string_util.h template <class str> inline void StringToUpperASCII(str* s) { str 279 base/strings/string_util.h for (typename str::iterator i = s->begin(); i != s->end(); ++i) str 283 base/strings/string_util.h template <class str> inline str StringToUpperASCII(const str& s) { str 285 base/strings/string_util.h str output(s); str 316 base/strings/string_util.h BASE_EXPORT bool StartsWithASCII(const std::string& str, str 319 base/strings/string_util.h BASE_EXPORT bool StartsWith(const base::string16& str, str 324 base/strings/string_util.h BASE_EXPORT bool EndsWith(const std::string& str, str 327 base/strings/string_util.h BASE_EXPORT bool EndsWith(const base::string16& str, str 380 base/strings/string_util.h base::string16* str, str 385 base/strings/string_util.h std::string* str, str 397 base/strings/string_util.h base::string16* str, str 402 base/strings/string_util.h std::string* str, str 428 base/strings/string_util.h inline typename string_type::value_type* WriteInto(string_type* str, str 431 base/strings/string_util.h str->reserve(length_with_null); str 432 base/strings/string_util.h str->resize(length_with_null - 1); str 433 base/strings/string_util.h return &((*str)[0]); str 441 base/strings/string_util.h BASE_EXPORT size_t Tokenize(const base::string16& str, str 444 base/strings/string_util.h BASE_EXPORT size_t Tokenize(const std::string& str, str 447 base/strings/string_util.h BASE_EXPORT size_t Tokenize(const base::StringPiece& str, str 19 base/strings/string_util_posix.h inline char* strdup(const char* str) { str 20 base/strings/string_util_posix.h return ::strdup(str); str 511 base/strings/string_util_unittest.cc const char* str; str 532 base/strings/string_util_unittest.cc string16 str = ASCIIToUTF16(cases[i].str); str 533 base/strings/string_util_unittest.cc ReplaceSubstringsAfterOffset(&str, cases[i].start_offset, str 536 base/strings/string_util_unittest.cc EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str); str 542 base/strings/string_util_unittest.cc const char* str; str 562 base/strings/string_util_unittest.cc string16 str = ASCIIToUTF16(cases[i].str); str 563 base/strings/string_util_unittest.cc ReplaceFirstSubstringAfterOffset(&str, cases[i].start_offset, str 566 base/strings/string_util_unittest.cc EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str); str 19 base/strings/string_util_win.h inline char* strdup(const char* str) { str 20 base/strings/string_util_win.h return _strdup(str); str 53 base/strings/utf_string_conversions_unittest.cc wide << UTF8ToWide(utf8.str()); str 55 base/strings/utf_string_conversions_unittest.cc EXPECT_EQ(kConvertRoundtripCases[i], wide.str()); str 51 base/sys_info_android.cc int64 ParseSystemPropertyBytes(const base::StringPiece& str) { str 55 base/sys_info_android.cc if (str.size() == 0u) str 58 base/sys_info_android.cc size_t length = str.size(); str 59 base/sys_info_android.cc if (str[length - 1] == 'k') { str 62 base/sys_info_android.cc } else if (str[length - 1] == 'm') { str 65 base/sys_info_android.cc } else if (str[length - 1] == 'g') { str 70 base/sys_info_android.cc bool parsed = base::StringToInt64(str.substr(0, length), &result); str 228 base/test/test_suite.cc void TestSuite::UnitTestAssertHandler(const std::string& str) { str 56 base/test/test_suite.h static void UnitTestAssertHandler(const std::string& str); str 90 base/test/trace_event_analyzer.cc std::string str; str 94 base/test/trace_event_analyzer.cc if (it.value().GetAsString(&str)) { str 95 base/test/trace_event_analyzer.cc arg_strings[it.key()] = str; str 213 base/test/trace_event_analyzer.cc Query Query::String(const std::string& str) { str 214 base/test/trace_event_analyzer.cc return Query(str); str 408 base/test/trace_event_analyzer.cc bool Query::GetAsString(const TraceEvent& event, std::string* str) const { str 411 base/test/trace_event_analyzer.cc return GetMemberValueAsString(event, str); str 413 base/test/trace_event_analyzer.cc *str = string_; str 488 base/test/trace_event_analyzer.cc std::string* str) const { str 503 base/test/trace_event_analyzer.cc *str = the_event->category; str 507 base/test/trace_event_analyzer.cc *str = the_event->name; str 511 base/test/trace_event_analyzer.cc *str = the_event->id; str 520 base/test/trace_event_analyzer.cc *str = str_i->second; str 528 base/test/trace_event_analyzer.cc Query::Query(const std::string& str) str 533 base/test/trace_event_analyzer.cc string_(str), str 181 base/test/trace_event_analyzer.h static Query String(const std::string& str); str 479 base/test/trace_event_analyzer.h explicit Query(const std::string& str); str 506 base/test/trace_event_analyzer.h bool GetAsString(const TraceEvent& event, std::string* str) const; str 89 base/test/trace_event_analyzer_unittest.cc const char* str = "the string"; str 96 base/test/trace_event_analyzer_unittest.cc event.arg_strings["string"] = str; str 110 base/test/trace_event_analyzer_unittest.cc EXPECT_STREQ(str, event.GetKnownArgAsString("string").c_str()); str 158 base/third_party/symbolize/demangle.cc static size_t StrLen(const char *str) { str 160 base/third_party/symbolize/demangle.cc while (*str != '\0') { str 161 base/third_party/symbolize/demangle.cc ++str; str 168 base/third_party/symbolize/demangle.cc static bool AtLeastNumCharsRemaining(const char *str, int n) { str 170 base/third_party/symbolize/demangle.cc if (str[i] == '\0') { str 178 base/third_party/symbolize/demangle.cc static bool StrPrefix(const char *str, const char *prefix) { str 180 base/third_party/symbolize/demangle.cc while (str[i] != '\0' && prefix[i] != '\0' && str 181 base/third_party/symbolize/demangle.cc str[i] == prefix[i]) { str 265 base/third_party/symbolize/demangle.cc static void Append(State *state, const char * const str, const int length) { str 269 base/third_party/symbolize/demangle.cc *state->out_cur = str[i]; str 298 base/third_party/symbolize/demangle.cc static bool IsFunctionCloneSuffix(const char *str) { str 300 base/third_party/symbolize/demangle.cc while (str[i] != '\0') { str 302 base/third_party/symbolize/demangle.cc if (str[i] != '.' || !IsAlpha(str[i + 1])) { str 306 base/third_party/symbolize/demangle.cc while (IsAlpha(str[i])) { str 309 base/third_party/symbolize/demangle.cc if (str[i] != '.' || !IsDigit(str[i + 1])) { str 313 base/third_party/symbolize/demangle.cc while (IsDigit(str[i])) { str 322 base/third_party/symbolize/demangle.cc static void MaybeAppendWithLength(State *state, const char * const str, str 327 base/third_party/symbolize/demangle.cc if (str[0] == '<' && state->out_begin < state->out_cur && str 332 base/third_party/symbolize/demangle.cc if (IsAlpha(str[0]) || str[0] == '_') { str 336 base/third_party/symbolize/demangle.cc Append(state, str, length); str 341 base/third_party/symbolize/demangle.cc static bool MaybeAppend(State *state, const char * const str) { str 343 base/third_party/symbolize/demangle.cc int length = StrLen(str); str 344 base/third_party/symbolize/demangle.cc MaybeAppendWithLength(state, str, length); str 572 base/third_party/xdg_mime/xdgmimecache.c ascii_tolower (const char *str) str 576 base/third_party/xdg_mime/xdgmimecache.c lower = strdup (str); str 389 base/third_party/xdg_mime/xdgmimeglob.c ascii_tolower (const char *str) str 393 base/third_party/xdg_mime/xdgmimeglob.c lower = strdup (str); str 24 base/value_conversions.cc std::string str; str 25 base/value_conversions.cc if (!value.GetAsString(&str)) str 28 base/value_conversions.cc *file_path = FilePath::FromUTF8Unsafe(str); str 40 base/value_conversions.cc std::string str; str 42 base/value_conversions.cc if (!value.GetAsString(&str) || !base::StringToInt64(str, &int_value)) str 46 base/win/scoped_bstr.cc BSTR ScopedBstr::Allocate(const char16* str) { str 47 base/win/scoped_bstr.cc Reset(SysAllocString(str)); str 45 base/win/scoped_bstr.h BSTR Allocate(const char16* str); str 19 base/win/scoped_variant.cc ScopedVariant::ScopedVariant(const wchar_t* str) { str 21 base/win/scoped_variant.cc Set(str); str 24 base/win/scoped_variant.cc ScopedVariant::ScopedVariant(const wchar_t* str, UINT length) { str 26 base/win/scoped_variant.cc var_.bstrVal = ::SysAllocStringLen(str, length); str 114 base/win/scoped_variant.cc void ScopedVariant::Set(const wchar_t* str) { str 117 base/win/scoped_variant.cc var_.bstrVal = ::SysAllocString(str); str 37 base/win/scoped_variant.h explicit ScopedVariant(const wchar_t* str); str 40 base/win/scoped_variant.h ScopedVariant(const wchar_t* str, UINT length); str 90 base/win/scoped_variant.h void Set(const wchar_t* str); str 1481 cc/layers/layer_impl.cc std::string str; str 1482 cc/layers/layer_impl.cc debug_info_->AppendAsTraceFormat(&str); str 1484 cc/layers/layer_impl.cc scoped_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str)); str 2778 cc/trees/layer_tree_host_impl.cc std::string str; str 2782 cc/trees/layer_tree_host_impl.cc json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str); str 2784 cc/trees/layer_tree_host_impl.cc return str; str 280 cc/trees/layer_tree_host_perftest.cc reinterpret_cast<const int8*>(name_stream.str().c_str())); str 129 chrome/browser/background/background_application_list_model_unittest.cc return output.str(); str 453 chrome/browser/bookmarks/bookmark_codec.cc void BookmarkCodec::UpdateChecksum(const std::string& str) { str 454 chrome/browser/bookmarks/bookmark_codec.cc base::MD5Update(&md5_context_, str); str 457 chrome/browser/bookmarks/bookmark_codec.cc void BookmarkCodec::UpdateChecksum(const base::string16& str) { str 460 chrome/browser/bookmarks/bookmark_codec.cc reinterpret_cast<const char*>(str.data()), str 461 chrome/browser/bookmarks/bookmark_codec.cc str.length() * sizeof(str[0]))); str 159 chrome/browser/bookmarks/bookmark_codec.h void UpdateChecksum(const std::string& str); str 160 chrome/browser/bookmarks/bookmark_codec.h void UpdateChecksum(const base::string16& str); str 219 chrome/browser/chromeos/app_mode/kiosk_app_manager_browsertest.cc std::string str; str 222 chrome/browser/chromeos/app_mode/kiosk_app_manager_browsertest.cc str += ','; str 223 chrome/browser/chromeos/app_mode/kiosk_app_manager_browsertest.cc str += apps[i].app_id; str 226 chrome/browser/chromeos/app_mode/kiosk_app_manager_browsertest.cc return str; str 87 chrome/browser/chromeos/file_manager/file_browser_handlers.cc std::string EscapedUtf8ToLower(const std::string& str) { str 89 chrome/browser/chromeos/file_manager/file_browser_handlers.cc net::UnescapeURLComponent(str, net::UnescapeRule::NORMAL)); str 72 chrome/browser/chromeos/file_manager/file_tasks.cc TaskType StringToTaskType(const std::string& str) { str 73 chrome/browser/chromeos/file_manager/file_tasks.cc if (str == kFileBrowserHandlerTaskType) str 75 chrome/browser/chromeos/file_manager/file_tasks.cc if (str == kFileHandlerTaskType) str 77 chrome/browser/chromeos/file_manager/file_tasks.cc if (str == kDriveAppTaskType) str 161 chrome/browser/chromeos/input_method/textinput_test_helper.cc bool TextInputTestHelper::ConvertRectFromString(const std::string& str, str 165 chrome/browser/chromeos/input_method/textinput_test_helper.cc if (Tokenize(str, ",", &rect_piece) != 4UL) str 59 chrome/browser/chromeos/input_method/textinput_test_helper.h static bool ConvertRectFromString(const std::string& str, gfx::Rect* rect); str 226 chrome/browser/chromeos/memory/oom_priority_manager.cc base::string16 str; str 227 chrome/browser/chromeos/memory/oom_priority_manager.cc str.reserve(4096); str 229 chrome/browser/chromeos/memory/oom_priority_manager.cc str += base::IntToString16(score); str 230 chrome/browser/chromeos/memory/oom_priority_manager.cc str += base::ASCIIToUTF16(" - "); str 231 chrome/browser/chromeos/memory/oom_priority_manager.cc str += it->title; str 232 chrome/browser/chromeos/memory/oom_priority_manager.cc str += base::ASCIIToUTF16(it->is_app ? " app" : ""); str 233 chrome/browser/chromeos/memory/oom_priority_manager.cc str += base::ASCIIToUTF16(it->is_reloadable_ui ? " reloadable_ui" : ""); str 234 chrome/browser/chromeos/memory/oom_priority_manager.cc str += base::ASCIIToUTF16(it->is_playing_audio ? " playing_audio" : ""); str 235 chrome/browser/chromeos/memory/oom_priority_manager.cc str += base::ASCIIToUTF16(it->is_pinned ? " pinned" : ""); str 236 chrome/browser/chromeos/memory/oom_priority_manager.cc str += base::ASCIIToUTF16(it->is_discarded ? " discarded" : ""); str 237 chrome/browser/chromeos/memory/oom_priority_manager.cc titles.push_back(str); str 113 chrome/browser/chromeos/policy/network_configuration_updater_unittest.cc std::stringstream str; str 114 chrome/browser/chromeos/policy/network_configuration_updater_unittest.cc str << value; str 115 chrome/browser/chromeos/policy/network_configuration_updater_unittest.cc return str.str(); str 63 chrome/browser/chromeos/power/cpu_data_collector.cc size_t IndexInVector(const std::string& str, str 66 chrome/browser/chromeos/power/cpu_data_collector.cc if (str == (*vector)[i]) str 71 chrome/browser/chromeos/power/cpu_data_collector.cc vector->push_back(str); str 49 chrome/browser/chromeos/status/network_menu.cc std::string str = input; str 50 chrome/browser/chromeos/status/network_menu.cc size_t found = str.find('&'); str 52 chrome/browser/chromeos/status/network_menu.cc str.replace(found, 1, "&&"); str 53 chrome/browser/chromeos/status/network_menu.cc found = str.find('&', found + 2); str 55 chrome/browser/chromeos/status/network_menu.cc return str; str 94 chrome/browser/chromeos/version_loader.cc std::string str = lines[i].substr(std::string(kFirmwarePrefix).size()); str 95 chrome/browser/chromeos/version_loader.cc size_t found = str.find_first_not_of("| "); str 97 chrome/browser/chromeos/version_loader.cc return str.substr(found); str 307 chrome/browser/devtools/adb_client_socket_browsertest.cc std::string response_data = response_stream.str(); str 292 chrome/browser/devtools/devtools_adb_bridge.cc void ParseScreenSize(const std::string& str); str 615 chrome/browser/devtools/devtools_adb_bridge.cc void AdbPagesCommand::ParseScreenSize(const std::string& str) { str 617 chrome/browser/devtools/devtools_adb_bridge.cc Tokenize(str, "-", &pairs); str 130 chrome/browser/diagnostics/sqlite_diagnostics.cc std::string str("Pragma failed. Error: "); str 131 chrome/browser/diagnostics/sqlite_diagnostics.cc str += base::IntToString(error); str 132 chrome/browser/diagnostics/sqlite_diagnostics.cc RecordFailure(DIAG_SQLITE_PRAGMA_FAILED, str); str 151 chrome/browser/diagnostics/sqlite_diagnostics.cc std::string str("Database corruption detected: "); str 152 chrome/browser/diagnostics/sqlite_diagnostics.cc str += base::IntToString(errors) + " errors"; str 153 chrome/browser/diagnostics/sqlite_diagnostics.cc RecordFailure(DIAG_SQLITE_DB_CORRUPTED, str); str 868 chrome/browser/download/download_browsertest.cc ASSERT_TRUE(url.is_valid()) << s.str(); str 873 chrome/browser/download/download_browsertest.cc ASSERT_TRUE(web_contents) << s.str(); str 932 chrome/browser/download/download_browsertest.cc ASSERT_EQ(downloads_expected, download_items.size()) << s.str(); str 942 chrome/browser/download/download_browsertest.cc ASSERT_EQ(url, item->GetOriginalUrl()) << s.str(); str 944 chrome/browser/download/download_browsertest.cc ASSERT_EQ(download_info.reason, item->GetLastReason()) << s.str(); str 1004 chrome/browser/download/download_browsertest.cc EXPECT_EQ(expected_successes, injector->TotalFileCount()) << s.str(); str 1005 chrome/browser/download/download_browsertest.cc EXPECT_EQ(0u, injector->CurrentFileCount()) << s.str(); str 1008 chrome/browser/download/download_browsertest.cc EXPECT_TRUE(injector->HadFile(GURL(info.error_info.url))) << s.str(); str 149 chrome/browser/drive/drive_api_util.cc std::string EscapeQueryStringValue(const std::string& str) { str 151 chrome/browser/drive/drive_api_util.cc result.reserve(str.size()); str 152 chrome/browser/drive/drive_api_util.cc for (size_t i = 0; i < str.size(); ++i) { str 153 chrome/browser/drive/drive_api_util.cc if (str[i] == '\\' || str[i] == '\'') { str 156 chrome/browser/drive/drive_api_util.cc result.push_back(str[i]); str 44 chrome/browser/drive/drive_api_util.h std::string EscapeQueryStringValue(const std::string& str); str 753 chrome/browser/extensions/api/cast_channel/cast_socket.cc void CastSocket::MessageHeader::PrependToString(std::string* str) { str 758 chrome/browser/extensions/api/cast_channel/cast_socket.cc str->insert(0, char_array, arraysize(char_array)); str 323 chrome/browser/extensions/api/cast_channel/cast_socket.h void PrependToString(std::string* str); str 323 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc bool Matches(const std::string& str) const; str 412 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc std::string str; str 413 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc CHECK(data->GetAsString(&str)); str 415 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc new StringMatchTest(str, type, case_sensitive)); str 421 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc const std::string& str) const { str 424 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc return StartsWithASCII(str, data_, case_sensitive_); str 426 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc return EndsWith(str, data_, case_sensitive_); str 428 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc return str.size() == data_.size() && str 429 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc StartsWithASCII(str, data_, case_sensitive_); str 432 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc return std::search(str.begin(), str.end(), data_.begin(), data_.end(), str 433 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc CaseInsensitiveCompareASCII<char>()) != str.end(); str 435 chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.cc return str.find(data_) != std::string::npos; str 96 chrome/browser/extensions/api/extension_action/extension_action_api.cc SkColor RawStringToSkColor(const std::string& str) { str 98 chrome/browser/extensions/api/extension_action/extension_action_api.cc base::StringToUint64(str, &value); str 110 chrome/browser/extensions/api/extension_action/extension_action_api.cc bool StringToSkBitmap(const std::string& str, SkBitmap* bitmap) { str 114 chrome/browser/extensions/api/extension_action/extension_action_api.cc if (!base::Base64Decode(str, &raw_str)) str 88 chrome/browser/extensions/api/file_system/file_system_api.cc CFStringRef str; str 89 chrome/browser/extensions/api/file_system/file_system_api.cc if (LSCopyDisplayNameForURL(url, &str) != noErr) str 92 chrome/browser/extensions/api/file_system/file_system_api.cc std::string result(base::SysCFStringRefToUTF8(str)); str 93 chrome/browser/extensions/api/file_system/file_system_api.cc CFRelease(str); str 99 chrome/browser/extensions/api/identity/account_tracker_unittest.cc std::string str = "["; str 104 chrome/browser/extensions/api/identity/account_tracker_unittest.cc str += ",\n "; str 106 chrome/browser/extensions/api/identity/account_tracker_unittest.cc str += it->ToString(); str 108 chrome/browser/extensions/api/identity/account_tracker_unittest.cc str += "]"; str 109 chrome/browser/extensions/api/identity/account_tracker_unittest.cc return str; str 36 chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc std::string SubstituteInstallParam(std::string str, str 38 chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc ReplaceSubstringsAfterOffset(&str, 0, "__PARAM__", install_parameter); str 39 chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc return str; str 34 chrome/browser/extensions/api/web_request/form_data_parser.h void set_value(const base::StringPiece& str) { str 35 chrome/browser/extensions/api/web_request/form_data_parser.h str.CopyToString(&value_); str 37 chrome/browser/extensions/api/web_request/form_data_parser.h void set_name(const std::string& str) { str 38 chrome/browser/extensions/api/web_request/form_data_parser.h name_ = str; str 40 chrome/browser/extensions/api/web_request/form_data_parser.h void set_value(const std::string& str) { str 41 chrome/browser/extensions/api/web_request/form_data_parser.h value_ = str; str 602 chrome/browser/extensions/api/web_request/web_request_api.cc std::string str; str 603 chrome/browser/extensions/api/web_request/web_request_api.cc if (!value.GetString(i, &str)) str 606 chrome/browser/extensions/api/web_request/web_request_api.cc if (str == "requestHeaders") str 608 chrome/browser/extensions/api/web_request/web_request_api.cc else if (str == "responseHeaders") str 610 chrome/browser/extensions/api/web_request/web_request_api.cc else if (str == "blocking") str 612 chrome/browser/extensions/api/web_request/web_request_api.cc else if (str == "asyncBlocking") str 614 chrome/browser/extensions/api/web_request/web_request_api.cc else if (str == "requestBody") str 18 chrome/browser/extensions/extension_notification_observer.cc std::string str = "["; str 23 chrome/browser/extensions/extension_notification_observer.cc str += ","; str 25 chrome/browser/extensions/extension_notification_observer.cc str += base::StringPrintf("%d", *it); str 27 chrome/browser/extensions/extension_notification_observer.cc str += "]"; str 28 chrome/browser/extensions/extension_notification_observer.cc return str; str 59 chrome/browser/feedback/feedback_uploader_delegate.cc << source->GetURL() << ") status: " << error_stream.str(); str 59 chrome/browser/google/google_util.cc bool HasGoogleSearchQueryParam(const std::string& str) { str 60 chrome/browser/google/google_util.cc url_parse::Component query(0, str.length()), key, value; str 61 chrome/browser/google/google_util.cc while (url_parse::ExtractQueryKeyValue(str.c_str(), &query, &key, str 63 chrome/browser/google/google_util.cc if ((key.len == 1) && (str[key.begin] == 'q') && value.is_nonempty()) str 24 chrome/browser/google/google_util.h bool HasGoogleSearchQueryParam(const std::string& str); str 86 chrome/browser/history/android/android_cache_database.cc sql.append(oss.str()); str 998 chrome/browser/history/android/android_provider_backend.cc statement.reset(QueryHistoryAndBookmarksInternal(projections, oss.str(), str 1384 chrome/browser/history/android/android_provider_backend_unittest.cc args.push_back(UTF8ToUTF16(oss.str())); str 1478 chrome/browser/history/android/android_provider_backend_unittest.cc args.push_back(UTF8ToUTF16(oss.str())); str 1488 chrome/browser/history/android/android_provider_backend_unittest.cc args.push_back(UTF8ToUTF16(oss1.str())); str 1504 chrome/browser/history/android/android_provider_backend_unittest.cc args.push_back(UTF8ToUTF16(oss1.str())); str 1533 chrome/browser/history/android/android_provider_backend_unittest.cc args.push_back(UTF8ToUTF16(oss.str())); str 104 chrome/browser/history/android/android_urls_database.cc sql.append(oss.str()); str 25 chrome/browser/history/delete_directive_handler.cc std::string str; str 26 chrome/browser/history/delete_directive_handler.cc base::JSONWriter::Write(value.get(), &str); str 27 chrome/browser/history/delete_directive_handler.cc return str; str 93 chrome/browser/history/expire_history_backend_unittest.cc static bool IsStringInFile(const base::FilePath& filename, const char* str); str 392 chrome/browser/history/expire_history_backend_unittest.cc const char* str) { str 395 chrome/browser/history/expire_history_backend_unittest.cc return contents.find(str) != std::string::npos; str 1289 chrome/browser/history/top_sites_impl_unittest.cc AppendMostVisitedURL(&old_url_list, GURL(url.str())); str 1290 chrome/browser/history/top_sites_impl_unittest.cc url.str(""); str 1292 chrome/browser/history/top_sites_impl_unittest.cc AppendMostVisitedURL(&new_url_list, GURL(url.str())); str 18 chrome/browser/local_discovery/device_description.cc ConnectionStateFromString(const std::string& str) { str 19 chrome/browser/local_discovery/device_description.cc if (LowerCaseEqualsASCII(str, kPrivetConnectionStatusOnline)) { str 21 chrome/browser/local_discovery/device_description.cc } else if (LowerCaseEqualsASCII(str, kPrivetConnectionStatusOffline)) { str 23 chrome/browser/local_discovery/device_description.cc } else if (LowerCaseEqualsASCII(str, kPrivetConnectionStatusConnecting)) { str 25 chrome/browser/local_discovery/device_description.cc } else if (LowerCaseEqualsASCII(str, kPrivetConnectionStatusNotConfigured)) { str 828 chrome/browser/local_discovery/privet_http_unittest.cc std::string str) { str 830 chrome/browser/local_discovery/privet_http_unittest.cc str_vec.insert(str_vec.begin(), str.begin(), str.end()); str 16 chrome/browser/local_discovery/storage/path_util.cc std::string UnescapeSlashes(const std::string& str) { str 18 chrome/browser/local_discovery/storage/path_util.cc for (size_t i = 0; i < str.length(); i++) { str 19 chrome/browser/local_discovery/storage/path_util.cc if (str[i] == '$') { str 21 chrome/browser/local_discovery/storage/path_util.cc switch (str[i]) { str 35 chrome/browser/local_discovery/storage/path_util.cc output += str[i]; str 23 chrome/browser/local_discovery/storage/privet_volume_lister.cc std::string EscapeSlashes(const std::string& str) { str 25 chrome/browser/local_discovery/storage/privet_volume_lister.cc for (size_t i = 0; i < str.length(); i++) { str 26 chrome/browser/local_discovery/storage/privet_volume_lister.cc switch (str[i]) { str 37 chrome/browser/local_discovery/storage/privet_volume_lister.cc output += str[i]; str 44 chrome/browser/local_discovery/storage/privet_volume_lister.cc std::string RemoveSlashes(const std::string& str) { str 46 chrome/browser/local_discovery/storage/privet_volume_lister.cc for (size_t i = 0; i < str.length(); i++) { str 47 chrome/browser/local_discovery/storage/privet_volume_lister.cc switch (str[i]) { str 52 chrome/browser/local_discovery/storage/privet_volume_lister.cc output += str[i]; str 61 chrome/browser/media/webrtc_browsertest_base.cc const std::string& str) { str 65 chrome/browser/media/webrtc_browsertest_base.cc bool contains_uncaught = str.find("\"Uncaught ") != std::string::npos; str 61 chrome/browser/metrics/metrics_log_serializer_unittest.cc std::string str; str 62 chrome/browser/metrics/metrics_log_serializer_unittest.cc (*it)->GetAsString(&str); // Base64 encoded "Hello world!" string. str 65 chrome/browser/metrics/metrics_log_serializer_unittest.cc EXPECT_TRUE(encoded == str); str 68 chrome/browser/metrics/metrics_log_serializer_unittest.cc (*it)->GetAsString(&str); // MD5 for encoded "Hello world!" string. str 69 chrome/browser/metrics/metrics_log_serializer_unittest.cc EXPECT_TRUE(base::MD5String(encoded) == str); str 164 chrome/browser/net/network_stats.h int SendData(const std::string& str); str 62 chrome/browser/net/probe_message.cc uint32 ProbeMessage::Checksum(const std::string& str) const { str 64 chrome/browser/net/probe_message.cc for (std::string::const_iterator i = str.begin(); i != str.end(); ++i) { str 48 chrome/browser/net/probe_message.h uint32 Checksum(const std::string& str) const; str 83 chrome/browser/net/probe_message_unittest.cc std::string str("ABC"); str 84 chrome/browser/net/probe_message_unittest.cc uint32 computed_checksum = pm.Checksum(str); str 86 chrome/browser/net/probe_message_unittest.cc for (unsigned i = 0; i < str.size(); ++i) str 87 chrome/browser/net/probe_message_unittest.cc expected_sum += static_cast<uint8>(str[i]); str 189 chrome/browser/password_manager/password_store_mac.cc port_string = port_stringstream.str(); str 407 chrome/browser/policy/policy_prefs_browsertest.cc ASSERT_TRUE(content::ExecuteScriptAndExtractString(contents, javascript.str(), str 628 chrome/browser/process_singleton_linux.cc std::string str(buf_, bytes_read_); str 630 chrome/browser/process_singleton_linux.cc base::SplitString(str, kTokenDelimiter, &tokens); str 633 chrome/browser/process_singleton_linux.cc LOG(ERROR) << "Wrong message format: " << str; str 399 chrome/browser/profile_resetter/profile_resetter_unittest.cc void ReplaceString(std::string* str, str 402 chrome/browser/profile_resetter/profile_resetter_unittest.cc ASSERT_NE(static_cast<std::string*>(NULL), str); str 403 chrome/browser/profile_resetter/profile_resetter_unittest.cc size_t placeholder_pos = str->find(placeholder); str 405 chrome/browser/profile_resetter/profile_resetter_unittest.cc str->replace(placeholder_pos, placeholder.size(), substitution); str 38 chrome/browser/profiles/profile_downloader_unittest.cc return stream.str(); str 49 chrome/browser/rlz/rlz_unittest.cc const char* str, str 51 chrome/browser/rlz/rlz_unittest.cc if (NULL != strstr(str, substr)) { str 57 chrome/browser/rlz/rlz_unittest.cc << substr << "' not in '" << str << "'"; str 62 chrome/browser/rlz/rlz_unittest.cc const char* str, str 64 chrome/browser/rlz/rlz_unittest.cc if (NULL == strstr(str, substr)) { str 70 chrome/browser/rlz/rlz_unittest.cc << substr << "' in '" << str << "'"; str 73 chrome/browser/rlz/rlz_unittest.cc #define EXPECT_STR_CONTAINS(str, substr) \ str 74 chrome/browser/rlz/rlz_unittest.cc EXPECT_PRED_FORMAT2(CmpHelperSTRC, str, substr) str 76 chrome/browser/rlz/rlz_unittest.cc #define EXPECT_STR_NOT_CONTAIN(str, substr) \ str 77 chrome/browser/rlz/rlz_unittest.cc EXPECT_PRED_FORMAT2(CmpHelperSTRNC, str, substr) str 299 chrome/browser/safe_browsing/database_manager.cc const std::string& str) { str 304 chrome/browser/safe_browsing/database_manager.cc return database_->ContainsDownloadWhitelistedString(str); str 171 chrome/browser/safe_browsing/database_manager.h virtual bool MatchDownloadWhitelistString(const std::string& str); str 830 chrome/browser/safe_browsing/safe_browsing_database.cc const std::string& str) { str 832 chrome/browser/safe_browsing/safe_browsing_database.cc hashes.push_back(SBFullHashForString(str)); str 127 chrome/browser/safe_browsing/safe_browsing_database.h virtual bool ContainsDownloadWhitelistedString(const std::string& str) = 0; str 303 chrome/browser/safe_browsing/safe_browsing_database.h const std::string& str) OVERRIDE; str 28 chrome/browser/safe_browsing/safe_browsing_database_unittest.cc SBPrefix SBPrefixForString(const std::string& str) { str 29 chrome/browser/safe_browsing/safe_browsing_database_unittest.cc return SBFullHashForString(str).prefix; str 223 chrome/browser/safe_browsing/safe_browsing_database_unittest.cc size_t message_start, const std::string& str) { str 227 chrome/browser/safe_browsing/safe_browsing_database_unittest.cc size_t newline = str.find('\n'); str 229 chrome/browser/safe_browsing/safe_browsing_database_unittest.cc const std::string msg = str.substr(0, newline + 1); str 112 chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc const std::string& str) OVERRIDE { str 22 chrome/browser/safe_browsing/safe_browsing_util.cc SBFullHash SBFullHashForString(const base::StringPiece& str) { str 24 chrome/browser/safe_browsing/safe_browsing_util.cc crypto::SHA256HashString(str, &h.full_hash, sizeof(h.full_hash)); str 285 chrome/browser/safe_browsing/safe_browsing_util.cc std::string RemoveConsecutiveChars(const std::string& str, const char c) { str 286 chrome/browser/safe_browsing/safe_browsing_util.cc std::string output(str); str 44 chrome/browser/safe_browsing/safe_browsing_util.h SBFullHash SBFullHashForString(const base::StringPiece& str); str 15 chrome/browser/safe_browsing/safe_browsing_util_unittest.cc const std::string& str) { str 16 chrome/browser/safe_browsing/safe_browsing_util_unittest.cc return std::find(data.begin(), data.end(), str) != data.end(); str 33 chrome/browser/sessions/base_session_service.cc const std::string& str) { str 34 chrome/browser/sessions/base_session_service.cc int num_bytes = str.size() * sizeof(char); str 37 chrome/browser/sessions/base_session_service.cc pickle.WriteString(str); str 55 chrome/browser/speech/extension_api/tts_extension_api.cc TtsEventType TtsEventTypeFromString(const std::string& str) { str 56 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeStart) str 58 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeEnd) str 60 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeWord) str 62 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeSentence) str 64 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeMarker) str 66 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeInterrupted) str 68 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeCancelled) str 70 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeError) str 72 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypePause) str 74 chrome/browser/speech/extension_api/tts_extension_api.cc if (str == constants::kEventTypeResume) str 19 chrome/browser/speech/extension_api/tts_extension_api.h TtsEventType TtsEventTypeFromString(const std::string& str); str 120 chrome/browser/spellchecker/spellcheck_custom_dictionary.cc std::string checksum = base::MD5String(content.str()); str 123 chrome/browser/spellchecker/spellcheck_custom_dictionary.cc base::ImportantFileWriter::WriteFileAtomically(path, content.str()); str 29 chrome/browser/sync/about_sync_util_unittest.cc base::string16 str(base::ASCIIToUTF16("none")); str 42 chrome/browser/sync/about_sync_util_unittest.cc .WillOnce(Return(str)); str 119 chrome/browser/sync/profile_sync_service_session_unittest.cc const std::string& str, str 121 chrome/browser/sync/profile_sync_service_session_unittest.cc if (mem->size() != str.size()) str 124 chrome/browser/sync/profile_sync_service_session_unittest.cc if (str[i] != *(mem->front() + i)) str 435 chrome/browser/sync/test/integration/profile_sync_service_harness.cc return os.str(); str 49 chrome/browser/sync_file_system/drive_backend/metadata_database.cc std::string RemovePrefix(const std::string& str, const std::string& prefix) { str 50 chrome/browser/sync_file_system/drive_backend/metadata_database.cc if (StartsWithASCII(str, prefix, true)) str 51 chrome/browser/sync_file_system/drive_backend/metadata_database.cc return str.substr(prefix.size()); str 52 chrome/browser/sync_file_system/drive_backend/metadata_database.cc return str; str 1149 chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc std::string str; str 1152 chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0"); str 1153 chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc EXPECT_TRUE(file->GetString("type", &str) && str == "folder"); str 1157 chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc EXPECT_TRUE(file->GetString("title", &str) && str == "file_0"); str 1158 chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc EXPECT_TRUE(file->GetString("type", &str) && str == "file"); str 25 chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc std::string RemovePrefix(const std::string& str, const std::string& prefix) { str 26 chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc if (StartsWithASCII(str, prefix, true)) str 27 chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc return std::string(str.begin() + prefix.size(), str.end()); str 28 chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.cc return str; str 80 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.cc std::string RemovePrefix(const std::string& str, const std::string& prefix) { str 81 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.cc if (StartsWithASCII(str, prefix, true)) str 82 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.cc return str.substr(prefix.size()); str 83 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.cc return str; str 610 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store_unittest.cc std::string str; str 613 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store_unittest.cc EXPECT_TRUE(file->GetString("title", &str) && str == "file_0"); str 614 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store_unittest.cc EXPECT_TRUE(file->GetString("type", &str) && str == "file"); str 618 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store_unittest.cc EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0"); str 619 chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store_unittest.cc EXPECT_TRUE(file->GetString("type", &str) && str == "folder"); str 30 chrome/browser/sync_file_system/drive_backend_v1/local_sync_operation_resolver_unittest.cc return ss.str(); str 78 chrome/browser/sync_file_system/drive_backend_v1/local_sync_operation_resolver_unittest.cc return ss.str(); str 26 chrome/browser/sync_file_system/drive_backend_v1/remote_sync_operation_resolver_unittest.cc return ss.str(); str 86 chrome/browser/sync_file_system/file_change.cc return ss.str(); str 1465 chrome/browser/task_manager/task_manager.cc base::string16 str = base::FormatNumber(number / 1024); str 1468 chrome/browser/task_manager/task_manager.cc base::i18n::AdjustStringForLocaleDirection(&str); str 1469 chrome/browser/task_manager/task_manager.cc return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT, str); str 25 chrome/browser/ui/android/autofill/autofill_dialog_result.cc std::string ConvertNullOrJavaStringToUTF8(JNIEnv* env, jstring str) { str 26 chrome/browser/ui/android/autofill/autofill_dialog_result.cc return str ? base::android::ConvertJavaStringToUTF8(env, str) : std::string(); str 29 chrome/browser/ui/android/autofill/autofill_dialog_result.cc base::string16 ConvertNullOrJavaStringToUTF16(JNIEnv* env, jstring str) { str 30 chrome/browser/ui/android/autofill/autofill_dialog_result.cc return str ? base::android::ConvertJavaStringToUTF16(env, str) str 37 chrome/browser/ui/app_list/search/history_data_store.cc std::string str; str 38 chrome/browser/ui/app_list/search/history_data_store.cc if (!(*it)->GetAsString(&str)) str 41 chrome/browser/ui/app_list/search/history_data_store.cc results.push_back(str); str 23 chrome/browser/ui/app_list/search/history_data_store_unittest.cc std::string str = std::string("p:") + data.primary + ";s:"; str 30 chrome/browser/ui/app_list/search/history_data_store_unittest.cc str += ','; str 32 chrome/browser/ui/app_list/search/history_data_store_unittest.cc str += *it; str 35 chrome/browser/ui/app_list/search/history_data_store_unittest.cc return str; str 19 chrome/browser/ui/app_list/search/tokenized_string_unittest.cc base::string16 str; str 22 chrome/browser/ui/app_list/search/tokenized_string_unittest.cc str += ' '; str 23 chrome/browser/ui/app_list/search/tokenized_string_unittest.cc str += tokens[i]; str 24 chrome/browser/ui/app_list/search/tokenized_string_unittest.cc str += base::UTF8ToUTF16(mappings[i].ToString()); str 26 chrome/browser/ui/app_list/search/tokenized_string_unittest.cc return str; str 23 chrome/browser/ui/browser_window_state.cc bool ParseCommaSeparatedIntegers(const std::string& str, str 26 chrome/browser/ui/browser_window_state.cc size_t num1_size = str.find_first_of(','); str 31 chrome/browser/ui/browser_window_state.cc size_t num2_size = str.size() - num2_pos; str 33 chrome/browser/ui/browser_window_state.cc if (!base::StringToInt(str.substr(0, num1_size), &num1) || str 34 chrome/browser/ui/browser_window_state.cc !base::StringToInt(str.substr(num2_pos, num2_size), &num2)) str 107 chrome/browser/ui/browser_window_state.cc std::string str = str 110 chrome/browser/ui/browser_window_state.cc if (ParseCommaSeparatedIntegers(str, &width, &height)) str 114 chrome/browser/ui/browser_window_state.cc std::string str = str 117 chrome/browser/ui/browser_window_state.cc if (ParseCommaSeparatedIntegers(str, &x, &y)) str 41 chrome/browser/ui/certificate_dialogs.cc std::string WrapAt64(const std::string &str) { str 43 chrome/browser/ui/certificate_dialogs.cc for (size_t i = 0; i < str.size(); i += 64) { str 44 chrome/browser/ui/certificate_dialogs.cc result.append(str, i, 64); // Append clamps the len arg internally. str 96 chrome/browser/ui/cocoa/location_bar/location_bar_decoration.h static void DrawAttributedString(NSAttributedString* str, str 642 chrome/browser/ui/fullscreen/fullscreen_controller_state_test.cc std::string output_log = "\nDebugging Log:\n" + debugging_log_.str(); str 643 chrome/browser/ui/fullscreen/fullscreen_controller_state_test.cc debugging_log_.str(std::string()); str 797 chrome/browser/ui/fullscreen/fullscreen_controller_state_test.cc return output.str(); str 823 chrome/browser/ui/fullscreen/fullscreen_controller_state_test.cc return output.str(); str 413 chrome/browser/ui/fullscreen/fullscreen_controller_state_unittest.cc LOG(INFO) << output.str(); str 37 chrome/browser/ui/gtk/sad_tab_gtk.cc GtkWidget* MakeWhiteMarkupLabel(const char* format, const std::string& str) { str 39 chrome/browser/ui/gtk/sad_tab_gtk.cc char* markup = g_markup_printf_escaped(format, str.c_str()); str 280 chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.cc const gchar* str) { str 281 chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.cc if (str && *str) str 283 chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.cc TextEditCommandX11::INSERT_TEXT, str, false); str 108 chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.h static void InsertAtCursor(GtkTextView* text_view, const gchar* str); str 253 chrome/browser/ui/libgtk2ui/x11_input_method_context_impl_gtk2.cc gchar* str = NULL; str 256 chrome/browser/ui/libgtk2ui/x11_input_method_context_impl_gtk2.cc gtk_im_context_get_preedit_string(context, &str, &attrs, &cursor_pos); str 258 chrome/browser/ui/libgtk2ui/x11_input_method_context_impl_gtk2.cc ui::ExtractCompositionTextFromGtkPreedit(str, attrs, cursor_pos, str 260 chrome/browser/ui/libgtk2ui/x11_input_method_context_impl_gtk2.cc g_free(str); str 976 chrome/browser/ui/search/instant_extended_interactive_uitest.cc EXPECT_TRUE(content::ExecuteScript(contents, stream.str())); str 130 chrome/browser/ui/views/app_list/win/app_list_service_win.cc result.append(base::UTF8ToUTF16(ss.str())); str 390 chrome/browser/ui/views/find_bar_host_interactive_uitest.cc base::string16 str; str 392 chrome/browser/ui/views/find_bar_host_interactive_uitest.cc &str); str 395 chrome/browser/ui/views/find_bar_host_interactive_uitest.cc EXPECT_EQ(ASCIIToUTF16("a"), str); str 61 chrome/browser/ui/webui/chromeos/login/network_screen_handler.cc bool InsertString(const std::string& str, std::set<std::string>& to) { str 63 chrome/browser/ui/webui/chromeos/login/network_screen_handler.cc to.insert(str); str 116 chrome/browser/ui/webui/net_internals/net_internals_ui.cc std::string str; str 119 chrome/browser/ui/webui/net_internals/net_internals_ui.cc str += ","; str 120 chrome/browser/ui/webui/net_internals/net_internals_ui.cc str += hashes[i].ToString(); str 122 chrome/browser/ui/webui/net_internals/net_internals_ui.cc return str; str 631 chrome/browser/ui/webui/options/chromeos/internet_options_handler.cc std::string str = base::StringPrintf("%d", int_value); str 632 chrome/browser/ui/webui/options/chromeos/internet_options_handler.cc dest->SetStringWithoutPathExpansion(dest_key, str); str 340 chrome/browser/ui/webui/options/preferences_browsertest.cc render_view_host_, javascript.str(), observed_json)); str 357 chrome/browser/ui/webui/options/preferences_browsertest.cc render_view_host_, javascript.str(), observed_json)); str 391 chrome/browser/ui/webui/options/preferences_browsertest.cc render_view_host_, javascript.str(), &observed_json)); str 405 chrome/browser/ui/webui/options/preferences_browsertest.cc render_view_host_, javascript.str(), &observed_json)); str 433 chrome/browser/ui/webui/options/preferences_browsertest.cc render_view_host_, javascript.str(), &observed_json)); str 201 chrome/common/content_settings_pattern_parser.cc std::string str; str 203 chrome/common/content_settings_pattern_parser.cc str += parts.scheme + content::kStandardSchemeSeparator; str 207 chrome/common/content_settings_pattern_parser.cc return str + kUrlPathSeparator + kPathWildcard; str 209 chrome/common/content_settings_pattern_parser.cc return str + parts.path; str 214 chrome/common/content_settings_pattern_parser.cc str += kHostWildcard; str 216 chrome/common/content_settings_pattern_parser.cc str += kDomainWildcard; str 218 chrome/common/content_settings_pattern_parser.cc str += parts.host; str 221 chrome/common/content_settings_pattern_parser.cc str += parts.path.empty() ? std::string(kUrlPathSeparator) : parts.path; str 222 chrome/common/content_settings_pattern_parser.cc return str; str 226 chrome/common/content_settings_pattern_parser.cc str += std::string(kUrlPortSeparator) + parts.port; str 229 chrome/common/content_settings_pattern_parser.cc return str; str 12 chrome/common/content_settings_pattern_unittest.cc ContentSettingsPattern Pattern(const std::string& str) { str 13 chrome/common/content_settings_pattern_unittest.cc return ContentSettingsPattern::FromString(str); str 90 chrome/common/logging_chrome.cc void SilentRuntimeAssertHandler(const std::string& str) { str 93 chrome/common/logging_chrome.cc void SilentRuntimeReportHandler(const std::string& str) { str 98 chrome/common/logging_chrome.cc void DumpProcessAssertHandler(const std::string& str) { str 32 chrome/common/profiling.cc event->name.str, event->name.len); str 273 chrome/installer/gcapi/gcapi.cc wchar_t str[] = L"test"; str 281 chrome/installer/gcapi/gcapi.cc if (::RegSetValueEx(key, str, 0, REG_SZ, (LPBYTE)str, str 282 chrome/installer/gcapi/gcapi.cc (DWORD)lstrlen(str)) == ERROR_SUCCESS) { str 284 chrome/installer/gcapi/gcapi.cc RegDeleteValue(key, str); str 25 chrome/installer/mini_installer/decompress.cc char* WideToUtf8(const wchar_t* str, int len) { str 27 chrome/installer/mini_installer/decompress.cc int size = WideCharToMultiByte(CP_UTF8, 0, str, len, NULL, 0, NULL, NULL); str 33 chrome/installer/mini_installer/decompress.cc WideCharToMultiByte(CP_UTF8, 0, str, len, ret, size, NULL, NULL); str 41 chrome/installer/mini_installer/decompress.cc wchar_t* Utf8ToWide(const char* str) { str 43 chrome/installer/mini_installer/decompress.cc int size = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0); str 47 chrome/installer/mini_installer/decompress.cc MultiByteToWideChar(CP_UTF8, 0, str, -1, ret, size); str 26 chrome/installer/mini_installer/mini_string.cc bool HexEncode(const void* bytes, size_t size, wchar_t* str, size_t str_size) { str 32 chrome/installer/mini_installer/mini_string.cc str[size * 2] = L'\0'; str 36 chrome/installer/mini_installer/mini_string.cc str[(i * 2)] = kHexChars[(b >> 4) & 0xf]; str 37 chrome/installer/mini_installer/mini_string.cc str[(i * 2) + 1] = kHexChars[b & 0xf]; str 43 chrome/installer/mini_installer/mini_string.cc size_t SafeStrLen(const wchar_t* str, size_t alloc_size) { str 44 chrome/installer/mini_installer/mini_string.cc if (!str || !alloc_size) str 47 chrome/installer/mini_installer/mini_string.cc while (--alloc_size && str[len] != L'\0') str 88 chrome/installer/mini_installer/mini_string.cc bool StrEndsWith(const wchar_t* str, const wchar_t* end_str) { str 89 chrome/installer/mini_installer/mini_string.cc if (str == NULL || end_str == NULL) str 92 chrome/installer/mini_installer/mini_string.cc for (int i = lstrlen(str) - 1, j = lstrlen(end_str) - 1; j >= 0; --i, --j) { str 93 chrome/installer/mini_installer/mini_string.cc if (i < 0 || !EqualASCIICharI(str[i], end_str[j])) str 100 chrome/installer/mini_installer/mini_string.cc bool StrStartsWith(const wchar_t* str, const wchar_t* start_str) { str 101 chrome/installer/mini_installer/mini_string.cc if (str == NULL || start_str == NULL) str 105 chrome/installer/mini_installer/mini_string.cc if (!EqualASCIICharI(str[i], start_str[i])) str 133 chrome/installer/mini_installer/mini_string.cc bool FindTagInStr(const wchar_t* str, str 137 chrome/installer/mini_installer/mini_string.cc const wchar_t* scan = str; str 24 chrome/installer/mini_installer/mini_string.h bool HexEncode(const void* bytes, size_t size, wchar_t* str, size_t str_size); str 29 chrome/installer/mini_installer/mini_string.h size_t SafeStrLen(const wchar_t* str, size_t alloc_size); str 46 chrome/installer/mini_installer/mini_string.h bool StrEndsWith(const wchar_t* str, const wchar_t* end_str); str 50 chrome/installer/mini_installer/mini_string.h bool StrStartsWith(const wchar_t* str, const wchar_t* start_str); str 58 chrome/installer/mini_installer/mini_string.h bool FindTagInStr(const wchar_t* str, const wchar_t* tag, str 93 chrome/installer/mini_installer/mini_string.h bool assign(const wchar_t* str) { str 94 chrome/installer/mini_installer/mini_string.h return SafeStrCopy(buffer_, kCapacity, str); str 97 chrome/installer/mini_installer/mini_string.h bool append(const wchar_t* str) { str 98 chrome/installer/mini_installer/mini_string.h return SafeStrCat(buffer_, kCapacity, str); str 115 chrome/installer/mini_installer/mini_string.h int comparei(const wchar_t* str) const { str 116 chrome/installer/mini_installer/mini_string.h return lstrcmpiW(buffer_, str); str 120 chrome/installer/mini_installer/mini_string.h int compare(const wchar_t* str) const { str 121 chrome/installer/mini_installer/mini_string.h return lstrcmpW(buffer_, str); str 29 chrome/installer/mini_installer/mini_string_test.cc StackString<MAX_PATH> str; str 30 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(MAX_PATH, str.capacity()); str 34 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(str.length(), compare_str.length()); str 35 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(0, compare_str.compare(str.get())); str 37 chrome/installer/mini_installer/mini_string_test.cc size_t max_chars = str.capacity() - 1; str 39 chrome/installer/mini_installer/mini_string_test.cc while ((str.length() + (arraysize(kTestString) - 1)) <= max_chars) { str 40 chrome/installer/mini_installer/mini_string_test.cc EXPECT_TRUE(str.append(kTestString)); str 42 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(str.length(), compare_str.length()); str 43 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(0, compare_str.compare(str.get())); str 46 chrome/installer/mini_installer/mini_string_test.cc EXPECT_GT(static_cast<size_t>(MAX_PATH), str.length()); str 50 chrome/installer/mini_installer/mini_string_test.cc EXPECT_FALSE(str.append(kTestString)); str 53 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(0, compare_str.compare(str.get())); str 54 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(str.length(), compare_str.length()); str 57 chrome/installer/mini_installer/mini_string_test.cc str.clear(); str 59 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(0, compare_str.compare(str.get())); str 60 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(str.length(), compare_str.length()); str 69 chrome/installer/mini_installer/mini_string_test.cc StackString<MAX_PATH> str; str 70 chrome/installer/mini_installer/mini_string_test.cc EXPECT_TRUE(str.assign(kTestStringSource)); str 71 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(str.get(), str.findi(kTestStringSource)); str 72 chrome/installer/mini_installer/mini_string_test.cc EXPECT_EQ(static_cast<const wchar_t*>(NULL), str.findi(kTestStringNotFound)); str 73 chrome/installer/mini_installer/mini_string_test.cc const wchar_t* found = str.findi(kTestStringFind); str 37 chrome/installer/tools/validate_installation_main.cc const std::string& str); str 107 chrome/installer/tools/validate_installation_main.cc const std::string& str) { str 109 chrome/installer/tools/validate_installation_main.cc fprintf(kOutputStream_, "%s", str.c_str() + message_start); str 114 chrome/installer/tools/validate_installation_main.cc return (old_message_handler_)(severity, file, line, message_start, str); str 104 chrome/installer/util/delete_after_reboot_helper_unittest.cc wchar_t* str; str 116 chrome/installer/util/delete_after_reboot_helper_unittest.cc MultiSZBytesToStringArray(reinterpret_cast<char*>(tests[i].str), str 124 chrome/installer/util/delete_after_reboot_helper_unittest.cc reinterpret_cast<char*>(tests[i].str), str 134 chrome/installer/util/delete_after_reboot_helper_unittest.cc MultiSZBytesToStringArray(reinterpret_cast<char*>(failures[i].str), str 32 chrome/installer/util/installation_validation_helper.cc const std::string& str); str 82 chrome/installer/util/installation_validation_helper.cc const std::string& str) { str 83 chrome/installer/util/installation_validation_helper.cc if (severity == kViolationSeverity_ && !str.empty()) { str 85 chrome/installer/util/installation_validation_helper.cc size_t message_length = str.size() - message_start; str 86 chrome/installer/util/installation_validation_helper.cc if (*str.rbegin() == '\n') str 89 chrome/installer/util/installation_validation_helper.cc << base::StringPiece(str.c_str() + message_start, message_length); str 94 chrome/installer/util/installation_validation_helper.cc return (old_message_handler_)(severity, file, line, message_start, str); str 337 chrome/installer/util/installation_validator_unittest.cc const std::string& str); str 415 chrome/installer/util/installation_validator_unittest.cc const std::string& str) { str 417 chrome/installer/util/installation_validator_unittest.cc if (severity == logging::LOG_ERROR && !str.empty()) { str 419 chrome/installer/util/installation_validator_unittest.cc size_t message_length = str.size() - message_start; str 420 chrome/installer/util/installation_validator_unittest.cc if (*str.rbegin() == '\n') str 424 chrome/installer/util/installation_validator_unittest.cc file, line, str.substr(message_start, message_length).c_str()); str 428 chrome/installer/util/installation_validator_unittest.cc << base::StringPiece(str.c_str() + message_start, message_length); str 434 chrome/installer/util/installation_validator_unittest.cc return (old_log_message_handler_)(severity, file, line, message_start, str); str 306 chrome/installer/util/master_preferences_unittest.cc CommandLine chrome_install(CommandLine::FromString(chrome_cmd.str())); str 321 chrome/installer/util/master_preferences_unittest.cc CommandLine chrome_install(CommandLine::FromString(chrome_cmd.str())); str 52 chrome/renderer/net/predictor_queue_unittest.cc buffer_->Push(value.str().c_str(), value.str().size()) : str 53 chrome/renderer/net/predictor_queue_unittest.cc buffer_->Push(value.str()); str 64 chrome/renderer/net/predictor_queue_unittest.cc EXPECT_STREQ(expected_value.str().c_str(), string.c_str()) str 93 chrome/renderer/plugins/plugin_uma.cc const char* str) { str 94 chrome/renderer/plugins/plugin_uma.cc return std::binary_search(array, array + array_size, str, CompareCStrings); str 71 chrome/renderer/plugins/plugin_uma.h const char* str); str 10 chrome/renderer/safe_browsing/murmurhash3_util.cc uint32 MurmurHash3String(const std::string& str, uint32 seed) { str 12 chrome/renderer/safe_browsing/murmurhash3_util.cc MurmurHash3_x86_32(str.data(), str.size(), seed, &output); str 15 chrome/renderer/safe_browsing/murmurhash3_util.h uint32 MurmurHash3String(const std::string& str, uint32 seed); str 324 chrome/renderer/translate/translate_helper.cc scoped_ptr<char[]> str(new char[length]); str 325 chrome/renderer/translate/translate_helper.cc v8_str->WriteUtf8(str.get(), length); str 326 chrome/renderer/translate/translate_helper.cc return std::string(str.get()); str 301 chrome/service/cloud_print/printer_job_handler_unittest.cc MOCK_METHOD1(OnPrinterDeleted, void(const std::string& str)); str 28 chrome/test/base/v8_unit_test.cc v8::String::Utf8Value str(args[i]); str 29 chrome/test/base/v8_unit_test.cc message += *str; str 235 chrome/test/base/v8_unit_test.cc std::string str; str 240 chrome/test/base/v8_unit_test.cc str.append(base::StringPrintf("%s\n", *exception)); str 245 chrome/test/base/v8_unit_test.cc str.append(base::StringPrintf( str 248 chrome/test/base/v8_unit_test.cc str.append(base::StringPrintf("%s\n", *sourceline)); str 250 chrome/test/base/v8_unit_test.cc return str; str 74 chrome/test/base/web_ui_browsertest.cc const std::string& str) { str 78 chrome/test/base/web_ui_browsertest.cc error_messages_.Get().push_back(str); str 40 chrome/test/chromedriver/capabilities.cc std::string str; str 41 chrome/test/chromedriver/capabilities.cc if (!option.GetAsString(&str)) str 43 chrome/test/chromedriver/capabilities.cc if (str.empty()) str 45 chrome/test/chromedriver/capabilities.cc *to_set = str; str 52 chrome/test/chromedriver/capabilities.cc base::FilePath::StringType str; str 53 chrome/test/chromedriver/capabilities.cc if (!option.GetAsString(&str)) str 55 chrome/test/chromedriver/capabilities.cc *to_set = base::FilePath(str); str 392 chrome/test/chromedriver/capabilities.cc std::string str; str 395 chrome/test/chromedriver/capabilities.cc str += "--" + iter->first; str 400 chrome/test/chromedriver/capabilities.cc str += "=" + value; str 405 chrome/test/chromedriver/capabilities.cc str += " "; str 407 chrome/test/chromedriver/capabilities.cc return str; str 98 chrome/test/chromedriver/logging.cc const std::string& str) { str 100 chrome/test/chromedriver/logging.cc std::string message = str.substr(message_start); str 453 chrome/test/data/dromaeo/JSON.php function reduce_string($str) str 455 chrome/test/data/dromaeo/JSON.php $str = preg_replace(array( str 466 chrome/test/data/dromaeo/JSON.php ), '', $str); str 469 chrome/test/data/dromaeo/JSON.php return trim($str); str 484 chrome/test/data/dromaeo/JSON.php function decode($str) str 486 chrome/test/data/dromaeo/JSON.php $str = $this->reduce_string($str); str 488 chrome/test/data/dromaeo/JSON.php switch (strtolower($str)) { str 501 chrome/test/data/dromaeo/JSON.php if (is_numeric($str)) { str 509 chrome/test/data/dromaeo/JSON.php return ((float)$str == (integer)$str) str 510 chrome/test/data/dromaeo/JSON.php ? (integer)$str str 511 chrome/test/data/dromaeo/JSON.php : (float)$str; str 513 chrome/test/data/dromaeo/JSON.php } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) { str 515 chrome/test/data/dromaeo/JSON.php $delim = substr($str, 0, 1); str 516 chrome/test/data/dromaeo/JSON.php $chrs = substr($str, 1, -1); str 610 chrome/test/data/dromaeo/JSON.php } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) { str 613 chrome/test/data/dromaeo/JSON.php if ($str{0} == '[') { str 630 chrome/test/data/dromaeo/JSON.php $chrs = substr($str, 1, -1); str 25 chrome/test/data/nacl/manifest_file/irt_manifest_file_test.cc std::string str; str 34 chrome/test/data/nacl/manifest_file/irt_manifest_file_test.cc str = "irt manifest api not found"; str 41 chrome/test/data/nacl/manifest_file/irt_manifest_file_test.cc str = "Can't open file"; str 46 chrome/test/data/nacl/manifest_file/irt_manifest_file_test.cc str = "File Contents:\n"; str 81 chrome/test/data/nacl/manifest_file/irt_manifest_file_test.cc str += buffer; str 83 chrome/test/data/nacl/manifest_file/irt_manifest_file_test.cc printf("file loaded: %s\n", str.c_str()); str 98 chrome/test/data/nacl/manifest_file/irt_manifest_file_test.cc pp::Var reply = pp::Var(str); str 212 chrome/test/logging/win/log_file_printer.cc PrintEventContext(event, level_stream.str(), base::StringPiece()); str 227 chrome/test/logging/win/log_file_printer.cc PrintEventContext(event, level_stream.str(), location_stream.str()); str 27 chrome/test/security_tests/ipc_security_tests.cc ::OutputDebugStringA(oss.str().c_str()); str 22 chrome/tools/convert_dict/aff_reader.cc bool StringBeginsWith(const std::string& str, const char* with) { str 24 chrome/tools/convert_dict/aff_reader.cc while (cur < str.size() && with[cur] != 0) { str 25 chrome/tools/convert_dict/aff_reader.cc if (str[cur] != with[cur]) str 33 chrome/tools/convert_dict/aff_reader.cc void CollapseDuplicateSpaces(std::string* str) { str 35 chrome/tools/convert_dict/aff_reader.cc for (size_t i = 0; i < str->length(); i++) { str 36 chrome/tools/convert_dict/aff_reader.cc if ((*str)[i] == ' ') { str 38 chrome/tools/convert_dict/aff_reader.cc str->erase(str->begin() + i); str 34 chrome/tools/convert_dict/hunspell_reader.cc std::string str = line; str 35 chrome/tools/convert_dict/hunspell_reader.cc TrimLine(&str); str 36 chrome/tools/convert_dict/hunspell_reader.cc return str; str 21 chromeos/dbus/power_policy_controller.cc #define APPEND_DELAY(str, delays, field, name) \ str 24 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf(name "=%" PRId64 " ", delays.field()); \ str 31 chromeos/dbus/power_policy_controller.cc #define APPEND_DELAYS(str, delays, prefix) \ str 33 chromeos/dbus/power_policy_controller.cc APPEND_DELAY(str, delays, screen_dim_ms, prefix "_screen_dim_ms"); \ str 34 chromeos/dbus/power_policy_controller.cc APPEND_DELAY(str, delays, screen_off_ms, prefix "_screen_off_ms"); \ str 35 chromeos/dbus/power_policy_controller.cc APPEND_DELAY(str, delays, screen_lock_ms, prefix "_screen_lock_ms"); \ str 36 chromeos/dbus/power_policy_controller.cc APPEND_DELAY(str, delays, idle_warning_ms, prefix "_idle_warning_ms"); \ str 37 chromeos/dbus/power_policy_controller.cc APPEND_DELAY(str, delays, idle_ms, prefix "_idle_ms"); \ str 95 chromeos/dbus/power_policy_controller.cc std::string str; str 97 chromeos/dbus/power_policy_controller.cc APPEND_DELAYS(str, policy.ac_delays(), "ac"); str 99 chromeos/dbus/power_policy_controller.cc APPEND_DELAYS(str, policy.battery_delays(), "battery"); str 101 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("ac_idle=%d ", policy.ac_idle_action()); str 103 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("battery_idle=%d ", policy.battery_idle_action()); str 105 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("lid_closed=%d ", policy.lid_closed_action()); str 107 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("use_audio=%d ", policy.use_audio_activity()); str 109 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("use_video=%d ", policy.use_audio_activity()); str 111 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("ac_brightness_percent=%f ", str 115 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("battery_brightness_percent=%f ", str 119 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("presentation_screen_dim_delay_factor=%f ", str 123 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("user_activity_screen_dim_delay_factor=%f ", str 127 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("wait_for_initial_user_activity=%d ", str 131 chromeos/dbus/power_policy_controller.cc str += base::StringPrintf("reason=\"%s\" ", policy.reason().c_str()); str 132 chromeos/dbus/power_policy_controller.cc base::TrimWhitespace(str, base::TRIM_TRAILING, &str); str 133 chromeos/dbus/power_policy_controller.cc return str; str 203 chromeos/dbus/shill_client_unittest_base.cc std::string str; str 204 chromeos/dbus/shill_client_unittest_base.cc ASSERT_TRUE(reader->PopString(&str)); str 205 chromeos/dbus/shill_client_unittest_base.cc EXPECT_EQ(expected_string, str); str 234 chromeos/dbus/shill_client_unittest_base.cc std::string str; str 235 chromeos/dbus/shill_client_unittest_base.cc ASSERT_TRUE(reader->PopString(&str)); str 236 chromeos/dbus/shill_client_unittest_base.cc EXPECT_EQ(expected_string, str); str 129 chromeos/dbus/shill_ipconfig_client.cc std::string str; str 130 chromeos/dbus/shill_ipconfig_client.cc (*it)->GetAsString(&str); str 131 chromeos/dbus/shill_ipconfig_client.cc array_writer.AppendString(str); str 40 chromeos/dbus/update_engine_client.cc const std::string& str) { str 41 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusIdle) str 43 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusCheckingForUpdate) str 45 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusUpdateAvailable) str 47 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusDownloading) str 49 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusVerifying) str 51 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusFinalizing) str 53 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusUpdatedNeedReboot) str 55 chromeos/dbus/update_engine_client.cc if (str == update_engine::kUpdateStatusReportingErrorEvent) str 46 chromeos/network/managed_network_configuration_handler_unittest.cc std::stringstream str; str 47 chromeos/network/managed_network_configuration_handler_unittest.cc str << *value; str 48 chromeos/network/managed_network_configuration_handler_unittest.cc return str.str(); str 27 chromeos/network/network_profile_handler.cc std::string str; str 28 chromeos/network/network_profile_handler.cc if (!string_list.GetString(i, &str)) str 30 chromeos/network/network_profile_handler.cc result->push_back(str); str 22 chromeos/network/network_state.cc std::string str; str 23 chromeos/network/network_state.cc if (!string_list.GetString(i, &str)) str 25 chromeos/network/network_state.cc result->push_back(str); str 56 chromeos/network/network_ui_data.cc const std::string& str, str 59 chromeos/network/network_ui_data.cc if (table[i].string == str) str 31 chromeos/network/onc/onc_translator_onc_to_shill.cc std::string str; str 32 chromeos/network/onc/onc_translator_onc_to_shill.cc if (!value.GetAsString(&str)) str 33 chromeos/network/onc/onc_translator_onc_to_shill.cc base::JSONWriter::Write(&value, &str); str 34 chromeos/network/onc/onc_translator_onc_to_shill.cc return make_scoped_ptr(base::Value::CreateStringValue(str)); str 28 chromeos/network/onc/onc_translator_shill_to_onc.cc scoped_ptr<base::Value> ConvertStringToValue(const std::string& str, str 32 chromeos/network/onc/onc_translator_shill_to_onc.cc value = base::Value::CreateStringValue(str); str 34 chromeos/network/onc/onc_translator_shill_to_onc.cc value = base::JSONReader::Read(str); str 197 chromeos/network/onc/onc_validator.cc std::string str = base::IntToString(index); str 198 chromeos/network/onc/onc_validator.cc path_.push_back(str); str 201 chromeos/network/onc/onc_validator.cc DCHECK_EQ(str, path_.back()); str 355 chromeos/network/onc/onc_validator.cc std::string str; str 357 chromeos/network/onc/onc_validator.cc if (value->GetAsString(&str)) { str 358 chromeos/network/onc/onc_validator.cc if (!str.empty()) str 27 chromeos/network/shill_property_util.cc std::string ValidateUTF8(const std::string& str) { str 29 chromeos/network/shill_property_util.cc for (int32 index = 0; index < static_cast<int32>(str.size()); ++index) { str 32 chromeos/network/shill_property_util.cc str.c_str(), str.size(), &index, &code_point_out); str 429 chromeos/network/shill_property_util.cc std::string str; str 433 chromeos/network/shill_property_util.cc if (!str.empty()) str 434 chromeos/network/shill_property_util.cc str += "|"; str 435 chromeos/network/shill_property_util.cc str += shill_type_to_flag[i].shill_network_type; str 437 chromeos/network/shill_property_util.cc return str; str 23 chromeos/process_proxy/process_output_watcher_unittest.cc std::string str; str 28 chromeos/process_proxy/process_output_watcher_unittest.cc : str(expected_string), str 41 chromeos/process_proxy/process_output_watcher_unittest.cc out_expectations_.append(expectations[i].str); str 114 chromeos/process_proxy/process_output_watcher_unittest.cc const std::string& test_str = test_cases[i].str; str 112 cloud_print/gcp20/prototype/dns_response_builder.cc for (std::vector<std::string>::const_iterator str = metadata.begin(); str 113 cloud_print/gcp20/prototype/dns_response_builder.cc str != metadata.end(); ++str) { str 114 cloud_print/gcp20/prototype/dns_response_builder.cc int len = static_cast<int>(str->size()); str 117 cloud_print/gcp20/prototype/dns_response_builder.cc rdata += *str; str 36 components/autofill/content/browser/wallet/required_action.cc RequiredAction ParseRequiredActionFromString(const std::string& str) { str 38 components/autofill/content/browser/wallet/required_action.cc base::TrimWhitespaceASCII(StringToLowerASCII(str), base::TRIM_ALL, str 62 components/autofill/content/browser/wallet/required_action.cc DLOG(ERROR) << "Failed to parse: \"" << str << "\" as a required action"; str 39 components/autofill/content/browser/wallet/required_action.h RequiredAction ParseRequiredActionFromString(const std::string& str); str 874 components/autofill/core/browser/autofill_country.cc const base::string16& str, str 1021 components/autofill/core/browser/autofill_country.cc const base::string16& str, str 1027 components/autofill/core/browser/autofill_country.cc icu::UnicodeString icu_str(str.c_str(), str.length()); str 139 components/autofill/core/browser/autofill_field.cc const base::string16& str) { str 142 components/autofill/core/browser/autofill_field.cc if (!StringToInt(year, &year_int) || !StringToInt(str, &str_int)) str 302 components/autofill/core/browser/autofill_field.cc std::string Hash32Bit(const std::string& str) { str 303 components/autofill/core/browser/autofill_field.cc std::string hash_bin = base::SHA1HashString(str); str 151 components/autofill/core/browser/autofill_merge_unittest.cc ServerFieldType StringToFieldType(const std::string& str); str 244 components/autofill/core/browser/autofill_merge_unittest.cc ServerFieldType AutofillMergeTest::StringToFieldType(const std::string& str) { str 245 components/autofill/core/browser/autofill_merge_unittest.cc return string_to_field_type_map_[str]; str 934 components/autofill/core/browser/form_structure.cc std::string FormStructure::Hash64Bit(const std::string& str) { str 935 components/autofill/core/browser/form_structure.cc std::string hash_bin = base::SHA1HashString(str); str 198 components/autofill/core/browser/form_structure.h static std::string Hash64Bit(const std::string& str); str 59 components/autofill/core/browser/form_structure_unittest.cc static std::string Hash64Bit(const std::string& str) { str 60 components/autofill/core/browser/form_structure_unittest.cc return FormStructure::Hash64Bit(str); str 20 components/autofill/core/common/autofill_data_validation.cc bool IsValidString(const std::string& str) { str 21 components/autofill/core/common/autofill_data_validation.cc return str.size() <= kMaxDataLength; str 24 components/autofill/core/common/autofill_data_validation.cc bool IsValidString16(const base::string16& str) { str 25 components/autofill/core/common/autofill_data_validation.cc return str.size() <= kMaxDataLength; str 34 components/autofill/core/common/autofill_data_validation.h bool IsValidString(const std::string& str); str 35 components/autofill/core/common/autofill_data_validation.h bool IsValidString16(const base::string16& str); str 192 components/breakpad/app/breakpad_linux.cc size_t LengthWithoutTrailingSpaces(const char* str, size_t len) { str 193 components/breakpad/app/breakpad_linux.cc while (len > 0 && str[len - 1] == ' ') { str 287 components/breakpad/app/breakpad_linux.cc void AddString(const char* str) { str 288 components/breakpad/app/breakpad_linux.cc AddItem(str, my_strlen(str)); str 165 components/breakpad/app/breakpad_win.cc std::wstring TrimToBreakpadMax(const std::wstring& str) { str 166 components/breakpad/app/breakpad_win.cc std::wstring shorter(str); str 101 components/dom_distiller/content/dom_distiller_viewer_source.cc unsafe_article_html = unsafe_output_stream.str(); str 80 components/dom_distiller/standalone/content_extractor.cc VLOG(0) << output.str(); str 77 components/nacl/browser/pnacl_host_unittest.cc char str[16]; str 78 components/nacl/browser/pnacl_host_unittest.cc memset(str, 0x0, 16); str 79 components/nacl/browser/pnacl_host_unittest.cc snprintf(str, 16, "testdata%d", ++write_callback_count_); str 80 components/nacl/browser/pnacl_host_unittest.cc EXPECT_EQ(16, base::WritePlatformFile(fd, 0, str, 16)); str 92 components/nacl/browser/pnacl_host_unittest.cc char str[16]; str 93 components/nacl/browser/pnacl_host_unittest.cc memset(str, 0x0, 16); str 94 components/nacl/browser/pnacl_host_unittest.cc snprintf(str, 16, "testdata%d", write_callback_count_); str 96 components/nacl/browser/pnacl_host_unittest.cc EXPECT_STREQ(str, data); str 596 components/password_manager/core/browser/login_database.cc base::string16 str; str 599 components/password_manager/core/browser/login_database.cc while (iterator.ReadString16(&str)) { str 600 components/password_manager/core/browser/login_database.cc ret.push_back(str); str 54 components/plugins/renderer/mobile_youtube_plugin.cc std::string str = StringToLowerASCII(path); str 56 components/plugins/renderer/mobile_youtube_plugin.cc if (strncmp(str.data(), kSlashVSlash, len) != 0 && str 57 components/plugins/renderer/mobile_youtube_plugin.cc strncmp(str.data(), kSlashESlash, len) != 0) str 62 components/plugins/renderer/mobile_youtube_plugin.cc char c = str[i]; str 93 components/policy/core/common/preg_parser_win.cc base::string16* str) { str 96 components/policy/core/common/preg_parser_win.cc *str += current; str 931 components/policy/core/common/schema.cc bool Schema::ValidateStringRestriction(int index, const char* str) const { str 935 components/policy/core/common/schema.cc if (strcmp(*storage_->string_enums(i), str) == 0) str 171 components/policy/core/common/schema.h bool ValidateStringRestriction(int index, const char* str) const; str 25 components/rappor/bloom_filter.cc void BloomFilter::AddString(const std::string& str) { str 30 components/rappor/bloom_filter.cc CityHash64WithSeed(str.data(), str.size(), hash_seed_offset_ + i); str 29 components/rappor/bloom_filter.h void AddString(const std::string& str); str 24 components/rappor/rappor_metric.cc void RapporMetric::AddSample(const std::string& str) { str 25 components/rappor/rappor_metric.cc bloom_filter_.AddString(str); str 38 components/rappor/rappor_metric.h void AddSample(const std::string& str); str 175 components/sessions/serialized_navigation_entry.cc const std::string& str) { str 176 components/sessions/serialized_navigation_entry.cc int num_bytes = str.size() * sizeof(char); str 179 components/sessions/serialized_navigation_entry.cc pickle->WriteString(str); str 191 components/sessions/serialized_navigation_entry.cc const base::string16& str) { str 192 components/sessions/serialized_navigation_entry.cc int num_bytes = str.size() * sizeof(base::char16); str 195 components/sessions/serialized_navigation_entry.cc pickle->WriteString16(str); str 61 components/signin/core/browser/signin_internals_util.cc std::string GetTruncatedHash(const std::string& str) { str 62 components/signin/core/browser/signin_internals_util.cc if (str.empty()) str 63 components/signin/core/browser/signin_internals_util.cc return str; str 70 components/signin/core/browser/signin_internals_util.cc crypto::SHA256HashString(str, &hash_val[0], kTruncateSize); str 86 components/signin/core/browser/signin_internals_util.h std::string GetTruncatedHash(const std::string& str); str 135 components/translate/core/browser/translate_script.cc base::StringPiece str = ResourceBundle::GetSharedInstance(). str 137 components/translate/core/browser/translate_script.cc str.AppendToString(&data_); str 284 components/url_matcher/url_matcher.cc const std::string& str) { str 285 components/url_matcher/url_matcher.cc return CreateCondition(URLMatcherCondition::HOST_CONTAINS, str); str 289 components/url_matcher/url_matcher.cc const std::string& str) { str 291 components/url_matcher/url_matcher.cc kBeginningOfURL + CanonicalizeHostname(str) + kEndOfDomain); str 306 components/url_matcher/url_matcher.cc const std::string& str) { str 307 components/url_matcher/url_matcher.cc return CreateCondition(URLMatcherCondition::PATH_CONTAINS, str); str 311 components/url_matcher/url_matcher.cc const std::string& str) { str 313 components/url_matcher/url_matcher.cc kEndOfDomain + str + kEndOfPath); str 338 components/url_matcher/url_matcher.cc const std::string& str) { str 339 components/url_matcher/url_matcher.cc if (!str.empty() && str[0] == '?') str 340 components/url_matcher/url_matcher.cc return CreateQueryPrefixCondition(str); str 342 components/url_matcher/url_matcher.cc return CreateCondition(URLMatcherCondition::QUERY_CONTAINS, str); str 346 components/url_matcher/url_matcher.cc const std::string& str) { str 348 components/url_matcher/url_matcher.cc if (!str.empty() && str[0] == '?') str 349 components/url_matcher/url_matcher.cc pattern = kEndOfPath + str + kEndOfURL; str 351 components/url_matcher/url_matcher.cc pattern = kEndOfPath + ('?' + str) + kEndOfURL; str 434 components/url_matcher/url_matcher.cc const std::string& str) { str 435 components/url_matcher/url_matcher.cc return CreateCondition(URLMatcherCondition::URL_CONTAINS, str); str 439 components/url_matcher/url_matcher.cc const std::string& str) { str 441 components/url_matcher/url_matcher.cc kBeginningOfURL + str + kEndOfURL); str 136 components/url_matcher/url_matcher.h URLMatcherCondition CreateHostContainsCondition(const std::string& str); str 137 components/url_matcher/url_matcher.h URLMatcherCondition CreateHostEqualsCondition(const std::string& str); str 141 components/url_matcher/url_matcher.h URLMatcherCondition CreatePathContainsCondition(const std::string& str); str 142 components/url_matcher/url_matcher.h URLMatcherCondition CreatePathEqualsCondition(const std::string& str); str 146 components/url_matcher/url_matcher.h URLMatcherCondition CreateQueryContainsCondition(const std::string& str); str 147 components/url_matcher/url_matcher.h URLMatcherCondition CreateQueryEqualsCondition(const std::string& str); str 170 components/url_matcher/url_matcher.h URLMatcherCondition CreateURLContainsCondition(const std::string& str); str 171 components/url_matcher/url_matcher.h URLMatcherCondition CreateURLEqualsCondition(const std::string& str); str 175 components/url_matcher/url_matcher_factory.cc bool ContainsUpperCase(const std::string& str) { str 176 components/url_matcher/url_matcher_factory.cc return std::find_if(str.begin(), str.end(), ::isupper) != str.end(); str 696 content/browser/accessibility/browser_accessibility_win.cc base::string16 str; str 699 content/browser/accessibility/browser_accessibility_win.cc str += L';'; str 700 content/browser/accessibility/browser_accessibility_win.cc str += ia2_attributes_[i]; str 703 content/browser/accessibility/browser_accessibility_win.cc if (str.empty()) str 706 content/browser/accessibility/browser_accessibility_win.cc *attributes = SysAllocString(str.c_str()); str 3206 content/browser/accessibility/browser_accessibility_win.cc base::string16 str; str 3208 content/browser/accessibility/browser_accessibility_win.cc if (!GetString16Attribute(attribute, &str)) str 3211 content/browser/accessibility/browser_accessibility_win.cc if (str.empty()) str 3214 content/browser/accessibility/browser_accessibility_win.cc *value_bstr = SysAllocString(str.c_str()); str 188 content/browser/appcache/view_appcache_internals_job.cc std::string str; str 190 content/browser/appcache/view_appcache_internals_job.cc str.append("Manifest, "); str 192 content/browser/appcache/view_appcache_internals_job.cc str.append("Master, "); str 194 content/browser/appcache/view_appcache_internals_job.cc str.append("Intercept, "); str 196 content/browser/appcache/view_appcache_internals_job.cc str.append("Fallback, "); str 198 content/browser/appcache/view_appcache_internals_job.cc str.append("Explicit, "); str 200 content/browser/appcache/view_appcache_internals_job.cc str.append("Foreign, "); str 201 content/browser/appcache/view_appcache_internals_job.cc return str; str 51 content/browser/gamepad/gamepad_platform_data_fetcher_linux.cc base::StringPiece str(&node_path[base_len], strlen(node_path) - base_len); str 52 content/browser/gamepad/gamepad_platform_data_fetcher_linux.cc if (!base::StringToInt(str, &tmp_idx)) str 300 content/browser/gpu/gpu_data_manager_impl_private.cc switches::kDefaultTileWidth, size.str()); str 302 content/browser/gpu/gpu_data_manager_impl_private.cc switches::kDefaultTileHeight, size.str()); str 28 content/browser/media/webrtc_internals_browsertest.cc return ss.str(); str 41 content/browser/media/webrtc_internals_browsertest.cc return ss.str(); str 62 content/browser/media/webrtc_internals_browsertest.cc return ss.str(); str 89 content/browser/media/webrtc_internals_browsertest.cc return ss.str(); str 95 content/browser/media/webrtc_internals_browsertest.cc return ss.str(); str 106 content/browser/media/webrtc_internals_browsertest.cc return ss.str(); str 178 content/browser/media/webrtc_internals_browsertest.cc ASSERT_TRUE(ExecuteJavascript("addPeerConnection(" + ss.str() + ");")); str 186 content/browser/media/webrtc_internals_browsertest.cc ASSERT_TRUE(ExecuteJavascript("removePeerConnection(" + ss.str() + ");")); str 196 content/browser/media/webrtc_internals_browsertest.cc ASSERT_TRUE(ExecuteJavascript("addGetUserMedia(" + ss.str() + ");")); str 204 content/browser/media/webrtc_internals_browsertest.cc ExecuteJavascript("removeGetUserMediaForRenderer(" + ss.str() + ");")); str 278 content/browser/media/webrtc_internals_browsertest.cc shell()->web_contents(), ss.str(), &result)); str 291 content/browser/media/webrtc_internals_browsertest.cc ASSERT_TRUE(ExecuteJavascript("updatePeerConnection(" + ss.str() + ")")); str 312 content/browser/media/webrtc_internals_browsertest.cc ASSERT_TRUE(ExecuteJavascript("addStats(" + ss.str() + ")")); str 389 content/browser/media/webrtc_internals_browsertest.cc shell()->web_contents(), ss.str(), &actual_value)); str 200 content/browser/renderer_host/gtk_key_bindings_handler.cc const gchar* str) { str 201 content/browser/renderer_host/gtk_key_bindings_handler.cc if (str && *str) str 202 content/browser/renderer_host/gtk_key_bindings_handler.cc GetHandlerOwner(text_view)->EditCommandMatched("InsertText", str); str 93 content/browser/renderer_host/gtk_key_bindings_handler.h static void InsertAtCursor(GtkTextView* text_view, const gchar* str); str 216 content/browser/renderer_host/java/java_bound_object.cc std::string str = str 218 content/browser/renderer_host/java/java_bound_object.cc size_t length = str.length(); str 222 content/browser/renderer_host/java/java_bound_object.cc str.copy(buffer, length, 0); str 53 content/browser/renderer_host/media/audio_input_sync_writer.cc if (!oss.str().empty()) str 54 content/browser/renderer_host/media/audio_input_sync_writer.cc MediaStreamManager::SendMessageToNativeLog(oss.str()); str 804 content/browser/renderer_host/media/media_stream_manager.cc AddLogMessageOnIOThread(oss.str()); str 1207 content/browser/renderer_host/render_message_filter.cc const base::string16& str) { str 1224 content/browser/renderer_host/render_message_filter.cc ExtTextOut(hdc, 0, 0, ETO_GLYPH_INDEX, 0, str.c_str(), str.length(), NULL); str 112 content/browser/tracing/tracing_ui.cc std::string str = base::DoubleToString(result); str 113 content/browser/tracing/tracing_ui.cc callback.Run(base::RefCountedString::TakeString(&str)); str 127 content/child/plugin_param_traits.cc NPUTF8* str = blink::WebBindings::utf8FromIdentifier(p.identifier); str 128 content/child/plugin_param_traits.cc l->append(str); str 129 content/child/plugin_param_traits.cc free(str); str 1403 content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.cc blink::WebString str = blink::WebString::fromUTF8(message.c_str()); str 1404 content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.cc error_message_callback_->onErrorMessage(str, id); str 85 content/common/mac/attributed_string_coder.h static const EncodedString* Encode(NSAttributedString* str); str 88 content/common/mac/attributed_string_coder.h static NSAttributedString* Decode(const EncodedString* str); str 317 content/common/page_state_serialization.cc void WriteString(const base::NullableString16& str, SerializeObject* obj) { str 318 content/common/page_state_serialization.cc if (str.is_null()) { str 321 content/common/page_state_serialization.cc const base::char16* data = str.string().data(); str 322 content/common/page_state_serialization.cc size_t length_in_bytes = str.string().length() * sizeof(base::char16); str 31 content/gpu/gpu_child_thread.cc const std::string& str) { str 32 content/gpu/gpu_child_thread.cc std::string header = str.substr(0, message_start); str 33 content/gpu/gpu_child_thread.cc std::string message = str.substr(message_start); str 73 content/gpu/gpu_main.cc const std::string& str) { str 74 content/gpu/gpu_main.cc std::string header = str.substr(0, message_start); str 75 content/gpu/gpu_main.cc std::string message = str.substr(message_start); str 221 content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java void logAndToastError(String str) { str 222 content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java Log.e(TAG, str); str 223 content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java if (mShowToasts) Toast.makeText(mContext, str, Toast.LENGTH_SHORT).show(); str 226 content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java void logAndToastInfo(String str) { str 227 content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java Log.i(TAG, str); str 228 content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java if (mShowToasts) Toast.makeText(mContext, str, Toast.LENGTH_SHORT).show(); str 202 content/public/android/javatests/src/org/chromium/content/browser/JavaBridgeCoercionTest.java String str = mTestObject.waitForStringValue(); str 203 content/public/android/javatests/src/org/chromium/content/browser/JavaBridgeCoercionTest.java assertTrue("42".equals(str) || "42.0".equals(str)); str 98 content/public/browser/desktop_media_id.cc DesktopMediaID DesktopMediaID::Parse(const std::string& str) { str 100 content/public/browser/desktop_media_id.cc base::SplitString(str, ':', &parts); str 43 content/public/browser/desktop_media_id.h static DesktopMediaID Parse(const std::string& str); str 132 content/renderer/browser_plugin/browser_plugin_browsertest.cc scoped_ptr<char[]> str(new char[length]); str 133 content/renderer/browser_plugin/browser_plugin_browsertest.cc v8_str->WriteUtf8(str.get(), length); str 134 content/renderer/browser_plugin/browser_plugin_browsertest.cc return str.get(); str 108 content/renderer/dom_automation_controller.cc const std::string& str) { str 112 content/renderer/dom_automation_controller.cc new FrameHostMsg_DomOperationResponse(routing_id(), str, automation_id)); str 104 content/renderer/dom_automation_controller.h bool SendWithId(int automation_id, const std::string& str); str 1091 content/renderer/media/buffered_resource_loader_unittest.cc const std::string& str, bool expect_success, str 1095 content/renderer/media/buffered_resource_loader_unittest.cc str, &first, &last, &size)) << str; str 1103 content/renderer/media/buffered_resource_loader_unittest.cc static void ExpectContentRangeFailure(const std::string& str) { str 1104 content/renderer/media/buffered_resource_loader_unittest.cc ExpectContentRange(str, false, 0, 0, 0); str 1108 content/renderer/media/buffered_resource_loader_unittest.cc const std::string& str, str 1110 content/renderer/media/buffered_resource_loader_unittest.cc ExpectContentRange(str, true, expected_first, expected_last, expected_size); str 75 content/renderer/pepper/content_decryptor_delegate.cc bool CopyStringToArray(const std::string& str, uint8 (&array)[array_size]) { str 76 content/renderer/pepper/content_decryptor_delegate.cc if (array_size < str.size()) str 79 content/renderer/pepper/content_decryptor_delegate.cc memcpy(array, str.data(), str.size()); str 73 content/renderer/pepper/pepper_in_process_resource_creation.cc std::string str = string_var.get() ? string_var->value() : std::string(); str 78 content/renderer/pepper/pepper_in_process_resource_creation.cc str.c_str()))->GetReference(); str 1113 content/renderer/render_thread_impl.cc const base::string16& str) { str 1114 content/renderer/render_thread_impl.cc Send(new ViewHostMsg_PreCacheFontCharacters(log_font, str)); str 309 content/renderer/render_thread_impl.h const base::string16& str); str 291 content/shell/browser/shell_gtk.cc const gchar* str = gtk_entry_get_text(GTK_ENTRY(entry)); str 292 content/shell/browser/shell_gtk.cc GURL url(str); str 294 content/shell/browser/shell_gtk.cc url = GURL(std::string("http://") + std::string(str)); str 14 content/shell/renderer/test_runner/TestCommon.h #define snprintf(str, size, ...) _snprintf_s(str, size, size, __VA_ARGS__) str 1109 content/shell/renderer/test_runner/test_runner.cc std::string str; str 1110 content/shell/renderer/test_runner/test_runner.cc args->GetNext(&str); str 1111 content/shell/renderer/test_runner/test_runner.cc runner_->ShowWebInspector(str); str 2473 content/shell/renderer/test_runner/test_runner.cc void TestRunner::ShowWebInspector(const std::string& str) { str 2474 content/shell/renderer/test_runner/test_runner.cc showDevTools(str); str 452 content/shell/renderer/test_runner/test_runner.h void ShowWebInspector(const std::string& str); str 674 courgette/disassembler_win32_x64.cc return s.str(); str 674 courgette/disassembler_win32_x86.cc return s.str(); str 99 crypto/openssl_util.cc int OpenSSLErrorCallback(const char* str, size_t len, void* context) { str 100 crypto/openssl_util.cc DVLOG(1) << "\t" << base::StringPiece(str, len); str 13 crypto/sha2.cc void SHA256HashString(const base::StringPiece& str, void* output, size_t len) { str 15 crypto/sha2.cc ctx->Update(str.data(), str.length()); str 19 crypto/sha2.cc std::string SHA256HashString(const base::StringPiece& str) { str 21 crypto/sha2.cc SHA256HashString(str, string_as_array(&output), output.size()); str 24 crypto/sha2.h CRYPTO_EXPORT void SHA256HashString(const base::StringPiece& str, str 29 crypto/sha2.h CRYPTO_EXPORT std::string SHA256HashString(const base::StringPiece& str); str 25 extensions/browser/extension_pref_value_map_unittest.cc static base::Value* CreateVal(const char* str) { str 26 extensions/browser/extension_pref_value_map_unittest.cc return new base::StringValue(str); str 24 extensions/browser/file_highlighter.cc void QuoteIncrement(const std::string& str, size_t* index) { str 27 extensions/browser/file_highlighter.cc while (!found && i < str.size()) { str 28 extensions/browser/file_highlighter.cc if (str[i] == '\\') str 30 extensions/browser/file_highlighter.cc else if (str[i] == '"') str 40 extensions/browser/file_highlighter.cc void CommentSafeIncrement(const std::string& str, size_t* index) { str 42 extensions/browser/file_highlighter.cc if (str[i] == '/' && i + 1 < str.size()) { str 44 extensions/browser/file_highlighter.cc if (str[i + 1] == '/') { str 46 extensions/browser/file_highlighter.cc while (i < str.size() && str[i] != '\n' && str[i] != '\r') str 48 extensions/browser/file_highlighter.cc } else if (str[i + 1] == '*') { // Eat a multi-line comment. str 50 extensions/browser/file_highlighter.cc while (i < str.size() && !(str[i - 1] == '*' && str[i] == '/')) str 60 extensions/browser/file_highlighter.cc void ChunkIncrement(const std::string& str, size_t* index, size_t end) { str 61 extensions/browser/file_highlighter.cc char c = str[*index]; str 65 extensions/browser/file_highlighter.cc QuoteIncrement(str, index); str 72 extensions/browser/file_highlighter.cc CommentSafeIncrement(str, index); str 73 extensions/browser/file_highlighter.cc c = str[*index]; str 29 extensions/common/extension_resource_unittest.cc base::FilePath::StringType str(in_str); str 30 extensions/common/extension_resource_unittest.cc std::transform(str.begin(), str.end(), str.begin(), tolower); str 31 extensions/common/extension_resource_unittest.cc return str; str 30 extensions/common/permissions/socket_permission_entry.cc bool StartsOrEndsWithWhitespace(const std::string& str) { str 31 extensions/common/permissions/socket_permission_entry.cc if (str.find_first_not_of(base::kWhitespaceASCII) != 0) str 33 extensions/common/permissions/socket_permission_entry.cc if (str.find_last_not_of(base::kWhitespaceASCII) != str.length() - 1) str 121 gin/converter.cc Handle<String> str = Handle<String>::Cast(val); str 122 gin/converter.cc int length = str->Utf8Length(); str 124 gin/converter.cc str->WriteUtf8(&(*out)[0], length, NULL, String::NO_NULL_TERMINATION); str 35 gin/try_catch.cc return ss.str(); str 46 gin/try_catch.cc return ss.str(); str 172 google_apis/gaia/oauth2_mint_token_flow_unittest.cc static base::DictionaryValue* ParseJson(const std::string& str) { str 173 google_apis/gaia/oauth2_mint_token_flow_unittest.cc scoped_ptr<base::Value> value(base::JSONReader::Read(str)); str 398 gpu/command_buffer/client/gles2_c_lib_autogen.h const GLchar* const* str, str 400 gpu/command_buffer/client/gles2_c_lib_autogen.h gles2::GetGLContext()->ShaderSource(shader, count, str, length); str 129 gpu/command_buffer/client/gles2_implementation.cc this_in_hex_ = ss.str(); str 603 gpu/command_buffer/client/gles2_implementation.cc uint32 bucket_id, const char* str) { str 606 gpu/command_buffer/client/gles2_implementation.cc if (str) { str 607 gpu/command_buffer/client/gles2_implementation.cc SetBucketContents(bucket_id, str, strlen(str) + 1); str 614 gpu/command_buffer/client/gles2_implementation.cc uint32 bucket_id, std::string* str) { str 615 gpu/command_buffer/client/gles2_implementation.cc DCHECK(str); str 625 gpu/command_buffer/client/gles2_implementation.cc str->assign(&data[0], &data[0] + data.size() - 1); str 630 gpu/command_buffer/client/gles2_implementation.cc uint32 bucket_id, const std::string& str) { str 633 gpu/command_buffer/client/gles2_implementation.cc SetBucketContents(bucket_id, str.c_str(), str.size() + 1); str 1324 gpu/command_buffer/client/gles2_implementation.cc std::string str(source[ii], length[ii]); str 1325 gpu/command_buffer/client/gles2_implementation.cc GPU_CLIENT_LOG(" " << ii << ": ---\n" << str << "\n---"); str 1969 gpu/command_buffer/client/gles2_implementation.cc std::vector<int8> str; str 1970 gpu/command_buffer/client/gles2_implementation.cc GetBucketContents(kResultBucketId, &str); str 1973 gpu/command_buffer/client/gles2_implementation.cc str.size() - 1)); str 1978 gpu/command_buffer/client/gles2_implementation.cc memcpy(name, &str[0], max_size); str 2040 gpu/command_buffer/client/gles2_implementation.cc std::vector<int8> str; str 2041 gpu/command_buffer/client/gles2_implementation.cc GetBucketContents(kResultBucketId, &str); str 2044 gpu/command_buffer/client/gles2_implementation.cc str.size() - 1)); str 2049 gpu/command_buffer/client/gles2_implementation.cc memcpy(name, &str[0], max_size); str 2176 gpu/command_buffer/client/gles2_implementation.cc std::string str; str 2177 gpu/command_buffer/client/gles2_implementation.cc if (GetBucketAsString(kResultBucketId, &str)) { str 2181 gpu/command_buffer/client/gles2_implementation.cc str += std::string(str.empty() ? "" : " ") + str 2186 gpu/command_buffer/client/gles2_implementation.cc str += " GL_CHROMIUM_map_image"; str 2205 gpu/command_buffer/client/gles2_implementation.cc std::set<std::string>::const_iterator sit = string_set.find(str); str 2210 gpu/command_buffer/client/gles2_implementation.cc string_set.insert(str); str 3022 gpu/command_buffer/client/gles2_implementation.cc std::string str; str 3023 gpu/command_buffer/client/gles2_implementation.cc if (GetBucketAsString(kResultBucketId, &str)) { str 3029 gpu/command_buffer/client/gles2_implementation.cc requestable_extensions_set_.find(str); str 3034 gpu/command_buffer/client/gles2_implementation.cc requestable_extensions_set_.insert(str); str 488 gpu/command_buffer/client/gles2_implementation.h void SetBucketAsCString(uint32 bucket_id, const char* str); str 492 gpu/command_buffer/client/gles2_implementation.h bool GetBucketAsString(uint32 bucket_id, std::string* str); str 495 gpu/command_buffer/client/gles2_implementation.h void SetBucketAsString(uint32 bucket_id, const std::string& str); str 323 gpu/command_buffer/client/gles2_implementation_autogen.h const GLchar* const* str, str 752 gpu/command_buffer/client/gles2_implementation_impl_autogen.h std::string str; str 754 gpu/command_buffer/client/gles2_implementation_impl_autogen.h if (GetBucketAsString(kResultBucketId, &str)) { str 756 gpu/command_buffer/client/gles2_implementation_impl_autogen.h max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size()); str 757 gpu/command_buffer/client/gles2_implementation_impl_autogen.h memcpy(infolog, str.c_str(), max_size); str 837 gpu/command_buffer/client/gles2_implementation_impl_autogen.h std::string str; str 839 gpu/command_buffer/client/gles2_implementation_impl_autogen.h if (GetBucketAsString(kResultBucketId, &str)) { str 841 gpu/command_buffer/client/gles2_implementation_impl_autogen.h max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size()); str 842 gpu/command_buffer/client/gles2_implementation_impl_autogen.h memcpy(infolog, str.c_str(), max_size); str 864 gpu/command_buffer/client/gles2_implementation_impl_autogen.h std::string str; str 866 gpu/command_buffer/client/gles2_implementation_impl_autogen.h if (GetBucketAsString(kResultBucketId, &str)) { str 868 gpu/command_buffer/client/gles2_implementation_impl_autogen.h max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size()); str 869 gpu/command_buffer/client/gles2_implementation_impl_autogen.h memcpy(source, str.c_str(), max_size); str 1940 gpu/command_buffer/client/gles2_implementation_impl_autogen.h std::string str; str 1942 gpu/command_buffer/client/gles2_implementation_impl_autogen.h if (GetBucketAsString(kResultBucketId, &str)) { str 1944 gpu/command_buffer/client/gles2_implementation_impl_autogen.h max_size = std::min(static_cast<size_t>(bufsize) - 1, str.size()); str 1945 gpu/command_buffer/client/gles2_implementation_impl_autogen.h memcpy(source, str.c_str(), max_size); str 80 gpu/command_buffer/client/gles2_implementation_unittest.cc char str[7]; str 959 gpu/command_buffer/client/gles2_implementation_unittest.cc EXPECT_STREQ(kString.str, buf); str 2101 gpu/command_buffer/client/gles2_implementation_unittest.cc EXPECT_STREQ(kString.str, buf); str 226 gpu/command_buffer/client/gles2_interface_autogen.h const GLchar* const* str, str 236 gpu/command_buffer/client/gles2_interface_stub_autogen.h const GLchar* const* str, str 236 gpu/command_buffer/client/gles2_trace_implementation_autogen.h const GLchar* const* str, str 656 gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h const GLchar* const* str, str 659 gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h gl_->ShaderSource(shader, count, str, length); str 703 gpu/command_buffer/common/gles2_cmd_utils.cc return "0x" + ss.str(); str 38 gpu/command_buffer/service/common_decoder.cc void CommonDecoder::Bucket::SetFromString(const char* str) { str 41 gpu/command_buffer/service/common_decoder.cc if (!str) { str 44 gpu/command_buffer/service/common_decoder.cc size_t size = strlen(str) + 1; str 46 gpu/command_buffer/service/common_decoder.cc SetData(str, 0, size); str 50 gpu/command_buffer/service/common_decoder.cc bool CommonDecoder::Bucket::GetAsString(std::string* str) { str 51 gpu/command_buffer/service/common_decoder.cc DCHECK(str); str 55 gpu/command_buffer/service/common_decoder.cc str->assign(GetDataAs<const char*>(0, size_ - 1), size_ - 1); str 78 gpu/command_buffer/service/common_decoder.h void SetFromString(const char* str); str 83 gpu/command_buffer/service/common_decoder.h bool GetAsString(std::string* str); str 41 gpu/command_buffer/service/feature_info.cc StringSet(const std::string& str) { str 42 gpu/command_buffer/service/feature_info.cc Init(str); str 46 gpu/command_buffer/service/feature_info.cc std::string str(s ? s : ""); str 47 gpu/command_buffer/service/feature_info.cc Init(str); str 50 gpu/command_buffer/service/feature_info.cc void Init(const std::string& str) { str 52 gpu/command_buffer/service/feature_info.cc Tokenize(str, " ", &tokens); str 781 gpu/command_buffer/service/feature_info.cc void FeatureInfo::AddExtensionString(const std::string& str) { str 782 gpu/command_buffer/service/feature_info.cc size_t pos = extensions_.find(str); str 784 gpu/command_buffer/service/feature_info.cc pos + str.length() < extensions_.length() && str 785 gpu/command_buffer/service/feature_info.cc extensions_.substr(pos + str.length(), 1) != " ") { str 787 gpu/command_buffer/service/feature_info.cc pos = extensions_.find(str, pos + str.length()); str 790 gpu/command_buffer/service/feature_info.cc extensions_ += (extensions_.empty() ? "" : " ") + str; str 123 gpu/command_buffer/service/feature_info.h void AddExtensionString(const std::string& str); str 273 gpu/command_buffer/service/gles2_cmd_decoder.cc static bool StringIsValidForGLES(const char* str) { str 274 gpu/command_buffer/service/gles2_cmd_decoder.cc for (; *str; ++str) { str 275 gpu/command_buffer/service/gles2_cmd_decoder.cc if (!CharacterIsValidForGLES(*str)) { str 6660 gpu/command_buffer/service/gles2_cmd_decoder.cc std::string str(data, data + data_size); str 6667 gpu/command_buffer/service/gles2_cmd_decoder.cc shader->UpdateSource(str.c_str()); str 7684 gpu/command_buffer/service/gles2_cmd_decoder.cc const char* str = reinterpret_cast<const char*>(glGetString(name)); str 7688 gpu/command_buffer/service/gles2_cmd_decoder.cc str = "OpenGL ES 2.0 Chromium"; str 7691 gpu/command_buffer/service/gles2_cmd_decoder.cc str = "OpenGL ES GLSL ES 1.0 Chromium"; str 7698 gpu/command_buffer/service/gles2_cmd_decoder.cc str = "Chromium"; str 7732 gpu/command_buffer/service/gles2_cmd_decoder.cc str = extensions.c_str(); str 7739 gpu/command_buffer/service/gles2_cmd_decoder.cc bucket->SetFromString(str); str 3002 gpu/command_buffer/service/gles2_cmd_decoder_autogen.h std::string str; str 3003 gpu/command_buffer/service/gles2_cmd_decoder_autogen.h if (!bucket->GetAsString(&str)) { str 3006 gpu/command_buffer/service/gles2_cmd_decoder_autogen.h DoInsertEventMarkerEXT(0, str.c_str()); str 3018 gpu/command_buffer/service/gles2_cmd_decoder_autogen.h std::string str; str 3019 gpu/command_buffer/service/gles2_cmd_decoder_autogen.h if (!bucket->GetAsString(&str)) { str 3022 gpu/command_buffer/service/gles2_cmd_decoder_autogen.h DoPushGroupMarkerEXT(0, str.c_str()); str 424 gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc uint32 bucket_id, const char* str) { str 425 gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc uint32 size = str ? (strlen(str) + 1) : 0; str 429 gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc if (str) { str 430 gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc memcpy(shared_memory_address_, str, size); str 148 gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h void SetBucketAsCString(uint32 bucket_id, const char* str); str 73 gpu/command_buffer/service/program_cache.cc const std::string& str, str 78 gpu/command_buffer/service/program_cache.cc std::string()) + str); str 236 gpu/command_buffer/service/program_manager.h void set_log_info(const char* str) { str 237 gpu/command_buffer/service/program_manager.h log_info_.reset(str ? new std::string(str) : NULL); str 232 gpu/command_buffer/service/renderbuffer_manager_unittest.cc bool InSet(std::set<std::string>* string_set, const std::string& str) { str 234 gpu/command_buffer/service/renderbuffer_manager_unittest.cc string_set->insert(str); str 1596 gpu/command_buffer/service/texture_manager_unittest.cc bool InSet(std::set<std::string>* string_set, const std::string& str) { str 1598 gpu/command_buffer/service/texture_manager_unittest.cc string_set->insert(str); str 35 gpu/config/gpu_util.cc void StringToIntSet(const std::string& str, std::set<int>* list) { str 38 gpu/config/gpu_util.cc base::SplitString(str, ',', &pieces); str 79 gpu/config/gpu_util.cc const std::string& str, std::set<int>* feature_set) { str 80 gpu/config/gpu_util.cc StringToIntSet(str, feature_set); str 38 gpu/config/gpu_util.h const std::string& str, std::set<int>* feature_set); str 189 ipc/ipc_fuzzing_tests.cc std::wstring output = wos.str(); str 145 ipc/sync_socket_unittest.cc void OnMsgClassResponse(const std::string& str) { str 151 ipc/sync_socket_unittest.cc EXPECT_EQ(strcmp(str.c_str(), buf), 0); str 56 jingle/glue/logging_unittest.cc const std::string& value = value_stream.str(); str 30 jingle/notifier/base/notification_method.cc NotificationMethod StringToNotificationMethod(const std::string& str) { str 31 jingle/notifier/base/notification_method.cc if (str == "p2p") { str 33 jingle/notifier/base/notification_method.cc } else if (str == "server") { str 36 jingle/notifier/base/notification_method.cc LOG(WARNING) << "Unknown notification method \"" << str str 27 jingle/notifier/base/notification_method.h NotificationMethod StringToNotificationMethod(const std::string& str); str 21 jingle/notifier/listener/xml_element_util.cc return xml_stream.str(); str 30 jingle/notifier/listener/xml_element_util_unittest.cc EXPECT_EQ(expected_xml_stream.str(), XmlElementToString(kXmlElement)); str 120 media/base/audio_decoder_config.cc return s.str(); str 87 media/base/decoder_buffer.cc return s.str(); str 110 media/base/media_log.cc log_cb_.Run(stream_.str()); str 30 media/base/ranges_unittest.cc ASSERT_EQ(ss.str(), expected_string); str 153 media/base/stream_parser_unittest.cc return results_stream.str(); str 129 media/base/video_decoder_config.cc return s.str(); str 79 media/cast/audio_sender/audio_encoder_unittest.cc return out.str(); str 166 media/cast/rtcp/rtcp_sender.cc return stream_.str(); str 44 media/cdm/ppapi/cdm_logging.h std::string message() { return stream_.str(); } str 480 media/cdm/ppapi/external_clear_key/clear_key_cdm.cc next_heartbeat_message_ = msg_stream.str(); str 134 media/filters/chunk_demuxer_unittest.cc static void LogFunc(const std::string& str) { DVLOG(1) << str; } str 232 media/filters/chunk_demuxer_unittest.cc const char str[] = "\xAE\x9E\xD7\x81\x03\x73\xC5\x81\x03" str 235 media/filters/chunk_demuxer_unittest.cc const int len = strlen(str); str 237 media/filters/chunk_demuxer_unittest.cc const uint8* const buf = reinterpret_cast<const uint8*>(str); str 805 media/filters/chunk_demuxer_unittest.cc EXPECT_EQ(expected, ss.str()); str 875 media/filters/chunk_demuxer_unittest.cc EXPECT_EQ(expected, ss.str()); str 180 media/filters/source_buffer_stream_unittest.cc EXPECT_EQ(expected, ss.str()); str 194 media/filters/source_buffer_stream_unittest.cc EXPECT_EQ(expected, ss.str()); str 292 media/filters/source_buffer_stream_unittest.cc EXPECT_EQ(expected, ss.str()); str 27 media/formats/common/stream_parser_test_base.cc return ss.str(); str 44 media/formats/common/stream_parser_test_base.cc return results_stream_.str(); str 80 media/formats/webm/webm_info_parser.cc bool WebMInfoParser::OnString(int id, const std::string& str) { str 37 media/formats/webm/webm_info_parser.h virtual bool OnString(int id, const std::string& str) OVERRIDE; str 609 media/formats/webm/webm_parser.cc std::string str(reinterpret_cast<const char*>(buf), length); str 610 media/formats/webm/webm_parser.cc return client->OnString(id, str) ? size : -1; str 676 media/formats/webm/webm_parser.cc bool WebMParserClient::OnString(int id, const std::string& str) { str 37 media/formats/webm/webm_parser.h virtual bool OnString(int id, const std::string& str); str 326 media/formats/webm/webm_tracks_parser.cc bool WebMTracksParser::OnString(int id, const std::string& str) { str 333 media/formats/webm/webm_tracks_parser.cc codec_id_ = str; str 338 media/formats/webm/webm_tracks_parser.cc track_name_ = str; str 343 media/formats/webm/webm_tracks_parser.cc track_language_ = str; str 83 media/formats/webm/webm_tracks_parser.h virtual bool OnString(int id, const std::string& str) OVERRIDE; str 17 mojo/common/common_type_converters_unittest.cc const base::StringPiece& str) { str 18 mojo/common/common_type_converters_unittest.cc EXPECT_EQ(expected, str.as_string()); str 22 mojo/common/common_type_converters_unittest.cc const String& str) { str 23 mojo/common/common_type_converters_unittest.cc EXPECT_EQ(expected, str.To<std::string>()); str 32 mojo/common/common_type_converters_unittest.cc const String& str) { str 33 mojo/common/common_type_converters_unittest.cc EXPECT_EQ(expected, str.To<base::string16>()); str 935 mojo/examples/pepper_container_app/ppb_opengles2_thunk.cc const char** str, str 939 mojo/examples/pepper_container_app/ppb_opengles2_thunk.cc glShaderSource(shader, count, str, length); str 348 mojo/public/c/gles2/gles2_call_visitor_autogen.h const GLchar* const* str, str 350 mojo/public/c/gles2/gles2_call_visitor_autogen.h (shader, count, str, length)) str 168 mojo/public/cpp/bindings/tests/sample_service_unittest.cc void Print(int depth, const char* name, const mojo::String& str) { str 169 mojo/public/cpp/bindings/tests/sample_service_unittest.cc std::string s = str.To<std::string>(); str 171 mojo/public/cpp/bindings/tests/sample_service_unittest.cc std::cout << name << ": \"" << str.To<std::string>() << "\"" << std::endl; str 202 mojo/public/cpp/bindings/tests/sample_service_unittest.cc Print(depth, buf.str().data(), array.at(i)); str 304 native_client_sdk/src/examples/api/file_io/file_io.cc PostMessage(ss.str()); str 328 native_client_sdk/src/examples/api/file_io/file_io.cc PostMessage(ss.str()); str 335 native_client_sdk/src/examples/api/file_io/file_io.cc PostMessage(ss.str()); str 78 native_client_sdk/src/examples/api/input_event/input_event.cc return stream.str(); str 95 native_client_sdk/src/examples/api/input_event/input_event.cc return stream.str(); str 123 native_client_sdk/src/examples/api/input_event/input_event.cc PostMessage(stream.str()); str 140 native_client_sdk/src/examples/api/input_event/input_event.cc PostMessage(stream.str()); str 169 native_client_sdk/src/examples/api/input_event/input_event.cc PostMessage(stream.str()); str 184 native_client_sdk/src/examples/api/input_event/input_event.cc PostMessage(stream.str()); str 199 native_client_sdk/src/examples/api/input_event/input_event.cc PostMessage(stream.str()); str 225 native_client_sdk/src/examples/api/input_event/input_event.cc PostMessage(stream.str()); str 234 native_client_sdk/src/examples/api/input_event/input_event.cc PostMessage(oss.str()); str 56 native_client_sdk/src/examples/api/network_monitor/network_monitor.cc PostMessage(status.str()); str 68 native_client_sdk/src/examples/api/network_monitor/network_monitor.cc PostMessage(status.str()); str 49 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 68 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 86 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 92 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 102 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 109 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 122 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 133 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 141 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 149 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 154 native_client_sdk/src/examples/api/socket/echo_server.cc instance_->PostMessage(status.str()); str 110 native_client_sdk/src/examples/api/socket/socket.cc PostMessage(status.str()); str 249 native_client_sdk/src/examples/api/socket/socket.cc PostMessage(status.str()); str 253 native_client_sdk/src/examples/api/socket/socket.cc PostMessage(status.str()); str 257 native_client_sdk/src/examples/api/socket/socket.cc PostMessage(status.str()); str 279 native_client_sdk/src/examples/api/socket/socket.cc PostMessage(status.str()); str 303 native_client_sdk/src/examples/api/socket/socket.cc PostMessage(status.str()); str 319 native_client_sdk/src/examples/api/socket/socket.cc PostMessage(status.str()); str 77 native_client_sdk/src/examples/demo/nacl_io/nacl_io_demo.c struct PP_Var CStrToVar(const char* str) { str 79 native_client_sdk/src/examples/demo/nacl_io/nacl_io_demo.c return ppb_var_interface->VarFromUtf8(str, strlen(str)); str 156 native_client_sdk/src/examples/demo/nacl_io/nacl_io_demo.c const char* str = ppb_var_interface->VarToUtf8(var, &var_length); str 159 native_client_sdk/src/examples/demo/nacl_io/nacl_io_demo.c memcpy(buffer, str, min_length); str 11 native_client_sdk/src/examples/demo/nacl_io/nacl_io_demo.h struct PP_Var CStrToVar(const char* str); str 40 native_client_sdk/src/examples/tutorial/debugging/debugging.c void PostMessage(const char* str); str 68 native_client_sdk/src/examples/tutorial/debugging/debugging.c void PostMessage(const char* str) { str 69 native_client_sdk/src/examples/tutorial/debugging/debugging.c if (NULL == str) str 76 native_client_sdk/src/examples/tutorial/debugging/debugging.c fprintf(stdout, "%s\n", str); str 80 native_client_sdk/src/examples/tutorial/debugging/debugging.c struct PP_Var var = ppb_var_interface->VarFromUtf8(str, strlen(str)); str 39 native_client_sdk/src/examples/tutorial/testing/testing.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 49 native_client_sdk/src/examples/tutorial/testing/testing.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 57 native_client_sdk/src/examples/tutorial/testing/testing.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 18 native_client_sdk/src/libraries/error_handling/error_handling.h typedef void (*EHJsonHandler)(const char* str); str 61 native_client_sdk/src/libraries/nacl_io/path.h Path& operator=(const std::string& str); str 87 native_client_sdk/src/libraries/nacl_io/syscalls/inet_ntop.cc memcpy(dst, output.str().c_str(), output.str().size() + 1); str 100 native_client_sdk/src/libraries/ppapi_simple/ps_instance.cc PostMessage(ss.str()); str 182 native_client_sdk/src/libraries/ppapi_simple/ps_instance.cc std::string arg_name = arg_stream.str(); str 19 native_client_sdk/src/libraries/sdk_util/string_util.h inline void SplitString(const std::string& str, str 24 native_client_sdk/src/libraries/sdk_util/string_util.h size_t size = str.size(); str 26 native_client_sdk/src/libraries/sdk_util/string_util.h if (i == size || str[i] == c) { str 27 native_client_sdk/src/libraries/sdk_util/string_util.h std::string tmp(str, last, i - last); str 190 native_client_sdk/src/libraries/xray/xray.c char* str = (char*) &capture->buffer[index]; str 193 native_client_sdk/src/libraries/xray/xray.c if (0 == str[i]) { str 407 native_client_sdk/src/libraries/xray/xray.c char* str = &capture->annotation[start]; str 408 native_client_sdk/src/libraries/xray/xray.c XRayTraceAppendString(capture, str); str 409 native_client_sdk/src/libraries/xray/xray.c *str = 0; str 32 native_client_sdk/src/libraries/xray/xray.h XRAY_NO_INSTRUMENT void __XRayAnnotate(const char* str, ...) str 35 native_client_sdk/src/libraries/xray/xray.h const char* str, ...) __attribute__ ((format(printf, 2, 3))); str 50 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 69 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 87 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 93 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 110 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 117 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 130 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 141 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 149 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 157 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 162 native_client_sdk/src/tests/nacl_io_socket_test/echo_server.cc Log(status.str().c_str()); str 33 native_client_sdk/src/tests/nacl_io_socket_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 43 native_client_sdk/src/tests/nacl_io_socket_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 51 native_client_sdk/src/tests/nacl_io_socket_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 128 native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_pepper_interface_url_loader.cc response->headers += ss.str(); str 178 native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_pepper_interface_url_loader.cc response->headers += ss.str(); str 69 native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_var_manager.cc return rtn.str(); str 34 native_client_sdk/src/tests/nacl_io_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 44 native_client_sdk/src/tests/nacl_io_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 52 native_client_sdk/src/tests/nacl_io_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 33 native_client_sdk/src/tests/sdk_util_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 43 native_client_sdk/src/tests/sdk_util_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 51 native_client_sdk/src/tests/sdk_util_test/main.cc pp::Instance(PSGetInstanceId()).PostMessage(msg.str()); str 109 net/android/keystore_unittest.cc unsigned char* OpenSSLWriteInto(std::string* str, size_t size) { str 110 net/android/keystore_unittest.cc return reinterpret_cast<unsigned char*>(WriteInto(str, size + 1)); str 238 net/base/escape.cc template <class str> str 239 net/base/escape.cc void AppendEscapedCharForHTMLImpl(typename str::value_type c, str* output) { str 263 net/base/escape.cc template <class str> str 264 net/base/escape.cc str EscapeForHTMLImpl(const str& input) { str 265 net/base/escape.cc str result; str 268 net/base/escape.cc for (typename str::const_iterator i = input.begin(); i != input.end(); ++i) str 185 net/base/escape_unittest.cc std::string str(unescape_cases[i].input); str 187 net/base/escape_unittest.cc UnescapeURLComponent(str, unescape_cases[i].rules)); str 278 net/base/escape_unittest.cc base::string16 str(base::WideToUTF16(unescape_cases[i].input)); str 280 net/base/escape_unittest.cc UnescapeURLComponent(str, unescape_cases[i].rules)); str 31 net/base/host_port_pair.cc HostPortPair HostPortPair::FromString(const std::string& str) { str 33 net/base/host_port_pair.cc base::SplitString(str, ':', &key_port); str 32 net/base/host_port_pair.h static HostPortPair FromString(const std::string& str); str 187 net/base/net_util.cc bool IsIDNComponentInSingleScript(const base::char16* str, int str_len) { str 194 net/base/net_util.cc U16_NEXT(str, i, str_len, code_point); str 308 net/base/net_util.cc bool IsIDNComponentSafe(const base::char16* str, str 363 net/base/net_util.cc icu::UnicodeString component_string(str, str_len); str 380 net/base/net_util.cc return IsIDNComponentInSingleScript(str, str_len); str 491 net/base/net_util.cc void LimitOffsets(const base::string16& str, Offsets* offsets_for_adjustment) { str 495 net/base/net_util.cc base::LimitOffset<base::string16>(str.length())); str 1606 net/base/net_util.cc std::string str; str 1607 net/base/net_util.cc url_canon::StdStringCanonOutput output(&str); str 1618 net/base/net_util.cc return str; str 55 net/base/registry_controlled_domains/effective_tld_names.cc static inline unsigned int hash (const char *str, unsigned int len); str 57 net/base/registry_controlled_domains/effective_tld_names.cc static const struct DomainRule *FindDomain (const char *str, unsigned int len); str 61 net/base/registry_controlled_domains/effective_tld_names.cc Perfect_Hash::hash (register const char *str, register unsigned int len) str 100 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[42]]; str 103 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[41]]; str 106 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[40]]; str 109 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[39]]; str 112 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[38]]; str 115 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[37]]; str 118 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[36]]; str 121 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[35]]; str 124 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[34]]; str 127 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[33]]; str 130 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[32]]; str 133 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[31]]; str 136 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[30]]; str 139 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[29]]; str 142 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[28]]; str 145 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[27]]; str 148 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[26]]; str 151 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[25]]; str 154 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[24]]; str 157 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[23]]; str 160 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[22]]; str 163 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[21]]; str 166 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[20]]; str 169 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[19]]; str 172 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[18]]; str 175 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[17]]; str 178 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[16]]; str 181 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[15]]; str 184 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[14]]; str 187 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[13]]; str 190 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[12]+1]; str 193 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[11]]; str 196 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[10]]; str 199 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[9]]; str 202 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[8]+1]; str 205 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[7]+1]; str 208 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[6]+3]; str 211 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[5]+16]; str 214 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[4]]; str 217 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[3]+15]; str 220 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[2]+14]; str 223 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[1]]; str 226 net/base/registry_controlled_domains/effective_tld_names.cc hval += asso_values[(unsigned char)str[0]+25]; str 13284 net/base/registry_controlled_domains/effective_tld_names.cc Perfect_Hash::FindDomain (register const char *str, register unsigned int len) str 54258 net/base/registry_controlled_domains/effective_tld_names.cc register int key = hash (str, len); str 54268 net/base/registry_controlled_domains/effective_tld_names.cc if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') str 56 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc static inline unsigned int hash (const char *str, unsigned int len); str 58 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc static const struct DomainRule *FindDomain (const char *str, unsigned int len); str 62 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc Perfect_Hash_Test1::hash (register const char *str, register unsigned int len) str 98 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[10]]; str 101 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[9]]; str 104 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[8]]; str 107 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[7]]; str 110 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[6]]; str 113 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[5]]; str 116 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[4]]; str 119 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[3]]; str 122 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[2]]; str 125 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[1]]; str 128 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc hval += asso_values[(unsigned char)str[0]]; str 164 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc Perfect_Hash_Test1::FindDomain (register const char *str, register unsigned int len) str 200 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc register int key = hash (str, len); str 210 net/base/registry_controlled_domains/effective_tld_names_unittest1.cc if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') str 51 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc static inline unsigned int hash (const char *str, unsigned int len); str 53 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc static const struct DomainRule *FindDomain (const char *str, unsigned int len); str 57 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc Perfect_Hash_Test2::hash (register const char *str, register unsigned int len) str 93 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc hval += asso_values[(unsigned char)str[5]]; str 96 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc hval += asso_values[(unsigned char)str[4]]; str 99 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc hval += asso_values[(unsigned char)str[3]]; str 102 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc hval += asso_values[(unsigned char)str[2]]; str 105 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc hval += asso_values[(unsigned char)str[1]]; str 108 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc hval += asso_values[(unsigned char)str[0]]; str 126 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc Perfect_Hash_Test2::FindDomain (register const char *str, register unsigned int len) str 143 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc register int key = hash (str, len); str 153 net/base/registry_controlled_domains/effective_tld_names_unittest2.cc if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') str 30 net/cert/pem_tokenizer.cc const StringPiece& str, str 32 net/cert/pem_tokenizer.cc Init(str, allowed_block_types); str 88 net/cert/pem_tokenizer.cc const StringPiece& str, str 90 net/cert/pem_tokenizer.cc str_ = str; str 25 net/cert/pem_tokenizer.h PEMTokenizer(const base::StringPiece& str, str 45 net/cert/pem_tokenizer.h void Init(const base::StringPiece& str, str 169 net/cert/x509_cert_types_mac.cc bool match(const std::string& str, const std::string& against) { str 172 net/cert/x509_cert_types_mac.cc return against == str; str 27 net/cookies/cookie_monster_perftest.cc int CountInString(const std::string& str, char c) { str 28 net/cookies/cookie_monster_perftest.cc return std::count(str.begin(), str.end(), c); str 419 net/cookies/cookie_monster_unittest.cc int CountInString(const std::string& str, char c) { str 420 net/cookies/cookie_monster_unittest.cc return std::count(str.begin(), str.end(), c); str 11 net/cookies/cookie_util_unittest.cc const char* str; str 21 net/cookies/cookie_util_unittest.cc net::cookie_util::DomainIsHostOnly(tests[i].str)); str 27 net/cookies/cookie_util_unittest.cc const char* str; str 103 net/cookies/cookie_util_unittest.cc parsed_time = net::cookie_util::ParseCookieTime(tests[i].str); str 105 net/cookies/cookie_util_unittest.cc EXPECT_FALSE(!parsed_time.is_null()) << tests[i].str; str 108 net/cookies/cookie_util_unittest.cc EXPECT_TRUE(!parsed_time.is_null()) << tests[i].str; str 109 net/cookies/cookie_util_unittest.cc EXPECT_EQ(tests[i].epoch, parsed_time.ToTimeT()) << tests[i].str; str 233 net/disk_cache/blockfile/stress_cache.cc void CrashHandler(const std::string& str) { str 239 net/disk_cache/blockfile/stress_cache.cc size_t message_start, const std::string& str) { str 242 net/disk_cache/blockfile/stress_cache.cc size_t len = std::min(str.length() - message_start, kMaxMessageLen - 1); str 244 net/disk_cache/blockfile/stress_cache.cc memcpy(message, str.c_str() + message_start, len); str 24 net/dns/address_sorter_posix_unittest.cc IPAddressNumber ParseIP(const std::string& str) { str 26 net/dns/address_sorter_posix_unittest.cc CHECK(ParseIPLiteralToNumber(str, &addr)); str 25 net/dns/address_sorter_unittest.cc IPEndPoint MakeEndPoint(const std::string& str) { str 27 net/dns/address_sorter_unittest.cc CHECK(ParseIPLiteralToNumber(str, &addr)); str 244 net/http/http_auth_gssapi_posix.cc const char* str = reinterpret_cast<const char*>(oid); str 247 net/http/http_auth_gssapi_posix.cc if (!str[str_length] || !isprint(str[str_length])) str 250 net/http/http_auth_gssapi_posix.cc if (!str[str_length]) { str 251 net/http/http_auth_gssapi_posix.cc output += base::StringPrintf("\"%s\"", str); str 213 net/http/http_auth_handler_ntlm_portable.cc void* buf, const base::char16* str, uint32 str_len) { str 216 net/http/http_auth_handler_ntlm_portable.cc const uint8* input = reinterpret_cast<const uint8*>(str); str 440 net/http/http_network_transaction_unittest.cc void FillLargeHeadersString(std::string* str, int size) { str 448 net/http/http_network_transaction_unittest.cc str->reserve(sizeof_data); str 451 net/http/http_network_transaction_unittest.cc str->append(row, sizeof_row); str 117 net/http/http_response_headers.cc void CheckDoesNotHaveEmbededNulls(const std::string& str) { str 121 net/http/http_response_headers.cc CHECK(str.find('\0') == std::string::npos); str 59 net/http/http_server_properties.cc AlternateProtocol AlternateProtocolFromString(const std::string& str) { str 63 net/http/http_server_properties.cc if (str == AlternateProtocolToString(protocol)) str 66 net/http/http_server_properties.cc if (str == kBrokenAlternateProtocol) str 51 net/http/http_server_properties.h const std::string& str); str 466 net/http/http_util.cc std::string HttpUtil::Unquote(const std::string& str) { str 467 net/http/http_util.cc return Unquote(str.begin(), str.end()); str 471 net/http/http_util.cc std::string HttpUtil::Quote(const std::string& str) { str 473 net/http/http_util.cc escaped.reserve(2 + str.size()); str 475 net/http/http_util.cc std::string::const_iterator begin = str.begin(); str 476 net/http/http_util.cc std::string::const_iterator end = str.end(); str 627 net/http/http_util.cc std::string HttpUtil::ConvertHeadersBackToHTTPResponse(const std::string& str) { str 629 net/http/http_util.cc base::StringTokenizer tokenizer(str, std::string(1, '\0')); str 110 net/http/http_util.h static bool IsToken(const std::string& str) { str 111 net/http/http_util.h return IsToken(str.begin(), str.end()); str 123 net/http/http_util.h static std::string Unquote(const std::string& str); str 126 net/http/http_util.h static std::string Quote(const std::string& str); str 160 net/http/http_util.h static std::string ConvertHeadersBackToHTTPResponse(const std::string& str); str 48 net/http/transport_security_state.cc std::string str; str 51 net/http/transport_security_state.cc str += ","; str 52 net/http/transport_security_state.cc str += hashes[i].ToString(); str 54 net/http/transport_security_state.cc return str; str 42 net/proxy/proxy_bypass_rules.cc std::string str; str 44 net/proxy/proxy_bypass_rules.cc base::StringAppendF(&str, "%s://", optional_scheme_.c_str()); str 45 net/proxy/proxy_bypass_rules.cc str += hostname_pattern_; str 47 net/proxy/proxy_bypass_rules.cc base::StringAppendF(&str, ":%d", optional_port_); str 48 net/proxy/proxy_bypass_rules.cc return str; str 156 net/proxy/proxy_config_service_android.cc ScopedJavaLocalRef<jstring> str = ConvertUTF8ToJavaString(env, property); str 158 net/proxy/proxy_config_service_android.cc Java_ProxyChangeListener_getProperty(env, str.obj()); str 456 net/quic/quic_framer_test.cc void CheckStreamFrameData(string str, QuicStreamFrame* frame) { str 458 net/quic/quic_framer_test.cc EXPECT_EQ(str, *frame_data); str 88 net/quic/quic_utils.h inline IOVector MakeIOVector(base::StringPiece str) { str 90 net/quic/quic_utils.h iov.Append(const_cast<char*>(str.data()), str.size()); str 25 net/server/web_socket.cc static uint32 WebSocketKeyFingerprint(const std::string& str) { str 27 net/server/web_socket.cc const char* p_char = str.c_str(); str 28 net/server/web_socket.cc int length = str.length(); str 1432 net/socket/ssl_client_socket_openssl.cc unsigned char* str = NULL; str 1433 net/socket/ssl_client_socket_openssl.cc int length = i2d_X509_NAME(ca_name, &str); str 1435 net/socket/ssl_client_socket_openssl.cc reinterpret_cast<const char*>(str), str 1437 net/socket/ssl_client_socket_openssl.cc OPENSSL_free(str); str 84 net/socket/stream_listen_socket.cc void StreamListenSocket::Send(const string& str, bool append_linefeed) { str 85 net/socket/stream_listen_socket.cc Send(str.data(), static_cast<int>(str.length()), append_linefeed); str 72 net/socket/stream_listen_socket.h void Send(const std::string& str, bool append_linefeed = false); str 225 net/socket/tcp_listen_socket_unittest.cc const std::string& str) { str 226 net/socket/tcp_listen_socket_unittest.cc int len = static_cast<int>(str.length()); str 227 net/socket/tcp_listen_socket_unittest.cc int send_len = HANDLE_EINTR(send(sock, str.data(), len, 0)); str 247 net/socket/tcp_listen_socket_unittest.cc std::string str(data, len); str 248 net/socket/tcp_listen_socket_unittest.cc ReportAction(TCPListenSocketTestAction(ACTION_READ, str)); str 90 net/socket/tcp_listen_socket_unittest.h virtual bool Send(SocketDescriptor sock, const std::string& str); str 55 net/socket/transport_client_socket_unittest.cc virtual void DidRead(StreamListenSocket*, const char* str, int len) OVERRIDE { str 41 net/socket_stream/socket_stream_unittest.cc const std::string& str, str 44 net/socket_stream/socket_stream_unittest.cc : event_type(type), socket(socket_stream), number(num), data(str), str 94 net/spdy/hpack_decoder_test.cc bool DecodeHeaderBlock(StringPiece str) { str 95 net/spdy/hpack_decoder_test.cc return decoder_.HandleControlFrameHeadersData(0, str.data(), str.size()) && str 105 net/spdy/hpack_decoder_test.cc const std::map<string, string>& DecodeUniqueHeaderSet(StringPiece str) { str 106 net/spdy/hpack_decoder_test.cc EXPECT_TRUE(DecodeHeaderBlock(str)); str 96 net/spdy/hpack_input_stream.cc bool HpackInputStream::DecodeNextIdentityString(StringPiece* str) { str 107 net/spdy/hpack_input_stream.cc *str = StringPiece(buffer_.data(), size); str 113 net/spdy/hpack_input_stream.cc string* str) { str 127 net/spdy/hpack_input_stream.cc return table.DecodeString(&bounded_reader, max_string_literal_size_, str); str 43 net/spdy/hpack_input_stream.h bool DecodeNextIdentityString(base::StringPiece* str); str 45 net/spdy/hpack_input_stream.h std::string* str); str 46 net/spdy/hpack_input_stream_test.cc uint32 DecodeValidUint32(uint8 N, StringPiece str) { str 49 net/spdy/hpack_input_stream_test.cc HpackInputStream input_stream(kLiteralBound, str); str 58 net/spdy/hpack_input_stream_test.cc void ExpectDecodeUint32Invalid(uint8 N, StringPiece str) { str 61 net/spdy/hpack_input_stream_test.cc HpackInputStream input_stream(kLiteralBound, str); str 89 net/spdy/hpack_output_stream.cc bool HpackOutputStream::AppendStringLiteral(base::StringPiece str) { str 93 net/spdy/hpack_output_stream.cc if (str.size() > max_string_literal_size_) str 95 net/spdy/hpack_output_stream.cc AppendUint32(static_cast<uint32>(str.size())); str 96 net/spdy/hpack_output_stream.cc buffer_.append(str.data(), str.size()); str 61 net/spdy/hpack_output_stream.h bool AppendStringLiteralForTest(base::StringPiece str) { str 62 net/spdy/hpack_output_stream.h return AppendStringLiteral(str); str 84 net/spdy/hpack_output_stream.h bool AppendStringLiteral(base::StringPiece str); str 43 net/spdy/hpack_output_stream_test.cc string str; str 44 net/spdy/hpack_output_stream_test.cc output_stream.TakeString(&str); str 45 net/spdy/hpack_output_stream_test.cc EXPECT_EQ(expected_str, str); str 56 net/spdy/hpack_output_stream_test.cc string str; str 57 net/spdy/hpack_output_stream_test.cc output_stream.TakeString(&str); str 58 net/spdy/hpack_output_stream_test.cc return str; str 242 net/spdy/hpack_output_stream_test.cc string str; str 243 net/spdy/hpack_output_stream_test.cc output_stream.TakeString(&str); str 244 net/spdy/hpack_output_stream_test.cc EXPECT_EQ(string("\xff\x00", 2), str); str 256 net/spdy/hpack_output_stream_test.cc string str; str 257 net/spdy/hpack_output_stream_test.cc output_stream.TakeString(&str); str 258 net/spdy/hpack_output_stream_test.cc EXPECT_EQ(string("\x7f\x00", 2) + literal, str); str 274 net/spdy/hpack_output_stream_test.cc string str; str 275 net/spdy/hpack_output_stream_test.cc output_stream.TakeString(&str); str 276 net/spdy/hpack_output_stream_test.cc EXPECT_EQ("\xff\x80\xff\xff\xff\x0f", str); str 286 net/spdy/hpack_output_stream_test.cc string str; str 287 net/spdy/hpack_output_stream_test.cc output_stream.TakeString(&str); str 288 net/spdy/hpack_output_stream_test.cc EXPECT_EQ("\x40\x04name\x05value", str); str 45 net/spdy/spdy_stream.cc bool ContainsUppercaseAscii(const std::string& str) { str 46 net/spdy/spdy_stream.cc for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) { str 28 net/test/scoped_disable_exit_on_dfatal.cc void ScopedDisableExitOnDFatal::LogAssertHandler(const std::string& str) { str 53 net/test/scoped_mock_log.cc const std::string& str) { str 54 net/test/scoped_mock_log.cc return g_instance_->Log(severity, file, line, message_start, str); str 74 net/test/scoped_mock_log.h const std::string& str)); str 86 net/test/scoped_mock_log.h const std::string& str); str 10 net/third_party/nss/ssl/sslerrstrs.c #define ER3(name, value, str) {#name, str}, str 744 net/tools/balsa/balsa_headers.cc void BalsaHeaders::DumpToString(std::string* str) const { str 750 net/tools/balsa/balsa_headers.cc str->append("\n<empty header>\n"); str 757 net/tools/balsa/balsa_headers.cc base::StringAppendF(str, "\n<incomplete header len: %d>\n%.*s\n", str 765 net/tools/balsa/balsa_headers.cc str->reserve(str->size() + GetSizeForWriteBuffer()); str 766 net/tools/balsa/balsa_headers.cc base::StringAppendF(str, "\n %.*s\n", str 771 net/tools/balsa/balsa_headers.cc base::StringAppendF(str, " %.*s: %.*s\n", str 826 net/tools/balsa/balsa_headers.h void DumpToString(std::string* str) const; str 21 net/tools/balsa/simple_buffer.h std::string str() const; str 164 net/tools/dns_fuzz_stub/dns_fuzz_stub.cc LOG(INFO) << result_line.str(); str 34 net/tools/dump_cache/url_to_filename_encoder.cc uint64 ParseLeadingHex64Value(const char *str, uint64 deflt) { str 36 net/tools/dump_cache/url_to_filename_encoder.cc const uint64 value = strtoull(str, &error, 16); str 37 net/tools/dump_cache/url_to_filename_encoder.cc return (error == str) ? deflt : value; str 185 net/tools/dump_cache/url_to_filename_encoder.h static void ReplaceAll(std::string* str, const std::string& from, str 188 net/tools/dump_cache/url_to_filename_encoder.h while ((pos = str->find(from, pos)) != std::string::npos) { str 189 net/tools/dump_cache/url_to_filename_encoder.h str->replace(pos, from.size(), to); str 301 net/tools/flip_server/flip_in_mem_edsm_server.cc if (!cl.HasSwitch(name.str())) { str 304 net/tools/flip_server/flip_in_mem_edsm_server.cc std::string value = cl.GetSwitchValueASCII(name.str()); str 60 net/tools/net_watcher/net_watcher.cc std::string str; str 61 net/tools/net_watcher/net_watcher.cc base::JSONWriter::Write(config_value.get(), &str); str 62 net/tools/net_watcher/net_watcher.cc return str; str 74 net/tools/quic/test_tools/http_message.cc HTTPMessage::Method HTTPMessage::StringToMethod(StringPiece str) { str 77 net/tools/quic/test_tools/http_message.cc if (strncmp(str.data(), kMethodString[i], str.length()) == 0) { str 84 net/tools/quic/test_tools/http_message.cc HTTPMessage::Version HTTPMessage::StringToVersion(StringPiece str) { str 87 net/tools/quic/test_tools/http_message.cc if (strncmp(str.data(), kHTTPVersionString[i], str.length()) == 0) { str 52 net/tools/quic/test_tools/http_message.h static Version StringToVersion(base::StringPiece str); str 53 net/tools/quic/test_tools/http_message.h static Method StringToMethod(base::StringPiece str); str 159 net/udp/udp_socket_unittest.cc std::string str = RecvFromSocket(server.get()); str 160 net/udp/udp_socket_unittest.cc DCHECK(simple_message == str); str 167 net/udp/udp_socket_unittest.cc str = ReadSocket(client.get()); str 168 net/udp/udp_socket_unittest.cc DCHECK(simple_message == str); str 242 net/udp/udp_socket_unittest.cc std::string str = RecvFromSocket(server1.get()); str 243 net/udp/udp_socket_unittest.cc ASSERT_EQ(first_message, str); str 244 net/udp/udp_socket_unittest.cc str = RecvFromSocket(server2.get()); str 245 net/udp/udp_socket_unittest.cc ASSERT_EQ(first_message, str); str 249 net/udp/udp_socket_unittest.cc str = RecvFromSocket(server1.get()); str 250 net/udp/udp_socket_unittest.cc ASSERT_EQ(second_message, str); str 251 net/udp/udp_socket_unittest.cc str = RecvFromSocket(server2.get()); str 252 net/udp/udp_socket_unittest.cc ASSERT_EQ(second_message, str); str 405 net/udp/udp_socket_unittest.cc std::string str = RecvFromSocket(&server1); str 406 net/udp/udp_socket_unittest.cc DCHECK(simple_message == str); str 424 net/udp/udp_socket_unittest.cc str = ReadSocket(&client); str 425 net/udp/udp_socket_unittest.cc DCHECK(simple_message == str); str 332 ppapi/c/ppb_opengles2.h const char** str, str 257 ppapi/cpp/var.cc const char* str; str 259 ppapi/cpp/var.cc str = get_interface<PPB_Var_1_2>()->VarToUtf8(var_, &len); str 261 ppapi/cpp/var.cc str = get_interface<PPB_Var_1_1>()->VarToUtf8(var_, &len); str 263 ppapi/cpp/var.cc str = get_interface<PPB_Var_1_0>()->VarToUtf8(var_, &len); str 266 ppapi/cpp/var.cc return std::string(str, len); str 299 ppapi/cpp/var.cc std::string str = AsString(); str 300 ppapi/cpp/var.cc if (str.length() > available) { str 301 ppapi/cpp/var.cc str.resize(available - 3); // Reserve space for ellipsis. str 302 ppapi/cpp/var.cc str.append("..."); str 304 ppapi/cpp/var.cc snprintf(buf, sizeof(buf), format, str.c_str()); str 124 ppapi/examples/crxfs/crxfs.cc PostMessage(pp::Var(out.str())); str 61 ppapi/examples/ime/ime.cc size_t GetPrevCharOffsetUtf8(const std::string& str, size_t current_pos) { str 66 ppapi/examples/ime/ime.cc while (i > 0 && (str[i] & 0xc0) == 0x80); str 71 ppapi/examples/ime/ime.cc size_t GetNextCharOffsetUtf8(const std::string& str, size_t current_pos) { str 73 ppapi/examples/ime/ime.cc if (i < str.size()) { str 76 ppapi/examples/ime/ime.cc while (i < str.size() && (str[i] & 0xc0) == 0x80); str 81 ppapi/examples/ime/ime.cc size_t GetNthCharOffsetUtf8(const std::string& str, size_t n) { str 84 ppapi/examples/ime/ime.cc i = GetNextCharOffsetUtf8(str, i); str 158 ppapi/examples/ime/ime.cc std::string str = utf8_text_.substr(0, caret_pos_); str 161 ppapi/examples/ime/ime.cc pp::TextRun_Dev(str.c_str(), false, false), str 166 ppapi/examples/ime/ime.cc offset += font_.MeasureSimpleText(str); str 170 ppapi/examples/ime/ime.cc const std::string& str = composition_; str 174 ppapi/examples/ime/ime.cc str.substr(0, composition_selection_.first)); str 176 ppapi/examples/ime/ime.cc str.substr(0, composition_selection_.second)); str 183 ppapi/examples/ime/ime.cc pp::TextRun_Dev(str.c_str(), false, false), str 192 ppapi/examples/ime/ime.cc int lx = font_.MeasureSimpleText(str.substr(0, l)); str 193 ppapi/examples/ime/ime.cc int rx = font_.MeasureSimpleText(str.substr(0, r)); str 204 ppapi/examples/ime/ime.cc str.substr(0, composition_selection_.first)); str 208 ppapi/examples/ime/ime.cc offset += font_.MeasureSimpleText(str); str 212 ppapi/examples/ime/ime.cc std::string str = utf8_text_.substr(caret_pos_); str 215 ppapi/examples/ime/ime.cc pp::TextRun_Dev(str.c_str(), false, false), str 363 ppapi/examples/ime/ime.cc std::string str = utf8_text_.substr(0, caret_pos_); str 365 ppapi/examples/ime/ime.cc str += composition_.substr(0, composition_selection_.first); str 366 ppapi/examples/ime/ime.cc int px = font_.MeasureSimpleText(str); str 656 ppapi/examples/ime/ime.cc std::string str = ev.GetCharacterText().AsString(); str 657 ppapi/examples/ime/ime.cc if (str != "\r" && str != "\n") str 658 ppapi/examples/ime/ime.cc it->InsertText(str); str 72 ppapi/examples/scaling/scaling.cc std::string str = message_data.AsString(); str 73 ppapi/examples/scaling/scaling.cc if (str == "dip") { str 78 ppapi/examples/scaling/scaling.cc } else if (str == "device") { str 83 ppapi/examples/scaling/scaling.cc } else if (str == "metrics") { str 88 ppapi/examples/scaling/scaling.cc PostMessage(stream.str()); str 111 ppapi/examples/scaling/scaling.cc PostMessage(stream.str()); str 155 ppapi/examples/video_decode/video_decode.cc const std::string& msg = stream_.str(); str 30 ppapi/examples/video_effects/video_effects.cc std::vector<std::string> SplitStringBySpace(const std::string& str) { str 31 ppapi/examples/video_effects/video_effects.cc std::istringstream buf(str); str 618 ppapi/lib/gl/gles2/gles2.c const char** str, str 621 ppapi/lib/gl/gles2/gles2.c glGetCurrentContextPPAPI(), shader, count, str, length); str 135 ppapi/native_client/src/trusted/plugin/json_manifest.cc *error_string = error_stream.str(); str 159 ppapi/native_client/src/trusted/plugin/json_manifest.cc *error_string = error_stream.str(); str 192 ppapi/native_client/src/trusted/plugin/json_manifest.cc *error_string = error_stream.str(); str 213 ppapi/native_client/src/trusted/plugin/json_manifest.cc *error_string = error_stream.str(); str 222 ppapi/native_client/src/trusted/plugin/json_manifest.cc *error_string = error_stream.str(); str 14 ppapi/native_client/src/trusted/plugin/nacl_http_response_headers.cc void SplitString(const std::string& str, str 17 ppapi/native_client/src/trusted/plugin/nacl_http_response_headers.cc std::stringstream ss(str); str 24 ppapi/native_client/src/trusted/plugin/nacl_http_response_headers.cc bool SplitOnce(const std::string& str, str 27 ppapi/native_client/src/trusted/plugin/nacl_http_response_headers.cc size_t pos = str.find(delim); str 29 ppapi/native_client/src/trusted/plugin/nacl_http_response_headers.cc elems->push_back(str.substr(0, pos)); str 30 ppapi/native_client/src/trusted/plugin/nacl_http_response_headers.cc elems->push_back(str.substr(pos + 1)); str 22 ppapi/native_client/src/trusted/plugin/nacl_subprocess.cc return ss.str(); str 128 ppapi/native_client/src/trusted/plugin/nacl_subprocess.cc params->ins()[i]->arrays.str = input; str 289 ppapi/native_client/src/trusted/plugin/pnacl_coordinator.cc error_info_.SetReport(err_code, ss.str()); str 583 ppapi/native_client/src/trusted/plugin/pnacl_coordinator.cc error_info_.SetReport(PP_NACL_ERROR_PNACL_PEXE_FETCH_OTHER, ss.str()); str 34 ppapi/native_client/src/trusted/plugin/pnacl_options.cc nacl::string str; str 38 ppapi/native_client/src/trusted/plugin/pnacl_options.cc str = ss.str(); str 39 ppapi/native_client/src/trusted/plugin/pnacl_options.cc std::copy(str.begin(), str.end(), std::back_inserter(result)); str 44 ppapi/native_client/src/trusted/plugin/pnacl_options.cc str = "-bitcode-format=llvm"; str 45 ppapi/native_client/src/trusted/plugin/pnacl_options.cc std::copy(str.begin(), str.end(), std::back_inserter(result)); str 187 ppapi/native_client/src/trusted/plugin/pnacl_translate_thread.cc nacl::string split_arg = ss.str(); str 221 ppapi/native_client/src/trusted/plugin/pnacl_translate_thread.cc nacl::string(params.outs()[0]->arrays.str)); str 281 ppapi/native_client/src/trusted/plugin/pnacl_translate_thread.cc params.outs()[3]->arrays.str); str 64 ppapi/native_client/src/trusted/plugin/srpc_params.cc free(arg->arrays.str); str 144 ppapi/native_client/tests/ppapi_test_lib/test_interface.h return s.str(); str 557 ppapi/proxy/ppapi_proxy_test.cc IPC::ChannelHandle handle(handle_name.str()); str 364 ppapi/proxy/ppapi_proxy_test.h #define EXPECT_VAR_IS_STRING(str, var) { \ str 368 ppapi/proxy/ppapi_proxy_test.h EXPECT_EQ(str, sv->value()); \ str 225 ppapi/proxy/resource_creation_proxy.cc std::string str = string_var.get() ? string_var->value() : std::string(); str 226 ppapi/proxy/resource_creation_proxy.cc return (new FileChooserResource(GetConnection(), instance, mode, str.c_str())) str 458 ppapi/proxy/serialized_var.cc const std::string& str) { str 459 ppapi/proxy/serialized_var.cc inner_->ForceSetVarValueForTest(StringVar::StringToPPVar(str)); str 488 ppapi/proxy/serialized_var.h explicit SerializedVarTestConstructor(const std::string& str); str 948 ppapi/shared_impl/ppb_opengles2_shared.cc const char** str, str 952 ppapi/shared_impl/ppb_opengles2_shared.cc ToGles2Impl(&enter)->ShaderSource(shader, count, str, length); str 48 ppapi/shared_impl/ppb_var_shared.cc StringVar* str = StringVar::FromPPVar(var); str 49 ppapi/shared_impl/ppb_var_shared.cc if (str) { str 50 ppapi/shared_impl/ppb_var_shared.cc *len = static_cast<uint32_t>(str->value().size()); str 51 ppapi/shared_impl/ppb_var_shared.cc return str->value().c_str(); str 293 ppapi/shared_impl/private/net_address_private_impl.cc std::string str = NetAddressPrivateImpl::DescribeNetAddress( str 295 ppapi/shared_impl/private/net_address_private_impl.cc if (str.empty()) str 300 ppapi/shared_impl/private/net_address_private_impl.cc return StringVar::StringToPPVar(str); str 133 ppapi/shared_impl/var.cc StringVar::StringVar(const std::string& str) : value_(str) {} str 135 ppapi/shared_impl/var.cc StringVar::StringVar(const char* str, uint32 len) : value_(str, len) {} str 150 ppapi/shared_impl/var.cc scoped_refptr<StringVar> str(new StringVar(data, len)); str 151 ppapi/shared_impl/var.cc if (!str.get() || !IsStringUTF8(str->value())) str 153 ppapi/shared_impl/var.cc return str->GetPPVar(); str 169 ppapi/shared_impl/var.cc scoped_refptr<StringVar> str(new StringVar); str 170 ppapi/shared_impl/var.cc str->value_.swap(*src); str 171 ppapi/shared_impl/var.cc return str->GetPPVar(); str 103 ppapi/shared_impl/var.h explicit StringVar(const std::string& str); str 104 ppapi/shared_impl/var.h StringVar(const char* str, uint32 len); str 125 ppapi/shared_impl/var.h static PP_Var StringToPPVar(const std::string& str); str 126 ppapi/shared_impl/var.h static PP_Var StringToPPVar(const char* str, uint32 len); str 21 ppapi/shared_impl/var_tracker_unittest.cc MockStringVar(const std::string& str) : StringVar(str) { str 112 ppapi/tests/test_case.cc return output.str(); str 232 ppapi/tests/test_case.cc errors += output.str(); str 290 ppapi/tests/test_case.h return stream.str(); str 350 ppapi/tests/test_case.h return stream.str(); str 699 ppapi/tests/test_file_ref.cc pp::FileRef file_ref(file_system, buffer.str().c_str()); str 707 ppapi/tests/test_file_ref.cc expected_file_names.insert(buffer.str()); str 715 ppapi/tests/test_file_ref.cc pp::FileRef file_ref(file_system, buffer.str().c_str()); str 722 ppapi/tests/test_file_ref.cc expected_dir_names.insert(buffer.str()); str 111 ppapi/tests/test_net_address_private_untrusted.cc ASSERT_EQ(os.str(), NetAddressPrivate::Describe(remote_address, false)); str 114 ppapi/tests/test_net_address_private_untrusted.cc ASSERT_EQ(os.str(), NetAddressPrivate::Describe(remote_address, true)); str 139 ppapi/tests/test_net_address_private_untrusted.cc ASSERT_EQ(os.str(), NetAddressPrivate::Describe(dst_addr, true)); str 422 ppapi/tests/test_post_message.cc const std::string kSizeAsString(size_stream.str()); str 501 ppapi/tests/test_post_message.cc std::string length_as_string(ss.str()); str 546 ppapi/tests/test_post_message.cc std::string length_as_string(ss.str()); str 69 ppapi/tests/test_test_internals.cc std::string str = "blah"; str 70 ppapi/tests/test_test_internals.cc ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(str + "blah"), str 176 ppapi/tests/test_udp_socket.cc std::string str; str 178 ppapi/tests/test_udp_socket.cc &str)); str 184 ppapi/tests/test_udp_socket.cc ASSERT_EQ(message, str); str 156 ppapi/tests/test_udp_socket_private.cc std::string str; str 157 ppapi/tests/test_udp_socket_private.cc ASSERT_SUBTEST_SUCCESS(ReadSocket(target, address, message.size(), &str)); str 163 ppapi/tests/test_udp_socket_private.cc ASSERT_EQ(message, str); str 48 ppapi/tests/test_var.cc PP_Var str = var_interface_->VarFromUtf8(kStr, kStrLen); str 49 ppapi/tests/test_var.cc ASSERT_EQ(PP_VARTYPE_STRING, str.type); str 53 ppapi/tests/test_var.cc const char* result = var_interface_->VarToUtf8(str, &len); str 58 ppapi/tests/test_var.cc var_interface_->Release(str); str 59 ppapi/tests/test_var.cc result = var_interface_->VarToUtf8(str, &len); str 96 ppapi/tests/test_var_deprecated.cc PP_Var str = var_interface_->VarFromUtf8(pp::Module::Get()->pp_module(), str 98 ppapi/tests/test_var_deprecated.cc ASSERT_EQ(PP_VARTYPE_STRING, str.type); str 102 ppapi/tests/test_var_deprecated.cc const char* result = var_interface_->VarToUtf8(str, &len); str 107 ppapi/tests/test_var_deprecated.cc var_interface_->Release(str); str 108 ppapi/tests/test_var_deprecated.cc result = var_interface_->VarToUtf8(str, &len); str 152 ppapi/tests/test_view.cc instance_->EvalScript(script_stream.str()); str 188 ppapi/tests/test_view.cc instance_->EvalScript(script_stream.str()); str 132 ppapi/tests/testing_instance.cc std::string time_string(number_stream.str()); str 138 remoting/base/compound_buffer_unittest.cc const std::string& str) { str 139 remoting/base/compound_buffer_unittest.cc SCOPED_TRACE(str); str 140 remoting/base/compound_buffer_unittest.cc scoped_ptr<char[]> buffer(new char[str.size() + 1]); str 141 remoting/base/compound_buffer_unittest.cc buffer[str.size()] = '\0'; str 142 remoting/base/compound_buffer_unittest.cc EXPECT_EQ(ReadFromInput(input, buffer.get(), str.size()), str.size()); str 143 remoting/base/compound_buffer_unittest.cc EXPECT_STREQ(str.data(), buffer.get()); str 1031 remoting/client/plugin/chromoting_instance.cc const std::string& str) { str 1062 remoting/client/plugin/chromoting_instance.cc message += (str.c_str() + message_start); str 1071 remoting/client/plugin/chromoting_instance.cc return (g_logging_old_handler)(severity, file, line, message_start, str); str 172 remoting/client/plugin/chromoting_instance.h size_t message_start, const std::string& str); str 219 remoting/client/plugin/pepper_port_allocator.cc request_info.SetHeaders(headers.str()); str 88 remoting/host/plugin/host_log_handler.cc const std::string& str) { str 111 remoting/host/plugin/host_log_handler.cc message += (str.c_str() + message_start); str 118 remoting/host/plugin/host_log_handler.cc return (g_logging_old_handler)(severity, file, line, message_start, str); str 33 remoting/host/plugin/host_log_handler.h size_t message_start, const std::string& str); str 123 remoting/host/server_log_entry.cc Set(kKeyOsVersion, os_version.str()); str 57 remoting/host/server_log_entry_unittest.cc *error = s.str(); str 48 remoting/host/setup/start_host.cc std::string str(kMaxLen, 0); str 49 remoting/host/setup/start_host.cc char* result = fgets(&str[0], kMaxLen, stdin); str 56 remoting/host/setup/start_host.cc size_t newline_index = str.find('\n'); str 58 remoting/host/setup/start_host.cc str[newline_index] = '\0'; str 59 remoting/host/setup/start_host.cc str.resize(strlen(&str[0])); str 60 remoting/host/setup/start_host.cc return str; str 106 remoting/protocol/negotiating_client_authenticator.cc result->AddAttr(kSupportedMethodsAttributeQName, supported_methods.str()); str 53 rlz/win/lib/rlz_value_store_registry.cc void AppendBrandToString(std::string* str) { str 56 rlz/win/lib/rlz_value_store_registry.cc base::StringAppendF(str, "\\_%s", brand.c_str()); str 157 sandbox/win/src/Wow64.cc writable_command(_wcsdup(command.str().c_str())); str 370 sandbox/win/src/policy_engine_opcodes.cc ptrdiff_t OpcodeFactory::AllocRelative(void* start, const wchar_t* str, str 381 sandbox/win/src/policy_engine_opcodes.cc memcpy(memory_bottom_, str, bytes); str 364 sandbox/win/src/policy_engine_opcodes.h ptrdiff_t AllocRelative(void* start, const wchar_t* str, size_t lenght); str 322 sandbox/win/src/policy_low_level.cc const wchar_t* str = opcode.GetRelativeString(0); str 331 sandbox/win/src/policy_low_level.cc memcpy(data_start, str, str_len); str 193 skia/config/SkUserConfig.h #define bzero(str, len) memset(str, 0, len) str 67 skia/ext/image_operations_unittest.cc char str[128]; str 72 skia/ext/image_operations_unittest.cc base::snprintf(str, sizeof(str), "bmp[%d,%d] = %08X", x, y, cur); str 73 skia/ext/image_operations_unittest.cc ADD_FAILURE() << str; str 419 skia/ext/image_operations_unittest.cc char str[128]; str 420 skia/ext/image_operations_unittest.cc base::snprintf(str, sizeof(str), str 423 skia/ext/image_operations_unittest.cc ADD_FAILURE() << str; str 9 skia/ext/skia_utils_base.cc bool ReadSkString(const Pickle& pickle, PickleIterator* iter, SkString* str) { str 16 skia/ext/skia_utils_base.cc if (str) str 17 skia/ext/skia_utils_base.cc str->set(reply_text, reply_length); str 41 skia/ext/skia_utils_base.cc bool WriteSkString(Pickle* pickle, const SkString& str) { str 42 skia/ext/skia_utils_base.cc return pickle->WriteData(str.c_str(), str.size()); str 16 skia/ext/skia_utils_base.h SkString* str); str 24 skia/ext/skia_utils_base.h SK_API bool WriteSkString(Pickle* pickle, const SkString& str); str 228 sql/statement.cc const char* str = reinterpret_cast<const char*>( str 233 sql/statement.cc if (str && len > 0) str 234 sql/statement.cc result.assign(str, len); str 82 sync/engine/syncer_proto_util.cc DVLOG(1) << response_trace.str(); str 213 sync/internal_api/public/base/ordinal_unittest.cc bool IsNonEmptyPrintableString(const std::string& str) { str 214 sync/internal_api/public/base/ordinal_unittest.cc if (str.empty()) str 216 sync/internal_api/public/base/ordinal_unittest.cc for (size_t i = 0; i < str.length(); ++i) { str 217 sync/internal_api/public/base/ordinal_unittest.cc if (!isprint(str[i])) str 480 sync/internal_api/public/base/unique_position.cc static uint32 ReadEncodedRunLength(const std::string& str, size_t i) { str 481 sync/internal_api/public/base/unique_position.cc DCHECK_LE(i + 4, str.length()); str 485 sync/internal_api/public/base/unique_position.cc ((uint8)(str[i+3]) << 0) | str 486 sync/internal_api/public/base/unique_position.cc ((uint8)(str[i+2]) << 8) | str 487 sync/internal_api/public/base/unique_position.cc ((uint8)(str[i+1]) << 16) | str 488 sync/internal_api/public/base/unique_position.cc ((uint8)(str[i+0]) << 24); str 513 sync/internal_api/public/base/unique_position.cc std::string UniquePosition::Compress(const std::string& str) { str 514 sync/internal_api/public/base/unique_position.cc DCHECK(IsValidBytes(str)); str 515 sync/internal_api/public/base/unique_position.cc std::string compressed = CompressImpl(str); str 517 sync/internal_api/public/base/unique_position.cc DCHECK_EQ(str, Uncompress(compressed)); str 523 sync/internal_api/public/base/unique_position.cc std::string UniquePosition::CompressImpl(const std::string& str) { str 535 sync/internal_api/public/base/unique_position.cc for (size_t i = 0; i < str.length(); ) { str 536 sync/internal_api/public/base/unique_position.cc if (i + 4 <= str.length() && IsRepeatedCharPrefix(str, i)) { str 539 sync/internal_api/public/base/unique_position.cc output.append(str, i, 4); str 542 sync/internal_api/public/base/unique_position.cc const char rep_digit = str[i]; str 543 sync/internal_api/public/base/unique_position.cc const size_t runs_until = str.find_first_not_of(rep_digit, i+4); str 549 sync/internal_api/public/base/unique_position.cc run_length = str.length() - i; str 553 sync/internal_api/public/base/unique_position.cc encode_high = static_cast<uint8>(str[runs_until]) > str 563 sync/internal_api/public/base/unique_position.cc const size_t len = std::min(static_cast<size_t>(8), str.length() - i); str 564 sync/internal_api/public/base/unique_position.cc output.append(str, i, len); str 574 sync/internal_api/public/base/unique_position.cc std::string UniquePosition::Uncompress(const std::string& str) { str 578 sync/internal_api/public/base/unique_position.cc for (i = 0; i + 8 <= str.length(); i += 8) { str 579 sync/internal_api/public/base/unique_position.cc if (IsRepeatedCharPrefix(str, i)) { str 581 sync/internal_api/public/base/unique_position.cc const char rep_digit = str[i]; str 582 sync/internal_api/public/base/unique_position.cc uint32 length = ReadEncodedRunLength(str, i+4); str 586 sync/internal_api/public/base/unique_position.cc output.append(str, i, 8); str 590 sync/internal_api/public/base/unique_position.cc output.append(str, i, std::string::npos); str 594 sync/internal_api/public/base/unique_position.cc bool UniquePosition::IsValidCompressed(const std::string& str) { str 595 sync/internal_api/public/base/unique_position.cc for (size_t i = 0; i + 8 <= str.length(); i += 8) { str 596 sync/internal_api/public/base/unique_position.cc if (IsRepeatedCharPrefix(str, i)) { str 597 sync/internal_api/public/base/unique_position.cc uint32 count = ReadEncodedRunLength(str, i+4); str 603 sync/internal_api/public/base/unique_position.cc if (str[i] == str[i+4]) { str 105 sync/internal_api/public/base/unique_position.h static std::string FindSmallerWithSuffix(const std::string& str, str 110 sync/internal_api/public/base/unique_position.h static std::string FindGreaterWithSuffix(const std::string& str, str 130 sync/internal_api/public/base/unique_position.h static bool IsValidCompressed(const std::string& str); str 22 sync/js/js_arg_list.cc std::string str; str 23 sync/js/js_arg_list.cc base::JSONWriter::Write(&Get(), &str); str 24 sync/js/js_arg_list.cc return str; str 23 sync/js/js_event_details.cc std::string str; str 24 sync/js/js_event_details.cc base::JSONWriter::Write(&Get(), &str); str 25 sync/js/js_event_details.cc return str; str 90 sync/notifier/invalidation_util.cc std::string str; str 91 sync/notifier/invalidation_util.cc base::JSONWriter::Write(value.get(), &str); str 92 sync/notifier/invalidation_util.cc return str; str 128 sync/notifier/invalidation_util.cc return ss.str(); str 114 sync/notifier/p2p_invalidator.cc bool P2PNotificationData::ResetFromString(const std::string& str) { str 115 sync/notifier/p2p_invalidator.cc scoped_ptr<base::Value> data_value(base::JSONReader::Read(str)); str 118 sync/notifier/p2p_invalidator.cc LOG(WARNING) << "Could not parse " << str << " as a dictionary"; str 78 sync/notifier/p2p_invalidator.h bool ResetFromString(const std::string& str); str 23 sync/protocol/proto_enum_conversions_unittest.cc const std::string& str = enum_string_fn(static_cast<T>(i)); str 24 sync/protocol/proto_enum_conversions_unittest.cc EXPECT_FALSE(str.empty()); str 63 sync/protocol/proto_value_conversions.cc base::StringValue* MakeStringValue(const std::string& str) { str 64 sync/protocol/proto_value_conversions.cc return new base::StringValue(str); str 124 sync/syncable/entry_kernel.cc base::StringValue* StringToValue(const std::string& str) { str 125 sync/syncable/entry_kernel.cc return new base::StringValue(str); str 25 sync/syncable/syncable_enum_conversions_unittest.cc const std::string& str = enum_string_fn(static_cast<T>(i)); str 26 sync/syncable/syncable_enum_conversions_unittest.cc EXPECT_FALSE(str.empty()); str 121 sync/tools/sync_client.cc std::string str; str 122 sync/tools/sync_client.cc base::JSONWriter::Write(&value, &str); str 123 sync/tools/sync_client.cc return str; str 51 sync/util/nigori.cc return stream_.str(); str 75 sync/util/nigori.cc SymmetricKey::HMAC_SHA1, salt_password.str(), str 134 sync/util/nigori.cc if (!encryptor.Encrypt(plaintext.str(), &ciphertext)) str 28 third_party/cacheinvalidation/overrides/google/cacheinvalidation/deps/gmock.h Proto* Deserialize(const string& str) const { str 30 third_party/cacheinvalidation/overrides/google/cacheinvalidation/deps/gmock.h if (proto->ParsePartialFromString(str)) { str 426 third_party/cld/base/logging.h CheckOpString(string* str) : str_(str) { } str 457 third_party/cld/base/logging.h return new string(ss.str(), ss.pcount()); str 1391 third_party/cld/base/logging.h inline NullStream& operator<<(NullStream &str, const T &value) { return str; } str 55 third_party/cld/encodings/compact_lang_det/cldutil_dbg.h void PrintText(FILE* f, Language cur_lang, const string& str); str 58 third_party/cld/encodings/compact_lang_det/cldutil_dbg.h void PrintTextSpeculative(FILE* f, Language cur_lang, const string& str); str 61 third_party/cld/encodings/compact_lang_det/cldutil_dbg.h void PrintSkippedText(FILE* f, const string& str); str 56 third_party/cld/encodings/compact_lang_det/cldutil_dbg_empty.cc void PrintText(FILE* f, Language cur_lang, const string& str) {}; str 59 third_party/cld/encodings/compact_lang_det/cldutil_dbg_empty.cc void PrintTextSpeculative(FILE* f, Language cur_lang, const string& str) {}; str 62 third_party/cld/encodings/compact_lang_det/cldutil_dbg_empty.cc void PrintSkippedText(FILE* f, const string& str) {}; str 1746 third_party/cld/encodings/compact_lang_det/compact_lang_det_impl.cc void MakeChar4(const char* str, char* norm) { str 1749 third_party/cld/encodings/compact_lang_det/compact_lang_det_impl.cc for (int i = 0; i < strlen(str); ++i) { str 1750 third_party/cld/encodings/compact_lang_det/compact_lang_det_impl.cc uint8 uc = static_cast<uint8>(str[i]); str 133 third_party/cld/encodings/compact_lang_det/win/cld_utf8statetable.cc const uint8* str, str 139 third_party/cld/encodings/compact_lang_det/win/cld_utf8statetable.cc const uint8* isrc = str; str 135 third_party/cld/encodings/compact_lang_det/win/cld_utf8statetable.h const uint8* str, str 160 third_party/expat/files/lib/xmlparse.c const XML_Char *str; str 2080 third_party/expat/files/lib/xmlparse.c if (tag->name.str == (XML_Char *)tag->buf) str 2081 third_party/expat/files/lib/xmlparse.c tag->name.str = (XML_Char *)temp; str 2437 third_party/expat/files/lib/xmlparse.c tag->name.str = (XML_Char *)tag->buf; str 2443 third_party/expat/files/lib/xmlparse.c startElementHandler(handlerArg, tag->name.str, str 2459 third_party/expat/files/lib/xmlparse.c name.str = poolStoreString(&tempPool, enc, rawName, str 2461 third_party/expat/files/lib/xmlparse.c if (!name.str) str 2469 third_party/expat/files/lib/xmlparse.c startElementHandler(handlerArg, name.str, (const XML_Char **)atts); str 2475 third_party/expat/files/lib/xmlparse.c endElementHandler(handlerArg, name.str); str 2522 third_party/expat/files/lib/xmlparse.c uri = (XML_Char *)tag->name.str + tag->name.uriLen; str 2532 third_party/expat/files/lib/xmlparse.c endElementHandler(handlerArg, tag->name.str); str 2716 third_party/expat/files/lib/xmlparse.c elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str,0); str 2718 third_party/expat/files/lib/xmlparse.c const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str); str 2998 third_party/expat/files/lib/xmlparse.c localPart = tagNamePtr->str; str 3004 third_party/expat/files/lib/xmlparse.c localPart = tagNamePtr->str; str 3028 third_party/expat/files/lib/xmlparse.c if (p->name.str == binding->uri) str 3029 third_party/expat/files/lib/xmlparse.c p->name.str = uri; str 3042 third_party/expat/files/lib/xmlparse.c tagNamePtr->str = binding->uri; str 6365 third_party/expat/files/lib/xmlparse.c XML_Char * str; str 6373 third_party/expat/files/lib/xmlparse.c str = (XML_Char *) (&ret[dtd->scaffCount]); str 6376 third_party/expat/files/lib/xmlparse.c build_node(parser, 0, ret, &cpos, &str); str 50 third_party/fontconfig/include/src/fcobjshash.h FcObjectTypeHash (register const char *str, register unsigned int len) str 81 third_party/fontconfig/include/src/fcobjshash.h return len + asso_values[(unsigned char)str[2]] + asso_values[(unsigned char)str[1]]; str 190 third_party/fontconfig/include/src/fcobjshash.h FcObjectTypeLookup (register const char *str, register unsigned int len) str 302 third_party/fontconfig/include/src/fcobjshash.h register int key = FcObjectTypeHash (str, len); str 311 third_party/fontconfig/include/src/fcobjshash.h if (*str == *s && !strcmp (str + 1, s + 1)) str 63 third_party/harfbuzz-ng/src/hb-buffer-serialize.cc hb_buffer_serialize_format_from_string (const char *str, int len) str 66 third_party/harfbuzz-ng/src/hb-buffer-serialize.cc return (hb_buffer_serialize_format_t) (hb_tag_from_string (str, len) & ~0x20202020); str 292 third_party/harfbuzz-ng/src/hb-buffer.h hb_buffer_serialize_format_from_string (const char *str, int len); str 70 third_party/harfbuzz-ng/src/hb-common.cc hb_tag_from_string (const char *str, int len) str 75 third_party/harfbuzz-ng/src/hb-common.cc if (!str || !len || !*str) str 80 third_party/harfbuzz-ng/src/hb-common.cc for (i = 0; i < (unsigned) len && str[i]; i++) str 81 third_party/harfbuzz-ng/src/hb-common.cc tag[i] = str[i]; str 128 third_party/harfbuzz-ng/src/hb-common.cc hb_direction_from_string (const char *str, int len) str 130 third_party/harfbuzz-ng/src/hb-common.cc if (unlikely (!str || !len || !*str)) str 136 third_party/harfbuzz-ng/src/hb-common.cc char c = TOLOWER (str[0]); str 293 third_party/harfbuzz-ng/src/hb-common.cc hb_language_from_string (const char *str, int len) str 297 third_party/harfbuzz-ng/src/hb-common.cc if (!str || !len || !*str) str 303 third_party/harfbuzz-ng/src/hb-common.cc str = (char *) memcpy (strbuf, str, len); str 307 third_party/harfbuzz-ng/src/hb-common.cc hb_language_item_t *item = lang_find_or_insert (str); str 101 third_party/harfbuzz-ng/src/hb-common.h hb_tag_from_string (const char *str, int len); str 120 third_party/harfbuzz-ng/src/hb-common.h hb_direction_from_string (const char *str, int len); str 139 third_party/harfbuzz-ng/src/hb-common.h hb_language_from_string (const char *str, int len); str 169 third_party/harfbuzz-ng/src/hb-shape.cc hb_feature_from_string (const char *str, int len, str 173 third_party/harfbuzz-ng/src/hb-shape.cc len = strlen (str); str 175 third_party/harfbuzz-ng/src/hb-shape.cc return parse_one_feature (&str, str + len, feature); str 52 third_party/harfbuzz-ng/src/hb-shape.h hb_feature_from_string (const char *str, int len, str 292 third_party/libaddressinput/chromium/cpp/src/util/md5.cc std::string MD5String(const std::string& str) { str 294 third_party/libaddressinput/chromium/cpp/src/util/md5.cc MD5Sum(str.data(), str.length(), &digest); str 68 third_party/libaddressinput/chromium/cpp/src/util/md5.h std::string MD5String(const std::string& str); str 120 third_party/libaddressinput/chromium/cpp/src/util/stl_util.h inline char* string_as_array(std::string* str) { str 122 third_party/libaddressinput/chromium/cpp/src/util/stl_util.h return str->empty() ? NULL : &*str->begin(); str 61 third_party/libaddressinput/chromium/cpp/src/util/string_util.cc void SplitString(const std::string& str, char s, std::vector<std::string>* r) { str 65 third_party/libaddressinput/chromium/cpp/src/util/string_util.cc size_t c = str.size(); str 67 third_party/libaddressinput/chromium/cpp/src/util/string_util.cc if (i == c || str[i] == s) { str 68 third_party/libaddressinput/chromium/cpp/src/util/string_util.cc std::string tmp(str, last, i - last); str 52 third_party/libaddressinput/chromium/cpp/src/util/string_util.h void SplitString(const std::string& str, char c, std::vector<std::string>* r); str 47 third_party/libaddressinput/chromium/cpp/test/countryinfo_example_addresses_test.cc return oss.str() == ep; str 339 third_party/libevent/evdns.c static int strtoint(const char *const str); str 2629 third_party/libevent/evdns.c strtoint(const char *const str) { str 2631 third_party/libevent/evdns.c const int r = strtol(str, &endptr, 10); str 2638 third_party/libevent/evdns.c strtoint_clipped(const char *const str, int min, int max) str 2640 third_party/libevent/evdns.c int r = strtoint(str); str 119 third_party/libjingle/overrides/talk/base/logging.cc return tmp.str(); str 153 third_party/libjingle/overrides/talk/base/logging.cc const std::string& str = print_stream_.str(); str 155 third_party/libjingle/overrides/talk/base/logging.cc LOG_LAZY_STREAM_DIRECT(file_name_, line_, severity_) << str; str 157 third_party/libjingle/overrides/talk/base/logging.cc g_logging_delegate_function(str); str 230 third_party/libjpeg/jerror.h #define ERREXITS(cinfo,code,str) \ str 232 third_party/libjpeg/jerror.h strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ str 286 third_party/libjpeg/jerror.h #define TRACEMSS(cinfo,lvl,code,str) \ str 288 third_party/libjpeg/jerror.h strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ str 34 third_party/libpng/pngrutil.c wchar_t *str, *end; str 37 third_party/libpng/pngrutil.c str = (wchar_t *)png_malloc(png_ptr, len * png_sizeof(wchar_t)); str 38 third_party/libpng/pngrutil.c if ( NULL != str ) str 40 third_party/libpng/pngrutil.c MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len); str 41 third_party/libpng/pngrutil.c result = wcstod(str, &end); str 44 third_party/libpng/pngrutil.c png_free(png_ptr, str); str 2035 third_party/libusb/src/libusb/core.c enum libusb_log_level level, const char * str) str 2041 third_party/libusb/src/libusb/core.c MultiByteToWideChar(CP_UTF8, 0, str, -1, wbuf, sizeof(wbuf)); str 2051 third_party/libusb/src/libusb/core.c __android_log_write(priority, "libusb", str); str 2060 third_party/libusb/src/libusb/core.c syslog(syslog_level, "%s", str); str 2063 third_party/libusb/src/libusb/core.c fputs(str, stderr); str 2066 third_party/libusb/src/libusb/core.c fputs(str, stderr); str 51 third_party/libusb/src/libusb/os/windows_common.h #define safe_strlen(str) ((str==NULL)?0:strlen(str)) str 54 third_party/libusb/src/libusb/os/windows_common.h #define safe_tcslen(str) ((str==NULL)?0:_tcslen(str)) str 56 third_party/libusb/src/libusb/os/windows_common.h #define wchar_to_utf8_ms(wstr, str, strlen) WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, strlen, NULL, NULL) str 452 third_party/libusb/src/libusb/os/windows_usb.c char* str; str 515 third_party/libusb/src/libusb/os/windows_usb.c safe_free(htab_table[i].str); str 530 third_party/libusb/src/libusb/os/windows_usb.c static unsigned long htab_hash(char* str) str 536 third_party/libusb/src/libusb/os/windows_usb.c char* sz = str; str 538 third_party/libusb/src/libusb/os/windows_usb.c if (str == NULL) str 557 third_party/libusb/src/libusb/os/windows_usb.c && (safe_strcmp(str, htab_table[idx].str) == 0) ) { str 561 third_party/libusb/src/libusb/os/windows_usb.c usbi_dbg("hash collision ('%s' vs '%s')", str, htab_table[idx].str); str 581 third_party/libusb/src/libusb/os/windows_usb.c && (safe_strcmp(str, htab_table[idx].str) == 0) ) { str 602 third_party/libusb/src/libusb/os/windows_usb.c safe_free(htab_table[idx].str); str 604 third_party/libusb/src/libusb/os/windows_usb.c htab_table[idx].str = (char*) malloc(safe_strlen(str)+1); str 605 third_party/libusb/src/libusb/os/windows_usb.c if (htab_table[idx].str == NULL) { str 610 third_party/libusb/src/libusb/os/windows_usb.c memcpy(htab_table[idx].str, str, safe_strlen(str)+1); str 3156 third_party/libusb/src/libusb/os/windows_usb.c static int _hid_wcslen(WCHAR *str) str 3159 third_party/libusb/src/libusb/os/windows_usb.c while (str[i] && (str[i] != 0x409)) { str 2202 third_party/libxml/src/HTMLparser.c static int areBlanks(htmlParserCtxtPtr ctxt, const xmlChar *str, int len) { str 2209 third_party/libxml/src/HTMLparser.c if (!(IS_BLANK_CH(str[j]))) return(0); str 2633 third_party/libxml/src/HTMLparser.c htmlParseEntityRef(htmlParserCtxtPtr ctxt, const xmlChar **str) { str 2637 third_party/libxml/src/HTMLparser.c if (str != NULL) *str = NULL; str 2649 third_party/libxml/src/HTMLparser.c if (str != NULL) str 2650 third_party/libxml/src/HTMLparser.c *str = name; str 2662 third_party/libxml/src/HTMLparser.c if (str != NULL) str 2663 third_party/libxml/src/HTMLparser.c *str = name; str 6386 third_party/libxml/src/HTMLparser.c #define DICT_FREE(str) \ str 6387 third_party/libxml/src/HTMLparser.c if ((str) && ((!dict) || \ str 6388 third_party/libxml/src/HTMLparser.c (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ str 6389 third_party/libxml/src/HTMLparser.c xmlFree((char *)(str)); str 1809 third_party/libxml/src/SAX2.c xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) { str 1833 third_party/libxml/src/SAX2.c xmlChar cur = str[len]; str 1839 third_party/libxml/src/SAX2.c memcpy(tmp, str, len); str 1843 third_party/libxml/src/SAX2.c ((cur == '<') && (str[len + 1] != '!')))) { str 1844 third_party/libxml/src/SAX2.c intern = xmlDictLookup(ctxt->dict, str, len); str 1845 third_party/libxml/src/SAX2.c } else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') && str 1846 third_party/libxml/src/SAX2.c (str[len + 1] != '!')) { str 1850 third_party/libxml/src/SAX2.c if (!IS_BLANK_CH(str[i])) goto skip; str 1852 third_party/libxml/src/SAX2.c intern = xmlDictLookup(ctxt->dict, str, len); str 1860 third_party/libxml/src/SAX2.c ret->content = xmlStrndup(str, len); str 1889 third_party/libxml/src/SAX2.c xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, str 1894 third_party/libxml/src/SAX2.c in = str; str 1901 third_party/libxml/src/SAX2.c ret = xmlStringLenDecodeEntities(ctxt, str, end - str, str 230 third_party/libxml/src/debugXML.c xmlCtxtCheckString(xmlDebugCtxtPtr ctxt, const xmlChar * str) str 232 third_party/libxml/src/debugXML.c if (str == NULL) return; str 234 third_party/libxml/src/debugXML.c if (!xmlCheckUTF8(str)) { str 236 third_party/libxml/src/debugXML.c "String is not UTF-8 %s", (const char *) str); str 420 third_party/libxml/src/debugXML.c xmlCtxtDumpString(xmlDebugCtxtPtr ctxt, const xmlChar * str) str 428 third_party/libxml/src/debugXML.c if (str == NULL) { str 433 third_party/libxml/src/debugXML.c if (str[i] == 0) str 435 third_party/libxml/src/debugXML.c else if (IS_BLANK_CH(str[i])) str 437 third_party/libxml/src/debugXML.c else if (str[i] >= 0x80) str 438 third_party/libxml/src/debugXML.c fprintf(ctxt->output, "#%X", str[i]); str 440 third_party/libxml/src/debugXML.c fputc(str[i], ctxt->output); str 1345 third_party/libxml/src/debugXML.c xmlDebugDumpString(FILE * output, const xmlChar * str) str 1351 third_party/libxml/src/debugXML.c if (str == NULL) { str 1356 third_party/libxml/src/debugXML.c if (str[i] == 0) str 1358 third_party/libxml/src/debugXML.c else if (IS_BLANK_CH(str[i])) str 1360 third_party/libxml/src/debugXML.c else if (str[i] >= 0x80) str 1361 third_party/libxml/src/debugXML.c fprintf(output, "#%X", str[i]); str 1363 third_party/libxml/src/debugXML.c fputc(str[i], output); str 1064 third_party/libxml/src/dict.c xmlDictOwns(xmlDictPtr dict, const xmlChar *str) { str 1067 third_party/libxml/src/dict.c if ((dict == NULL) || (str == NULL)) str 1071 third_party/libxml/src/dict.c if ((str >= &pool->array[0]) && (str <= pool->free)) str 1076 third_party/libxml/src/dict.c return(xmlDictOwns(dict->subdict, str)); str 23 third_party/libxml/src/error.c #define XML_GET_VAR_STR(msg, str) { \ str 29 third_party/libxml/src/error.c str = (char *) xmlMalloc(150); \ str 30 third_party/libxml/src/error.c if (str != NULL) { \ str 36 third_party/libxml/src/error.c chars = vsnprintf(str, size, msg, ap); \ str 49 third_party/libxml/src/error.c if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\ str 52 third_party/libxml/src/error.c str = larger; \ str 243 third_party/libxml/src/error.c xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str, str 380 third_party/libxml/src/error.c if (str != NULL) { str 382 third_party/libxml/src/error.c len = xmlStrlen((const xmlChar *)str); str 383 third_party/libxml/src/error.c if ((len > 0) && (str[len - 1] != '\n')) str 384 third_party/libxml/src/error.c channel(data, "%s\n", str); str 386 third_party/libxml/src/error.c channel(data, "%s", str); str 450 third_party/libxml/src/error.c char *str = NULL; str 490 third_party/libxml/src/error.c str = (char *) xmlStrdup(BAD_CAST "No error message provided"); str 492 third_party/libxml/src/error.c XML_GET_VAR_STR(msg, str); str 537 third_party/libxml/src/error.c to->message = str; str 624 third_party/libxml/src/error.c xmlReportError(to, ctxt, str, NULL, NULL); str 627 third_party/libxml/src/error.c xmlReportError(to, ctxt, str, channel, data); str 629 third_party/libxml/src/error.c channel(data, "%s", str); str 677 third_party/libxml/src/error.c char * str; str 690 third_party/libxml/src/error.c XML_GET_VAR_STR(msg, str); str 691 third_party/libxml/src/error.c xmlGenericError(xmlGenericErrorContext, "%s", str); str 692 third_party/libxml/src/error.c if (str != NULL) str 693 third_party/libxml/src/error.c xmlFree(str); str 720 third_party/libxml/src/error.c char * str; str 733 third_party/libxml/src/error.c XML_GET_VAR_STR(msg, str); str 734 third_party/libxml/src/error.c xmlGenericError(xmlGenericErrorContext, "%s", str); str 735 third_party/libxml/src/error.c if (str != NULL) str 736 third_party/libxml/src/error.c xmlFree(str); str 768 third_party/libxml/src/error.c char * str; str 788 third_party/libxml/src/error.c XML_GET_VAR_STR(msg, str); str 789 third_party/libxml/src/error.c xmlGenericError(xmlGenericErrorContext, "%s", str); str 790 third_party/libxml/src/error.c if (str != NULL) str 791 third_party/libxml/src/error.c xmlFree(str); str 812 third_party/libxml/src/error.c char * str; str 824 third_party/libxml/src/error.c XML_GET_VAR_STR(msg, str); str 825 third_party/libxml/src/error.c xmlGenericError(xmlGenericErrorContext, "%s", str); str 826 third_party/libxml/src/error.c if (str != NULL) str 827 third_party/libxml/src/error.c xmlFree(str); str 102 third_party/libxml/src/include/libxml/HTMLparser.h const xmlChar **str); str 30 third_party/libxml/src/include/libxml/debugXML.h const xmlChar *str); str 56 third_party/libxml/src/include/libxml/dict.h const xmlChar *str); str 52 third_party/libxml/src/include/libxml/parser.h typedef void (* xmlParserInputDeallocate)(xmlChar *str); str 490 third_party/libxml/src/include/libxml/parserInternals.h const xmlChar *str, str 497 third_party/libxml/src/include/libxml/parserInternals.h const xmlChar *str, str 676 third_party/libxml/src/include/libxml/tree.h const xmlChar *str, str 680 third_party/libxml/src/include/libxml/tree.h const xmlChar *str, str 684 third_party/libxml/src/include/libxml/tree.h const xmlChar *str); str 687 third_party/libxml/src/include/libxml/tree.h const char *str); str 61 third_party/libxml/src/include/libxml/uri.h xmlParseURI (const char *str); str 63 third_party/libxml/src/include/libxml/uri.h xmlParseURIRaw (const char *str, str 67 third_party/libxml/src/include/libxml/uri.h const char *str); str 74 third_party/libxml/src/include/libxml/uri.h xmlURIEscapeStr (const xmlChar *str, str 77 third_party/libxml/src/include/libxml/uri.h xmlURIUnescapeString (const char *str, str 83 third_party/libxml/src/include/libxml/uri.h xmlURIEscape (const xmlChar *str); str 254 third_party/libxml/src/include/libxml/xmlIO.h const char *str); str 257 third_party/libxml/src/include/libxml/xmlIO.h const xmlChar *str, str 87 third_party/libxml/src/include/libxml/xmlmemory.h typedef char *(XMLCALL *xmlStrdupFunc)(const char *str); str 159 third_party/libxml/src/include/libxml/xmlmemory.h xmlMemoryStrdup (const char *str); str 167 third_party/libxml/src/include/libxml/xmlmemory.h xmlMemStrdupLoc (const char *str, const char *file, int line); str 208 third_party/libxml/src/include/libxml/xmlmemory.h #define xmlMemStrdup(str) xmlMemStrdupLoc((str), __FILE__, __LINE__) str 182 third_party/libxml/src/include/libxml/xmlreader.h const xmlChar *str); str 202 third_party/libxml/src/include/libxml/xmlregexp.h const xmlChar *str, str 51 third_party/libxml/src/include/libxml/xmlstring.h xmlStrsub (const xmlChar *str, str 55 third_party/libxml/src/include/libxml/xmlstring.h xmlStrchr (const xmlChar *str, str 58 third_party/libxml/src/include/libxml/xmlstring.h xmlStrstr (const xmlChar *str, str 61 third_party/libxml/src/include/libxml/xmlstring.h xmlStrcasestr (const xmlChar *str, str 83 third_party/libxml/src/include/libxml/xmlstring.h const xmlChar *str); str 85 third_party/libxml/src/include/libxml/xmlstring.h xmlStrlen (const xmlChar *str); str 472 third_party/libxml/src/include/libxml/xmlwriter.h const xmlChar * str); str 508 third_party/libxml/src/include/libxml/xpath.h xmlXPathEval (const xmlChar *str, str 511 third_party/libxml/src/include/libxml/xpath.h xmlXPathEvalExpression (const xmlChar *str, str 520 third_party/libxml/src/include/libxml/xpath.h xmlXPathCompile (const xmlChar *str); str 523 third_party/libxml/src/include/libxml/xpath.h const xmlChar *str); str 157 third_party/libxml/src/include/libxml/xpathInternals.h #define xmlXPathReturnString(ctxt, str) \ str 158 third_party/libxml/src/include/libxml/xpathInternals.h valuePush((ctxt), xmlXPathWrapString(str)) str 473 third_party/libxml/src/include/libxml/xpathInternals.h xmlXPathNewParserContext (const xmlChar *str, str 527 third_party/libxml/src/include/libxml/xpathInternals.h xmlXPathStringEvalNumber (const xmlChar *str); str 100 third_party/libxml/src/include/libxml/xpointer.h xmlXPtrEval (const xmlChar *str, str 206 third_party/libxml/src/parser.c const xmlChar **str); str 1369 third_party/libxml/src/parser.c const xmlChar ** str); str 2147 third_party/libxml/src/parser.c xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) { str 2153 third_party/libxml/src/parser.c if ((str == NULL) || (*str == NULL)) return(0); str 2154 third_party/libxml/src/parser.c ptr = *str; str 2202 third_party/libxml/src/parser.c *str = ptr; str 2230 third_party/libxml/src/parser.c static void deallocblankswrapper (xmlChar *str) {xmlFree(str);} str 2502 third_party/libxml/src/parser.c xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, str 2514 third_party/libxml/src/parser.c if ((ctxt == NULL) || (str == NULL) || (len < 0)) str 2516 third_party/libxml/src/parser.c last = str + len; str 2536 third_party/libxml/src/parser.c if (str < last) str 2537 third_party/libxml/src/parser.c c = CUR_SCHAR(str, l); str 2544 third_party/libxml/src/parser.c if ((c == '&') && (str[1] == '#')) { str 2545 third_party/libxml/src/parser.c int val = xmlParseStringCharRef(ctxt, &str); str 2556 third_party/libxml/src/parser.c str); str 2557 third_party/libxml/src/parser.c ent = xmlParseStringEntityRef(ctxt, &str); str 2609 third_party/libxml/src/parser.c "String decoding PE Reference: %.30s\n", str); str 2610 third_party/libxml/src/parser.c ent = xmlParseStringPEReference(ctxt, &str); str 2640 third_party/libxml/src/parser.c str += l; str 2645 third_party/libxml/src/parser.c if (str < last) str 2646 third_party/libxml/src/parser.c c = CUR_SCHAR(str, l); str 2682 third_party/libxml/src/parser.c xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what, str 2684 third_party/libxml/src/parser.c if ((ctxt == NULL) || (str == NULL)) return(NULL); str 2685 third_party/libxml/src/parser.c return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what, str 2707 third_party/libxml/src/parser.c static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, str 2731 third_party/libxml/src/parser.c if (!(IS_BLANK_CH(str[i]))) return(0); str 3357 third_party/libxml/src/parser.c xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) { str 3359 third_party/libxml/src/parser.c const xmlChar *cur = *str; str 3411 third_party/libxml/src/parser.c *str = cur; str 3415 third_party/libxml/src/parser.c *str = cur; str 7378 third_party/libxml/src/parser.c xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) { str 7384 third_party/libxml/src/parser.c if ((str == NULL) || (*str == NULL)) str 7386 third_party/libxml/src/parser.c ptr = *str; str 7396 third_party/libxml/src/parser.c *str = ptr; str 7402 third_party/libxml/src/parser.c *str = ptr; str 7415 third_party/libxml/src/parser.c *str = ptr; str 7537 third_party/libxml/src/parser.c *str = ptr; str 7795 third_party/libxml/src/parser.c xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) { str 7801 third_party/libxml/src/parser.c if ((str == NULL) || (*str == NULL)) return(NULL); str 7802 third_party/libxml/src/parser.c ptr = *str; str 7811 third_party/libxml/src/parser.c *str = ptr; str 7818 third_party/libxml/src/parser.c *str = ptr; str 7877 third_party/libxml/src/parser.c *str = ptr; str 14254 third_party/libxml/src/parser.c #define DICT_FREE(str) \ str 14255 third_party/libxml/src/parser.c if ((str) && ((!dict) || \ str 14256 third_party/libxml/src/parser.c (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ str 14257 third_party/libxml/src/parser.c xmlFree((char *)(str)); str 166 third_party/libxml/src/parserInternals.c xmlErrInternal(xmlParserCtxtPtr ctxt, const char *msg, const xmlChar * str) str 175 third_party/libxml/src/parserInternals.c XML_ERR_FATAL, NULL, 0, (const char *) str, NULL, NULL, str 176 third_party/libxml/src/parserInternals.c 0, 0, msg, str); str 2398 third_party/libxml/src/relaxng.c const xmlChar * str); str 3447 third_party/libxml/src/relaxng.c xmlRelaxNGIsBlank(xmlChar * str) str 3449 third_party/libxml/src/relaxng.c if (str == NULL) str 3451 third_party/libxml/src/relaxng.c while (*str != 0) { str 3452 third_party/libxml/src/relaxng.c if (!(IS_BLANK_CH(*str))) str 3454 third_party/libxml/src/relaxng.c str++; str 8531 third_party/libxml/src/relaxng.c xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str) str 8537 third_party/libxml/src/relaxng.c if (str == NULL) str 8539 third_party/libxml/src/relaxng.c tmp = str; str 8542 third_party/libxml/src/relaxng.c len = tmp - str; str 8550 third_party/libxml/src/relaxng.c while (IS_BLANK_CH(*str)) str 8551 third_party/libxml/src/relaxng.c str++; str 8552 third_party/libxml/src/relaxng.c while (*str != 0) { str 8553 third_party/libxml/src/relaxng.c if (IS_BLANK_CH(*str)) { str 8554 third_party/libxml/src/relaxng.c while (IS_BLANK_CH(*str)) str 8555 third_party/libxml/src/relaxng.c str++; str 8556 third_party/libxml/src/relaxng.c if (*str == 0) str 8560 third_party/libxml/src/relaxng.c *p++ = *str++; str 355 third_party/libxml/src/runtest.c const char *str; str 377 third_party/libxml/src/runtest.c str = err->message; str 492 third_party/libxml/src/runtest.c if (str != NULL) { str 494 third_party/libxml/src/runtest.c len = xmlStrlen((const xmlChar *)str); str 495 third_party/libxml/src/runtest.c if ((len > 0) && (str[len - 1] != '\n')) str 496 third_party/libxml/src/runtest.c channel(data, "%s\n", str); str 498 third_party/libxml/src/runtest.c channel(data, "%s", str); str 2275 third_party/libxml/src/runtest.c testXPath(const char *str, int xptr, int expr) { str 2283 third_party/libxml/src/runtest.c res = xmlXPtrEval(BAD_CAST str, ctxt); str 2289 third_party/libxml/src/runtest.c res = xmlXPathEvalExpression(BAD_CAST str, ctxt); str 2294 third_party/libxml/src/runtest.c comp = xmlXPathCompile(BAD_CAST str); str 2567 third_party/libxml/src/runtest.c handleURI(const char *str, const char *base, FILE *o) { str 2575 third_party/libxml/src/runtest.c ret = xmlParseURIReference(uri, str); str 2577 third_party/libxml/src/runtest.c fprintf(o, "%s : error %d\n", str, ret); str 2584 third_party/libxml/src/runtest.c res = xmlBuildURI((xmlChar *)str, (xmlChar *) base); str 2613 third_party/libxml/src/runtest.c char str[1024]; str 2642 third_party/libxml/src/runtest.c if (fgets (&str[0], sizeof (str) - 1, f) == NULL) str 2648 third_party/libxml/src/runtest.c i = strlen(str); str 2650 third_party/libxml/src/runtest.c ((str[i - 1] == '\n') || (str[i - 1] == '\r') || str 2651 third_party/libxml/src/runtest.c (str[i - 1] == ' ') || (str[i - 1] == '\t'))) { str 2653 third_party/libxml/src/runtest.c str[i] = 0; str 2656 third_party/libxml/src/runtest.c handleURI(str, base, o); str 3415 third_party/libxml/src/runtest.c char str[1024]; str 3461 third_party/libxml/src/runtest.c if (fgets (&str[0], sizeof (str) - 1, f) == NULL) str 3467 third_party/libxml/src/runtest.c i = strlen(str); str 3469 third_party/libxml/src/runtest.c ((str[i - 1] == '\n') || (str[i - 1] == '\r') || str 3470 third_party/libxml/src/runtest.c (str[i - 1] == ' ') || (str[i - 1] == '\t'))) { str 3472 third_party/libxml/src/runtest.c str[i] = 0; str 3492 third_party/libxml/src/runtest.c patternc = xmlPatterncompile((const xmlChar *) str, doc->dict, str 3496 third_party/libxml/src/runtest.c "Pattern %s failed to compile\n", str); str 3515 third_party/libxml/src/runtest.c patternNode(o, reader, str, patternc, patstream); str 3657 third_party/libxml/src/runtest.c parse_list(xmlChar *str) { str 3663 third_party/libxml/src/runtest.c if(str == NULL) { str 3667 third_party/libxml/src/runtest.c len = xmlStrlen(str); str 3668 third_party/libxml/src/runtest.c if((str[0] == '\'') && (str[len - 1] == '\'')) { str 3669 third_party/libxml/src/runtest.c str[len - 1] = '\0'; str 3670 third_party/libxml/src/runtest.c str++; str 3683 third_party/libxml/src/runtest.c while(*str != '\0') { str 3690 third_party/libxml/src/runtest.c (*out++) = str; str 3691 third_party/libxml/src/runtest.c while(*str != ',' && *str != '\0') ++str; str 3692 third_party/libxml/src/runtest.c if(*str == ',') *(str++) = '\0'; str 51 third_party/libxml/src/testC14N.c static xmlChar **parse_list(xmlChar *str); str 191 third_party/libxml/src/testC14N.c parse_list(xmlChar *str) { str 197 third_party/libxml/src/testC14N.c if(str == NULL) { str 201 third_party/libxml/src/testC14N.c len = xmlStrlen(str); str 202 third_party/libxml/src/testC14N.c if((str[0] == '\'') && (str[len - 1] == '\'')) { str 203 third_party/libxml/src/testC14N.c str[len - 1] = '\0'; str 204 third_party/libxml/src/testC14N.c str++; str 217 third_party/libxml/src/testC14N.c while(*str != '\0') { str 224 third_party/libxml/src/testC14N.c (*out++) = str; str 225 third_party/libxml/src/testC14N.c while(*str != ',' && *str != '\0') ++str; str 226 third_party/libxml/src/testC14N.c if(*str == ',') *(str++) = '\0'; str 114 third_party/libxml/src/testRegexp.c char *str = &expression[2]; str 123 third_party/libxml/src/testRegexp.c printf("Expression: %s\n", str) ; str 124 third_party/libxml/src/testRegexp.c expr = xmlExpParse(ctxt, str); str 23 third_party/libxml/src/testURI.c static void handleURI(const char *str) { str 31 third_party/libxml/src/testURI.c ret = xmlParseURIReference(uri, str); str 33 third_party/libxml/src/testURI.c printf("%s : error %d\n", str, ret); str 60 third_party/libxml/src/testURI.c res = xmlBuildURI((xmlChar *)str, (xmlChar *) base); str 95 third_party/libxml/src/testURI.c char str[1024]; str 101 third_party/libxml/src/testURI.c if (fgets (&str[0], sizeof (str) - 1, stdin) == NULL) str 107 third_party/libxml/src/testURI.c i = strlen(str); str 109 third_party/libxml/src/testURI.c ((str[i - 1] == '\n') || (str[i - 1] == '\r') || str 110 third_party/libxml/src/testURI.c (str[i - 1] == ' ') || (str[i - 1] == '\t'))) { str 112 third_party/libxml/src/testURI.c str[i] = 0; str 114 third_party/libxml/src/testURI.c handleURI(str); str 79 third_party/libxml/src/testXPath.c testXPath(const char *str) { str 86 third_party/libxml/src/testXPath.c res = xmlXPtrEval(BAD_CAST str, ctxt); str 92 third_party/libxml/src/testXPath.c res = xmlXPathEvalExpression(BAD_CAST str, ctxt); str 97 third_party/libxml/src/testXPath.c comp = xmlXPathCompile(BAD_CAST str); str 2433 third_party/libxml/src/testapi.c xmlChar ** str; /* location to store the entity name */ str 2440 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr_ptr(n_str, 1); str 2442 third_party/libxml/src/testapi.c ret_val = htmlParseEntityRef(ctxt, (const xmlChar **)str); str 2446 third_party/libxml/src/testapi.c des_const_xmlChar_ptr_ptr(n_str, (const xmlChar **)str, 1); str 7389 third_party/libxml/src/testapi.c xmlChar * str; /* the string */ str 7396 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 7398 third_party/libxml/src/testapi.c xmlDebugDumpString(output, (const xmlChar *)str); str 7401 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 8308 third_party/libxml/src/testapi.c xmlChar * str; /* the string */ str 8315 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 8317 third_party/libxml/src/testapi.c ret_val = xmlDictOwns(dict, (const xmlChar *)str); str 8321 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 16515 third_party/libxml/src/testapi.c xmlChar * str; /* the input string */ str 16534 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 16540 third_party/libxml/src/testapi.c ret_val = xmlStringDecodeEntities(ctxt, (const xmlChar *)str, what, end, end2, end3); str 16544 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 16582 third_party/libxml/src/testapi.c xmlChar * str; /* the input string */ str 16604 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 16611 third_party/libxml/src/testapi.c ret_val = xmlStringLenDecodeEntities(ctxt, (const xmlChar *)str, len, what, end, end2, end3); str 16615 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 18425 third_party/libxml/src/testapi.c xmlChar * str; /* the #xmlChar string */ str 18435 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 18438 third_party/libxml/src/testapi.c ret_val = xmlBufferAdd(buf, (const xmlChar *)str, len); str 18442 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 18471 third_party/libxml/src/testapi.c xmlChar * str; /* the #xmlChar string */ str 18481 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 18484 third_party/libxml/src/testapi.c ret_val = xmlBufferAddHead(buf, (const xmlChar *)str, len); str 18488 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 18517 third_party/libxml/src/testapi.c char * str; /* the C char string */ str 18524 third_party/libxml/src/testapi.c str = gen_const_char_ptr(n_str, 1); str 18526 third_party/libxml/src/testapi.c ret_val = xmlBufferCCat(buf, (const char *)str); str 18530 third_party/libxml/src/testapi.c des_const_char_ptr(n_str, (const char *)str, 1); str 18556 third_party/libxml/src/testapi.c xmlChar * str; /* the #xmlChar string */ str 18563 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 18565 third_party/libxml/src/testapi.c ret_val = xmlBufferCat(buf, (const xmlChar *)str); str 18569 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 24351 third_party/libxml/src/testapi.c char * str; /* the string to analyze */ str 24358 third_party/libxml/src/testapi.c str = gen_const_char_ptr(n_str, 1); str 24360 third_party/libxml/src/testapi.c ret_val = xmlParseURIReference(uri, (const char *)str); str 24364 third_party/libxml/src/testapi.c des_const_char_ptr(n_str, (const char *)str, 1); str 24489 third_party/libxml/src/testapi.c xmlChar * str; /* the string of the URI to escape */ str 24494 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 24496 third_party/libxml/src/testapi.c ret_val = xmlURIEscape((const xmlChar *)str); str 24499 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 24521 third_party/libxml/src/testapi.c xmlChar * str; /* string to escape */ str 24529 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 24532 third_party/libxml/src/testapi.c ret_val = xmlURIEscapeStr((const xmlChar *)str, (const xmlChar *)list); str 24535 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 28470 third_party/libxml/src/testapi.c char * str; /* a zero terminated C string */ str 28477 third_party/libxml/src/testapi.c str = gen_const_char_ptr(n_str, 1); str 28479 third_party/libxml/src/testapi.c ret_val = xmlOutputBufferWriteString(out, (const char *)str); str 28483 third_party/libxml/src/testapi.c des_const_char_ptr(n_str, (const char *)str, 1); str 30604 third_party/libxml/src/testapi.c xmlChar * str; /* the string to intern. */ str 30611 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 30613 third_party/libxml/src/testapi.c ret_val = xmlTextReaderConstString(reader, (const xmlChar *)str); str 30617 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 36118 third_party/libxml/src/testapi.c xmlChar * str; /* the second xmlChar * */ str 36127 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 2); str 36129 third_party/libxml/src/testapi.c ret_val = xmlStrQEqual((const xmlChar *)pref, (const xmlChar *)name, (const xmlChar *)str); str 36134 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 2); str 36209 third_party/libxml/src/testapi.c xmlChar * str; /* the xmlChar * array (haystack) */ str 36217 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 36220 third_party/libxml/src/testapi.c ret_val = xmlStrcasestr((const xmlChar *)str, (const xmlChar *)val); str 36223 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 36248 third_party/libxml/src/testapi.c xmlChar * str; /* the xmlChar * array */ str 36256 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 36259 third_party/libxml/src/testapi.c ret_val = xmlStrchr((const xmlChar *)str, val); str 36262 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 36358 third_party/libxml/src/testapi.c xmlChar * str; /* the xmlChar * array */ str 36363 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 36365 third_party/libxml/src/testapi.c ret_val = xmlStrlen((const xmlChar *)str); str 36368 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 36567 third_party/libxml/src/testapi.c xmlChar * str; /* the xmlChar * array (haystack) */ str 36575 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 36578 third_party/libxml/src/testapi.c ret_val = xmlStrstr((const xmlChar *)str, (const xmlChar *)val); str 36581 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 36606 third_party/libxml/src/testapi.c xmlChar * str; /* the xmlChar * array (haystack) */ str 36617 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 36621 third_party/libxml/src/testapi.c ret_val = xmlStrsub((const xmlChar *)str, start, len); str 36624 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 43488 third_party/libxml/src/testapi.c xmlChar * str; /* the xmlChar string */ str 43495 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 1); str 43497 third_party/libxml/src/testapi.c ret_val = xmlTextWriterSetIndentString(writer, (const xmlChar *)str); str 43501 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); str 46272 third_party/libxml/src/testapi.c xmlChar * str; /* the XPath expression */ str 46280 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 46283 third_party/libxml/src/testapi.c ret_val = xmlXPathEval((const xmlChar *)str, ctx); str 46286 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 46313 third_party/libxml/src/testapi.c xmlChar * str; /* the XPath expression */ str 46321 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 46324 third_party/libxml/src/testapi.c ret_val = xmlXPathEvalExpression((const xmlChar *)str, ctxt); str 46327 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 50062 third_party/libxml/src/testapi.c xmlChar * str; /* A string to scan */ str 50067 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 50069 third_party/libxml/src/testapi.c ret_val = xmlXPathStringEvalNumber((const xmlChar *)str); str 50072 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 50955 third_party/libxml/src/testapi.c xmlChar * str; /* the XPointer expression */ str 50963 third_party/libxml/src/testapi.c str = gen_const_xmlChar_ptr(n_str, 0); str 50966 third_party/libxml/src/testapi.c ret_val = xmlXPtrEval((const xmlChar *)str, ctx); str 50969 third_party/libxml/src/testapi.c des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); str 134 third_party/libxml/src/tree.c #define IS_STR_XML(str) ((str != NULL) && (str[0] == 'x') && \ str 135 third_party/libxml/src/tree.c (str[1] == 'm') && (str[2] == 'l') && (str[3] == 0)) str 1027 third_party/libxml/src/tree.c #define DICT_FREE(str) \ str 1028 third_party/libxml/src/tree.c if ((str) && ((!dict) || \ str 1029 third_party/libxml/src/tree.c (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ str 1030 third_party/libxml/src/tree.c xmlFree((char *)(str)); str 1040 third_party/libxml/src/tree.c #define DICT_COPY(str, cpy) \ str 1041 third_party/libxml/src/tree.c if (str) { \ str 1043 third_party/libxml/src/tree.c if (xmlDictOwns(dict, (const xmlChar *)(str))) \ str 1044 third_party/libxml/src/tree.c cpy = (xmlChar *) (str); \ str 1046 third_party/libxml/src/tree.c cpy = (xmlChar *) xmlDictLookup((dict), (const xmlChar *)(str), -1); \ str 1048 third_party/libxml/src/tree.c cpy = xmlStrdup((const xmlChar *)(str)); } str 1057 third_party/libxml/src/tree.c #define DICT_CONST_COPY(str, cpy) \ str 1058 third_party/libxml/src/tree.c if (str) { \ str 1060 third_party/libxml/src/tree.c if (xmlDictOwns(dict, (const xmlChar *)(str))) \ str 1061 third_party/libxml/src/tree.c cpy = (const xmlChar *) (str); \ str 1063 third_party/libxml/src/tree.c cpy = xmlDictLookup((dict), (const xmlChar *)(str), -1); \ str 1065 third_party/libxml/src/tree.c cpy = (const xmlChar *) xmlStrdup((const xmlChar *)(str)); } str 7288 third_party/libxml/src/tree.c xmlBufferAdd(xmlBufferPtr buf, const xmlChar *str, int len) { str 7291 third_party/libxml/src/tree.c if ((str == NULL) || (buf == NULL)) { str 7305 third_party/libxml/src/tree.c len = xmlStrlen(str); str 7318 third_party/libxml/src/tree.c memmove(&buf->content[buf->use], str, len*sizeof(xmlChar)); str 7337 third_party/libxml/src/tree.c xmlBufferAddHead(xmlBufferPtr buf, const xmlChar *str, int len) { str 7343 third_party/libxml/src/tree.c if (str == NULL) { str 7360 third_party/libxml/src/tree.c len = xmlStrlen(str); str 7372 third_party/libxml/src/tree.c memmove(&buf->content[0], str, len); str 7387 third_party/libxml/src/tree.c memmove(&buf->content[0], str, len); str 7404 third_party/libxml/src/tree.c xmlBufferCat(xmlBufferPtr buf, const xmlChar *str) { str 7408 third_party/libxml/src/tree.c if (str == NULL) return -1; str 7409 third_party/libxml/src/tree.c return xmlBufferAdd(buf, str, -1); str 7423 third_party/libxml/src/tree.c xmlBufferCCat(xmlBufferPtr buf, const char *str) { str 7429 third_party/libxml/src/tree.c if (str == NULL) { str 7436 third_party/libxml/src/tree.c for (cur = str;*cur != 0;cur++) { str 7923 third_party/libxml/src/tree.c #define XML_TREE_ADOPT_STR(str) \ str 7924 third_party/libxml/src/tree.c if (adoptStr && (str != NULL)) { \ str 7926 third_party/libxml/src/tree.c const xmlChar *old = str; \ str 7927 third_party/libxml/src/tree.c str = xmlDictLookup(destDoc->dict, str, -1); \ str 7932 third_party/libxml/src/tree.c xmlDictOwns(sourceDoc->dict, str)) { \ str 7933 third_party/libxml/src/tree.c str = BAD_CAST xmlStrdup(str); \ str 7941 third_party/libxml/src/tree.c #define XML_TREE_ADOPT_STR_2(str) \ str 7942 third_party/libxml/src/tree.c if (adoptStr && (str != NULL) && (sourceDoc != NULL) && \ str 177 third_party/libxml/src/uri.c xmlParse3986Scheme(xmlURIPtr uri, const char **str) { str 180 third_party/libxml/src/uri.c if (str == NULL) str 183 third_party/libxml/src/uri.c cur = *str; str 191 third_party/libxml/src/uri.c uri->scheme = STRNDUP(*str, cur - *str); str 193 third_party/libxml/src/uri.c *str = cur; str 213 third_party/libxml/src/uri.c xmlParse3986Fragment(xmlURIPtr uri, const char **str) str 217 third_party/libxml/src/uri.c if (str == NULL) str 220 third_party/libxml/src/uri.c cur = *str; str 230 third_party/libxml/src/uri.c uri->fragment = STRNDUP(*str, cur - *str); str 232 third_party/libxml/src/uri.c uri->fragment = xmlURIUnescapeString(*str, cur - *str, NULL); str 234 third_party/libxml/src/uri.c *str = cur; str 250 third_party/libxml/src/uri.c xmlParse3986Query(xmlURIPtr uri, const char **str) str 254 third_party/libxml/src/uri.c if (str == NULL) str 257 third_party/libxml/src/uri.c cur = *str; str 266 third_party/libxml/src/uri.c uri->query = STRNDUP(*str, cur - *str); str 268 third_party/libxml/src/uri.c uri->query = xmlURIUnescapeString(*str, cur - *str, NULL); str 275 third_party/libxml/src/uri.c uri->query_raw = STRNDUP (*str, cur - *str); str 277 third_party/libxml/src/uri.c *str = cur; str 294 third_party/libxml/src/uri.c xmlParse3986Port(xmlURIPtr uri, const char **str) str 296 third_party/libxml/src/uri.c const char *cur = *str; str 306 third_party/libxml/src/uri.c *str = cur; str 325 third_party/libxml/src/uri.c xmlParse3986Userinfo(xmlURIPtr uri, const char **str) str 329 third_party/libxml/src/uri.c cur = *str; str 337 third_party/libxml/src/uri.c uri->user = STRNDUP(*str, cur - *str); str 339 third_party/libxml/src/uri.c uri->user = xmlURIUnescapeString(*str, cur - *str, NULL); str 341 third_party/libxml/src/uri.c *str = cur; str 362 third_party/libxml/src/uri.c xmlParse3986DecOctet(const char **str) { str 363 third_party/libxml/src/uri.c const char *cur = *str; str 381 third_party/libxml/src/uri.c *str = cur; str 400 third_party/libxml/src/uri.c xmlParse3986Host(xmlURIPtr uri, const char **str) str 402 third_party/libxml/src/uri.c const char *cur = *str; str 439 third_party/libxml/src/uri.c cur = *str; str 459 third_party/libxml/src/uri.c *str = cur; str 476 third_party/libxml/src/uri.c xmlParse3986Authority(xmlURIPtr uri, const char **str) str 481 third_party/libxml/src/uri.c cur = *str; str 487 third_party/libxml/src/uri.c cur = *str; str 497 third_party/libxml/src/uri.c *str = cur; str 518 third_party/libxml/src/uri.c xmlParse3986Segment(const char **str, char forbid, int empty) str 522 third_party/libxml/src/uri.c cur = *str; str 530 third_party/libxml/src/uri.c *str = cur; str 547 third_party/libxml/src/uri.c xmlParse3986PathAbEmpty(xmlURIPtr uri, const char **str) str 552 third_party/libxml/src/uri.c cur = *str; str 561 third_party/libxml/src/uri.c if (*str != cur) { str 563 third_party/libxml/src/uri.c uri->path = STRNDUP(*str, cur - *str); str 565 third_party/libxml/src/uri.c uri->path = xmlURIUnescapeString(*str, cur - *str, NULL); str 570 third_party/libxml/src/uri.c *str = cur; str 587 third_party/libxml/src/uri.c xmlParse3986PathAbsolute(xmlURIPtr uri, const char **str) str 592 third_party/libxml/src/uri.c cur = *str; str 607 third_party/libxml/src/uri.c if (cur != *str) { str 609 third_party/libxml/src/uri.c uri->path = STRNDUP(*str, cur - *str); str 611 third_party/libxml/src/uri.c uri->path = xmlURIUnescapeString(*str, cur - *str, NULL); str 616 third_party/libxml/src/uri.c *str = cur; str 633 third_party/libxml/src/uri.c xmlParse3986PathRootless(xmlURIPtr uri, const char **str) str 638 third_party/libxml/src/uri.c cur = *str; str 649 third_party/libxml/src/uri.c if (cur != *str) { str 651 third_party/libxml/src/uri.c uri->path = STRNDUP(*str, cur - *str); str 653 third_party/libxml/src/uri.c uri->path = xmlURIUnescapeString(*str, cur - *str, NULL); str 658 third_party/libxml/src/uri.c *str = cur; str 675 third_party/libxml/src/uri.c xmlParse3986PathNoScheme(xmlURIPtr uri, const char **str) str 680 third_party/libxml/src/uri.c cur = *str; str 691 third_party/libxml/src/uri.c if (cur != *str) { str 693 third_party/libxml/src/uri.c uri->path = STRNDUP(*str, cur - *str); str 695 third_party/libxml/src/uri.c uri->path = xmlURIUnescapeString(*str, cur - *str, NULL); str 700 third_party/libxml/src/uri.c *str = cur; str 720 third_party/libxml/src/uri.c xmlParse3986HierPart(xmlURIPtr uri, const char **str) str 725 third_party/libxml/src/uri.c cur = *str; str 733 third_party/libxml/src/uri.c *str = cur; str 748 third_party/libxml/src/uri.c *str = cur; str 769 third_party/libxml/src/uri.c xmlParse3986RelativeRef(xmlURIPtr uri, const char *str) { str 772 third_party/libxml/src/uri.c if ((*str == '/') && (*(str + 1) == '/')) { str 773 third_party/libxml/src/uri.c str += 2; str 774 third_party/libxml/src/uri.c ret = xmlParse3986Authority(uri, &str); str 776 third_party/libxml/src/uri.c ret = xmlParse3986PathAbEmpty(uri, &str); str 778 third_party/libxml/src/uri.c } else if (*str == '/') { str 779 third_party/libxml/src/uri.c ret = xmlParse3986PathAbsolute(uri, &str); str 781 third_party/libxml/src/uri.c } else if (ISA_PCHAR(str)) { str 782 third_party/libxml/src/uri.c ret = xmlParse3986PathNoScheme(uri, &str); str 792 third_party/libxml/src/uri.c if (*str == '?') { str 793 third_party/libxml/src/uri.c str++; str 794 third_party/libxml/src/uri.c ret = xmlParse3986Query(uri, &str); str 797 third_party/libxml/src/uri.c if (*str == '#') { str 798 third_party/libxml/src/uri.c str++; str 799 third_party/libxml/src/uri.c ret = xmlParse3986Fragment(uri, &str); str 802 third_party/libxml/src/uri.c if (*str != 0) { str 823 third_party/libxml/src/uri.c xmlParse3986URI(xmlURIPtr uri, const char *str) { str 826 third_party/libxml/src/uri.c ret = xmlParse3986Scheme(uri, &str); str 828 third_party/libxml/src/uri.c if (*str != ':') { str 831 third_party/libxml/src/uri.c str++; str 832 third_party/libxml/src/uri.c ret = xmlParse3986HierPart(uri, &str); str 834 third_party/libxml/src/uri.c if (*str == '?') { str 835 third_party/libxml/src/uri.c str++; str 836 third_party/libxml/src/uri.c ret = xmlParse3986Query(uri, &str); str 839 third_party/libxml/src/uri.c if (*str == '#') { str 840 third_party/libxml/src/uri.c str++; str 841 third_party/libxml/src/uri.c ret = xmlParse3986Fragment(uri, &str); str 844 third_party/libxml/src/uri.c if (*str != 0) { str 864 third_party/libxml/src/uri.c xmlParse3986URIReference(xmlURIPtr uri, const char *str) { str 867 third_party/libxml/src/uri.c if (str == NULL) str 875 third_party/libxml/src/uri.c ret = xmlParse3986URI(uri, str); str 878 third_party/libxml/src/uri.c ret = xmlParse3986RelativeRef(uri, str); str 898 third_party/libxml/src/uri.c xmlParseURI(const char *str) { str 902 third_party/libxml/src/uri.c if (str == NULL) str 906 third_party/libxml/src/uri.c ret = xmlParse3986URIReference(uri, str); str 928 third_party/libxml/src/uri.c xmlParseURIReference(xmlURIPtr uri, const char *str) { str 929 third_party/libxml/src/uri.c return(xmlParse3986URIReference(uri, str)); str 944 third_party/libxml/src/uri.c xmlParseURIRaw(const char *str, int raw) { str 948 third_party/libxml/src/uri.c if (str == NULL) str 955 third_party/libxml/src/uri.c ret = xmlParseURIReference(uri, str); str 1683 third_party/libxml/src/uri.c xmlURIUnescapeString(const char *str, int len, char *target) { str 1687 third_party/libxml/src/uri.c if (str == NULL) str 1689 third_party/libxml/src/uri.c if (len <= 0) len = strlen(str); str 1701 third_party/libxml/src/uri.c in = str; str 1742 third_party/libxml/src/uri.c xmlURIEscapeStr(const xmlChar *str, const xmlChar *list) { str 1749 third_party/libxml/src/uri.c if (str == NULL) str 1751 third_party/libxml/src/uri.c if (str[0] == 0) str 1752 third_party/libxml/src/uri.c return(xmlStrdup(str)); str 1753 third_party/libxml/src/uri.c len = xmlStrlen(str); str 1763 third_party/libxml/src/uri.c in = (const xmlChar *) str; str 1819 third_party/libxml/src/uri.c xmlURIEscape(const xmlChar * str) str 1831 third_party/libxml/src/uri.c if (str == NULL) str 1840 third_party/libxml/src/uri.c ret2 = xmlParseURIReference(uri, (const char *)str); str 2537 third_party/libxml/src/valid.c #define DICT_FREE(str) \ str 2538 third_party/libxml/src/valid.c if ((str) && ((!dict) || \ str 2539 third_party/libxml/src/valid.c (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ str 2540 third_party/libxml/src/valid.c xmlFree((char *)(str)); str 6443 third_party/libxml/src/valid.c xmlChar *dup, *str = NULL, *cur, save; str 6452 third_party/libxml/src/valid.c str = cur; str 6456 third_party/libxml/src/valid.c id = xmlGetID(ctxt->doc, str); str 6460 third_party/libxml/src/valid.c ref->name, ref->lineno, str); str 6478 third_party/libxml/src/valid.c xmlChar *dup, *str = NULL, *cur, save; str 6488 third_party/libxml/src/valid.c str = cur; str 6492 third_party/libxml/src/valid.c id = xmlGetID(ctxt->doc, str); str 6496 third_party/libxml/src/valid.c attr->name, str, NULL); str 3408 third_party/libxml/src/xmlIO.c xmlOutputBufferWriteEscape(xmlOutputBufferPtr out, const xmlChar *str, str 3418 third_party/libxml/src/xmlIO.c if ((out == NULL) || (out->error) || (str == NULL) || str 3421 third_party/libxml/src/xmlIO.c len = strlen((const char *)str); str 3457 third_party/libxml/src/xmlIO.c &chunk, str, &cons); str 3478 third_party/libxml/src/xmlIO.c &chunk, str, &cons); str 3485 third_party/libxml/src/xmlIO.c str += cons; str 3540 third_party/libxml/src/xmlIO.c xmlOutputBufferWriteString(xmlOutputBufferPtr out, const char *str) { str 3544 third_party/libxml/src/xmlIO.c if (str == NULL) str 3546 third_party/libxml/src/xmlIO.c len = strlen(str); str 3549 third_party/libxml/src/xmlIO.c return(xmlOutputBufferWrite(out, len, str)); str 384 third_party/libxml/src/xmllint.c myStrdupFunc(const char *str) str 388 third_party/libxml/src/xmllint.c ret = xmlMemoryStrdup(str); str 480 third_party/libxml/src/xmlmemory.c xmlMemStrdupLoc(const char *str, const char *file, int line) str 483 third_party/libxml/src/xmlmemory.c size_t size = strlen(str) + 1; str 513 third_party/libxml/src/xmlmemory.c strcpy(s,str); str 541 third_party/libxml/src/xmlmemory.c xmlMemoryStrdup(const char *str) { str 542 third_party/libxml/src/xmlmemory.c return(xmlMemStrdupLoc(str, "none", 0)); str 191 third_party/libxml/src/xmlreader.c #define CONSTSTR(str) xmlDictLookup(reader->dict, (str), -1) str 192 third_party/libxml/src/xmlreader.c #define CONSTQSTR(p, str) xmlDictQLookup(reader->dict, (p), (str)) str 209 third_party/libxml/src/xmlreader.c #define DICT_FREE(str) \ str 210 third_party/libxml/src/xmlreader.c if ((str) && ((!dict) || \ str 211 third_party/libxml/src/xmlreader.c (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ str 212 third_party/libxml/src/xmlreader.c xmlFree((char *)(str)); str 3699 third_party/libxml/src/xmlreader.c xmlTextReaderConstString(xmlTextReaderPtr reader, const xmlChar *str) { str 3702 third_party/libxml/src/xmlreader.c return(CONSTSTR(str)); str 4013 third_party/libxml/src/xmlreader.c char *str; str 4018 third_party/libxml/src/xmlreader.c str = xmlTextReaderBuildMessage(msg, ap); str 4020 third_party/libxml/src/xmlreader.c xmlTextReaderValidityError(ctx, "%s", str); str 4022 third_party/libxml/src/xmlreader.c reader->errorFunc(reader->errorFuncArg, str, str 4026 third_party/libxml/src/xmlreader.c if (str != NULL) str 4027 third_party/libxml/src/xmlreader.c xmlFree(str); str 4036 third_party/libxml/src/xmlreader.c char *str; str 4041 third_party/libxml/src/xmlreader.c str = xmlTextReaderBuildMessage(msg, ap); str 4043 third_party/libxml/src/xmlreader.c xmlTextReaderValidityWarning(ctx, "%s", str); str 4045 third_party/libxml/src/xmlreader.c reader->errorFunc(reader->errorFuncArg, str, str 4049 third_party/libxml/src/xmlreader.c if (str != NULL) str 4050 third_party/libxml/src/xmlreader.c xmlFree(str); str 4539 third_party/libxml/src/xmlreader.c char *str = NULL; str 4544 third_party/libxml/src/xmlreader.c chars = vsnprintf(str, size, msg, aq); str 4548 third_party/libxml/src/xmlreader.c if (str) str 4549 third_party/libxml/src/xmlreader.c xmlFree(str); str 4558 third_party/libxml/src/xmlreader.c if ((larger = (char *) xmlRealloc(str, size)) == NULL) { str 4560 third_party/libxml/src/xmlreader.c if (str) str 4561 third_party/libxml/src/xmlreader.c xmlFree(str); str 4564 third_party/libxml/src/xmlreader.c str = larger; str 4567 third_party/libxml/src/xmlreader.c return str; str 4645 third_party/libxml/src/xmlreader.c char *str) str 4651 third_party/libxml/src/xmlreader.c if (str != NULL) { str 4653 third_party/libxml/src/xmlreader.c reader->errorFunc(reader->errorFuncArg, str, severity, str 4655 third_party/libxml/src/xmlreader.c xmlFree(str); str 47 third_party/libxml/src/xmlregexp.c #define ERROR(str) \ str 49 third_party/libxml/src/xmlregexp.c xmlRegexpErrCompile(ctxt, str); str 4142 third_party/libxml/src/xmlregexp.c xmlChar *str; str 4158 third_party/libxml/src/xmlregexp.c str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2); str 4159 third_party/libxml/src/xmlregexp.c if (str == NULL) { str 4164 third_party/libxml/src/xmlregexp.c str = buf; str 4166 third_party/libxml/src/xmlregexp.c memcpy(&str[0], value, lenp); str 4167 third_party/libxml/src/xmlregexp.c str[lenp] = XML_REG_STRING_SEPARATOR; str 4168 third_party/libxml/src/xmlregexp.c memcpy(&str[lenp + 1], value2, lenn); str 4169 third_party/libxml/src/xmlregexp.c str[lenn + lenp + 1] = 0; str 4172 third_party/libxml/src/xmlregexp.c ret = xmlRegCompactPushString(exec, exec->comp, str, data); str 4174 third_party/libxml/src/xmlregexp.c ret = xmlRegExecPushStringInternal(exec, str, data, 1); str 4176 third_party/libxml/src/xmlregexp.c if (str != buf) str 4177 third_party/libxml/src/xmlregexp.c xmlFree(str); str 5740 third_party/libxml/src/xmlregexp.c xmlChar *str; str 5745 third_party/libxml/src/xmlregexp.c str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2); str 5746 third_party/libxml/src/xmlregexp.c if (str == NULL) { str 5750 third_party/libxml/src/xmlregexp.c memcpy(&str[0], token, lenp); str 5751 third_party/libxml/src/xmlregexp.c str[lenp] = '|'; str 5752 third_party/libxml/src/xmlregexp.c memcpy(&str[lenp + 1], token2, lenn); str 5753 third_party/libxml/src/xmlregexp.c str[lenn + lenp + 1] = 0; str 5755 third_party/libxml/src/xmlregexp.c atom->valuep = str; str 5802 third_party/libxml/src/xmlregexp.c xmlChar *str; str 5807 third_party/libxml/src/xmlregexp.c str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2); str 5808 third_party/libxml/src/xmlregexp.c if (str == NULL) { str 5812 third_party/libxml/src/xmlregexp.c memcpy(&str[0], token, lenp); str 5813 third_party/libxml/src/xmlregexp.c str[lenp] = '|'; str 5814 third_party/libxml/src/xmlregexp.c memcpy(&str[lenp + 1], token2, lenn); str 5815 third_party/libxml/src/xmlregexp.c str[lenn + lenp + 1] = 0; str 5817 third_party/libxml/src/xmlregexp.c atom->valuep = str; str 5872 third_party/libxml/src/xmlregexp.c xmlChar *str; str 5877 third_party/libxml/src/xmlregexp.c str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2); str 5878 third_party/libxml/src/xmlregexp.c if (str == NULL) { str 5882 third_party/libxml/src/xmlregexp.c memcpy(&str[0], token, lenp); str 5883 third_party/libxml/src/xmlregexp.c str[lenp] = '|'; str 5884 third_party/libxml/src/xmlregexp.c memcpy(&str[lenp + 1], token2, lenn); str 5885 third_party/libxml/src/xmlregexp.c str[lenn + lenp + 1] = 0; str 5887 third_party/libxml/src/xmlregexp.c atom->valuep = str; str 6027 third_party/libxml/src/xmlregexp.c xmlChar *str; str 6032 third_party/libxml/src/xmlregexp.c str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2); str 6033 third_party/libxml/src/xmlregexp.c if (str == NULL) { str 6037 third_party/libxml/src/xmlregexp.c memcpy(&str[0], token, lenp); str 6038 third_party/libxml/src/xmlregexp.c str[lenp] = '|'; str 6039 third_party/libxml/src/xmlregexp.c memcpy(&str[lenp + 1], token2, lenn); str 6040 third_party/libxml/src/xmlregexp.c str[lenn + lenp + 1] = 0; str 6042 third_party/libxml/src/xmlregexp.c atom->valuep = str; str 7063 third_party/libxml/src/xmlregexp.c xmlExpStringDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, const xmlChar *str) str 7073 third_party/libxml/src/xmlregexp.c if (exp->exp_str == str) { str 7092 third_party/libxml/src/xmlregexp.c tmp = xmlExpStringDeriveInt(ctxt, exp->exp_left, str); str 7096 third_party/libxml/src/xmlregexp.c ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str); str 7109 third_party/libxml/src/xmlregexp.c ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str); str 7117 third_party/libxml/src/xmlregexp.c ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str); str 7134 third_party/libxml/src/xmlregexp.c ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str); str 7186 third_party/libxml/src/xmlregexp.c const xmlChar *str, int len) { str 7189 third_party/libxml/src/xmlregexp.c if ((exp == NULL) || (ctxt == NULL) || (str == NULL)) { str 7196 third_party/libxml/src/xmlregexp.c input = xmlDictExists(ctxt->dict, str, len); str 321 third_party/libxml/src/xmlschemas.c #define FREE_AND_NULL(str) if ((str) != NULL) { xmlFree((xmlChar *) (str)); str = NULL; } str 1424 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 1428 third_party/libxml/src/xmlschemas.c *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, str 1431 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 1570 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 1643 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, WXS_ATTRUSE_DECL(ause))); str 1644 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 1657 third_party/libxml/src/xmlschemas.c *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str, str 1659 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 1672 third_party/libxml/src/xmlschemas.c *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str, str 1714 third_party/libxml/src/xmlschemas.c *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, item)); str 1716 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 1728 third_party/libxml/src/xmlschemas.c *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, item)); str 1730 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 1748 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, elem->ns->href, elem->name)); str 1749 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 1758 third_party/libxml/src/xmlschemas.c *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str, str 1760 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 1765 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 2002 third_party/libxml/src/xmlschemas.c const char *msg, const xmlChar *str) str 2005 third_party/libxml/src/xmlschemas.c msg, (const char *) str); str 2153 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 2177 third_party/libxml/src/xmlschemas.c *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str, str 2180 third_party/libxml/src/xmlschemas.c *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str, str 2182 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 2189 third_party/libxml/src/xmlschemas.c *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str, str 2192 third_party/libxml/src/xmlschemas.c *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str, str 2194 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 2206 third_party/libxml/src/xmlschemas.c *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str, str 2208 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 2214 third_party/libxml/src/xmlschemas.c *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str, str 2216 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 2235 third_party/libxml/src/xmlschemas.c *msg = xmlStrcat(*msg, xmlSchemaFormatItemForReport(&str, str 2237 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 2454 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 2461 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 2464 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 2476 third_party/libxml/src/xmlschemas.c xmlSchemaFormatErrorNodeQName(xmlChar ** str, str 2482 third_party/libxml/src/xmlschemas.c return (xmlSchemaFormatQName(str, node->ns->href, node->name)); str 2484 third_party/libxml/src/xmlschemas.c return (xmlSchemaFormatQName(str, NULL, node->name)); str 2486 third_party/libxml/src/xmlschemas.c return (xmlSchemaFormatQName(str, ni->nsName, ni->localName)); str 2496 third_party/libxml/src/xmlschemas.c xmlChar *msg = NULL, *str = NULL; str 2501 third_party/libxml/src/xmlschemas.c xmlSchemaFormatErrorNodeQName(&str, (xmlSchemaNodeInfoPtr) ni, node), str 2503 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 2517 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL, *msg = NULL; str 2532 third_party/libxml/src/xmlschemas.c str = xmlStrdup(BAD_CAST " Expected is one of ( "); str 2534 third_party/libxml/src/xmlschemas.c str = xmlStrdup(BAD_CAST " Expected is ( "); str 2544 third_party/libxml/src/xmlschemas.c str = xmlStrcat(str, BAD_CAST "##other"); str 2585 third_party/libxml/src/xmlschemas.c str = xmlStrcat(str, BAD_CAST nsName); str 2592 third_party/libxml/src/xmlschemas.c str = xmlStrcat(str, BAD_CAST localName); str 2596 third_party/libxml/src/xmlschemas.c str = xmlStrcat(str, BAD_CAST ", "); str 2598 third_party/libxml/src/xmlschemas.c str = xmlStrcat(str, BAD_CAST " ).\n"); str 2599 third_party/libxml/src/xmlschemas.c msg = xmlStrcat(msg, BAD_CAST str); str 2600 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 2619 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL, *msg = NULL; str 2678 third_party/libxml/src/xmlschemas.c xmlSchemaFormatFacetEnumSet(actxt, &str, type)); str 2726 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 2969 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL, *msg = NULL; str 2974 third_party/libxml/src/xmlschemas.c BAD_CAST xmlSchemaFormatItemForReport(&str, NULL, str 2976 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 3119 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 3126 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 3129 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 4267 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 4288 third_party/libxml/src/xmlschemas.c fprintf(output, "ELEM '%s'", xmlSchemaFormatQName(&str, str 4291 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 4344 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 4369 third_party/libxml/src/xmlschemas.c (const char *) xmlSchemaFormatQName(&str, tns, name)); str 4370 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 4522 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 4529 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, namespaceName, localName)); str 4530 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 4536 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, str 4538 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 4987 third_party/libxml/src/xmlschemas.c xmlSchemaIsBlank(xmlChar * str, int len) str 4989 third_party/libxml/src/xmlschemas.c if (str == NULL) str 4992 third_party/libxml/src/xmlschemas.c while (*str != 0) { str 4993 third_party/libxml/src/xmlschemas.c if (!(IS_BLANK_CH(*str))) str 4995 third_party/libxml/src/xmlschemas.c str++; str 4997 third_party/libxml/src/xmlschemas.c } else while ((*str != 0) && (len != 0)) { str 4998 third_party/libxml/src/xmlschemas.c if (!(IS_BLANK_CH(*str))) str 5000 third_party/libxml/src/xmlschemas.c str++; str 7391 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 7397 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, tmpNs, tmpName), str 7399 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 7706 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 7713 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, refNs, ref), NULL); str 7714 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 11366 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 11373 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 11377 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 11382 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 11395 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 11399 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 14118 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 14131 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, baseItem), str 14133 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 14196 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 14205 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, str 14208 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 14229 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 14237 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, baseItem), str 14239 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 14297 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 14310 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, baseItem)); str 14311 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 14316 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 14330 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, baseItem), str 14332 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 14344 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 14352 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, baseItem), str 14354 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15125 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 15155 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, baseType)); str 15156 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15167 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, baseType)); str 15168 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15194 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, baseType)); str 15195 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15228 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 15247 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, type->baseType)); str 15248 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15261 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, type->baseType)); str 15262 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15325 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, itemType)); str 15326 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15339 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, member->type)); str 15340 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15363 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, itemType)); str 15364 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15406 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, type->baseType)); str 15407 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15420 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, type->baseType)); str 15421 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15447 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, itemType), str 15451 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15520 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, member->type)); str 15521 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15543 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, member->type)); str 15544 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15569 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, type->baseType)); str 15570 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15582 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, type->baseType)); str 15583 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15629 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, member->type), str 15632 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 15914 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 15920 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, use), str 15922 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 15943 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 15952 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, use), str 15954 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 16167 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 16178 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, str 16181 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 16199 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 16206 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, base)); str 16207 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 16212 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 16219 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, base)); str 16220 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 16594 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 16600 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, base->targetNamespace, str 16602 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 16615 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 16627 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, base->targetNamespace, str 16629 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 16666 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 16679 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, base->targetNamespace, str 16681 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 16689 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 16698 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, base->targetNamespace, str 16707 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, base->targetNamespace, str 16710 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 18691 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 18698 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 18700 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 18927 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 18939 third_party/libxml/src/xmlschemas.c "defined", xmlSchemaFormatQName(&str, str 18941 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 19086 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 19094 third_party/libxml/src/xmlschemas.c "defined", xmlSchemaGetComponentQName(&str, attrGr)); str 19095 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 19259 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 19267 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 19270 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 19357 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 19363 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, use), str 19365 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 19387 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 19396 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, use), str 19398 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 20368 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 20383 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, refer->targetNamespace, str 20386 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 20450 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 20482 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, redef->refTargetNs, str 20484 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 20568 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 20582 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentDesignation(&str, prev), str 20584 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 20761 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 20769 third_party/libxml/src/xmlschemas.c xmlSchemaGetComponentQName(&str, item)); str 20770 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 22442 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 22445 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, vctxt->inode->nsName, str 22447 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 22650 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 22653 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, vctxt->inode->nsName, str 22655 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 22708 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 22720 third_party/libxml/src/xmlschemas.c xmlSchemaGetIDCDesignation(&str, sto->matcher->aidc->def)); str 22721 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 22812 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 22829 third_party/libxml/src/xmlschemas.c xmlSchemaGetIDCDesignation(&str, matcher->aidc->def)); str 22830 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 22991 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL, *strB = NULL; str 22999 third_party/libxml/src/xmlschemas.c xmlSchemaFormatIDCKeySequence(vctxt, &str, str 23002 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 23072 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 23083 third_party/libxml/src/xmlschemas.c xmlSchemaGetIDCDesignation(&str, idc), NULL); str 23084 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 23153 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 23156 third_party/libxml/src/xmlschemas.c (char *) xmlSchemaFormatQName(&str, vctxt->inode->nsName, str 23158 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 23829 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL, *strB = NULL; str 23835 third_party/libxml/src/xmlschemas.c xmlSchemaFormatIDCKeySequence(vctxt, &str, str 23839 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 23848 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL, *strB = NULL; str 23853 third_party/libxml/src/xmlschemas.c xmlSchemaFormatIDCKeySequence(vctxt, &str, str 23856 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 24883 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 24890 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, nsName, local), NULL); str 24891 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 24941 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 24948 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 24952 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str); str 25714 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 25719 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 25723 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 25924 third_party/libxml/src/xmlschemas.c xmlChar *str = NULL; str 25929 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 25934 third_party/libxml/src/xmlschemas.c xmlSchemaFormatQName(&str, str 25938 third_party/libxml/src/xmlschemas.c FREE_AND_NULL(str) str 105 third_party/libxml/src/xmlschemastypes.c xmlChar *str; str 112 third_party/libxml/src/xmlschemastypes.c xmlChar *str; str 129 third_party/libxml/src/xmlschemastypes.c xmlChar *str; str 899 third_party/libxml/src/xmlschemastypes.c return (BAD_CAST val->value.str); str 949 third_party/libxml/src/xmlschemastypes.c val->value.str = (xmlChar *) value; str 1031 third_party/libxml/src/xmlschemastypes.c if (value->value.str != NULL) str 1032 third_party/libxml/src/xmlschemastypes.c xmlFree(value->value.str); str 1042 third_party/libxml/src/xmlschemastypes.c if (value->value.hex.str != NULL) str 1043 third_party/libxml/src/xmlschemastypes.c xmlFree(value->value.hex.str); str 1046 third_party/libxml/src/xmlschemastypes.c if (value->value.base64.str != NULL) str 1047 third_party/libxml/src/xmlschemastypes.c xmlFree(value->value.base64.str); str 1191 third_party/libxml/src/xmlschemastypes.c _xmlSchemaParseGYear (xmlSchemaValDatePtr dt, const xmlChar **str) { str 1192 third_party/libxml/src/xmlschemastypes.c const xmlChar *cur = *str, *firstChar; str 1223 third_party/libxml/src/xmlschemastypes.c *str = cur; str 1284 third_party/libxml/src/xmlschemastypes.c _xmlSchemaParseGMonth (xmlSchemaValDatePtr dt, const xmlChar **str) { str 1285 third_party/libxml/src/xmlschemastypes.c const xmlChar *cur = *str; str 1298 third_party/libxml/src/xmlschemastypes.c *str = cur; str 1314 third_party/libxml/src/xmlschemastypes.c _xmlSchemaParseGDay (xmlSchemaValDatePtr dt, const xmlChar **str) { str 1315 third_party/libxml/src/xmlschemastypes.c const xmlChar *cur = *str; str 1327 third_party/libxml/src/xmlschemastypes.c *str = cur; str 1344 third_party/libxml/src/xmlschemastypes.c _xmlSchemaParseTime (xmlSchemaValDatePtr dt, const xmlChar **str) { str 1345 third_party/libxml/src/xmlschemastypes.c const xmlChar *cur = *str; str 1379 third_party/libxml/src/xmlschemastypes.c *str = cur; str 1395 third_party/libxml/src/xmlschemastypes.c _xmlSchemaParseTimeZone (xmlSchemaValDatePtr dt, const xmlChar **str) { str 1399 third_party/libxml/src/xmlschemastypes.c if (str == NULL) str 1401 third_party/libxml/src/xmlschemastypes.c cur = *str; str 1454 third_party/libxml/src/xmlschemastypes.c *str = cur; str 2069 third_party/libxml/src/xmlschemastypes.c xmlSchemaParseUInt(const xmlChar **str, unsigned long *llo, str 2072 third_party/libxml/src/xmlschemastypes.c const xmlChar *tmp, *cur = *str; str 2086 third_party/libxml/src/xmlschemastypes.c *str = tmp; str 2102 third_party/libxml/src/xmlschemastypes.c *str = cur; str 2170 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2214 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2244 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2605 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2623 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2637 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2663 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrndup(start, end - start); str 2718 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2730 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2767 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2928 third_party/libxml/src/xmlschemastypes.c v->value.str = xmlStrdup(value); str 2984 third_party/libxml/src/xmlschemastypes.c v->value.hex.str = (xmlChar *) cur; str 3102 third_party/libxml/src/xmlschemastypes.c v->value.base64.str = base; str 3692 third_party/libxml/src/xmlschemastypes.c if (val->value.str != NULL) str 3693 third_party/libxml/src/xmlschemastypes.c cur->value.str = xmlStrdup(BAD_CAST val->value.str); str 3707 third_party/libxml/src/xmlschemastypes.c if (val->value.hex.str != NULL) str 3708 third_party/libxml/src/xmlschemastypes.c cur->value.hex.str = xmlStrdup(BAD_CAST val->value.hex.str); str 3712 third_party/libxml/src/xmlschemastypes.c if (val->value.base64.str != NULL) str 3713 third_party/libxml/src/xmlschemastypes.c cur->value.base64.str = str 3714 third_party/libxml/src/xmlschemastypes.c xmlStrdup(BAD_CAST val->value.base64.str); str 4760 third_party/libxml/src/xmlschemastypes.c xv = x->value.str; str 4764 third_party/libxml/src/xmlschemastypes.c yv = y->value.str; str 4859 third_party/libxml/src/xmlschemastypes.c int ret = xmlStrcmp(x->value.hex.str, y->value.hex.str); str 4876 third_party/libxml/src/xmlschemastypes.c int ret = xmlStrcmp(x->value.base64.str, str 4877 third_party/libxml/src/xmlschemastypes.c y->value.base64.str); str 5662 third_party/libxml/src/xmlschemastypes.c if (val->value.str == NULL) str 5666 third_party/libxml/src/xmlschemastypes.c BAD_CAST xmlStrdup((const xmlChar *) val->value.str); str 5669 third_party/libxml/src/xmlschemastypes.c if (val->value.str == NULL) str 5673 third_party/libxml/src/xmlschemastypes.c (const xmlChar *) val->value.str); str 5676 third_party/libxml/src/xmlschemastypes.c (const xmlChar *) val->value.str); str 5689 third_party/libxml/src/xmlschemastypes.c if (val->value.str == NULL) str 5692 third_party/libxml/src/xmlschemastypes.c BAD_CAST xmlSchemaCollapseString(BAD_CAST val->value.str); str 5695 third_party/libxml/src/xmlschemastypes.c BAD_CAST xmlStrdup((const xmlChar *) val->value.str); str 6012 third_party/libxml/src/xmlschemastypes.c *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.hex.str); str 6021 third_party/libxml/src/xmlschemastypes.c *retValue = BAD_CAST xmlStrdup(BAD_CAST val->value.base64.str); str 6082 third_party/libxml/src/xmlschemastypes.c if (val->value.str == NULL) str 6085 third_party/libxml/src/xmlschemastypes.c *retValue = xmlSchemaCollapseString(val->value.str); str 6087 third_party/libxml/src/xmlschemastypes.c *retValue = xmlSchemaWhiteSpaceReplace(val->value.str); str 6089 third_party/libxml/src/xmlschemastypes.c *retValue = BAD_CAST xmlStrdup(val->value.str); str 6092 third_party/libxml/src/xmlschemastypes.c if (val->value.str == NULL) str 6096 third_party/libxml/src/xmlschemastypes.c *retValue = xmlSchemaCollapseString(val->value.str); str 6098 third_party/libxml/src/xmlschemastypes.c *retValue = xmlSchemaWhiteSpaceReplace(val->value.str); str 6100 third_party/libxml/src/xmlschemastypes.c *retValue = BAD_CAST xmlStrdup(val->value.str); str 179 third_party/libxml/src/xmlstring.c xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str) { str 180 third_party/libxml/src/xmlstring.c if (pref == NULL) return(xmlStrEqual(name, str)); str 182 third_party/libxml/src/xmlstring.c if (str == NULL) return(0); str 185 third_party/libxml/src/xmlstring.c if (*pref++ != *str) return(0); str 186 third_party/libxml/src/xmlstring.c } while ((*str++) && (*pref)); str 187 third_party/libxml/src/xmlstring.c if (*str++ != ':') return(0); str 189 third_party/libxml/src/xmlstring.c if (*name++ != *str) return(0); str 190 third_party/libxml/src/xmlstring.c } while (*str++); str 321 third_party/libxml/src/xmlstring.c xmlStrchr(const xmlChar *str, xmlChar val) { str 322 third_party/libxml/src/xmlstring.c if (str == NULL) return(NULL); str 323 third_party/libxml/src/xmlstring.c while (*str != 0) { /* non input consuming */ str 324 third_party/libxml/src/xmlstring.c if (*str == val) return((xmlChar *) str); str 325 third_party/libxml/src/xmlstring.c str++; str 341 third_party/libxml/src/xmlstring.c xmlStrstr(const xmlChar *str, const xmlChar *val) { str 344 third_party/libxml/src/xmlstring.c if (str == NULL) return(NULL); str 348 third_party/libxml/src/xmlstring.c if (n == 0) return(str); str 349 third_party/libxml/src/xmlstring.c while (*str != 0) { /* non input consuming */ str 350 third_party/libxml/src/xmlstring.c if (*str == *val) { str 351 third_party/libxml/src/xmlstring.c if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str); str 353 third_party/libxml/src/xmlstring.c str++; str 369 third_party/libxml/src/xmlstring.c xmlStrcasestr(const xmlChar *str, const xmlChar *val) { str 372 third_party/libxml/src/xmlstring.c if (str == NULL) return(NULL); str 376 third_party/libxml/src/xmlstring.c if (n == 0) return(str); str 377 third_party/libxml/src/xmlstring.c while (*str != 0) { /* non input consuming */ str 378 third_party/libxml/src/xmlstring.c if (casemap[*str] == casemap[*val]) str 379 third_party/libxml/src/xmlstring.c if (!xmlStrncasecmp(str, val, n)) return(str); str 380 third_party/libxml/src/xmlstring.c str++; str 397 third_party/libxml/src/xmlstring.c xmlStrsub(const xmlChar *str, int start, int len) { str 400 third_party/libxml/src/xmlstring.c if (str == NULL) return(NULL); str 405 third_party/libxml/src/xmlstring.c if (*str == 0) return(NULL); str 406 third_party/libxml/src/xmlstring.c str++; str 408 third_party/libxml/src/xmlstring.c if (*str == 0) return(NULL); str 409 third_party/libxml/src/xmlstring.c return(xmlStrndup(str, len)); str 422 third_party/libxml/src/xmlstring.c xmlStrlen(const xmlChar *str) { str 425 third_party/libxml/src/xmlstring.c if (str == NULL) return(0); str 426 third_party/libxml/src/xmlstring.c while (*str != 0) { /* non input consuming */ str 427 third_party/libxml/src/xmlstring.c str++; str 105 third_party/libxml/src/xmlwriter.c const xmlChar * str, int len); str 4414 third_party/libxml/src/xmlwriter.c xmlTextWriterWriteDocCallback(void *context, const xmlChar * str, int len) str 4419 third_party/libxml/src/xmlwriter.c if ((rc = xmlParseChunk(ctxt, (const char *) str, len, 0)) != 0) { str 4593 third_party/libxml/src/xmlwriter.c xmlTextWriterSetIndentString(xmlTextWriterPtr writer, const xmlChar * str) str 4595 third_party/libxml/src/xmlwriter.c if ((writer == NULL) || (!str)) str 4600 third_party/libxml/src/xmlwriter.c writer->ichar = xmlStrdup(str); str 5786 third_party/libxml/src/xpath.c xmlChar *str; str 5791 third_party/libxml/src/xpath.c str = xmlXPathCastNodeSetToString(ns); str 5792 third_party/libxml/src/xpath.c ret = xmlXPathCastStringToNumber(str); str 5793 third_party/libxml/src/xpath.c xmlFree(str); str 6100 third_party/libxml/src/xpath.c xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) { str 6109 third_party/libxml/src/xpath.c ret->cur = ret->base = str; str 6605 third_party/libxml/src/xpath.c xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq) str 6612 third_party/libxml/src/xpath.c if ((str == NULL) || (arg == NULL) || str 6622 third_party/libxml/src/xpath.c hash = xmlXPathStringHash(str); str 6626 third_party/libxml/src/xpath.c if ((str2 != NULL) && (xmlStrEqual(str, str2))) { str 6631 third_party/libxml/src/xpath.c } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) { str 8993 third_party/libxml/src/xpath.c xmlXPathObjectPtr str, start, len; str 9022 third_party/libxml/src/xpath.c str = valuePop(ctxt); str 9023 third_party/libxml/src/xpath.c m = xmlUTF8Strlen((const unsigned char *)str->stringval); str 9073 third_party/libxml/src/xpath.c ret = xmlUTF8Strsub(str->stringval, i, l); str 9084 third_party/libxml/src/xpath.c xmlXPathReleaseObject(ctxt->context, str); str 9102 third_party/libxml/src/xpath.c xmlXPathObjectPtr str; str 9112 third_party/libxml/src/xpath.c str = valuePop(ctxt); str 9116 third_party/libxml/src/xpath.c point = xmlStrstr(str->stringval, find->stringval); str 9118 third_party/libxml/src/xpath.c offset = (int)(point - str->stringval); str 9119 third_party/libxml/src/xpath.c xmlBufferAdd(target, str->stringval, offset); str 9125 third_party/libxml/src/xpath.c xmlXPathReleaseObject(ctxt->context, str); str 9145 third_party/libxml/src/xpath.c xmlXPathObjectPtr str; str 9155 third_party/libxml/src/xpath.c str = valuePop(ctxt); str 9159 third_party/libxml/src/xpath.c point = xmlStrstr(str->stringval, find->stringval); str 9161 third_party/libxml/src/xpath.c offset = (int)(point - str->stringval) + xmlStrlen(find->stringval); str 9162 third_party/libxml/src/xpath.c xmlBufferAdd(target, &str->stringval[offset], str 9163 third_party/libxml/src/xpath.c xmlStrlen(str->stringval) - offset); str 9169 third_party/libxml/src/xpath.c xmlXPathReleaseObject(ctxt->context, str); str 9260 third_party/libxml/src/xpath.c xmlXPathObjectPtr str; str 9276 third_party/libxml/src/xpath.c str = valuePop(ctxt); str 9281 third_party/libxml/src/xpath.c for (cptr = str->stringval; (ch=*cptr); ) { str 9316 third_party/libxml/src/xpath.c xmlXPathReleaseObject(ctxt->context, str); str 9948 third_party/libxml/src/xpath.c xmlXPathStringEvalNumber(const xmlChar *str) { str 9949 third_party/libxml/src/xpath.c const xmlChar *cur = str; str 14484 third_party/libxml/src/xpath.c xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) { str 14496 third_party/libxml/src/xpath.c if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) && str 14497 third_party/libxml/src/xpath.c (!xmlStrchr(str, '@'))) { str 14509 third_party/libxml/src/xpath.c tmp = xmlStrchr(str, ':'); str 14532 third_party/libxml/src/xpath.c stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH, str 14619 third_party/libxml/src/xpath.c xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) { str 14624 third_party/libxml/src/xpath.c comp = xmlXPathTryStreamCompile(ctxt, str); str 14631 third_party/libxml/src/xpath.c pctxt = xmlXPathNewParserContext(str, ctxt); str 14658 third_party/libxml/src/xpath.c comp->expr = xmlStrdup(str); str 14660 third_party/libxml/src/xpath.c comp->string = xmlStrdup(str); str 14684 third_party/libxml/src/xpath.c xmlXPathCompile(const xmlChar *str) { str 14685 third_party/libxml/src/xpath.c return(xmlXPathCtxtCompile(NULL, str)); str 14874 third_party/libxml/src/xpath.c xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) { str 14883 third_party/libxml/src/xpath.c ctxt = xmlXPathNewParserContext(str, ctx); str 14936 third_party/libxml/src/xpath.c xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) { str 14945 third_party/libxml/src/xpath.c pctxt = xmlXPathNewParserContext(str, ctxt); str 15027 third_party/libxml/src/xpath.c xmlXPathObjectPtr str; str 15038 third_party/libxml/src/xpath.c str = valuePop(ctxt); str 15046 third_party/libxml/src/xpath.c for (cptr = str->stringval; *cptr; cptr++) { str 15083 third_party/libxml/src/xpath.c xmlXPathReleaseObject(ctxt->context, str); str 1365 third_party/libxml/src/xpointer.c xmlXPtrEval(const xmlChar *str, xmlXPathContextPtr ctx) { str 1373 third_party/libxml/src/xpointer.c if ((ctx == NULL) || (str == NULL)) str 1376 third_party/libxml/src/xpointer.c ctxt = xmlXPathNewParserContext(str, ctx); str 2533 third_party/libxml/src/xpointer.c const xmlChar *str; str 2555 third_party/libxml/src/xpointer.c str = xmlStrchr(&cur->content[pos], first); str 2556 third_party/libxml/src/xpointer.c if (str != NULL) { str 2557 third_party/libxml/src/xpointer.c pos = (str - (xmlChar *)(cur->content)); str 464 third_party/libxslt/libexslt/crypto.c xmlChar ** str) { str 473 third_party/libxslt/libexslt/crypto.c *str = xmlXPathPopString (ctxt); str 474 third_party/libxslt/libexslt/crypto.c str_len = xmlUTF8Strlen (*str); str 478 third_party/libxslt/libexslt/crypto.c xmlFree (*str); str 496 third_party/libxslt/libexslt/crypto.c xmlChar *str = NULL, *ret = NULL; str 500 third_party/libxslt/libexslt/crypto.c str_len = exsltCryptoPopString (ctxt, nargs, &str); str 503 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 507 third_party/libxslt/libexslt/crypto.c PLATFORM_HASH (ctxt, PLATFORM_MD4, (const char *) str, str_len, str 514 third_party/libxslt/libexslt/crypto.c if (str != NULL) str 515 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 529 third_party/libxslt/libexslt/crypto.c xmlChar *str = NULL, *ret = NULL; str 533 third_party/libxslt/libexslt/crypto.c str_len = exsltCryptoPopString (ctxt, nargs, &str); str 536 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 540 third_party/libxslt/libexslt/crypto.c PLATFORM_HASH (ctxt, PLATFORM_MD5, (const char *) str, str_len, str 547 third_party/libxslt/libexslt/crypto.c if (str != NULL) str 548 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 562 third_party/libxslt/libexslt/crypto.c xmlChar *str = NULL, *ret = NULL; str 566 third_party/libxslt/libexslt/crypto.c str_len = exsltCryptoPopString (ctxt, nargs, &str); str 569 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 573 third_party/libxslt/libexslt/crypto.c PLATFORM_HASH (ctxt, PLATFORM_SHA1, (const char *) str, str_len, str 580 third_party/libxslt/libexslt/crypto.c if (str != NULL) str 581 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 596 third_party/libxslt/libexslt/crypto.c xmlChar *key = NULL, *str = NULL, *padkey = NULL; str 606 third_party/libxslt/libexslt/crypto.c str = xmlXPathPopString (ctxt); str 607 third_party/libxslt/libexslt/crypto.c str_len = xmlUTF8Strlen (str); str 611 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 621 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 647 third_party/libxslt/libexslt/crypto.c bin = xmlStrdup (str); str 655 third_party/libxslt/libexslt/crypto.c PLATFORM_RC4_ENCRYPT (ctxt, padkey, str, str_len, bin, bin_len); str 674 third_party/libxslt/libexslt/crypto.c if (str != NULL) str 675 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 694 third_party/libxslt/libexslt/crypto.c xmlChar *key = NULL, *str = NULL, *padkey = NULL, *bin = str 704 third_party/libxslt/libexslt/crypto.c str = xmlXPathPopString (ctxt); str 705 third_party/libxslt/libexslt/crypto.c str_len = xmlUTF8Strlen (str); str 709 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 719 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 752 third_party/libxslt/libexslt/crypto.c ret_len = exsltCryptoHex2Bin (str, str_len, bin, bin_len); str 770 third_party/libxslt/libexslt/crypto.c if (str != NULL) str 771 third_party/libxslt/libexslt/crypto.c xmlFree (str); str 204 third_party/libxslt/libexslt/date.c _exsltDateParseGYear (exsltDateValDatePtr dt, const xmlChar **str) str 206 third_party/libxslt/libexslt/date.c const xmlChar *cur = *str, *firstChar; str 237 third_party/libxslt/libexslt/date.c *str = cur; str 359 third_party/libxslt/libexslt/date.c xmlChar *sav, *str; \ str 362 third_party/libxslt/libexslt/date.c str = xmlXPathCastNumberToString(num); \ str 363 third_party/libxslt/libexslt/date.c sav = str; \ str 364 third_party/libxslt/libexslt/date.c while (*str != 0) \ str 365 third_party/libxslt/libexslt/date.c *cur++ = *str++; \ str 381 third_party/libxslt/libexslt/date.c _exsltDateParseGMonth (exsltDateValDatePtr dt, const xmlChar **str) str 383 third_party/libxslt/libexslt/date.c const xmlChar *cur = *str; str 390 third_party/libxslt/libexslt/date.c *str = cur; str 423 third_party/libxslt/libexslt/date.c _exsltDateParseGDay (exsltDateValDatePtr dt, const xmlChar **str) str 425 third_party/libxslt/libexslt/date.c const xmlChar *cur = *str; str 432 third_party/libxslt/libexslt/date.c *str = cur; str 483 third_party/libxslt/libexslt/date.c _exsltDateParseTime (exsltDateValDatePtr dt, const xmlChar **str) str 485 third_party/libxslt/libexslt/date.c const xmlChar *cur = *str; str 515 third_party/libxslt/libexslt/date.c *str = cur; str 555 third_party/libxslt/libexslt/date.c _exsltDateParseTimeZone (exsltDateValDatePtr dt, const xmlChar **str) str 560 third_party/libxslt/libexslt/date.c if (str == NULL) str 562 third_party/libxslt/libexslt/date.c cur = *str; str 609 third_party/libxslt/libexslt/date.c *str = cur; str 3538 third_party/libxslt/libexslt/date.c xmlChar *str = NULL; str 3547 third_party/libxslt/libexslt/date.c str = xmlXPathPopString(ctxt); str 3554 third_party/libxslt/libexslt/date.c ret = exsltDateSeconds(str); str 3555 third_party/libxslt/libexslt/date.c if (str != NULL) str 3556 third_party/libxslt/libexslt/date.c xmlFree(str); str 55 third_party/libxslt/libexslt/dynamic.c xmlChar *str = NULL; str 67 third_party/libxslt/libexslt/dynamic.c str = xmlXPathPopString(ctxt); str 69 third_party/libxslt/libexslt/dynamic.c if (!str||!xmlStrlen(str)) { str 70 third_party/libxslt/libexslt/dynamic.c if (str) xmlFree(str); str 74 third_party/libxslt/libexslt/dynamic.c ret = xmlXPathEval(str,ctxt->context); str 79 third_party/libxslt/libexslt/dynamic.c "dyn:evaluate() : unable to evaluate expression '%s'\n",str); str 82 third_party/libxslt/libexslt/dynamic.c xmlFree(str); str 99 third_party/libxslt/libexslt/dynamic.c xmlChar *str = NULL; str 115 third_party/libxslt/libexslt/dynamic.c str = xmlXPathPopString(ctxt); str 126 third_party/libxslt/libexslt/dynamic.c if (str == NULL || !xmlStrlen(str) || !(comp = xmlXPathCompile(str))) { str 129 third_party/libxslt/libexslt/dynamic.c if (str != NULL) str 130 third_party/libxslt/libexslt/dynamic.c xmlFree(str); str 265 third_party/libxslt/libexslt/dynamic.c if (str != NULL) str 266 third_party/libxslt/libexslt/dynamic.c xmlFree(str); str 359 third_party/libxslt/libexslt/math.c xmlChar *str; str 372 third_party/libxslt/libexslt/math.c str = xmlStrsub(EXSLT_PI, 0, len); str 380 third_party/libxslt/libexslt/math.c str = xmlStrsub(EXSLT_E, 0, len); str 388 third_party/libxslt/libexslt/math.c str = xmlStrsub(EXSLT_SQRRT2, 0, len); str 396 third_party/libxslt/libexslt/math.c str = xmlStrsub(EXSLT_LN2, 0, len); str 404 third_party/libxslt/libexslt/math.c str = xmlStrsub(EXSLT_LN10, 0, len); str 412 third_party/libxslt/libexslt/math.c str = xmlStrsub(EXSLT_LOG2E, 0, len); str 420 third_party/libxslt/libexslt/math.c str = xmlStrsub(EXSLT_SQRT1_2, 0, len); str 423 third_party/libxslt/libexslt/math.c str = NULL; str 425 third_party/libxslt/libexslt/math.c if (str == NULL) str 427 third_party/libxslt/libexslt/math.c ret = xmlXPathCastStringToNumber(str); str 428 third_party/libxslt/libexslt/math.c xmlFree(str); str 36 third_party/libxslt/libexslt/strings.c xmlChar *str, *delimiters, *cur; str 58 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 59 third_party/libxslt/libexslt/strings.c if (xmlXPathCheckError(ctxt) || (str == NULL)) { str 77 third_party/libxslt/libexslt/strings.c for (cur = str, token = str; *cur != 0; cur += clen) { str 123 third_party/libxslt/libexslt/strings.c if (str != NULL) str 124 third_party/libxslt/libexslt/strings.c xmlFree(str); str 144 third_party/libxslt/libexslt/strings.c xmlChar *str, *delimiter, *cur; str 167 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 168 third_party/libxslt/libexslt/strings.c if (xmlXPathCheckError(ctxt) || (str == NULL)) { str 189 third_party/libxslt/libexslt/strings.c for (cur = str, token = str; *cur != 0; cur++) { str 234 third_party/libxslt/libexslt/strings.c if (str != NULL) str 235 third_party/libxslt/libexslt/strings.c xmlFree(str); str 254 third_party/libxslt/libexslt/strings.c xmlChar *str = NULL, *ret = NULL, *tmp; str 275 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 276 third_party/libxslt/libexslt/strings.c str_len = xmlUTF8Strlen(str); str 280 third_party/libxslt/libexslt/strings.c xmlFree(str); str 284 third_party/libxslt/libexslt/strings.c ret = xmlURIEscapeStr(str,(const xmlChar *)(escape_all?"-_.!~*'()":"-_.!~*'();/?:@&=+$,[]")); str 287 third_party/libxslt/libexslt/strings.c if (str != NULL) str 288 third_party/libxslt/libexslt/strings.c xmlFree(str); str 301 third_party/libxslt/libexslt/strings.c xmlChar *str = NULL, *ret = NULL, *tmp; str 320 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 321 third_party/libxslt/libexslt/strings.c str_len = xmlUTF8Strlen(str); str 325 third_party/libxslt/libexslt/strings.c xmlFree(str); str 329 third_party/libxslt/libexslt/strings.c ret = (xmlChar *) xmlURIUnescapeString((const char *)str,0,NULL); str 334 third_party/libxslt/libexslt/strings.c xmlFree(str); str 341 third_party/libxslt/libexslt/strings.c if (str != NULL) str 342 third_party/libxslt/libexslt/strings.c xmlFree(str); str 355 third_party/libxslt/libexslt/strings.c xmlChar *str = NULL, *ret = NULL, *tmp; str 363 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 364 third_party/libxslt/libexslt/strings.c str_len = xmlUTF8Strlen(str); str 367 third_party/libxslt/libexslt/strings.c if (str != NULL) xmlFree(str); str 368 third_party/libxslt/libexslt/strings.c str = xmlStrdup((const xmlChar *) " "); str 376 third_party/libxslt/libexslt/strings.c xmlFree(str); str 381 third_party/libxslt/libexslt/strings.c ret = xmlStrncat(ret, str, str_len); str 384 third_party/libxslt/libexslt/strings.c tmp = xmlUTF8Strndup (str, number); str 391 third_party/libxslt/libexslt/strings.c if (str != NULL) str 392 third_party/libxslt/libexslt/strings.c xmlFree(str); str 404 third_party/libxslt/libexslt/strings.c xmlChar *str, *padding, *alignment, *ret; str 418 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 420 third_party/libxslt/libexslt/strings.c str_l = xmlUTF8Strlen (str); str 424 third_party/libxslt/libexslt/strings.c xmlXPathReturnString (ctxt, str); str 431 third_party/libxslt/libexslt/strings.c ret = xmlUTF8Strndup (str, padding_l); str 435 third_party/libxslt/libexslt/strings.c ret = xmlStrcat (ret, str); str 441 third_party/libxslt/libexslt/strings.c ret = xmlStrcat (ret, str); str 448 third_party/libxslt/libexslt/strings.c str_s = xmlStrlen (str); str 449 third_party/libxslt/libexslt/strings.c ret = xmlStrdup (str); str 456 third_party/libxslt/libexslt/strings.c xmlFree(str); str 516 third_party/libxslt/libexslt/strings.c exsltStrReplaceInternal(const xmlChar* str, const xmlChar* searchStr, str 523 third_party/libxslt/libexslt/strings.c curr = str; str 550 third_party/libxslt/libexslt/strings.c xmlChar *str = NULL, *searchStr = NULL, *replaceStr = NULL; str 575 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 582 third_party/libxslt/libexslt/strings.c ret = exsltStrReplaceInternal(str, searchStr, replaceStr); str 591 third_party/libxslt/libexslt/strings.c str = xmlXPathPopString(ctxt); str 592 third_party/libxslt/libexslt/strings.c ret = xmlStrdup(str); str 639 third_party/libxslt/libexslt/strings.c if (str != NULL) str 640 third_party/libxslt/libexslt/strings.c xmlFree(str); str 172 third_party/libxslt/libxslt/attrvt.c const xmlChar *str; str 189 third_party/libxslt/libxslt/attrvt.c str = attr->children->content; str 190 third_party/libxslt/libxslt/attrvt.c if ((xmlStrchr(str, '{') == NULL) && str 191 third_party/libxslt/libxslt/attrvt.c (xmlStrchr(str, '}') == NULL)) return; str 195 third_party/libxslt/libxslt/attrvt.c "Found AVT %s: %s\n", attr->name, str); str 219 third_party/libxslt/libxslt/attrvt.c cur = str; str 224 third_party/libxslt/libxslt/attrvt.c ret = xmlStrncat(ret, str, cur - str); str 226 third_party/libxslt/libxslt/attrvt.c str = cur; str 230 third_party/libxslt/libxslt/attrvt.c ret = xmlStrncat(ret, str, cur - str); str 232 third_party/libxslt/libxslt/attrvt.c str = cur; str 235 third_party/libxslt/libxslt/attrvt.c if ((ret != NULL) || (cur - str > 0)) { str 236 third_party/libxslt/libxslt/attrvt.c ret = xmlStrncat(ret, str, cur - str); str 237 third_party/libxslt/libxslt/attrvt.c str = cur; str 265 third_party/libxslt/libxslt/attrvt.c str++; str 266 third_party/libxslt/libxslt/attrvt.c expr = xmlStrndup(str, cur - str); str 297 third_party/libxslt/libxslt/attrvt.c str = cur; str 301 third_party/libxslt/libxslt/attrvt.c ret = xmlStrncat(ret, str, cur - str); str 303 third_party/libxslt/libxslt/attrvt.c str = cur; str 314 third_party/libxslt/libxslt/attrvt.c if ((ret != NULL) || (cur - str > 0)) { str 315 third_party/libxslt/libxslt/attrvt.c ret = xmlStrncat(ret, str, cur - str); str 316 third_party/libxslt/libxslt/attrvt.c str = cur; str 364 third_party/libxslt/libxslt/attrvt.c int str; str 368 third_party/libxslt/libxslt/attrvt.c str = cur->strstart; str 370 third_party/libxslt/libxslt/attrvt.c if (str) { str 384 third_party/libxslt/libxslt/attrvt.c str = !str; str 174 third_party/libxslt/libxslt/extra.c char *str; str 199 third_party/libxslt/libxslt/extra.c str = (char *) obj->stringval; str 203 third_party/libxslt/libxslt/extra.c strncpy(digits, str+7, 4); str 208 third_party/libxslt/libxslt/extra.c strncpy(digits, str+12, 2); str 213 third_party/libxslt/libxslt/extra.c strncpy(digits, str+15, 2); str 218 third_party/libxslt/libxslt/extra.c strncpy(digits, str+18, 2); str 223 third_party/libxslt/libxslt/extra.c strncpy(digits, str+21, 2); str 228 third_party/libxslt/libxslt/extra.c strncpy(digits, str+24, 2); str 259 third_party/libxslt/libxslt/extra.c str = asctime(local_tm); /* "Tue Jun 26 05:02:16 2001" */ str 265 third_party/libxslt/libxslt/extra.c strncpy(result, str, 20); str 267 third_party/libxslt/libxslt/extra.c strncpy(result+23, str+19, 5); str 551 third_party/libxslt/libxslt/functions.c xmlChar *str; str 564 third_party/libxslt/libxslt/functions.c str = obj->stringval; str 565 third_party/libxslt/libxslt/functions.c if (str == NULL) { str 570 third_party/libxslt/libxslt/functions.c entity = xmlGetDocEntity(ctxt->context->doc, str); str 659 third_party/libxslt/libxslt/functions.c xmlChar str[30]; str 714 third_party/libxslt/libxslt/functions.c sprintf((char *)str, "idp%ld", val); str 716 third_party/libxslt/libxslt/functions.c sprintf((char *)str, "idm%ld", -val); str 718 third_party/libxslt/libxslt/functions.c valuePush(ctxt, xmlXPathNewString(str)); str 604 third_party/libxslt/libxslt/keys.c xmlChar *str = NULL; str 769 third_party/libxslt/libxslt/keys.c str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[0]); str 779 third_party/libxslt/libxslt/keys.c str = useRes->stringval; str 782 third_party/libxslt/libxslt/keys.c str = xmlXPathCastToString(useRes); str 790 third_party/libxslt/libxslt/keys.c if (str == NULL) str 795 third_party/libxslt/libxslt/keys.c "xsl:key : node associated to ('%s', '%s')\n", keyDef->name, str)); str 798 third_party/libxslt/libxslt/keys.c keylist = xmlHashLookup(table->keys, str); str 803 third_party/libxslt/libxslt/keys.c xmlHashAddEntry(table->keys, str, keylist); str 828 third_party/libxslt/libxslt/keys.c xmlFree(str); str 829 third_party/libxslt/libxslt/keys.c str = NULL; str 835 third_party/libxslt/libxslt/keys.c str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[k]); str 855 third_party/libxslt/libxslt/keys.c if (str) str 856 third_party/libxslt/libxslt/keys.c xmlFree(str); str 258 third_party/libxslt/libxslt/templates.c const xmlChar *str, xmlNodePtr inst) str 266 third_party/libxslt/libxslt/templates.c if (str == NULL) return(NULL); str 267 third_party/libxslt/libxslt/templates.c if (*str == 0) str 270 third_party/libxslt/libxslt/templates.c cur = str; str 275 third_party/libxslt/libxslt/templates.c ret = xmlStrncat(ret, str, cur - str); str 277 third_party/libxslt/libxslt/templates.c str = cur; str 280 third_party/libxslt/libxslt/templates.c ret = xmlStrncat(ret, str, cur - str); str 281 third_party/libxslt/libxslt/templates.c str = cur; str 287 third_party/libxslt/libxslt/templates.c ret = xmlStrncat(ret, str, cur - str); str 290 third_party/libxslt/libxslt/templates.c str++; str 291 third_party/libxslt/libxslt/templates.c expr = xmlStrndup(str, cur - str); str 322 third_party/libxslt/libxslt/templates.c str = cur; str 326 third_party/libxslt/libxslt/templates.c ret = xmlStrncat(ret, str, cur - str); str 328 third_party/libxslt/libxslt/templates.c str = cur; str 337 third_party/libxslt/libxslt/templates.c if (cur != str) { str 338 third_party/libxslt/libxslt/templates.c ret = xmlStrncat(ret, str, cur - str); str 358 third_party/libxslt/libxslt/templates.c xsltAttrTemplateValueProcess(xsltTransformContextPtr ctxt, const xmlChar *str) { str 359 third_party/libxslt/libxslt/templates.c return(xsltAttrTemplateValueProcessNode(ctxt, str, NULL)); str 70 third_party/libxslt/libxslt/templates.h const xmlChar* str, str 98 third_party/libxslt/libxslt/xslt.c double xmlXPathStringEvalNumber(const xmlChar *str); str 258 third_party/libxslt/libxslt/xslt.c xsltIsBlank(xmlChar *str) { str 259 third_party/libxslt/libxslt/xslt.c if (str == NULL) str 261 third_party/libxslt/libxslt/xslt.c while (*str != 0) { str 262 third_party/libxslt/libxslt/xslt.c if (!(IS_BLANK(*str))) return(0); str 263 third_party/libxslt/libxslt/xslt.c str++; str 1838 third_party/libxslt/libxslt/xsltInternals.h xsltIsBlank (xmlChar *str); str 473 third_party/libxslt/libxslt/xsltutils.c #define XSLT_GET_VAR_STR(msg, str) { \ str 479 third_party/libxslt/libxslt/xsltutils.c str = (char *) xmlMalloc(150); \ str 480 third_party/libxslt/libxslt/xsltutils.c if (str == NULL) \ str 487 third_party/libxslt/libxslt/xsltutils.c chars = vsnprintf(str, size, msg, ap); \ str 495 third_party/libxslt/libxslt/xsltutils.c if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\ str 496 third_party/libxslt/libxslt/xsltutils.c xmlFree(str); \ str 499 third_party/libxslt/libxslt/xsltutils.c str = larger; \ str 703 third_party/libxslt/libxslt/xsltutils.c char * str; str 715 third_party/libxslt/libxslt/xsltutils.c XSLT_GET_VAR_STR(msg, str); str 716 third_party/libxslt/libxslt/xsltutils.c error(errctx, "%s", str); str 717 third_party/libxslt/libxslt/xsltutils.c if (str != NULL) str 718 third_party/libxslt/libxslt/xsltutils.c xmlFree(str); str 1043 third_party/libxslt/libxslt/xsltutils.c xmlChar *str = res->stringval; str 1044 third_party/libxslt/libxslt/xsltutils.c res->stringval = (xmlChar *) xsltStrxfrm(comp->locale, str); str 1045 third_party/libxslt/libxslt/xsltutils.c xmlFree(str); str 2103 third_party/libxslt/libxslt/xsltutils.c xsltXPathCompile(xsltStylesheetPtr style, const xmlChar *str) { str 2138 third_party/libxslt/libxslt/xsltutils.c ret = xmlXPathCtxtCompile(xpathCtxt, str); str 244 third_party/libxslt/libxslt/xsltutils.h const xmlChar *str); str 80 third_party/modp_b64/modp_b64.cc size_t modp_b64_encode(char* dest, const char* str, size_t len) str 90 third_party/modp_b64/modp_b64.cc t1 = str[i]; t2 = str[i+1]; t3 = str[i+2]; str 102 third_party/modp_b64/modp_b64.cc t1 = str[i]; str 109 third_party/modp_b64/modp_b64.cc t1 = str[i]; t2 = str[i+1]; str 58 third_party/modp_b64/modp_b64.h size_t modp_b64_encode(char* dest, const char* str, size_t len); str 174 third_party/npapi/bindings/npruntime.h NPString str = { _val, (uint32_t)(strlen(_val)) }; \ str 175 third_party/npapi/bindings/npruntime.h (_v).value.stringValue = str; \ str 181 third_party/npapi/bindings/npruntime.h NPString str = { _val, (uint32_t)(_len) }; \ str 182 third_party/npapi/bindings/npruntime.h (_v).value.stringValue = str; \ str 508 third_party/npapi/npspy/common/npn_gate.cpp bool NPN_Evaluate(NPP id, NPObject* obj, NPString* str, NPVariant* variant) str 511 third_party/npapi/npspy/common/npn_gate.cpp logger->logCall(action_npn_evaluate, (DWORD)str); str 513 third_party/npapi/npspy/common/npn_gate.cpp bool rv = NPNFuncs.evaluate(id, obj, str, variant); str 585 third_party/npapi/npspy/extern/java/jni.h (JNIEnv *env, jstring str); str 587 third_party/npapi/npspy/extern/java/jni.h (JNIEnv *env, jstring str, jboolean *isCopy); str 589 third_party/npapi/npspy/extern/java/jni.h (JNIEnv *env, jstring str, const jchar *chars); str 594 third_party/npapi/npspy/extern/java/jni.h (JNIEnv *env, jstring str); str 596 third_party/npapi/npspy/extern/java/jni.h (JNIEnv *env, jstring str, jboolean *isCopy); str 598 third_party/npapi/npspy/extern/java/jni.h (JNIEnv *env, jstring str, const char* chars); str 1514 third_party/npapi/npspy/extern/java/jni.h jsize GetStringLength(jstring str) { str 1515 third_party/npapi/npspy/extern/java/jni.h return functions->GetStringLength(this,str); str 1517 third_party/npapi/npspy/extern/java/jni.h const jchar *GetStringChars(jstring str, jboolean *isCopy) { str 1518 third_party/npapi/npspy/extern/java/jni.h return functions->GetStringChars(this,str,isCopy); str 1520 third_party/npapi/npspy/extern/java/jni.h void ReleaseStringChars(jstring str, const jchar *chars) { str 1521 third_party/npapi/npspy/extern/java/jni.h functions->ReleaseStringChars(this,str,chars); str 1527 third_party/npapi/npspy/extern/java/jni.h jsize GetStringUTFLength(jstring str) { str 1528 third_party/npapi/npspy/extern/java/jni.h return functions->GetStringUTFLength(this,str); str 1530 third_party/npapi/npspy/extern/java/jni.h const char* GetStringUTFChars(jstring str, jboolean *isCopy) { str 1531 third_party/npapi/npspy/extern/java/jni.h return functions->GetStringUTFChars(this,str,isCopy); str 1533 third_party/npapi/npspy/extern/java/jni.h void ReleaseStringUTFChars(jstring str, const char* chars) { str 1534 third_party/npapi/npspy/extern/java/jni.h functions->ReleaseStringUTFChars(this,str,chars); str 69 third_party/npapi/npspy/extern/nspr/plstr.h PL_strlen(const char *str); str 80 third_party/npapi/npspy/extern/nspr/plstr.h PL_strnlen(const char *str, PRUint32 max); str 202 third_party/npapi/npspy/extern/plugin/npruntime.h NPString str = { _val, strlen(_val) }; \ str 203 third_party/npapi/npspy/extern/plugin/npruntime.h (_v).value.stringValue = str; \ str 209 third_party/npapi/npspy/extern/plugin/npruntime.h NPString str = { _val, _len }; \ str 210 third_party/npapi/npspy/extern/plugin/npruntime.h (_v).value.stringValue = str; \ str 267 third_party/protobuf/java/src/test/java/com/google/protobuf/TestUtil.java static ByteString toBytes(String str) { str 269 third_party/protobuf/java/src/test/java/com/google/protobuf/TestUtil.java return ByteString.copyFrom(str.getBytes("UTF-8")); str 226 third_party/protobuf/java/src/test/java/com/google/protobuf/TextFormatTest.java private ByteString bytes(String str) throws Exception { str 227 third_party/protobuf/java/src/test/java/com/google/protobuf/TextFormatTest.java return ByteString.copyFrom(str.getBytes("ISO-8859-1")); str 98 third_party/protobuf/python/google/protobuf/pyext/python-proto2.cc #define C(str) const_cast<char*>(str) str 1309 third_party/protobuf/python/google/protobuf/pyext/python-proto2.cc char str[1024]; str 1310 third_party/protobuf/python/google/protobuf/pyext/python-proto2.cc str[sizeof(str) - 1] = 0; str 1311 third_party/protobuf/python/google/protobuf/pyext/python-proto2.cc snprintf(str, sizeof(str) - 1, "CMessage: <%p>", self->message); str 1312 third_party/protobuf/python/google/protobuf/pyext/python-proto2.cc return PyString_FromString(str); str 39 third_party/protobuf/python/google/protobuf/pyext/python_descriptor.cc #define C(str) const_cast<char*>(str) str 236 third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_unittest.cc string* str = message.release_default_string(); str 238 third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_unittest.cc ASSERT_TRUE(str != NULL); str 239 third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_unittest.cc EXPECT_EQ("blah", *str); str 240 third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_unittest.cc delete str; str 206 third_party/protobuf/src/google/protobuf/compiler/importer.cc static inline char LastChar(const string& str) { str 207 third_party/protobuf/src/google/protobuf/compiler/importer.cc return str[str.size() - 1]; str 81 third_party/protobuf/src/google/protobuf/generated_message_util.h LIBPROTOBUF_EXPORT int StringSpaceUsedExcludingSelf(const string& str); str 649 third_party/protobuf/src/google/protobuf/io/coded_stream.h void WriteString(const string& str); str 651 third_party/protobuf/src/google/protobuf/io/coded_stream.h static uint8* WriteStringToArray(const string& str, uint8* target); str 1028 third_party/protobuf/src/google/protobuf/io/coded_stream.h inline void CodedOutputStream::WriteString(const string& str) { str 1029 third_party/protobuf/src/google/protobuf/io/coded_stream.h WriteRaw(str.data(), static_cast<int>(str.size())); str 1033 third_party/protobuf/src/google/protobuf/io/coded_stream.h const string& str, uint8* target) { str 1034 third_party/protobuf/src/google/protobuf/io/coded_stream.h return WriteRawToArray(str.data(), static_cast<int>(str.size()), target); str 648 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 649 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, strlen(kRawBytes))); str 650 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_EQ(kRawBytes, str); str 663 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 665 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_FALSE(coded_input.ReadString(&str, 1 << 30)); str 674 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 675 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_FALSE(coded_input.ReadString(&str, 1 << 30)); str 681 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 682 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_FALSE(coded_input.ReadString(&str, 1 << 30)); str 701 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 702 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, strlen("<Before skipping>"))); str 703 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_EQ("<Before skipping>", str); str 705 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, strlen("<After skipping>"))); str 706 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_EQ("<After skipping>", str); str 984 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 985 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, 16)); str 991 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_FALSE(coded_input.ReadString(&str, 1)); str 1000 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, 16)); str 1014 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 1015 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, 16)); str 1044 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 1045 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(input.ReadString(&str, 2048)); str 1175 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc string str; str 1176 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, 512)); str 1177 third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc EXPECT_TRUE(coded_input.ReadString(&str, 1024)); str 101 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc void WriteString(ZeroCopyOutputStream* output, const string& str); str 104 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc void ReadString(ZeroCopyInputStream* input, const string& str); str 194 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc void IoTest::WriteString(ZeroCopyOutputStream* output, const string& str) { str 195 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc EXPECT_TRUE(WriteToOutput(output, str.c_str(), str.size())); str 198 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc void IoTest::ReadString(ZeroCopyInputStream* input, const string& str) { str 199 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc scoped_array<char> buffer(new char[str.size() + 1]); str 200 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc buffer[str.size()] = '\0'; str 201 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc EXPECT_EQ(ReadFromInput(input, buffer.get(), str.size()), str.size()); str 202 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc EXPECT_STREQ(str.c_str(), buffer.get()); str 664 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc string str; str 666 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc StringOutputStream output(&str); str 670 third_party/protobuf/src/google/protobuf/io/zero_copy_stream_unittest.cc ArrayInputStream input(str.data(), str.size()); str 92 third_party/protobuf/src/google/protobuf/message_unittest.cc string temp = stream.str(); str 56 third_party/protobuf/src/google/protobuf/repeated_field_reflection_unittest.cc string str; str 57 third_party/protobuf/src/google/protobuf/repeated_field_reflection_unittest.cc SStringPrintf(&str, "%d", Func(i, 4)); str 58 third_party/protobuf/src/google/protobuf/repeated_field_reflection_unittest.cc return str; str 160 third_party/protobuf/src/google/protobuf/stubs/hash.h inline size_t operator()(const char* str) const { str 162 third_party/protobuf/src/google/protobuf/stubs/hash.h for (; *str != '\0'; str++) { str 163 third_party/protobuf/src/google/protobuf/stubs/hash.h result = 5 * result + *str; str 83 third_party/protobuf/src/google/protobuf/stubs/stl_util.h inline char* string_as_array(string* str) { str 85 third_party/protobuf/src/google/protobuf/stubs/stl_util.h return str->empty() ? NULL : &*str->begin(); str 357 third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc const char * str, str 364 third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc const uint8* isrc = reinterpret_cast<const uint8*>(str); str 467 third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc const char * str, str 473 third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc const uint8* isrc = reinterpret_cast<const uint8*>(str); str 498 third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc exit_reason = UTF8GenericScan(st, str + n, str_length - n, &rest_consumed); str 89 third_party/protobuf/src/google/protobuf/stubs/strutil.cc const char * str = str_start; str 90 third_party/protobuf/src/google/protobuf/stubs/strutil.cc for (str = strpbrk(str, remove); str 91 third_party/protobuf/src/google/protobuf/stubs/strutil.cc str != NULL; str 92 third_party/protobuf/src/google/protobuf/stubs/strutil.cc str = strpbrk(str + 1, remove)) { str 93 third_party/protobuf/src/google/protobuf/stubs/strutil.cc (*s)[str - str_start] = replacewith; str 1097 third_party/protobuf/src/google/protobuf/stubs/strutil.cc bool safe_strtof(const char* str, float* value) { str 1101 third_party/protobuf/src/google/protobuf/stubs/strutil.cc *value = strtod(str, &endptr); str 1103 third_party/protobuf/src/google/protobuf/stubs/strutil.cc *value = strtof(str, &endptr); str 1105 third_party/protobuf/src/google/protobuf/stubs/strutil.cc return *str != 0 && *endptr == 0 && errno == 0; str 80 third_party/protobuf/src/google/protobuf/stubs/strutil.h inline bool HasPrefixString(const string& str, str 82 third_party/protobuf/src/google/protobuf/stubs/strutil.h return str.size() >= prefix.size() && str 83 third_party/protobuf/src/google/protobuf/stubs/strutil.h str.compare(0, prefix.size(), prefix) == 0; str 86 third_party/protobuf/src/google/protobuf/stubs/strutil.h inline string StripPrefixString(const string& str, const string& prefix) { str 87 third_party/protobuf/src/google/protobuf/stubs/strutil.h if (HasPrefixString(str, prefix)) { str 88 third_party/protobuf/src/google/protobuf/stubs/strutil.h return str.substr(prefix.size()); str 90 third_party/protobuf/src/google/protobuf/stubs/strutil.h return str; str 102 third_party/protobuf/src/google/protobuf/stubs/strutil.h inline bool HasSuffixString(const string& str, str 104 third_party/protobuf/src/google/protobuf/stubs/strutil.h return str.size() >= suffix.size() && str 105 third_party/protobuf/src/google/protobuf/stubs/strutil.h str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; str 108 third_party/protobuf/src/google/protobuf/stubs/strutil.h inline string StripSuffixString(const string& str, const string& suffix) { str 109 third_party/protobuf/src/google/protobuf/stubs/strutil.h if (HasSuffixString(str, suffix)) { str 110 third_party/protobuf/src/google/protobuf/stubs/strutil.h return str.substr(0, str.size() - suffix.size()); str 112 third_party/protobuf/src/google/protobuf/stubs/strutil.h return str; str 955 third_party/protobuf/src/google/protobuf/text_format.cc void Print(const string& str) { str 956 third_party/protobuf/src/google/protobuf/text_format.cc Print(str.data(), str.size()); str 1236 third_party/protobuf/src/google/protobuf/text_format_unittest.cc protobuf_unittest::TestMessageSetExtension2::message_set_extension).str()); str 49 third_party/protobuf/src/google/protobuf/unknown_field_set.cc int StringSpaceUsedExcludingSelf(const string& str) { str 50 third_party/protobuf/src/google/protobuf/unknown_field_set.cc const void* start = &str; str 51 third_party/protobuf/src/google/protobuf/unknown_field_set.cc const void* end = &str + 1; str 53 third_party/protobuf/src/google/protobuf/unknown_field_set.cc if (start <= str.data() && str.data() <= end) { str 57 third_party/protobuf/src/google/protobuf/unknown_field_set.cc return str.capacity(); str 494 third_party/protobuf/src/google/protobuf/unknown_field_set_unittest.cc string* str = unknown_fields->AddLengthDelimited(1); str 498 third_party/protobuf/src/google/protobuf/unknown_field_set_unittest.cc str->assign(sizeof(string) + 1, 'x'); str 374 third_party/protobuf/src/google/protobuf/wire_format_unittest.cc EXPECT_EQ("foo", message2.str()); str 468 third_party/protobuf/src/google/protobuf/wire_format_unittest.cc unittest::TestMessageSetExtension2::message_set_extension).str()); str 190 third_party/re2/re2/prefilter.cc Prefilter* Prefilter::FromString(const string& str) { str 192 third_party/re2/re2/prefilter.cc m->atom_ = str; str 73 third_party/re2/re2/prefilter.h static Prefilter* FromString(const string& str); str 367 third_party/re2/re2/re2.cc bool RE2::Replace(string *str, str 374 third_party/re2/re2/re2.cc if (!re.Match(*str, 0, str->size(), UNANCHORED, vec, nvec)) str 381 third_party/re2/re2/re2.cc assert(vec[0].begin() >= str->data()); str 382 third_party/re2/re2/re2.cc assert(vec[0].end() <= str->data()+str->size()); str 383 third_party/re2/re2/re2.cc str->replace(vec[0].data() - str->data(), vec[0].size(), s); str 387 third_party/re2/re2/re2.cc int RE2::GlobalReplace(string *str, str 395 third_party/re2/re2/re2.cc const char* p = str->data(); str 396 third_party/re2/re2/re2.cc const char* ep = p + str->size(); str 401 third_party/re2/re2/re2.cc if (!re.Match(*str, p - str->data(), str->size(), UNANCHORED, vec, nvec)) str 423 third_party/re2/re2/re2.cc swap(out, *str); str 956 third_party/re2/re2/re2.cc bool RE2::Arg::parse_null(const char* str, int n, void* dest) { str 961 third_party/re2/re2/re2.cc bool RE2::Arg::parse_string(const char* str, int n, void* dest) { str 963 third_party/re2/re2/re2.cc reinterpret_cast<string*>(dest)->assign(str, n); str 967 third_party/re2/re2/re2.cc bool RE2::Arg::parse_stringpiece(const char* str, int n, void* dest) { str 969 third_party/re2/re2/re2.cc reinterpret_cast<StringPiece*>(dest)->set(str, n); str 973 third_party/re2/re2/re2.cc bool RE2::Arg::parse_char(const char* str, int n, void* dest) { str 976 third_party/re2/re2/re2.cc *(reinterpret_cast<char*>(dest)) = str[0]; str 980 third_party/re2/re2/re2.cc bool RE2::Arg::parse_uchar(const char* str, int n, void* dest) { str 983 third_party/re2/re2/re2.cc *(reinterpret_cast<unsigned char*>(dest)) = str[0]; str 993 third_party/re2/re2/re2.cc static const char* TerminateNumber(char* buf, const char* str, int* np) { str 996 third_party/re2/re2/re2.cc if (n > 0 && isspace(*str)) { str 1011 third_party/re2/re2/re2.cc if (n >= 1 && str[0] == '-') { str 1014 third_party/re2/re2/re2.cc str++; str 1017 third_party/re2/re2/re2.cc if (n >= 3 && str[0] == '0' && str[1] == '0') { str 1018 third_party/re2/re2/re2.cc while (n >= 3 && str[2] == '0') { str 1020 third_party/re2/re2/re2.cc str++; str 1026 third_party/re2/re2/re2.cc str--; str 1031 third_party/re2/re2/re2.cc memmove(buf, str, n); str 1040 third_party/re2/re2/re2.cc bool RE2::Arg::parse_long_radix(const char* str, str 1046 third_party/re2/re2/re2.cc str = TerminateNumber(buf, str, &n); str 1049 third_party/re2/re2/re2.cc long r = strtol(str, &end, radix); str 1050 third_party/re2/re2/re2.cc if (end != str + n) return false; // Leftover junk str 1057 third_party/re2/re2/re2.cc bool RE2::Arg::parse_ulong_radix(const char* str, str 1063 third_party/re2/re2/re2.cc str = TerminateNumber(buf, str, &n); str 1064 third_party/re2/re2/re2.cc if (str[0] == '-') { str 1072 third_party/re2/re2/re2.cc unsigned long r = strtoul(str, &end, radix); str 1073 third_party/re2/re2/re2.cc if (end != str + n) return false; // Leftover junk str 1080 third_party/re2/re2/re2.cc bool RE2::Arg::parse_short_radix(const char* str, str 1085 third_party/re2/re2/re2.cc if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse str 1092 third_party/re2/re2/re2.cc bool RE2::Arg::parse_ushort_radix(const char* str, str 1097 third_party/re2/re2/re2.cc if (!parse_ulong_radix(str, n, &r, radix)) return false; // Could not parse str 1104 third_party/re2/re2/re2.cc bool RE2::Arg::parse_int_radix(const char* str, str 1109 third_party/re2/re2/re2.cc if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse str 1116 third_party/re2/re2/re2.cc bool RE2::Arg::parse_uint_radix(const char* str, str 1121 third_party/re2/re2/re2.cc if (!parse_ulong_radix(str, n, &r, radix)) return false; // Could not parse str 1128 third_party/re2/re2/re2.cc bool RE2::Arg::parse_longlong_radix(const char* str, str 1134 third_party/re2/re2/re2.cc str = TerminateNumber(buf, str, &n); str 1137 third_party/re2/re2/re2.cc int64 r = strtoll(str, &end, radix); str 1138 third_party/re2/re2/re2.cc if (end != str + n) return false; // Leftover junk str 1145 third_party/re2/re2/re2.cc bool RE2::Arg::parse_ulonglong_radix(const char* str, str 1151 third_party/re2/re2/re2.cc str = TerminateNumber(buf, str, &n); str 1152 third_party/re2/re2/re2.cc if (str[0] == '-') { str 1159 third_party/re2/re2/re2.cc uint64 r = strtoull(str, &end, radix); str 1160 third_party/re2/re2/re2.cc if (end != str + n) return false; // Leftover junk str 1167 third_party/re2/re2/re2.cc static bool parse_double_float(const char* str, int n, bool isfloat, void *dest) { str 1172 third_party/re2/re2/re2.cc memcpy(buf, str, n); str 1193 third_party/re2/re2/re2.cc bool RE2::Arg::parse_double(const char* str, int n, void* dest) { str 1194 third_party/re2/re2/re2.cc return parse_double_float(str, n, false, dest); str 1197 third_party/re2/re2/re2.cc bool RE2::Arg::parse_float(const char* str, int n, void* dest) { str 1198 third_party/re2/re2/re2.cc return parse_double_float(str, n, true, dest); str 1203 third_party/re2/re2/re2.cc bool RE2::Arg::parse_##name(const char* str, int n, void* dest) { \ str 1204 third_party/re2/re2/re2.cc return parse_##name##_radix(str, n, dest, 10); \ str 1206 third_party/re2/re2/re2.cc bool RE2::Arg::parse_##name##_hex(const char* str, int n, void* dest) { \ str 1207 third_party/re2/re2/re2.cc return parse_##name##_radix(str, n, dest, 16); \ str 1209 third_party/re2/re2/re2.cc bool RE2::Arg::parse_##name##_octal(const char* str, int n, void* dest) { \ str 1210 third_party/re2/re2/re2.cc return parse_##name##_radix(str, n, dest, 8); \ str 1212 third_party/re2/re2/re2.cc bool RE2::Arg::parse_##name##_cradix(const char* str, int n, void* dest) { \ str 1213 third_party/re2/re2/re2.cc return parse_##name##_radix(str, n, dest, 0); \ str 370 third_party/re2/re2/re2.h static bool Replace(string *str, str 387 third_party/re2/re2/re2.h static int GlobalReplace(string *str, str 727 third_party/re2/re2/re2.h static inline bool Parse(const char* str, int n, void* dest) { str 730 third_party/re2/re2/re2.h return object->ParseFrom(str, n); str 742 third_party/re2/re2/re2.h typedef bool (*Parser)(const char* str, int n, void* dest); str 776 third_party/re2/re2/re2.h bool Parse(const char* str, int n) const; str 782 third_party/re2/re2/re2.h static bool parse_null (const char* str, int n, void* dest); str 783 third_party/re2/re2/re2.h static bool parse_char (const char* str, int n, void* dest); str 784 third_party/re2/re2/re2.h static bool parse_uchar (const char* str, int n, void* dest); str 785 third_party/re2/re2/re2.h static bool parse_float (const char* str, int n, void* dest); str 786 third_party/re2/re2/re2.h static bool parse_double (const char* str, int n, void* dest); str 787 third_party/re2/re2/re2.h static bool parse_string (const char* str, int n, void* dest); str 788 third_party/re2/re2/re2.h static bool parse_stringpiece (const char* str, int n, void* dest); str 792 third_party/re2/re2/re2.h static bool parse_ ## name(const char* str, int n, void* dest); \ str 794 third_party/re2/re2/re2.h const char* str, int n, void* dest, int radix); \ str 796 third_party/re2/re2/re2.h static bool parse_ ## name ## _hex(const char* str, int n, void* dest); \ str 797 third_party/re2/re2/re2.h static bool parse_ ## name ## _octal(const char* str, int n, void* dest); \ str 798 third_party/re2/re2/re2.h static bool parse_ ## name ## _cradix(const char* str, int n, void* dest) str 815 third_party/re2/re2/re2.h inline bool RE2::Arg::Parse(const char* str, int n) const { str 816 third_party/re2/re2/re2.h return (*parser_)(str, n, arg_); str 42 third_party/re2/re2/stringpiece.h StringPiece(const char* str) str 43 third_party/re2/re2/stringpiece.h : ptr_(str), length_((str == NULL) ? 0 : static_cast<int>(strlen(str))) { } str 44 third_party/re2/re2/stringpiece.h StringPiece(const std::string& str) str 45 third_party/re2/re2/stringpiece.h : ptr_(str.data()), length_(static_cast<int>(str.size())) { } str 59 third_party/re2/re2/stringpiece.h void set(const char* str) { str 60 third_party/re2/re2/stringpiece.h ptr_ = str; str 61 third_party/re2/re2/stringpiece.h if (str != NULL) str 62 third_party/re2/re2/stringpiece.h length_ = static_cast<int>(strlen(str)); str 1278 third_party/re2/re2/testing/re2_test.cc const string str = "ABCDEFGHIèšæ°¸é‹’"; str 1309 third_party/re2/re2/testing/re2_test.cc EXPECT_TRUE(RE2::PartialMatch(str, "(.).*?(.).*?(.)", &a, &b, &c)); str 1314 third_party/re2/re2/testing/re2_test.cc EXPECT_TRUE(RE2::PartialMatch(str, "(.).*?([\\p{L}]).*?(.)", &a, &b, &c)); str 1319 third_party/re2/re2/testing/re2_test.cc EXPECT_FALSE(RE2::PartialMatch(str, "\\P{L}")); str 1321 third_party/re2/re2/testing/re2_test.cc EXPECT_TRUE(RE2::PartialMatch(str, "(.).*?([\\p{Lu}]).*?(.)", &a, &b, &c)); str 1326 third_party/re2/re2/testing/re2_test.cc EXPECT_FALSE(RE2::PartialMatch(str, "[^\\p{Lu}\\p{Lo}]")); str 1328 third_party/re2/re2/testing/re2_test.cc EXPECT_TRUE(RE2::PartialMatch(str, ".*(.).*?([\\p{Lu}\\p{Lo}]).*?(.)", &a, &b, &c)); str 61 third_party/re2/util/logging.h string s = str_.str(); str 331 third_party/re2/util/pcre.cc bool PCRE::Replace(string *str, str 335 third_party/re2/util/pcre.cc int matches = pattern.TryMatch(*str, 0, UNANCHORED, true, vec, kVecSize); str 340 third_party/re2/util/pcre.cc if (!pattern.Rewrite(&s, rewrite, *str, vec, matches)) str 345 third_party/re2/util/pcre.cc str->replace(vec[0], vec[1] - vec[0], s); str 349 third_party/re2/util/pcre.cc int PCRE::GlobalReplace(string *str, str 358 third_party/re2/util/pcre.cc for (; start <= str->length();) { str 371 third_party/re2/util/pcre.cc matches = pattern.TryMatch(*str, start, ANCHOR_START, false, str 374 third_party/re2/util/pcre.cc if (start < str->length()) str 375 third_party/re2/util/pcre.cc out.push_back((*str)[start]); str 381 third_party/re2/util/pcre.cc matches = pattern.TryMatch(*str, start, UNANCHORED, true, vec, kVecSize); str 389 third_party/re2/util/pcre.cc out.append(*str, start, matchstart - start); str 390 third_party/re2/util/pcre.cc pattern.Rewrite(&out, rewrite, *str, vec, matches); str 399 third_party/re2/util/pcre.cc if (start < str->length()) str 400 third_party/re2/util/pcre.cc out.append(*str, start, str->length() - start); str 401 third_party/re2/util/pcre.cc swap(out, *str); str 700 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_null(const char* str, int n, void* dest) { str 705 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_string(const char* str, int n, void* dest) { str 707 third_party/re2/util/pcre.cc reinterpret_cast<string*>(dest)->assign(str, n); str 711 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_stringpiece(const char* str, int n, void* dest) { str 713 third_party/re2/util/pcre.cc reinterpret_cast<StringPiece*>(dest)->set(str, n); str 717 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_char(const char* str, int n, void* dest) { str 720 third_party/re2/util/pcre.cc *(reinterpret_cast<char*>(dest)) = str[0]; str 724 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_uchar(const char* str, int n, void* dest) { str 727 third_party/re2/util/pcre.cc *(reinterpret_cast<unsigned char*>(dest)) = str[0]; str 741 third_party/re2/util/pcre.cc static const char* TerminateNumber(char* buf, const char* str, int n) { str 742 third_party/re2/util/pcre.cc if ((n > 0) && isspace(*str)) { str 750 third_party/re2/util/pcre.cc if (isdigit(str[n]) || str 751 third_party/re2/util/pcre.cc ((str[n] >= 'a') && (str[n] <= 'f')) || str 752 third_party/re2/util/pcre.cc ((str[n] >= 'A') && (str[n] <= 'F'))) { str 754 third_party/re2/util/pcre.cc memcpy(buf, str, n); str 759 third_party/re2/util/pcre.cc return str; str 763 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_long_radix(const char* str, str 769 third_party/re2/util/pcre.cc str = TerminateNumber(buf, str, n); str 772 third_party/re2/util/pcre.cc long r = strtol(str, &end, radix); str 773 third_party/re2/util/pcre.cc if (end != str + n) return false; // Leftover junk str 780 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_ulong_radix(const char* str, str 786 third_party/re2/util/pcre.cc str = TerminateNumber(buf, str, n); str 787 third_party/re2/util/pcre.cc if (str[0] == '-') { str 795 third_party/re2/util/pcre.cc unsigned long r = strtoul(str, &end, radix); str 796 third_party/re2/util/pcre.cc if (end != str + n) return false; // Leftover junk str 803 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_short_radix(const char* str, str 808 third_party/re2/util/pcre.cc if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse str 815 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_ushort_radix(const char* str, str 820 third_party/re2/util/pcre.cc if (!parse_ulong_radix(str, n, &r, radix)) return false; // Could not parse str 827 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_int_radix(const char* str, str 832 third_party/re2/util/pcre.cc if (!parse_long_radix(str, n, &r, radix)) return false; // Could not parse str 839 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_uint_radix(const char* str, str 844 third_party/re2/util/pcre.cc if (!parse_ulong_radix(str, n, &r, radix)) return false; // Could not parse str 851 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_longlong_radix(const char* str, str 857 third_party/re2/util/pcre.cc str = TerminateNumber(buf, str, n); str 860 third_party/re2/util/pcre.cc int64 r = strtoll(str, &end, radix); str 861 third_party/re2/util/pcre.cc if (end != str + n) return false; // Leftover junk str 868 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_ulonglong_radix(const char* str, str 874 third_party/re2/util/pcre.cc str = TerminateNumber(buf, str, n); str 875 third_party/re2/util/pcre.cc if (str[0] == '-') { str 882 third_party/re2/util/pcre.cc uint64 r = strtoull(str, &end, radix); str 883 third_party/re2/util/pcre.cc if (end != str + n) return false; // Leftover junk str 890 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_double(const char* str, int n, void* dest) { str 895 third_party/re2/util/pcre.cc memcpy(buf, str, n); str 932 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_float(const char* str, int n, void* dest) { str 934 third_party/re2/util/pcre.cc if (!parse_double(str, n, &r)) return false; str 942 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_##name(const char* str, int n, void* dest) { \ str 943 third_party/re2/util/pcre.cc return parse_##name##_radix(str, n, dest, 10); \ str 945 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_##name##_hex(const char* str, int n, void* dest) { \ str 946 third_party/re2/util/pcre.cc return parse_##name##_radix(str, n, dest, 16); \ str 948 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_##name##_octal(const char* str, int n, void* dest) { \ str 949 third_party/re2/util/pcre.cc return parse_##name##_radix(str, n, dest, 8); \ str 951 third_party/re2/util/pcre.cc bool PCRE::Arg::parse_##name##_cradix(const char* str, int n, void* dest) { \ str 952 third_party/re2/util/pcre.cc return parse_##name##_radix(str, n, dest, 0); \ str 395 third_party/re2/util/pcre.h static bool Replace(string *str, str 409 third_party/re2/util/pcre.h static int GlobalReplace(string *str, str 574 third_party/re2/util/pcre.h static inline bool Parse(const char* str, int n, void* dest) { str 577 third_party/re2/util/pcre.h return object->ParseFrom(str, n); str 589 third_party/re2/util/pcre.h typedef bool (*Parser)(const char* str, int n, void* dest); str 622 third_party/re2/util/pcre.h bool Parse(const char* str, int n) const; str 628 third_party/re2/util/pcre.h static bool parse_null (const char* str, int n, void* dest); str 629 third_party/re2/util/pcre.h static bool parse_char (const char* str, int n, void* dest); str 630 third_party/re2/util/pcre.h static bool parse_uchar (const char* str, int n, void* dest); str 631 third_party/re2/util/pcre.h static bool parse_float (const char* str, int n, void* dest); str 632 third_party/re2/util/pcre.h static bool parse_double (const char* str, int n, void* dest); str 633 third_party/re2/util/pcre.h static bool parse_string (const char* str, int n, void* dest); str 634 third_party/re2/util/pcre.h static bool parse_stringpiece (const char* str, int n, void* dest); str 638 third_party/re2/util/pcre.h static bool parse_ ## name(const char* str, int n, void* dest); \ str 640 third_party/re2/util/pcre.h const char* str, int n, void* dest, int radix); \ str 642 third_party/re2/util/pcre.h static bool parse_ ## name ## _hex(const char* str, int n, void* dest); \ str 643 third_party/re2/util/pcre.h static bool parse_ ## name ## _octal(const char* str, int n, void* dest); \ str 644 third_party/re2/util/pcre.h static bool parse_ ## name ## _cradix(const char* str, int n, void* dest) str 661 third_party/re2/util/pcre.h inline bool PCRE::Arg::Parse(const char* str, int n) const { str 662 third_party/re2/util/pcre.h return (*parser_)(str, n, arg_); str 49 third_party/re2/util/rune.cc chartorune(Rune *rune, const char *str) str 58 third_party/re2/util/rune.cc c = *(unsigned char*)str; str 68 third_party/re2/util/rune.cc c1 = *(unsigned char*)(str+1) ^ Tx; str 85 third_party/re2/util/rune.cc c2 = *(unsigned char*)(str+2) ^ Tx; str 100 third_party/re2/util/rune.cc c3 = *(unsigned char*)(str+3) ^ Tx; str 125 third_party/re2/util/rune.cc runetochar(char *str, const Rune *rune) str 136 third_party/re2/util/rune.cc str[0] = c; str 145 third_party/re2/util/rune.cc str[0] = T2 | (c >> 1*Bitx); str 146 third_party/re2/util/rune.cc str[1] = Tx | (c & Maskx); str 164 third_party/re2/util/rune.cc str[0] = T3 | (c >> 2*Bitx); str 165 third_party/re2/util/rune.cc str[1] = Tx | ((c >> 1*Bitx) & Maskx); str 166 third_party/re2/util/rune.cc str[2] = Tx | (c & Maskx); str 174 third_party/re2/util/rune.cc str[0] = T4 | (c >> 3*Bitx); str 175 third_party/re2/util/rune.cc str[1] = Tx | ((c >> 2*Bitx) & Maskx); str 176 third_party/re2/util/rune.cc str[2] = Tx | ((c >> 1*Bitx) & Maskx); str 177 third_party/re2/util/rune.cc str[3] = Tx | (c & Maskx); str 184 third_party/re2/util/rune.cc char str[10]; str 186 third_party/re2/util/rune.cc return runetochar(str, &rune); str 190 third_party/re2/util/rune.cc fullrune(const char *str, int n) str 193 third_party/re2/util/rune.cc int c = *(unsigned char*)str; str 1029 third_party/simplejson/_speedups.c char *str = PyString_AS_STRING(pystr); str 1052 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1055 third_party/simplejson/_speedups.c if (idx <= end_idx && str[idx] != '}') { str 1060 third_party/simplejson/_speedups.c if (str[idx] != '"') { str 1082 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1083 third_party/simplejson/_speedups.c if (idx > end_idx || str[idx] != ':') { str 1088 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1116 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1120 third_party/simplejson/_speedups.c if (str[idx] == '}') { str 1123 third_party/simplejson/_speedups.c else if (str[idx] != ',') { str 1130 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1134 third_party/simplejson/_speedups.c if (idx > end_idx || str[idx] != '}') { str 1177 third_party/simplejson/_speedups.c Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); str 1200 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1203 third_party/simplejson/_speedups.c if (idx <= end_idx && str[idx] != '}') { str 1208 third_party/simplejson/_speedups.c if (str[idx] != '"') { str 1231 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1232 third_party/simplejson/_speedups.c if (idx > end_idx || str[idx] != ':') { str 1237 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1265 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1270 third_party/simplejson/_speedups.c if (str[idx] == '}') { str 1273 third_party/simplejson/_speedups.c else if (str[idx] != ',') { str 1280 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1285 third_party/simplejson/_speedups.c if (idx > end_idx || str[idx] != '}') { str 1328 third_party/simplejson/_speedups.c char *str = PyString_AS_STRING(pystr); str 1337 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1340 third_party/simplejson/_speedups.c if (idx <= end_idx && str[idx] != ']') { str 1360 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1364 third_party/simplejson/_speedups.c if (str[idx] == ']') { str 1367 third_party/simplejson/_speedups.c else if (str[idx] != ',') { str 1374 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1379 third_party/simplejson/_speedups.c if (idx > end_idx || str[idx] != ']') { str 1400 third_party/simplejson/_speedups.c Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); str 1409 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1412 third_party/simplejson/_speedups.c if (idx <= end_idx && str[idx] != ']') { str 1432 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1436 third_party/simplejson/_speedups.c if (str[idx] == ']') { str 1439 third_party/simplejson/_speedups.c else if (str[idx] != ',') { str 1446 third_party/simplejson/_speedups.c while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; str 1451 third_party/simplejson/_speedups.c if (idx > end_idx || str[idx] != ']') { str 1500 third_party/simplejson/_speedups.c char *str = PyString_AS_STRING(pystr); str 1508 third_party/simplejson/_speedups.c if (str[idx] == '-') { str 1517 third_party/simplejson/_speedups.c if (str[idx] >= '1' && str[idx] <= '9') { str 1519 third_party/simplejson/_speedups.c while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; str 1522 third_party/simplejson/_speedups.c else if (str[idx] == '0') { str 1532 third_party/simplejson/_speedups.c if (idx < end_idx && str[idx] == '.' && str[idx + 1] >= '0' && str[idx + 1] <= '9') { str 1535 third_party/simplejson/_speedups.c while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; str 1539 third_party/simplejson/_speedups.c if (idx < end_idx && (str[idx] == 'e' || str[idx] == 'E')) { str 1546 third_party/simplejson/_speedups.c if (idx < end_idx && (str[idx] == '-' || str[idx] == '+')) idx++; str 1549 third_party/simplejson/_speedups.c while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; str 1552 third_party/simplejson/_speedups.c if (str[idx - 1] >= '0' && str[idx - 1] <= '9') { str 1561 third_party/simplejson/_speedups.c numstr = PyString_FromStringAndSize(&str[start], idx - start); str 1603 third_party/simplejson/_speedups.c Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); str 1611 third_party/simplejson/_speedups.c if (str[idx] == '-') { str 1620 third_party/simplejson/_speedups.c if (str[idx] >= '1' && str[idx] <= '9') { str 1622 third_party/simplejson/_speedups.c while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; str 1625 third_party/simplejson/_speedups.c else if (str[idx] == '0') { str 1635 third_party/simplejson/_speedups.c if (idx < end_idx && str[idx] == '.' && str[idx + 1] >= '0' && str[idx + 1] <= '9') { str 1638 third_party/simplejson/_speedups.c while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; str 1642 third_party/simplejson/_speedups.c if (idx < end_idx && (str[idx] == 'e' || str[idx] == 'E')) { str 1647 third_party/simplejson/_speedups.c if (idx < end_idx && (str[idx] == '-' || str[idx] == '+')) idx++; str 1650 third_party/simplejson/_speedups.c while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; str 1653 third_party/simplejson/_speedups.c if (str[idx - 1] >= '0' && str[idx - 1] <= '9') { str 1662 third_party/simplejson/_speedups.c numstr = PyUnicode_FromUnicode(&str[start], idx - start); str 1693 third_party/simplejson/_speedups.c char *str = PyString_AS_STRING(pystr); str 1703 third_party/simplejson/_speedups.c switch (str[idx]) { str 1721 third_party/simplejson/_speedups.c if ((idx + 3 < length) && str[idx + 1] == 'u' && str[idx + 2] == 'l' && str[idx + 3] == 'l') { str 1731 third_party/simplejson/_speedups.c if ((idx + 3 < length) && str[idx + 1] == 'r' && str[idx + 2] == 'u' && str[idx + 3] == 'e') { str 1741 third_party/simplejson/_speedups.c if ((idx + 4 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'l' && str[idx + 3] == 's' && str[idx + 4] == 'e') { str 1751 third_party/simplejson/_speedups.c if ((idx + 2 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'N') { str 1759 third_party/simplejson/_speedups.c if ((idx + 7 < length) && str[idx + 1] == 'n' && str[idx + 2] == 'f' && str[idx + 3] == 'i' && str[idx + 4] == 'n' && str[idx + 5] == 'i' && str[idx + 6] == 't' && str[idx + 7] == 'y') { str 1767 third_party/simplejson/_speedups.c if ((idx + 8 < length) && str[idx + 1] == 'I' && str[idx + 2] == 'n' && str[idx + 3] == 'f' && str[idx + 4] == 'i' && str[idx + 5] == 'n' && str[idx + 6] == 'i' && str[idx + 7] == 't' && str[idx + 8] == 'y') { str 1793 third_party/simplejson/_speedups.c Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); str 1803 third_party/simplejson/_speedups.c switch (str[idx]) { str 1820 third_party/simplejson/_speedups.c if ((idx + 3 < length) && str[idx + 1] == 'u' && str[idx + 2] == 'l' && str[idx + 3] == 'l') { str 1830 third_party/simplejson/_speedups.c if ((idx + 3 < length) && str[idx + 1] == 'r' && str[idx + 2] == 'u' && str[idx + 3] == 'e') { str 1840 third_party/simplejson/_speedups.c if ((idx + 4 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'l' && str[idx + 3] == 's' && str[idx + 4] == 'e') { str 1850 third_party/simplejson/_speedups.c if ((idx + 2 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'N') { str 1858 third_party/simplejson/_speedups.c if ((idx + 7 < length) && str[idx + 1] == 'n' && str[idx + 2] == 'f' && str[idx + 3] == 'i' && str[idx + 4] == 'n' && str[idx + 5] == 'i' && str[idx + 6] == 't' && str[idx + 7] == 'y') { str 1866 third_party/simplejson/_speedups.c if ((idx + 8 < length) && str[idx + 1] == 'I' && str[idx + 2] == 'n' && str[idx + 3] == 'f' && str[idx + 4] == 'i' && str[idx + 5] == 'n' && str[idx + 6] == 'i' && str[idx + 7] == 't' && str[idx + 8] == 'y') { str 873 third_party/sqlite/src/ext/fts1/fts1.c char *str = malloc(n + 1); str 874 third_party/sqlite/src/ext/fts1/fts1.c memcpy(str, s, n); str 875 third_party/sqlite/src/ext/fts1/fts1.c str[n] = '\0'; str 876 third_party/sqlite/src/ext/fts1/fts1.c return str; str 461 third_party/sqlite/src/ext/fts1/fulltext.c char *str = malloc(n + 1); str 462 third_party/sqlite/src/ext/fts1/fulltext.c memcpy(str, s, n); str 463 third_party/sqlite/src/ext/fts1/fulltext.c str[n] = '\0'; str 464 third_party/sqlite/src/ext/fts1/fulltext.c return str; str 26 third_party/sqlite/src/ext/fts1/simple_tokenizer.c char *str = malloc(strlen(s) + 1); str 27 third_party/sqlite/src/ext/fts1/simple_tokenizer.c strcpy(str, s); str 28 third_party/sqlite/src/ext/fts1/simple_tokenizer.c return str; str 1792 third_party/sqlite/src/ext/fts2/fts2.c char *str = sqlite3_malloc(n + 1); str 1793 third_party/sqlite/src/ext/fts2/fts2.c memcpy(str, s, n); str 1794 third_party/sqlite/src/ext/fts2/fts2.c str[n] = '\0'; str 1795 third_party/sqlite/src/ext/fts2/fts2.c return str; str 539 third_party/sqlite/src/src/tclsqlite.c Tcl_DString str; str 541 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringInit(&str); str 542 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppend(&str, pDb->zTrace, -1); str 543 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zSql); str 544 third_party/sqlite/src/src/tclsqlite.c Tcl_Eval(pDb->interp, Tcl_DStringValue(&str)); str 545 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringFree(&str); str 557 third_party/sqlite/src/src/tclsqlite.c Tcl_DString str; str 561 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringInit(&str); str 562 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppend(&str, pDb->zProfile, -1); str 563 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zSql); str 564 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zTm); str 565 third_party/sqlite/src/src/tclsqlite.c Tcl_Eval(pDb->interp, Tcl_DStringValue(&str)); str 566 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringFree(&str); str 850 third_party/sqlite/src/src/tclsqlite.c Tcl_DString str; str 892 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringInit(&str); str 893 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppend(&str, pDb->zAuth, -1); str 894 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zCode); str 895 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : ""); str 896 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : ""); str 897 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : ""); str 898 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : ""); str 899 third_party/sqlite/src/src/tclsqlite.c rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str)); str 900 third_party/sqlite/src/src/tclsqlite.c Tcl_DStringFree(&str); str 229 third_party/sqlite/src/src/test1.c Tcl_DString *str = (Tcl_DString*)pArg; str 232 third_party/sqlite/src/src/test1.c if( Tcl_DStringLength(str)==0 ){ str 234 third_party/sqlite/src/src/test1.c Tcl_DStringAppendElement(str, name[i] ? name[i] : "NULL"); str 238 third_party/sqlite/src/src/test1.c Tcl_DStringAppendElement(str, argv[i] ? argv[i] : "NULL"); str 312 third_party/sqlite/src/src/test1.c Tcl_DString str; str 323 third_party/sqlite/src/src/test1.c Tcl_DStringInit(&str); str 325 third_party/sqlite/src/src/test1.c rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr); str 329 third_party/sqlite/src/src/test1.c Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr); str 330 third_party/sqlite/src/src/test1.c Tcl_DStringFree(&str); str 350 third_party/sqlite/src/src/test1.c Tcl_DString str; str 372 third_party/sqlite/src/src/test1.c Tcl_DStringInit(&str); str 373 third_party/sqlite/src/src/test1.c rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr); str 376 third_party/sqlite/src/src/test1.c Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr); str 377 third_party/sqlite/src/src/test1.c Tcl_DStringFree(&str); str 434 third_party/sqlite/src/src/test1.c Tcl_DString str; str 446 third_party/sqlite/src/src/test1.c Tcl_DStringInit(&str); str 457 third_party/sqlite/src/src/test1.c rc = sqlite3_exec(db, zSql, exec_printf_cb, &str, &zErr); str 461 third_party/sqlite/src/src/test1.c Tcl_AppendElement(interp, rc==SQLITE_OK ? Tcl_DStringValue(&str) : zErr); str 462 third_party/sqlite/src/src/test1.c Tcl_DStringFree(&str); str 581 third_party/sqlite/src/src/test1.c Tcl_DString str; str 599 third_party/sqlite/src/src/test1.c Tcl_DStringInit(&str); str 1167 third_party/sqlite/src/src/test8.c Tcl_DString str; str 1170 third_party/sqlite/src/src/test8.c Tcl_DStringInit(&str); str 1171 third_party/sqlite/src/src/test8.c Tcl_DStringAppendElement(&str, "::echo_glob_overload"); str 1173 third_party/sqlite/src/src/test8.c Tcl_DStringAppendElement(&str, (char*)sqlite3_value_text(apArg[i])); str 1175 third_party/sqlite/src/src/test8.c rc = Tcl_Eval(interp, Tcl_DStringValue(&str)); str 1176 third_party/sqlite/src/src/test8.c Tcl_DStringFree(&str); str 3166 third_party/sqlite/src/tool/lemon.c PRIVATE void tplt_print(FILE *out, struct lemon *lemp, char *str, int *lineno) str 3168 third_party/sqlite/src/tool/lemon.c if( str==0 ) return; str 3169 third_party/sqlite/src/tool/lemon.c while( *str ){ str 3170 third_party/sqlite/src/tool/lemon.c putc(*str,out); str 3171 third_party/sqlite/src/tool/lemon.c if( *str=='\n' ) (*lineno)++; str 3172 third_party/sqlite/src/tool/lemon.c str++; str 3174 third_party/sqlite/src/tool/lemon.c if( str[-1]!='\n' ){ str 506 third_party/talloc/libreplace/replace.c long long int rep_strtoll(const char *str, char **endptr, int base) str 509 third_party/talloc/libreplace/replace.c return strtoq(str, endptr, base); str 511 third_party/talloc/libreplace/replace.c return __strtoll(str, endptr, base); str 513 third_party/talloc/libreplace/replace.c return (long long int) strtol(str, endptr, base); str 522 third_party/talloc/libreplace/replace.c unsigned long long int rep_strtoull(const char *str, char **endptr, int base) str 525 third_party/talloc/libreplace/replace.c return strtouq(str, endptr, base); str 527 third_party/talloc/libreplace/replace.c return __strtoull(str, endptr, base); str 529 third_party/talloc/libreplace/replace.c return (unsigned long long int) strtoul(str, endptr, base); str 282 third_party/talloc/libreplace/replace.h long long int rep_strtoll(const char *str, char **endptr, int base); str 287 third_party/talloc/libreplace/replace.h unsigned long long int rep_strtoull(const char *str, char **endptr, int base); str 1189 third_party/talloc/libreplace/snprintf.c int vsnprintf (char *str, size_t count, const char *fmt, va_list args) str 1191 third_party/talloc/libreplace/snprintf.c return dopr(str, count, fmt, args); str 1202 third_party/talloc/libreplace/snprintf.c int snprintf(char *str,size_t count,const char *fmt,...) str 1208 third_party/talloc/libreplace/snprintf.c ret = vsnprintf(str, count, fmt, ap); str 1298 third_party/talloc/libreplace/snprintf.c int sprintf(char *str,const char *fmt,...); str 477 third_party/talloc/libreplace/test/testsuite.c #define TEST_STRTO_X(type,fmt,func,str,base,res,diff,rrnoo) do {\ str 482 third_party/talloc/libreplace/test/testsuite.c strlcpy(_s, str, sizeof(_s));\ str 495 third_party/talloc/libreplace/test/testsuite.c str, diff, base, res, _v, rrnoo, errno); \ str 503 third_party/talloc/libreplace/test/testsuite.c str, diff, base, res, _v); \ str 512 third_party/talloc/libreplace/test/testsuite.c str, diff, base, res, _v, _ep, _p, (int)(diff - (_ep - _p)), diff); \ str 521 third_party/talloc/libreplace/test/testsuite.c #define TEST_STRTOLL(str,base,res,diff,errnoo) TEST_STRTO_X(long long int, "%lld", strtoll,str,base,res,diff,errnoo) str 620 third_party/talloc/libreplace/test/testsuite.c #define TEST_STRTOULL(str,base,res,diff,errnoo) TEST_STRTO_X(long long unsigned int,"%llu",strtoull,str,base,res,diff,errnoo) str 44 third_party/talloc/testsuite.c #define torture_assert(test, expr, str) if (!(expr)) { \ str 46 third_party/talloc/testsuite.c test, __location__, #expr, str); \ str 69 third_party/tcmalloc/chromium/src/internal_logging.cc bool AddStr(const char* str, int n); str 132 third_party/tcmalloc/chromium/src/internal_logging.cc return AddStr(item.u_.str, strlen(item.u_.str)); str 152 third_party/tcmalloc/chromium/src/internal_logging.cc bool Logger::AddStr(const char* str, int n) { str 156 third_party/tcmalloc/chromium/src/internal_logging.cc memcpy(p_, str, n); str 72 third_party/tcmalloc/chromium/src/internal_logging.h LogItem(const char* v) : tag_(kStr) { u_.str = v; } str 91 third_party/tcmalloc/chromium/src/internal_logging.h const char* str; str 116 third_party/tcmalloc/chromium/src/internal_logging.h #define CHECK_CONDITION_PRINT(cond, str) \ str 119 third_party/tcmalloc/chromium/src/internal_logging.h ::tcmalloc::Log(::tcmalloc::kCrash, __FILE__, __LINE__, str); \ str 127 third_party/tcmalloc/chromium/src/internal_logging.h #define ASSERT_PRINT(cond, str) CHECK_CONDITION_PRINT(cond, str) str 130 third_party/tcmalloc/chromium/src/internal_logging.h #define ASSERT_PRINT(cond, str) ((void) 0) str 307 third_party/tcmalloc/chromium/src/windows/port.h inline int perftools_vsnprintf(char *str, size_t size, const char *format, str 309 third_party/tcmalloc/chromium/src/windows/port.h return vsnprintf_s(str, size, _TRUNCATE, format, ap); str 312 third_party/tcmalloc/chromium/src/windows/port.h inline int perftools_vsnprintf(char *str, size_t size, const char *format, str 316 third_party/tcmalloc/chromium/src/windows/port.h str[size-1] = '\0'; str 317 third_party/tcmalloc/chromium/src/windows/port.h return _vsnprintf(str, size-1, format, ap); str 322 third_party/tcmalloc/chromium/src/windows/port.h inline int snprintf(char *str, size_t size, const char *format, ...) { str 326 third_party/tcmalloc/chromium/src/windows/port.h r = perftools_vsnprintf(str, size, format, ap); str 353 third_party/tcmalloc/chromium/src/windows/preamble_patcher_test.cc int safe_vsnprintf(char *str, size_t size, const char *format, va_list ap) { str 356 third_party/tcmalloc/chromium/src/windows/preamble_patcher_test.cc str[size-1] = '\0'; str 357 third_party/tcmalloc/chromium/src/windows/preamble_patcher_test.cc return _vsnprintf(str, size-1, format, ap); str 68 third_party/tcmalloc/vendor/src/internal_logging.cc bool AddStr(const char* str, int n); str 131 third_party/tcmalloc/vendor/src/internal_logging.cc return AddStr(item.u_.str, strlen(item.u_.str)); str 151 third_party/tcmalloc/vendor/src/internal_logging.cc bool Logger::AddStr(const char* str, int n) { str 155 third_party/tcmalloc/vendor/src/internal_logging.cc memcpy(p_, str, n); str 72 third_party/tcmalloc/vendor/src/internal_logging.h LogItem(const char* v) : tag_(kStr) { u_.str = v; } str 91 third_party/tcmalloc/vendor/src/internal_logging.h const char* str; str 304 third_party/tcmalloc/vendor/src/windows/port.h inline int perftools_vsnprintf(char *str, size_t size, const char *format, str 306 third_party/tcmalloc/vendor/src/windows/port.h return vsnprintf_s(str, size, _TRUNCATE, format, ap); str 309 third_party/tcmalloc/vendor/src/windows/port.h inline int perftools_vsnprintf(char *str, size_t size, const char *format, str 313 third_party/tcmalloc/vendor/src/windows/port.h str[size-1] = '\0'; str 314 third_party/tcmalloc/vendor/src/windows/port.h return _vsnprintf(str, size-1, format, ap); str 319 third_party/tcmalloc/vendor/src/windows/port.h inline int snprintf(char *str, size_t size, const char *format, ...) { str 323 third_party/tcmalloc/vendor/src/windows/port.h r = perftools_vsnprintf(str, size, format, ap); str 353 third_party/tcmalloc/vendor/src/windows/preamble_patcher_test.cc int safe_vsnprintf(char *str, size_t size, const char *format, va_list ap) { str 356 third_party/tcmalloc/vendor/src/windows/preamble_patcher_test.cc str[size-1] = '\0'; str 357 third_party/tcmalloc/vendor/src/windows/preamble_patcher_test.cc return _vsnprintf(str, size-1, format, ap); str 5730 third_party/wtl/include/atlctrls.h int GetString(int nString, _CSTRING_NS::CString& str) const str 5736 third_party/wtl/include/atlctrls.h LPTSTR lpstr = str.GetBufferSetLength(nLength + 1); str 5741 third_party/wtl/include/atlctrls.h str.ReleaseBuffer(); str 1022 third_party/wtl/include/atldlgs.h static HRESULT GetFileNameFromShellItem(IShellItem* pShellItem, SIGDN type, _CSTRING_NS::CString& str) str 1031 third_party/wtl/include/atldlgs.h str = lpstrName; str 3463 third_party/wtl/include/atlmisc.h _CSTRING_NS::CString str = m_lpszRoot; str 3464 third_party/wtl/include/atlmisc.h return str; str 179 third_party/zlib/deflate.c #define INSERT_STRING(s, str, match_head) \ str 180 third_party/zlib/deflate.c (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ str 182 third_party/zlib/deflate.c s->head[s->ins_h] = (Pos)(str)) str 184 third_party/zlib/deflate.c #define INSERT_STRING(s, str, match_head) \ str 185 third_party/zlib/deflate.c (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ str 186 third_party/zlib/deflate.c match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ str 187 third_party/zlib/deflate.c s->head[s->ins_h] = (Pos)(str)) str 498 third_party/zlib/deflate.c Bytef *str; str 522 third_party/zlib/deflate.c str = s->gzhead->name; str 523 third_party/zlib/deflate.c if (str != Z_NULL) str 526 third_party/zlib/deflate.c } while (*str++); str 527 third_party/zlib/deflate.c str = s->gzhead->comment; str 528 third_party/zlib/deflate.c if (str != Z_NULL) str 531 third_party/zlib/deflate.c } while (*str++); str 1308 third_party/zlib/deflate.c Bytef *str = s->window + start; str 1316 third_party/zlib/deflate.c hash = ((hash << 5) + hash) + str[i]; str 545 third_party/zlib/gzread.c char *str; str 568 third_party/zlib/gzread.c str = buf; str 576 third_party/zlib/gzread.c if (buf == str) /* got bupkus */ str 599 third_party/zlib/gzread.c return str; str 264 third_party/zlib/gzwrite.c int ZEXPORT gzputs(file, str) str 266 third_party/zlib/gzwrite.c const char *str; str 272 third_party/zlib/gzwrite.c len = (unsigned)strlen(str); str 273 third_party/zlib/gzwrite.c ret = gzwrite(file, str, len); str 979 tools/clang/blink_gc_plugin/BlinkGCPlugin.cpp return OS.str(); str 155 tools/clang/blink_gc_plugin/Config.h static bool StartsWith(const std::string& str, const std::string& prefix) { str 156 tools/clang/blink_gc_plugin/Config.h if (prefix.size() > str.size()) str 158 tools/clang/blink_gc_plugin/Config.h return str.compare(0, prefix.size(), prefix) == 0; str 161 tools/clang/blink_gc_plugin/Config.h static bool EndsWith(const std::string& str, const std::string& suffix) { str 162 tools/clang/blink_gc_plugin/Config.h if (suffix.size() > str.size()) str 164 tools/clang/blink_gc_plugin/Config.h return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; str 242 tools/clang/plugins/ChromeClassTester.cpp OS.str()); str 184 tools/gn/command_desc.cc void operator()(const std::string& str, std::ostream& out) const { str 185 tools/gn/command_desc.cc out << " " << str << "\n"; str 226 tools/gn/command_desc.cc std::string out_str = out.str(); str 12 tools/gn/escape.cc void EscapeStringToString(const base::StringPiece& str, str 18 tools/gn/escape.cc for (size_t i = 0; i < str.size(); i++) { str 19 tools/gn/escape.cc if (str[i] == '$' && (options.mode & ESCAPE_NINJA)) { str 23 tools/gn/escape.cc } else if (str[i] == '"' && (options.mode & ESCAPE_SHELL)) { str 28 tools/gn/escape.cc } else if (str[i] == ' ') { str 45 tools/gn/escape.cc } else if (str[i] == '\'' && (options.mode & ESCAPE_JSON)) { str 49 tools/gn/escape.cc } else if (str[i] == '/' && options.convert_slashes) { str 53 tools/gn/escape.cc } else if (str[i] == '\\' && (options.mode & ESCAPE_SHELL)) { str 58 tools/gn/escape.cc } else if (str[i] == '\\' && (options.mode & ESCAPE_JSON)) { str 62 tools/gn/escape.cc dest->push_back(str[i]); str 72 tools/gn/escape.cc std::string EscapeString(const base::StringPiece& str, str 76 tools/gn/escape.cc result.reserve(str.size() + 4); // Guess we'll add a couple of extra chars. str 77 tools/gn/escape.cc EscapeStringToString(str, options, &result, needed_quoting); str 82 tools/gn/escape.cc const base::StringPiece& str, str 86 tools/gn/escape.cc result->reserve(str.size() + 4); // Guess we'll add a couple of extra chars. str 87 tools/gn/escape.cc EscapeStringToString(str, options, &result.container(), NULL); str 55 tools/gn/escape.h std::string EscapeString(const base::StringPiece& str, str 62 tools/gn/escape.h const base::StringPiece& str, str 133 tools/gn/file_template.cc void FileTemplate::ApplyString(const std::string& str, str 140 tools/gn/file_template.cc subst[i] = GetSubstitution(str, static_cast<Subrange::Type>(i)); str 260 tools/gn/file_template.cc void FileTemplate::ParseOneTemplateString(const std::string& str) { str 266 tools/gn/file_template.cc size_t next = str.find("{{", cur); str 270 tools/gn/file_template.cc if (cur != str.size()) str 271 tools/gn/file_template.cc t.container().push_back(Subrange(Subrange::LITERAL, str.substr(cur))); str 275 tools/gn/file_template.cc Subrange(Subrange::LITERAL, str.substr(cur, next - cur))); str 279 tools/gn/file_template.cc if (str.compare(next, arraysize(kSource) - 1, kSource) == 0) { str 284 tools/gn/file_template.cc } else if (str.compare(next, arraysize(kSourceNamePart) - 1, str 290 tools/gn/file_template.cc } else if (str.compare(next, arraysize(kSourceFilePart) - 1, str 136 tools/gn/file_template.h void ParseOneTemplateString(const std::string& str); str 68 tools/gn/file_template_unittest.cc out.str()); str 88 tools/gn/file_template_unittest.cc out.str()); str 252 tools/gn/filesystem_utils.cc std::string FilePathToUTF8(const base::FilePath::StringType& str) { str 254 tools/gn/filesystem_utils.cc return base::WideToUTF8(str); str 256 tools/gn/filesystem_utils.cc return str; str 333 tools/gn/filesystem_utils.cc const std::string& str, str 342 tools/gn/filesystem_utils.cc if (str.compare(0, dir_str.length() - 1, dir_str, 0, dir_str.length() - 1) str 348 tools/gn/filesystem_utils.cc + str + "\"."); str 43 tools/gn/filesystem_utils.h std::string FilePathToUTF8(const base::FilePath::StringType& str); str 106 tools/gn/filesystem_utils.h const std::string& str, str 75 tools/gn/function_write_file.cc const std::string& contents_string = contents.str(); str 14 tools/gn/label_unittest.cc const char* str; str 72 tools/gn/label_unittest.cc v.string_value() = cur.str; str 75 tools/gn/label_unittest.cc EXPECT_EQ(cur.success, !err.has_error()) << i << " " << cur.str; str 78 tools/gn/label_unittest.cc << i << " " << cur.str; str 80 tools/gn/label_unittest.cc << i << " " << cur.str; str 83 tools/gn/label_unittest.cc << i << " " << cur.str; str 85 tools/gn/label_unittest.cc << i << " " << cur.str; str 147 tools/gn/ninja_action_target_writer.cc out_, source_file_stream.str(), template_escape_options); str 32 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 60 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 83 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 128 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 160 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 217 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 260 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 321 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 366 tools/gn/ninja_action_target_writer_unittest.cc std::string out_str = out.str(); str 43 tools/gn/ninja_binary_target_writer_unittest.cc std::string out_str = out.str(); str 83 tools/gn/ninja_binary_target_writer_unittest.cc std::string out_str = out.str(); str 130 tools/gn/ninja_binary_target_writer_unittest.cc std::string out_str = out.str(); str 176 tools/gn/ninja_binary_target_writer_unittest.cc std::string out_str = out.str(); str 38 tools/gn/ninja_copy_target_writer_unittest.cc std::string out_str = out.str(); str 60 tools/gn/ninja_copy_target_writer_unittest.cc std::string out_str = out.str(); str 82 tools/gn/ninja_target_writer.cc std::string contents = file.str(); str 110 tools/gn/ninja_target_writer.cc return ret.str(); str 144 tools/gn/operators_unittest.cc Token str(Location(), Token::STRING, str_str); str 145 tools/gn/operators_unittest.cc node.set_right(scoped_ptr<ParseNode>(new LiteralNode(str))); str 18 tools/gn/output_file.h explicit OutputFile(const base::StringPiece& str) str 19 tools/gn/output_file.h : value_(str.data(), str.size()) { str 23 tools/gn/output_stream.h OutputStream& Write(const std::string& str) { str 24 tools/gn/output_stream.h return WriteBuffer(str.c_str(), str.size()); str 37 tools/gn/parser_unittest.cc EXPECT_EQ(expected, collector.str()); str 53 tools/gn/parser_unittest.cc EXPECT_EQ(expected, collector.str()); str 93 tools/gn/path_output.cc const base::StringPiece& str) const { str 101 tools/gn/path_output.cc intermediate.reserve(inverse_current_dir_.size() + str.size()); str 104 tools/gn/path_output.cc intermediate.append(str.data(), str.size()); str 113 tools/gn/path_output.cc EscapeStringToStream(out, str, options_); str 118 tools/gn/path_output.cc const base::StringPiece& str) const { str 119 tools/gn/path_output.cc DCHECK(str.size() > 0 && str[0] == '/'); str 121 tools/gn/path_output.cc if (str.substr(0, current_dir_.value().size()) == str 125 tools/gn/path_output.cc EscapeStringToStream(out, str.substr(current_dir_.value().size()), str 127 tools/gn/path_output.cc } else if (str.size() >= 2 && str[1] == '/') { str 128 tools/gn/path_output.cc WriteSourceRelativeString(out, str.substr(2)); str 135 tools/gn/path_output.cc EscapeStringToStream(out, str.substr(1), options_); str 137 tools/gn/path_output.cc EscapeStringToStream(out, str, options_); str 69 tools/gn/path_output.h void WritePathStr(std::ostream& out, const base::StringPiece& str) const; str 75 tools/gn/path_output.h const base::StringPiece& str) const; str 19 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/bar.cc", out.str()); str 25 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo.cc", out.str()); str 33 tools/gn/path_output_unittest.cc EXPECT_EQ("foo.cc bar/baz.cc", out.str()); str 40 tools/gn/path_output_unittest.cc EXPECT_EQ("C:/foo/bar.cc", out.str()); str 47 tools/gn/path_output_unittest.cc EXPECT_EQ("/foo/bar.cc", out.str()); str 60 tools/gn/path_output_unittest.cc EXPECT_EQ("foo/bar.cc", out.str()); str 66 tools/gn/path_output_unittest.cc EXPECT_EQ("foo.cc", out.str()); str 77 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/foo$ bar$$.cc", out.str()); str 83 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/\"foo\\bar\".cc", out.str()); str 94 tools/gn/path_output_unittest.cc EXPECT_EQ("\"../../foo/foo bar.cc\"", out.str()); str 100 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/\\\"foobar\\\".cc", out.str()); str 107 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo\\bar.cc", out.str()); str 109 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo\\\\bar.cc", out.str()); str 121 tools/gn/path_output_unittest.cc EXPECT_EQ("..\\..\\foo\\bar.cc", out.str()); str 123 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/bar.cc", out.str()); str 136 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/foo bar.cc", out.str()); str 148 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/bar/", out.str()); str 154 tools/gn/path_output_unittest.cc EXPECT_EQ("../../foo/bar", out.str()); str 162 tools/gn/path_output_unittest.cc EXPECT_EQ("../../", out.str()); str 168 tools/gn/path_output_unittest.cc EXPECT_EQ("../..", out.str()); str 176 tools/gn/path_output_unittest.cc EXPECT_EQ("/", out.str()); str 182 tools/gn/path_output_unittest.cc EXPECT_EQ("/", out.str()); str 188 tools/gn/path_output_unittest.cc EXPECT_EQ("/.", out.str()); str 196 tools/gn/path_output_unittest.cc EXPECT_EQ("./", out.str()); str 202 tools/gn/path_output_unittest.cc EXPECT_EQ(".", out.str()); str 208 tools/gn/path_output_unittest.cc EXPECT_EQ("foo/", out.str()); str 214 tools/gn/path_output_unittest.cc EXPECT_EQ("foo", out.str()); str 224 tools/gn/path_output_unittest.cc EXPECT_EQ("./", out.str()); str 230 tools/gn/path_output_unittest.cc EXPECT_EQ(".", out.str()); str 166 tools/gn/string_utils.cc std::string RemovePrefix(const std::string& str, const std::string& prefix) { str 167 tools/gn/string_utils.cc CHECK(str.size() >= prefix.size() && str 168 tools/gn/string_utils.cc str.compare(0, prefix.size(), prefix) == 0); str 169 tools/gn/string_utils.cc return str.substr(prefix.size()); str 42 tools/gn/string_utils.h std::string RemovePrefix(const std::string& str, const std::string& prefix); str 44 tools/gn/toolchain.cc Toolchain::ToolType Toolchain::ToolNameToType(const base::StringPiece& str) { str 45 tools/gn/toolchain.cc if (str == kToolCc) return TYPE_CC; str 46 tools/gn/toolchain.cc if (str == kToolCxx) return TYPE_CXX; str 47 tools/gn/toolchain.cc if (str == kToolObjC) return TYPE_OBJC; str 48 tools/gn/toolchain.cc if (str == kToolObjCxx) return TYPE_OBJCXX; str 49 tools/gn/toolchain.cc if (str == kToolRc) return TYPE_RC; str 50 tools/gn/toolchain.cc if (str == kToolAsm) return TYPE_ASM; str 51 tools/gn/toolchain.cc if (str == kToolAlink) return TYPE_ALINK; str 52 tools/gn/toolchain.cc if (str == kToolSolink) return TYPE_SOLINK; str 53 tools/gn/toolchain.cc if (str == kToolLink) return TYPE_LINK; str 54 tools/gn/toolchain.cc if (str == kToolStamp) return TYPE_STAMP; str 55 tools/gn/toolchain.cc if (str == kToolCopy) return TYPE_COPY; str 81 tools/gn/toolchain.h static ToolType ToolNameToType(const base::StringPiece& str); str 214 tools/gn/trace.cc return out.str(); str 290 tools/gn/trace.cc std::string out_str = out.str(); str 130 tools/gn/visibility.cc const std::string& str = value.string_value(); str 131 tools/gn/visibility.cc if (str.empty()) { str 138 tools/gn/visibility.cc size_t star = str.find('*'); str 158 tools/gn/visibility.cc size_t colon = str.find(':'); str 160 tools/gn/visibility.cc path = base::StringPiece(str); str 162 tools/gn/visibility.cc path = base::StringPiece(&str[0], colon); str 163 tools/gn/visibility.cc name = base::StringPiece(&str[colon + 1], str.size() - colon - 1); str 398 tools/imagediff/image_diff.cc base::FilePath FilePathFromASCII(const std::string& str) { str 400 tools/imagediff/image_diff.cc return base::FilePath(base::ASCIIToWide(str)); str 402 tools/imagediff/image_diff.cc return base::FilePath(str); str 399 tools/imagediff/image_diff_png.cc inline char* strdup(const char* str) { str 401 tools/imagediff/image_diff_png.cc return _strdup(str); str 403 tools/imagediff/image_diff_png.cc return ::strdup(str); str 67 tools/json_schema_compiler/test/simple_api_unittest.cc EXPECT_FALSE(params->str.get()); str 75 tools/json_schema_compiler/test/simple_api_unittest.cc EXPECT_TRUE(params->str.get()); str 76 tools/json_schema_compiler/test/simple_api_unittest.cc EXPECT_EQ("asdf", *params->str); str 87 tools/json_schema_compiler/test/simple_api_unittest.cc EXPECT_FALSE(params->str.get()); str 30 tools/traceline/traceline/main.cc std::string JSONString(const std::string& str) { str 34 tools/traceline/traceline/main.cc for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) { str 1067 tools/traceline/traceline/main.cc std::string str(&buf_[pos], kLdrBufSize); str 1068 tools/traceline/traceline/main.cc str = str.substr(0, str.find('\0')); str 1069 tools/traceline/traceline/main.cc printf("'ldrinfo': %s,\n", JSONString(str).c_str()); str 1093 tools/traceline/traceline/main.cc std::string str(&buf_[pos], kThreadNameBufSize); str 1094 tools/traceline/traceline/main.cc str = str.substr(0, str.find('\0')); str 1097 tools/traceline/traceline/main.cc JSONString(str).c_str()); str 162 ui/accessibility/ax_generated_tree_unittest.cc std::string str = TreeToString(tree); str 163 ui/accessibility/ax_generated_tree_unittest.cc EXPECT_EQ(EXPECTED_TREES[i], str); str 22 ui/accessibility/ax_node_data.cc std::string str; str 25 ui/accessibility/ax_node_data.cc str += ","; str 26 ui/accessibility/ax_node_data.cc str += IntToString(items[i]); str 28 ui/accessibility/ax_node_data.cc return str; str 100 ui/base/clipboard/clipboard_android.cc ScopedJavaLocalRef<jstring> str = ConvertUTF8ToJavaString(env, data); str 101 ui/base/clipboard/clipboard_android.cc DCHECK(str.obj()); str 103 ui/base/clipboard/clipboard_android.cc Java_Clipboard_setText(env, clipboard_manager_.obj(), str.obj()); str 714 ui/base/clipboard/clipboard_aurax11.cc std::string str(text_data, text_len); str 716 ui/base/clipboard/clipboard_aurax11.cc base::RefCountedString::TakeString(&str)); str 121 ui/base/clipboard/clipboard_gtk.cc GdkAtom StringToGdkAtom(const std::string& str) { str 122 ui/base/clipboard/clipboard_gtk.cc return gdk_atom_intern(str.c_str(), FALSE); str 72 ui/base/clipboard/clipboard_util_win.cc void SplitUrlAndTitle(const base::string16& str, str 76 ui/base/clipboard/clipboard_util_win.cc size_t newline_pos = str.find('\n'); str 78 ui/base/clipboard/clipboard_util_win.cc url->assign(str, 0, newline_pos); str 79 ui/base/clipboard/clipboard_util_win.cc title->assign(str, newline_pos + 1, base::string16::npos); str 81 ui/base/clipboard/clipboard_util_win.cc url->assign(str); str 82 ui/base/clipboard/clipboard_util_win.cc title->assign(str); str 129 ui/base/clipboard/clipboard_win.cc HGLOBAL CreateGlobalData(const std::basic_string<charT>& str) { str 131 ui/base/clipboard/clipboard_win.cc ::GlobalAlloc(GMEM_MOVEABLE, ((str.size() + 1) * sizeof(charT))); str 134 ui/base/clipboard/clipboard_win.cc memcpy(raw_data, str.data(), str.size() * sizeof(charT)); str 135 ui/base/clipboard/clipboard_win.cc raw_data[str.size()] = '\0'; str 670 ui/base/l10n/l10n_util.cc base::string16 str = rb.GetLocalizedString(message_id); str 671 ui/base/l10n/l10n_util.cc AdjustParagraphDirectionality(&str); str 673 ui/base/l10n/l10n_util.cc return str; str 71 ui/base/x/selection_utils.cc void AddString16ToVector(const base::string16& str, str 74 ui/base/x/selection_utils.cc reinterpret_cast<const unsigned char*>(str.data()); str 75 ui/base/x/selection_utils.cc bytes->insert(bytes->end(), front, front + (str.size() * 2)); str 46 ui/base/x/selection_utils.h UI_BASE_EXPORT void AddString16ToVector(const base::string16& str, str 352 ui/base/x/x11_util.h explicit XScopedString(char* str) : string_(str) {} str 104 ui/compositor/debug_utils.cc LOG(ERROR) << out.str(); str 46 ui/compositor/transform_animation_curve_adapter_unittest.cc SCOPED_TRACE(message.str()); str 16 ui/display/edid_parser_unittest.cc #define charsize(str) (arraysize(str) - 1) str 1048 ui/gfx/render_text_unittest.cc const wchar_t* str) { str 1049 ui/gfx/render_text_unittest.cc render_text->SetText(WideToUTF16(str)); str 31 ui/gfx/selection_model.cc std::string str = "{"; str 33 ui/gfx/selection_model.cc base::StringAppendF(&str, "%" PRIuS, caret_pos()); str 35 ui/gfx/selection_model.cc str += selection().ToString(); str 37 ui/gfx/selection_model.cc return str + (backward ? ",BACKWARD}" : ",FORWARD}"); str 22 ui/gfx/test/gfx_util.cc return stream.str(); str 856 ui/gfx/text_elider_unittest.cc const base::string16 str(WideToUTF16( str 867 ui/gfx/text_elider_unittest.cc EXPECT_TRUE(ElideRectangleString(str, 2, 4, true, &output)); str 869 ui/gfx/text_elider_unittest.cc EXPECT_FALSE(ElideRectangleString(str, 2, 12, true, &output)); str 875 ui/gfx/text_elider_unittest.cc const base::string16 str(UTF8ToUTF16( str 882 ui/gfx/text_elider_unittest.cc EXPECT_TRUE(ElideRectangleString(str, 3, 3, true, &output)); str 411 ui/gl/gl_bindings_skia_in_process.cc GLvoid StubGLShaderSource(GLuint shader, GLsizei count, const char* const* str, str 413 ui/gl/gl_bindings_skia_in_process.cc glShaderSource(shader, count, str, length); str 1565 ui/views/controls/textfield/textfield_unittest.cc base::string16 str; str 1594 ui/views/controls/textfield/textfield_unittest.cc base::string16 str; str 1622 ui/views/controls/textfield/textfield_unittest.cc base::string16 str; str 64 ui/views/debug_utils.cc LOG(ERROR) << out.str(); str 72 ui/views/debug_utils.cc LOG(ERROR) << out.str(); str 26 url/gurl_unittest.cc const CHAR* str) { str 27 url/gurl_unittest.cc if (str) { str 29 url/gurl_unittest.cc if (str[0]) str 30 url/gurl_unittest.cc comp.len = static_cast<int>(strlen(str)); str 31 url/gurl_unittest.cc (replacements->*func)(str, comp); str 110 url/url_canon.h void Append(const T* str, int str_len) { str 116 url/url_canon.h buffer_[cur_len_ + i] = str[i]; str 187 url/url_canon_icu.cc bool ReadUTFChar(const char* str, int* begin, int length, str 190 url/url_canon_icu.cc U8_NEXT(str, *begin, length, code_point); str 204 url/url_canon_icu.cc bool ReadUTFChar(const base::char16* str, int* begin, int length, str 206 url/url_canon_icu.cc if (U16_IS_SURROGATE(str[*begin])) { str 207 url/url_canon_icu.cc if (!U16_IS_SURROGATE_LEAD(str[*begin]) || *begin + 1 >= length || str 208 url/url_canon_icu.cc !U16_IS_TRAIL(str[*begin + 1])) { str 214 url/url_canon_icu.cc *code_point = U16_GET_SUPPLEMENTARY(str[*begin], str[*begin + 1]); str 219 url/url_canon_icu.cc *code_point = str[*begin]; str 153 url/url_canon_internal.h URL_EXPORT bool ReadUTFChar(const char* str, int* begin, int length, str 230 url/url_canon_internal.h URL_EXPORT bool ReadUTFChar(const base::char16* str, int* begin, int length, str 265 url/url_canon_internal.h inline bool AppendUTF8EscapedChar(const base::char16* str, int* begin, str 271 url/url_canon_internal.h bool success = ReadUTFChar(str, begin, length, &char_value); str 277 url/url_canon_internal.h inline bool AppendUTF8EscapedChar(const char* str, int* begin, int length, str 283 url/url_canon_internal.h bool success = ReadUTFChar(str, begin, length, &ch); str 595 url/url_canon_ip.cc char str[16]; str 596 url/url_canon_ip.cc _itoa_s(address[i], str, 10); str 598 url/url_canon_ip.cc for (int ch = 0; str[ch] != 0; ch++) str 599 url/url_canon_ip.cc output->push_back(str[ch]); str 630 url/url_canon_ip.cc char str[5]; str 631 url/url_canon_ip.cc _itoa_s(x, str, 16); str 632 url/url_canon_ip.cc for (int ch = 0; str[ch] != 0; ++ch) str 633 url/url_canon_ip.cc output->push_back(str[ch]); str 9 url/url_canon_stdstring.cc StdStringCanonOutput::StdStringCanonOutput(std::string* str) str 10 url/url_canon_stdstring.cc : CanonOutput(), str_(str) { str 38 url/url_canon_stdstring.h StdStringCanonOutput(std::string* str); str 124 url/url_canon_unittest.cc const CHAR* str) { str 125 url/url_canon_unittest.cc if (str && str[0] == kDeleteComp[0]) { str 127 url/url_canon_unittest.cc } else if (str) { str 128 url/url_canon_unittest.cc (rep->*set)(str, url_parse::Component(0, static_cast<int>(strlen(str)))); str 269 url/url_canon_unittest.cc std::string str; str 270 url/url_canon_unittest.cc url_canon::StdStringCanonOutput output(&str); str 277 url/url_canon_unittest.cc EXPECT_STREQ(icu_cases[i].expected, str.c_str()); str 49 url/url_parse_internal.h inline int CountConsecutiveSlashes(const CHAR *str, str 53 url/url_parse_internal.h IsURLSlash(str[begin_offset + count])) str 23 url/url_test_utils.h base::string16 str; str 26 url/url_test_utils.h str.push_back(static_cast<base::char16>(src[i])); str 28 url/url_test_utils.h return str; str 42 url/url_test_utils.h std::string str; str 43 url/url_test_utils.h url_canon::StdStringCanonOutput output(&str); str 48 url/url_test_utils.h return str; str 99 url/url_util.cc bool DoFindAndCompareScheme(const CHAR* str, str 107 url/url_util.cc const CHAR* spec = RemoveURLWhitespace(str, str_len, str 418 url/url_util.cc bool FindAndCompareScheme(const char* str, str 422 url/url_util.cc return DoFindAndCompareScheme(str, str_len, compare, found_scheme); str 425 url/url_util.cc bool FindAndCompareScheme(const base::char16* str, str 429 url/url_util.cc return DoFindAndCompareScheme(str, str_len, compare, found_scheme); str 66 url/url_util.h URL_EXPORT bool FindAndCompareScheme(const char* str, str 70 url/url_util.h URL_EXPORT bool FindAndCompareScheme(const base::char16* str, str 74 url/url_util.h inline bool FindAndCompareScheme(const std::string& str, str 77 url/url_util.h return FindAndCompareScheme(str.data(), static_cast<int>(str.size()), str 80 url/url_util.h inline bool FindAndCompareScheme(const base::string16& str, str 83 url/url_util.h return FindAndCompareScheme(str.data(), static_cast<int>(str.size()), str 110 webkit/browser/fileapi/file_system_url.cc return ss.str(); str 170 webkit/common/database/database_identifier_unittest.cc std::string str; str 206 webkit/common/database/database_identifier_unittest.cc DatabaseIdentifier::Parse(valid_cases[i].str); str 208 webkit/common/database/database_identifier_unittest.cc << "test case " << valid_cases[i].str; str 210 webkit/common/database/database_identifier_unittest.cc << "test case " << valid_cases[i].str; str 212 webkit/common/database/database_identifier_unittest.cc << "test case " << valid_cases[i].str; str 214 webkit/common/database/database_identifier_unittest.cc << "test case " << valid_cases[i].str; str 216 webkit/common/database/database_identifier_unittest.cc << "test case " << valid_cases[i].str; str 26 win8/metro_driver/winrt_utils.cc HSTRING MakeHString(const base::string16& str) { str 28 win8/metro_driver/winrt_utils.cc if (FAILED(::WindowsCreateString(str.c_str(), static_cast<UINT32>(str.size()), str 36 win8/metro_driver/winrt_utils.cc const wchar_t* str; str 38 win8/metro_driver/winrt_utils.cc str = ::WindowsGetStringRawBuffer(hstring, &size); str 41 win8/metro_driver/winrt_utils.cc return base::string16(str, size); str 15 win8/metro_driver/winrt_utils.h void CheckHR(HRESULT hr, const char* str = nullptr); str 17 win8/metro_driver/winrt_utils.h HSTRING MakeHString(const base::string16& str);