Move URL from WebCore to WTF
[WebKit-https.git] / Source / WebKit / NetworkProcess / capture / NetworkCaptureManager.cpp
1 /*
2  * Copyright (C) 2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "NetworkCaptureManager.h"
28
29 #if ENABLE(NETWORK_CAPTURE)
30
31 #include "NetworkCaptureLogging.h"
32 #include "NetworkCaptureResource.h"
33 #include <WebCore/ResourceRequest.h>
34 #include <algorithm>
35 #include <iterator>
36 #include <limits>
37 #include <wtf/MD5.h>
38 #include <wtf/NeverDestroyed.h>
39 #include <wtf/URL.h>
40 #include <wtf/text/Base64.h>
41 #include <wtf/text/StringBuilder.h>
42
43 #define DEBUG_CLASS Manager
44
45 namespace WebKit {
46 namespace NetworkCapture {
47
48 using namespace WebCore::FileSystem;
49
50 static const char* kDirNameRecordReplay = "WebKitPerf/record_replay";
51 static const char* kDirNameResources = "resources";
52 static const char* kFileNameReportLoad = "report_load.txt";
53 static const char* kFileNameReportRecord = "report_record.txt";
54 static const char* kFileNameReportReplay = "report_replay.txt";
55
56 static int kMaxMatch = std::numeric_limits<int>::max();
57 static int kMinMatch = std::numeric_limits<int>::min();
58
59 Manager& Manager::singleton()
60 {
61     static NeverDestroyed<Manager> instance;
62     return instance;
63 }
64
65 void Manager::initialize(const String& recordReplayMode, const String& recordReplayCacheLocation)
66 {
67     if (equalIgnoringASCIICase(recordReplayMode, "record")) {
68         DEBUG_LOG("Initializing: recording mode");
69         m_recordReplayMode = Record;
70     } else if (equalIgnoringASCIICase(recordReplayMode, "replay")) {
71         DEBUG_LOG("Initializing: replay mode");
72         m_recordReplayMode = Replay;
73     } else {
74         DEBUG_LOG("Initializing: disabled");
75         m_recordReplayMode = Disabled;
76     }
77
78     m_recordReplayCacheLocation = pathByAppendingComponent(recordReplayCacheLocation, kDirNameRecordReplay);
79     DEBUG_LOG("Cache location = " STRING_SPECIFIER, DEBUG_STR(m_recordReplayCacheLocation));
80
81     if (isRecording()) {
82         m_recordFileHandle = WebCore::FileHandle(reportRecordPath(), FileOpenMode::Write);
83     } else if (isReplaying()) {
84         m_recordFileHandle = WebCore::FileHandle(reportRecordPath(), FileOpenMode::Read);
85         m_loadFileHandle = WebCore::FileHandle(reportLoadPath(), FileOpenMode::Write);
86         m_replayFileHandle = WebCore::FileHandle(reportReplayPath(), FileOpenMode::Write);
87         loadResources();
88     }
89 }
90
91 void Manager::terminate()
92 {
93     m_loadFileHandle.close();
94     m_recordFileHandle.close();
95     m_replayFileHandle.close();
96 }
97
98 Resource* Manager::findMatch(const WebCore::ResourceRequest& request)
99 {
100     DEBUG_LOG_VERBOSE("URL = " STRING_SPECIFIER, DEBUG_STR(request.url().string()));
101
102     auto bestMatch = findExactMatch(request);
103     if (!bestMatch)
104         bestMatch = findBestFuzzyMatch(request);
105
106 #if CAPTURE_INTERNAL_DEBUGGING
107     if (!bestMatch)
108         DEBUG_LOG("Could not find match for: " STRING_SPECIFIER, DEBUG_STR(request.url().string()));
109     else if (request.url() == bestMatch->url())
110         DEBUG_LOG("Found exact match for: " STRING_SPECIFIER, DEBUG_STR(request.url().string()));
111     else {
112         DEBUG_LOG("Found fuzzy match for: " STRING_SPECIFIER, DEBUG_STR(request.url().string()));
113         DEBUG_LOG("       replaced with : " STRING_SPECIFIER, DEBUG_STR(bestMatch->url().string()));
114     }
115 #endif
116
117     return bestMatch;
118 }
119
120 Resource* Manager::findExactMatch(const WebCore::ResourceRequest& request)
121 {
122     const auto& url = request.url();
123     auto lower = std::lower_bound(std::begin(m_cachedResources), std::end(m_cachedResources), url, [](auto& resource, const auto& url) {
124         return WTF::codePointCompareLessThan(resource.url().string(), url.string());
125     });
126
127     if (lower != std::end(m_cachedResources) && lower->url() == url) {
128         DEBUG_LOG_VERBOSE("Found exact match: " STRING_SPECIFIER, DEBUG_STR(lower->url().string()));
129         return &*lower;
130     }
131
132     return nullptr;
133 }
134
135 Resource* Manager::findBestFuzzyMatch(const WebCore::ResourceRequest& request)
136 {
137     const auto& url = request.url();
138     const auto& urlIdentifyingCommonDomain = Manager::urlIdentifyingCommonDomain(url);
139
140     const auto& lower = std::lower_bound(std::begin(m_cachedResources), std::end(m_cachedResources), urlIdentifyingCommonDomain, [](auto& resource, const auto& urlIdentifyingCommonDomain) {
141         return WTF::codePointCompareLessThan(resource.urlIdentifyingCommonDomain(), urlIdentifyingCommonDomain);
142     });
143     const auto& upper = std::upper_bound(lower, std::end(m_cachedResources), urlIdentifyingCommonDomain, [](const auto& urlIdentifyingCommonDomain, auto& resource) {
144         return WTF::codePointCompareLessThan(urlIdentifyingCommonDomain, resource.urlIdentifyingCommonDomain());
145     });
146
147     Resource* bestMatch = nullptr;
148     int bestScore = kMinMatch;
149     const auto& requestParameters = WTF::URLParser::parseURLEncodedForm(url.query());
150     for (auto iResource = lower; iResource != upper; ++iResource) {
151         int thisScore = fuzzyMatchURLs(url, requestParameters, iResource->url(), iResource->queryParameters());
152         // TODO: Consider ignoring any matches < 0 as being too different.
153         if (bestScore < thisScore) {
154             DEBUG_LOG("New best match (%d): " STRING_SPECIFIER, thisScore, DEBUG_STR(iResource->url().string()));
155             bestScore = thisScore;
156             bestMatch = &*iResource;
157             if (bestScore == kMaxMatch)
158                 break;
159         }
160     }
161
162     return bestMatch;
163 }
164
165 // TODO: Convert to an interface based on ResourceRequest so that we can do
166 // deeper matching.
167
168 int Manager::fuzzyMatchURLs(const URL& requestURL, const WTF::URLParser::URLEncodedForm& requestParameters, const URL& resourceURL, const WTF::URLParser::URLEncodedForm& resourceParameters)
169 {
170     // TODO: consider requiring that any trailing suffixes (e.g., ".js",
171     // ".png", ".css", ".html", etc.) should be an exact match.
172
173     // We do fuzzy matching on the path and query parameters. So let's first
174     // make sure that all the other parts are equal.
175
176     // If scheme, host, and port don't all match, return this as the "worst"
177     // match.
178
179     if (!protocolHostAndPortAreEqual(requestURL, resourceURL)) {
180         DEBUG_LOG("Scheme/host/port mismatch: " STRING_SPECIFIER " != " STRING_SPECIFIER, DEBUG_STR(requestURL.string()), DEBUG_STR(resourceURL.string()));
181         return kMinMatch;
182     }
183
184     // If fragments don't match, return this as the "worst" match.
185
186     if (requestURL.fragmentIdentifier() != resourceURL.fragmentIdentifier()) {
187         DEBUG_LOG("Fragments mismatch: " STRING_SPECIFIER " != " STRING_SPECIFIER, DEBUG_STR(requestURL.string()), DEBUG_STR(resourceURL.string()));
188         return kMinMatch;
189     }
190
191     DEBUG_LOG("Fuzzy matching:");
192     DEBUG_LOG("   : " STRING_SPECIFIER, DEBUG_STR(requestURL.string()));
193     DEBUG_LOG("   : " STRING_SPECIFIER, DEBUG_STR(resourceURL.string()));
194
195     // Compare the path components and the query parameters. Score each partial
196     // match as +4, each mismatch as -1, and each missing component as -1.
197     //
198     // Note that at the current time these values are rather arbitrary and
199     // could fine-tuned.
200
201     const int kPathMatchScore = 4;
202     const int kPathMismatchScore = -1;
203     const int kPathMissingScore = -1;
204     const int kParameterMatchScore = 4;
205     const int kParameterMismatchScore = -1;
206     const int kParameterMissingScore = -1;
207
208     int score = 0;
209
210     // Quantize the differences in URL paths.
211     //
212     // The approach here is to increase our score for each matching path
213     // component, and to subtract for each differing component as well as for
214     // components that exist in one path but not the other.
215
216     const auto& requestPath = requestURL.path();
217     const auto& resourcePath = resourceURL.path();
218
219     Vector<String> requestPathComponents = requestPath.split('/');
220     Vector<String> resourcePathComponents = resourcePath.split('/');
221
222     auto updatedIterators = std::mismatch(
223         std::begin(requestPathComponents), std::end(requestPathComponents),
224         std::begin(resourcePathComponents), std::end(resourcePathComponents));
225
226     auto matchingDistance = std::distance(std::begin(requestPathComponents), updatedIterators.first);
227     auto requestPathMismatchDistance = std::distance(updatedIterators.first, std::end(requestPathComponents));
228     auto resourcePathMismatchDistance = std::distance(updatedIterators.second, std::end(resourcePathComponents));
229     decltype(matchingDistance) mismatchingDistance;
230     decltype(matchingDistance) missingDistance;
231     if (requestPathMismatchDistance < resourcePathMismatchDistance) {
232         mismatchingDistance = requestPathMismatchDistance;
233         missingDistance = resourcePathMismatchDistance - requestPathMismatchDistance;
234     } else {
235         mismatchingDistance = resourcePathMismatchDistance;
236         missingDistance = requestPathMismatchDistance - resourcePathMismatchDistance;
237     }
238
239     DEBUG_LOG("Path matching results: matching = %d, mismatching = %d, missing = %d",
240         static_cast<int>(matchingDistance),
241         static_cast<int>(mismatchingDistance),
242         static_cast<int>(missingDistance));
243
244     score += matchingDistance * kPathMatchScore
245         + mismatchingDistance * kPathMismatchScore
246         + missingDistance * kPathMissingScore;
247     DEBUG_LOG("Score = %d", score);
248
249     // Quantize the differences in query parameters.
250     //
251     // The approach here is to walk lock-step over the two sets of query
252     // parameters. For each pair of parameters for each URL, we compare their
253     // names and values. If the names and values match, we add a high score. If
254     // just the names match, we add a lower score.
255     //
256     // If the names don't match, we then assume that some intervening query
257     // parameters have been added to one or the other URL. We therefore try to
258     // sync up the iterators used to traverse the query parameter collections
259     // so that they're again pointing to parameters with the same names. We
260     // first start scanning forward down the query parameters for one URL,
261     // looking for one with the same name as the one we're on in the other URL.
262     // If that doesn't turn up a match, we reverse the roles of the query
263     // parameters perform the same process of scanning forward. If neither of
264     // these scans produces a match, we figure that each query parameter we're
265     // looking at from each of the query parameter collections is unique. We
266     // deduct points from the overall score and move on to the next query
267     // parameters in each set.
268     //
269     // If, on the other hand, the forward-scanning does turn up a match, we
270     // adjust out iterators so that they're now again pointing to query
271     // parameters with the same name. This synchronization involves skipping
272     // over any intervening query parameters in one collection or the other.
273     // The assumption here is that these intervening query parameters are
274     // insertions that exist in one URL but not the other. We treat them as
275     // such, subtracting from the overall score for each one. However, this
276     // assumption might easily be incorrect. It might be that the query
277     // parameters that we're skipping over in one URL might exist in the other
278     // URL. If so, then we are foregoing the possibility of using those matches
279     // to increase the overall match score between the two URLs.
280     //
281     // To address this problem, we might want to consider sorting the query
282     // parameters by their names. However, doing this may cause problems if the
283     // order of the parameters is significant. So if we decide to take the
284     // approach of sorting the parameters, keep in mind this possible drawback.
285
286     auto requestParameter = std::begin(requestParameters);
287     auto resourceParameter = std::begin(resourceParameters);
288
289     for (; requestParameter != std::end(requestParameters) && resourceParameter != std::end(resourceParameters); ++requestParameter, ++resourceParameter) {
290         if (requestParameter->key == resourceParameter->key) {
291 #if CAPTURE_INTERNAL_DEBUGGING
292             if (requestParameter->value == resourceParameter->value)
293                 DEBUG_LOG("Matching parameter names and values: \"" STRING_SPECIFIER "\" = \"" STRING_SPECIFIER "\"", DEBUG_STR(requestParameter->first), DEBUG_STR(requestParameter->second));
294             else
295                 DEBUG_LOG("Mismatching parameter values: \"" STRING_SPECIFIER "\" = \"" STRING_SPECIFIER "\" vs. \"" STRING_SPECIFIER "\"", DEBUG_STR(requestParameter->first), DEBUG_STR(requestParameter->second), DEBUG_STR(resourceParameter->second));
296 #endif
297             score += (requestParameter->value == resourceParameter->value) ? kParameterMatchScore : kParameterMismatchScore;
298             DEBUG_LOG("Score = %d", score);
299         } else {
300             DEBUG_LOG("Mismatching parameter names: " STRING_SPECIFIER ", " STRING_SPECIFIER, DEBUG_STR(requestParameter->first), DEBUG_STR(resourceParameter->first));
301
302             const auto scanForwardForMatch = [&score, kParameterMatchScore, kParameterMismatchScore, kParameterMissingScore](const auto& fixedIter, auto& scanningIter, const auto& scannerEnd) {
303                 auto scanner = scanningIter;
304                 while (scanner != scannerEnd && scanner->key != fixedIter->key)
305                     ++scanner;
306                 if (scanner == scannerEnd)
307                     return false;
308                 DEBUG_LOG("Skipping past %d non-matching parameter names", static_cast<int>(std::distance(scanningIter, scanner)));
309                 score += kParameterMissingScore * std::distance(scanningIter, scanner);
310                 DEBUG_LOG("Score = %d", score);
311 #if CAPTURE_INTERNAL_DEBUGGING
312                 if (fixedIter->second == scanner->second)
313                     DEBUG_LOG("Matching parameter names and values: \"" STRING_SPECIFIER "\" = \"" STRING_SPECIFIER "\"", DEBUG_STR(fixedIter->first), DEBUG_STR(fixedIter->second));
314                 else
315                     DEBUG_LOG("Mismatching parameter values: \"" STRING_SPECIFIER "\" = \"" STRING_SPECIFIER "\" vs. \"" STRING_SPECIFIER "\"", DEBUG_STR(fixedIter->first), DEBUG_STR(fixedIter->second), DEBUG_STR(scanner->second));
316 #endif
317                 score += (fixedIter->value == scanner->value) ? kParameterMatchScore : kParameterMismatchScore;
318                 DEBUG_LOG("Score = %d", score);
319                 scanningIter = scanner;
320                 return true;
321             };
322
323             if (!scanForwardForMatch(requestParameter, resourceParameter, std::end(resourceParameters))) {
324                 if (!scanForwardForMatch(resourceParameter, requestParameter, std::end(requestParameters))) {
325                     DEBUG_LOG("Unmatched parameter: " STRING_SPECIFIER "=" STRING_SPECIFIER, DEBUG_STR(requestParameter->first), DEBUG_STR(requestParameter->second));
326                     DEBUG_LOG("Unmatched parameter: " STRING_SPECIFIER "=" STRING_SPECIFIER, DEBUG_STR(resourceParameter->first), DEBUG_STR(resourceParameter->second));
327                     score += kParameterMissingScore + kParameterMissingScore;
328                     DEBUG_LOG("Score = %d", score);
329                 }
330             }
331         }
332     }
333
334     DEBUG_LOG("Adjusting for trailing parameters");
335     score += kParameterMissingScore
336         * (std::distance(requestParameter, std::end(requestParameters))
337             + std::distance(resourceParameter, std::end(resourceParameters)));
338     DEBUG_LOG("Score = %d", score);
339
340     return score;
341 }
342
343 void Manager::loadResources()
344 {
345     auto lines = readFile(reportRecordPath());
346     if (!lines)
347         return;
348
349     for (const auto& line : *lines) {
350         if (line.size() != 2) {
351             DEBUG_LOG_ERROR("line.size == %d", (int) line.size());
352             continue;
353         }
354
355         Resource newResource(hashToPath(line[0]));
356         m_cachedResources.append(WTFMove(newResource));
357     }
358
359     std::sort(std::begin(m_cachedResources), std::end(m_cachedResources), [](auto& left, auto& right) {
360         return WTF::codePointCompareLessThan(left.url().string(), right.url().string());
361     });
362
363     for (auto& resource : m_cachedResources)
364         logLoadedResource(resource);
365 }
366
367 String Manager::reportLoadPath()
368 {
369     return pathByAppendingComponent(m_recordReplayCacheLocation, kFileNameReportLoad);
370 }
371
372 String Manager::reportRecordPath()
373 {
374     return pathByAppendingComponent(m_recordReplayCacheLocation, kFileNameReportRecord);
375 }
376
377 String Manager::reportReplayPath()
378 {
379     return pathByAppendingComponent(m_recordReplayCacheLocation, kFileNameReportReplay);
380 }
381
382 String Manager::requestToPath(const WebCore::ResourceRequest& request)
383 {
384     // TODO: come up with a more comprehensive hash that includes HTTP method
385     // and possibly other values (such as headers).
386
387     const auto& hash = stringToHash(request.url().string());
388     const auto& path = hashToPath(hash);
389     return path;
390 }
391
392 String Manager::stringToHash(const String& s)
393 {
394     WTF::MD5 md5;
395     if (s.characters8())
396         md5.addBytes(static_cast<const uint8_t*>(s.characters8()), s.length());
397     else
398         md5.addBytes(reinterpret_cast<const uint8_t*>(s.characters16()), 2 * s.length());
399
400     WTF::MD5::Digest digest;
401     md5.checksum(digest);
402
403     return WTF::base64URLEncode(&digest[0], WTF::MD5::hashSize);
404 }
405
406 String Manager::hashToPath(const String& hash)
407 {
408     auto hashHead = hash.substring(0, 2);
409     auto hashTail = hash.substring(2);
410
411     StringBuilder fileName;
412     fileName.append(hashTail);
413     fileName.appendLiteral(".data");
414
415     auto path = pathByAppendingComponent(m_recordReplayCacheLocation, kDirNameResources);
416     path = pathByAppendingComponent(path, hashHead);
417     path = pathByAppendingComponent(path, fileName.toString());
418
419     return path;
420 }
421
422 String Manager::urlIdentifyingCommonDomain(const URL& url)
423 {
424     return url.protocolHostAndPort();
425 }
426
427 void Manager::logRecordedResource(const WebCore::ResourceRequest& request)
428 {
429     // Log network resources as they are cached to disk.
430
431     const auto& url = request.url();
432     m_recordFileHandle.printf("%s %s\n", DEBUG_STR(stringToHash(url.string())), DEBUG_STR(url.string()));
433 }
434
435 void Manager::logLoadedResource(Resource& resource)
436 {
437     // Log cached resources as they are loaded from disk.
438
439     m_loadFileHandle.printf("%s\n", DEBUG_STR(resource.url().string()));
440 }
441
442 void Manager::logPlayedBackResource(const WebCore::ResourceRequest& request, bool wasCacheMiss)
443 {
444     // Log network resources that are requested during replay.
445
446     const auto& url = request.url();
447
448     if (wasCacheMiss)
449         DEBUG_LOG("Cache miss: URL = " STRING_SPECIFIER, DEBUG_STR(url.string()));
450     else
451         DEBUG_LOG("Cache hit:  URL = " STRING_SPECIFIER, DEBUG_STR(url.string()));
452
453     m_replayFileHandle.printf("%s %s\n", wasCacheMiss ? "miss" : "hit ", DEBUG_STR(url.string()));
454 }
455
456 WebCore::FileHandle Manager::openCacheFile(const String& filePath, FileOpenMode mode)
457 {
458     // If we can trivially open the file, then do that and return the new file
459     // handle.
460
461     auto fileHandle = WebCore::FileHandle(filePath, mode);
462     if (fileHandle.open())
463         return fileHandle;
464
465     // If we're opening the file for writing (including appending), then try
466     // again after making sure all intermediate directories have been created.
467
468     if (mode != FileOpenMode::Read) {
469         const auto& parentDir = directoryName(filePath);
470         if (!makeAllDirectories(parentDir)) {
471             DEBUG_LOG_ERROR("Error %d trying to create intermediate directories: " STRING_SPECIFIER, errno, DEBUG_STR(parentDir));
472             return fileHandle;
473         }
474
475         fileHandle = WebCore::FileHandle(filePath, mode);
476         if (fileHandle.open())
477             return fileHandle;
478     }
479
480     // Could not open the file. Log the error and leave, returning the invalid
481     // file handle.
482
483     if (mode == FileOpenMode::Read)
484         DEBUG_LOG_ERROR("Error %d trying to open " STRING_SPECIFIER " for reading", errno, DEBUG_STR(filePath));
485     else
486         DEBUG_LOG_ERROR("Error %d trying to open " STRING_SPECIFIER " for writing", errno, DEBUG_STR(filePath));
487
488     return fileHandle;
489 }
490
491 std::optional<Vector<Vector<String>>> Manager::readFile(const String& filePath)
492 {
493     bool success = false;
494     MappedFileData file(filePath, success);
495     if (!success)
496         return std::nullopt;
497
498     Vector<Vector<String>> lines;
499     auto begin = static_cast<const uint8_t*>(file.data());
500     auto end = begin + file.size();
501
502     Vector<String> line;
503     while (getLine(begin, end, line))
504         lines.append(WTFMove(line));
505
506     return WTFMove(lines);
507 }
508
509 bool Manager::getLine(uint8_t const *& p, uint8_t const * const end, Vector<String>& line)
510 {
511     // NB: Returns true if there may be more data to get, false if we've hit
512     // the end of the buffer.
513
514     DEBUG_LOG_VERBOSE("Getting a line");
515
516     line.clear();
517
518     if (p == end) {
519         DEBUG_LOG_VERBOSE("Iterator at end; returning false");
520         return false;
521     }
522
523     String word;
524     while (getWord(p, end, word)) {
525         if (!word.isEmpty()) {
526             DEBUG_LOG_VERBOSE("Adding word: " STRING_SPECIFIER, DEBUG_STR(word));
527             line.append(word);
528         }
529     }
530
531     return true;
532 }
533
534 bool Manager::getWord(uint8_t const *& p, uint8_t const * const end, String& word)
535 {
536     // NB: Returns true if a (possibly empty) word was found and there may be
537     // more, false if we've hit the end of line or buffer.
538
539     DEBUG_LOG_VERBOSE("Getting a word");
540
541     if (p == end) {
542         DEBUG_LOG_VERBOSE("Iterator at end; returning false");
543         return false;
544     }
545
546     if (*p == '\n') {
547         DEBUG_LOG_VERBOSE("Iterator hit EOL; returning false");
548         ++p;
549         return false;
550     }
551
552     bool escaping = false;
553     bool ignoring = false;
554
555     word = String();
556
557     DEBUG_LOG_VERBOSE("Iterating");
558
559     for ( ; p != end; ++p) {
560         if (ignoring) {
561             if (*p == '\n')
562                 break;
563         } else if (escaping) {
564             word.append(*p);
565             escaping = false;
566         } else if (*p == '#') {
567             ignoring = true;
568         } else if (*p == '\\') {
569             escaping = true;
570         } else if (*p == ' ') {
571             if (!word.isEmpty())
572                 break;
573         } else if (*p == '\n')
574             break;
575         else
576             word.append(*p);
577     }
578
579     return true;
580 }
581
582 } // namespace NetworkCapture
583 } // namespace WebKit
584
585 #undef DEBUG_CLASS
586
587 #endif // ENABLE(NETWORK_CAPTURE)