libweave: Remove unnecessary code from base lib
Mostly strings, logs and command line routines.
BUG=brillo:1256
TEST=`FEATURES=test emerge-gizmo libweave buffet`
Change-Id: I69cf44792ee1277109ca1a4b5995c5021d84d434
Reviewed-on: https://chromium-review.googlesource.com/294173
Tested-by: Vitaly Buka <vitalybuka@chromium.org>
Reviewed-by: Alex Vakulenko <avakulenko@chromium.org>
diff --git a/libweave/external/base/atomicops.h b/libweave/external/base/atomicops.h
index 6a5371c..eea00ed 100644
--- a/libweave/external/base/atomicops.h
+++ b/libweave/external/base/atomicops.h
@@ -37,7 +37,7 @@
#include <cstddef>
#include "base/base_export.h"
-#include "build/build_config.h"
+#include "base/build/build_config.h"
#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
// windows.h #defines this (only on x64). This causes problems because the
diff --git a/libweave/external/base/atomicops_unittest.cc b/libweave/external/base/atomicops_unittest.cc
index 3fd5597..7771142 100644
--- a/libweave/external/base/atomicops_unittest.cc
+++ b/libweave/external/base/atomicops_unittest.cc
@@ -7,7 +7,7 @@
#include <stdint.h>
#include <string.h>
-#include "testing/gtest/include/gtest/gtest.h"
+#include <gtest/gtest.h>
template <class AtomicType>
static void TestAtomicIncrement() {
diff --git a/libweave/external/base/base_export.h b/libweave/external/base/base_export.h
index 723b38a..89693b4 100644
--- a/libweave/external/base/base_export.h
+++ b/libweave/external/base/base_export.h
@@ -5,30 +5,7 @@
#ifndef BASE_BASE_EXPORT_H_
#define BASE_BASE_EXPORT_H_
-#if defined(COMPONENT_BUILD)
-#if defined(WIN32)
-
-#if defined(BASE_IMPLEMENTATION)
-#define BASE_EXPORT __declspec(dllexport)
-#define BASE_EXPORT_PRIVATE __declspec(dllexport)
-#else
-#define BASE_EXPORT __declspec(dllimport)
-#define BASE_EXPORT_PRIVATE __declspec(dllimport)
-#endif // defined(BASE_IMPLEMENTATION)
-
-#else // defined(WIN32)
-#if defined(BASE_IMPLEMENTATION)
-#define BASE_EXPORT __attribute__((visibility("default")))
-#define BASE_EXPORT_PRIVATE __attribute__((visibility("default")))
-#else
#define BASE_EXPORT
#define BASE_EXPORT_PRIVATE
-#endif // defined(BASE_IMPLEMENTATION)
-#endif
-
-#else // defined(COMPONENT_BUILD)
-#define BASE_EXPORT
-#define BASE_EXPORT_PRIVATE
-#endif
#endif // BASE_BASE_EXPORT_H_
diff --git a/libweave/external/base/basictypes.h b/libweave/external/base/basictypes.h
index d71abd9..154688d 100644
--- a/libweave/external/base/basictypes.h
+++ b/libweave/external/base/basictypes.h
@@ -16,7 +16,7 @@
#include <stdint.h> // For intptr_t.
#include "base/macros.h"
-#include "build/build_config.h"
+#include "base/build/build_config.h"
// DEPRECATED: Please use (u)int{8,16,32,64}_t instead (and include <stdint.h>).
typedef int8_t int8;
diff --git a/libweave/external/base/bind_helpers.h b/libweave/external/base/bind_helpers.h
index 4003dea..09deb33 100644
--- a/libweave/external/base/bind_helpers.h
+++ b/libweave/external/base/bind_helpers.h
@@ -261,21 +261,21 @@
// Helpers to assert that arguments of a recounted type are bound with a
// scoped_refptr.
template <bool IsClasstype, typename T>
-struct UnsafeBindtoRefCountedArgHelper : false_type {
+struct UnsafeBindtoRefCountedArgHelper : std::false_type {
};
template <typename T>
struct UnsafeBindtoRefCountedArgHelper<true, T>
- : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {
+ : std::integral_constant<bool, SupportsAddRefAndRelease<T>::value> {
};
template <typename T>
-struct UnsafeBindtoRefCountedArg : false_type {
+struct UnsafeBindtoRefCountedArg : std::false_type {
};
template <typename T>
struct UnsafeBindtoRefCountedArg<T*>
- : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {
+ : UnsafeBindtoRefCountedArgHelper<std::is_class<T>::value, T> {
};
template <typename T>
@@ -550,14 +550,14 @@
// The first argument should be the type of the object that will be received by
// the method.
template <bool IsMethod, typename... Args>
-struct IsWeakMethod : public false_type {};
+struct IsWeakMethod : public std::false_type {};
template <typename T, typename... Args>
-struct IsWeakMethod<true, WeakPtr<T>, Args...> : public true_type {};
+struct IsWeakMethod<true, WeakPtr<T>, Args...> : public std::true_type {};
template <typename T, typename... Args>
struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T>>, Args...>
- : public true_type {};
+ : public std::true_type {};
// Packs a list of types to hold them in a single type.
diff --git a/libweave/external/base/bind_internal.h b/libweave/external/base/bind_internal.h
index e053218..6d500a5 100644
--- a/libweave/external/base/bind_internal.h
+++ b/libweave/external/base/bind_internal.h
@@ -6,12 +6,11 @@
#define BASE_BIND_INTERNAL_H_
#include "base/bind_helpers.h"
+#include "base/build/build_config.h"
#include "base/callback_internal.h"
-#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
#include "base/memory/weak_ptr.h"
#include "base/template_util.h"
#include "base/tuple.h"
-#include "build/build_config.h"
#if defined(OS_WIN)
#include "base/bind_internal_win.h"
@@ -70,7 +69,7 @@
// Implementation note: This non-specialized case handles zero-arity case only.
// Non-zero-arity cases should be handled by the specialization below.
template <typename Sig>
-struct HasNonConstReferenceParam : false_type {};
+struct HasNonConstReferenceParam : std::false_type {};
// Implementation note: Select true_type if the first parameter is a non-const
// reference. Otherwise, skip the first parameter and check rest of parameters
@@ -78,7 +77,7 @@
template <typename R, typename T, typename... Args>
struct HasNonConstReferenceParam<R(T, Args...)>
: SelectType<is_non_const_reference<T>::value,
- true_type,
+ std::true_type,
HasNonConstReferenceParam<R(Args...)>>::Type {};
// HasRefCountedTypeAsRawPtr selects true_type when any of the |Args| is a raw
@@ -86,16 +85,7 @@
// Implementation note: This non-specialized case handles zero-arity case only.
// Non-zero-arity cases should be handled by the specialization below.
template <typename... Args>
-struct HasRefCountedTypeAsRawPtr : false_type {};
-
-// Implementation note: Select true_type if the first parameter is a raw pointer
-// to a RefCounted type. Otherwise, skip the first parameter and check rest of
-// parameters recursively.
-template <typename T, typename... Args>
-struct HasRefCountedTypeAsRawPtr<T, Args...>
- : SelectType<NeedsScopedRefptrButGetsRawPtr<T>::value,
- true_type,
- HasRefCountedTypeAsRawPtr<Args...>>::Type {};
+struct HasRefCountedTypeAsRawPtr : std::false_type {};
// BindsArrayToFirstArg selects true_type when |is_method| is true and the first
// item of |Args| is an array type.
@@ -103,10 +93,10 @@
// zero-arity case only. Other cases should be handled by the specialization
// below.
template <bool is_method, typename... Args>
-struct BindsArrayToFirstArg : false_type {};
+struct BindsArrayToFirstArg : std::false_type {};
template <typename T, typename... Args>
-struct BindsArrayToFirstArg<true, T, Args...> : is_array<T> {};
+struct BindsArrayToFirstArg<true, T, Args...> : std::is_array<T> {};
// HasRefCountedParamAsRawPtr is the same to HasRefCountedTypeAsRawPtr except
// when |is_method| is true HasRefCountedParamAsRawPtr skips the first argument.
@@ -166,7 +156,7 @@
class RunnableAdapter<R(T::*)(Args...)> {
public:
typedef R (RunType)(T*, Args...);
- typedef true_type IsMethod;
+ typedef std::true_type IsMethod;
explicit RunnableAdapter(R(T::*method)(Args...))
: method_(method) {
@@ -185,7 +175,7 @@
class RunnableAdapter<R(T::*)(Args...) const> {
public:
typedef R (RunType)(const T*, Args...);
- typedef true_type IsMethod;
+ typedef std::true_type IsMethod;
explicit RunnableAdapter(R(T::*method)(Args...) const)
: method_(method) {
@@ -311,7 +301,7 @@
// WeakCalls are only supported for functions with a void return type.
// Otherwise, the function result would be undefined if the the WeakPtr<>
// is invalidated.
- COMPILE_ASSERT(is_void<ReturnType>::value,
+ COMPILE_ASSERT(std::is_void<ReturnType>::value,
weak_ptrs_can_only_bind_to_methods_without_return_values);
};
diff --git a/libweave/external/base/bind_unittest.cc b/libweave/external/base/bind_unittest.cc
index f885403..d3cc79a 100644
--- a/libweave/external/base/bind_unittest.cc
+++ b/libweave/external/base/bind_unittest.cc
@@ -4,12 +4,13 @@
#include "base/bind.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
using ::testing::Mock;
using ::testing::Return;
diff --git a/libweave/external/base/build/build_config.h b/libweave/external/base/build/build_config.h
index 5181b2b..904965a 100644
--- a/libweave/external/base/build/build_config.h
+++ b/libweave/external/base/build/build_config.h
@@ -12,8 +12,8 @@
// ARCH_CPU_X86 / ARCH_CPU_X86_64 / ARCH_CPU_X86_FAMILY (X86 or X86_64)
// ARCH_CPU_32_BITS / ARCH_CPU_64_BITS
-#ifndef BUILD_BUILD_CONFIG_H_
-#define BUILD_BUILD_CONFIG_H_
+#ifndef BASE_BUILD_BUILD_CONFIG_H_
+#define BASE_BUILD_BUILD_CONFIG_H_
// Add Brillo-specific defines.
#if defined(__BRILLO__)
@@ -151,25 +151,6 @@
#error Please add support for your architecture in build/build_config.h
#endif
-// Type detection for wchar_t.
-#if defined(OS_WIN)
-#define WCHAR_T_IS_UTF16
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
- defined(__WCHAR_MAX__) && \
- (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
-#define WCHAR_T_IS_UTF32
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && \
- defined(__WCHAR_MAX__) && \
- (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
-// On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
-// compile in this mode (in particular, Chrome doesn't). This is intended for
-// other projects using base who manage their own dependencies and make sure
-// short wchar works for them.
-#define WCHAR_T_IS_UTF16
-#else
-#error Please add support for your compiler in build/build_config.h
-#endif
-
#if defined(OS_ANDROID)
// The compiler thinks std::string::const_iterator and "const char*" are
// equivalent types.
@@ -179,4 +160,4 @@
#define BASE_STRING16_ITERATOR_IS_CHAR16_POINTER
#endif
-#endif // BUILD_BUILD_CONFIG_H_
+#endif // BASE_BUILD_BUILD_CONFIG_H_
diff --git a/libweave/external/base/callback_internal.h b/libweave/external/base/callback_internal.h
index 3e5ed9d..84c5dc8 100644
--- a/libweave/external/base/callback_internal.h
+++ b/libweave/external/base/callback_internal.h
@@ -108,7 +108,7 @@
static NoType Test(...);
static const bool value = sizeof((Test<T>(0))) == sizeof(YesType) &&
- !is_const<T>::value;
+ !std::is_const<T>::value;
};
// Mark std::unique_ptr<T> and common containers using unique_ptr as MoveOnly
@@ -236,12 +236,14 @@
// parameter to another callback. This is to support Callbacks that return
// the movable-but-not-copyable types whitelisted above.
template <typename T>
-typename enable_if<!IsMoveOnlyType<T>::value, T>::type& CallbackForward(T& t) {
+typename std::enable_if<!IsMoveOnlyType<T>::value, T>::type& CallbackForward(
+ T& t) {
return t;
}
template <typename T>
-typename enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(T& t) {
+typename std::enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(
+ T& t) {
return t.Pass();
}
diff --git a/libweave/external/base/callback_list_unittest.cc b/libweave/external/base/callback_list_unittest.cc
index 9adbabb..3b50622 100644
--- a/libweave/external/base/callback_list_unittest.cc
+++ b/libweave/external/base/callback_list_unittest.cc
@@ -4,11 +4,12 @@
#include "base/callback_list.h"
+#include <gtest/gtest.h>
+
#include "base/basictypes.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/memory/scoped_ptr.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
diff --git a/libweave/external/base/callback_unittest.cc b/libweave/external/base/callback_unittest.cc
index 2844aa9..3630176 100644
--- a/libweave/external/base/callback_unittest.cc
+++ b/libweave/external/base/callback_unittest.cc
@@ -2,13 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "base/bind.h"
#include "base/callback.h"
-#include "base/callback_helpers.h"
+
+#include <gtest/gtest.h>
+
+#include "base/bind.h"
#include "base/callback_internal.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
@@ -148,15 +149,6 @@
Closure cb;
};
-TEST_F(CallbackTest, ResetAndReturn) {
- TestForReentrancy tfr;
- ASSERT_FALSE(tfr.cb.is_null());
- ASSERT_FALSE(tfr.cb_already_run);
- ResetAndReturn(&tfr.cb).Run();
- ASSERT_TRUE(tfr.cb.is_null());
- ASSERT_TRUE(tfr.cb_already_run);
-}
-
class CallbackOwner : public base::RefCounted<CallbackOwner> {
public:
explicit CallbackOwner(bool* deleted) {
diff --git a/libweave/external/base/command_line.h b/libweave/external/base/command_line.h
index 3de8873..662a4d4 100644
--- a/libweave/external/base/command_line.h
+++ b/libweave/external/base/command_line.h
@@ -16,234 +16,14 @@
#define BASE_COMMAND_LINE_H_
#include <stddef.h>
-#include <map>
-#include <string>
-#include <vector>
#include "base/base_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "build/build_config.h"
namespace base {
-class FilePath;
-
class BASE_EXPORT CommandLine {
public:
-#if defined(OS_WIN)
- // The native command line string type.
- typedef base::string16 StringType;
-#elif defined(OS_POSIX)
- typedef std::string StringType;
-#endif
-
- typedef StringType::value_type CharType;
- typedef std::vector<StringType> StringVector;
- typedef std::map<std::string, StringType> SwitchMap;
- typedef std::map<base::StringPiece, const StringType*> StringPieceSwitchMap;
-
- // A constructor for CommandLines that only carry switches and arguments.
- enum NoProgram { NO_PROGRAM };
- explicit CommandLine(NoProgram no_program);
-
- // Construct a new command line with |program| as argv[0].
- explicit CommandLine(const FilePath& program);
-
- // Construct a new command line from an argument list.
- CommandLine(int argc, const CharType* const* argv);
- explicit CommandLine(const StringVector& argv);
-
- // Override copy and assign to ensure |switches_by_stringpiece_| is valid.
- CommandLine(const CommandLine& other);
- CommandLine& operator=(const CommandLine& other);
-
- ~CommandLine();
-
-#if defined(OS_WIN)
- // By default this class will treat command-line arguments beginning with
- // slashes as switches on Windows, but not other platforms.
- //
- // If this behavior is inappropriate for your application, you can call this
- // function BEFORE initializing the current process' global command line
- // object and the behavior will be the same as Posix systems (only hyphens
- // begin switches, everything else will be an arg).
- static void set_slash_is_not_a_switch();
-#endif
-
- // Initialize the current process CommandLine singleton. On Windows, ignores
- // its arguments (we instead parse GetCommandLineW() directly) because we
- // don't trust the CRT's parsing of the command line, but it still must be
- // called to set up the command line. Returns false if initialization has
- // already occurred, and true otherwise. Only the caller receiving a 'true'
- // return value should take responsibility for calling Reset.
- static bool Init(int argc, const char* const* argv);
-
- // Destroys the current process CommandLine singleton. This is necessary if
- // you want to reset the base library to its initial state (for example, in an
- // outer library that needs to be able to terminate, and be re-initialized).
- // If Init is called only once, as in main(), Reset() is not necessary.
- static void Reset();
-
- // Get the singleton CommandLine representing the current process's
- // command line. Note: returned value is mutable, but not thread safe;
- // only mutate if you know what you're doing!
- static CommandLine* ForCurrentProcess();
-
- // Returns true if the CommandLine has been initialized for the given process.
- static bool InitializedForCurrentProcess();
-
-#if defined(OS_WIN)
- static CommandLine FromString(const base::string16& command_line);
-#endif
-
- // Initialize from an argv vector.
- void InitFromArgv(int argc, const CharType* const* argv);
- void InitFromArgv(const StringVector& argv);
-
- // Constructs and returns the represented command line string.
- // CAUTION! This should be avoided on POSIX because quoting behavior is
- // unclear.
- StringType GetCommandLineString() const {
- return GetCommandLineStringInternal(false);
- }
-
-#if defined(OS_WIN)
- // Constructs and returns the represented command line string. Assumes the
- // command line contains placeholders (eg, %1) and quotes any program or
- // argument with a '%' in it. This should be avoided unless the placeholder is
- // required by an external interface (eg, the Windows registry), because it is
- // not generally safe to replace it with an arbitrary string. If possible,
- // placeholders should be replaced *before* converting the command line to a
- // string.
- StringType GetCommandLineStringWithPlaceholders() const {
- return GetCommandLineStringInternal(true);
- }
-#endif
-
- // Constructs and returns the represented arguments string.
- // CAUTION! This should be avoided on POSIX because quoting behavior is
- // unclear.
- StringType GetArgumentsString() const {
- return GetArgumentsStringInternal(false);
- }
-
-#if defined(OS_WIN)
- // Constructs and returns the represented arguments string. Assumes the
- // command line contains placeholders (eg, %1) and quotes any argument with a
- // '%' in it. This should be avoided unless the placeholder is required by an
- // external interface (eg, the Windows registry), because it is not generally
- // safe to replace it with an arbitrary string. If possible, placeholders
- // should be replaced *before* converting the arguments to a string.
- StringType GetArgumentsStringWithPlaceholders() const {
- return GetArgumentsStringInternal(true);
- }
-#endif
-
- // Returns the original command line string as a vector of strings.
- const StringVector& argv() const { return argv_; }
-
- // Get and Set the program part of the command line string (the first item).
- FilePath GetProgram() const;
- void SetProgram(const FilePath& program);
-
- // Returns true if this command line contains the given switch.
- // Switch names must be lowercase.
- // The second override provides an optimized version to avoid inlining codegen
- // at every callsite to find the length of the constant and construct a
- // StringPiece.
- bool HasSwitch(const base::StringPiece& switch_string) const;
- bool HasSwitch(const char switch_constant[]) const;
-
- // Returns the value associated with the given switch. If the switch has no
- // value or isn't present, this method returns the empty string.
- // Switch names must be lowercase.
- std::string GetSwitchValueASCII(const base::StringPiece& switch_string) const;
- FilePath GetSwitchValuePath(const base::StringPiece& switch_string) const;
- StringType GetSwitchValueNative(const base::StringPiece& switch_string) const;
-
- // Get a copy of all switches, along with their values.
- const SwitchMap& GetSwitches() const { return switches_; }
-
- // Append a switch [with optional value] to the command line.
- // Note: Switches will precede arguments regardless of appending order.
- void AppendSwitch(const std::string& switch_string);
- void AppendSwitchPath(const std::string& switch_string,
- const FilePath& path);
- void AppendSwitchNative(const std::string& switch_string,
- const StringType& value);
- void AppendSwitchASCII(const std::string& switch_string,
- const std::string& value);
-
- // Copy a set of switches (and any values) from another command line.
- // Commonly used when launching a subprocess.
- void CopySwitchesFrom(const CommandLine& source,
- const char* const switches[],
- size_t count);
-
- // Get the remaining arguments to the command.
- StringVector GetArgs() const;
-
- // Append an argument to the command line. Note that the argument is quoted
- // properly such that it is interpreted as one argument to the target command.
- // AppendArg is primarily for ASCII; non-ASCII input is interpreted as UTF-8.
- // Note: Switches will precede arguments regardless of appending order.
- void AppendArg(const std::string& value);
- void AppendArgPath(const FilePath& value);
- void AppendArgNative(const StringType& value);
-
- // Append the switches and arguments from another command line to this one.
- // If |include_program| is true, include |other|'s program as well.
- void AppendArguments(const CommandLine& other, bool include_program);
-
- // Insert a command before the current command.
- // Common for debuggers, like "valgrind" or "gdb --args".
- void PrependWrapper(const StringType& wrapper);
-
-#if defined(OS_WIN)
- // Initialize by parsing the given command line string.
- // The program name is assumed to be the first item in the string.
- void ParseFromString(const base::string16& command_line);
-#endif
-
- private:
- // Disallow default constructor; a program name must be explicitly specified.
- CommandLine();
- // Allow the copy constructor. A common pattern is to copy of the current
- // process's command line and then add some flags to it. For example:
- // CommandLine cl(*CommandLine::ForCurrentProcess());
- // cl.AppendSwitch(...);
-
- // Internal version of GetCommandLineString. If |quote_placeholders| is true,
- // also quotes parts with '%' in them.
- StringType GetCommandLineStringInternal(bool quote_placeholders) const;
-
- // Internal version of GetArgumentsString. If |quote_placeholders| is true,
- // also quotes parts with '%' in them.
- StringType GetArgumentsStringInternal(bool quote_placeholders) const;
-
- // Reconstruct |switches_by_stringpiece| to be a mirror of |switches|.
- // |switches_by_stringpiece| only contains pointers to objects owned by
- // |switches|.
- void ResetStringPieces();
-
- // The singleton CommandLine representing the current process's command line.
- static CommandLine* current_process_commandline_;
-
- // The argv array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
- StringVector argv_;
-
- // Parsed-out switch keys and values.
- SwitchMap switches_;
-
- // A mirror of |switches_| with only references to the actual strings.
- // The StringPiece internally holds a pointer to a key in |switches_| while
- // the mapped_type points to a value in |switches_|.
- // Used for allocation-free lookups.
- StringPieceSwitchMap switches_by_stringpiece_;
-
- // The index after the program and switches, any arguments start here.
- size_t begin_args_;
+ static bool Init(int argc, const char* const* argv) { return true; }
};
} // namespace base
diff --git a/libweave/external/base/compiler_specific.h b/libweave/external/base/compiler_specific.h
index 63297dc..8c2ba34 100644
--- a/libweave/external/base/compiler_specific.h
+++ b/libweave/external/base/compiler_specific.h
@@ -5,7 +5,7 @@
#ifndef BASE_COMPILER_SPECIFIC_H_
#define BASE_COMPILER_SPECIFIC_H_
-#include "build/build_config.h"
+#include "base/build/build_config.h"
#if defined(COMPILER_MSVC)
diff --git a/libweave/external/base/gtest_prod_util.h b/libweave/external/base/gtest_prod_util.h
index 3289e63..b90cd4e 100644
--- a/libweave/external/base/gtest_prod_util.h
+++ b/libweave/external/base/gtest_prod_util.h
@@ -5,7 +5,7 @@
#ifndef BASE_GTEST_PROD_UTIL_H_
#define BASE_GTEST_PROD_UTIL_H_
-#include "testing/gtest/include/gtest/gtest_prod.h"
+#include <gtest/gtest_prod.h>
// This is a wrapper for gtest's FRIEND_TEST macro that friends
// test with all possible prefixes. This is very helpful when changing the test
diff --git a/libweave/external/base/guid.h b/libweave/external/base/guid.h
index abcc589..420ec17 100644
--- a/libweave/external/base/guid.h
+++ b/libweave/external/base/guid.h
@@ -9,7 +9,7 @@
#include "base/base_export.h"
#include "base/basictypes.h"
-#include "build/build_config.h"
+#include "base/build/build_config.h"
namespace base {
@@ -19,9 +19,6 @@
// the GUID. The Windows implementation uses system services.
BASE_EXPORT std::string GenerateGUID();
-// Returns true if the input string conforms to the GUID format.
-BASE_EXPORT bool IsValidGUID(const std::string& guid);
-
#if defined(OS_POSIX)
// For unit testing purposes only. Do not use outside of tests.
BASE_EXPORT std::string RandomDataToGUIDString(const uint64 bytes[2]);
diff --git a/libweave/external/base/guid_unittest.cc b/libweave/external/base/guid_unittest.cc
index 1485497..37b4edc 100644
--- a/libweave/external/base/guid_unittest.cc
+++ b/libweave/external/base/guid_unittest.cc
@@ -6,8 +6,9 @@
#include <limits>
+#include <gtest/gtest.h>
+
#include "base/strings/string_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
@@ -15,6 +16,32 @@
namespace {
+template <typename Char>
+inline bool IsHexDigit(Char c) {
+ return (c >= '0' && c <= '9') ||
+ (c >= 'A' && c <= 'F') ||
+ (c >= 'a' && c <= 'f');
+}
+
+bool IsValidGUID(const std::string& guid) {
+ const size_t kGUIDLength = 36U;
+ if (guid.length() != kGUIDLength)
+ return false;
+
+ for (size_t i = 0; i < guid.length(); ++i) {
+ char current = guid[i];
+ if (i == 8 || i == 13 || i == 18 || i == 23) {
+ if (current != '-')
+ return false;
+ } else {
+ if (!IsHexDigit(current))
+ return false;
+ }
+ }
+
+ return true;
+}
+
bool IsGUIDv4(const std::string& guid) {
// The format of GUID version 4 must be xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx,
// where y is one of [8, 9, A, B].
@@ -43,8 +70,6 @@
for (int it = 0; it < kIterations; ++it) {
std::string guid = GenerateGUID();
EXPECT_TRUE(IsValidGUID(guid));
- EXPECT_TRUE(IsValidGUID(StringToLowerASCII(guid)));
- EXPECT_TRUE(IsValidGUID(StringToUpperASCII(guid)));
}
}
diff --git a/libweave/external/base/json/json_parser.cc b/libweave/external/base/json/json_parser.cc
index 4d79be3..964fcd4 100644
--- a/libweave/external/base/json/json_parser.cc
+++ b/libweave/external/base/json/json_parser.cc
@@ -13,7 +13,6 @@
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversion_utils.h"
-#include "base/strings/utf_string_conversions.h"
#include "base/third_party/icu/icu_utf.h"
#include "base/values.h"
@@ -142,10 +141,6 @@
string_piece_.CopyToString(out_value);
return true;
}
- bool GetAsString(string16* out_value) const override {
- *out_value = UTF8ToUTF16(string_piece_);
- return true;
- }
Value* DeepCopy() const override {
return new StringValue(string_piece_.as_string());
}
@@ -885,7 +880,7 @@
int len = 0;
char c = first;
- while (CanConsume(1) && IsAsciiDigit(c)) {
+ while (CanConsume(1) && std::isdigit(c)) {
c = *NextChar();
++len;
}
diff --git a/libweave/external/base/json/json_parser.h b/libweave/external/base/json/json_parser.h
index b4d0b1b..c8ed0cd 100644
--- a/libweave/external/base/json/json_parser.h
+++ b/libweave/external/base/json/json_parser.h
@@ -10,30 +10,14 @@
#include "base/base_export.h"
#include "base/basictypes.h"
#include "base/compiler_specific.h"
+#include "base/gtest_prod_util.h"
#include "base/json/json_reader.h"
#include "base/strings/string_piece.h"
-#if !defined(OS_CHROMEOS)
-#include "base/gtest_prod_util.h"
-#endif
-
namespace base {
class Value;
}
-#if defined(OS_CHROMEOS)
-// Chromium and Chromium OS check out gtest to different places, so this is
-// unable to compile on both if gtest_prod.h is included here. Instead, include
-// its only contents -- this will need to be updated if the macro ever changes.
-#define FRIEND_TEST(test_case_name, test_name)\
-friend class test_case_name##_##test_name##_Test
-
-#define FRIEND_TEST_ALL_PREFIXES(test_case_name, test_name) \
- FRIEND_TEST(test_case_name, test_name); \
- FRIEND_TEST(test_case_name, DISABLED_##test_name); \
- FRIEND_TEST(test_case_name, FLAKY_##test_name)
-#endif // OS_CHROMEOS
-
namespace base {
namespace internal {
diff --git a/libweave/external/base/json/json_parser_unittest.cc b/libweave/external/base/json/json_parser_unittest.cc
index f776ddf..c432eee 100644
--- a/libweave/external/base/json/json_parser_unittest.cc
+++ b/libweave/external/base/json/json_parser_unittest.cc
@@ -4,10 +4,11 @@
#include "base/json/json_parser.h"
+#include <gtest/gtest.h>
+
#include "base/json/json_reader.h"
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace internal {
diff --git a/libweave/external/base/json/json_reader_unittest.cc b/libweave/external/base/json/json_reader_unittest.cc
index 7d3a6d9..a5f2530 100644
--- a/libweave/external/base/json/json_reader_unittest.cc
+++ b/libweave/external/base/json/json_reader_unittest.cc
@@ -4,16 +4,14 @@
#include "base/json/json_reader.h"
-#include "base/base_paths.h"
-#include "base/files/file_util.h"
+#include <gtest/gtest.h>
+
+#include "base/build/build_config.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
-#include "base/path_service.h"
#include "base/strings/string_piece.h"
-#include "base/strings/utf_string_conversions.h"
+#include "base/strings/utf_string_conversion_utils.h"
#include "base/values.h"
-#include "build/build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
@@ -225,7 +223,7 @@
EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
str_val.clear();
EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ(std::wstring(L"A\0\x1234", 3), UTF8ToWide(str_val));
+ EXPECT_EQ((std::string{'A', '\0', '\xE1', '\x88', '\xB4'}), str_val);
// Test invalid strings
root = JSONReader().ReadToValue("\"no closing quote");
@@ -482,7 +480,7 @@
EXPECT_TRUE(root->IsType(Value::TYPE_STRING));
str_val.clear();
EXPECT_TRUE(root->GetAsString(&str_val));
- EXPECT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val));
+ EXPECT_EQ("\xE7\xBD\x91\xE9\xA1\xB5", str_val);
root = JSONReader().ReadToValue(
"{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}");
@@ -551,22 +549,6 @@
EXPECT_EQ("root", str_val);
}
-TEST(JSONReaderTest, ReadFromFile) {
- FilePath path;
- ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
- path = path.AppendASCII("json");
- ASSERT_TRUE(base::PathExists(path));
-
- std::string input;
- ASSERT_TRUE(ReadFileToString(
- path.Append(FILE_PATH_LITERAL("bom_feff.json")), &input));
-
- JSONReader reader;
- scoped_ptr<Value> root(reader.ReadToValue(input));
- ASSERT_TRUE(root.get()) << reader.GetErrorMessage();
- EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
-}
-
// Tests that the root of a JSON object can be deleted safely while its
// children outlive it.
TEST(JSONReaderTest, StringOptimizations) {
diff --git a/libweave/external/base/json/json_writer.cc b/libweave/external/base/json/json_writer.cc
index abfead8..8bf4c6f 100644
--- a/libweave/external/base/json/json_writer.cc
+++ b/libweave/external/base/json/json_writer.cc
@@ -9,7 +9,7 @@
#include "base/json/string_escape.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
-#include "base/strings/utf_string_conversions.h"
+#include "base/strings/utf_string_conversion_utils.h"
#include "base/values.h"
namespace base {
diff --git a/libweave/external/base/json/json_writer_unittest.cc b/libweave/external/base/json/json_writer_unittest.cc
index 0daeafc..cb88cde 100644
--- a/libweave/external/base/json/json_writer_unittest.cc
+++ b/libweave/external/base/json/json_writer_unittest.cc
@@ -3,8 +3,10 @@
// found in the LICENSE file.
#include "base/json/json_writer.h"
+
+#include <gtest/gtest.h>
+
#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
diff --git a/libweave/external/base/json/string_escape.cc b/libweave/external/base/json/string_escape.cc
index 469f9f9..7ba612f 100644
--- a/libweave/external/base/json/string_escape.cc
+++ b/libweave/external/base/json/string_escape.cc
@@ -6,10 +6,10 @@
#include <string>
+#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversion_utils.h"
-#include "base/strings/utf_string_conversions.h"
#include "base/third_party/icu/icu_utf.h"
namespace base {
@@ -107,12 +107,6 @@
return EscapeJSONStringImpl(str, put_in_quotes, dest);
}
-bool EscapeJSONString(const StringPiece16& str,
- bool put_in_quotes,
- std::string* dest) {
- return EscapeJSONStringImpl(str, put_in_quotes, dest);
-}
-
std::string GetQuotedJSONString(const StringPiece& str) {
std::string dest;
bool ok = EscapeJSONStringImpl(str, true, &dest);
@@ -120,13 +114,6 @@
return dest;
}
-std::string GetQuotedJSONString(const StringPiece16& str) {
- std::string dest;
- bool ok = EscapeJSONStringImpl(str, true, &dest);
- DCHECK(ok);
- return dest;
-}
-
std::string EscapeBytesAsInvalidJSONString(const StringPiece& str,
bool put_in_quotes) {
std::string dest;
diff --git a/libweave/external/base/json/string_escape.h b/libweave/external/base/json/string_escape.h
index b66b7e5..c3a34bd 100644
--- a/libweave/external/base/json/string_escape.h
+++ b/libweave/external/base/json/string_escape.h
@@ -29,17 +29,9 @@
bool put_in_quotes,
std::string* dest);
-// Performs a similar function to the UTF-8 StringPiece version above,
-// converting UTF-16 code units to UTF-8 code units and escaping non-printing
-// control characters. On return, |dest| will contain a valid UTF-8 JSON string.
-BASE_EXPORT bool EscapeJSONString(const StringPiece16& str,
- bool put_in_quotes,
- std::string* dest);
-
// Helper functions that wrap the above two functions but return the value
// instead of appending. |put_in_quotes| is always true.
BASE_EXPORT std::string GetQuotedJSONString(const StringPiece& str);
-BASE_EXPORT std::string GetQuotedJSONString(const StringPiece16& str);
// Given an arbitrary byte string |str|, this will escape all non-ASCII bytes
// as \uXXXX escape sequences. This function is *NOT* meant to be used with
diff --git a/libweave/external/base/json/string_escape_unittest.cc b/libweave/external/base/json/string_escape_unittest.cc
index 100373f..615acc4 100644
--- a/libweave/external/base/json/string_escape_unittest.cc
+++ b/libweave/external/base/json/string_escape_unittest.cc
@@ -4,9 +4,10 @@
#include "base/json/string_escape.h"
+#include <gtest/gtest.h>
+
#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "base/strings/utf_string_conversion_utils.h"
namespace base {
@@ -68,91 +69,6 @@
EXPECT_TRUE(IsStringUTF8(out));
}
-TEST(JSONStringEscapeTest, EscapeUTF16) {
- const struct {
- const wchar_t* to_escape;
- const char* escaped;
- } cases[] = {
- {L"b\uffb1\u00ff", "b\xEF\xBE\xB1\xC3\xBF"},
- {L"\b\001aZ\"\\wee", "\\b\\u0001aZ\\\"\\\\wee"},
- {L"a\b\f\n\r\t\v\1\\.\"z",
- "a\\b\\f\\n\\r\\t\\u000B\\u0001\\\\.\\\"z"},
- {L"b\x0f\x7f\xf0\xff!", "b\\u000F\x7F\xC3\xB0\xC3\xBF!"},
- {L"c<>d", "c\\u003C>d"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- string16 in = WideToUTF16(cases[i].to_escape);
-
- std::string out;
- EscapeJSONString(in, false, &out);
- EXPECT_EQ(std::string(cases[i].escaped), out);
- EXPECT_TRUE(IsStringUTF8(out));
-
- out = GetQuotedJSONString(in);
- EXPECT_EQ("\"" + std::string(cases[i].escaped) + "\"", out);
- EXPECT_TRUE(IsStringUTF8(out));
- }
-
- string16 in = WideToUTF16(cases[0].to_escape);
- std::string out;
- EscapeJSONString(in, false, &out);
- EXPECT_TRUE(IsStringUTF8(out));
-
- // test quoting
- std::string out_quoted;
- EscapeJSONString(in, true, &out_quoted);
- EXPECT_EQ(out.length() + 2, out_quoted.length());
- EXPECT_EQ(out_quoted.find(out), 1U);
- EXPECT_TRUE(IsStringUTF8(out));
-
- // now try with a NULL in the string
- string16 null_prepend = WideToUTF16(L"test");
- null_prepend.push_back(0);
- in = null_prepend + in;
- std::string expected = "test\\u0000";
- expected += cases[0].escaped;
- out.clear();
- EscapeJSONString(in, false, &out);
- EXPECT_EQ(expected, out);
- EXPECT_TRUE(IsStringUTF8(out));
-}
-
-TEST(JSONStringEscapeTest, EscapeUTF16OutsideBMP) {
- {
- // {a, U+10300, !}, SMP.
- string16 test;
- test.push_back('a');
- test.push_back(0xD800);
- test.push_back(0xDF00);
- test.push_back('!');
- std::string actual;
- EXPECT_TRUE(EscapeJSONString(test, false, &actual));
- EXPECT_EQ("a\xF0\x90\x8C\x80!", actual);
- }
- {
- // {U+20021, U+2002B}, SIP.
- string16 test;
- test.push_back(0xD840);
- test.push_back(0xDC21);
- test.push_back(0xD840);
- test.push_back(0xDC2B);
- std::string actual;
- EXPECT_TRUE(EscapeJSONString(test, false, &actual));
- EXPECT_EQ("\xF0\xA0\x80\xA1\xF0\xA0\x80\xAB", actual);
- }
- {
- // {?, U+D800, @}, lone surrogate.
- string16 test;
- test.push_back('?');
- test.push_back(0xD800);
- test.push_back('@');
- std::string actual;
- EXPECT_FALSE(EscapeJSONString(test, false, &actual));
- EXPECT_EQ("?\xEF\xBF\xBD@", actual);
- }
-}
-
TEST(JSONStringEscapeTest, EscapeBytes) {
const struct {
const char* to_escape;
diff --git a/libweave/external/base/location.cc b/libweave/external/base/location.cc
index 1333e6e..b31cae8 100644
--- a/libweave/external/base/location.cc
+++ b/libweave/external/base/location.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "build/build_config.h"
+#include "base/build/build_config.h"
#if defined(COMPILER_MSVC)
#include <intrin.h>
diff --git a/libweave/external/base/location.h b/libweave/external/base/location.h
index 477dc02..4a38264 100644
--- a/libweave/external/base/location.h
+++ b/libweave/external/base/location.h
@@ -10,7 +10,6 @@
#include "base/base_export.h"
#include "base/basictypes.h"
-#include "base/containers/hash_tables.h"
namespace tracked_objects {
@@ -47,26 +46,6 @@
std::string ToString() const;
- // Hash operator for hash maps.
- struct Hash {
- size_t operator()(const Location& location) const {
- // Compute the hash value using file name pointer and line number.
- // No need to use |function_name_| since the other two fields uniquely
- // identify this location.
-
- // The file name will always be uniquely identified by its pointer since
- // it comes from __FILE__, so no need to check the contents of the string.
- // See the definition of FROM_HERE in location.h, and how it is used
- // elsewhere.
-
- // Due to inconsistent definitions of uint64_t and uintptr_t, casting the
- // file name pointer to a uintptr_t causes a compiler error for some
- // platforms. The solution is to explicitly cast it to a uint64_t.
- return base::HashPair(reinterpret_cast<uint64_t>(location.file_name()),
- location.line_number());
- }
- };
-
// Translate the some of the state in this instance into a human readable
// string with HTML characters in the function names escaped, and append that
// string to |output|. Inclusion of the file_name_ and function_name_ are
diff --git a/libweave/external/base/logging.cc b/libweave/external/base/logging.cc
index 71528ad..1a796b8 100644
--- a/libweave/external/base/logging.cc
+++ b/libweave/external/base/logging.cc
@@ -4,39 +4,14 @@
#include "base/logging.h"
-#if defined(OS_WIN)
-#include <io.h>
-#include <windows.h>
-typedef HANDLE FileHandle;
-typedef HANDLE MutexHandle;
-// Windows warns on using write(). It prefers _write().
-#define write(fd, buf, count) _write(fd, buf, static_cast<unsigned int>(count))
-// Windows doesn't define STDERR_FILENO. Define it here.
-#define STDERR_FILENO 2
-#elif defined(OS_MACOSX)
-#include <mach/mach.h>
-#include <mach/mach_time.h>
-#include <mach-o/dyld.h>
-#elif defined(OS_POSIX)
-#if defined(OS_NACL)
-#include <sys/time.h> // timespec doesn't seem to be in <time.h>
-#else
#include <sys/syscall.h>
-#endif
#include <time.h>
-#endif
-
-#if defined(OS_POSIX)
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#define MAX_PATH PATH_MAX
-typedef FILE* FileHandle;
-typedef pthread_mutex_t* MutexHandle;
-#endif
#include <algorithm>
#include <cstring>
@@ -45,34 +20,16 @@
#include <ostream>
#include <string>
-#include "base/base_switches.h"
-#include "base/command_line.h"
-#include "base/debug/alias.h"
-#include "base/debug/debugger.h"
-#include "base/debug/stack_trace.h"
#include "base/posix/eintr_wrapper.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/lock_impl.h"
-#include "base/threading/platform_thread.h"
-#include "base/vlog.h"
-#if defined(OS_POSIX)
-#include "base/posix/safe_strerror.h"
-#endif
-
-#if defined(OS_ANDROID)
-#include <android/log.h>
-#endif
+#include "base/strings/utf_string_conversion_utils.h"
namespace logging {
namespace {
-VlogInfo* g_vlog_info = nullptr;
-VlogInfo* g_vlog_info_prev = nullptr;
-
const char* const log_severity_names[LOG_NUM_SEVERITIES] = {
"INFO", "WARNING", "ERROR", "FATAL" };
@@ -89,24 +46,8 @@
// For LOG_ERROR and above, always print to stderr.
const int kAlwaysPrintErrorLevel = LOG_ERROR;
-// Which log file to use? This is initialized by InitLogging or
-// will be lazily initialized to the default value when it is
-// first needed.
-#if defined(OS_WIN)
-typedef std::wstring PathString;
-#else
-typedef std::string PathString;
-#endif
-PathString* g_log_file_name = nullptr;
-
-// This file is lazily opened and the handle may be nullptr
-FileHandle g_log_file = nullptr;
-
// What should be prepended to each message?
-bool g_log_process_id = false;
-bool g_log_thread_id = false;
bool g_log_timestamp = true;
-bool g_log_tickcount = false;
// Should we pop up fatal debug messages in a dialog?
bool show_error_dialogs = false;
@@ -119,281 +60,15 @@
// Helper functions to wrap platform differences.
-int32 CurrentProcessId() {
-#if defined(OS_WIN)
- return GetCurrentProcessId();
-#elif defined(OS_POSIX)
- return getpid();
-#endif
-}
-
-uint64 TickCount() {
-#if defined(OS_WIN)
- return GetTickCount();
-#elif defined(OS_MACOSX)
- return mach_absolute_time();
-#elif defined(OS_NACL)
- // NaCl sadly does not have _POSIX_TIMERS enabled in sys/features.h
- // So we have to use clock() for now.
- return clock();
-#elif defined(OS_POSIX)
- struct timespec ts;
- clock_gettime(CLOCK_MONOTONIC, &ts);
-
- uint64 absolute_micro =
- static_cast<int64>(ts.tv_sec) * 1000000 +
- static_cast<int64>(ts.tv_nsec) / 1000;
-
- return absolute_micro;
-#endif
-}
-
-void DeleteFilePath(const PathString& log_name) {
-#if defined(OS_WIN)
- DeleteFile(log_name.c_str());
-#elif defined(OS_NACL)
- // Do nothing; unlink() isn't supported on NaCl.
-#else
- unlink(log_name.c_str());
-#endif
-}
-
-PathString GetDefaultLogFile() {
-#if defined(OS_WIN)
- // On Windows we use the same path as the exe.
- wchar_t module_name[MAX_PATH];
- GetModuleFileName(nullptr, module_name, MAX_PATH);
-
- PathString log_name = module_name;
- PathString::size_type last_backslash = log_name.rfind('\\', log_name.size());
- if (last_backslash != PathString::npos)
- log_name.erase(last_backslash + 1);
- log_name += L"debug.log";
- return log_name;
-#elif defined(OS_POSIX)
- // On other platforms we just use the current directory.
- return PathString("debug.log");
-#endif
-}
-
-// This class acts as a wrapper for locking the logging files.
-// LoggingLock::Init() should be called from the main thread before any logging
-// is done. Then whenever logging, be sure to have a local LoggingLock
-// instance on the stack. This will ensure that the lock is unlocked upon
-// exiting the frame.
-// LoggingLocks can not be nested.
-class LoggingLock {
- public:
- LoggingLock() {
- LockLogging();
- }
-
- ~LoggingLock() {
- UnlockLogging();
- }
-
- static void Init(LogLockingState lock_log, const PathChar* new_log_file) {
- if (initialized)
- return;
- lock_log_file = lock_log;
- if (lock_log_file == LOCK_LOG_FILE) {
-#if defined(OS_WIN)
- if (!log_mutex) {
- std::wstring safe_name;
- if (new_log_file)
- safe_name = new_log_file;
- else
- safe_name = GetDefaultLogFile();
- // \ is not a legal character in mutex names so we replace \ with /
- std::replace(safe_name.begin(), safe_name.end(), '\\', '/');
- std::wstring t(L"Global\\");
- t.append(safe_name);
- log_mutex = ::CreateMutex(nullptr, FALSE, t.c_str());
-
- if (log_mutex == nullptr) {
-#if DEBUG
- // Keep the error code for debugging
- int error = GetLastError(); // NOLINT
- base::debug::BreakDebugger();
-#endif
- // Return nicely without putting initialized to true.
- return;
- }
- }
-#endif
- } else {
- log_lock = new base::internal::LockImpl();
- }
- initialized = true;
- }
-
- private:
- static void LockLogging() {
- if (lock_log_file == LOCK_LOG_FILE) {
-#if defined(OS_WIN)
- ::WaitForSingleObject(log_mutex, INFINITE);
- // WaitForSingleObject could have returned WAIT_ABANDONED. We don't
- // abort the process here. UI tests might be crashy sometimes,
- // and aborting the test binary only makes the problem worse.
- // We also don't use LOG macros because that might lead to an infinite
- // loop. For more info see http://crbug.com/18028.
-#elif defined(OS_POSIX)
- pthread_mutex_lock(&log_mutex);
-#endif
- } else {
- // use the lock
- log_lock->Lock();
- }
- }
-
- static void UnlockLogging() {
- if (lock_log_file == LOCK_LOG_FILE) {
-#if defined(OS_WIN)
- ReleaseMutex(log_mutex);
-#elif defined(OS_POSIX)
- pthread_mutex_unlock(&log_mutex);
-#endif
- } else {
- log_lock->Unlock();
- }
- }
-
- // The lock is used if log file locking is false. It helps us avoid problems
- // with multiple threads writing to the log file at the same time. Use
- // LockImpl directly instead of using Lock, because Lock makes logging calls.
- static base::internal::LockImpl* log_lock;
-
- // When we don't use a lock, we are using a global mutex. We need to do this
- // because LockFileEx is not thread safe.
-#if defined(OS_WIN)
- static MutexHandle log_mutex;
-#elif defined(OS_POSIX)
- static pthread_mutex_t log_mutex;
-#endif
-
- static bool initialized;
- static LogLockingState lock_log_file;
-};
-
-// static
-bool LoggingLock::initialized = false;
-// static
-base::internal::LockImpl* LoggingLock::log_lock = nullptr;
-// static
-LogLockingState LoggingLock::lock_log_file = LOCK_LOG_FILE;
-
-#if defined(OS_WIN)
-// static
-MutexHandle LoggingLock::log_mutex = nullptr;
-#elif defined(OS_POSIX)
-pthread_mutex_t LoggingLock::log_mutex = PTHREAD_MUTEX_INITIALIZER;
-#endif
-
-// Called by logging functions to ensure that |g_log_file| is initialized
-// and can be used for writing. Returns false if the file could not be
-// initialized. |g_log_file| will be nullptr in this case.
-bool InitializeLogFileHandle() {
- if (g_log_file)
- return true;
-
- if (!g_log_file_name) {
- // Nobody has called InitLogging to specify a debug log file, so here we
- // initialize the log file name to a default.
- g_log_file_name = new PathString(GetDefaultLogFile());
- }
-
- if ((g_logging_destination & LOG_TO_FILE) != 0) {
-#if defined(OS_WIN)
- g_log_file = CreateFile(g_log_file_name->c_str(), GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
- OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
- if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
- // try the current directory
- g_log_file = CreateFile(L".\\debug.log", GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
- OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
- if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
- g_log_file = nullptr;
- return false;
- }
- }
- SetFilePointer(g_log_file, 0, 0, FILE_END);
-#elif defined(OS_POSIX)
- g_log_file = fopen(g_log_file_name->c_str(), "a");
- if (g_log_file == nullptr)
- return false;
-#endif
- }
-
- return true;
-}
-
-void CloseFile(FileHandle log) {
-#if defined(OS_WIN)
- CloseHandle(log);
-#else
- fclose(log);
-#endif
-}
-
-void CloseLogFileUnlocked() {
- if (!g_log_file)
- return;
-
- CloseFile(g_log_file);
- g_log_file = nullptr;
-}
-
} // namespace
LoggingSettings::LoggingSettings()
- : logging_dest(LOG_DEFAULT),
- log_file(nullptr),
- lock_log(LOCK_LOG_FILE),
- delete_old(APPEND_TO_OLD_LOG_FILE) {}
+ : logging_dest(LOG_DEFAULT) {}
bool BaseInitLoggingImpl(const LoggingSettings& settings) {
-#if defined(OS_NACL)
- // Can log only to the system debug log.
- CHECK_EQ(settings.logging_dest & ~LOG_TO_SYSTEM_DEBUG_LOG, 0);
-#endif
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- // Don't bother initializing |g_vlog_info| unless we use one of the
- // vlog switches.
- if (command_line->HasSwitch(switches::kV) ||
- command_line->HasSwitch(switches::kVModule)) {
- // NOTE: If |g_vlog_info| has already been initialized, it might be in use
- // by another thread. Don't delete the old VLogInfo, just create a second
- // one. We keep track of both to avoid memory leak warnings.
- CHECK(!g_vlog_info_prev);
- g_vlog_info_prev = g_vlog_info;
-
- g_vlog_info =
- new VlogInfo(command_line->GetSwitchValueASCII(switches::kV),
- command_line->GetSwitchValueASCII(switches::kVModule),
- &g_min_log_level);
- }
-
g_logging_destination = settings.logging_dest;
- // ignore file options unless logging to file is set.
- if ((g_logging_destination & LOG_TO_FILE) == 0)
- return true;
-
- LoggingLock::Init(settings.lock_log, settings.log_file);
- LoggingLock logging_lock;
-
- // Calling InitLogging twice or after some log call has already opened the
- // default log file will re-initialize to the new options.
- CloseLogFileUnlocked();
-
- if (!g_log_file_name)
- g_log_file_name = new PathString();
- *g_log_file_name = settings.log_file;
- if (settings.delete_old == DELETE_OLD_LOG_FILE)
- DeleteFilePath(*g_log_file_name);
-
- return InitializeLogFileHandle();
+ return true;
}
void SetMinLogLevel(int level) {
@@ -410,20 +85,12 @@
int GetVlogLevelHelper(const char* file, size_t N) {
DCHECK_GT(N, 0U);
- // Note: |g_vlog_info| may change on a different thread during startup
- // (but will always be valid or nullptr).
- VlogInfo* vlog_info = g_vlog_info;
- return vlog_info ?
- vlog_info->GetVlogLevel(base::StringPiece(file, N - 1)) :
- GetVlogVerbosity();
+ return 0;
}
void SetLogItems(bool enable_process_id, bool enable_thread_id,
bool enable_timestamp, bool enable_tickcount) {
- g_log_process_id = enable_process_id;
- g_log_thread_id = enable_thread_id;
g_log_timestamp = enable_timestamp;
- g_log_tickcount = enable_tickcount;
}
void SetShowErrorDialogs(bool enable_dialogs) {
@@ -454,68 +121,6 @@
template std::string* MakeCheckOpString<std::string, std::string>(
const std::string&, const std::string&, const char* name);
-#if !defined(NDEBUG)
-// Displays a message box to the user with the error message in it.
-// Used for fatal messages, where we close the app simultaneously.
-// This is for developers only; we don't use this in circumstances
-// (like release builds) where users could see it, since users don't
-// understand these messages anyway.
-void DisplayDebugMessageInDialog(const std::string& str) {
- if (str.empty())
- return;
-
- if (!show_error_dialogs)
- return;
-
-#if defined(OS_WIN)
- // For Windows programs, it's possible that the message loop is
- // messed up on a fatal error, and creating a MessageBox will cause
- // that message loop to be run. Instead, we try to spawn another
- // process that displays its command line. We look for "Debug
- // Message.exe" in the same directory as the application. If it
- // exists, we use it, otherwise, we use a regular message box.
- wchar_t prog_name[MAX_PATH];
- GetModuleFileNameW(nullptr, prog_name, MAX_PATH);
- wchar_t* backslash = wcsrchr(prog_name, '\\');
- if (backslash)
- backslash[1] = 0;
- wcscat_s(prog_name, MAX_PATH, L"debug_message.exe");
-
- std::wstring cmdline = base::UTF8ToWide(str);
- if (cmdline.empty())
- return;
-
- STARTUPINFO startup_info;
- memset(&startup_info, 0, sizeof(startup_info));
- startup_info.cb = sizeof(startup_info);
-
- PROCESS_INFORMATION process_info;
- if (CreateProcessW(prog_name, &cmdline[0], nullptr, nullptr, false, 0,
- nullptr, nullptr, &startup_info, &process_info)) {
- WaitForSingleObject(process_info.hProcess, INFINITE);
- CloseHandle(process_info.hThread);
- CloseHandle(process_info.hProcess);
- } else {
- // debug process broken, let's just do a message box
- MessageBoxW(nullptr, &cmdline[0], L"Fatal error",
- MB_OK | MB_ICONHAND | MB_TOPMOST);
- }
-#else
- // We intentionally don't implement a dialog on other platforms.
- // You can just look at stderr.
-#endif // defined(OS_WIN)
-}
-#endif // !defined(NDEBUG)
-
-#if defined(OS_WIN)
-LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {
-}
-
-LogMessage::SaveLastError::~SaveLastError() {
- ::SetLastError(last_error_);
-}
-#endif // defined(OS_WIN)
-
LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
: severity_(severity), file_(file), line_(line) {
Init(file, line);
@@ -537,14 +142,6 @@
}
LogMessage::~LogMessage() {
-#if !defined(NDEBUG) && !defined(OS_NACL) && !defined(__UCLIBC__)
- if (severity_ == LOG_FATAL) {
- // Include a stack trace on a fatal.
- base::debug::StackTrace trace;
- stream_ << std::endl; // Newline to separate from log message.
- trace.OutputToStream(&stream_);
- }
-#endif
stream_ << std::endl;
std::string str_newline(stream_.str());
@@ -557,27 +154,6 @@
}
if ((g_logging_destination & LOG_TO_SYSTEM_DEBUG_LOG) != 0) {
-#if defined(OS_WIN)
- OutputDebugStringA(str_newline.c_str());
-#elif defined(OS_ANDROID)
- android_LogPriority priority =
- (severity_ < 0) ? ANDROID_LOG_VERBOSE : ANDROID_LOG_UNKNOWN;
- switch (severity_) {
- case LOG_INFO:
- priority = ANDROID_LOG_INFO;
- break;
- case LOG_WARNING:
- priority = ANDROID_LOG_WARN;
- break;
- case LOG_ERROR:
- priority = ANDROID_LOG_ERROR;
- break;
- case LOG_FATAL:
- priority = ANDROID_LOG_FATAL;
- break;
- }
- __android_log_write(priority, "chromium", str_newline.c_str());
-#endif
ignore_result(fwrite(str_newline.data(), str_newline.size(), 1, stderr));
fflush(stderr);
} else if (severity_ >= kAlwaysPrintErrorLevel) {
@@ -588,55 +164,18 @@
fflush(stderr);
}
- // write to log file
- if ((g_logging_destination & LOG_TO_FILE) != 0) {
- // We can have multiple threads and/or processes, so try to prevent them
- // from clobbering each other's writes.
- // If the client app did not call InitLogging, and the lock has not
- // been created do it now. We do this on demand, but if two threads try
- // to do this at the same time, there will be a race condition to create
- // the lock. This is why InitLogging should be called from the main
- // thread at the beginning of execution.
- LoggingLock::Init(LOCK_LOG_FILE, nullptr);
- LoggingLock logging_lock;
- if (InitializeLogFileHandle()) {
-#if defined(OS_WIN)
- SetFilePointer(g_log_file, 0, 0, SEEK_END);
- DWORD num_written;
- WriteFile(g_log_file,
- static_cast<const void*>(str_newline.c_str()),
- static_cast<DWORD>(str_newline.length()),
- &num_written,
- nullptr);
-#else
- ignore_result(fwrite(
- str_newline.data(), str_newline.size(), 1, g_log_file));
- fflush(g_log_file);
-#endif
- }
- }
-
if (severity_ == LOG_FATAL) {
// Ensure the first characters of the string are on the stack so they
// are contained in minidumps for diagnostic purposes.
char str_stack[1024];
str_newline.copy(str_stack, arraysize(str_stack));
- base::debug::Alias(str_stack);
if (log_assert_handler) {
// Make a copy of the string for the handler out of paranoia.
log_assert_handler(std::string(stream_.str()));
} else {
- // Don't use the string with the newline, get a fresh version to send to
- // the debug message process. We also don't display assertions to the
- // user in release mode. The enduser can't do anything with this
- // information, and displaying message boxes when the application is
- // hosed can cause additional problems.
-#ifndef NDEBUG
- DisplayDebugMessageInDialog(stream_.str());
-#endif
// Crash the process to generate a dump.
- base::debug::BreakDebugger();
+ abort();
}
}
}
@@ -651,10 +190,6 @@
// TODO(darin): It might be nice if the columns were fixed width.
stream_ << '[';
- if (g_log_process_id)
- stream_ << CurrentProcessId() << ':';
- if (g_log_thread_id)
- stream_ << base::PlatformThread::CurrentId() << ':';
if (g_log_timestamp) {
time_t t = time(nullptr);
struct tm local_time = {0};
@@ -673,8 +208,6 @@
<< std::setw(2) << tm_time->tm_sec
<< ':';
}
- if (g_log_tickcount)
- stream_ << TickCount() << ':';
if (severity_ >= 0)
stream_ << log_severity_name(severity_);
else
@@ -685,82 +218,6 @@
message_start_ = stream_.str().length();
}
-#if defined(OS_WIN)
-// This has already been defined in the header, but defining it again as DWORD
-// ensures that the type used in the header is equivalent to DWORD. If not,
-// the redefinition is a compile error.
-typedef DWORD SystemErrorCode;
-#endif
-
-SystemErrorCode GetLastSystemErrorCode() {
-#if defined(OS_WIN)
- return ::GetLastError();
-#elif defined(OS_POSIX)
- return errno;
-#else
-#error Not implemented
-#endif
-}
-
-#if defined(OS_WIN)
-BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code) {
- const int kErrorMessageBufferSize = 256;
- char msgbuf[kErrorMessageBufferSize];
- DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
- DWORD len = FormatMessageA(flags, nullptr, error_code, 0, msgbuf,
- arraysize(msgbuf), nullptr);
- if (len) {
- // Messages returned by system end with line breaks.
- return base::CollapseWhitespaceASCII(msgbuf, true) +
- base::StringPrintf(" (0x%X)", error_code);
- }
- return base::StringPrintf("Error (0x%X) while retrieving error. (0x%X)",
- GetLastError(), error_code);
-}
-#elif defined(OS_POSIX)
-BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code) {
- return base::safe_strerror(error_code);
-}
-#else
-#error Not implemented
-#endif // defined(OS_WIN)
-
-
-#if defined(OS_WIN)
-Win32ErrorLogMessage::Win32ErrorLogMessage(const char* file,
- int line,
- LogSeverity severity,
- SystemErrorCode err)
- : err_(err),
- log_message_(file, line, severity) {
-}
-
-Win32ErrorLogMessage::~Win32ErrorLogMessage() {
- stream() << ": " << SystemErrorCodeToString(err_);
- // We're about to crash (CHECK). Put |err_| on the stack (by placing it in a
- // field) and use Alias in hopes that it makes it into crash dumps.
- DWORD last_error = err_;
- base::debug::Alias(&last_error);
-}
-#elif defined(OS_POSIX)
-ErrnoLogMessage::ErrnoLogMessage(const char* file,
- int line,
- LogSeverity severity,
- SystemErrorCode err)
- : err_(err),
- log_message_(file, line, severity) {
-}
-
-ErrnoLogMessage::~ErrnoLogMessage() {
- stream() << ": " << SystemErrorCodeToString(err_);
-}
-#endif // defined(OS_WIN)
-
-void CloseLogFile() {
- LoggingLock logging_lock;
- CloseLogFileUnlocked();
-}
-
void RawLog(int level, const char* message) {
if (level >= g_min_log_level) {
size_t bytes_written = 0;
@@ -789,27 +246,15 @@
}
if (level == LOG_FATAL)
- base::debug::BreakDebugger();
+ abort();
}
// This was defined at the beginning of this file.
#undef write
-#if defined(OS_WIN)
-std::wstring GetLogFileFullPath() {
- if (g_log_file_name)
- return *g_log_file_name;
- return std::wstring();
-}
-#endif
-
BASE_EXPORT void LogErrorNotReached(const char* file, int line) {
LogMessage(file, line, LOG_ERROR).stream()
<< "NOTREACHED() hit.";
}
} // namespace logging
-
-std::ostream& std::operator<<(std::ostream& out, const wchar_t* wstr) {
- return out << base::WideToUTF8(wstr);
-}
diff --git a/libweave/external/base/logging.h b/libweave/external/base/logging.h
index ea096d1..34846fc 100644
--- a/libweave/external/base/logging.h
+++ b/libweave/external/base/logging.h
@@ -12,8 +12,7 @@
#include "base/base_export.h"
#include "base/basictypes.h"
-#include "base/debug/debugger.h"
-#include "build/build_config.h"
+#include "base/build/build_config.h"
//
// Optional message capabilities
@@ -114,18 +113,6 @@
//
// We also override the standard 'assert' to use 'DLOG_ASSERT'.
//
-// Lastly, there is:
-//
-// PLOG(ERROR) << "Couldn't do foo";
-// DPLOG(ERROR) << "Couldn't do foo";
-// PLOG_IF(ERROR, cond) << "Couldn't do foo";
-// DPLOG_IF(ERROR, cond) << "Couldn't do foo";
-// PCHECK(condition) << "Couldn't do foo";
-// DPCHECK(condition) << "Couldn't do foo";
-//
-// which append the last system error to the message in string form (taken from
-// GetLastError() on Windows and errno on POSIX).
-//
// The supported severity levels for macros that allow you to specify one
// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
//
@@ -137,61 +124,24 @@
namespace logging {
-// TODO(avi): do we want to do a unification of character types here?
-#if defined(OS_WIN)
-typedef wchar_t PathChar;
-#else
-typedef char PathChar;
-#endif
-
// Where to record logging output? A flat file and/or system debug log
// via OutputDebugString.
enum LoggingDestination {
LOG_NONE = 0,
- LOG_TO_FILE = 1 << 0,
LOG_TO_SYSTEM_DEBUG_LOG = 1 << 1,
- LOG_TO_ALL = LOG_TO_FILE | LOG_TO_SYSTEM_DEBUG_LOG,
+ LOG_TO_ALL = LOG_TO_SYSTEM_DEBUG_LOG,
- // On Windows, use a file next to the exe; on POSIX platforms, where
- // it may not even be possible to locate the executable on disk, use
- // stderr.
-#if defined(OS_WIN)
- LOG_DEFAULT = LOG_TO_FILE,
-#elif defined(OS_POSIX)
LOG_DEFAULT = LOG_TO_SYSTEM_DEBUG_LOG,
-#endif
};
-// Indicates that the log file should be locked when being written to.
-// Unless there is only one single-threaded process that is logging to
-// the log file, the file should be locked during writes to make each
-// log output atomic. Other writers will block.
-//
-// All processes writing to the log file must have their locking set for it to
-// work properly. Defaults to LOCK_LOG_FILE.
-enum LogLockingState { LOCK_LOG_FILE, DONT_LOCK_LOG_FILE };
-
-// On startup, should we delete or append to an existing log file (if any)?
-// Defaults to APPEND_TO_OLD_LOG_FILE.
-enum OldFileDeletionState { DELETE_OLD_LOG_FILE, APPEND_TO_OLD_LOG_FILE };
-
struct BASE_EXPORT LoggingSettings {
// The defaults values are:
//
// logging_dest: LOG_DEFAULT
- // log_file: NULL
- // lock_log: LOCK_LOG_FILE
- // delete_old: APPEND_TO_OLD_LOG_FILE
LoggingSettings();
LoggingDestination logging_dest;
-
- // The three settings below have an effect only when LOG_TO_FILE is
- // set in |logging_dest|.
- const PathChar* log_file;
- LogLockingState lock_log;
- OldFileDeletionState delete_old;
};
// Define different names for the BaseInitLoggingImpl() function depending on
@@ -322,20 +272,6 @@
#define COMPACT_GOOGLE_LOG_DFATAL \
COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
-#if defined(OS_WIN)
-// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
-// substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us
-// to keep using this syntax, we define this macro to do the same thing
-// as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that
-// the Windows SDK does for consistency.
-#define ERROR 0
-#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
- COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
-// Needed for LOG_IS_ON(ERROR).
-const LogSeverity LOG_0 = LOG_ERROR;
-#endif
-
// As special cases, we can assume that LOG_IS_ON(FATAL) always holds. Also,
// LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will
// always fire if they fail.
@@ -382,46 +318,11 @@
LAZY_STREAM(VLOG_STREAM(verbose_level), \
VLOG_IS_ON(verbose_level) && (condition))
-#if defined (OS_WIN)
-#define VPLOG_STREAM(verbose_level) \
- logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
- ::logging::GetLastSystemErrorCode()).stream()
-#elif defined(OS_POSIX)
-#define VPLOG_STREAM(verbose_level) \
- logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
- ::logging::GetLastSystemErrorCode()).stream()
-#endif
-
-#define VPLOG(verbose_level) \
- LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
-
-#define VPLOG_IF(verbose_level, condition) \
- LAZY_STREAM(VPLOG_STREAM(verbose_level), \
- VLOG_IS_ON(verbose_level) && (condition))
-
-// TODO(akalin): Add more VLOG variants, e.g. VPLOG.
-
#define LOG_ASSERT(condition) \
LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
#define SYSLOG_ASSERT(condition) \
SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
-#if defined(OS_WIN)
-#define PLOG_STREAM(severity) \
- COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
- ::logging::GetLastSystemErrorCode()).stream()
-#elif defined(OS_POSIX)
-#define PLOG_STREAM(severity) \
- COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
- ::logging::GetLastSystemErrorCode()).stream()
-#endif
-
-#define PLOG(severity) \
- LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
-
-#define PLOG_IF(severity, condition) \
- LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
-
// The actual stream used isn't important.
#define EAT_STREAM_PARAMETERS \
true ? (void) 0 : ::logging::LogMessageVoidify() & LOG_STREAM(FATAL)
@@ -450,36 +351,10 @@
#else
-#if defined(_PREFAST_) && defined(OS_WIN)
-// Use __analysis_assume to tell the VC++ static analysis engine that
-// assert conditions are true, to suppress warnings. The LAZY_STREAM
-// parameter doesn't reference 'condition' in /analyze builds because
-// this evaluation confuses /analyze. The !! before condition is because
-// __analysis_assume gets confused on some conditions:
-// http://randomascii.wordpress.com/2011/09/13/analyze-for-visual-studio-the-ugly-part-5/
-
-#define CHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(LOG_STREAM(FATAL), false) \
- << "Check failed: " #condition ". "
-
-#define PCHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(PLOG_STREAM(FATAL), false) \
- << "Check failed: " #condition ". "
-
-#else // _PREFAST_
-
#define CHECK(condition) \
LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \
<< "Check failed: " #condition ". "
-#define PCHECK(condition) \
- LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \
- << "Check failed: " #condition ". "
-
-#endif // _PREFAST_
-
// Helper macro for binary operators.
// Don't use this macro directly in your code, use CHECK_EQ et al below.
//
@@ -572,9 +447,7 @@
#define DLOG_IS_ON(severity) LOG_IS_ON(severity)
#define DLOG_IF(severity, condition) LOG_IF(severity, condition)
#define DLOG_ASSERT(condition) LOG_ASSERT(condition)
-#define DPLOG_IF(severity, condition) PLOG_IF(severity, condition)
#define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
-#define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
#else // ENABLE_DLOG
@@ -586,9 +459,7 @@
#define DLOG_IS_ON(severity) false
#define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
#define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS
-#define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
#define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
-#define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
#endif // ENABLE_DLOG
@@ -607,13 +478,8 @@
#define DLOG(severity) \
LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
-#define DPLOG(severity) \
- LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
-
#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
-#define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
-
// Definitions for DCHECK et al.
#if DCHECK_IS_ON()
@@ -638,31 +504,10 @@
// variable warnings if the only use of a variable is in a DCHECK.
// This behavior is different from DLOG_IF et al.
-#if defined(_PREFAST_) && defined(OS_WIN)
-// See comments on the previous use of __analysis_assume.
-
-#define DCHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(LOG_STREAM(DCHECK), false) \
- << "Check failed: " #condition ". "
-
-#define DPCHECK(condition) \
- __analysis_assume(!!(condition)), \
- LAZY_STREAM(PLOG_STREAM(DCHECK), false) \
- << "Check failed: " #condition ". "
-
-#else // _PREFAST_
-
#define DCHECK(condition) \
LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON() ? !(condition) : false) \
<< "Check failed: " #condition ". "
-#define DPCHECK(condition) \
- LAZY_STREAM(PLOG_STREAM(DCHECK), DCHECK_IS_ON() ? !(condition) : false) \
- << "Check failed: " #condition ". "
-
-#endif // _PREFAST_
-
// Helper macro for binary operators.
// Don't use this macro directly in your code, use DCHECK_EQ et al below.
#define DCHECK_OP(name, op, val1, val2) \
@@ -699,16 +544,7 @@
#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
#define DCHECK_IMPLIES(val1, val2) DCHECK(!(val1) || (val2))
-#if !DCHECK_IS_ON() && defined(OS_CHROMEOS)
-// Implement logging of NOTREACHED() as a dedicated function to get function
-// call overhead down to a minimum.
-void LogErrorNotReached(const char* file, int line);
-#define NOTREACHED() \
- true ? ::logging::LogErrorNotReached(__FILE__, __LINE__) \
- : EAT_STREAM_PARAMETERS
-#else
#define NOTREACHED() DCHECK(false)
-#endif
// Redefine the standard assert to use our nice log files
#undef assert
@@ -750,26 +586,6 @@
const char* file_;
const int line_;
-#if defined(OS_WIN)
- // Stores the current value of GetLastError in the constructor and restores
- // it in the destructor by calling SetLastError.
- // This is useful since the LogMessage class uses a lot of Win32 calls
- // that will lose the value of GLE and the code that called the log function
- // will have lost the thread error value when the log call returns.
- class SaveLastError {
- public:
- SaveLastError();
- ~SaveLastError();
-
- unsigned long get_error() const { return last_error_; }
-
- protected:
- unsigned long last_error_;
- };
-
- SaveLastError last_error_;
-#endif
-
DISALLOW_COPY_AND_ASSIGN(LogMessage);
};
@@ -790,65 +606,6 @@
void operator&(std::ostream&) { }
};
-#if defined(OS_WIN)
-typedef unsigned long SystemErrorCode;
-#elif defined(OS_POSIX)
-typedef int SystemErrorCode;
-#endif
-
-// Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
-// pull in windows.h just for GetLastError() and DWORD.
-BASE_EXPORT SystemErrorCode GetLastSystemErrorCode();
-BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code);
-
-#if defined(OS_WIN)
-// Appends a formatted system message of the GetLastError() type.
-class BASE_EXPORT Win32ErrorLogMessage {
- public:
- Win32ErrorLogMessage(const char* file,
- int line,
- LogSeverity severity,
- SystemErrorCode err);
-
- // Appends the error message before destructing the encapsulated class.
- ~Win32ErrorLogMessage();
-
- std::ostream& stream() { return log_message_.stream(); }
-
- private:
- SystemErrorCode err_;
- LogMessage log_message_;
-
- DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage);
-};
-#elif defined(OS_POSIX)
-// Appends a formatted system message of the errno type
-class BASE_EXPORT ErrnoLogMessage {
- public:
- ErrnoLogMessage(const char* file,
- int line,
- LogSeverity severity,
- SystemErrorCode err);
-
- // Appends the error message before destructing the encapsulated class.
- ~ErrnoLogMessage();
-
- std::ostream& stream() { return log_message_.stream(); }
-
- private:
- SystemErrorCode err_;
- LogMessage log_message_;
-
- DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage);
-};
-#endif // OS_WIN
-
-// Closes the log file explicitly if open.
-// NOTE: Since the log file is opened as necessary by the action of logging
-// statements, there's no guarantee that it will stay closed
-// after this call.
-BASE_EXPORT void CloseLogFile();
-
// Async signal safe logging mechanism.
BASE_EXPORT void RawLog(int level, const char* message);
@@ -860,34 +617,9 @@
logging::RawLog(logging::LOG_FATAL, "Check failed: " #condition "\n"); \
} while (0)
-#if defined(OS_WIN)
-// Returns the default log file path.
-BASE_EXPORT std::wstring GetLogFileFullPath();
-#endif
} // namespace logging
-// Note that "The behavior of a C++ program is undefined if it adds declarations
-// or definitions to namespace std or to a namespace within namespace std unless
-// otherwise specified." --C++11[namespace.std]
-//
-// We've checked that this particular definition has the intended behavior on
-// our implementations, but it's prone to breaking in the future, and please
-// don't imitate this in your own definitions without checking with some
-// standard library experts.
-namespace std {
-// These functions are provided as a convenience for logging, which is where we
-// use streams (it is against Google style to use streams in other places). It
-// is designed to allow you to emit non-ASCII Unicode strings to the log file,
-// which is normally ASCII. It is relatively slow, so try not to use it for
-// common cases. Non-ASCII characters will be converted to UTF-8 by these
-// operators.
-BASE_EXPORT std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
-inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
- return out << wstr.c_str();
-}
-} // namespace std
-
// The NOTIMPLEMENTED() macro annotates codepaths which have
// not been implemented yet.
//
@@ -900,13 +632,9 @@
// 5 -- LOG(ERROR) at runtime, only once per call-site
#ifndef NOTIMPLEMENTED_POLICY
-#if defined(OS_ANDROID) && defined(OFFICIAL_BUILD)
-#define NOTIMPLEMENTED_POLICY 0
-#else
// Select default policy: LOG(ERROR)
#define NOTIMPLEMENTED_POLICY 4
#endif
-#endif
#if defined(COMPILER_GCC)
// On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
diff --git a/libweave/external/base/logging_unittest.cc b/libweave/external/base/logging_unittest.cc
index 8b9701a..d51015d 100644
--- a/libweave/external/base/logging_unittest.cc
+++ b/libweave/external/base/logging_unittest.cc
@@ -2,12 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
#include "base/logging.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
namespace logging {
@@ -54,7 +55,7 @@
TEST_F(LoggingTest, BasicLogging) {
MockLogSource mock_log_source;
- EXPECT_CALL(mock_log_source, Log()).Times(DEBUG_MODE ? 16 : 8).
+ EXPECT_CALL(mock_log_source, Log()).
WillRepeatedly(Return("log message"));
SetMinLogLevel(LOG_INFO);
@@ -68,21 +69,13 @@
LOG(INFO) << mock_log_source.Log();
LOG_IF(INFO, true) << mock_log_source.Log();
- PLOG(INFO) << mock_log_source.Log();
- PLOG_IF(INFO, true) << mock_log_source.Log();
VLOG(0) << mock_log_source.Log();
VLOG_IF(0, true) << mock_log_source.Log();
- VPLOG(0) << mock_log_source.Log();
- VPLOG_IF(0, true) << mock_log_source.Log();
DLOG(INFO) << mock_log_source.Log();
DLOG_IF(INFO, true) << mock_log_source.Log();
- DPLOG(INFO) << mock_log_source.Log();
- DPLOG_IF(INFO, true) << mock_log_source.Log();
DVLOG(0) << mock_log_source.Log();
DVLOG_IF(0, true) << mock_log_source.Log();
- DVPLOG(0) << mock_log_source.Log();
- DVPLOG_IF(0, true) << mock_log_source.Log();
}
TEST_F(LoggingTest, LogIsOn) {
@@ -134,21 +127,13 @@
LOG(INFO) << mock_log_source.Log();
LOG_IF(INFO, false) << mock_log_source.Log();
- PLOG(INFO) << mock_log_source.Log();
- PLOG_IF(INFO, false) << mock_log_source.Log();
VLOG(1) << mock_log_source.Log();
VLOG_IF(1, true) << mock_log_source.Log();
- VPLOG(1) << mock_log_source.Log();
- VPLOG_IF(1, true) << mock_log_source.Log();
DLOG(INFO) << mock_log_source.Log();
DLOG_IF(INFO, true) << mock_log_source.Log();
- DPLOG(INFO) << mock_log_source.Log();
- DPLOG_IF(INFO, true) << mock_log_source.Log();
DVLOG(1) << mock_log_source.Log();
DVLOG_IF(1, true) << mock_log_source.Log();
- DVPLOG(1) << mock_log_source.Log();
- DVPLOG_IF(1, true) << mock_log_source.Log();
}
// Official builds have CHECKs directly call BreakDebugger.
@@ -156,14 +141,13 @@
TEST_F(LoggingTest, CheckStreamsAreLazy) {
MockLogSource mock_log_source, uncalled_mock_log_source;
- EXPECT_CALL(mock_log_source, Log()).Times(8).
+ EXPECT_CALL(mock_log_source, Log()).
WillRepeatedly(Return("check message"));
EXPECT_CALL(uncalled_mock_log_source, Log()).Times(0);
SetLogAssertHandler(&LogSink);
CHECK(mock_log_source.Log()) << uncalled_mock_log_source.Log();
- PCHECK(!mock_log_source.Log()) << mock_log_source.Log();
CHECK_EQ(mock_log_source.Log(), mock_log_source.Log())
<< uncalled_mock_log_source.Log();
CHECK_NE(mock_log_source.Log(), mock_log_source.Log())
@@ -180,7 +164,6 @@
// in release mode.
DLOG_IF(INFO, debug_only_variable) << "test";
DLOG_ASSERT(debug_only_variable) << "test";
- DPLOG_IF(INFO, debug_only_variable) << "test";
DVLOG_IF(1, debug_only_variable) << "test";
}
@@ -219,10 +202,8 @@
EXPECT_EQ(0, log_sink_call_count);
DCHECK(false);
EXPECT_EQ(DCHECK_IS_ON() ? 1 : 0, log_sink_call_count);
- DPCHECK(false);
- EXPECT_EQ(DCHECK_IS_ON() ? 2 : 0, log_sink_call_count);
DCHECK_EQ(0, 1);
- EXPECT_EQ(DCHECK_IS_ON() ? 3 : 0, log_sink_call_count);
+ EXPECT_EQ(DCHECK_IS_ON() ? 2 : 0, log_sink_call_count);
}
TEST_F(LoggingTest, DcheckReleaseBehavior) {
@@ -230,29 +211,9 @@
// These should still reference |some_variable| so we don't get
// unused variable warnings.
DCHECK(some_variable) << "test";
- DPCHECK(some_variable) << "test";
DCHECK_EQ(some_variable, 1) << "test";
}
-// Test that defining an operator<< for a type in a namespace doesn't prevent
-// other code in that namespace from calling the operator<<(ostream, wstring)
-// defined by logging.h. This can fail if operator<<(ostream, wstring) can't be
-// found by ADL, since defining another operator<< prevents name lookup from
-// looking in the global namespace.
-namespace nested_test {
- class Streamable {};
- ALLOW_UNUSED_TYPE std::ostream& operator<<(std::ostream& out,
- const Streamable&) {
- return out << "Streamable";
- }
- TEST_F(LoggingTest, StreamingWstringFindsCorrectOperator) {
- std::wstring wstr = L"Hello World";
- std::ostringstream ostr;
- ostr << wstr;
- EXPECT_EQ("Hello World", ostr.str());
- }
-} // namespace nested_test
-
} // namespace
} // namespace logging
diff --git a/libweave/external/base/memory/ref_counted.cc b/libweave/external/base/memory/ref_counted.cc
index f5924d0..4a20cb6 100644
--- a/libweave/external/base/memory/ref_counted.cc
+++ b/libweave/external/base/memory/ref_counted.cc
@@ -3,7 +3,6 @@
// found in the LICENSE file.
#include "base/memory/ref_counted.h"
-#include "base/threading/thread_collision_warner.h"
namespace base {
diff --git a/libweave/external/base/memory/ref_counted.h b/libweave/external/base/memory/ref_counted.h
index 5f94b4c..ee5f58b 100644
--- a/libweave/external/base/memory/ref_counted.h
+++ b/libweave/external/base/memory/ref_counted.h
@@ -10,13 +10,10 @@
#include "base/atomic_ref_count.h"
#include "base/base_export.h"
+#include "base/build/build_config.h"
#include "base/compiler_specific.h"
-#ifndef NDEBUG
#include "base/logging.h"
-#endif
#include "base/move.h"
-#include "base/threading/thread_collision_warner.h"
-#include "build/build_config.h"
namespace base {
@@ -43,10 +40,6 @@
void AddRef() const {
- // TODO(maruel): Add back once it doesn't assert 500 times/sec.
- // Current thread books the critical section "AddRelease"
- // without release it.
- // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
#ifndef NDEBUG
DCHECK(!in_dtor_);
#endif
@@ -55,10 +48,6 @@
// Returns true if the object should self-delete.
bool Release() const {
- // TODO(maruel): Add back once it doesn't assert 500 times/sec.
- // Current thread books the critical section "AddRelease"
- // without release it.
- // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
#ifndef NDEBUG
DCHECK(!in_dtor_);
#endif
@@ -77,8 +66,6 @@
mutable bool in_dtor_;
#endif
- DFAKE_MUTEX(add_release_);
-
DISALLOW_COPY_AND_ASSIGN(RefCountedBase);
};
diff --git a/libweave/external/base/memory/ref_counted_unittest.cc b/libweave/external/base/memory/ref_counted_unittest.cc
index 6f8e599..9eda813 100644
--- a/libweave/external/base/memory/ref_counted_unittest.cc
+++ b/libweave/external/base/memory/ref_counted_unittest.cc
@@ -4,8 +4,7 @@
#include "base/memory/ref_counted.h"
-#include "base/test/opaque_ref_counted.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include <gtest/gtest.h>
namespace {
@@ -139,16 +138,6 @@
EXPECT_TRUE(ScopedRefPtrToSelf::was_destroyed());
}
-TEST(RefCountedUnitTest, ScopedRefPtrToOpaque) {
- scoped_refptr<base::OpaqueRefCounted> p = base::MakeOpaqueRefCounted();
- base::TestOpaqueRefCounted(p);
-
- scoped_refptr<base::OpaqueRefCounted> q;
- q = p;
- base::TestOpaqueRefCounted(p);
- base::TestOpaqueRefCounted(q);
-}
-
TEST(RefCountedUnitTest, BooleanTesting) {
scoped_refptr<SelfAssign> p;
EXPECT_FALSE(p);
diff --git a/libweave/external/base/memory/scoped_ptr.h b/libweave/external/base/memory/scoped_ptr.h
index 987ccfa..2aa1b32 100644
--- a/libweave/external/base/memory/scoped_ptr.h
+++ b/libweave/external/base/memory/scoped_ptr.h
@@ -120,7 +120,7 @@
// cannot convert to T*.
enum { T_must_be_complete = sizeof(T) };
enum { U_must_be_complete = sizeof(U) };
- COMPILE_ASSERT((base::is_convertible<U*, T*>::value),
+ COMPILE_ASSERT((std::is_convertible<U*, T*>::value),
U_ptr_must_implicitly_convert_to_T_ptr);
}
inline void operator()(T* ptr) const {
@@ -169,8 +169,8 @@
template <typename T> struct IsNotRefCounted {
enum {
- value = !base::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
- !base::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
+ value = !std::is_convertible<T*, base::subtle::RefCountedBase*>::value &&
+ !std::is_convertible<T*, base::subtle::RefCountedThreadSafeBase*>::
value
};
};
@@ -345,7 +345,7 @@
template <typename U, typename V>
scoped_ptr(scoped_ptr<U, V>&& other)
: impl_(&other.impl_) {
- COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+ COMPILE_ASSERT(!std::is_array<U>::value, U_cannot_be_an_array);
}
// operator=. Allows assignment from a scoped_ptr rvalue for a convertible
@@ -360,7 +360,7 @@
// scoped_ptr.
template <typename U, typename V>
scoped_ptr& operator=(scoped_ptr<U, V>&& rhs) {
- COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
+ COMPILE_ASSERT(!std::is_array<U>::value, U_cannot_be_an_array);
impl_.TakeState(&rhs.impl_);
return *this;
}
diff --git a/libweave/external/base/memory/scoped_ptr_unittest.cc b/libweave/external/base/memory/scoped_ptr_unittest.cc
index 766f444..d4ff410 100644
--- a/libweave/external/base/memory/scoped_ptr_unittest.cc
+++ b/libweave/external/base/memory/scoped_ptr_unittest.cc
@@ -6,10 +6,11 @@
#include <sstream>
+#include <gtest/gtest.h>
+
#include "base/basictypes.h"
#include "base/bind.h"
#include "base/callback.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace {
diff --git a/libweave/external/base/memory/weak_ptr.cc b/libweave/external/base/memory/weak_ptr.cc
index d9ce86a..0f91ef3 100644
--- a/libweave/external/base/memory/weak_ptr.cc
+++ b/libweave/external/base/memory/weak_ptr.cc
@@ -8,23 +8,13 @@
namespace internal {
WeakReference::Flag::Flag() : is_valid_(true) {
- // Flags only become bound when checked for validity, or invalidated,
- // so that we can check that later validity/invalidation operations on
- // the same Flag take place on the same sequenced thread.
- sequence_checker_.DetachFromSequence();
}
void WeakReference::Flag::Invalidate() {
- // The flag being invalidated with a single ref implies that there are no
- // weak pointers in existence. Allow deletion on other thread in this case.
- DCHECK(sequence_checker_.CalledOnValidSequencedThread() || HasOneRef())
- << "WeakPtrs must be invalidated on the same sequenced thread.";
is_valid_ = false;
}
bool WeakReference::Flag::IsValid() const {
- DCHECK(sequence_checker_.CalledOnValidSequencedThread())
- << "WeakPtrs must be checked on the same sequenced thread.";
return is_valid_;
}
diff --git a/libweave/external/base/memory/weak_ptr.h b/libweave/external/base/memory/weak_ptr.h
index 8a43392..4c1fd4a 100644
--- a/libweave/external/base/memory/weak_ptr.h
+++ b/libweave/external/base/memory/weak_ptr.h
@@ -68,8 +68,6 @@
#include "base/base_export.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
-#include "base/sequence_checker.h"
-#include "base/template_util.h"
namespace base {
@@ -96,7 +94,6 @@
~Flag();
- SequenceChecker sequence_checker_;
bool is_valid_;
};
@@ -153,8 +150,8 @@
// function that makes calling this easier.
template<typename Derived>
static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
- typedef
- is_convertible<Derived, internal::SupportsWeakPtrBase&> convertible;
+ typedef std::is_convertible<Derived*, internal::SupportsWeakPtrBase*>
+ convertible;
COMPILE_ASSERT(convertible::value,
AsWeakPtr_argument_inherits_from_SupportsWeakPtr);
return AsWeakPtrImpl<Derived>(t, *t);
diff --git a/libweave/external/base/memory/weak_ptr_unittest.cc b/libweave/external/base/memory/weak_ptr_unittest.cc
index 20e5c7b..8d4057c 100644
--- a/libweave/external/base/memory/weak_ptr_unittest.cc
+++ b/libweave/external/base/memory/weak_ptr_unittest.cc
@@ -6,38 +6,15 @@
#include <string>
+#include <gtest/gtest.h>
+
#include "base/bind.h"
-#include "base/debug/leak_annotations.h"
#include "base/location.h"
#include "base/memory/scoped_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
-template <class T>
-class OffThreadObjectCreator {
- public:
- static T* NewObject() {
- T* result;
- {
- Thread creator_thread("creator_thread");
- creator_thread.Start();
- creator_thread.task_runner()->PostTask(
- FROM_HERE, base::Bind(OffThreadObjectCreator::CreateObject, &result));
- }
- DCHECK(result); // We synchronized on thread destruction above.
- return result;
- }
- private:
- static void CreateObject(T** result) {
- *result = new T;
- }
-};
-
struct Base {
std::string member;
};
@@ -56,125 +33,6 @@
WeakPtrFactory<Target> factory;
};
-// Helper class to create and destroy weak pointer copies
-// and delete objects on a background thread.
-class BackgroundThread : public Thread {
- public:
- BackgroundThread() : Thread("owner_thread") {}
-
- ~BackgroundThread() override { Stop(); }
-
- void CreateArrowFromTarget(Arrow** arrow, Target* target) {
- WaitableEvent completion(true, false);
- task_runner()->PostTask(
- FROM_HERE, base::Bind(&BackgroundThread::DoCreateArrowFromTarget, arrow,
- target, &completion));
- completion.Wait();
- }
-
- void CreateArrowFromArrow(Arrow** arrow, const Arrow* other) {
- WaitableEvent completion(true, false);
- task_runner()->PostTask(
- FROM_HERE, base::Bind(&BackgroundThread::DoCreateArrowFromArrow, arrow,
- other, &completion));
- completion.Wait();
- }
-
- void DeleteTarget(Target* object) {
- WaitableEvent completion(true, false);
- task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&BackgroundThread::DoDeleteTarget, object, &completion));
- completion.Wait();
- }
-
- void CopyAndAssignArrow(Arrow* object) {
- WaitableEvent completion(true, false);
- task_runner()->PostTask(
- FROM_HERE, base::Bind(&BackgroundThread::DoCopyAndAssignArrow, object,
- &completion));
- completion.Wait();
- }
-
- void CopyAndAssignArrowBase(Arrow* object) {
- WaitableEvent completion(true, false);
- task_runner()->PostTask(
- FROM_HERE, base::Bind(&BackgroundThread::DoCopyAndAssignArrowBase,
- object, &completion));
- completion.Wait();
- }
-
- void DeleteArrow(Arrow* object) {
- WaitableEvent completion(true, false);
- task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&BackgroundThread::DoDeleteArrow, object, &completion));
- completion.Wait();
- }
-
- Target* DeRef(const Arrow* arrow) {
- WaitableEvent completion(true, false);
- Target* result = NULL;
- task_runner()->PostTask(FROM_HERE, base::Bind(&BackgroundThread::DoDeRef,
- arrow, &result, &completion));
- completion.Wait();
- return result;
- }
-
- protected:
- static void DoCreateArrowFromArrow(Arrow** arrow,
- const Arrow* other,
- WaitableEvent* completion) {
- *arrow = new Arrow;
- **arrow = *other;
- completion->Signal();
- }
-
- static void DoCreateArrowFromTarget(Arrow** arrow,
- Target* target,
- WaitableEvent* completion) {
- *arrow = new Arrow;
- (*arrow)->target = target->AsWeakPtr();
- completion->Signal();
- }
-
- static void DoDeRef(const Arrow* arrow,
- Target** result,
- WaitableEvent* completion) {
- *result = arrow->target.get();
- completion->Signal();
- }
-
- static void DoDeleteTarget(Target* object, WaitableEvent* completion) {
- delete object;
- completion->Signal();
- }
-
- static void DoCopyAndAssignArrow(Arrow* object, WaitableEvent* completion) {
- // Copy constructor.
- Arrow a = *object;
- // Assignment operator.
- *object = a;
- completion->Signal();
- }
-
- static void DoCopyAndAssignArrowBase(
- Arrow* object,
- WaitableEvent* completion) {
- // Copy constructor.
- WeakPtr<TargetBase> b = object->target;
- // Assignment operator.
- WeakPtr<TargetBase> c;
- c = object->target;
- completion->Signal();
- }
-
- static void DoDeleteArrow(Arrow* object, WaitableEvent* completion) {
- delete object;
- completion->Signal();
- }
-};
-
} // namespace
TEST(WeakPtrFactoryTest, Basic) {
@@ -292,320 +150,4 @@
EXPECT_FALSE(factory.HasWeakPtrs());
}
-TEST(WeakPtrTest, ObjectAndWeakPtrOnDifferentThreads) {
- // Test that it is OK to create an object that supports WeakPtr on one thread,
- // but use it on another. This tests that we do not trip runtime checks that
- // ensure that a WeakPtr is not used by multiple threads.
- scoped_ptr<Target> target(OffThreadObjectCreator<Target>::NewObject());
- WeakPtr<Target> weak_ptr = target->AsWeakPtr();
- EXPECT_EQ(target.get(), weak_ptr.get());
-}
-
-TEST(WeakPtrTest, WeakPtrInitiateAndUseOnDifferentThreads) {
- // Test that it is OK to create an object that has a WeakPtr member on one
- // thread, but use it on another. This tests that we do not trip runtime
- // checks that ensure that a WeakPtr is not used by multiple threads.
- scoped_ptr<Arrow> arrow(OffThreadObjectCreator<Arrow>::NewObject());
- Target target;
- arrow->target = target.AsWeakPtr();
- EXPECT_EQ(&target, arrow->target.get());
-}
-
-TEST(WeakPtrTest, MoveOwnershipImplicitly) {
- // Move object ownership to another thread by releasing all weak pointers
- // on the original thread first, and then establish WeakPtr on a different
- // thread.
- BackgroundThread background;
- background.Start();
-
- Target* target = new Target();
- {
- WeakPtr<Target> weak_ptr = target->AsWeakPtr();
- // Main thread deletes the WeakPtr, then the thread ownership of the
- // object can be implicitly moved.
- }
- Arrow* arrow;
-
- // Background thread creates WeakPtr(and implicitly owns the object).
- background.CreateArrowFromTarget(&arrow, target);
- EXPECT_EQ(background.DeRef(arrow), target);
-
- {
- // Main thread creates another WeakPtr, but this does not trigger implicitly
- // thread ownership move.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
-
- // The new WeakPtr is owned by background thread.
- EXPECT_EQ(target, background.DeRef(&arrow));
- }
-
- // Target can only be deleted on background thread.
- background.DeleteTarget(target);
- background.DeleteArrow(arrow);
-}
-
-TEST(WeakPtrTest, MoveOwnershipOfUnreferencedObject) {
- BackgroundThread background;
- background.Start();
-
- Arrow* arrow;
- {
- Target target;
- // Background thread creates WeakPtr.
- background.CreateArrowFromTarget(&arrow, &target);
-
- // Bind to background thread.
- EXPECT_EQ(&target, background.DeRef(arrow));
-
- // Release the only WeakPtr.
- arrow->target.reset();
-
- // Now we should be able to create a new reference from this thread.
- arrow->target = target.AsWeakPtr();
-
- // Re-bind to main thread.
- EXPECT_EQ(&target, arrow->target.get());
-
- // And the main thread can now delete the target.
- }
-
- delete arrow;
-}
-
-TEST(WeakPtrTest, MoveOwnershipAfterInvalidate) {
- BackgroundThread background;
- background.Start();
-
- Arrow arrow;
- scoped_ptr<TargetWithFactory> target(new TargetWithFactory);
-
- // Bind to main thread.
- arrow.target = target->factory.GetWeakPtr();
- EXPECT_EQ(target.get(), arrow.target.get());
-
- target->factory.InvalidateWeakPtrs();
- EXPECT_EQ(NULL, arrow.target.get());
-
- arrow.target = target->factory.GetWeakPtr();
- // Re-bind to background thread.
- EXPECT_EQ(target.get(), background.DeRef(&arrow));
-
- // And the background thread can now delete the target.
- background.DeleteTarget(target.release());
-}
-
-TEST(WeakPtrTest, MainThreadRefOutlivesBackgroundThreadRef) {
- // Originating thread has a WeakPtr that outlives others.
- // - Main thread creates a WeakPtr
- // - Background thread creates a WeakPtr copy from the one in main thread
- // - Destruct the WeakPtr on background thread
- // - Destruct the WeakPtr on main thread
- BackgroundThread background;
- background.Start();
-
- Target target;
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
-
- Arrow* arrow_copy;
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
- EXPECT_EQ(arrow_copy->target.get(), &target);
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrTest, BackgroundThreadRefOutlivesMainThreadRef) {
- // Originating thread drops all references before another thread.
- // - Main thread creates a WeakPtr and passes copy to background thread
- // - Destruct the pointer on main thread
- // - Destruct the pointer on background thread
- BackgroundThread background;
- background.Start();
-
- Target target;
- Arrow* arrow_copy;
- {
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
- }
- EXPECT_EQ(arrow_copy->target.get(), &target);
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrTest, OwnerThreadDeletesObject) {
- // Originating thread invalidates WeakPtrs while its held by other thread.
- // - Main thread creates WeakPtr and passes Copy to background thread
- // - Object gets destroyed on main thread
- // (invalidates WeakPtr on background thread)
- // - WeakPtr gets destroyed on Thread B
- BackgroundThread background;
- background.Start();
- Arrow* arrow_copy;
- {
- Target target;
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
- }
- EXPECT_EQ(NULL, arrow_copy->target.get());
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrTest, NonOwnerThreadCanCopyAndAssignWeakPtr) {
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow *arrow = new Arrow();
- arrow->target = target.AsWeakPtr();
-
- // Background can copy and assign arrow (as well as the WeakPtr inside).
- BackgroundThread background;
- background.Start();
- background.CopyAndAssignArrow(arrow);
- background.DeleteArrow(arrow);
-}
-
-TEST(WeakPtrTest, NonOwnerThreadCanCopyAndAssignWeakPtrBase) {
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow *arrow = new Arrow();
- arrow->target = target.AsWeakPtr();
-
- // Background can copy and assign arrow's WeakPtr to a base class WeakPtr.
- BackgroundThread background;
- background.Start();
- background.CopyAndAssignArrowBase(arrow);
- background.DeleteArrow(arrow);
-}
-
-TEST(WeakPtrTest, NonOwnerThreadCanDeleteWeakPtr) {
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow* arrow = new Arrow();
- arrow->target = target.AsWeakPtr();
-
- // Background can delete arrow (as well as the WeakPtr inside).
- BackgroundThread background;
- background.Start();
- background.DeleteArrow(arrow);
-}
-
-#if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && GTEST_HAS_DEATH_TEST
-
-TEST(WeakPtrDeathTest, WeakPtrCopyDoesNotChangeThreadBinding) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- BackgroundThread background;
- background.Start();
-
- // Main thread creates a Target object.
- Target target;
- // Main thread creates an arrow referencing the Target.
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
-
- // Background copies the WeakPtr.
- Arrow* arrow_copy;
- background.CreateArrowFromArrow(&arrow_copy, &arrow);
-
- // The copy is still bound to main thread so I can deref.
- EXPECT_EQ(arrow.target.get(), arrow_copy->target.get());
-
- // Although background thread created the copy, it can not deref the copied
- // WeakPtr.
- ASSERT_DEATH(background.DeRef(arrow_copy), "");
-
- background.DeleteArrow(arrow_copy);
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadDereferencesWeakPtrAfterReference) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- // Main thread creates a Target object.
- Target target;
-
- // Main thread creates an arrow referencing the Target (so target's
- // thread ownership can not be implicitly moved).
- Arrow arrow;
- arrow.target = target.AsWeakPtr();
- arrow.target.get();
-
- // Background thread tries to deref target, which violates thread ownership.
- BackgroundThread background;
- background.Start();
- ASSERT_DEATH(background.DeRef(&arrow), "");
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadDeletesWeakPtrAfterReference) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- scoped_ptr<Target> target(new Target());
-
- // Main thread creates an arrow referencing the Target.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
-
- // Background thread tries to deref target, binding it to the thread.
- BackgroundThread background;
- background.Start();
- background.DeRef(&arrow);
-
- // Main thread deletes Target, violating thread binding.
- ASSERT_DEATH(target.reset(), "");
-
- // |target.reset()| died so |target| still holds the object, so we
- // must pass it to the background thread to teardown.
- background.DeleteTarget(target.release());
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadDeletesObjectAfterReference) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- scoped_ptr<Target> target(new Target());
-
- // Main thread creates an arrow referencing the Target, and references it, so
- // that it becomes bound to the thread.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
- arrow.target.get();
-
- // Background thread tries to delete target, volating thread binding.
- BackgroundThread background;
- background.Start();
- ASSERT_DEATH(background.DeleteTarget(target.release()), "");
-}
-
-TEST(WeakPtrDeathTest, NonOwnerThreadReferencesObjectAfterDeletion) {
- // The default style "fast" does not support multi-threaded tests
- // (introduces deadlock on Linux).
- ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-
- scoped_ptr<Target> target(new Target());
-
- // Main thread creates an arrow referencing the Target.
- Arrow arrow;
- arrow.target = target->AsWeakPtr();
-
- // Background thread tries to delete target, binding the object to the thread.
- BackgroundThread background;
- background.Start();
- background.DeleteTarget(target.release());
-
- // Main thread attempts to dereference the target, violating thread binding.
- ASSERT_DEATH(arrow.target.get(), "");
-}
-
-#endif
-
} // namespace base
diff --git a/libweave/external/base/move_unittest.cc b/libweave/external/base/move_unittest.cc
index 1f4ce84..bebcfd8 100644
--- a/libweave/external/base/move_unittest.cc
+++ b/libweave/external/base/move_unittest.cc
@@ -4,7 +4,7 @@
#include "base/move.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include <gtest/gtest.h>
namespace {
diff --git a/libweave/external/base/numerics/safe_conversions_impl.h b/libweave/external/base/numerics/safe_conversions_impl.h
index 4157067..d07221e 100644
--- a/libweave/external/base/numerics/safe_conversions_impl.h
+++ b/libweave/external/base/numerics/safe_conversions_impl.h
@@ -7,8 +7,6 @@
#include <limits>
-#include "base/template_util.h"
-
namespace base {
namespace internal {
diff --git a/libweave/external/base/numerics/safe_math.h b/libweave/external/base/numerics/safe_math.h
index 1fab032..a596d4b 100644
--- a/libweave/external/base/numerics/safe_math.h
+++ b/libweave/external/base/numerics/safe_math.h
@@ -173,15 +173,15 @@
template <typename Src>
static CheckedNumeric<T> cast(
Src u,
- typename enable_if<std::numeric_limits<Src>::is_specialized, int>::type =
- 0) {
+ typename std::enable_if<std::numeric_limits<Src>::is_specialized,
+ int>::type = 0) {
return u;
}
template <typename Src>
static CheckedNumeric<T> cast(
const CheckedNumeric<Src>& u,
- typename enable_if<!is_same<Src, T>::value, int>::type = 0) {
+ typename std::enable_if<!std::is_same<Src, T>::value, int>::type = 0) {
return u;
}
diff --git a/libweave/external/base/numerics/safe_math_impl.h b/libweave/external/base/numerics/safe_math_impl.h
index 08f2e88..0ae1dfe 100644
--- a/libweave/external/base/numerics/safe_math_impl.h
+++ b/libweave/external/base/numerics/safe_math_impl.h
@@ -12,7 +12,6 @@
#include <limits>
#include "base/numerics/safe_conversions.h"
-#include "base/template_util.h"
namespace base {
namespace internal {
@@ -63,21 +62,21 @@
template <typename Integer>
struct UnsignedIntegerForSize {
- typedef typename enable_if<
+ typedef typename std::enable_if<
std::numeric_limits<Integer>::is_integer,
typename IntegerForSizeAndSign<sizeof(Integer), false>::type>::type type;
};
template <typename Integer>
struct SignedIntegerForSize {
- typedef typename enable_if<
+ typedef typename std::enable_if<
std::numeric_limits<Integer>::is_integer,
typename IntegerForSizeAndSign<sizeof(Integer), true>::type>::type type;
};
template <typename Integer>
struct TwiceWiderInteger {
- typedef typename enable_if<
+ typedef typename std::enable_if<
std::numeric_limits<Integer>::is_integer,
typename IntegerForSizeAndSign<
sizeof(Integer) * 2,
@@ -86,7 +85,7 @@
template <typename Integer>
struct PositionOfSignBit {
- static const typename enable_if<std::numeric_limits<Integer>::is_integer,
+ static const typename std::enable_if<std::numeric_limits<Integer>::is_integer,
size_t>::type value = 8 * sizeof(Integer) - 1;
};
@@ -110,7 +109,7 @@
// way to coalesce things into the CheckedNumericState specializations below.
template <typename T>
-typename enable_if<std::numeric_limits<T>::is_integer, T>::type
+typename std::enable_if<std::numeric_limits<T>::is_integer, T>::type
CheckedAdd(T x, T y, RangeConstraint* validity) {
// Since the value of x+y is undefined if we have a signed type, we compute
// it using the unsigned type of the same size.
@@ -133,7 +132,7 @@
}
template <typename T>
-typename enable_if<std::numeric_limits<T>::is_integer, T>::type
+typename std::enable_if<std::numeric_limits<T>::is_integer, T>::type
CheckedSub(T x, T y, RangeConstraint* validity) {
// Since the value of x+y is undefined if we have a signed type, we compute
// it using the unsigned type of the same size.
@@ -160,7 +159,7 @@
// slow case we need to manually check that the result won't be truncated by
// checking with division against the appropriate bound.
template <typename T>
-typename enable_if<
+typename std::enable_if<
std::numeric_limits<T>::is_integer && sizeof(T) * 2 <= sizeof(uintmax_t),
T>::type
CheckedMul(T x, T y, RangeConstraint* validity) {
@@ -172,9 +171,10 @@
}
template <typename T>
-typename enable_if<std::numeric_limits<T>::is_integer&& std::numeric_limits<
- T>::is_signed&&(sizeof(T) * 2 > sizeof(uintmax_t)),
- T>::type
+typename std::enable_if<std::numeric_limits<T>::is_integer &&
+ std::numeric_limits<T>::is_signed &&
+ (sizeof(T) * 2 > sizeof(uintmax_t)),
+ T>::type
CheckedMul(T x, T y, RangeConstraint* validity) {
// If either side is zero then the result will be zero.
if (!x || !y) {
@@ -201,7 +201,7 @@
}
template <typename T>
-typename enable_if<std::numeric_limits<T>::is_integer &&
+typename std::enable_if<std::numeric_limits<T>::is_integer &&
!std::numeric_limits<T>::is_signed &&
(sizeof(T) * 2 > sizeof(uintmax_t)),
T>::type
@@ -214,11 +214,11 @@
// Division just requires a check for an invalid negation on signed min/-1.
template <typename T>
-T CheckedDiv(
- T x,
- T y,
- RangeConstraint* validity,
- typename enable_if<std::numeric_limits<T>::is_integer, int>::type = 0) {
+T CheckedDiv(T x,
+ T y,
+ RangeConstraint* validity,
+ typename std::enable_if<std::numeric_limits<T>::is_integer,
+ int>::type = 0) {
if (std::numeric_limits<T>::is_signed && x == std::numeric_limits<T>::min() &&
y == static_cast<T>(-1)) {
*validity = RANGE_OVERFLOW;
@@ -230,7 +230,7 @@
}
template <typename T>
-typename enable_if<
+typename std::enable_if<
std::numeric_limits<T>::is_integer&& std::numeric_limits<T>::is_signed,
T>::type
CheckedMod(T x, T y, RangeConstraint* validity) {
@@ -239,7 +239,7 @@
}
template <typename T>
-typename enable_if<
+typename std::enable_if<
std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
T>::type
CheckedMod(T x, T y, RangeConstraint* validity) {
@@ -248,7 +248,7 @@
}
template <typename T>
-typename enable_if<
+typename std::enable_if<
std::numeric_limits<T>::is_integer&& std::numeric_limits<T>::is_signed,
T>::type
CheckedNeg(T value, RangeConstraint* validity) {
@@ -259,7 +259,7 @@
}
template <typename T>
-typename enable_if<
+typename std::enable_if<
std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
T>::type
CheckedNeg(T value, RangeConstraint* validity) {
@@ -270,7 +270,7 @@
}
template <typename T>
-typename enable_if<
+typename std::enable_if<
std::numeric_limits<T>::is_integer&& std::numeric_limits<T>::is_signed,
T>::type
CheckedAbs(T value, RangeConstraint* validity) {
@@ -280,7 +280,7 @@
}
template <typename T>
-typename enable_if<
+typename std::enable_if<
std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
T>::type
CheckedAbs(T value, RangeConstraint* validity) {
@@ -293,7 +293,7 @@
// negation operation is ever called.
#define BASE_FLOAT_ARITHMETIC_STUBS(NAME) \
template <typename T> \
- typename enable_if<std::numeric_limits<T>::is_iec559, T>::type \
+ typename std::enable_if<std::numeric_limits<T>::is_iec559, T>::type \
Checked##NAME(T, T, RangeConstraint*) { \
NOTREACHED(); \
return 0; \
@@ -308,14 +308,14 @@
#undef BASE_FLOAT_ARITHMETIC_STUBS
template <typename T>
-typename enable_if<std::numeric_limits<T>::is_iec559, T>::type CheckedNeg(
+typename std::enable_if<std::numeric_limits<T>::is_iec559, T>::type CheckedNeg(
T value,
RangeConstraint*) {
return -value;
}
template <typename T>
-typename enable_if<std::numeric_limits<T>::is_iec559, T>::type CheckedAbs(
+typename std::enable_if<std::numeric_limits<T>::is_iec559, T>::type CheckedAbs(
T value,
RangeConstraint*) {
return std::abs(value);
@@ -375,8 +375,8 @@
template <typename Src>
explicit CheckedNumericState(
Src value,
- typename enable_if<std::numeric_limits<Src>::is_specialized, int>::type =
- 0)
+ typename std::enable_if<std::numeric_limits<Src>::is_specialized,
+ int>::type = 0)
: value_(static_cast<T>(value)),
validity_(DstRangeRelationToSrcRange<T>(value)) {}
@@ -400,7 +400,8 @@
CheckedNumericState(
Src value,
RangeConstraint validity,
- typename enable_if<std::numeric_limits<Src>::is_integer, int>::type = 0) {
+ typename std::enable_if<std::numeric_limits<Src>::is_integer, int>::type =
+ 0) {
switch (DstRangeRelationToSrcRange<T>(value)) {
case RANGE_VALID:
value_ = static_cast<T>(value);
@@ -426,8 +427,8 @@
template <typename Src>
explicit CheckedNumericState(
Src value,
- typename enable_if<std::numeric_limits<Src>::is_specialized, int>::type =
- 0)
+ typename std::enable_if<std::numeric_limits<Src>::is_specialized,
+ int>::type = 0)
: value_(static_cast<T>(value)) {}
// Copy constructor.
diff --git a/libweave/external/base/numerics/safe_numerics_unittest.cc b/libweave/external/base/numerics/safe_numerics_unittest.cc
index 6f9a966..96b579a 100644
--- a/libweave/external/base/numerics/safe_numerics_unittest.cc
+++ b/libweave/external/base/numerics/safe_numerics_unittest.cc
@@ -9,11 +9,12 @@
#include <limits>
+#include <gtest/gtest.h>
+
#include "base/compiler_specific.h"
#include "base/numerics/safe_conversions.h"
#include "base/numerics/safe_math.h"
#include "base/template_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
using std::numeric_limits;
using base::CheckedNumeric;
@@ -27,7 +28,7 @@
using base::internal::RANGE_INVALID;
using base::internal::RANGE_OVERFLOW;
using base::internal::RANGE_UNDERFLOW;
-using base::enable_if;
+using std::enable_if;
// These tests deliberately cause arithmetic overflows. If the compiler is
// aggressive enough, it can const fold these overflows. Disable warnings about
diff --git a/libweave/external/base/observer_list.h b/libweave/external/base/observer_list.h
index a454430..3baf910 100644
--- a/libweave/external/base/observer_list.h
+++ b/libweave/external/base/observer_list.h
@@ -59,9 +59,6 @@
namespace base {
-template <typename ObserverType>
-class ObserverListThreadSafe;
-
template <class ObserverType>
class ObserverListBase
: public SupportsWeakPtr<ObserverListBase<ObserverType>> {
@@ -113,8 +110,6 @@
void Compact();
private:
- friend class ObserverListThreadSafe<ObserverType>;
-
typedef std::vector<ObserverType*> ListType;
ListType observers_;
diff --git a/libweave/external/base/observer_list_unittest.cc b/libweave/external/base/observer_list_unittest.cc
index 2e51e45..8af999a 100644
--- a/libweave/external/base/observer_list_unittest.cc
+++ b/libweave/external/base/observer_list_unittest.cc
@@ -3,17 +3,14 @@
// found in the LICENSE file.
#include "base/observer_list.h"
-#include "base/observer_list_threadsafe.h"
#include <vector>
+#include <gtest/gtest.h>
+
#include "base/compiler_specific.h"
#include "base/location.h"
#include "base/memory/weak_ptr.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/platform_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
@@ -49,20 +46,6 @@
Foo* doomed_;
};
-class ThreadSafeDisrupter : public Foo {
- public:
- ThreadSafeDisrupter(ObserverListThreadSafe<Foo>* list, Foo* doomed)
- : list_(list),
- doomed_(doomed) {
- }
- ~ThreadSafeDisrupter() override {}
- void Observe(int x) override { list_->RemoveObserver(doomed_); }
-
- private:
- ObserverListThreadSafe<Foo>* list_;
- Foo* doomed_;
-};
-
template <typename ObserverListType>
class AddInObserve : public Foo {
public:
@@ -85,97 +68,6 @@
};
-static const int kThreadRunTime = 2000; // ms to run the multi-threaded test.
-
-// A thread for use in the ThreadSafeObserver test
-// which will add and remove itself from the notification
-// list repeatedly.
-class AddRemoveThread : public PlatformThread::Delegate,
- public Foo {
- public:
- AddRemoveThread(ObserverListThreadSafe<Foo>* list, bool notify)
- : list_(list),
- loop_(nullptr),
- in_list_(false),
- start_(Time::Now()),
- count_observes_(0),
- count_addtask_(0),
- do_notifies_(notify),
- weak_factory_(this) {
- }
-
- ~AddRemoveThread() override {}
-
- void ThreadMain() override {
- loop_ = new MessageLoop(); // Fire up a message loop.
- loop_->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
- loop_->Run();
- //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " <<
- // count_observes_ << ", " << count_addtask_;
- delete loop_;
- loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef);
- delete this;
- }
-
- // This task just keeps posting to itself in an attempt
- // to race with the notifier.
- void AddTask() {
- count_addtask_++;
-
- if ((Time::Now() - start_).InMilliseconds() > kThreadRunTime) {
- VLOG(1) << "DONE!";
- return;
- }
-
- if (!in_list_) {
- list_->AddObserver(this);
- in_list_ = true;
- }
-
- if (do_notifies_) {
- list_->Notify(FROM_HERE, &Foo::Observe, 10);
- }
-
- loop_->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
- }
-
- void Quit() {
- loop_->task_runner()->PostTask(FROM_HERE,
- MessageLoop::QuitWhenIdleClosure());
- }
-
- void Observe(int x) override {
- count_observes_++;
-
- // If we're getting called after we removed ourselves from
- // the list, that is very bad!
- DCHECK(in_list_);
-
- // This callback should fire on the appropriate thread
- EXPECT_EQ(loop_, MessageLoop::current());
-
- list_->RemoveObserver(this);
- in_list_ = false;
- }
-
- private:
- ObserverListThreadSafe<Foo>* list_;
- MessageLoop* loop_;
- bool in_list_; // Are we currently registered for notifications.
- // in_list_ is only used on |this| thread.
- Time start_; // The time we started the test.
-
- int count_observes_; // Number of times we observed.
- int count_addtask_; // Number of times thread AddTask was called
- bool do_notifies_; // Whether these threads should do notifications.
-
- base::WeakPtrFactory<AddRemoveThread> weak_factory_;
-};
-
TEST(ObserverListTest, BasicTest) {
ObserverList<Foo> observer_list;
Adder a(1), b(-1), c(1), d(-1), e(-1);
@@ -205,230 +97,6 @@
EXPECT_EQ(0, e.total);
}
-TEST(ObserverListThreadSafeTest, BasicTest) {
- MessageLoop loop;
-
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
- Adder a(1);
- Adder b(-1);
- Adder c(1);
- Adder d(-1);
- ThreadSafeDisrupter evil(observer_list.get(), &c);
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- observer_list->AddObserver(&evil);
- observer_list->AddObserver(&c);
- observer_list->AddObserver(&d);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(-20, b.total);
- EXPECT_EQ(0, c.total);
- EXPECT_EQ(-10, d.total);
-}
-
-TEST(ObserverListThreadSafeTest, RemoveObserver) {
- MessageLoop loop;
-
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
- Adder a(1), b(1);
-
- // A workaround for the compiler bug. See http://crbug.com/121960.
- EXPECT_NE(&a, &b);
-
- // Should do nothing.
- observer_list->RemoveObserver(&a);
- observer_list->RemoveObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(0, a.total);
- EXPECT_EQ(0, b.total);
-
- observer_list->AddObserver(&a);
-
- // Should also do nothing.
- observer_list->RemoveObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(10, a.total);
- EXPECT_EQ(0, b.total);
-}
-
-TEST(ObserverListThreadSafeTest, WithoutMessageLoop) {
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
-
- Adder a(1), b(1), c(1);
-
- // No MessageLoop, so these should not be added.
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- {
- // Add c when there's a loop.
- MessageLoop loop;
- observer_list->AddObserver(&c);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(0, a.total);
- EXPECT_EQ(0, b.total);
- EXPECT_EQ(10, c.total);
-
- // Now add a when there's a loop.
- observer_list->AddObserver(&a);
-
- // Remove c when there's a loop.
- observer_list->RemoveObserver(&c);
-
- // Notify again.
- observer_list->Notify(FROM_HERE, &Foo::Observe, 20);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(0, b.total);
- EXPECT_EQ(10, c.total);
- }
-
- // Removing should always succeed with or without a loop.
- observer_list->RemoveObserver(&a);
-
- // Notifying should not fail but should also be a no-op.
- MessageLoop loop;
- observer_list->AddObserver(&b);
- observer_list->Notify(FROM_HERE, &Foo::Observe, 30);
- RunLoop().RunUntilIdle();
-
- EXPECT_EQ(20, a.total);
- EXPECT_EQ(30, b.total);
- EXPECT_EQ(10, c.total);
-}
-
-class FooRemover : public Foo {
- public:
- explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {}
- ~FooRemover() override {}
-
- void AddFooToRemove(Foo* foo) {
- foos_.push_back(foo);
- }
-
- void Observe(int x) override {
- std::vector<Foo*> tmp;
- tmp.swap(foos_);
- for (std::vector<Foo*>::iterator it = tmp.begin();
- it != tmp.end(); ++it) {
- list_->RemoveObserver(*it);
- }
- }
-
- private:
- const scoped_refptr<ObserverListThreadSafe<Foo> > list_;
- std::vector<Foo*> foos_;
-};
-
-TEST(ObserverListThreadSafeTest, RemoveMultipleObservers) {
- MessageLoop loop;
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
-
- FooRemover a(observer_list.get());
- Adder b(1);
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- a.AddFooToRemove(&a);
- a.AddFooToRemove(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
- RunLoop().RunUntilIdle();
-}
-
-// A test driver for a multi-threaded notification loop. Runs a number
-// of observer threads, each of which constantly adds/removes itself
-// from the observer list. Optionally, if cross_thread_notifies is set
-// to true, the observer threads will also trigger notifications to
-// all observers.
-static void ThreadSafeObserverHarness(int num_threads,
- bool cross_thread_notifies) {
- MessageLoop loop;
-
- const int kMaxThreads = 15;
- num_threads = num_threads > kMaxThreads ? kMaxThreads : num_threads;
-
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
- Adder a(1);
- Adder b(-1);
- Adder c(1);
- Adder d(-1);
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- AddRemoveThread* threaded_observer[kMaxThreads];
- base::PlatformThreadHandle threads[kMaxThreads];
- for (int index = 0; index < num_threads; index++) {
- threaded_observer[index] = new AddRemoveThread(observer_list.get(), false);
- EXPECT_TRUE(PlatformThread::Create(0,
- threaded_observer[index], &threads[index]));
- }
-
- Time start = Time::Now();
- while (true) {
- if ((Time::Now() - start).InMilliseconds() > kThreadRunTime)
- break;
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
-
- RunLoop().RunUntilIdle();
- }
-
- for (int index = 0; index < num_threads; index++) {
- threaded_observer[index]->Quit();
- PlatformThread::Join(threads[index]);
- }
-}
-
-TEST(ObserverListThreadSafeTest, CrossThreadObserver) {
- // Use 7 observer threads. Notifications only come from
- // the main thread.
- ThreadSafeObserverHarness(7, false);
-}
-
-TEST(ObserverListThreadSafeTest, CrossThreadNotifications) {
- // Use 3 observer threads. Notifications will fire from
- // the main thread and all 3 observer threads.
- ThreadSafeObserverHarness(3, true);
-}
-
-TEST(ObserverListThreadSafeTest, OutlivesMessageLoop) {
- MessageLoop* loop = new MessageLoop;
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>);
-
- Adder a(1);
- observer_list->AddObserver(&a);
- delete loop;
- // Test passes if we don't crash here.
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
-}
-
TEST(ObserverListTest, Existing) {
ObserverList<Foo> observer_list(ObserverList<Foo>::NOTIFY_EXISTING_ONLY);
Adder a(1);
@@ -449,31 +117,6 @@
EXPECT_EQ(1, b.adder.total);
}
-// Same as above, but for ObserverListThreadSafe
-TEST(ObserverListThreadSafeTest, Existing) {
- MessageLoop loop;
- scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
- new ObserverListThreadSafe<Foo>(ObserverList<Foo>::NOTIFY_EXISTING_ONLY));
- Adder a(1);
- AddInObserve<ObserverListThreadSafe<Foo> > b(observer_list.get());
-
- observer_list->AddObserver(&a);
- observer_list->AddObserver(&b);
-
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
- RunLoop().RunUntilIdle();
-
- EXPECT_TRUE(b.added);
- // B's adder should not have been notified because it was added during
- // notification.
- EXPECT_EQ(0, b.adder.total);
-
- // Notify again to make sure b's adder is notified.
- observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
- RunLoop().RunUntilIdle();
- EXPECT_EQ(1, b.adder.total);
-}
-
class AddInClearObserve : public Foo {
public:
explicit AddInClearObserve(ObserverList<Foo>* list)
diff --git a/libweave/external/base/posix/eintr_wrapper.h b/libweave/external/base/posix/eintr_wrapper.h
index 5a5dc75..27de8fc 100644
--- a/libweave/external/base/posix/eintr_wrapper.h
+++ b/libweave/external/base/posix/eintr_wrapper.h
@@ -16,7 +16,7 @@
#ifndef BASE_POSIX_EINTR_WRAPPER_H_
#define BASE_POSIX_EINTR_WRAPPER_H_
-#include "build/build_config.h"
+#include "base/build/build_config.h"
#if defined(OS_POSIX)
diff --git a/libweave/external/base/rand_util.cc b/libweave/external/base/rand_util.cc
index 931eb4e..a55cdbd 100644
--- a/libweave/external/base/rand_util.cc
+++ b/libweave/external/base/rand_util.cc
@@ -64,8 +64,8 @@
std::string RandBytesAsString(size_t length) {
DCHECK_GT(length, 0u);
- std::string result;
- RandBytes(WriteInto(&result, length + 1), length);
+ std::string result(length, ' ');
+ RandBytes(&result[0], length);
return result;
}
diff --git a/libweave/external/base/rand_util.h b/libweave/external/base/rand_util.h
index 6130c12..e3d4888 100644
--- a/libweave/external/base/rand_util.h
+++ b/libweave/external/base/rand_util.h
@@ -50,10 +50,6 @@
// See crypto/ for cryptographically secure random number generation APIs.
BASE_EXPORT std::string RandBytesAsString(size_t length);
-#if defined(OS_POSIX)
-BASE_EXPORT int GetUrandomFD();
-#endif
-
} // namespace base
#endif // BASE_RAND_UTIL_H_
diff --git a/libweave/external/base/rand_util_posix.cc b/libweave/external/base/rand_util_posix.cc
index fe73b96..76a5dab 100644
--- a/libweave/external/base/rand_util_posix.cc
+++ b/libweave/external/base/rand_util_posix.cc
@@ -8,16 +8,11 @@
#include <fcntl.h>
#include <unistd.h>
-#include "base/files/file_util.h"
-#include "base/lazy_instance.h"
#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
namespace {
-// We keep the file descriptor for /dev/urandom around so we don't need to
-// reopen it (which is expensive), and since we may not even be able to reopen
-// it if we are later put in a sandbox. This class wraps the file descriptor so
-// we can use LazyInstance to handle opening it on the first access.
class URandomFd {
public:
URandomFd() : fd_(open("/dev/urandom", O_RDONLY)) {
@@ -32,7 +27,17 @@
const int fd_;
};
-base::LazyInstance<URandomFd>::Leaky g_urandom_fd = LAZY_INSTANCE_INITIALIZER;
+bool ReadFromFD(int fd, char* buffer, size_t bytes) {
+ size_t total_read = 0;
+ while (total_read < bytes) {
+ ssize_t bytes_read =
+ HANDLE_EINTR(read(fd, buffer + total_read, bytes - total_read));
+ if (bytes_read <= 0)
+ break;
+ total_read += bytes_read;
+ }
+ return total_read == bytes;
+}
} // namespace
@@ -46,14 +51,10 @@
}
void RandBytes(void* output, size_t output_length) {
- const int urandom_fd = g_urandom_fd.Pointer()->fd();
+ URandomFd urandom_fd;
const bool success =
- ReadFromFD(urandom_fd, static_cast<char*>(output), output_length);
+ ReadFromFD(urandom_fd.fd(), static_cast<char*>(output), output_length);
CHECK(success);
}
-int GetUrandomFD(void) {
- return g_urandom_fd.Pointer()->fd();
-}
-
} // namespace base
diff --git a/libweave/external/base/rand_util_unittest.cc b/libweave/external/base/rand_util_unittest.cc
index 90690ec..384125b 100644
--- a/libweave/external/base/rand_util_unittest.cc
+++ b/libweave/external/base/rand_util_unittest.cc
@@ -7,10 +7,11 @@
#include <algorithm>
#include <limits>
+#include <gtest/gtest.h>
+
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace {
@@ -123,22 +124,3 @@
FAIL() << "Didn't achieve all bit values in maximum number of tries.";
}
-
-// Benchmark test for RandBytes(). Disabled since it's intentionally slow and
-// does not test anything that isn't already tested by the existing RandBytes()
-// tests.
-TEST(RandUtilTest, DISABLED_RandBytesPerf) {
- // Benchmark the performance of |kTestIterations| of RandBytes() using a
- // buffer size of |kTestBufferSize|.
- const int kTestIterations = 10;
- const size_t kTestBufferSize = 1 * 1024 * 1024;
-
- scoped_ptr<uint8[]> buffer(new uint8[kTestBufferSize]);
- const base::TimeTicks now = base::TimeTicks::Now();
- for (int i = 0; i < kTestIterations; ++i)
- base::RandBytes(buffer.get(), kTestBufferSize);
- const base::TimeTicks end = base::TimeTicks::Now();
-
- LOG(INFO) << "RandBytes(" << kTestBufferSize << ") took: "
- << (end - now).InMicroseconds() << "µs";
-}
diff --git a/libweave/external/base/scoped_clear_errno_unittest.cc b/libweave/external/base/scoped_clear_errno_unittest.cc
index 8afb33e..1666d7a 100644
--- a/libweave/external/base/scoped_clear_errno_unittest.cc
+++ b/libweave/external/base/scoped_clear_errno_unittest.cc
@@ -4,8 +4,9 @@
#include <errno.h>
+#include <gtest/gtest.h>
+
#include "base/scoped_clear_errno.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
diff --git a/libweave/external/base/strings/string_number_conversions.cc b/libweave/external/base/strings/string_number_conversions.cc
index 642d24e..b5463fb 100644
--- a/libweave/external/base/strings/string_number_conversions.cc
+++ b/libweave/external/base/strings/string_number_conversions.cc
@@ -13,7 +13,6 @@
#include "base/logging.h"
#include "base/scoped_clear_errno.h"
-#include "base/strings/utf_string_conversions.h"
#include "base/third_party/dmg_fp/dmg_fp.h"
namespace base {
@@ -145,13 +144,6 @@
}
};
-template<> class WhitespaceHelper<char16> {
- public:
- static bool Invoke(char16 c) {
- return 0 != iswspace(c);
- }
-};
-
template<typename CHAR> bool LocalIsWhitespace(CHAR c) {
return WhitespaceHelper<CHAR>::Invoke(c);
}
@@ -352,19 +344,6 @@
input.begin(), input.end(), output);
}
-template <typename VALUE, int BASE>
-class StringPiece16ToNumberTraits
- : public BaseIteratorRangeToNumberTraits<StringPiece16::const_iterator,
- VALUE,
- BASE> {
-};
-
-template <typename VALUE>
-bool String16ToIntImpl(const StringPiece16& input, VALUE* output) {
- return IteratorRangeToNumber<StringPiece16ToNumberTraits<VALUE, 10> >::Invoke(
- input.begin(), input.end(), output);
-}
-
} // namespace
std::string IntToString(int value) {
@@ -372,45 +351,23 @@
IntToString(value);
}
-string16 IntToString16(int value) {
- return IntToStringT<string16, int, unsigned int, true>::
- IntToString(value);
-}
-
std::string UintToString(unsigned int value) {
return IntToStringT<std::string, unsigned int, unsigned int, false>::
IntToString(value);
}
-string16 UintToString16(unsigned int value) {
- return IntToStringT<string16, unsigned int, unsigned int, false>::
- IntToString(value);
-}
-
std::string Int64ToString(int64 value) {
return IntToStringT<std::string, int64, uint64, true>::IntToString(value);
}
-string16 Int64ToString16(int64 value) {
- return IntToStringT<string16, int64, uint64, true>::IntToString(value);
-}
-
std::string Uint64ToString(uint64 value) {
return IntToStringT<std::string, uint64, uint64, false>::IntToString(value);
}
-string16 Uint64ToString16(uint64 value) {
- return IntToStringT<string16, uint64, uint64, false>::IntToString(value);
-}
-
std::string SizeTToString(size_t value) {
return IntToStringT<std::string, size_t, size_t, false>::IntToString(value);
}
-string16 SizeTToString16(size_t value) {
- return IntToStringT<string16, size_t, size_t, false>::IntToString(value);
-}
-
std::string DoubleToString(double value) {
// According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
char buffer[32];
@@ -422,42 +379,22 @@
return StringToIntImpl(input, output);
}
-bool StringToInt(const StringPiece16& input, int* output) {
- return String16ToIntImpl(input, output);
-}
-
bool StringToUint(const StringPiece& input, unsigned* output) {
return StringToIntImpl(input, output);
}
-bool StringToUint(const StringPiece16& input, unsigned* output) {
- return String16ToIntImpl(input, output);
-}
-
bool StringToInt64(const StringPiece& input, int64* output) {
return StringToIntImpl(input, output);
}
-bool StringToInt64(const StringPiece16& input, int64* output) {
- return String16ToIntImpl(input, output);
-}
-
bool StringToUint64(const StringPiece& input, uint64* output) {
return StringToIntImpl(input, output);
}
-bool StringToUint64(const StringPiece16& input, uint64* output) {
- return String16ToIntImpl(input, output);
-}
-
bool StringToSizeT(const StringPiece& input, size_t* output) {
return StringToIntImpl(input, output);
}
-bool StringToSizeT(const StringPiece16& input, size_t* output) {
- return String16ToIntImpl(input, output);
-}
-
bool StringToDouble(const std::string& input, double* output) {
// Thread-safe? It is on at least Mac, Linux, and Windows.
ScopedClearErrno clear_errno;
diff --git a/libweave/external/base/strings/string_number_conversions.h b/libweave/external/base/strings/string_number_conversions.h
index 050e627..78059ed 100644
--- a/libweave/external/base/strings/string_number_conversions.h
+++ b/libweave/external/base/strings/string_number_conversions.h
@@ -10,7 +10,6 @@
#include "base/base_export.h"
#include "base/basictypes.h"
-#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
// ----------------------------------------------------------------------------
@@ -30,19 +29,14 @@
// Number -> string conversions ------------------------------------------------
BASE_EXPORT std::string IntToString(int value);
-BASE_EXPORT string16 IntToString16(int value);
BASE_EXPORT std::string UintToString(unsigned value);
-BASE_EXPORT string16 UintToString16(unsigned value);
BASE_EXPORT std::string Int64ToString(int64 value);
-BASE_EXPORT string16 Int64ToString16(int64 value);
BASE_EXPORT std::string Uint64ToString(uint64 value);
-BASE_EXPORT string16 Uint64ToString16(uint64 value);
BASE_EXPORT std::string SizeTToString(size_t value);
-BASE_EXPORT string16 SizeTToString16(size_t value);
// DoubleToString converts the double to a string format that ignores the
// locale. If you want to use locale specific formatting, use ICU.
@@ -65,19 +59,14 @@
// |*output| will be set to 0.
// - Empty string. |*output| will be set to 0.
BASE_EXPORT bool StringToInt(const StringPiece& input, int* output);
-BASE_EXPORT bool StringToInt(const StringPiece16& input, int* output);
BASE_EXPORT bool StringToUint(const StringPiece& input, unsigned* output);
-BASE_EXPORT bool StringToUint(const StringPiece16& input, unsigned* output);
BASE_EXPORT bool StringToInt64(const StringPiece& input, int64* output);
-BASE_EXPORT bool StringToInt64(const StringPiece16& input, int64* output);
BASE_EXPORT bool StringToUint64(const StringPiece& input, uint64* output);
-BASE_EXPORT bool StringToUint64(const StringPiece16& input, uint64* output);
BASE_EXPORT bool StringToSizeT(const StringPiece& input, size_t* output);
-BASE_EXPORT bool StringToSizeT(const StringPiece16& input, size_t* output);
// For floating-point conversions, only conversions of input strings in decimal
// form are defined to work. Behavior with strings representing floating-point
diff --git a/libweave/external/base/strings/string_number_conversions_unittest.cc b/libweave/external/base/strings/string_number_conversions_unittest.cc
index 0bc72f1..80d1471 100644
--- a/libweave/external/base/strings/string_number_conversions_unittest.cc
+++ b/libweave/external/base/strings/string_number_conversions_unittest.cc
@@ -11,10 +11,10 @@
#include <cmath>
#include <limits>
-#include "base/format_macros.h"
+#include <gtest/gtest.h>
+
#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "base/strings/utf_string_conversion_utils.h"
namespace base {
@@ -50,16 +50,12 @@
for (size_t i = 0; i < arraysize(int_tests); ++i) {
const IntToStringTest<int>* test = &int_tests[i];
EXPECT_EQ(IntToString(test->num), test->sexpected);
- EXPECT_EQ(IntToString16(test->num), UTF8ToUTF16(test->sexpected));
EXPECT_EQ(UintToString(test->num), test->uexpected);
- EXPECT_EQ(UintToString16(test->num), UTF8ToUTF16(test->uexpected));
}
for (size_t i = 0; i < arraysize(int64_tests); ++i) {
const IntToStringTest<int64>* test = &int64_tests[i];
EXPECT_EQ(Int64ToString(test->num), test->sexpected);
- EXPECT_EQ(Int64ToString16(test->num), UTF8ToUTF16(test->sexpected));
EXPECT_EQ(Uint64ToString(test->num), test->uexpected);
- EXPECT_EQ(Uint64ToString16(test->num), UTF8ToUTF16(test->uexpected));
}
}
@@ -80,7 +76,7 @@
TEST(StringNumberConversionsTest, SizeTToString) {
size_t size_t_max = std::numeric_limits<size_t>::max();
- std::string size_t_max_string = StringPrintf("%" PRIuS, size_t_max);
+ std::string size_t_max_string = std::to_string(size_t_max);
static const struct {
size_t input;
@@ -137,11 +133,6 @@
int output = 0;
EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToInt(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
}
// One additional test to verify that conversion of numbers in strings with
@@ -152,16 +143,6 @@
int output;
EXPECT_FALSE(StringToInt(input_string, &output));
EXPECT_EQ(6, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToInt(utf16_input, &output));
- EXPECT_EQ(6, output);
-
- output = 0;
- const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
- EXPECT_FALSE(StringToInt(string16(negative_wide_input), &output));
- EXPECT_EQ(0, output);
}
TEST(StringNumberConversionsTest, StringToUint) {
@@ -201,11 +182,6 @@
unsigned output = 0;
EXPECT_EQ(cases[i].success, StringToUint(cases[i].input, &output));
EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToUint(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
}
// One additional test to verify that conversion of numbers in strings with
@@ -216,16 +192,6 @@
unsigned output;
EXPECT_FALSE(StringToUint(input_string, &output));
EXPECT_EQ(6U, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToUint(utf16_input, &output));
- EXPECT_EQ(6U, output);
-
- output = 0;
- const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
- EXPECT_FALSE(StringToUint(string16(negative_wide_input), &output));
- EXPECT_EQ(0U, output);
}
TEST(StringNumberConversionsTest, StringToInt64) {
@@ -271,11 +237,6 @@
int64 output = 0;
EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToInt64(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
}
// One additional test to verify that conversion of numbers in strings with
@@ -286,11 +247,6 @@
int64 output;
EXPECT_FALSE(StringToInt64(input_string, &output));
EXPECT_EQ(6, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToInt64(utf16_input, &output));
- EXPECT_EQ(6, output);
}
TEST(StringNumberConversionsTest, StringToUint64) {
@@ -338,11 +294,6 @@
uint64 output = 0;
EXPECT_EQ(cases[i].success, StringToUint64(cases[i].input, &output));
EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToUint64(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
}
// One additional test to verify that conversion of numbers in strings with
@@ -353,16 +304,11 @@
uint64 output;
EXPECT_FALSE(StringToUint64(input_string, &output));
EXPECT_EQ(6U, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToUint64(utf16_input, &output));
- EXPECT_EQ(6U, output);
}
TEST(StringNumberConversionsTest, StringToSizeT) {
size_t size_t_max = std::numeric_limits<size_t>::max();
- std::string size_t_max_string = StringPrintf("%" PRIuS, size_t_max);
+ std::string size_t_max_string = std::to_string(size_t_max);
static const struct {
std::string input;
@@ -407,11 +353,6 @@
size_t output = 0;
EXPECT_EQ(cases[i].success, StringToSizeT(cases[i].input, &output));
EXPECT_EQ(cases[i].output, output);
-
- string16 utf16_input = UTF8ToUTF16(cases[i].input);
- output = 0;
- EXPECT_EQ(cases[i].success, StringToSizeT(utf16_input, &output));
- EXPECT_EQ(cases[i].output, output);
}
// One additional test to verify that conversion of numbers in strings with
@@ -422,11 +363,6 @@
size_t output;
EXPECT_FALSE(StringToSizeT(input_string, &output));
EXPECT_EQ(6U, output);
-
- string16 utf16_input = UTF8ToUTF16(input_string);
- output = 0;
- EXPECT_FALSE(StringToSizeT(utf16_input, &output));
- EXPECT_EQ(6U, output);
}
TEST(StringNumberConversionsTest, HexStringToInt) {
diff --git a/libweave/external/base/strings/string_piece.cc b/libweave/external/base/strings/string_piece.cc
index 4c7f112..aa0695d 100644
--- a/libweave/external/base/strings/string_piece.cc
+++ b/libweave/external/base/strings/string_piece.cc
@@ -33,7 +33,6 @@
// MSVC doesn't like complex extern templates and DLLs.
#if !defined(COMPILER_MSVC)
template class BasicStringPiece<std::string>;
-template class BasicStringPiece<string16>;
#endif
bool operator==(const StringPiece& x, const StringPiece& y) {
@@ -62,10 +61,6 @@
CopyToStringT(self, target);
}
-void CopyToString(const StringPiece16& self, string16* target) {
- CopyToStringT(self, target);
-}
-
template<typename STR>
void AppendToStringT(const BasicStringPiece<STR>& self, STR* target) {
if (!self.empty())
@@ -76,10 +71,6 @@
AppendToStringT(self, target);
}
-void AppendToString(const StringPiece16& self, string16* target) {
- AppendToStringT(self, target);
-}
-
template<typename STR>
size_t copyT(const BasicStringPiece<STR>& self,
typename STR::value_type* buf,
@@ -94,10 +85,6 @@
return copyT(self, buf, n, pos);
}
-size_t copy(const StringPiece16& self, char16* buf, size_t n, size_t pos) {
- return copyT(self, buf, n, pos);
-}
-
template<typename STR>
size_t findT(const BasicStringPiece<STR>& self,
const BasicStringPiece<STR>& s,
@@ -116,10 +103,6 @@
return findT(self, s, pos);
}
-size_t find(const StringPiece16& self, const StringPiece16& s, size_t pos) {
- return findT(self, s, pos);
-}
-
template<typename STR>
size_t findT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
@@ -137,10 +120,6 @@
return findT(self, c, pos);
}
-size_t find(const StringPiece16& self, char16 c, size_t pos) {
- return findT(self, c, pos);
-}
-
template<typename STR>
size_t rfindT(const BasicStringPiece<STR>& self,
const BasicStringPiece<STR>& s,
@@ -163,10 +142,6 @@
return rfindT(self, s, pos);
}
-size_t rfind(const StringPiece16& self, const StringPiece16& s, size_t pos) {
- return rfindT(self, s, pos);
-}
-
template<typename STR>
size_t rfindT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
@@ -188,10 +163,6 @@
return rfindT(self, c, pos);
}
-size_t rfind(const StringPiece16& self, char16 c, size_t pos) {
- return rfindT(self, c, pos);
-}
-
// 8-bit version using lookup table.
size_t find_first_of(const StringPiece& self,
const StringPiece& s,
@@ -213,17 +184,6 @@
return StringPiece::npos;
}
-// 16-bit brute force version.
-size_t find_first_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos) {
- StringPiece16::const_iterator found =
- std::find_first_of(self.begin() + pos, self.end(), s.begin(), s.end());
- if (found == self.end())
- return StringPiece16::npos;
- return found - self.begin();
-}
-
// 8-bit version using lookup table.
size_t find_first_not_of(const StringPiece& self,
const StringPiece& s,
@@ -248,27 +208,6 @@
return StringPiece::npos;
}
-// 16-bit brute-force version.
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos) {
- if (self.size() == 0)
- return StringPiece16::npos;
-
- for (size_t self_i = pos; self_i < self.size(); ++self_i) {
- bool found = false;
- for (size_t s_i = 0; s_i < s.size(); ++s_i) {
- if (self[self_i] == s[s_i]) {
- found = true;
- break;
- }
- }
- if (!found)
- return self_i;
- }
- return StringPiece16::npos;
-}
-
template<typename STR>
size_t find_first_not_ofT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
@@ -290,12 +229,6 @@
return find_first_not_ofT(self, c, pos);
}
-size_t find_first_not_of(const StringPiece16& self,
- char16 c,
- size_t pos) {
- return find_first_not_ofT(self, c, pos);
-}
-
// 8-bit version using lookup table.
size_t find_last_of(const StringPiece& self, const StringPiece& s, size_t pos) {
if (self.size() == 0 || s.size() == 0)
@@ -316,25 +249,6 @@
return StringPiece::npos;
}
-// 16-bit brute-force version.
-size_t find_last_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos) {
- if (self.size() == 0)
- return StringPiece16::npos;
-
- for (size_t self_i = std::min(pos, self.size() - 1); ;
- --self_i) {
- for (size_t s_i = 0; s_i < s.size(); s_i++) {
- if (self.data()[self_i] == s[s_i])
- return self_i;
- }
- if (self_i == 0)
- break;
- }
- return StringPiece16::npos;
-}
-
// 8-bit version using lookup table.
size_t find_last_not_of(const StringPiece& self,
const StringPiece& s,
@@ -361,29 +275,6 @@
return StringPiece::npos;
}
-// 16-bit brute-force version.
-size_t find_last_not_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos) {
- if (self.size() == 0)
- return StringPiece::npos;
-
- for (size_t self_i = std::min(pos, self.size() - 1); ; --self_i) {
- bool found = false;
- for (size_t s_i = 0; s_i < s.size(); s_i++) {
- if (self.data()[self_i] == s[s_i]) {
- found = true;
- break;
- }
- }
- if (!found)
- return self_i;
- if (self_i == 0)
- break;
- }
- return StringPiece16::npos;
-}
-
template<typename STR>
size_t find_last_not_ofT(const BasicStringPiece<STR>& self,
typename STR::value_type c,
@@ -406,12 +297,6 @@
return find_last_not_ofT(self, c, pos);
}
-size_t find_last_not_of(const StringPiece16& self,
- char16 c,
- size_t pos) {
- return find_last_not_ofT(self, c, pos);
-}
-
template<typename STR>
BasicStringPiece<STR> substrT(const BasicStringPiece<STR>& self,
size_t pos,
@@ -427,11 +312,5 @@
return substrT(self, pos, n);
}
-StringPiece16 substr(const StringPiece16& self,
- size_t pos,
- size_t n) {
- return substrT(self, pos, n);
-}
-
} // namespace internal
} // namespace base
diff --git a/libweave/external/base/strings/string_piece.h b/libweave/external/base/strings/string_piece.h
index a83b7d8..c3ce222 100644
--- a/libweave/external/base/strings/string_piece.h
+++ b/libweave/external/base/strings/string_piece.h
@@ -29,14 +29,11 @@
#include "base/base_export.h"
#include "base/basictypes.h"
-#include "base/containers/hash_tables.h"
-#include "base/strings/string16.h"
namespace base {
template <typename STRING_TYPE> class BasicStringPiece;
typedef BasicStringPiece<std::string> StringPiece;
-typedef BasicStringPiece<string16> StringPiece16;
// internal --------------------------------------------------------------------
@@ -50,88 +47,49 @@
namespace internal {
BASE_EXPORT void CopyToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void CopyToString(const StringPiece16& self, string16* target);
BASE_EXPORT void AppendToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void AppendToString(const StringPiece16& self, string16* target);
BASE_EXPORT size_t copy(const StringPiece& self,
char* buf,
size_t n,
size_t pos);
-BASE_EXPORT size_t copy(const StringPiece16& self,
- char16* buf,
- size_t n,
- size_t pos);
BASE_EXPORT size_t find(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
BASE_EXPORT size_t find(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
- char16 c,
- size_t pos);
BASE_EXPORT size_t rfind(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
BASE_EXPORT size_t rfind(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
- char16 c,
- size_t pos);
BASE_EXPORT size_t find_first_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_first_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
- char16 c,
- size_t pos);
BASE_EXPORT size_t find_last_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
BASE_EXPORT size_t find_last_of(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
- char16 c,
- size_t pos);
BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
- const StringPiece16& s,
- size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
- char16 c,
- size_t pos);
BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
char c,
size_t pos);
@@ -139,9 +97,6 @@
BASE_EXPORT StringPiece substr(const StringPiece& self,
size_t pos,
size_t n);
-BASE_EXPORT StringPiece16 substr(const StringPiece16& self,
- size_t pos,
- size_t n);
} // namespace internal
@@ -352,7 +307,6 @@
// MSVC doesn't like complex extern templates and DLLs.
#if !defined(COMPILER_MSVC)
extern template class BASE_EXPORT BasicStringPiece<std::string>;
-extern template class BASE_EXPORT BasicStringPiece<string16>;
#endif
// StingPiece operators --------------------------------------------------------
@@ -381,72 +335,9 @@
return !(x < y);
}
-// StringPiece16 operators -----------------------------------------------------
-
-inline bool operator==(const StringPiece16& x, const StringPiece16& y) {
- if (x.size() != y.size())
- return false;
-
- return StringPiece16::wordmemcmp(x.data(), y.data(), x.size()) == 0;
-}
-
-inline bool operator!=(const StringPiece16& x, const StringPiece16& y) {
- return !(x == y);
-}
-
-inline bool operator<(const StringPiece16& x, const StringPiece16& y) {
- const int r = StringPiece16::wordmemcmp(
- x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
- return ((r < 0) || ((r == 0) && (x.size() < y.size())));
-}
-
-inline bool operator>(const StringPiece16& x, const StringPiece16& y) {
- return y < x;
-}
-
-inline bool operator<=(const StringPiece16& x, const StringPiece16& y) {
- return !(x > y);
-}
-
-inline bool operator>=(const StringPiece16& x, const StringPiece16& y) {
- return !(x < y);
-}
-
BASE_EXPORT std::ostream& operator<<(std::ostream& o,
const StringPiece& piece);
} // namespace base
-// Hashing ---------------------------------------------------------------------
-
-// We provide appropriate hash functions so StringPiece and StringPiece16 can
-// be used as keys in hash sets and maps.
-
-// This hash function is copied from base/containers/hash_tables.h. We don't
-// use the ones already defined for string and string16 directly because it
-// would require the string constructors to be called, which we don't want.
-#define HASH_STRING_PIECE(StringPieceType, string_piece) \
- std::size_t result = 0; \
- for (StringPieceType::const_iterator i = string_piece.begin(); \
- i != string_piece.end(); ++i) \
- result = (result * 131) + *i; \
- return result; \
-
-namespace BASE_HASH_NAMESPACE {
-
-template<>
-struct hash<base::StringPiece> {
- std::size_t operator()(const base::StringPiece& sp) const {
- HASH_STRING_PIECE(base::StringPiece, sp);
- }
-};
-template<>
-struct hash<base::StringPiece16> {
- std::size_t operator()(const base::StringPiece16& sp16) const {
- HASH_STRING_PIECE(base::StringPiece16, sp16);
- }
-};
-
-} // namespace BASE_HASH_NAMESPACE
-
#endif // BASE_STRINGS_STRING_PIECE_H_
diff --git a/libweave/external/base/strings/string_piece_unittest.cc b/libweave/external/base/strings/string_piece_unittest.cc
index 5336603..2c2b0a6 100644
--- a/libweave/external/base/strings/string_piece_unittest.cc
+++ b/libweave/external/base/strings/string_piece_unittest.cc
@@ -4,10 +4,10 @@
#include <string>
-#include "base/strings/string16.h"
+#include <gtest/gtest.h>
+
#include "base/strings/string_piece.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "base/strings/utf_string_conversion_utils.h"
namespace base {
@@ -22,18 +22,7 @@
}
};
-template <>
-class CommonStringPieceTest<string16> : public ::testing::Test {
- public:
- static const string16 as_string(const char* input) {
- return ASCIIToUTF16(input);
- }
- static const string16 as_string(const std::string& input) {
- return ASCIIToUTF16(input);
- }
-};
-
-typedef ::testing::Types<std::string, string16> SupportedStringTypes;
+typedef ::testing::Types<std::string> SupportedStringTypes;
TYPED_TEST_CASE(CommonStringPieceTest, SupportedStringTypes);
@@ -640,32 +629,6 @@
ASSERT_TRUE(hello.c_str() == BasicStringPiece<TypeParam>(hello));
}
-// string16-specific stuff
-TEST(StringPiece16Test, CheckSTL) {
- // Check some non-ascii characters.
- string16 fifth(ASCIIToUTF16("123"));
- fifth.push_back(0x0000);
- fifth.push_back(0xd8c5);
- fifth.push_back(0xdffe);
- StringPiece16 f(fifth);
-
- ASSERT_EQ(f[3], '\0');
- ASSERT_EQ(f[5], static_cast<char16>(0xdffe));
-
- ASSERT_EQ(f.size(), 6U);
-}
-
-
-
-TEST(StringPiece16Test, CheckConversion) {
- // Make sure that we can convert from UTF8 to UTF16 and back. We use a two
- // byte character (G clef) to test this.
- ASSERT_EQ(
- UTF16ToUTF8(
- StringPiece16(UTF8ToUTF16("\xf0\x9d\x84\x9e")).as_string()),
- "\xf0\x9d\x84\x9e");
-}
-
TYPED_TEST(CommonStringPieceTest, CheckConstructors) {
TypeParam str(TestFixture::as_string("hello world"));
TypeParam empty;
diff --git a/libweave/external/base/strings/string_util.cc b/libweave/external/base/strings/string_util.cc
index 738d32e..4042b39 100644
--- a/libweave/external/base/strings/string_util.cc
+++ b/libweave/external/base/strings/string_util.cc
@@ -4,69 +4,11 @@
#include "base/strings/string_util.h"
-#include <ctype.h>
-#include <errno.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <wchar.h>
-#include <wctype.h>
-
-#include <algorithm>
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/memory/singleton.h"
-#include "base/strings/string_split.h"
#include "base/strings/utf_string_conversion_utils.h"
-#include "base/strings/utf_string_conversions.h"
#include "base/third_party/icu/icu_utf.h"
-#include "build/build_config.h"
-
-// Remove when this entire file is in the base namespace.
-using base::char16;
-using base::string16;
namespace {
-// Force the singleton used by EmptyString[16] to be a unique type. This
-// prevents other code that might accidentally use Singleton<string> from
-// getting our internal one.
-struct EmptyStrings {
- EmptyStrings() {}
- const std::string s;
- const string16 s16;
-
- static EmptyStrings* GetInstance() {
- return Singleton<EmptyStrings>::get();
- }
-};
-
-// Used by ReplaceStringPlaceholders to track the position in the string of
-// replaced parameters.
-struct ReplacementOffset {
- ReplacementOffset(uintptr_t parameter, size_t offset)
- : parameter(parameter),
- offset(offset) {}
-
- // Index of the parameter.
- uintptr_t parameter;
-
- // Starting position in the string.
- size_t offset;
-};
-
-static bool CompareParameter(const ReplacementOffset& elem1,
- const ReplacementOffset& elem2) {
- return elem1.parameter < elem2.parameter;
-}
-
-// Assuming that a pointer is the size of a "machine word", then
-// uintptr_t is an integer type that is also a machine word.
typedef uintptr_t MachineWord;
const uintptr_t kMachineWordAlignmentMask = sizeof(MachineWord) - 1;
@@ -80,74 +22,17 @@
}
template<size_t size, typename CharacterType> struct NonASCIIMask;
-template<> struct NonASCIIMask<4, base::char16> {
- static inline uint32_t value() { return 0xFF80FF80U; }
-};
template<> struct NonASCIIMask<4, char> {
static inline uint32_t value() { return 0x80808080U; }
};
-template<> struct NonASCIIMask<8, base::char16> {
- static inline uint64_t value() { return 0xFF80FF80FF80FF80ULL; }
-};
template<> struct NonASCIIMask<8, char> {
static inline uint64_t value() { return 0x8080808080808080ULL; }
};
-#if defined(WCHAR_T_IS_UTF32)
-template<> struct NonASCIIMask<4, wchar_t> {
- static inline uint32_t value() { return 0xFFFFFF80U; }
-};
-template<> struct NonASCIIMask<8, wchar_t> {
- static inline uint64_t value() { return 0xFFFFFF80FFFFFF80ULL; }
-};
-#endif // WCHAR_T_IS_UTF32
} // namespace
namespace base {
-bool IsWprintfFormatPortable(const wchar_t* format) {
- for (const wchar_t* position = format; *position != '\0'; ++position) {
- if (*position == '%') {
- bool in_specification = true;
- bool modifier_l = false;
- while (in_specification) {
- // Eat up characters until reaching a known specifier.
- if (*++position == '\0') {
- // The format string ended in the middle of a specification. Call
- // it portable because no unportable specifications were found. The
- // string is equally broken on all platforms.
- return true;
- }
-
- if (*position == 'l') {
- // 'l' is the only thing that can save the 's' and 'c' specifiers.
- modifier_l = true;
- } else if (((*position == 's' || *position == 'c') && !modifier_l) ||
- *position == 'S' || *position == 'C' || *position == 'F' ||
- *position == 'D' || *position == 'O' || *position == 'U') {
- // Not portable.
- return false;
- }
-
- if (wcschr(L"diouxXeEfgGaAcspn%", *position)) {
- // Portable, keep scanning the rest of the format string.
- in_specification = false;
- }
- }
- }
- }
-
- return true;
-}
-
-const std::string& EmptyString() {
- return EmptyStrings::GetInstance()->s;
-}
-
-const string16& EmptyString16() {
- return EmptyStrings::GetInstance()->s16;
-}
-
template<typename STR>
bool ReplaceCharsT(const STR& input,
const STR& replace_chars,
@@ -168,13 +53,6 @@
return removed;
}
-bool ReplaceChars(const string16& input,
- const base::StringPiece16& replace_chars,
- const string16& replace_with,
- string16* output) {
- return ReplaceCharsT(input, replace_chars.as_string(), replace_with, output);
-}
-
bool ReplaceChars(const std::string& input,
const base::StringPiece& replace_chars,
const std::string& replace_with,
@@ -182,18 +60,6 @@
return ReplaceCharsT(input, replace_chars.as_string(), replace_with, output);
}
-bool RemoveChars(const string16& input,
- const base::StringPiece16& remove_chars,
- string16* output) {
- return ReplaceChars(input, remove_chars.as_string(), string16(), output);
-}
-
-bool RemoveChars(const std::string& input,
- const base::StringPiece& remove_chars,
- std::string* output) {
- return ReplaceChars(input, remove_chars.as_string(), std::string(), output);
-}
-
template<typename Str>
TrimPositions TrimStringT(const Str& input,
BasicStringPiece<Str> trim_chars,
@@ -230,12 +96,6 @@
((last_good_char == last_char) ? TRIM_NONE : TRIM_TRAILING));
}
-bool TrimString(const string16& input,
- base::StringPiece16 trim_chars,
- string16* output) {
- return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
-}
-
bool TrimString(const std::string& input,
base::StringPiece trim_chars,
std::string* output) {
@@ -253,136 +113,18 @@
return input.substr(begin, end - begin);
}
-StringPiece16 TrimString(StringPiece16 input,
- const base::StringPiece16& trim_chars,
- TrimPositions positions) {
- return TrimStringPieceT(input, trim_chars, positions);
-}
-
StringPiece TrimString(StringPiece input,
const base::StringPiece& trim_chars,
TrimPositions positions) {
return TrimStringPieceT(input, trim_chars, positions);
}
-void TruncateUTF8ToByteSize(const std::string& input,
- const size_t byte_size,
- std::string* output) {
- DCHECK(output);
- if (byte_size > input.length()) {
- *output = input;
- return;
- }
- DCHECK_LE(byte_size, static_cast<uint32>(kint32max));
- // Note: This cast is necessary because CBU8_NEXT uses int32s.
- int32 truncation_length = static_cast<int32>(byte_size);
- int32 char_index = truncation_length - 1;
- const char* data = input.data();
-
- // Using CBU8, we will move backwards from the truncation point
- // to the beginning of the string looking for a valid UTF8
- // character. Once a full UTF8 character is found, we will
- // truncate the string to the end of that character.
- while (char_index >= 0) {
- int32 prev = char_index;
- base_icu::UChar32 code_point = 0;
- CBU8_NEXT(data, char_index, truncation_length, code_point);
- if (!IsValidCharacter(code_point) ||
- !IsValidCodepoint(code_point)) {
- char_index = prev - 1;
- } else {
- break;
- }
- }
-
- if (char_index >= 0 )
- *output = input.substr(0, char_index);
- else
- output->clear();
-}
-
-TrimPositions TrimWhitespace(const string16& input,
- TrimPositions positions,
- string16* output) {
- return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
-}
-
TrimPositions TrimWhitespaceASCII(const std::string& input,
TrimPositions positions,
std::string* output) {
return TrimStringT(input, StringPiece(kWhitespaceASCII), positions, output);
}
-// This function is only for backward-compatibility.
-// To be removed when all callers are updated.
-TrimPositions TrimWhitespace(const std::string& input,
- TrimPositions positions,
- std::string* output) {
- return TrimWhitespaceASCII(input, positions, output);
-}
-
-template<typename STR>
-STR CollapseWhitespaceT(const STR& text,
- bool trim_sequences_with_line_breaks) {
- STR result;
- result.resize(text.size());
-
- // Set flags to pretend we're already in a trimmed whitespace sequence, so we
- // will trim any leading whitespace.
- bool in_whitespace = true;
- bool already_trimmed = true;
-
- int chars_written = 0;
- for (typename STR::const_iterator i(text.begin()); i != text.end(); ++i) {
- if (IsWhitespace(*i)) {
- if (!in_whitespace) {
- // Reduce all whitespace sequences to a single space.
- in_whitespace = true;
- result[chars_written++] = L' ';
- }
- if (trim_sequences_with_line_breaks && !already_trimmed &&
- ((*i == '\n') || (*i == '\r'))) {
- // Whitespace sequences containing CR or LF are eliminated entirely.
- already_trimmed = true;
- --chars_written;
- }
- } else {
- // Non-whitespace chracters are copied straight across.
- in_whitespace = false;
- already_trimmed = false;
- result[chars_written++] = *i;
- }
- }
-
- if (in_whitespace && !already_trimmed) {
- // Any trailing whitespace is eliminated.
- --chars_written;
- }
-
- result.resize(chars_written);
- return result;
-}
-
-string16 CollapseWhitespace(const string16& text,
- bool trim_sequences_with_line_breaks) {
- return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
-}
-
-std::string CollapseWhitespaceASCII(const std::string& text,
- bool trim_sequences_with_line_breaks) {
- return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
-}
-
-bool ContainsOnlyChars(const StringPiece& input,
- const StringPiece& characters) {
- return input.find_first_not_of(characters) == StringPiece::npos;
-}
-
-bool ContainsOnlyChars(const StringPiece16& input,
- const StringPiece16& characters) {
- return input.find_first_not_of(characters) == StringPiece16::npos;
-}
-
template <class Char>
inline bool DoIsStringASCII(const Char* characters, size_t length) {
MachineWord all_char_bits = 0;
@@ -417,20 +159,6 @@
return DoIsStringASCII(str.data(), str.length());
}
-bool IsStringASCII(const StringPiece16& str) {
- return DoIsStringASCII(str.data(), str.length());
-}
-
-bool IsStringASCII(const string16& str) {
- return DoIsStringASCII(str.data(), str.length());
-}
-
-#if defined(WCHAR_T_IS_UTF32)
-bool IsStringASCII(const std::wstring& str) {
- return DoIsStringASCII(str.data(), str.length());
-}
-#endif
-
bool IsStringUTF8(const StringPiece& str) {
const char *src = str.data();
int32 src_len = static_cast<int32>(str.length());
@@ -445,606 +173,4 @@
return true;
}
-template<typename Iter>
-static inline bool DoLowerCaseEqualsASCII(Iter a_begin,
- Iter a_end,
- const char* b) {
- for (Iter it = a_begin; it != a_end; ++it, ++b) {
- if (!*b || ToLowerASCII(*it) != *b)
- return false;
- }
- return *b == 0;
-}
-
-// Front-ends for LowerCaseEqualsASCII.
-bool LowerCaseEqualsASCII(const std::string& a, const char* b) {
- return DoLowerCaseEqualsASCII(a.begin(), a.end(), b);
-}
-
-bool LowerCaseEqualsASCII(const string16& a, const char* b) {
- return DoLowerCaseEqualsASCII(a.begin(), a.end(), b);
-}
-
-bool LowerCaseEqualsASCII(std::string::const_iterator a_begin,
- std::string::const_iterator a_end,
- const char* b) {
- return DoLowerCaseEqualsASCII(a_begin, a_end, b);
-}
-
-bool LowerCaseEqualsASCII(string16::const_iterator a_begin,
- string16::const_iterator a_end,
- const char* b) {
- return DoLowerCaseEqualsASCII(a_begin, a_end, b);
-}
-
-bool LowerCaseEqualsASCII(const char* a_begin,
- const char* a_end,
- const char* b) {
- return DoLowerCaseEqualsASCII(a_begin, a_end, b);
-}
-
-bool LowerCaseEqualsASCII(const char* a_begin,
- const char* a_end,
- const char* b_begin,
- const char* b_end) {
- while (a_begin != a_end && b_begin != b_end &&
- ToLowerASCII(*a_begin) == *b_begin) {
- a_begin++;
- b_begin++;
- }
- return a_begin == a_end && b_begin == b_end;
-}
-
-bool LowerCaseEqualsASCII(const char16* a_begin,
- const char16* a_end,
- const char* b) {
- return DoLowerCaseEqualsASCII(a_begin, a_end, b);
-}
-
-bool EqualsASCII(const string16& a, const StringPiece& b) {
- if (a.length() != b.length())
- return false;
- return std::equal(b.begin(), b.end(), a.begin());
-}
-
-bool StartsWithASCII(const std::string& str,
- const std::string& search,
- bool case_sensitive) {
- if (case_sensitive)
- return str.compare(0, search.length(), search) == 0;
- else
- return base::strncasecmp(str.c_str(), search.c_str(), search.length()) == 0;
-}
-
-bool StartsWith(const string16& str,
- const string16& search,
- bool case_sensitive) {
- if (case_sensitive) {
- return str.compare(0, search.length(), search) == 0;
- }
- if (search.size() > str.size())
- return false;
- return std::equal(search.begin(), search.end(), str.begin(),
- CaseInsensitiveCompare<char16>());
-}
-
-template <typename STR>
-bool EndsWithT(const STR& str, const STR& search, bool case_sensitive) {
- size_t str_length = str.length();
- size_t search_length = search.length();
- if (search_length > str_length)
- return false;
- if (case_sensitive)
- return str.compare(str_length - search_length, search_length, search) == 0;
- return std::equal(search.begin(), search.end(),
- str.begin() + (str_length - search_length),
- base::CaseInsensitiveCompare<typename STR::value_type>());
-}
-
-bool EndsWith(const std::string& str, const std::string& search,
- bool case_sensitive) {
- return EndsWithT(str, search, case_sensitive);
-}
-
-bool EndsWith(const string16& str, const string16& search,
- bool case_sensitive) {
- return EndsWithT(str, search, case_sensitive);
-}
-
} // namespace base
-
-static const char* const kByteStringsUnlocalized[] = {
- " B",
- " kB",
- " MB",
- " GB",
- " TB",
- " PB"
-};
-
-string16 FormatBytesUnlocalized(int64 bytes) {
- double unit_amount = static_cast<double>(bytes);
- size_t dimension = 0;
- const int kKilo = 1024;
- while (unit_amount >= kKilo &&
- dimension < arraysize(kByteStringsUnlocalized) - 1) {
- unit_amount /= kKilo;
- dimension++;
- }
-
- char buf[64];
- if (bytes != 0 && dimension > 0 && unit_amount < 100) {
- base::snprintf(buf, arraysize(buf), "%.1lf%s", unit_amount,
- kByteStringsUnlocalized[dimension]);
- } else {
- base::snprintf(buf, arraysize(buf), "%.0lf%s", unit_amount,
- kByteStringsUnlocalized[dimension]);
- }
-
- return base::ASCIIToUTF16(buf);
-}
-
-// Runs in O(n) time in the length of |str|.
-template<class StringType>
-void DoReplaceSubstringsAfterOffset(StringType* str,
- size_t offset,
- const StringType& find_this,
- const StringType& replace_with,
- bool replace_all) {
- DCHECK(!find_this.empty());
-
- // If the find string doesn't appear, there's nothing to do.
- offset = str->find(find_this, offset);
- if (offset == StringType::npos)
- return;
-
- // If we're only replacing one instance, there's no need to do anything
- // complicated.
- size_t find_length = find_this.length();
- if (!replace_all) {
- str->replace(offset, find_length, replace_with);
- return;
- }
-
- // If the find and replace strings are the same length, we can simply use
- // replace() on each instance, and finish the entire operation in O(n) time.
- size_t replace_length = replace_with.length();
- if (find_length == replace_length) {
- do {
- str->replace(offset, find_length, replace_with);
- offset = str->find(find_this, offset + replace_length);
- } while (offset != StringType::npos);
- return;
- }
-
- // Since the find and replace strings aren't the same length, a loop like the
- // one above would be O(n^2) in the worst case, as replace() will shift the
- // entire remaining string each time. We need to be more clever to keep
- // things O(n).
- //
- // If we're shortening the string, we can alternate replacements with shifting
- // forward the intervening characters using memmove().
- size_t str_length = str->length();
- if (find_length > replace_length) {
- size_t write_offset = offset;
- do {
- if (replace_length) {
- str->replace(write_offset, replace_length, replace_with);
- write_offset += replace_length;
- }
- size_t read_offset = offset + find_length;
- offset = std::min(str->find(find_this, read_offset), str_length);
- size_t length = offset - read_offset;
- if (length) {
- memmove(&(*str)[write_offset], &(*str)[read_offset],
- length * sizeof(typename StringType::value_type));
- write_offset += length;
- }
- } while (offset < str_length);
- str->resize(write_offset);
- return;
- }
-
- // We're lengthening the string. We can use alternating replacements and
- // memmove() calls like above, but we need to precalculate the final string
- // length and then expand from back-to-front to avoid overwriting the string
- // as we're reading it, needing to shift, or having to copy to a second string
- // temporarily.
- size_t first_match = offset;
-
- // First, calculate the final length and resize the string.
- size_t final_length = str_length;
- size_t expansion = replace_length - find_length;
- size_t current_match;
- do {
- final_length += expansion;
- // Minor optimization: save this offset into |current_match|, so that on
- // exit from the loop, |current_match| will point at the last instance of
- // the find string, and we won't need to find() it again immediately.
- current_match = offset;
- offset = str->find(find_this, offset + find_length);
- } while (offset != StringType::npos);
- str->resize(final_length);
-
- // Now do the replacement loop, working backwards through the string.
- for (size_t prev_match = str_length, write_offset = final_length; ;
- current_match = str->rfind(find_this, current_match - 1)) {
- size_t read_offset = current_match + find_length;
- size_t length = prev_match - read_offset;
- if (length) {
- write_offset -= length;
- memmove(&(*str)[write_offset], &(*str)[read_offset],
- length * sizeof(typename StringType::value_type));
- }
- write_offset -= replace_length;
- str->replace(write_offset, replace_length, replace_with);
- if (current_match == first_match)
- return;
- prev_match = current_match;
- }
-}
-
-void ReplaceFirstSubstringAfterOffset(string16* str,
- size_t start_offset,
- const string16& find_this,
- const string16& replace_with) {
- DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
- false); // replace first instance
-}
-
-void ReplaceFirstSubstringAfterOffset(std::string* str,
- size_t start_offset,
- const std::string& find_this,
- const std::string& replace_with) {
- DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
- false); // replace first instance
-}
-
-void ReplaceSubstringsAfterOffset(string16* str,
- size_t start_offset,
- const string16& find_this,
- const string16& replace_with) {
- DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
- true); // replace all instances
-}
-
-void ReplaceSubstringsAfterOffset(std::string* str,
- size_t start_offset,
- const std::string& find_this,
- const std::string& replace_with) {
- DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
- true); // replace all instances
-}
-
-size_t Tokenize(const base::string16& str,
- const base::string16& delimiters,
- std::vector<base::string16>* tokens) {
- *tokens = base::SplitString(
- str, delimiters, base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
- return tokens->size();
-}
-
-size_t Tokenize(const std::string& str,
- const std::string& delimiters,
- std::vector<std::string>* tokens) {
- *tokens = base::SplitString(
- str, delimiters, base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
- return tokens->size();
-}
-
-size_t Tokenize(const base::StringPiece& str,
- const base::StringPiece& delimiters,
- std::vector<base::StringPiece>* tokens) {
- *tokens = base::SplitStringPiece(
- str, delimiters, base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
- return tokens->size();
-}
-
-template<typename STR>
-static STR JoinStringT(const std::vector<STR>& parts, const STR& sep) {
- if (parts.empty())
- return STR();
-
- STR result(parts[0]);
- typename std::vector<STR>::const_iterator iter = parts.begin();
- ++iter;
-
- for (; iter != parts.end(); ++iter) {
- result += sep;
- result += *iter;
- }
-
- return result;
-}
-
-std::string JoinString(const std::vector<std::string>& parts, char sep) {
- return JoinStringT(parts, std::string(1, sep));
-}
-
-string16 JoinString(const std::vector<string16>& parts, char16 sep) {
- return JoinStringT(parts, string16(1, sep));
-}
-
-std::string JoinString(const std::vector<std::string>& parts,
- const std::string& separator) {
- return JoinStringT(parts, separator);
-}
-
-string16 JoinString(const std::vector<string16>& parts,
- const string16& separator) {
- return JoinStringT(parts, separator);
-}
-
-template<class FormatStringType, class OutStringType>
-OutStringType DoReplaceStringPlaceholders(const FormatStringType& format_string,
- const std::vector<OutStringType>& subst, std::vector<size_t>* offsets) {
- size_t substitutions = subst.size();
-
- size_t sub_length = 0;
- for (typename std::vector<OutStringType>::const_iterator iter = subst.begin();
- iter != subst.end(); ++iter) {
- sub_length += iter->length();
- }
-
- OutStringType formatted;
- formatted.reserve(format_string.length() + sub_length);
-
- std::vector<ReplacementOffset> r_offsets;
- for (typename FormatStringType::const_iterator i = format_string.begin();
- i != format_string.end(); ++i) {
- if ('$' == *i) {
- if (i + 1 != format_string.end()) {
- ++i;
- DCHECK('$' == *i || '1' <= *i) << "Invalid placeholder: " << *i;
- if ('$' == *i) {
- while (i != format_string.end() && '$' == *i) {
- formatted.push_back('$');
- ++i;
- }
- --i;
- } else {
- uintptr_t index = 0;
- while (i != format_string.end() && '0' <= *i && *i <= '9') {
- index *= 10;
- index += *i - '0';
- ++i;
- }
- --i;
- index -= 1;
- if (offsets) {
- ReplacementOffset r_offset(index,
- static_cast<int>(formatted.size()));
- r_offsets.insert(std::lower_bound(r_offsets.begin(),
- r_offsets.end(),
- r_offset,
- &CompareParameter),
- r_offset);
- }
- if (index < substitutions)
- formatted.append(subst.at(index));
- }
- }
- } else {
- formatted.push_back(*i);
- }
- }
- if (offsets) {
- for (std::vector<ReplacementOffset>::const_iterator i = r_offsets.begin();
- i != r_offsets.end(); ++i) {
- offsets->push_back(i->offset);
- }
- }
- return formatted;
-}
-
-string16 ReplaceStringPlaceholders(const string16& format_string,
- const std::vector<string16>& subst,
- std::vector<size_t>* offsets) {
- return DoReplaceStringPlaceholders(format_string, subst, offsets);
-}
-
-std::string ReplaceStringPlaceholders(const base::StringPiece& format_string,
- const std::vector<std::string>& subst,
- std::vector<size_t>* offsets) {
- return DoReplaceStringPlaceholders(format_string, subst, offsets);
-}
-
-string16 ReplaceStringPlaceholders(const string16& format_string,
- const string16& a,
- size_t* offset) {
- std::vector<size_t> offsets;
- std::vector<string16> subst;
- subst.push_back(a);
- string16 result = ReplaceStringPlaceholders(format_string, subst, &offsets);
-
- DCHECK_EQ(1U, offsets.size());
- if (offset)
- *offset = offsets[0];
- return result;
-}
-
-static bool IsWildcard(base_icu::UChar32 character) {
- return character == '*' || character == '?';
-}
-
-// Move the strings pointers to the point where they start to differ.
-template <typename CHAR, typename NEXT>
-static void EatSameChars(const CHAR** pattern, const CHAR* pattern_end,
- const CHAR** string, const CHAR* string_end,
- NEXT next) {
- const CHAR* escape = NULL;
- while (*pattern != pattern_end && *string != string_end) {
- if (!escape && IsWildcard(**pattern)) {
- // We don't want to match wildcard here, except if it's escaped.
- return;
- }
-
- // Check if the escapement char is found. If so, skip it and move to the
- // next character.
- if (!escape && **pattern == '\\') {
- escape = *pattern;
- next(pattern, pattern_end);
- continue;
- }
-
- // Check if the chars match, if so, increment the ptrs.
- const CHAR* pattern_next = *pattern;
- const CHAR* string_next = *string;
- base_icu::UChar32 pattern_char = next(&pattern_next, pattern_end);
- if (pattern_char == next(&string_next, string_end) &&
- pattern_char != CBU_SENTINEL) {
- *pattern = pattern_next;
- *string = string_next;
- } else {
- // Uh oh, it did not match, we are done. If the last char was an
- // escapement, that means that it was an error to advance the ptr here,
- // let's put it back where it was. This also mean that the MatchPattern
- // function will return false because if we can't match an escape char
- // here, then no one will.
- if (escape) {
- *pattern = escape;
- }
- return;
- }
-
- escape = NULL;
- }
-}
-
-template <typename CHAR, typename NEXT>
-static void EatWildcard(const CHAR** pattern, const CHAR* end, NEXT next) {
- while (*pattern != end) {
- if (!IsWildcard(**pattern))
- return;
- next(pattern, end);
- }
-}
-
-template <typename CHAR, typename NEXT>
-static bool MatchPatternT(const CHAR* eval, const CHAR* eval_end,
- const CHAR* pattern, const CHAR* pattern_end,
- int depth,
- NEXT next) {
- const int kMaxDepth = 16;
- if (depth > kMaxDepth)
- return false;
-
- // Eat all the matching chars.
- EatSameChars(&pattern, pattern_end, &eval, eval_end, next);
-
- // If the string is empty, then the pattern must be empty too, or contains
- // only wildcards.
- if (eval == eval_end) {
- EatWildcard(&pattern, pattern_end, next);
- return pattern == pattern_end;
- }
-
- // Pattern is empty but not string, this is not a match.
- if (pattern == pattern_end)
- return false;
-
- // If this is a question mark, then we need to compare the rest with
- // the current string or the string with one character eaten.
- const CHAR* next_pattern = pattern;
- next(&next_pattern, pattern_end);
- if (pattern[0] == '?') {
- if (MatchPatternT(eval, eval_end, next_pattern, pattern_end,
- depth + 1, next))
- return true;
- const CHAR* next_eval = eval;
- next(&next_eval, eval_end);
- if (MatchPatternT(next_eval, eval_end, next_pattern, pattern_end,
- depth + 1, next))
- return true;
- }
-
- // This is a *, try to match all the possible substrings with the remainder
- // of the pattern.
- if (pattern[0] == '*') {
- // Collapse duplicate wild cards (********** into *) so that the
- // method does not recurse unnecessarily. http://crbug.com/52839
- EatWildcard(&next_pattern, pattern_end, next);
-
- while (eval != eval_end) {
- if (MatchPatternT(eval, eval_end, next_pattern, pattern_end,
- depth + 1, next))
- return true;
- eval++;
- }
-
- // We reached the end of the string, let see if the pattern contains only
- // wildcards.
- if (eval == eval_end) {
- EatWildcard(&pattern, pattern_end, next);
- if (pattern != pattern_end)
- return false;
- return true;
- }
- }
-
- return false;
-}
-
-struct NextCharUTF8 {
- base_icu::UChar32 operator()(const char** p, const char* end) {
- base_icu::UChar32 c;
- int offset = 0;
- CBU8_NEXT(*p, offset, end - *p, c);
- *p += offset;
- return c;
- }
-};
-
-struct NextCharUTF16 {
- base_icu::UChar32 operator()(const char16** p, const char16* end) {
- base_icu::UChar32 c;
- int offset = 0;
- CBU16_NEXT(*p, offset, end - *p, c);
- *p += offset;
- return c;
- }
-};
-
-bool MatchPattern(const base::StringPiece& eval,
- const base::StringPiece& pattern) {
- return MatchPatternT(eval.data(), eval.data() + eval.size(),
- pattern.data(), pattern.data() + pattern.size(),
- 0, NextCharUTF8());
-}
-
-bool MatchPattern(const string16& eval, const string16& pattern) {
- return MatchPatternT(eval.c_str(), eval.c_str() + eval.size(),
- pattern.c_str(), pattern.c_str() + pattern.size(),
- 0, NextCharUTF16());
-}
-
-// The following code is compatible with the OpenBSD lcpy interface. See:
-// http://www.gratisoft.us/todd/papers/strlcpy.html
-// ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/{wcs,str}lcpy.c
-
-namespace {
-
-template <typename CHAR>
-size_t lcpyT(CHAR* dst, const CHAR* src, size_t dst_size) {
- for (size_t i = 0; i < dst_size; ++i) {
- if ((dst[i] = src[i]) == 0) // We hit and copied the terminating NULL.
- return i;
- }
-
- // We were left off at dst_size. We over copied 1 byte. Null terminate.
- if (dst_size != 0)
- dst[dst_size - 1] = 0;
-
- // Count the rest of the |src|, and return it's length in characters.
- while (src[dst_size]) ++dst_size;
- return dst_size;
-}
-
-} // namespace
-
-size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
- return lcpyT<char>(dst, src, dst_size);
-}
-size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
- return lcpyT<wchar_t>(dst, src, dst_size);
-}
diff --git a/libweave/external/base/strings/string_util.h b/libweave/external/base/strings/string_util.h
index 027c6b6..b5b013a 100644
--- a/libweave/external/base/strings/string_util.h
+++ b/libweave/external/base/strings/string_util.h
@@ -16,7 +16,6 @@
#include "base/base_export.h"
#include "base/basictypes.h"
#include "base/compiler_specific.h"
-#include "base/strings/string16.h"
#include "base/strings/string_piece.h" // For implicit conversions.
// On Android, bionic's stdio.h defines an snprintf macro when being built with
@@ -30,19 +29,6 @@
// are listed below. These functions are then implemented as inline calls
// to the platform-specific equivalents in the platform-specific headers.
-// Compares the two strings s1 and s2 without regard to case using
-// the current locale; returns 0 if they are equal, 1 if s1 > s2, and -1 if
-// s2 > s1 according to a lexicographic comparison.
-int strcasecmp(const char* s1, const char* s2);
-
-// Compares up to count characters of s1 and s2 without regard to case using
-// the current locale; returns 0 if they are equal, 1 if s1 > s2, and -1 if
-// s2 > s1 according to a lexicographic comparison.
-int strncasecmp(const char* s1, const char* s2, size_t count);
-
-// Same as strncmp but for char16 strings.
-int strncmp16(const char16* s1, const char16* s2, size_t count);
-
// Wrapper for vsnprintf that always null-terminates and always returns the
// number of characters that would be in an untruncated formatted
// string, even when truncation occurs.
@@ -63,114 +49,16 @@
return result;
}
-// BSD-style safe and consistent string copy functions.
-// Copies |src| to |dst|, where |dst_size| is the total allocated size of |dst|.
-// Copies at most |dst_size|-1 characters, and always NULL terminates |dst|, as
-// long as |dst_size| is not 0. Returns the length of |src| in characters.
-// If the return value is >= dst_size, then the output was truncated.
-// NOTE: All sizes are in number of characters, NOT in bytes.
-BASE_EXPORT size_t strlcpy(char* dst, const char* src, size_t dst_size);
-BASE_EXPORT size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size);
-
-// Scan a wprintf format string to determine whether it's portable across a
-// variety of systems. This function only checks that the conversion
-// specifiers used by the format string are supported and have the same meaning
-// on a variety of systems. It doesn't check for other errors that might occur
-// within a format string.
-//
-// Nonportable conversion specifiers for wprintf are:
-// - 's' and 'c' without an 'l' length modifier. %s and %c operate on char
-// data on all systems except Windows, which treat them as wchar_t data.
-// Use %ls and %lc for wchar_t data instead.
-// - 'S' and 'C', which operate on wchar_t data on all systems except Windows,
-// which treat them as char data. Use %ls and %lc for wchar_t data
-// instead.
-// - 'F', which is not identified by Windows wprintf documentation.
-// - 'D', 'O', and 'U', which are deprecated and not available on all systems.
-// Use %ld, %lo, and %lu instead.
-//
-// Note that there is no portable conversion specifier for char data when
-// working with wprintf.
-//
-// This function is intended to be called from base::vswprintf.
-BASE_EXPORT bool IsWprintfFormatPortable(const wchar_t* format);
-
-// ASCII-specific tolower. The standard library's tolower is locale sensitive,
-// so we don't want to use it here.
-template <class Char> inline Char ToLowerASCII(Char c) {
- return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
-}
-
-// ASCII-specific toupper. The standard library's toupper is locale sensitive,
-// so we don't want to use it here.
-template <class Char> inline Char ToUpperASCII(Char c) {
- return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
-}
-
-// Function objects to aid in comparing/searching strings.
-
-template<typename Char> struct CaseInsensitiveCompare {
- public:
- bool operator()(Char x, Char y) const {
- // TODO(darin): Do we really want to do locale sensitive comparisons here?
- // See http://crbug.com/24917
- return tolower(x) == tolower(y);
- }
-};
-
-template<typename Char> struct CaseInsensitiveCompareASCII {
- public:
- bool operator()(Char x, Char y) const {
- return ToLowerASCII(x) == ToLowerASCII(y);
- }
-};
-
-// These threadsafe functions return references to globally unique empty
-// strings.
-//
-// It is likely faster to construct a new empty string object (just a few
-// instructions to set the length to 0) than to get the empty string singleton
-// returned by these functions (which requires threadsafe singleton access).
-//
-// Therefore, DO NOT USE THESE AS A GENERAL-PURPOSE SUBSTITUTE FOR DEFAULT
-// CONSTRUCTORS. There is only one case where you should use these: functions
-// which need to return a string by reference (e.g. as a class member
-// accessor), and don't have an empty string to use (e.g. in an error case).
-// These should not be used as initializers, function arguments, or return
-// values for functions which return by value or outparam.
-BASE_EXPORT const std::string& EmptyString();
-BASE_EXPORT const string16& EmptyString16();
-
// Contains the set of characters representing whitespace in the corresponding
// encoding. Null-terminated. The ASCII versions are the whitespaces as defined
// by HTML5, and don't include control characters.
-BASE_EXPORT extern const wchar_t kWhitespaceWide[]; // Includes Unicode.
-BASE_EXPORT extern const char16 kWhitespaceUTF16[]; // Includes Unicode.
BASE_EXPORT extern const char kWhitespaceASCII[];
-BASE_EXPORT extern const char16 kWhitespaceASCIIAs16[]; // No unicode.
-
-// Null-terminated string representing the UTF-8 byte order mark.
-BASE_EXPORT extern const char kUtf8ByteOrderMark[];
-
-// Removes characters in |remove_chars| from anywhere in |input|. Returns true
-// if any characters were removed. |remove_chars| must be null-terminated.
-// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool RemoveChars(const string16& input,
- const base::StringPiece16& remove_chars,
- string16* output);
-BASE_EXPORT bool RemoveChars(const std::string& input,
- const base::StringPiece& remove_chars,
- std::string* output);
// Replaces characters in |replace_chars| from anywhere in |input| with
// |replace_with|. Each character in |replace_chars| will be replaced with
// the |replace_with| string. Returns true if any characters were replaced.
// |replace_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool ReplaceChars(const string16& input,
- const base::StringPiece16& replace_chars,
- const string16& replace_with,
- string16* output);
BASE_EXPORT bool ReplaceChars(const std::string& input,
const base::StringPiece& replace_chars,
const std::string& replace_with,
@@ -188,28 +76,16 @@
//
// It is safe to use the same variable for both |input| and |output| (this is
// the normal usage to trim in-place).
-BASE_EXPORT bool TrimString(const string16& input,
- base::StringPiece16 trim_chars,
- string16* output);
BASE_EXPORT bool TrimString(const std::string& input,
base::StringPiece trim_chars,
std::string* output);
// StringPiece versions of the above. The returned pieces refer to the original
// buffer.
-BASE_EXPORT StringPiece16 TrimString(StringPiece16 input,
- const base::StringPiece16& trim_chars,
- TrimPositions positions);
BASE_EXPORT StringPiece TrimString(StringPiece input,
const base::StringPiece& trim_chars,
TrimPositions positions);
-// Truncates a string to the nearest UTF-8 character that will leave
-// the string less than or equal to the specified byte size.
-BASE_EXPORT void TruncateUTF8ToByteSize(const std::string& input,
- const size_t byte_size,
- std::string* output);
-
// Trims any whitespace from either end of the input string. Returns where
// whitespace was found.
// The non-wide version has two functions:
@@ -217,9 +93,6 @@
// This function is for ASCII strings and only looks for ASCII whitespace;
// Please choose the best one according to your usage.
// NOTE: Safe to use the same variable for both input and output.
-BASE_EXPORT TrimPositions TrimWhitespace(const string16& input,
- TrimPositions positions,
- base::string16* output);
BASE_EXPORT TrimPositions TrimWhitespaceASCII(const std::string& input,
TrimPositions positions,
std::string* output);
@@ -230,28 +103,6 @@
TrimPositions positions,
std::string* output);
-// Searches for CR or LF characters. Removes all contiguous whitespace
-// strings that contain them. This is useful when trying to deal with text
-// copied from terminals.
-// Returns |text|, with the following three transformations:
-// (1) Leading and trailing whitespace is trimmed.
-// (2) If |trim_sequences_with_line_breaks| is true, any other whitespace
-// sequences containing a CR or LF are trimmed.
-// (3) All other whitespace sequences are converted to single spaces.
-BASE_EXPORT string16 CollapseWhitespace(
- const string16& text,
- bool trim_sequences_with_line_breaks);
-BASE_EXPORT std::string CollapseWhitespaceASCII(
- const std::string& text,
- bool trim_sequences_with_line_breaks);
-
-// Returns true if |input| is empty or contains only characters found in
-// |characters|.
-BASE_EXPORT bool ContainsOnlyChars(const StringPiece& input,
- const StringPiece& characters);
-BASE_EXPORT bool ContainsOnlyChars(const StringPiece16& input,
- const StringPiece16& characters);
-
// Returns true if the specified string matches the criteria. How can a wide
// string be 8-bit or UTF8? It contains only characters that are < 256 (in the
// first case) or characters that use only 8-bits and whose 8-bit
@@ -268,90 +119,6 @@
// if it is not the case.
BASE_EXPORT bool IsStringUTF8(const StringPiece& str);
BASE_EXPORT bool IsStringASCII(const StringPiece& str);
-BASE_EXPORT bool IsStringASCII(const StringPiece16& str);
-// A convenience adaptor for WebStrings, as they don't convert into
-// StringPieces directly.
-BASE_EXPORT bool IsStringASCII(const string16& str);
-#if defined(WCHAR_T_IS_UTF32)
-BASE_EXPORT bool IsStringASCII(const std::wstring& str);
-#endif
-
-// Converts the elements of the given string. This version uses a pointer to
-// clearly differentiate it from the non-pointer variant.
-template <class str> inline void StringToLowerASCII(str* s) {
- for (typename str::iterator i = s->begin(); i != s->end(); ++i)
- *i = ToLowerASCII(*i);
-}
-
-template <class str> inline str StringToLowerASCII(const str& s) {
- // for std::string and std::wstring
- str output(s);
- StringToLowerASCII(&output);
- return output;
-}
-
-// Converts the elements of the given string. This version uses a pointer to
-// clearly differentiate it from the non-pointer variant.
-template <class str> inline void StringToUpperASCII(str* s) {
- for (typename str::iterator i = s->begin(); i != s->end(); ++i)
- *i = ToUpperASCII(*i);
-}
-
-template <class str> inline str StringToUpperASCII(const str& s) {
- // for std::string and std::wstring
- str output(s);
- StringToUpperASCII(&output);
- return output;
-}
-//
-// Compare the lower-case form of the given string against the given ASCII
-// string. This is useful for doing checking if an input string matches some
-// token, and it is optimized to avoid intermediate string copies. This API is
-// borrowed from the equivalent APIs in Mozilla.
-BASE_EXPORT bool LowerCaseEqualsASCII(const std::string& a, const char* b);
-BASE_EXPORT bool LowerCaseEqualsASCII(const string16& a, const char* b);
-
-// Same thing, but with string iterators instead.
-BASE_EXPORT bool LowerCaseEqualsASCII(std::string::const_iterator a_begin,
- std::string::const_iterator a_end,
- const char* b);
-BASE_EXPORT bool LowerCaseEqualsASCII(string16::const_iterator a_begin,
- string16::const_iterator a_end,
- const char* b);
-BASE_EXPORT bool LowerCaseEqualsASCII(const char* a_begin,
- const char* a_end,
- const char* b);
-BASE_EXPORT bool LowerCaseEqualsASCII(const char* a_begin,
- const char* a_end,
- const char* b_begin,
- const char* b_end);
-BASE_EXPORT bool LowerCaseEqualsASCII(const char16* a_begin,
- const char16* a_end,
- const char* b);
-
-// Performs a case-sensitive string compare. The behavior is undefined if both
-// strings are not ASCII.
-BASE_EXPORT bool EqualsASCII(const string16& a, const StringPiece& b);
-
-// Returns true if str starts with search, or false otherwise.
-// TODO(brettw) the case sensitive flag makes callsites difficult to read.
-// Consider splitting this out in two variants (few callers want
-// case-insensitive compares) or use an enum that makes this more explicit.
-BASE_EXPORT bool StartsWithASCII(const std::string& str,
- const std::string& search,
- bool case_sensitive);
-BASE_EXPORT bool StartsWith(const base::string16& str,
- const base::string16& search,
- bool case_sensitive);
-
-// Returns true if str ends with search, or false otherwise.
-// TODO(brettw) case sensitive flag confusion, see StartsWith above.
-BASE_EXPORT bool EndsWith(const std::string& str,
- const std::string& search,
- bool case_sensitive);
-BASE_EXPORT bool EndsWith(const base::string16& str,
- const base::string16& search,
- bool case_sensitive);
} // namespace base
@@ -363,169 +130,4 @@
#error Define string operations appropriately for your platform
#endif
-// Determines the type of ASCII character, independent of locale (the C
-// library versions will change based on locale).
-template <typename Char>
-inline bool IsAsciiWhitespace(Char c) {
- return c == ' ' || c == '\r' || c == '\n' || c == '\t';
-}
-template <typename Char>
-inline bool IsAsciiAlpha(Char c) {
- return ((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z'));
-}
-template <typename Char>
-inline bool IsAsciiDigit(Char c) {
- return c >= '0' && c <= '9';
-}
-
-template <typename Char>
-inline bool IsHexDigit(Char c) {
- return (c >= '0' && c <= '9') ||
- (c >= 'A' && c <= 'F') ||
- (c >= 'a' && c <= 'f');
-}
-
-template <typename Char>
-inline char HexDigitToInt(Char c) {
- DCHECK(IsHexDigit(c));
- if (c >= '0' && c <= '9')
- return static_cast<char>(c - '0');
- if (c >= 'A' && c <= 'F')
- return static_cast<char>(c - 'A' + 10);
- if (c >= 'a' && c <= 'f')
- return static_cast<char>(c - 'a' + 10);
- return 0;
-}
-
-// Returns true if it's a whitespace character.
-inline bool IsWhitespace(wchar_t c) {
- return wcschr(base::kWhitespaceWide, c) != NULL;
-}
-
-// Return a byte string in human-readable format with a unit suffix. Not
-// appropriate for use in any UI; use of FormatBytes and friends in ui/base is
-// highly recommended instead. TODO(avi): Figure out how to get callers to use
-// FormatBytes instead; remove this.
-BASE_EXPORT base::string16 FormatBytesUnlocalized(int64 bytes);
-
-// Starting at |start_offset| (usually 0), replace the first instance of
-// |find_this| with |replace_with|.
-BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
- base::string16* str,
- size_t start_offset,
- const base::string16& find_this,
- const base::string16& replace_with);
-BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
- std::string* str,
- size_t start_offset,
- const std::string& find_this,
- const std::string& replace_with);
-
-// Starting at |start_offset| (usually 0), look through |str| and replace all
-// instances of |find_this| with |replace_with|.
-//
-// This does entire substrings; use std::replace in <algorithm> for single
-// characters, for example:
-// std::replace(str.begin(), str.end(), 'a', 'b');
-BASE_EXPORT void ReplaceSubstringsAfterOffset(
- base::string16* str,
- size_t start_offset,
- const base::string16& find_this,
- const base::string16& replace_with);
-BASE_EXPORT void ReplaceSubstringsAfterOffset(std::string* str,
- size_t start_offset,
- const std::string& find_this,
- const std::string& replace_with);
-
-// Reserves enough memory in |str| to accommodate |length_with_null| characters,
-// sets the size of |str| to |length_with_null - 1| characters, and returns a
-// pointer to the underlying contiguous array of characters. This is typically
-// used when calling a function that writes results into a character array, but
-// the caller wants the data to be managed by a string-like object. It is
-// convenient in that is can be used inline in the call, and fast in that it
-// avoids copying the results of the call from a char* into a string.
-//
-// |length_with_null| must be at least 2, since otherwise the underlying string
-// would have size 0, and trying to access &((*str)[0]) in that case can result
-// in a number of problems.
-//
-// Internally, this takes linear time because the resize() call 0-fills the
-// underlying array for potentially all
-// (|length_with_null - 1| * sizeof(string_type::value_type)) bytes. Ideally we
-// could avoid this aspect of the resize() call, as we expect the caller to
-// immediately write over this memory, but there is no other way to set the size
-// of the string, and not doing that will mean people who access |str| rather
-// than str.c_str() will get back a string of whatever size |str| had on entry
-// to this function (probably 0).
-template <class string_type>
-inline typename string_type::value_type* WriteInto(string_type* str,
- size_t length_with_null) {
- DCHECK_GT(length_with_null, 1u);
- str->reserve(length_with_null);
- str->resize(length_with_null - 1);
- return &((*str)[0]);
-}
-
-//-----------------------------------------------------------------------------
-
-// Splits a string into its fields delimited by any of the characters in
-// |delimiters|. Each field is added to the |tokens| vector. Returns the
-// number of tokens found.
-//
-// DEPRECATED. Use SplitStringUsingSet for new code (these just forward).
-// TODO(brettw) convert callers and delete these forwarders.
-BASE_EXPORT size_t Tokenize(const base::string16& str,
- const base::string16& delimiters,
- std::vector<base::string16>* tokens);
-BASE_EXPORT size_t Tokenize(const std::string& str,
- const std::string& delimiters,
- std::vector<std::string>* tokens);
-BASE_EXPORT size_t Tokenize(const base::StringPiece& str,
- const base::StringPiece& delimiters,
- std::vector<base::StringPiece>* tokens);
-
-// Does the opposite of SplitString().
-BASE_EXPORT base::string16 JoinString(const std::vector<base::string16>& parts,
- base::char16 s);
-BASE_EXPORT std::string JoinString(
- const std::vector<std::string>& parts, char s);
-
-// Join |parts| using |separator|.
-BASE_EXPORT std::string JoinString(
- const std::vector<std::string>& parts,
- const std::string& separator);
-BASE_EXPORT base::string16 JoinString(
- const std::vector<base::string16>& parts,
- const base::string16& separator);
-
-// Replace $1-$2-$3..$9 in the format string with |a|-|b|-|c|..|i| respectively.
-// Additionally, any number of consecutive '$' characters is replaced by that
-// number less one. Eg $$->$, $$$->$$, etc. The offsets parameter here can be
-// NULL. This only allows you to use up to nine replacements.
-BASE_EXPORT base::string16 ReplaceStringPlaceholders(
- const base::string16& format_string,
- const std::vector<base::string16>& subst,
- std::vector<size_t>* offsets);
-
-BASE_EXPORT std::string ReplaceStringPlaceholders(
- const base::StringPiece& format_string,
- const std::vector<std::string>& subst,
- std::vector<size_t>* offsets);
-
-// Single-string shortcut for ReplaceStringHolders. |offset| may be NULL.
-BASE_EXPORT base::string16 ReplaceStringPlaceholders(
- const base::string16& format_string,
- const base::string16& a,
- size_t* offset);
-
-// Returns true if the string passed in matches the pattern. The pattern
-// string can contain wildcards like * and ?
-// The backslash character (\) is an escape character for * and ?
-// We limit the patterns to having a max of 16 * or ? characters.
-// ? matches 0 or 1 character, while * matches 0 or more characters.
-BASE_EXPORT bool MatchPattern(const base::StringPiece& string,
- const base::StringPiece& pattern);
-BASE_EXPORT bool MatchPattern(const base::string16& string,
- const base::string16& pattern);
-
#endif // BASE_STRINGS_STRING_UTIL_H_
diff --git a/libweave/external/base/strings/string_util_constants.cc b/libweave/external/base/strings/string_util_constants.cc
index aba1b12..905294c 100644
--- a/libweave/external/base/strings/string_util_constants.cc
+++ b/libweave/external/base/strings/string_util_constants.cc
@@ -34,14 +34,6 @@
0x3000, /* IDEOGRAPHIC SPACE */ \
0
-const wchar_t kWhitespaceWide[] = {
- WHITESPACE_UNICODE
-};
-
-const char16 kWhitespaceUTF16[] = {
- WHITESPACE_UNICODE
-};
-
const char kWhitespaceASCII[] = {
0x09, // CHARACTER TABULATION
0x0A, // LINE FEED (LF)
@@ -52,16 +44,4 @@
0
};
-const char16 kWhitespaceASCIIAs16[] = {
- 0x09, // CHARACTER TABULATION
- 0x0A, // LINE FEED (LF)
- 0x0B, // LINE TABULATION
- 0x0C, // FORM FEED (FF)
- 0x0D, // CARRIAGE RETURN (CR)
- 0x20, // SPACE
- 0
-};
-
-const char kUtf8ByteOrderMark[] = "\xEF\xBB\xBF";
-
} // namespace base
diff --git a/libweave/external/base/strings/string_util_posix.h b/libweave/external/base/strings/string_util_posix.h
index f4009d4..ccfff10 100644
--- a/libweave/external/base/strings/string_util_posix.h
+++ b/libweave/external/base/strings/string_util_posix.h
@@ -14,39 +14,11 @@
namespace base {
-// Chromium code style is to not use malloc'd strings; this is only for use
-// for interaction with APIs that require it.
-inline char* strdup(const char* str) {
- return ::strdup(str);
-}
-
-inline int strcasecmp(const char* string1, const char* string2) {
- return ::strcasecmp(string1, string2);
-}
-
-inline int strncasecmp(const char* string1, const char* string2, size_t count) {
- return ::strncasecmp(string1, string2, count);
-}
-
inline int vsnprintf(char* buffer, size_t size,
const char* format, va_list arguments) {
return ::vsnprintf(buffer, size, format, arguments);
}
-inline int strncmp16(const char16* s1, const char16* s2, size_t count) {
-#if defined(WCHAR_T_IS_UTF16)
- return ::wcsncmp(s1, s2, count);
-#elif defined(WCHAR_T_IS_UTF32)
- return c16memcmp(s1, s2, count);
-#endif
-}
-
-inline int vswprintf(wchar_t* buffer, size_t size,
- const wchar_t* format, va_list arguments) {
- DCHECK(IsWprintfFormatPortable(format));
- return ::vswprintf(buffer, size, format, arguments);
-}
-
} // namespace base
#endif // BASE_STRINGS_STRING_UTIL_POSIX_H_
diff --git a/libweave/external/base/strings/string_util_unittest.cc b/libweave/external/base/strings/string_util_unittest.cc
index fb0bead..1a75218 100644
--- a/libweave/external/base/strings/string_util_unittest.cc
+++ b/libweave/external/base/strings/string_util_unittest.cc
@@ -9,317 +9,16 @@
#include <algorithm>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
#include "base/basictypes.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "base/strings/utf_string_conversion_utils.h"
using ::testing::ElementsAre;
namespace base {
-static const struct trim_case {
- const wchar_t* input;
- const TrimPositions positions;
- const wchar_t* output;
- const TrimPositions return_value;
-} trim_cases[] = {
- {L" Google Video ", TRIM_LEADING, L"Google Video ", TRIM_LEADING},
- {L" Google Video ", TRIM_TRAILING, L" Google Video", TRIM_TRAILING},
- {L" Google Video ", TRIM_ALL, L"Google Video", TRIM_ALL},
- {L"Google Video", TRIM_ALL, L"Google Video", TRIM_NONE},
- {L"", TRIM_ALL, L"", TRIM_NONE},
- {L" ", TRIM_LEADING, L"", TRIM_LEADING},
- {L" ", TRIM_TRAILING, L"", TRIM_TRAILING},
- {L" ", TRIM_ALL, L"", TRIM_ALL},
- {L"\t\rTest String\n", TRIM_ALL, L"Test String", TRIM_ALL},
- {L"\x2002Test String\x00A0\x3000", TRIM_ALL, L"Test String", TRIM_ALL},
-};
-
-static const struct trim_case_ascii {
- const char* input;
- const TrimPositions positions;
- const char* output;
- const TrimPositions return_value;
-} trim_cases_ascii[] = {
- {" Google Video ", TRIM_LEADING, "Google Video ", TRIM_LEADING},
- {" Google Video ", TRIM_TRAILING, " Google Video", TRIM_TRAILING},
- {" Google Video ", TRIM_ALL, "Google Video", TRIM_ALL},
- {"Google Video", TRIM_ALL, "Google Video", TRIM_NONE},
- {"", TRIM_ALL, "", TRIM_NONE},
- {" ", TRIM_LEADING, "", TRIM_LEADING},
- {" ", TRIM_TRAILING, "", TRIM_TRAILING},
- {" ", TRIM_ALL, "", TRIM_ALL},
- {"\t\rTest String\n", TRIM_ALL, "Test String", TRIM_ALL},
-};
-
-namespace {
-
-// Helper used to test TruncateUTF8ToByteSize.
-bool Truncated(const std::string& input,
- const size_t byte_size,
- std::string* output) {
- size_t prev = input.length();
- TruncateUTF8ToByteSize(input, byte_size, output);
- return prev != output->length();
-}
-
-} // namespace
-
-TEST(StringUtilTest, TruncateUTF8ToByteSize) {
- std::string output;
-
- // Empty strings and invalid byte_size arguments
- EXPECT_FALSE(Truncated(std::string(), 0, &output));
- EXPECT_EQ(output, "");
- EXPECT_TRUE(Truncated("\xe1\x80\xbf", 0, &output));
- EXPECT_EQ(output, "");
- EXPECT_FALSE(Truncated("\xe1\x80\xbf", static_cast<size_t>(-1), &output));
- EXPECT_FALSE(Truncated("\xe1\x80\xbf", 4, &output));
-
- // Testing the truncation of valid UTF8 correctly
- EXPECT_TRUE(Truncated("abc", 2, &output));
- EXPECT_EQ(output, "ab");
- EXPECT_TRUE(Truncated("\xc2\x81\xc2\x81", 2, &output));
- EXPECT_EQ(output.compare("\xc2\x81"), 0);
- EXPECT_TRUE(Truncated("\xc2\x81\xc2\x81", 3, &output));
- EXPECT_EQ(output.compare("\xc2\x81"), 0);
- EXPECT_FALSE(Truncated("\xc2\x81\xc2\x81", 4, &output));
- EXPECT_EQ(output.compare("\xc2\x81\xc2\x81"), 0);
-
- {
- const char array[] = "\x00\x00\xc2\x81\xc2\x81";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\x00\x00\xc2\x81", 4)), 0);
- }
-
- {
- const char array[] = "\x00\xc2\x81\xc2\x81";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\x00\xc2\x81", 3)), 0);
- }
-
- // Testing invalid UTF8
- EXPECT_TRUE(Truncated("\xed\xa0\x80\xed\xbf\xbf", 6, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xed\xa0\x8f", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xed\xbf\xbf", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // Testing invalid UTF8 mixed with valid UTF8
- EXPECT_FALSE(Truncated("\xe1\x80\xbf", 3, &output));
- EXPECT_EQ(output.compare("\xe1\x80\xbf"), 0);
- EXPECT_FALSE(Truncated("\xf1\x80\xa0\xbf", 4, &output));
- EXPECT_EQ(output.compare("\xf1\x80\xa0\xbf"), 0);
- EXPECT_FALSE(Truncated("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf",
- 10, &output));
- EXPECT_EQ(output.compare("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf"), 0);
- EXPECT_TRUE(Truncated("a\xc2\x81\xe1\x80\xbf\xf1""a""\x80\xa0",
- 10, &output));
- EXPECT_EQ(output.compare("a\xc2\x81\xe1\x80\xbf\xf1""a"), 0);
- EXPECT_FALSE(Truncated("\xef\xbb\xbf" "abc", 6, &output));
- EXPECT_EQ(output.compare("\xef\xbb\xbf" "abc"), 0);
-
- // Overlong sequences
- EXPECT_TRUE(Truncated("\xc0\x80", 2, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xc1\x80\xc1\x81", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xe0\x80\x80", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xe0\x82\x80", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xe0\x9f\xbf", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x80\x80\x8D", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x80\x82\x91", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x80\xa0\x80", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x8f\xbb\xbf", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf8\x80\x80\x80\xbf", 5, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xfc\x80\x80\x80\xa0\xa5", 6, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // Beyond U+10FFFF (the upper limit of Unicode codespace)
- EXPECT_TRUE(Truncated("\xf4\x90\x80\x80", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf8\xa0\xbf\x80\xbf", 5, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xfc\x9c\xbf\x80\xbf\x80", 6, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // BOMs in UTF-16(BE|LE) and UTF-32(BE|LE)
- EXPECT_TRUE(Truncated("\xfe\xff", 2, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xff\xfe", 2, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- {
- const char array[] = "\x00\x00\xfe\xff";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\x00\x00", 2)), 0);
- }
-
- // Variants on the previous test
- {
- const char array[] = "\xff\xfe\x00\x00";
- const std::string array_string(array, 4);
- EXPECT_FALSE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\xff\xfe\x00\x00", 4)), 0);
- }
- {
- const char array[] = "\xff\x00\x00\xfe";
- const std::string array_string(array, arraysize(array));
- EXPECT_TRUE(Truncated(array_string, 4, &output));
- EXPECT_EQ(output.compare(std::string("\xff\x00\x00", 3)), 0);
- }
-
- // Non-characters : U+xxFFF[EF] where xx is 0x00 through 0x10 and <FDD0,FDEF>
- EXPECT_TRUE(Truncated("\xef\xbf\xbe", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf0\x8f\xbf\xbe", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xf3\xbf\xbf\xbf", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xef\xb7\x90", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_TRUE(Truncated("\xef\xb7\xaf", 3, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // Strings in legacy encodings that are valid in UTF-8, but
- // are invalid as UTF-8 in real data.
- EXPECT_TRUE(Truncated("caf\xe9", 4, &output));
- EXPECT_EQ(output.compare("caf"), 0);
- EXPECT_TRUE(Truncated("\xb0\xa1\xb0\xa2", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
- EXPECT_FALSE(Truncated("\xa7\x41\xa6\x6e", 4, &output));
- EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
- EXPECT_TRUE(Truncated("\xa7\x41\xa6\x6e\xd9\xee\xe4\xee", 7,
- &output));
- EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
-
- // Testing using the same string as input and output.
- EXPECT_FALSE(Truncated(output, 4, &output));
- EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
- EXPECT_TRUE(Truncated(output, 3, &output));
- EXPECT_EQ(output.compare("\xa7\x41"), 0);
-
- // "abc" with U+201[CD] in windows-125[0-8]
- EXPECT_TRUE(Truncated("\x93" "abc\x94", 5, &output));
- EXPECT_EQ(output.compare("\x93" "abc"), 0);
-
- // U+0639 U+064E U+0644 U+064E in ISO-8859-6
- EXPECT_TRUE(Truncated("\xd9\xee\xe4\xee", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
-
- // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
- EXPECT_TRUE(Truncated("\xe3\xe5\xe9\xdC", 4, &output));
- EXPECT_EQ(output.compare(""), 0);
-}
-
-TEST(StringUtilTest, TrimWhitespace) {
- string16 output; // Allow contents to carry over to next testcase
- for (size_t i = 0; i < arraysize(trim_cases); ++i) {
- const trim_case& value = trim_cases[i];
- EXPECT_EQ(value.return_value,
- TrimWhitespace(WideToUTF16(value.input), value.positions,
- &output));
- EXPECT_EQ(WideToUTF16(value.output), output);
- }
-
- // Test that TrimWhitespace() can take the same string for input and output
- output = ASCIIToUTF16(" This is a test \r\n");
- EXPECT_EQ(TRIM_ALL, TrimWhitespace(output, TRIM_ALL, &output));
- EXPECT_EQ(ASCIIToUTF16("This is a test"), output);
-
- // Once more, but with a string of whitespace
- output = ASCIIToUTF16(" \r\n");
- EXPECT_EQ(TRIM_ALL, TrimWhitespace(output, TRIM_ALL, &output));
- EXPECT_EQ(string16(), output);
-
- std::string output_ascii;
- for (size_t i = 0; i < arraysize(trim_cases_ascii); ++i) {
- const trim_case_ascii& value = trim_cases_ascii[i];
- EXPECT_EQ(value.return_value,
- TrimWhitespace(value.input, value.positions, &output_ascii));
- EXPECT_EQ(value.output, output_ascii);
- }
-}
-
-static const struct collapse_case {
- const wchar_t* input;
- const bool trim;
- const wchar_t* output;
-} collapse_cases[] = {
- {L" Google Video ", false, L"Google Video"},
- {L"Google Video", false, L"Google Video"},
- {L"", false, L""},
- {L" ", false, L""},
- {L"\t\rTest String\n", false, L"Test String"},
- {L"\x2002Test String\x00A0\x3000", false, L"Test String"},
- {L" Test \n \t String ", false, L"Test String"},
- {L"\x2002Test\x1680 \x2028 \tString\x00A0\x3000", false, L"Test String"},
- {L" Test String", false, L"Test String"},
- {L"Test String ", false, L"Test String"},
- {L"Test String", false, L"Test String"},
- {L"", true, L""},
- {L"\n", true, L""},
- {L" \r ", true, L""},
- {L"\nFoo", true, L"Foo"},
- {L"\r Foo ", true, L"Foo"},
- {L" Foo bar ", true, L"Foo bar"},
- {L" \tFoo bar \n", true, L"Foo bar"},
- {L" a \r b\n c \r\n d \t\re \t f \n ", true, L"abcde f"},
-};
-
-TEST(StringUtilTest, CollapseWhitespace) {
- for (size_t i = 0; i < arraysize(collapse_cases); ++i) {
- const collapse_case& value = collapse_cases[i];
- EXPECT_EQ(WideToUTF16(value.output),
- CollapseWhitespace(WideToUTF16(value.input), value.trim));
- }
-}
-
-static const struct collapse_case_ascii {
- const char* input;
- const bool trim;
- const char* output;
-} collapse_cases_ascii[] = {
- {" Google Video ", false, "Google Video"},
- {"Google Video", false, "Google Video"},
- {"", false, ""},
- {" ", false, ""},
- {"\t\rTest String\n", false, "Test String"},
- {" Test \n \t String ", false, "Test String"},
- {" Test String", false, "Test String"},
- {"Test String ", false, "Test String"},
- {"Test String", false, "Test String"},
- {"", true, ""},
- {"\n", true, ""},
- {" \r ", true, ""},
- {"\nFoo", true, "Foo"},
- {"\r Foo ", true, "Foo"},
- {" Foo bar ", true, "Foo bar"},
- {" \tFoo bar \n", true, "Foo bar"},
- {" a \r b\n c \r\n d \t\re \t f \n ", true, "abcde f"},
-};
-
-TEST(StringUtilTest, CollapseWhitespaceASCII) {
- for (size_t i = 0; i < arraysize(collapse_cases_ascii); ++i) {
- const collapse_case_ascii& value = collapse_cases_ascii[i];
- EXPECT_EQ(value.output, CollapseWhitespaceASCII(value.input, value.trim));
- }
-}
-
TEST(StringUtilTest, IsStringUTF8) {
EXPECT_TRUE(IsStringUTF8("abc"));
EXPECT_TRUE(IsStringUTF8("\xc2\x81"));
@@ -389,10 +88,6 @@
TEST(StringUtilTest, IsStringASCII) {
static char char_ascii[] =
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
- static char16 char16_ascii[] = {
- '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A',
- 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5', '6',
- '7', '8', '9', '0', 'A', 'B', 'C', 'D', 'E', 'F', 0 };
static std::wstring wchar_ascii(
L"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF");
@@ -414,725 +109,6 @@
}
}
}
-
- {
- const size_t string_length = arraysize(char16_ascii) - 1;
- for (size_t offset = 0; offset < 4; ++offset) {
- for (size_t len = 0, max_len = string_length - offset; len < max_len;
- ++len) {
- EXPECT_TRUE(IsStringASCII(StringPiece16(char16_ascii + offset, len)));
- for (size_t char_pos = offset; char_pos < len; ++char_pos) {
- char16_ascii[char_pos] |= 0x80;
- EXPECT_FALSE(
- IsStringASCII(StringPiece16(char16_ascii + offset, len)));
- char16_ascii[char_pos] &= ~0x80;
- // Also test when the upper half is non-zero.
- char16_ascii[char_pos] |= 0x100;
- EXPECT_FALSE(
- IsStringASCII(StringPiece16(char16_ascii + offset, len)));
- char16_ascii[char_pos] &= ~0x100;
- }
- }
- }
- }
-
- {
- const size_t string_length = wchar_ascii.length();
- for (size_t len = 0; len < string_length; ++len) {
- EXPECT_TRUE(IsStringASCII(wchar_ascii.substr(0, len)));
- for (size_t char_pos = 0; char_pos < len; ++char_pos) {
- wchar_ascii[char_pos] |= 0x80;
- EXPECT_FALSE(
- IsStringASCII(wchar_ascii.substr(0, len)));
- wchar_ascii[char_pos] &= ~0x80;
- wchar_ascii[char_pos] |= 0x100;
- EXPECT_FALSE(
- IsStringASCII(wchar_ascii.substr(0, len)));
- wchar_ascii[char_pos] &= ~0x100;
-#if defined(WCHAR_T_IS_UTF32)
- wchar_ascii[char_pos] |= 0x10000;
- EXPECT_FALSE(
- IsStringASCII(wchar_ascii.substr(0, len)));
- wchar_ascii[char_pos] &= ~0x10000;
-#endif // WCHAR_T_IS_UTF32
- }
- }
- }
-}
-
-TEST(StringUtilTest, ConvertASCII) {
- static const char* const char_cases[] = {
- "Google Video",
- "Hello, world\n",
- "0123ABCDwxyz \a\b\t\r\n!+,.~"
- };
-
- static const wchar_t* const wchar_cases[] = {
- L"Google Video",
- L"Hello, world\n",
- L"0123ABCDwxyz \a\b\t\r\n!+,.~"
- };
-
- for (size_t i = 0; i < arraysize(char_cases); ++i) {
- EXPECT_TRUE(IsStringASCII(char_cases[i]));
- string16 utf16 = ASCIIToUTF16(char_cases[i]);
- EXPECT_EQ(WideToUTF16(wchar_cases[i]), utf16);
-
- std::string ascii = UTF16ToASCII(WideToUTF16(wchar_cases[i]));
- EXPECT_EQ(char_cases[i], ascii);
- }
-
- EXPECT_FALSE(IsStringASCII("Google \x80Video"));
-
- // Convert empty strings.
- string16 empty16;
- std::string empty;
- EXPECT_EQ(empty, UTF16ToASCII(empty16));
- EXPECT_EQ(empty16, ASCIIToUTF16(empty));
-
- // Convert strings with an embedded NUL character.
- const char chars_with_nul[] = "test\0string";
- const int length_with_nul = arraysize(chars_with_nul) - 1;
- std::string string_with_nul(chars_with_nul, length_with_nul);
- string16 string16_with_nul = ASCIIToUTF16(string_with_nul);
- EXPECT_EQ(static_cast<string16::size_type>(length_with_nul),
- string16_with_nul.length());
- std::string narrow_with_nul = UTF16ToASCII(string16_with_nul);
- EXPECT_EQ(static_cast<std::string::size_type>(length_with_nul),
- narrow_with_nul.length());
- EXPECT_EQ(0, string_with_nul.compare(narrow_with_nul));
-}
-
-TEST(StringUtilTest, ToUpperASCII) {
- EXPECT_EQ('C', ToUpperASCII('C'));
- EXPECT_EQ('C', ToUpperASCII('c'));
- EXPECT_EQ('2', ToUpperASCII('2'));
-
- EXPECT_EQ(L'C', ToUpperASCII(L'C'));
- EXPECT_EQ(L'C', ToUpperASCII(L'c'));
- EXPECT_EQ(L'2', ToUpperASCII(L'2'));
-
- std::string in_place_a("Cc2");
- StringToUpperASCII(&in_place_a);
- EXPECT_EQ("CC2", in_place_a);
-
- std::wstring in_place_w(L"Cc2");
- StringToUpperASCII(&in_place_w);
- EXPECT_EQ(L"CC2", in_place_w);
-
- std::string original_a("Cc2");
- std::string upper_a = StringToUpperASCII(original_a);
- EXPECT_EQ("CC2", upper_a);
-
- std::wstring original_w(L"Cc2");
- std::wstring upper_w = StringToUpperASCII(original_w);
- EXPECT_EQ(L"CC2", upper_w);
-}
-
-TEST(StringUtilTest, LowerCaseEqualsASCII) {
- static const struct {
- const char* src_a;
- const char* dst;
- } lowercase_cases[] = {
- { "FoO", "foo" },
- { "foo", "foo" },
- { "FOO", "foo" },
- };
-
- for (size_t i = 0; i < arraysize(lowercase_cases); ++i) {
- EXPECT_TRUE(LowerCaseEqualsASCII(ASCIIToUTF16(lowercase_cases[i].src_a),
- lowercase_cases[i].dst));
- EXPECT_TRUE(LowerCaseEqualsASCII(lowercase_cases[i].src_a,
- lowercase_cases[i].dst));
- }
-}
-
-TEST(StringUtilTest, FormatBytesUnlocalized) {
- static const struct {
- int64 bytes;
- const char* expected;
- } cases[] = {
- // Expected behavior: we show one post-decimal digit when we have
- // under two pre-decimal digits, except in cases where it makes no
- // sense (zero or bytes).
- // Since we switch units once we cross the 1000 mark, this keeps
- // the display of file sizes or bytes consistently around three
- // digits.
- {0, "0 B"},
- {512, "512 B"},
- {1024*1024, "1.0 MB"},
- {1024*1024*1024, "1.0 GB"},
- {10LL*1024*1024*1024, "10.0 GB"},
- {99LL*1024*1024*1024, "99.0 GB"},
- {105LL*1024*1024*1024, "105 GB"},
- {105LL*1024*1024*1024 + 500LL*1024*1024, "105 GB"},
- {~(1LL << 63), "8192 PB"},
-
- {99*1024 + 103, "99.1 kB"},
- {1024*1024 + 103, "1.0 MB"},
- {1024*1024 + 205 * 1024, "1.2 MB"},
- {1024*1024*1024 + (927 * 1024*1024), "1.9 GB"},
- {10LL*1024*1024*1024, "10.0 GB"},
- {100LL*1024*1024*1024, "100 GB"},
- };
-
- for (size_t i = 0; i < arraysize(cases); ++i) {
- EXPECT_EQ(ASCIIToUTF16(cases[i].expected),
- FormatBytesUnlocalized(cases[i].bytes));
- }
-}
-TEST(StringUtilTest, ReplaceSubstringsAfterOffset) {
- static const struct {
- const char* str;
- string16::size_type start_offset;
- const char* find_this;
- const char* replace_with;
- const char* expected;
- } cases[] = {
- {"aaa", 0, "a", "b", "bbb"},
- {"abb", 0, "ab", "a", "ab"},
- {"Removing some substrings inging", 0, "ing", "", "Remov some substrs "},
- {"Not found", 0, "x", "0", "Not found"},
- {"Not found again", 5, "x", "0", "Not found again"},
- {" Making it much longer ", 0, " ", "Four score and seven years ago",
- "Four score and seven years agoMakingFour score and seven years agoit"
- "Four score and seven years agomuchFour score and seven years agolonger"
- "Four score and seven years ago"},
- {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
- {"Replace me only me once", 9, "me ", "", "Replace me only once"},
- {"abababab", 2, "ab", "c", "abccc"},
- };
-
- for (size_t i = 0; i < arraysize(cases); i++) {
- string16 str = ASCIIToUTF16(cases[i].str);
- ReplaceSubstringsAfterOffset(&str, cases[i].start_offset,
- ASCIIToUTF16(cases[i].find_this),
- ASCIIToUTF16(cases[i].replace_with));
- EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str);
- }
-}
-
-TEST(StringUtilTest, ReplaceFirstSubstringAfterOffset) {
- static const struct {
- const char* str;
- string16::size_type start_offset;
- const char* find_this;
- const char* replace_with;
- const char* expected;
- } cases[] = {
- {"aaa", 0, "a", "b", "baa"},
- {"abb", 0, "ab", "a", "ab"},
- {"Removing some substrings inging", 0, "ing", "",
- "Remov some substrings inging"},
- {"Not found", 0, "x", "0", "Not found"},
- {"Not found again", 5, "x", "0", "Not found again"},
- {" Making it much longer ", 0, " ", "Four score and seven years ago",
- "Four score and seven years agoMaking it much longer "},
- {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
- {"Replace me only me once", 4, "me ", "", "Replace only me once"},
- {"abababab", 2, "ab", "c", "abcabab"},
- };
-
- for (size_t i = 0; i < arraysize(cases); i++) {
- string16 str = ASCIIToUTF16(cases[i].str);
- ReplaceFirstSubstringAfterOffset(&str, cases[i].start_offset,
- ASCIIToUTF16(cases[i].find_this),
- ASCIIToUTF16(cases[i].replace_with));
- EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str);
- }
-}
-
-TEST(StringUtilTest, HexDigitToInt) {
- EXPECT_EQ(0, HexDigitToInt('0'));
- EXPECT_EQ(1, HexDigitToInt('1'));
- EXPECT_EQ(2, HexDigitToInt('2'));
- EXPECT_EQ(3, HexDigitToInt('3'));
- EXPECT_EQ(4, HexDigitToInt('4'));
- EXPECT_EQ(5, HexDigitToInt('5'));
- EXPECT_EQ(6, HexDigitToInt('6'));
- EXPECT_EQ(7, HexDigitToInt('7'));
- EXPECT_EQ(8, HexDigitToInt('8'));
- EXPECT_EQ(9, HexDigitToInt('9'));
- EXPECT_EQ(10, HexDigitToInt('A'));
- EXPECT_EQ(11, HexDigitToInt('B'));
- EXPECT_EQ(12, HexDigitToInt('C'));
- EXPECT_EQ(13, HexDigitToInt('D'));
- EXPECT_EQ(14, HexDigitToInt('E'));
- EXPECT_EQ(15, HexDigitToInt('F'));
-
- // Verify the lower case as well.
- EXPECT_EQ(10, HexDigitToInt('a'));
- EXPECT_EQ(11, HexDigitToInt('b'));
- EXPECT_EQ(12, HexDigitToInt('c'));
- EXPECT_EQ(13, HexDigitToInt('d'));
- EXPECT_EQ(14, HexDigitToInt('e'));
- EXPECT_EQ(15, HexDigitToInt('f'));
-}
-
-// Test for Tokenize
-template <typename STR>
-void TokenizeTest() {
- std::vector<STR> r;
- size_t size;
-
- size = Tokenize(STR("This is a string"), STR(" "), &r);
- EXPECT_EQ(4U, size);
- ASSERT_EQ(4U, r.size());
- EXPECT_EQ(r[0], STR("This"));
- EXPECT_EQ(r[1], STR("is"));
- EXPECT_EQ(r[2], STR("a"));
- EXPECT_EQ(r[3], STR("string"));
- r.clear();
-
- size = Tokenize(STR("one,two,three"), STR(","), &r);
- EXPECT_EQ(3U, size);
- ASSERT_EQ(3U, r.size());
- EXPECT_EQ(r[0], STR("one"));
- EXPECT_EQ(r[1], STR("two"));
- EXPECT_EQ(r[2], STR("three"));
- r.clear();
-
- size = Tokenize(STR("one,two:three;four"), STR(",:"), &r);
- EXPECT_EQ(3U, size);
- ASSERT_EQ(3U, r.size());
- EXPECT_EQ(r[0], STR("one"));
- EXPECT_EQ(r[1], STR("two"));
- EXPECT_EQ(r[2], STR("three;four"));
- r.clear();
-
- size = Tokenize(STR("one,two:three;four"), STR(";,:"), &r);
- EXPECT_EQ(4U, size);
- ASSERT_EQ(4U, r.size());
- EXPECT_EQ(r[0], STR("one"));
- EXPECT_EQ(r[1], STR("two"));
- EXPECT_EQ(r[2], STR("three"));
- EXPECT_EQ(r[3], STR("four"));
- r.clear();
-
- size = Tokenize(STR("one, two, three"), STR(","), &r);
- EXPECT_EQ(3U, size);
- ASSERT_EQ(3U, r.size());
- EXPECT_EQ(r[0], STR("one"));
- EXPECT_EQ(r[1], STR(" two"));
- EXPECT_EQ(r[2], STR(" three"));
- r.clear();
-
- size = Tokenize(STR("one, two, three, "), STR(","), &r);
- EXPECT_EQ(4U, size);
- ASSERT_EQ(4U, r.size());
- EXPECT_EQ(r[0], STR("one"));
- EXPECT_EQ(r[1], STR(" two"));
- EXPECT_EQ(r[2], STR(" three"));
- EXPECT_EQ(r[3], STR(" "));
- r.clear();
-
- size = Tokenize(STR("one, two, three,"), STR(","), &r);
- EXPECT_EQ(3U, size);
- ASSERT_EQ(3U, r.size());
- EXPECT_EQ(r[0], STR("one"));
- EXPECT_EQ(r[1], STR(" two"));
- EXPECT_EQ(r[2], STR(" three"));
- r.clear();
-
- size = Tokenize(STR(), STR(","), &r);
- EXPECT_EQ(0U, size);
- ASSERT_EQ(0U, r.size());
- r.clear();
-
- size = Tokenize(STR(","), STR(","), &r);
- EXPECT_EQ(0U, size);
- ASSERT_EQ(0U, r.size());
- r.clear();
-
- size = Tokenize(STR(",;:."), STR(".:;,"), &r);
- EXPECT_EQ(0U, size);
- ASSERT_EQ(0U, r.size());
- r.clear();
-
- size = Tokenize(STR("\t\ta\t"), STR("\t"), &r);
- EXPECT_EQ(1U, size);
- ASSERT_EQ(1U, r.size());
- EXPECT_EQ(r[0], STR("a"));
- r.clear();
-
- size = Tokenize(STR("\ta\t\nb\tcc"), STR("\n"), &r);
- EXPECT_EQ(2U, size);
- ASSERT_EQ(2U, r.size());
- EXPECT_EQ(r[0], STR("\ta\t"));
- EXPECT_EQ(r[1], STR("b\tcc"));
- r.clear();
-}
-
-TEST(StringUtilTest, TokenizeStdString) {
- TokenizeTest<std::string>();
-}
-
-TEST(StringUtilTest, TokenizeStringPiece) {
- TokenizeTest<StringPiece>();
-}
-
-// Test for JoinString
-TEST(StringUtilTest, JoinString) {
- std::vector<std::string> in;
- EXPECT_EQ("", JoinString(in, ','));
-
- in.push_back("a");
- EXPECT_EQ("a", JoinString(in, ','));
-
- in.push_back("b");
- in.push_back("c");
- EXPECT_EQ("a,b,c", JoinString(in, ','));
-
- in.push_back(std::string());
- EXPECT_EQ("a,b,c,", JoinString(in, ','));
- in.push_back(" ");
- EXPECT_EQ("a|b|c|| ", JoinString(in, '|'));
-}
-
-// Test for JoinString overloaded with std::string separator
-TEST(StringUtilTest, JoinStringWithString) {
- std::string separator(", ");
- std::vector<std::string> parts;
- EXPECT_EQ(std::string(), JoinString(parts, separator));
-
- parts.push_back("a");
- EXPECT_EQ("a", JoinString(parts, separator));
-
- parts.push_back("b");
- parts.push_back("c");
- EXPECT_EQ("a, b, c", JoinString(parts, separator));
-
- parts.push_back(std::string());
- EXPECT_EQ("a, b, c, ", JoinString(parts, separator));
- parts.push_back(" ");
- EXPECT_EQ("a|b|c|| ", JoinString(parts, "|"));
-}
-
-// Test for JoinString overloaded with string16 separator
-TEST(StringUtilTest, JoinStringWithString16) {
- string16 separator = ASCIIToUTF16(", ");
- std::vector<string16> parts;
- EXPECT_EQ(string16(), JoinString(parts, separator));
-
- parts.push_back(ASCIIToUTF16("a"));
- EXPECT_EQ(ASCIIToUTF16("a"), JoinString(parts, separator));
-
- parts.push_back(ASCIIToUTF16("b"));
- parts.push_back(ASCIIToUTF16("c"));
- EXPECT_EQ(ASCIIToUTF16("a, b, c"), JoinString(parts, separator));
-
- parts.push_back(ASCIIToUTF16(""));
- EXPECT_EQ(ASCIIToUTF16("a, b, c, "), JoinString(parts, separator));
- parts.push_back(ASCIIToUTF16(" "));
- EXPECT_EQ(ASCIIToUTF16("a|b|c|| "), JoinString(parts, ASCIIToUTF16("|")));
-}
-
-TEST(StringUtilTest, StartsWith) {
- EXPECT_TRUE(StartsWithASCII("javascript:url", "javascript", true));
- EXPECT_FALSE(StartsWithASCII("JavaScript:url", "javascript", true));
- EXPECT_TRUE(StartsWithASCII("javascript:url", "javascript", false));
- EXPECT_TRUE(StartsWithASCII("JavaScript:url", "javascript", false));
- EXPECT_FALSE(StartsWithASCII("java", "javascript", true));
- EXPECT_FALSE(StartsWithASCII("java", "javascript", false));
- EXPECT_FALSE(StartsWithASCII(std::string(), "javascript", false));
- EXPECT_FALSE(StartsWithASCII(std::string(), "javascript", true));
- EXPECT_TRUE(StartsWithASCII("java", std::string(), false));
- EXPECT_TRUE(StartsWithASCII("java", std::string(), true));
-
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
- ASCIIToUTF16("javascript"), true));
- EXPECT_FALSE(StartsWith(ASCIIToUTF16("JavaScript:url"),
- ASCIIToUTF16("javascript"), true));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
- ASCIIToUTF16("javascript"), false));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("JavaScript:url"),
- ASCIIToUTF16("javascript"), false));
- EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"),
- ASCIIToUTF16("javascript"), true));
- EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"),
- ASCIIToUTF16("javascript"), false));
- EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"), false));
- EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"), true));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(), false));
- EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(), true));
-}
-
-TEST(StringUtilTest, EndsWith) {
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"),
- ASCIIToUTF16(".plugin"), true));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.Plugin"),
- ASCIIToUTF16(".plugin"), true));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"),
- ASCIIToUTF16(".plugin"), false));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.Plugin"),
- ASCIIToUTF16(".plugin"), false));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"), true));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"), false));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"),
- ASCIIToUTF16(".plugin"), true));
- EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"),
- ASCIIToUTF16(".plugin"), false));
- EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"), false));
- EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"), true));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), false));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), true));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"),
- ASCIIToUTF16(".plugin"), false));
- EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"), ASCIIToUTF16(".plugin"), true));
- EXPECT_TRUE(EndsWith(string16(), string16(), false));
- EXPECT_TRUE(EndsWith(string16(), string16(), true));
-}
-
-TEST(StringUtilTest, GetStringFWithOffsets) {
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("1"));
- subst.push_back(ASCIIToUTF16("2"));
- std::vector<size_t> offsets;
-
- ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $1. Your number is $2."),
- subst,
- &offsets);
- EXPECT_EQ(2U, offsets.size());
- EXPECT_EQ(7U, offsets[0]);
- EXPECT_EQ(25U, offsets[1]);
- offsets.clear();
-
- ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $2. Your number is $1."),
- subst,
- &offsets);
- EXPECT_EQ(2U, offsets.size());
- EXPECT_EQ(25U, offsets[0]);
- EXPECT_EQ(7U, offsets[1]);
- offsets.clear();
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersTooFew) {
- // Test whether replacestringplaceholders works as expected when there
- // are fewer inputs than outputs.
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("9a"));
- subst.push_back(ASCIIToUTF16("8b"));
- subst.push_back(ASCIIToUTF16("7c"));
-
- string16 formatted =
- ReplaceStringPlaceholders(
- ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$1g,$2h,$3i"), subst, NULL);
-
- EXPECT_EQ(formatted, ASCIIToUTF16("9aa,8bb,7cc,d,e,f,9ag,8bh,7ci"));
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholders) {
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("9a"));
- subst.push_back(ASCIIToUTF16("8b"));
- subst.push_back(ASCIIToUTF16("7c"));
- subst.push_back(ASCIIToUTF16("6d"));
- subst.push_back(ASCIIToUTF16("5e"));
- subst.push_back(ASCIIToUTF16("4f"));
- subst.push_back(ASCIIToUTF16("3g"));
- subst.push_back(ASCIIToUTF16("2h"));
- subst.push_back(ASCIIToUTF16("1i"));
-
- string16 formatted =
- ReplaceStringPlaceholders(
- ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i"), subst, NULL);
-
- EXPECT_EQ(formatted, ASCIIToUTF16("9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii"));
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersMoreThan9Replacements) {
- std::vector<string16> subst;
- subst.push_back(ASCIIToUTF16("9a"));
- subst.push_back(ASCIIToUTF16("8b"));
- subst.push_back(ASCIIToUTF16("7c"));
- subst.push_back(ASCIIToUTF16("6d"));
- subst.push_back(ASCIIToUTF16("5e"));
- subst.push_back(ASCIIToUTF16("4f"));
- subst.push_back(ASCIIToUTF16("3g"));
- subst.push_back(ASCIIToUTF16("2h"));
- subst.push_back(ASCIIToUTF16("1i"));
- subst.push_back(ASCIIToUTF16("0j"));
- subst.push_back(ASCIIToUTF16("-1k"));
- subst.push_back(ASCIIToUTF16("-2l"));
- subst.push_back(ASCIIToUTF16("-3m"));
- subst.push_back(ASCIIToUTF16("-4n"));
-
- string16 formatted =
- ReplaceStringPlaceholders(
- ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i,"
- "$10j,$11k,$12l,$13m,$14n,$1"), subst, NULL);
-
- EXPECT_EQ(formatted, ASCIIToUTF16("9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,"
- "1ii,0jj,-1kk,-2ll,-3mm,-4nn,9a"));
-}
-
-TEST(StringUtilTest, StdStringReplaceStringPlaceholders) {
- std::vector<std::string> subst;
- subst.push_back("9a");
- subst.push_back("8b");
- subst.push_back("7c");
- subst.push_back("6d");
- subst.push_back("5e");
- subst.push_back("4f");
- subst.push_back("3g");
- subst.push_back("2h");
- subst.push_back("1i");
-
- std::string formatted =
- ReplaceStringPlaceholders(
- "$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i", subst, NULL);
-
- EXPECT_EQ(formatted, "9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii");
-}
-
-TEST(StringUtilTest, ReplaceStringPlaceholdersConsecutiveDollarSigns) {
- std::vector<std::string> subst;
- subst.push_back("a");
- subst.push_back("b");
- subst.push_back("c");
- EXPECT_EQ(ReplaceStringPlaceholders("$$1 $$$2 $$$$3", subst, NULL),
- "$1 $$2 $$$3");
-}
-
-TEST(StringUtilTest, MatchPatternTest) {
- EXPECT_TRUE(MatchPattern("www.google.com", "*.com"));
- EXPECT_TRUE(MatchPattern("www.google.com", "*"));
- EXPECT_FALSE(MatchPattern("www.google.com", "www*.g*.org"));
- EXPECT_TRUE(MatchPattern("Hello", "H?l?o"));
- EXPECT_FALSE(MatchPattern("www.google.com", "http://*)"));
- EXPECT_FALSE(MatchPattern("www.msn.com", "*.COM"));
- EXPECT_TRUE(MatchPattern("Hello*1234", "He??o\\*1*"));
- EXPECT_FALSE(MatchPattern("", "*.*"));
- EXPECT_TRUE(MatchPattern("", "*"));
- EXPECT_TRUE(MatchPattern("", "?"));
- EXPECT_TRUE(MatchPattern("", ""));
- EXPECT_FALSE(MatchPattern("Hello", ""));
- EXPECT_TRUE(MatchPattern("Hello*", "Hello*"));
- // Stop after a certain recursion depth.
- EXPECT_FALSE(MatchPattern("123456789012345678", "?????????????????*"));
-
- // Test UTF8 matching.
- EXPECT_TRUE(MatchPattern("heart: \xe2\x99\xa0", "*\xe2\x99\xa0"));
- EXPECT_TRUE(MatchPattern("heart: \xe2\x99\xa0.", "heart: ?."));
- EXPECT_TRUE(MatchPattern("hearts: \xe2\x99\xa0\xe2\x99\xa0", "*"));
- // Invalid sequences should be handled as a single invalid character.
- EXPECT_TRUE(MatchPattern("invalid: \xef\xbf\xbe", "invalid: ?"));
- // If the pattern has invalid characters, it shouldn't match anything.
- EXPECT_FALSE(MatchPattern("\xf4\x90\x80\x80", "\xf4\x90\x80\x80"));
-
- // Test UTF16 character matching.
- EXPECT_TRUE(MatchPattern(UTF8ToUTF16("www.google.com"),
- UTF8ToUTF16("*.com")));
- EXPECT_TRUE(MatchPattern(UTF8ToUTF16("Hello*1234"),
- UTF8ToUTF16("He??o\\*1*")));
-
- // This test verifies that consecutive wild cards are collapsed into 1
- // wildcard (when this doesn't occur, MatchPattern reaches it's maximum
- // recursion depth).
- EXPECT_TRUE(MatchPattern(UTF8ToUTF16("Hello"),
- UTF8ToUTF16("He********************************o")));
-}
-
-TEST(StringUtilTest, LcpyTest) {
- // Test the normal case where we fit in our buffer.
- {
- char dst[10];
- wchar_t wdst[10];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
- }
-
- // Test dst_size == 0, nothing should be written to |dst| and we should
- // have the equivalent of strlen(src).
- {
- char dst[2] = {1, 2};
- wchar_t wdst[2] = {1, 2};
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", 0));
- EXPECT_EQ(1, dst[0]);
- EXPECT_EQ(2, dst[1]);
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", 0));
- EXPECT_EQ(static_cast<wchar_t>(1), wdst[0]);
- EXPECT_EQ(static_cast<wchar_t>(2), wdst[1]);
- }
-
- // Test the case were we _just_ competely fit including the null.
- {
- char dst[8];
- wchar_t wdst[8];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
- }
-
- // Test the case were we we are one smaller, so we can't fit the null.
- {
- char dst[7];
- wchar_t wdst[7];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "abcdef", 7));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"abcdef", sizeof(wchar_t) * 7));
- }
-
- // Test the case were we are just too small.
- {
- char dst[3];
- wchar_t wdst[3];
- EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
- EXPECT_EQ(0, memcmp(dst, "ab", 3));
- EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
- EXPECT_EQ(0, memcmp(wdst, L"ab", sizeof(wchar_t) * 3));
- }
-}
-
-TEST(StringUtilTest, WprintfFormatPortabilityTest) {
- static const struct {
- const wchar_t* input;
- bool portable;
- } cases[] = {
- { L"%ls", true },
- { L"%s", false },
- { L"%S", false },
- { L"%lS", false },
- { L"Hello, %s", false },
- { L"%lc", true },
- { L"%c", false },
- { L"%C", false },
- { L"%lC", false },
- { L"%ls %s", false },
- { L"%s %ls", false },
- { L"%s %ls %s", false },
- { L"%f", true },
- { L"%f %F", false },
- { L"%d %D", false },
- { L"%o %O", false },
- { L"%u %U", false },
- { L"%f %d %o %u", true },
- { L"%-8d (%02.1f%)", true },
- { L"% 10s", false },
- { L"% 10ls", true }
- };
- for (size_t i = 0; i < arraysize(cases); ++i)
- EXPECT_EQ(cases[i].portable, IsWprintfFormatPortable(cases[i].input));
-}
-
-TEST(StringUtilTest, RemoveChars) {
- const char kRemoveChars[] = "-/+*";
- std::string input = "A-+bc/d!*";
- EXPECT_TRUE(RemoveChars(input, kRemoveChars, &input));
- EXPECT_EQ("Abcd!", input);
-
- // No characters match kRemoveChars.
- EXPECT_FALSE(RemoveChars(input, kRemoveChars, &input));
- EXPECT_EQ("Abcd!", input);
-
- // Empty string.
- input.clear();
- EXPECT_FALSE(RemoveChars(input, kRemoveChars, &input));
- EXPECT_EQ(std::string(), input);
}
TEST(StringUtilTest, ReplaceChars) {
@@ -1169,67 +145,4 @@
}
}
-TEST(StringUtilTest, ContainsOnlyChars) {
- // Providing an empty list of characters should return false but for the empty
- // string.
- EXPECT_TRUE(ContainsOnlyChars(std::string(), std::string()));
- EXPECT_FALSE(ContainsOnlyChars("Hello", std::string()));
-
- EXPECT_TRUE(ContainsOnlyChars(std::string(), "1234"));
- EXPECT_TRUE(ContainsOnlyChars("1", "1234"));
- EXPECT_TRUE(ContainsOnlyChars("1", "4321"));
- EXPECT_TRUE(ContainsOnlyChars("123", "4321"));
- EXPECT_FALSE(ContainsOnlyChars("123a", "4321"));
-
- EXPECT_TRUE(ContainsOnlyChars(std::string(), kWhitespaceASCII));
- EXPECT_TRUE(ContainsOnlyChars(" ", kWhitespaceASCII));
- EXPECT_TRUE(ContainsOnlyChars("\t", kWhitespaceASCII));
- EXPECT_TRUE(ContainsOnlyChars("\t \r \n ", kWhitespaceASCII));
- EXPECT_FALSE(ContainsOnlyChars("a", kWhitespaceASCII));
- EXPECT_FALSE(ContainsOnlyChars("\thello\r \n ", kWhitespaceASCII));
-
- EXPECT_TRUE(ContainsOnlyChars(string16(), kWhitespaceUTF16));
- EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16(" "), kWhitespaceUTF16));
- EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16("\t"), kWhitespaceUTF16));
- EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16("\t \r \n "), kWhitespaceUTF16));
- EXPECT_FALSE(ContainsOnlyChars(ASCIIToUTF16("a"), kWhitespaceUTF16));
- EXPECT_FALSE(ContainsOnlyChars(ASCIIToUTF16("\thello\r \n "),
- kWhitespaceUTF16));
-}
-
-class WriteIntoTest : public testing::Test {
- protected:
- static void WritesCorrectly(size_t num_chars) {
- std::string buffer;
- char kOriginal[] = "supercali";
- strncpy(WriteInto(&buffer, num_chars + 1), kOriginal, num_chars);
- // Using std::string(buffer.c_str()) instead of |buffer| truncates the
- // string at the first \0.
- EXPECT_EQ(std::string(kOriginal,
- std::min(num_chars, arraysize(kOriginal) - 1)),
- std::string(buffer.c_str()));
- EXPECT_EQ(num_chars, buffer.size());
- }
-};
-
-TEST_F(WriteIntoTest, WriteInto) {
- // Validate that WriteInto reserves enough space and
- // sizes a string correctly.
- WritesCorrectly(1);
- WritesCorrectly(2);
- WritesCorrectly(5000);
-
- // Validate that WriteInto doesn't modify other strings
- // when using a Copy-on-Write implementation.
- const char kLive[] = "live";
- const char kDead[] = "dead";
- const std::string live = kLive;
- std::string dead = live;
- strncpy(WriteInto(&dead, 5), kDead, 4);
- EXPECT_EQ(kDead, dead);
- EXPECT_EQ(4u, dead.size());
- EXPECT_EQ(kLive, live);
- EXPECT_EQ(4u, live.size());
-}
-
} // namespace base
diff --git a/libweave/external/base/strings/stringprintf.cc b/libweave/external/base/strings/stringprintf.cc
index 537873d..5f1ad9b 100644
--- a/libweave/external/base/strings/stringprintf.cc
+++ b/libweave/external/base/strings/stringprintf.cc
@@ -8,9 +8,9 @@
#include <vector>
+#include "base/logging.h"
#include "base/scoped_clear_errno.h"
#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
namespace base {
@@ -29,15 +29,6 @@
return base::vsnprintf(buffer, buf_size, format, argptr);
}
-#if defined(OS_WIN)
-inline int vsnprintfT(wchar_t* buffer,
- size_t buf_size,
- const wchar_t* format,
- va_list argptr) {
- return base::vswprintf(buffer, buf_size, format, argptr);
-}
-#endif
-
// Templatized backend for StringPrintF/StringAppendF. This does not finalize
// the va_list, the caller is expected to do that.
template <class StringType>
@@ -119,17 +110,6 @@
return result;
}
-#if defined(OS_WIN)
-std::wstring StringPrintf(const wchar_t* format, ...) {
- va_list ap;
- va_start(ap, format);
- std::wstring result;
- StringAppendV(&result, format, ap);
- va_end(ap);
- return result;
-}
-#endif
-
std::string StringPrintV(const char* format, va_list ap) {
std::string result;
StringAppendV(&result, format, ap);
@@ -145,18 +125,6 @@
return *dst;
}
-#if defined(OS_WIN)
-const std::wstring& SStringPrintf(std::wstring* dst,
- const wchar_t* format, ...) {
- va_list ap;
- va_start(ap, format);
- dst->clear();
- StringAppendV(dst, format, ap);
- va_end(ap);
- return *dst;
-}
-#endif
-
void StringAppendF(std::string* dst, const char* format, ...) {
va_list ap;
va_start(ap, format);
@@ -164,23 +132,8 @@
va_end(ap);
}
-#if defined(OS_WIN)
-void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
- va_list ap;
- va_start(ap, format);
- StringAppendV(dst, format, ap);
- va_end(ap);
-}
-#endif
-
void StringAppendV(std::string* dst, const char* format, va_list ap) {
StringAppendVT(dst, format, ap);
}
-#if defined(OS_WIN)
-void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
- StringAppendVT(dst, format, ap);
-}
-#endif
-
} // namespace base
diff --git a/libweave/external/base/strings/stringprintf.h b/libweave/external/base/strings/stringprintf.h
index 523f7ee..bb4b22d 100644
--- a/libweave/external/base/strings/stringprintf.h
+++ b/libweave/external/base/strings/stringprintf.h
@@ -17,10 +17,6 @@
// Return a C++ string given printf-like input.
BASE_EXPORT std::string StringPrintf(const char* format, ...)
PRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
-#if defined(OS_WIN)
-BASE_EXPORT std::wstring StringPrintf(const wchar_t* format, ...)
- WPRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
-#endif
// Return a C++ string given vprintf-like input.
BASE_EXPORT std::string StringPrintV(const char* format, va_list ap)
@@ -30,29 +26,15 @@
BASE_EXPORT const std::string& SStringPrintf(std::string* dst,
const char* format, ...)
PRINTF_FORMAT(2, 3);
-#if defined(OS_WIN)
-BASE_EXPORT const std::wstring& SStringPrintf(std::wstring* dst,
- const wchar_t* format, ...)
- WPRINTF_FORMAT(2, 3);
-#endif
// Append result to a supplied string.
BASE_EXPORT void StringAppendF(std::string* dst, const char* format, ...)
PRINTF_FORMAT(2, 3);
-#if defined(OS_WIN)
-BASE_EXPORT void StringAppendF(std::wstring* dst, const wchar_t* format, ...)
- WPRINTF_FORMAT(2, 3);
-#endif
// Lower-level routine that takes a va_list and appends to a specified
// string. All other routines are just convenience wrappers around it.
BASE_EXPORT void StringAppendV(std::string* dst, const char* format, va_list ap)
PRINTF_FORMAT(2, 0);
-#if defined(OS_WIN)
-BASE_EXPORT void StringAppendV(std::wstring* dst,
- const wchar_t* format, va_list ap)
- WPRINTF_FORMAT(2, 0);
-#endif
} // namespace base
diff --git a/libweave/external/base/strings/stringprintf_unittest.cc b/libweave/external/base/strings/stringprintf_unittest.cc
index c49637c..88a9675 100644
--- a/libweave/external/base/strings/stringprintf_unittest.cc
+++ b/libweave/external/base/strings/stringprintf_unittest.cc
@@ -6,8 +6,9 @@
#include <errno.h>
+#include <gtest/gtest.h>
+
#include "base/basictypes.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
@@ -80,10 +81,6 @@
for (size_t i = 0; i < arraysize(src); i++)
src[i] = 'A';
- wchar_t srcw[kSrcLen];
- for (size_t i = 0; i < arraysize(srcw); i++)
- srcw[i] = 'A';
-
for (int i = 1; i < 3; i++) {
src[kSrcLen - i] = 0;
std::string out;
diff --git a/libweave/external/base/strings/utf_string_conversion_utils.cc b/libweave/external/base/strings/utf_string_conversion_utils.cc
index 022c0df..05bd122 100644
--- a/libweave/external/base/strings/utf_string_conversion_utils.cc
+++ b/libweave/external/base/strings/utf_string_conversion_utils.cc
@@ -29,43 +29,6 @@
return IsValidCodepoint(code_point);
}
-bool ReadUnicodeCharacter(const char16* src,
- int32 src_len,
- int32* char_index,
- uint32* code_point) {
- if (CBU16_IS_SURROGATE(src[*char_index])) {
- if (!CBU16_IS_SURROGATE_LEAD(src[*char_index]) ||
- *char_index + 1 >= src_len ||
- !CBU16_IS_TRAIL(src[*char_index + 1])) {
- // Invalid surrogate pair.
- return false;
- }
-
- // Valid surrogate pair.
- *code_point = CBU16_GET_SUPPLEMENTARY(src[*char_index],
- src[*char_index + 1]);
- (*char_index)++;
- } else {
- // Not a surrogate, just one 16-bit word.
- *code_point = src[*char_index];
- }
-
- return IsValidCodepoint(*code_point);
-}
-
-#if defined(WCHAR_T_IS_UTF32)
-bool ReadUnicodeCharacter(const wchar_t* src,
- int32 src_len,
- int32* char_index,
- uint32* code_point) {
- // Conversion is easy since the source is 32-bit.
- *code_point = src[*char_index];
-
- // Validate the value.
- return IsValidCodepoint(*code_point);
-}
-#endif // defined(WCHAR_T_IS_UTF32)
-
// WriteUnicodeCharacter -------------------------------------------------------
size_t WriteUnicodeCharacter(uint32 code_point, std::string* output) {
@@ -89,19 +52,6 @@
return char_offset - original_char_offset;
}
-size_t WriteUnicodeCharacter(uint32 code_point, string16* output) {
- if (CBU16_LENGTH(code_point) == 1) {
- // Thie code point is in the Basic Multilingual Plane (BMP).
- output->push_back(static_cast<char16>(code_point));
- return 1;
- }
- // Non-BMP characters use a double-character encoding.
- size_t char_offset = output->length();
- output->resize(char_offset + CBU16_MAX_LENGTH);
- CBU16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);
- return CBU16_MAX_LENGTH;
-}
-
// Generalized Unicode converter -----------------------------------------------
template<typename CHAR>
@@ -120,10 +70,6 @@
}
}
-// Instantiate versions we know callers will need.
-template void PrepareForUTF8Output(const wchar_t*, size_t, std::string*);
-template void PrepareForUTF8Output(const char16*, size_t, std::string*);
-
template<typename STRING>
void PrepareForUTF16Or32Output(const char* src,
size_t src_len,
@@ -141,8 +87,4 @@
}
}
-// Instantiate versions we know callers will need.
-template void PrepareForUTF16Or32Output(const char*, size_t, std::wstring*);
-template void PrepareForUTF16Or32Output(const char*, size_t, string16*);
-
} // namespace base
diff --git a/libweave/external/base/strings/utf_string_conversion_utils.h b/libweave/external/base/strings/utf_string_conversion_utils.h
index 22abbbc..57940dd 100644
--- a/libweave/external/base/strings/utf_string_conversion_utils.h
+++ b/libweave/external/base/strings/utf_string_conversion_utils.h
@@ -5,10 +5,12 @@
#ifndef BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
#define BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
+#include <string>
+
// This should only be used by the various UTF string conversion files.
#include "base/base_export.h"
-#include "base/strings/string16.h"
+#include "base/basictypes.h"
namespace base {
@@ -42,12 +44,6 @@
int32* char_index,
uint32* code_point_out);
-// Reads a UTF-16 character. The usage is the same as the 8-bit version above.
-BASE_EXPORT bool ReadUnicodeCharacter(const char16* src,
- int32 src_len,
- int32* char_index,
- uint32* code_point);
-
#if defined(WCHAR_T_IS_UTF32)
// Reads UTF-32 character. The usage is the same as the 8-bit version above.
BASE_EXPORT bool ReadUnicodeCharacter(const wchar_t* src,
@@ -64,10 +60,6 @@
BASE_EXPORT size_t WriteUnicodeCharacter(uint32 code_point,
std::string* output);
-// Appends the given code point as a UTF-16 character to the given 16-bit
-// string. Returns the number of 16-bit values written.
-BASE_EXPORT size_t WriteUnicodeCharacter(uint32 code_point, string16* output);
-
#if defined(WCHAR_T_IS_UTF32)
// Appends the given UTF-32 character to the given 32-bit string. Returns the
// number of 32-bit values written.
diff --git a/libweave/external/base/template_util.h b/libweave/external/base/template_util.h
index 83fa322..f8f507b 100644
--- a/libweave/external/base/template_util.h
+++ b/libweave/external/base/template_util.h
@@ -6,55 +6,15 @@
#define BASE_TEMPLATE_UTIL_H_
#include <cstddef> // For size_t.
+#include <type_traits>
-#include "build/build_config.h"
+#include "base/build/build_config.h"
namespace base {
-// template definitions from tr1
-
-template<class T, T v>
-struct integral_constant {
- static const T value = v;
- typedef T value_type;
- typedef integral_constant<T, v> type;
-};
-
-template <class T, T v> const T integral_constant<T, v>::value;
-
-typedef integral_constant<bool, true> true_type;
-typedef integral_constant<bool, false> false_type;
-
-template <class T> struct is_pointer : false_type {};
-template <class T> struct is_pointer<T*> : true_type {};
-
-// Member function pointer detection. This is built-in to C++ 11's stdlib, and
-// we can remove this when we switch to it.
-template<typename T>
-struct is_member_function_pointer : false_type {};
-
-template <typename R, typename Z, typename... A>
-struct is_member_function_pointer<R(Z::*)(A...)> : true_type {};
-template <typename R, typename Z, typename... A>
-struct is_member_function_pointer<R(Z::*)(A...) const> : true_type {};
-
-
-template <class T, class U> struct is_same : public false_type {};
-template <class T> struct is_same<T,T> : true_type {};
-
-template<class> struct is_array : public false_type {};
-template<class T, size_t n> struct is_array<T[n]> : public true_type {};
-template<class T> struct is_array<T[]> : public true_type {};
-
-template <class T> struct is_non_const_reference : false_type {};
-template <class T> struct is_non_const_reference<T&> : true_type {};
-template <class T> struct is_non_const_reference<const T&> : false_type {};
-
-template <class T> struct is_const : false_type {};
-template <class T> struct is_const<const T> : true_type {};
-
-template <class T> struct is_void : false_type {};
-template <> struct is_void<void> : true_type {};
+template <class T> struct is_non_const_reference : std::false_type {};
+template <class T> struct is_non_const_reference<T&> : std::true_type {};
+template <class T> struct is_non_const_reference<const T&> : std::false_type {};
namespace internal {
@@ -66,63 +26,8 @@
YesType dummy[2];
};
-// This class is an implementation detail for is_convertible, and you
-// don't need to know how it works to use is_convertible. For those
-// who care: we declare two different functions, one whose argument is
-// of type To and one with a variadic argument list. We give them
-// return types of different size, so we can use sizeof to trick the
-// compiler into telling us which function it would have chosen if we
-// had called it with an argument of type From. See Alexandrescu's
-// _Modern C++ Design_ for more details on this sort of trick.
-
-struct ConvertHelper {
- template <typename To>
- static YesType Test(To);
-
- template <typename To>
- static NoType Test(...);
-
- template <typename From>
- static From& Create();
-};
-
-// Used to determine if a type is a struct/union/class. Inspired by Boost's
-// is_class type_trait implementation.
-struct IsClassHelper {
- template <typename C>
- static YesType Test(void(C::*)(void));
-
- template <typename C>
- static NoType Test(...);
-};
-
} // namespace internal
-// Inherits from true_type if From is convertible to To, false_type otherwise.
-//
-// Note that if the type is convertible, this will be a true_type REGARDLESS
-// of whether or not the conversion would emit a warning.
-template <typename From, typename To>
-struct is_convertible
- : integral_constant<bool,
- sizeof(internal::ConvertHelper::Test<To>(
- internal::ConvertHelper::Create<From>())) ==
- sizeof(internal::YesType)> {
-};
-
-template <typename T>
-struct is_class
- : integral_constant<bool,
- sizeof(internal::IsClassHelper::Test<T>(0)) ==
- sizeof(internal::YesType)> {
-};
-
-template<bool B, class T = void>
-struct enable_if {};
-
-template<class T>
-struct enable_if<true, T> { typedef T type; };
-
} // namespace base
#endif // BASE_TEMPLATE_UTIL_H_
diff --git a/libweave/external/base/template_util_unittest.cc b/libweave/external/base/template_util_unittest.cc
index 3ec3887..7c86355 100644
--- a/libweave/external/base/template_util_unittest.cc
+++ b/libweave/external/base/template_util_unittest.cc
@@ -4,8 +4,9 @@
#include "base/template_util.h"
+#include <gtest/gtest.h>
+
#include "base/basictypes.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
@@ -17,6 +18,13 @@
class Parent {};
class Child : public Parent {};
+using std::is_pointer;
+using std::is_array;
+using std::is_convertible;
+using std::is_same;
+using std::is_class;
+using std::is_member_function_pointer;
+
// is_pointer<Type>
COMPILE_ASSERT(!is_pointer<int>::value, IsPointer);
COMPILE_ASSERT(!is_pointer<int&>::value, IsPointer);
diff --git a/libweave/external/base/time/time.cc b/libweave/external/base/time/time.cc
index 8cbb382..7006407 100644
--- a/libweave/external/base/time/time.cc
+++ b/libweave/external/base/time/time.cc
@@ -10,10 +10,8 @@
#include <ostream>
#include <sstream>
-#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/strings/stringprintf.h"
-#include "base/third_party/nspr/prtime.h"
namespace base {
@@ -246,27 +244,6 @@
return FromLocalExploded(exploded);
}
-// static
-bool Time::FromStringInternal(const char* time_string,
- bool is_local,
- Time* parsed_time) {
- DCHECK((time_string != NULL) && (parsed_time != NULL));
-
- if (time_string[0] == '\0')
- return false;
-
- PRTime result_time = 0;
- PRStatus result = PR_ParseTimeString(time_string,
- is_local ? PR_FALSE : PR_TRUE,
- &result_time);
- if (PR_SUCCESS != result)
- return false;
-
- result_time += kTimeTToMicrosecondsOffset;
- *parsed_time = Time(result_time);
- return true;
-}
-
std::ostream& operator<<(std::ostream& os, Time time) {
Time::Exploded exploded;
time.UTCExplode(&exploded);
@@ -296,14 +273,6 @@
DISALLOW_COPY_AND_ASSIGN(UnixEpochSingleton);
};
-static LazyInstance<UnixEpochSingleton>::Leaky
- leaky_unix_epoch_singleton_instance = LAZY_INSTANCE_INITIALIZER;
-
-// Static
-TimeTicks TimeTicks::UnixEpoch() {
- return leaky_unix_epoch_singleton_instance.Get().unix_epoch();
-}
-
TimeTicks TimeTicks::SnappedToNextTick(TimeTicks tick_phase,
TimeDelta tick_interval) const {
// |interval_offset| is the offset from |this| to the next multiple of
diff --git a/libweave/external/base/time/time.h b/libweave/external/base/time/time.h
index a02fbeb..8764d6f 100644
--- a/libweave/external/base/time/time.h
+++ b/libweave/external/base/time/time.h
@@ -61,8 +61,8 @@
#include "base/base_export.h"
#include "base/basictypes.h"
+#include "base/build/build_config.h"
#include "base/numerics/safe_math.h"
-#include "build/build_config.h"
#if defined(OS_MACOSX)
#include <CoreFoundation/CoreFoundation.h>
@@ -539,21 +539,6 @@
return FromExploded(true, exploded);
}
- // Converts a string representation of time to a Time object.
- // An example of a time string which is converted is as below:-
- // "Tue, 15 Nov 1994 12:45:26 GMT". If the timezone is not specified
- // in the input string, FromString assumes local time and FromUTCString
- // assumes UTC. A timezone that cannot be parsed (e.g. "UTC" which is not
- // specified in RFC822) is treated as if the timezone is not specified.
- // TODO(iyengar) Move the FromString/FromTimeT/ToTimeT/FromFileTime to
- // a new time converter class.
- static bool FromString(const char* time_string, Time* parsed_time) {
- return FromStringInternal(time_string, true, parsed_time);
- }
- static bool FromUTCString(const char* time_string, Time* parsed_time) {
- return FromStringInternal(time_string, false, parsed_time);
- }
-
// Fills the given exploded structure with either the local time or UTC from
// this time structure (containing UTC).
void UTCExplode(Exploded* exploded) const {
@@ -580,17 +565,6 @@
// Unexplodes a given time assuming the source is either local time
// |is_local = true| or UTC |is_local = false|.
static Time FromExploded(bool is_local, const Exploded& exploded);
-
- // Converts a string representation of time to a Time object.
- // An example of a time string which is converted is as below:-
- // "Tue, 15 Nov 1994 12:45:26 GMT". If the timezone is not specified
- // in the input string, local time |is_local = true| or
- // UTC |is_local = false| is assumed. A timezone that cannot be parsed
- // (e.g. "UTC" which is not specified in RFC822) is treated as if the
- // timezone is not specified.
- static bool FromStringInternal(const char* time_string,
- bool is_local,
- Time* parsed_time);
};
// Inline the TimeDelta factory methods, for fast TimeDelta construction.
diff --git a/libweave/external/base/time/time_posix.cc b/libweave/external/base/time/time_posix.cc
index fc82c62..b625af6 100644
--- a/libweave/external/base/time/time_posix.cc
+++ b/libweave/external/base/time/time_posix.cc
@@ -16,28 +16,12 @@
#include <ostream>
#include "base/basictypes.h"
+#include "base/build/build_config.h"
#include "base/logging.h"
-#include "build/build_config.h"
-
-#if defined(OS_ANDROID)
-#include "base/os_compat_android.h"
-#elif defined(OS_NACL)
-#include "base/os_compat_nacl.h"
-#endif
-
-#if !defined(OS_MACOSX)
-#include "base/lazy_instance.h"
-#include "base/synchronization/lock.h"
-#endif
namespace {
#if !defined(OS_MACOSX)
-// This prevents a crash on traversing the environment global and looking up
-// the 'TZ' variable in libc. See: crbug.com/390567.
-base::LazyInstance<base::Lock>::Leaky
- g_sys_time_to_time_struct_lock = LAZY_INSTANCE_INITIALIZER;
-
// Define a system-specific SysTime that wraps either to a time_t or
// a time64_t depending on the host system, and associated convertion.
// See crbug.com/162007
@@ -45,7 +29,6 @@
typedef time64_t SysTime;
SysTime SysTimeFromTimeStruct(struct tm* timestruct, bool is_local) {
- base::AutoLock locked(g_sys_time_to_time_struct_lock.Get());
if (is_local)
return mktime64(timestruct);
else
@@ -53,7 +36,6 @@
}
void SysTimeToTimeStruct(SysTime t, struct tm* timestruct, bool is_local) {
- base::AutoLock locked(g_sys_time_to_time_struct_lock.Get());
if (is_local)
localtime64_r(&t, timestruct);
else
@@ -64,7 +46,6 @@
typedef time_t SysTime;
SysTime SysTimeFromTimeStruct(struct tm* timestruct, bool is_local) {
- base::AutoLock locked(g_sys_time_to_time_struct_lock.Get());
if (is_local)
return mktime(timestruct);
else
@@ -72,7 +53,6 @@
}
void SysTimeToTimeStruct(SysTime t, struct tm* timestruct, bool is_local) {
- base::AutoLock locked(g_sys_time_to_time_struct_lock.Get());
if (is_local)
localtime_r(&t, timestruct);
else
@@ -154,7 +134,7 @@
struct timezone tz = { 0, 0 }; // UTC
if (gettimeofday(&tv, &tz) != 0) {
DCHECK(0) << "Could not determine time of day";
- PLOG(ERROR) << "Call to gettimeofday failed.";
+ LOG(ERROR) << "Call to gettimeofday failed.";
// Return null instead of uninitialized |tv| value, which contains random
// garbage data. This may result in the crash seen in crbug.com/147570.
return Time();
diff --git a/libweave/external/base/time/time_unittest.cc b/libweave/external/base/time/time_unittest.cc
index b7e05b7..43373e7 100644
--- a/libweave/external/base/time/time_unittest.cc
+++ b/libweave/external/base/time/time_unittest.cc
@@ -9,12 +9,12 @@
#include <limits>
#include <string>
+#include <gtest/gtest.h>
+
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/strings/stringprintf.h"
-#include "base/threading/platform_thread.h"
-#include "build/build_config.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "base/build/build_config.h"
namespace base {
@@ -162,201 +162,6 @@
EXPECT_EQ(0, exploded.millisecond);
}
-TEST_F(TimeTest, ParseTimeTest1) {
- time_t current_time = 0;
- time(¤t_time);
-
- const int BUFFER_SIZE = 64;
- struct tm local_time = {0};
- char time_buf[BUFFER_SIZE] = {0};
-#if defined(OS_WIN)
- localtime_s(&local_time, ¤t_time);
- asctime_s(time_buf, arraysize(time_buf), &local_time);
-#elif defined(OS_POSIX)
- localtime_r(¤t_time, &local_time);
- asctime_r(&local_time, time_buf);
-#endif
-
- Time parsed_time;
- EXPECT_TRUE(Time::FromString(time_buf, &parsed_time));
- EXPECT_EQ(current_time, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, DayOfWeekSunday) {
- Time time;
- EXPECT_TRUE(Time::FromString("Sun, 06 May 2012 12:00:00 GMT", &time));
- Time::Exploded exploded;
- time.UTCExplode(&exploded);
- EXPECT_EQ(0, exploded.day_of_week);
-}
-
-TEST_F(TimeTest, DayOfWeekWednesday) {
- Time time;
- EXPECT_TRUE(Time::FromString("Wed, 09 May 2012 12:00:00 GMT", &time));
- Time::Exploded exploded;
- time.UTCExplode(&exploded);
- EXPECT_EQ(3, exploded.day_of_week);
-}
-
-TEST_F(TimeTest, DayOfWeekSaturday) {
- Time time;
- EXPECT_TRUE(Time::FromString("Sat, 12 May 2012 12:00:00 GMT", &time));
- Time::Exploded exploded;
- time.UTCExplode(&exploded);
- EXPECT_EQ(6, exploded.day_of_week);
-}
-
-TEST_F(TimeTest, ParseTimeTest2) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("Mon, 15 Oct 2007 19:45:00 GMT", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest3) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15 Oct 07 12:45:00", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest4) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15 Oct 07 19:45 GMT", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest5) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("Mon Oct 15 12:45 PDT 2007", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest6) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("Monday, Oct 15, 2007 12:45 PM", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest7) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("10/15/07 12:45:00 PM", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest8) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15-OCT-2007 12:45pm", &parsed_time));
- EXPECT_EQ(comparison_time_local_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest9) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("16 Oct 2007 4:45-JST (Tuesday)", &parsed_time));
- EXPECT_EQ(comparison_time_pdt_, parsed_time);
-}
-
-TEST_F(TimeTest, ParseTimeTest10) {
- Time parsed_time;
- EXPECT_TRUE(Time::FromString("15/10/07 12:45", &parsed_time));
- EXPECT_EQ(parsed_time, comparison_time_local_);
-}
-
-// Test some of edge cases around epoch, etc.
-TEST_F(TimeTest, ParseTimeTestEpoch0) {
- Time parsed_time;
-
- // time_t == epoch == 0
- EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:00 +0100 1970",
- &parsed_time));
- EXPECT_EQ(0, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:00 GMT 1970",
- &parsed_time));
- EXPECT_EQ(0, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpoch1) {
- Time parsed_time;
-
- // time_t == 1 second after epoch == 1
- EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:01 +0100 1970",
- &parsed_time));
- EXPECT_EQ(1, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:01 GMT 1970",
- &parsed_time));
- EXPECT_EQ(1, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpoch2) {
- Time parsed_time;
-
- // time_t == 2 seconds after epoch == 2
- EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:02 +0100 1970",
- &parsed_time));
- EXPECT_EQ(2, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:02 GMT 1970",
- &parsed_time));
- EXPECT_EQ(2, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpochNeg1) {
- Time parsed_time;
-
- // time_t == 1 second before epoch == -1
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:59 +0100 1970",
- &parsed_time));
- EXPECT_EQ(-1, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 1969",
- &parsed_time));
- EXPECT_EQ(-1, parsed_time.ToTimeT());
-}
-
-// If time_t is 32 bits, a date after year 2038 will overflow time_t and
-// cause timegm() to return -1. The parsed time should not be 1 second
-// before epoch.
-TEST_F(TimeTest, ParseTimeTestEpochNotNeg1) {
- Time parsed_time;
-
- EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 2100",
- &parsed_time));
- EXPECT_NE(-1, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpochNeg2) {
- Time parsed_time;
-
- // time_t == 2 seconds before epoch == -2
- EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:58 +0100 1970",
- &parsed_time));
- EXPECT_EQ(-2, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:58 GMT 1969",
- &parsed_time));
- EXPECT_EQ(-2, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEpoch1960) {
- Time parsed_time;
-
- // time_t before Epoch, in 1960
- EXPECT_TRUE(Time::FromString("Wed Jun 29 19:40:01 +0100 1960",
- &parsed_time));
- EXPECT_EQ(-299999999, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Jun 29 18:40:01 GMT 1960",
- &parsed_time));
- EXPECT_EQ(-299999999, parsed_time.ToTimeT());
- EXPECT_TRUE(Time::FromString("Wed Jun 29 17:40:01 GMT 1960",
- &parsed_time));
- EXPECT_EQ(-300003599, parsed_time.ToTimeT());
-}
-
-TEST_F(TimeTest, ParseTimeTestEmpty) {
- Time parsed_time;
- EXPECT_FALSE(Time::FromString("", &parsed_time));
-}
-
-TEST_F(TimeTest, ParseTimeTestInvalidString) {
- Time parsed_time;
- EXPECT_FALSE(Time::FromString("Monday morning 2000", &parsed_time));
-}
-
TEST_F(TimeTest, ExplodeBeforeUnixEpoch) {
static const int kUnixEpochYear = 1970; // In case this changes (ha!).
Time t;
@@ -615,33 +420,6 @@
}
#endif // OS_ANDROID
-TEST(TimeTicks, Deltas) {
- for (int index = 0; index < 50; index++) {
- TimeTicks ticks_start = TimeTicks::Now();
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
- TimeTicks ticks_stop = TimeTicks::Now();
- TimeDelta delta = ticks_stop - ticks_start;
- // Note: Although we asked for a 10ms sleep, if the
- // time clock has a finer granularity than the Sleep()
- // clock, it is quite possible to wakeup early. Here
- // is how that works:
- // Time(ms timer) Time(us timer)
- // 5 5010
- // 6 6010
- // 7 7010
- // 8 8010
- // 9 9000
- // Elapsed 4ms 3990us
- //
- // Unfortunately, our InMilliseconds() function truncates
- // rather than rounds. We should consider fixing this
- // so that our averages come out better.
- EXPECT_GE(delta.InMilliseconds(), 9);
- EXPECT_GE(delta.InMicroseconds(), 9000);
- EXPECT_EQ(delta.InSeconds(), 0);
- }
-}
-
static void HighResClockTest(TimeTicks (*GetTicks)()) {
// IsHighResolution() is false on some systems. Since the product still works
// even if it's false, it makes this entire test questionable.
@@ -683,33 +461,6 @@
HighResClockTest(&TimeTicks::Now);
}
-// Fails frequently on Android http://crbug.com/352633 with:
-// Expected: (delta_thread.InMicroseconds()) > (0), actual: 0 vs 0
-#if defined(OS_ANDROID)
-#define MAYBE_ThreadNow DISABLED_ThreadNow
-#else
-#define MAYBE_ThreadNow ThreadNow
-#endif
-TEST(ThreadTicks, MAYBE_ThreadNow) {
- if (ThreadTicks::IsSupported()) {
- TimeTicks begin = TimeTicks::Now();
- ThreadTicks begin_thread = ThreadTicks::Now();
- // Make sure that ThreadNow value is non-zero.
- EXPECT_GT(begin_thread, ThreadTicks());
- // Sleep for 10 milliseconds to get the thread de-scheduled.
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
- ThreadTicks end_thread = ThreadTicks::Now();
- TimeTicks end = TimeTicks::Now();
- TimeDelta delta = end - begin;
- TimeDelta delta_thread = end_thread - begin_thread;
- // Make sure that some thread time have elapsed.
- EXPECT_GT(delta_thread.InMicroseconds(), 0);
- // But the thread time is at least 9ms less than clock time.
- TimeDelta difference = delta - delta_thread;
- EXPECT_GE(difference.InMicroseconds(), 9000);
- }
-}
-
TEST(TraceTicks, NowFromSystemTraceTime) {
// Re-use HighRes test for now since clock properties are identical.
using NowFunction = TimeTicks (*)(void);
@@ -1050,12 +801,6 @@
DCHECK_EQ(Time(), Time());
}
-TEST(TimeLogging, ChromeBirthdate) {
- Time birthdate;
- ASSERT_TRUE(Time::FromString("Tue, 02 Sep 2008 09:42:18 GMT", &birthdate));
- EXPECT_EQ("2008-09-02 09:42:18.000 UTC", AnyToString(birthdate));
-}
-
TEST(TimeLogging, DoesNotMessUpFormattingFlags) {
std::ostringstream oss;
std::ios_base::fmtflags flags_before = oss.flags();
diff --git a/libweave/external/base/tuple_unittest.cc b/libweave/external/base/tuple_unittest.cc
index 55a9139..668c115 100644
--- a/libweave/external/base/tuple_unittest.cc
+++ b/libweave/external/base/tuple_unittest.cc
@@ -4,8 +4,9 @@
#include "base/tuple.h"
+#include <gtest/gtest.h>
+
#include "base/compiler_specific.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
diff --git a/libweave/external/base/values.cc b/libweave/external/base/values.cc
index 4534d27..689fdd7 100644
--- a/libweave/external/base/values.cc
+++ b/libweave/external/base/values.cc
@@ -14,7 +14,7 @@
#include "base/logging.h"
#include "base/move.h"
#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
+#include "base/strings/utf_string_conversion_utils.h"
namespace base {
@@ -112,10 +112,6 @@
return false;
}
-bool Value::GetAsString(string16* out_value) const {
- return false;
-}
-
bool Value::GetAsString(const StringValue** out_value) const {
return false;
}
@@ -260,11 +256,6 @@
DCHECK(IsStringUTF8(in_value));
}
-StringValue::StringValue(const string16& in_value)
- : Value(TYPE_STRING),
- value_(UTF16ToUTF8(in_value)) {
-}
-
StringValue::~StringValue() {
}
@@ -282,12 +273,6 @@
return true;
}
-bool StringValue::GetAsString(string16* out_value) const {
- if (out_value)
- *out_value = UTF8ToUTF16(value_);
- return true;
-}
-
bool StringValue::GetAsString(const StringValue** out_value) const {
if (out_value)
*out_value = this;
@@ -433,11 +418,6 @@
Set(path, new StringValue(in_value));
}
-void DictionaryValue::SetString(const std::string& path,
- const string16& in_value) {
- Set(path, new StringValue(in_value));
-}
-
void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
scoped_ptr<Value> in_value) {
Value* bare_ptr = in_value.release();
@@ -477,11 +457,6 @@
SetWithoutPathExpansion(path, new StringValue(in_value));
}
-void DictionaryValue::SetStringWithoutPathExpansion(
- const std::string& path, const string16& in_value) {
- SetWithoutPathExpansion(path, new StringValue(in_value));
-}
-
bool DictionaryValue::Get(const std::string& path,
const Value** out_value) const {
DCHECK(IsStringUTF8(path));
@@ -544,15 +519,6 @@
return value->GetAsString(out_value);
}
-bool DictionaryValue::GetString(const std::string& path,
- string16* out_value) const {
- const Value* value;
- if (!Get(path, &value))
- return false;
-
- return value->GetAsString(out_value);
-}
-
bool DictionaryValue::GetStringASCII(const std::string& path,
std::string* out_value) const {
std::string out;
@@ -684,15 +650,6 @@
return value->GetAsString(out_value);
}
-bool DictionaryValue::GetStringWithoutPathExpansion(const std::string& key,
- string16* out_value) const {
- const Value* value;
- if (!GetWithoutPathExpansion(key, &value))
- return false;
-
- return value->GetAsString(out_value);
-}
-
bool DictionaryValue::GetDictionaryWithoutPathExpansion(
const std::string& key,
const DictionaryValue** out_value) const {
@@ -949,14 +906,6 @@
return value->GetAsString(out_value);
}
-bool ListValue::GetString(size_t index, string16* out_value) const {
- const Value* value;
- if (!Get(index, &value))
- return false;
-
- return value->GetAsString(out_value);
-}
-
bool ListValue::GetBinary(size_t index, const BinaryValue** out_value) const {
const Value* value;
bool result = Get(index, &value);
@@ -1075,10 +1024,6 @@
Append(new StringValue(in_value));
}
-void ListValue::AppendString(const string16& in_value) {
- Append(new StringValue(in_value));
-}
-
void ListValue::AppendStrings(const std::vector<std::string>& in_values) {
for (std::vector<std::string>::const_iterator it = in_values.begin();
it != in_values.end(); ++it) {
@@ -1086,13 +1031,6 @@
}
}
-void ListValue::AppendStrings(const std::vector<string16>& in_values) {
- for (std::vector<string16>::const_iterator it = in_values.begin();
- it != in_values.end(); ++it) {
- AppendString(*it);
- }
-}
-
bool ListValue::AppendIfNotPresent(Value* in_value) {
DCHECK(in_value);
for (ValueVector::const_iterator i(list_.begin()); i != list_.end(); ++i) {
@@ -1166,12 +1104,6 @@
return true;
}
-ValueSerializer::~ValueSerializer() {
-}
-
-ValueDeserializer::~ValueDeserializer() {
-}
-
std::ostream& operator<<(std::ostream& out, const Value& value) {
std::string json;
JSONWriter::WriteWithOptions(value, JSONWriter::OPTIONS_PRETTY_PRINT, &json);
diff --git a/libweave/external/base/values.h b/libweave/external/base/values.h
index 7feef9d..b95af6d 100644
--- a/libweave/external/base/values.h
+++ b/libweave/external/base/values.h
@@ -29,7 +29,6 @@
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
-#include "base/strings/string16.h"
namespace base {
@@ -84,7 +83,6 @@
virtual bool GetAsInteger(int* out_value) const;
virtual bool GetAsDouble(double* out_value) const;
virtual bool GetAsString(std::string* out_value) const;
- virtual bool GetAsString(string16* out_value) const;
virtual bool GetAsString(const StringValue** out_value) const;
virtual bool GetAsBinary(const BinaryValue** out_value) const;
virtual bool GetAsList(ListValue** out_value);
@@ -149,9 +147,6 @@
// Initializes a StringValue with a UTF-8 narrow character string.
explicit StringValue(const std::string& in_value);
- // Initializes a StringValue with a string16.
- explicit StringValue(const string16& in_value);
-
~StringValue() override;
// Returns |value_| as a pointer or reference.
@@ -160,7 +155,6 @@
// Overridden from Value:
bool GetAsString(std::string* out_value) const override;
- bool GetAsString(string16* out_value) const override;
bool GetAsString(const StringValue** out_value) const override;
StringValue* DeepCopy() const override;
bool Equals(const Value* other) const override;
@@ -244,7 +238,6 @@
void SetInteger(const std::string& path, int in_value);
void SetDouble(const std::string& path, double in_value);
void SetString(const std::string& path, const std::string& in_value);
- void SetString(const std::string& path, const string16& in_value);
// Like Set(), but without special treatment of '.'. This allows e.g. URLs to
// be used as paths.
@@ -259,8 +252,6 @@
void SetDoubleWithoutPathExpansion(const std::string& path, double in_value);
void SetStringWithoutPathExpansion(const std::string& path,
const std::string& in_value);
- void SetStringWithoutPathExpansion(const std::string& path,
- const string16& in_value);
// Gets the Value associated with the given path starting from this object.
// A path has the form "<key>" or "<key>.<key>.[...]", where "." indexes
@@ -283,7 +274,6 @@
// doubles.
bool GetDouble(const std::string& path, double* out_value) const;
bool GetString(const std::string& path, std::string* out_value) const;
- bool GetString(const std::string& path, string16* out_value) const;
bool GetStringASCII(const std::string& path, std::string* out_value) const;
bool GetBinary(const std::string& path, const BinaryValue** out_value) const;
bool GetBinary(const std::string& path, BinaryValue** out_value);
@@ -306,8 +296,6 @@
double* out_value) const;
bool GetStringWithoutPathExpansion(const std::string& key,
std::string* out_value) const;
- bool GetStringWithoutPathExpansion(const std::string& key,
- string16* out_value) const;
bool GetDictionaryWithoutPathExpansion(
const std::string& key,
const DictionaryValue** out_value) const;
@@ -424,7 +412,6 @@
// doubles.
bool GetDouble(size_t index, double* out_value) const;
bool GetString(size_t index, std::string* out_value) const;
- bool GetString(size_t index, string16* out_value) const;
bool GetBinary(size_t index, const BinaryValue** out_value) const;
bool GetBinary(size_t index, BinaryValue** out_value);
bool GetDictionary(size_t index, const DictionaryValue** out_value) const;
@@ -460,9 +447,7 @@
void AppendInteger(int in_value);
void AppendDouble(double in_value);
void AppendString(const std::string& in_value);
- void AppendString(const string16& in_value);
void AppendStrings(const std::vector<std::string>& in_values);
- void AppendStrings(const std::vector<string16>& in_values);
// Appends a Value if it's not already present. Takes ownership of the
// |in_value|. Returns true if successful, or false if the value was already
@@ -503,30 +488,6 @@
DISALLOW_COPY_AND_ASSIGN(ListValue);
};
-// This interface is implemented by classes that know how to serialize
-// Value objects.
-class BASE_EXPORT ValueSerializer {
- public:
- virtual ~ValueSerializer();
-
- virtual bool Serialize(const Value& root) = 0;
-};
-
-// This interface is implemented by classes that know how to deserialize Value
-// objects.
-class BASE_EXPORT ValueDeserializer {
- public:
- virtual ~ValueDeserializer();
-
- // This method deserializes the subclass-specific format into a Value object.
- // If the return value is non-NULL, the caller takes ownership of returned
- // Value. If the return value is NULL, and if error_code is non-NULL,
- // error_code will be set with the underlying error.
- // If |error_message| is non-null, it will be filled in with a formatted
- // error message including the location of the error if appropriate.
- virtual Value* Deserialize(int* error_code, std::string* error_str) = 0;
-};
-
// Stream operator so Values can be used in assertion statements. In order that
// gtest uses this operator to print readable output on test failures, we must
// override each specific type. Otherwise, the default template implementation
diff --git a/libweave/external/base/values_unittest.cc b/libweave/external/base/values_unittest.cc
index 37ed7ce..d246691 100644
--- a/libweave/external/base/values_unittest.cc
+++ b/libweave/external/base/values_unittest.cc
@@ -4,11 +4,11 @@
#include <limits>
+#include <gtest/gtest.h>
+
#include "base/memory/scoped_ptr.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
+#include "base/strings/utf_string_conversion_utils.h"
#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
namespace base {
@@ -141,30 +141,16 @@
scoped_ptr<Value> narrow_value(new StringValue("narrow"));
ASSERT_TRUE(narrow_value.get());
ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING));
- scoped_ptr<Value> utf16_value(new StringValue(ASCIIToUTF16("utf16")));
- ASSERT_TRUE(utf16_value.get());
- ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING));
// Test overloaded GetAsString.
std::string narrow = "http://google.com";
- string16 utf16 = ASCIIToUTF16("http://google.com");
const StringValue* string_value = NULL;
ASSERT_TRUE(narrow_value->GetAsString(&narrow));
- ASSERT_TRUE(narrow_value->GetAsString(&utf16));
ASSERT_TRUE(narrow_value->GetAsString(&string_value));
ASSERT_EQ(std::string("narrow"), narrow);
- ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
- ASSERT_EQ(string_value->GetString(), narrow);
-
- ASSERT_TRUE(utf16_value->GetAsString(&narrow));
- ASSERT_TRUE(utf16_value->GetAsString(&utf16));
- ASSERT_TRUE(utf16_value->GetAsString(&string_value));
- ASSERT_EQ(std::string("utf16"), narrow);
- ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
ASSERT_EQ(string_value->GetString(), narrow);
// Don't choke on NULL values.
- ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL)));
ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL)));
ASSERT_TRUE(narrow_value->GetAsString(
static_cast<const StringValue**>(NULL)));
@@ -406,10 +392,6 @@
scoped_ptr<StringValue> scoped_string(new StringValue("hello"));
StringValue* original_string = scoped_string.get();
original_dict.Set("string", scoped_string.Pass());
- scoped_ptr<StringValue> scoped_string16(
- new StringValue(ASCIIToUTF16("hello16")));
- StringValue* original_string16 = scoped_string16.get();
- original_dict.Set("string16", scoped_string16.Pass());
scoped_ptr<char[]> original_buffer(new char[42]);
memset(original_buffer.get(), '!', 42);
@@ -476,21 +458,6 @@
ASSERT_NE(copy_string, original_string);
ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING));
std::string copy_string_value;
- string16 copy_string16_value;
- ASSERT_TRUE(copy_string->GetAsString(©_string_value));
- ASSERT_TRUE(copy_string->GetAsString(©_string16_value));
- ASSERT_EQ(std::string("hello"), copy_string_value);
- ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value);
-
- Value* copy_string16 = NULL;
- ASSERT_TRUE(copy_dict->Get("string16", ©_string16));
- ASSERT_TRUE(copy_string16);
- ASSERT_NE(copy_string16, original_string16);
- ASSERT_TRUE(copy_string16->IsType(Value::TYPE_STRING));
- ASSERT_TRUE(copy_string16->GetAsString(©_string_value));
- ASSERT_TRUE(copy_string16->GetAsString(©_string16_value));
- ASSERT_EQ(std::string("hello16"), copy_string_value);
- ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value);
Value* copy_binary = NULL;
ASSERT_TRUE(copy_dict->Get("binary", ©_binary));
@@ -556,7 +523,6 @@
dv.SetInteger("b", 2);
dv.SetDouble("c", 2.5);
dv.SetString("d1", "string");
- dv.SetString("d2", ASCIIToUTF16("http://google.com"));
dv.Set("e", Value::CreateNullValue());
scoped_ptr<DictionaryValue> copy = dv.CreateDeepCopy();
@@ -624,10 +590,6 @@
scoped_ptr<StringValue> scoped_string(new StringValue("hello"));
Value* original_string = scoped_string.get();
original_dict.Set("string", scoped_string.Pass());
- scoped_ptr<StringValue> scoped_string16(
- new StringValue(ASCIIToUTF16("hello16")));
- Value* original_string16 = scoped_string16.get();
- original_dict.Set("string16", scoped_string16.Pass());
scoped_ptr<char[]> original_buffer(new char[42]);
memset(original_buffer.get(), '!', 42);
@@ -650,7 +612,6 @@
scoped_ptr<Value> copy_int = original_int->CreateDeepCopy();
scoped_ptr<Value> copy_double = original_double->CreateDeepCopy();
scoped_ptr<Value> copy_string = original_string->CreateDeepCopy();
- scoped_ptr<Value> copy_string16 = original_string16->CreateDeepCopy();
scoped_ptr<Value> copy_binary = original_binary->CreateDeepCopy();
scoped_ptr<Value> copy_list = original_list->CreateDeepCopy();
@@ -660,7 +621,6 @@
EXPECT_TRUE(original_int->Equals(copy_int.get()));
EXPECT_TRUE(original_double->Equals(copy_double.get()));
EXPECT_TRUE(original_string->Equals(copy_string.get()));
- EXPECT_TRUE(original_string16->Equals(copy_string16.get()));
EXPECT_TRUE(original_binary->Equals(copy_binary.get()));
EXPECT_TRUE(original_list->Equals(copy_list.get()));
}
@@ -933,15 +893,6 @@
EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(NULL)));
EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(NULL)));
- EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(NULL)));
- EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(NULL)));
-
EXPECT_FALSE(main_dict.GetBinary("bool", NULL));
EXPECT_FALSE(main_dict.GetBinary("int", NULL));
EXPECT_FALSE(main_dict.GetBinary("double", NULL));
@@ -1022,23 +973,6 @@
EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
"DNE", static_cast<std::string*>(NULL)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "bool", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "int", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "double", static_cast<string16*>(NULL)));
- EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
- "string", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "binary", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "dict", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "list", static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
- "DNE", static_cast<string16*>(NULL)));
-
// There is no GetBinaryWithoutPathExpansion for some reason, but if there
// were it should be tested here...
@@ -1105,15 +1039,6 @@
EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(NULL)));
EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(NULL)));
- EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(NULL)));
- EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(NULL)));
- EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(NULL)));
-
EXPECT_FALSE(main_list.GetBinary(0, NULL));
EXPECT_FALSE(main_list.GetBinary(1, NULL));
EXPECT_FALSE(main_list.GetBinary(2, NULL));
