admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete method Pathname::url and base/urlencode*

Browse Source 
BUG=webrtc:6424

Review-Url: https://codereview.webrtc.org/2572703002
Cr-Commit-Position: refs/heads/master@{#15595}
This commit is contained in:
nisse 2016-12-14 01:42:53 -08:00 committed by Commit bot
parent bb66ec3573
commit bd6c6fa309
8 changed files with 0 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/BUILD.gn
View File

@ -445,7 +445,6 @@ if (rtc_include_tests) {
"base/thread_unittest.cc",
"base/timestampaligner_unittest.cc",
"base/timeutils_unittest.cc",
"base/urlencode_unittest.cc",
"base/weak_ptr_unittest.cc",
"p2p/base/asyncstuntcpsocket_unittest.cc",
"p2p/base/dtlstransportchannel_unittest.cc",

2
webrtc/base/BUILD.gn
View File

@ -183,8 +183,6 @@ rtc_static_library("rtc_base_approved") {
"timeutils.h",
"trace_event.h",
"type_traits.h",
"urlencode.cc",
"urlencode.h",
]
if (is_android) {

14
webrtc/base/pathutils.cc
View File

@ -20,7 +20,6 @@
#include "webrtc/base/logging.h"
#include "webrtc/base/pathutils.h"
#include "webrtc/base/stringutils.h"
#include "webrtc/base/urlencode.h"
namespace rtc {
@ -106,19 +105,6 @@ std::string Pathname::pathname() const {
return pathname;
}
std::string Pathname::url() const {
std::string s = "file:///";
for (size_t i=0; i<folder_.length(); ++i) {
if (IsFolderDelimiter(folder_[i]))
s += '/';
else
s += folder_[i];
}
s += basename_;
s += extension_;
return UrlEncodeStringForOnlyUnsafeChars(s);
}
void Pathname::SetPathname(const std::string& pathname) {
std::string::size_type pos = pathname.find_last_of(FOLDER_DELIMS);
if (pos != std::string::npos) {

2
webrtc/base/pathutils.h
View File

@ -66,8 +66,6 @@ public:
// is always false.
bool empty() const;
std::string url() const;
// Returns the folder and filename components. If the pathname is empty,
// returns a string representing the current directory (as a relative path,
// i.e., ".").

3
webrtc/base/pathutils_unittest.cc
View File

@ -42,7 +42,4 @@ TEST(Pathname, ReturnsDotForEmptyPathname) {
EXPECT_TRUE (path.filename().empty());
EXPECT_FALSE(path.pathname().empty());
EXPECT_EQ(kCWD, path.pathname());
rtc::Pathname path2("c:/foo bar.txt");
EXPECT_EQ(path2.url(), std::string("file:///c:/foo%20bar.txt"));
}

181
webrtc/base/urlencode.cc
View File

@ -1,181 +0,0 @@
/*
* Copyright 2008 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/base/urlencode.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/stringutils.h"
static int HexPairValue(const char * code) {
int value = 0;
for (const char * pch = code; pch < code + 2; ++pch) {
value <<= 4;
int digit = *pch;
if (digit >= '0' && digit <= '9') {
value += digit - '0';
}
else if (digit >= 'A' && digit <= 'F') {
value += digit - 'A' + 10;
}
else if (digit >= 'a' && digit <= 'f') {
value += digit - 'a' + 10;
}
else {
return -1;
}
}
return value;
}
static int InternalUrlDecode(const char *source, char *dest,
bool encode_space_as_plus) {
char * start = dest;
while (*source) {
switch (*source) {
case '+':
if (encode_space_as_plus) {
*(dest++) = ' ';
} else {
*dest++ = *source;
}
break;
case '%':
if (source[1] && source[2]) {
int value = HexPairValue(source + 1);
if (value >= 0) {
*(dest++) = static_cast<char>(value);
source += 2;
}
else {
*dest++ = '?';
}
}
else {
*dest++ = '?';
}
break;
default:
*dest++ = *source;
}
source++;
}
*dest = 0;
return static_cast<int>(dest - start);
}
static bool IsValidUrlChar(char ch, bool unsafe_only) {
if (unsafe_only) {
return !(ch <= ' ' || strchr("\\\"^&`<>[]{}", ch));
} else {
return isalnum(ch) || strchr("-_.!~*'()", ch);
}
}
namespace rtc {
int UrlDecode(const char *source, char *dest) {
return InternalUrlDecode(source, dest, true);
}
int UrlDecodeWithoutEncodingSpaceAsPlus(const char *source, char *dest) {
return InternalUrlDecode(source, dest, false);
}
int InternalUrlEncode(const char *source, char *dest, unsigned int max,
bool encode_space_as_plus, bool unsafe_only) {
static const char *digits = "0123456789ABCDEF";
if (max == 0) {
return 0;
}
char *start = dest;
while (static_cast<unsigned>(dest - start) < max && *source) {
unsigned char ch = static_cast<unsigned char>(*source);
if (*source == ' ' && encode_space_as_plus && !unsafe_only) {
*dest++ = '+';
} else if (IsValidUrlChar(ch, unsafe_only)) {
*dest++ = *source;
} else {
if (static_cast<unsigned>(dest - start) + 4 > max) {
break;
}
*dest++ = '%';
*dest++ = digits[(ch >> 4) & 0x0F];
*dest++ = digits[ ch & 0x0F];
}
source++;
}
RTC_DCHECK_LT(static_cast<unsigned int>(dest - start), max);
*dest = 0;
return static_cast<int>(dest - start);
}
int UrlEncode(const char *source, char *dest, unsigned max) {
return InternalUrlEncode(source, dest, max, true, false);
}
int UrlEncodeWithoutEncodingSpaceAsPlus(const char *source, char *dest,
unsigned max) {
return InternalUrlEncode(source, dest, max, false, false);
}
int UrlEncodeOnlyUnsafeChars(const char *source, char *dest, unsigned max) {
return InternalUrlEncode(source, dest, max, false, true);
}
std::string
InternalUrlDecodeString(const std::string & encoded,
bool encode_space_as_plus) {
size_t needed_length = encoded.length() + 1;
char* buf = STACK_ARRAY(char, needed_length);
InternalUrlDecode(encoded.c_str(), buf, encode_space_as_plus);
return buf;
}
std::string
UrlDecodeString(const std::string & encoded) {
return InternalUrlDecodeString(encoded, true);
}
std::string
UrlDecodeStringWithoutEncodingSpaceAsPlus(const std::string & encoded) {
return InternalUrlDecodeString(encoded, false);
}
std::string
InternalUrlEncodeString(const std::string & decoded,
bool encode_space_as_plus,
bool unsafe_only) {
int needed_length = static_cast<int>(decoded.length()) * 3 + 1;
char* buf = STACK_ARRAY(char, needed_length);
InternalUrlEncode(decoded.c_str(), buf, needed_length,
encode_space_as_plus, unsafe_only);
return buf;
}
std::string
UrlEncodeString(const std::string & decoded) {
return InternalUrlEncodeString(decoded, true, false);
}
std::string
UrlEncodeStringWithoutEncodingSpaceAsPlus(const std::string & decoded) {
return InternalUrlEncodeString(decoded, false, false);
}
std::string
UrlEncodeStringForOnlyUnsafeChars(const std::string & decoded) {
return InternalUrlEncodeString(decoded, false, true);
}
} // namespace rtc

46
webrtc/base/urlencode.h
View File

@ -1,46 +0,0 @@
/*
* Copyright 2008 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef _URLENCODE_H_
#define _URLENCODE_H_
#include <string>
namespace rtc {
// Decode all encoded characters. Also decode + as space.
int UrlDecode(const char *source, char *dest);
// Decode all encoded characters.
int UrlDecodeWithoutEncodingSpaceAsPlus(const char *source, char *dest);
// Encode all characters except alphas, numbers, and -_.!~*'()
// Also encode space as +.
int UrlEncode(const char *source, char *dest, unsigned max);
// Encode all characters except alphas, numbers, and -_.!~*'()
int UrlEncodeWithoutEncodingSpaceAsPlus(const char *source, char *dest,
unsigned max);
// Encode only unsafe chars, including \ "^&`<>[]{}
// Also encode space as %20, instead of +
int UrlEncodeOnlyUnsafeChars(const char *source, char *dest, unsigned max);
std::string UrlDecodeString(const std::string & encoded);
std::string UrlDecodeStringWithoutEncodingSpaceAsPlus(
const std::string & encoded);
std::string UrlEncodeString(const std::string & decoded);
std::string UrlEncodeStringWithoutEncodingSpaceAsPlus(
const std::string & decoded);
std::string UrlEncodeStringForOnlyUnsafeChars(const std::string & decoded);
#endif
} // namespace rtc

84
webrtc/base/urlencode_unittest.cc
View File

@ -1,84 +0,0 @@
/*
* Copyright 2004 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/base/arraysize.h"
#include "webrtc/base/common.h"
#include "webrtc/base/gunit.h"
#include "webrtc/base/thread.h"
#include "webrtc/base/urlencode.h"
using rtc::UrlEncode;
TEST(Urlencode, SourceTooLong) {
char source[] = "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^";
char dest[1];
ASSERT_EQ(0, UrlEncode(source, dest, arraysize(dest)));
ASSERT_EQ('\0', dest[0]);
dest[0] = 'a';
ASSERT_EQ(0, UrlEncode(source, dest, 0));
ASSERT_EQ('a', dest[0]);
}
TEST(Urlencode, OneCharacterConversion) {
char source[] = "^";
char dest[4];
ASSERT_EQ(3, UrlEncode(source, dest, arraysize(dest)));
ASSERT_STREQ("%5E", dest);
}
TEST(Urlencode, ShortDestinationNoEncoding) {
// In this case we have a destination that would not be
// big enough to hold an encoding but is big enough to
// hold the text given.
char source[] = "aa";
char dest[3];
ASSERT_EQ(2, UrlEncode(source, dest, arraysize(dest)));
ASSERT_STREQ("aa", dest);
}
TEST(Urlencode, ShortDestinationEncoding) {
// In this case we have a destination that is not
// big enough to hold the encoding.
char source[] = "&";
char dest[3];
ASSERT_EQ(0, UrlEncode(source, dest, arraysize(dest)));
ASSERT_EQ('\0', dest[0]);
}
TEST(Urlencode, Encoding1) {
char source[] = "A^ ";
char dest[8];
ASSERT_EQ(5, UrlEncode(source, dest, arraysize(dest)));
ASSERT_STREQ("A%5E+", dest);
}
TEST(Urlencode, Encoding2) {
char source[] = "A^ ";
char dest[8];
ASSERT_EQ(7, rtc::UrlEncodeWithoutEncodingSpaceAsPlus(source, dest,
arraysize(dest)));
ASSERT_STREQ("A%5E%20", dest);
}
TEST(Urldecode, Decoding1) {
char source[] = "A%5E+";
char dest[8];
ASSERT_EQ(3, rtc::UrlDecode(source, dest));
ASSERT_STREQ("A^ ", dest);
}
TEST(Urldecode, Decoding2) {
char source[] = "A%5E+";
char dest[8];
ASSERT_EQ(3, rtc::UrlDecodeWithoutEncodingSpaceAsPlus(source, dest));
ASSERT_STREQ("A^+", dest);
}