1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/common/net/url_fixer_upper.h"
#include <algorithm>
#if defined(OS_POSIX)
#include "base/environment.h"
#endif
#include "base/file_util.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/common/url_constants.h"
#include "net/base/escape.h"
#include "net/base/filename_util.h"
#include "net/base/net_util.h"
#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
#include "url/url_file.h"
#include "url/url_parse.h"
#include "url/url_util.h"
const char* URLFixerUpper::home_directory_override = NULL;
namespace {
// TODO(estade): Remove these ugly, ugly functions. They are only used in
// SegmentURL. A url::Parsed object keeps track of a bunch of indices into
// a url string, and these need to be updated when the URL is converted from
// UTF8 to UTF16. Instead of this after-the-fact adjustment, we should parse it
// in the correct string format to begin with.
url::Component UTF8ComponentToUTF16Component(
const std::string& text_utf8,
const url::Component& component_utf8) {
if (component_utf8.len == -1)
return url::Component();
std::string before_component_string =
text_utf8.substr(0, component_utf8.begin);
std::string component_string = text_utf8.substr(component_utf8.begin,
component_utf8.len);
base::string16 before_component_string_16 =
base::UTF8ToUTF16(before_component_string);
base::string16 component_string_16 = base::UTF8ToUTF16(component_string);
url::Component component_16(before_component_string_16.length(),
component_string_16.length());
return component_16;
}
void UTF8PartsToUTF16Parts(const std::string& text_utf8,
const url::Parsed& parts_utf8,
url::Parsed* parts) {
if (base::IsStringASCII(text_utf8)) {
*parts = parts_utf8;
return;
}
parts->scheme =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.scheme);
parts ->username =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.username);
parts->password =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.password);
parts->host =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.host);
parts->port =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.port);
parts->path =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.path);
parts->query =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.query);
parts->ref =
UTF8ComponentToUTF16Component(text_utf8, parts_utf8.ref);
}
base::TrimPositions TrimWhitespaceUTF8(const std::string& input,
base::TrimPositions positions,
std::string* output) {
// This implementation is not so fast since it converts the text encoding
// twice. Please feel free to file a bug if this function hurts the
// performance of Chrome.
DCHECK(base::IsStringUTF8(input));
base::string16 input16 = base::UTF8ToUTF16(input);
base::string16 output16;
base::TrimPositions result =
base::TrimWhitespace(input16, positions, &output16);
*output = base::UTF16ToUTF8(output16);
return result;
}
// does some basic fixes for input that we want to test for file-ness
void PrepareStringForFileOps(const base::FilePath& text,
base::FilePath::StringType* output) {
#if defined(OS_WIN)
base::TrimWhitespace(text.value(), base::TRIM_ALL, output);
replace(output->begin(), output->end(), '/', '\\');
#else
TrimWhitespaceUTF8(text.value(), base::TRIM_ALL, output);
#endif
}
// Tries to create a full path from |text|. If the result is valid and the
// file exists, returns true and sets |full_path| to the result. Otherwise,
// returns false and leaves |full_path| unchanged.
bool ValidPathForFile(const base::FilePath::StringType& text,
base::FilePath* full_path) {
base::FilePath file_path = base::MakeAbsoluteFilePath(base::FilePath(text));
if (file_path.empty())
return false;
if (!base::PathExists(file_path))
return false;
*full_path = file_path;
return true;
}
#if defined(OS_POSIX)
// Given a path that starts with ~, return a path that starts with an
// expanded-out /user/foobar directory.
std::string FixupHomedir(const std::string& text) {
DCHECK(text.length() > 0 && text[0] == '~');
if (text.length() == 1 || text[1] == '/') {
const char* home = getenv(base::env_vars::kHome);
if (URLFixerUpper::home_directory_override)
home = URLFixerUpper::home_directory_override;
// We'll probably break elsewhere if $HOME is undefined, but check here
// just in case.
if (!home)
return text;
return home + text.substr(1);
}
// Otherwise, this is a path like ~foobar/baz, where we must expand to
// user foobar's home directory. Officially, we should use getpwent(),
// but that is a nasty blocking call.
#if defined(OS_MACOSX)
static const char kHome[] = "/Users/";
#else
static const char kHome[] = "/home/";
#endif
return kHome + text.substr(1);
}
#endif
// Tries to create a file: URL from |text| if it looks like a filename, even if
// it doesn't resolve as a valid path or to an existing file. Returns a
// (possibly invalid) file: URL in |fixed_up_url| for input beginning
// with a drive specifier or "\\". Returns the unchanged input in other cases
// (including file: URLs: these don't look like filenames).
std::string FixupPath(const std::string& text) {
DCHECK(!text.empty());
base::FilePath::StringType filename;
#if defined(OS_WIN)
base::FilePath input_path(base::UTF8ToWide(text));
PrepareStringForFileOps(input_path, &filename);
// Fixup Windows-style drive letters, where "C:" gets rewritten to "C|".
if (filename.length() > 1 && filename[1] == '|')
filename[1] = ':';
#elif defined(OS_POSIX)
base::FilePath input_path(text);
PrepareStringForFileOps(input_path, &filename);
if (filename.length() > 0 && filename[0] == '~')
filename = FixupHomedir(filename);
#endif
// Here, we know the input looks like a file.
GURL file_url = net::FilePathToFileURL(base::FilePath(filename));
if (file_url.is_valid()) {
return base::UTF16ToUTF8(net::FormatUrl(file_url, std::string(),
net::kFormatUrlOmitUsernamePassword, net::UnescapeRule::NORMAL, NULL,
NULL, NULL));
}
// Invalid file URL, just return the input.
return text;
}
// Checks |domain| to see if a valid TLD is already present. If not, appends
// |desired_tld| to the domain, and prepends "www." unless it's already present.
void AddDesiredTLD(const std::string& desired_tld, std::string* domain) {
if (desired_tld.empty() || domain->empty())
return;
// Check the TLD. If the return value is positive, we already have a TLD, so
// abort. If the return value is std::string::npos, there's no valid host,
// but we can try to append a TLD anyway, since the host may become valid once
// the TLD is attached -- for example, "999999999999" is detected as a broken
// IP address and marked invalid, but attaching ".com" makes it legal. When
// the return value is 0, there's a valid host with no known TLD, so we can
// definitely append the user's TLD. We disallow unknown registries here so
// users can input "mail.yahoo" and hit ctrl-enter to get
// "www.mail.yahoo.com".
const size_t registry_length =
net::registry_controlled_domains::GetRegistryLength(
*domain,
net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
if ((registry_length != 0) && (registry_length != std::string::npos))
return;
// Add the suffix at the end of the domain.
const size_t domain_length(domain->length());
DCHECK_GT(domain_length, 0U);
DCHECK_NE(desired_tld[0], '.');
if ((*domain)[domain_length - 1] != '.')
domain->push_back('.');
domain->append(desired_tld);
// Now, if the domain begins with "www.", stop.
const std::string prefix("www.");
if (domain->compare(0, prefix.length(), prefix) != 0) {
// Otherwise, add www. to the beginning of the URL.
domain->insert(0, prefix);
}
}
inline void FixupUsername(const std::string& text,
const url::Component& part,
std::string* url) {
if (!part.is_valid())
return;
// We don't fix up the username at the moment.
url->append(text, part.begin, part.len);
// Do not append the trailing '@' because we might need to include the user's
// password. FixupURL itself will append the '@' for us.
}
inline void FixupPassword(const std::string& text,
const url::Component& part,
std::string* url) {
if (!part.is_valid())
return;
// We don't fix up the password at the moment.
url->append(":");
url->append(text, part.begin, part.len);
}
void FixupHost(const std::string& text,
const url::Component& part,
bool has_scheme,
const std::string& desired_tld,
std::string* url) {
if (!part.is_valid())
return;
// Make domain valid.
// Strip all leading dots and all but one trailing dot, unless the user only
// typed dots, in which case their input is totally invalid and we should just
// leave it unchanged.
std::string domain(text, part.begin, part.len);
const size_t first_nondot(domain.find_first_not_of('.'));
if (first_nondot != std::string::npos) {
domain.erase(0, first_nondot);
size_t last_nondot(domain.find_last_not_of('.'));
DCHECK(last_nondot != std::string::npos);
last_nondot += 2; // Point at second period in ending string
if (last_nondot < domain.length())
domain.erase(last_nondot);
}
// Add any user-specified TLD, if applicable.
AddDesiredTLD(desired_tld, &domain);
url->append(domain);
}
void FixupPort(const std::string& text,
const url::Component& part,
std::string* url) {
if (!part.is_valid())
return;
// We don't fix up the port at the moment.
url->append(":");
url->append(text, part.begin, part.len);
}
inline void FixupPath(const std::string& text,
const url::Component& part,
std::string* url) {
if (!part.is_valid() || part.len == 0) {
// We should always have a path.
url->append("/");
return;
}
// Append the path as is.
url->append(text, part.begin, part.len);
}
inline void FixupQuery(const std::string& text,
const url::Component& part,
std::string* url) {
if (!part.is_valid())
return;
// We don't fix up the query at the moment.
url->append("?");
url->append(text, part.begin, part.len);
}
inline void FixupRef(const std::string& text,
const url::Component& part,
std::string* url) {
if (!part.is_valid())
return;
// We don't fix up the ref at the moment.
url->append("#");
url->append(text, part.begin, part.len);
}
bool HasPort(const std::string& original_text,
const url::Component& scheme_component) {
// Find the range between the ":" and the "/".
size_t port_start = scheme_component.end() + 1;
size_t port_end = port_start;
while ((port_end < original_text.length()) &&
!url::IsAuthorityTerminator(original_text[port_end]))
++port_end;
if (port_end == port_start)
return false;
// Scan the range to see if it is entirely digits.
for (size_t i = port_start; i < port_end; ++i) {
if (!IsAsciiDigit(original_text[i]))
return false;
}
return true;
}
// Try to extract a valid scheme from the beginning of |text|.
// If successful, set |scheme_component| to the text range where the scheme
// was located, and fill |canon_scheme| with its canonicalized form.
// Otherwise, return false and leave the outputs in an indeterminate state.
bool GetValidScheme(const std::string& text,
url::Component* scheme_component,
std::string* canon_scheme) {
canon_scheme->clear();
// Locate everything up to (but not including) the first ':'
if (!url::ExtractScheme(text.data(), static_cast<int>(text.length()),
scheme_component)) {
return false;
}
// Make sure the scheme contains only valid characters, and convert
// to lowercase. This also catches IPv6 literals like [::1], because
// brackets are not in the whitelist.
url::StdStringCanonOutput canon_scheme_output(canon_scheme);
url::Component canon_scheme_component;
if (!url::CanonicalizeScheme(text.data(), *scheme_component,
&canon_scheme_output, &canon_scheme_component)) {
return false;
}
// Strip the ':', and any trailing buffer space.
DCHECK_EQ(0, canon_scheme_component.begin);
canon_scheme->erase(canon_scheme_component.len);
// We need to fix up the segmentation for "www.example.com:/". For this
// case, we guess that schemes with a "." are not actually schemes.
if (canon_scheme->find('.') != std::string::npos)
return false;
// We need to fix up the segmentation for "www:123/". For this case, we
// will add an HTTP scheme later and make the URL parser happy.
// TODO(pkasting): Maybe we should try to use GURL's parser for this?
if (HasPort(text, *scheme_component))
return false;
// Everything checks out.
return true;
}
// Performs the work for URLFixerUpper::SegmentURL. |text| may be modified on
// output on success: a semicolon following a valid scheme is replaced with a
// colon.
std::string SegmentURLInternal(std::string* text, url::Parsed* parts) {
// Initialize the result.
*parts = url::Parsed();
std::string trimmed;
TrimWhitespaceUTF8(*text, base::TRIM_ALL, &trimmed);
if (trimmed.empty())
return std::string(); // Nothing to segment.
#if defined(OS_WIN)
int trimmed_length = static_cast<int>(trimmed.length());
if (url::DoesBeginWindowsDriveSpec(trimmed.data(), 0, trimmed_length) ||
url::DoesBeginUNCPath(trimmed.data(), 0, trimmed_length, true))
return "file";
#elif defined(OS_POSIX)
if (base::FilePath::IsSeparator(trimmed.data()[0]) ||
trimmed.data()[0] == '~')
return "file";
#endif
// Otherwise, we need to look at things carefully.
std::string scheme;
if (!GetValidScheme(*text, &parts->scheme, &scheme)) {
// Try again if there is a ';' in the text. If changing it to a ':' results
// in a scheme being found, continue processing with the modified text.
bool found_scheme = false;
size_t semicolon = text->find(';');
if (semicolon != 0 && semicolon != std::string::npos) {
(*text)[semicolon] = ':';
if (GetValidScheme(*text, &parts->scheme, &scheme))
found_scheme = true;
else
(*text)[semicolon] = ';';
}
if (!found_scheme) {
// Couldn't determine the scheme, so just pick one.
parts->scheme.reset();
scheme = StartsWithASCII(*text, "ftp.", false) ?
content::kFtpScheme : url::kHttpScheme;
}
}
// Proceed with about and chrome schemes, but not file or nonstandard schemes.
if ((scheme != content::kAboutScheme) &&
(scheme != content::kChromeUIScheme) &&
((scheme == content::kFileScheme) ||
!url::IsStandard(scheme.c_str(),
url::Component(0,
static_cast<int>(scheme.length()))))) {
return scheme;
}
if (scheme == content::kFileSystemScheme) {
// Have the GURL parser do the heavy lifting for us.
url::ParseFileSystemURL(text->data(), static_cast<int>(text->length()),
parts);
return scheme;
}
if (parts->scheme.is_valid()) {
// Have the GURL parser do the heavy lifting for us.
url::ParseStandardURL(text->data(), static_cast<int>(text->length()),
parts);
return scheme;
}
// We need to add a scheme in order for ParseStandardURL to be happy.
// Find the first non-whitespace character.
std::string::iterator first_nonwhite = text->begin();
while ((first_nonwhite != text->end()) && IsWhitespace(*first_nonwhite))
++first_nonwhite;
// Construct the text to parse by inserting the scheme.
std::string inserted_text(scheme);
inserted_text.append(content::kStandardSchemeSeparator);
std::string text_to_parse(text->begin(), first_nonwhite);
text_to_parse.append(inserted_text);
text_to_parse.append(first_nonwhite, text->end());
// Have the GURL parser do the heavy lifting for us.
url::ParseStandardURL(text_to_parse.data(),
static_cast<int>(text_to_parse.length()), parts);
// Offset the results of the parse to match the original text.
const int offset = -static_cast<int>(inserted_text.length());
URLFixerUpper::OffsetComponent(offset, &parts->scheme);
URLFixerUpper::OffsetComponent(offset, &parts->username);
URLFixerUpper::OffsetComponent(offset, &parts->password);
URLFixerUpper::OffsetComponent(offset, &parts->host);
URLFixerUpper::OffsetComponent(offset, &parts->port);
URLFixerUpper::OffsetComponent(offset, &parts->path);
URLFixerUpper::OffsetComponent(offset, &parts->query);
URLFixerUpper::OffsetComponent(offset, &parts->ref);
return scheme;
}
} // namespace
std::string URLFixerUpper::SegmentURL(const std::string& text,
url::Parsed* parts) {
std::string mutable_text(text);
return SegmentURLInternal(&mutable_text, parts);
}
base::string16 URLFixerUpper::SegmentURL(const base::string16& text,
url::Parsed* parts) {
std::string text_utf8 = base::UTF16ToUTF8(text);
url::Parsed parts_utf8;
std::string scheme_utf8 = SegmentURL(text_utf8, &parts_utf8);
UTF8PartsToUTF16Parts(text_utf8, parts_utf8, parts);
return base::UTF8ToUTF16(scheme_utf8);
}
GURL URLFixerUpper::FixupURL(const std::string& text,
const std::string& desired_tld) {
std::string trimmed;
TrimWhitespaceUTF8(text, base::TRIM_ALL, &trimmed);
if (trimmed.empty())
return GURL(); // Nothing here.
// Segment the URL.
url::Parsed parts;
std::string scheme(SegmentURLInternal(&trimmed, &parts));
// For view-source: URLs, we strip "view-source:", do fixup, and stick it back
// on. This allows us to handle things like "view-source:google.com".
if (scheme == content::kViewSourceScheme) {
// Reject "view-source:view-source:..." to avoid deep recursion.
std::string view_source(content::kViewSourceScheme + std::string(":"));
if (!StartsWithASCII(text, view_source + view_source, false)) {
return GURL(content::kViewSourceScheme + std::string(":") +
FixupURL(trimmed.substr(scheme.length() + 1),
desired_tld).possibly_invalid_spec());
}
}
// We handle the file scheme separately.
if (scheme == content::kFileScheme)
return GURL(parts.scheme.is_valid() ? text : FixupPath(text));
// We handle the filesystem scheme separately.
if (scheme == content::kFileSystemScheme) {
if (parts.inner_parsed() && parts.inner_parsed()->scheme.is_valid())
return GURL(text);
return GURL();
}
// Parse and rebuild about: and chrome: URLs, except about:blank.
bool chrome_url = !LowerCaseEqualsASCII(trimmed, content::kAboutBlankURL) &&
((scheme == content::kAboutScheme) ||
(scheme == content::kChromeUIScheme));
// For some schemes whose layouts we understand, we rebuild it.
if (chrome_url ||
url::IsStandard(scheme.c_str(),
url::Component(0, static_cast<int>(scheme.length())))) {
// Replace the about: scheme with the chrome: scheme.
std::string url(chrome_url ? content::kChromeUIScheme : scheme);
url.append(content::kStandardSchemeSeparator);
// We need to check whether the |username| is valid because it is our
// responsibility to append the '@' to delineate the user information from
// the host portion of the URL.
if (parts.username.is_valid()) {
FixupUsername(trimmed, parts.username, &url);
FixupPassword(trimmed, parts.password, &url);
url.append("@");
}
FixupHost(trimmed, parts.host, parts.scheme.is_valid(), desired_tld, &url);
if (chrome_url && !parts.host.is_valid())
url.append(chrome::kChromeUIDefaultHost);
FixupPort(trimmed, parts.port, &url);
FixupPath(trimmed, parts.path, &url);
FixupQuery(trimmed, parts.query, &url);
FixupRef(trimmed, parts.ref, &url);
return GURL(url);
}
// In the worst-case, we insert a scheme if the URL lacks one.
if (!parts.scheme.is_valid()) {
std::string fixed_scheme(scheme);
fixed_scheme.append(content::kStandardSchemeSeparator);
trimmed.insert(0, fixed_scheme);
}
return GURL(trimmed);
}
// The rules are different here than for regular fixup, since we need to handle
// input like "hello.html" and know to look in the current directory. Regular
// fixup will look for cues that it is actually a file path before trying to
// figure out what file it is. If our logic doesn't work, we will fall back on
// regular fixup.
GURL URLFixerUpper::FixupRelativeFile(const base::FilePath& base_dir,
const base::FilePath& text) {
base::FilePath old_cur_directory;
if (!base_dir.empty()) {
// Save the old current directory before we move to the new one.
base::GetCurrentDirectory(&old_cur_directory);
base::SetCurrentDirectory(base_dir);
}
// Allow funny input with extra whitespace and the wrong kind of slashes.
base::FilePath::StringType trimmed;
PrepareStringForFileOps(text, &trimmed);
bool is_file = true;
// Avoid recognizing definite non-file URLs as file paths.
GURL gurl(trimmed);
if (gurl.is_valid() && gurl.IsStandard())
is_file = false;
base::FilePath full_path;
if (is_file && !ValidPathForFile(trimmed, &full_path)) {
// Not a path as entered, try unescaping it in case the user has
// escaped things. We need to go through 8-bit since the escaped values
// only represent 8-bit values.
#if defined(OS_WIN)
std::wstring unescaped = base::UTF8ToWide(net::UnescapeURLComponent(
base::WideToUTF8(trimmed),
net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS));
#elif defined(OS_POSIX)
std::string unescaped = net::UnescapeURLComponent(
trimmed,
net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
#endif
if (!ValidPathForFile(unescaped, &full_path))
is_file = false;
}
// Put back the current directory if we saved it.
if (!base_dir.empty())
base::SetCurrentDirectory(old_cur_directory);
if (is_file) {
GURL file_url = net::FilePathToFileURL(full_path);
if (file_url.is_valid())
return GURL(base::UTF16ToUTF8(net::FormatUrl(file_url, std::string(),
net::kFormatUrlOmitUsernamePassword, net::UnescapeRule::NORMAL, NULL,
NULL, NULL)));
// Invalid files fall through to regular processing.
}
// Fall back on regular fixup for this input.
#if defined(OS_WIN)
std::string text_utf8 = base::WideToUTF8(text.value());
#elif defined(OS_POSIX)
std::string text_utf8 = text.value();
#endif
return FixupURL(text_utf8, std::string());
}
void URLFixerUpper::OffsetComponent(int offset, url::Component* part) {
DCHECK(part);
if (part->is_valid()) {
// Offset the location of this component.
part->begin += offset;
// This part might not have existed in the original text.
if (part->begin < 0)
part->reset();
}
}
|