Remove another pile of unused stuff
Change-Id: I926511deb046064b1c857e15a331bc73b53c97dc
Reviewed-on: https://gn-review.googlesource.com/1622
Commit-Queue: Scott Graham <scottmg@chromium.org>
Reviewed-by: Brett Wilson <brettw@chromium.org>
diff --git a/base/OWNERS b/base/OWNERS
deleted file mode 100644
index 21d1970..0000000
--- a/base/OWNERS
+++ /dev/null
@@ -1,52 +0,0 @@
-# About src/base:
-#
-# Chromium is a very mature project, most things that are generally useful are
-# already here, and that things not here aren't generally useful.
-#
-# Base is pulled into many projects. For example, various ChromeOS daemons. So
-# the bar for adding stuff is that it must have demonstrated wide
-# applicability. Prefer to add things closer to where they're used (i.e. "not
-# base"), and pull into base only when needed. In a project our size,
-# sometimes even duplication is OK and inevitable.
-#
-# Adding a new logging macro DPVELOG_NE is not more clear than just
-# writing the stuff you want to log in a regular logging statement, even
-# if it makes your calling code longer. Just add it to your own code.
-#
-# If the code in question does not need to be used inside base, but will have
-# multiple consumers across the codebase, consider placing it in a new directory
-# under components/ instead.
-
-danakj@chromium.org
-dcheng@chromium.org
-gab@chromium.org
-mark@chromium.org
-thakis@chromium.org
-thestig@chromium.org
-
-# For Bind/Callback:
-per-file bind*=tzik@chromium.org
-per-file callback*=tzik@chromium.org
-
-# For Android-specific changes:
-per-file *android*=file://base/android/OWNERS
-per-file BUILD.gn=file://base/android/OWNERS
-
-# For Fuchsia-specific changes:
-per-file *_fuchsia*=file://build/fuchsia/OWNERS
-
-# For FeatureList API:
-per-file feature_list*=asvitkine@chromium.org
-per-file feature_list*=isherman@chromium.org
-
-# Restricted since rand_util.h also backs the cryptographically secure RNG.
-per-file rand_util*=set noparent
-per-file rand_util*=file://ipc/SECURITY_OWNERS
-
-# For TCMalloc tests:
-per-file security_unittest.cc=jln@chromium.org
-
-# For Value:
-per-file values*=jdoerrie@chromium.org
-
-# COMPONENT: Internals>Core
diff --git a/base/auto_reset.h b/base/auto_reset.h
deleted file mode 100644
index 8515fe9..0000000
--- a/base/auto_reset.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_AUTO_RESET_H_
-#define BASE_AUTO_RESET_H_
-
-#include <utility>
-
-#include "base/macros.h"
-
-// base::AutoReset<> is useful for setting a variable to a new value only within
-// a particular scope. An base::AutoReset<> object resets a variable to its
-// original value upon destruction, making it an alternative to writing
-// "var = false;" or "var = old_val;" at all of a block's exit points.
-//
-// This should be obvious, but note that an base::AutoReset<> instance should
-// have a shorter lifetime than its scoped_variable, to prevent invalid memory
-// writes when the base::AutoReset<> object is destroyed.
-
-namespace base {
-
-template<typename T>
-class AutoReset {
- public:
- AutoReset(T* scoped_variable, T new_value)
- : scoped_variable_(scoped_variable),
- original_value_(std::move(*scoped_variable)) {
- *scoped_variable_ = std::move(new_value);
- }
-
- ~AutoReset() { *scoped_variable_ = std::move(original_value_); }
-
- private:
- T* scoped_variable_;
- T original_value_;
-
- DISALLOW_COPY_AND_ASSIGN(AutoReset);
-};
-
-} // namespace base
-
-#endif // BASE_AUTO_RESET_H_
diff --git a/base/containers/OWNERS b/base/containers/OWNERS
deleted file mode 100644
index cc39b28..0000000
--- a/base/containers/OWNERS
+++ /dev/null
@@ -1,3 +0,0 @@
-danakj@chromium.org
-dcheng@chromium.org
-vmpstr@chromium.org
diff --git a/base/containers/README.md b/base/containers/README.md
deleted file mode 100644
index 092a264..0000000
--- a/base/containers/README.md
+++ /dev/null
@@ -1,295 +0,0 @@
-# base/containers library
-
-## What goes here
-
-This directory contains some STL-like containers.
-
-Things should be moved here that are generally applicable across the code base.
-Don't add things here just because you need them in one place and think others
-may someday want something similar. You can put specialized containers in
-your component's directory and we can promote them here later if we feel there
-is broad applicability.
-
-### Design and naming
-
-Containers should adhere as closely to STL as possible. Functions and behaviors
-not present in STL should only be added when they are related to the specific
-data structure implemented by the container.
-
-For STL-like containers our policy is that they should use STL-like naming even
-when it may conflict with the style guide. So functions and class names should
-be lower case with underscores. Non-STL-like classes and functions should use
-Google naming. Be sure to use the base namespace.
-
-## Map and set selection
-
-### Usage advice
-
- * Generally avoid **std::unordered\_set** and **std::unordered\_map**. In the
- common case, query performance is unlikely to be sufficiently higher than
- std::map to make a difference, insert performance is slightly worse, and
- the memory overhead is high. This makes sense mostly for large tables where
- you expect a lot of lookups.
-
- * Most maps and sets in Chrome are small and contain objects that can be
- moved efficiently. In this case, consider **base::flat\_map** and
- **base::flat\_set**. You need to be aware of the maximum expected size of
- the container since individual inserts and deletes are O(n), giving O(n^2)
- construction time for the entire map. But because it avoids mallocs in most
- cases, inserts are better or comparable to other containers even for
- several dozen items, and efficiently-moved types are unlikely to have
- performance problems for most cases until you have hundreds of items. If
- your container can be constructed in one shot, the constructor from vector
- gives O(n log n) construction times and it should be strictly better than
- a std::map.
-
- * **base::small\_map** has better runtime memory usage without the poor
- mutation performance of large containers that base::flat\_map has. But this
- advantage is partially offset by additional code size. Prefer in cases
- where you make many objects so that the code/heap tradeoff is good.
-
- * Use **std::map** and **std::set** if you can't decide. Even if they're not
- great, they're unlikely to be bad or surprising.
-
-### Map and set details
-
-Sizes are on 64-bit platforms. Stable iterators aren't invalidated when the
-container is mutated.
-
-| Container | Empty size | Per-item overhead | Stable iterators? |
-|:---------------------------------------- |:--------------------- |:----------------- |:----------------- |
-| std::map, std::set | 16 bytes | 32 bytes | Yes |
-| std::unordered\_map, std::unordered\_set | 128 bytes | 16-24 bytes | No |
-| base::flat\_map and base::flat\_set | 24 bytes | 0 (see notes) | No |
-| base::small\_map | 24 bytes (see notes) | 32 bytes | No |
-
-**Takeaways:** std::unordered\_map and std::unordered\_map have high
-overhead for small container sizes, prefer these only for larger workloads.
-
-Code size comparisons for a block of code (see appendix) on Windows using
-strings as keys.
-
-| Container | Code size |
-|:------------------- |:---------- |
-| std::unordered\_map | 1646 bytes |
-| std::map | 1759 bytes |
-| base::flat\_map | 1872 bytes |
-| base::small\_map | 2410 bytes |
-
-**Takeaways:** base::small\_map generates more code because of the inlining of
-both brute-force and red-black tree searching. This makes it less attractive
-for random one-off uses. But if your code is called frequently, the runtime
-memory benefits will be more important. The code sizes of the other maps are
-close enough it's not worth worrying about.
-
-### std::map and std::set
-
-A red-black tree. Each inserted item requires the memory allocation of a node
-on the heap. Each node contains a left pointer, a right pointer, a parent
-pointer, and a "color" for the red-black tree (32-bytes per item on 64-bits).
-
-### std::unordered\_map and std::unordered\_set
-
-A hash table. Implemented on Windows as a std::vector + std::list and in libc++
-as the equivalent of a std::vector + a std::forward\_list. Both implementations
-allocate an 8-entry hash table (containing iterators into the list) on
-initialization, and grow to 64 entries once 8 items are inserted. Above 64
-items, the size doubles every time the load factor exceeds 1.
-
-The empty size is sizeof(std::unordered\_map) = 64 +
-the initial hash table size which is 8 pointers. The per-item overhead in the
-table above counts the list node (2 pointers on Windows, 1 pointer in libc++),
-plus amortizes the hash table assuming a 0.5 load factor on average.
-
-In a microbenchmark on Windows, inserts of 1M integers into a
-std::unordered\_set took 1.07x the time of std::set, and queries took 0.67x the
-time of std::set. For a typical 4-entry set (the statistical mode of map sizes
-in the browser), query performance is identical to std::set and base::flat\_set.
-On ARM, unordered\_set performance can be worse because integer division to
-compute the bucket is slow, and a few "less than" operations can be faster than
-computing a hash depending on the key type. The takeaway is that you should not
-default to using unordered maps because "they're faster."
-
-### base::flat\_map and base::flat\_set
-
-A sorted std::vector. Seached via binary search, inserts in the middle require
-moving elements to make room. Good cache locality. For large objects and large
-set sizes, std::vector's doubling-when-full strategy can waste memory.
-
-Supports efficient construction from a vector of items which avoids the O(n^2)
-insertion time of each element separately.
-
-The per-item overhead will depend on the underlying std::vector's reallocation
-strategy and the memory access pattern. Assuming items are being linearly added,
-one would expect it to be 3/4 full, so per-item overhead will be 0.25 *
-sizeof(T).
-
-
-flat\_set/flat\_map support a notion of transparent comparisons. Therefore you
-can, for example, lookup base::StringPiece in a set of std::strings without
-constructing a temporary std::string. This functionality is based on C++14
-extensions to std::set/std::map interface.
-
-You can find more information about transparent comparisons here:
-http://en.cppreference.com/w/cpp/utility/functional/less_void
-
-Example, smart pointer set:
-
-```cpp
-// Declare a type alias using base::UniquePtrComparator.
-template <typename T>
-using UniquePtrSet = base::flat_set<std::unique_ptr<T>,
- base::UniquePtrComparator>;
-
-// ...
-// Collect data.
-std::vector<std::unique_ptr<int>> ptr_vec;
-ptr_vec.reserve(5);
-std::generate_n(std::back_inserter(ptr_vec), 5, []{
- return std::make_unique<int>(0);
-});
-
-// Construct a set.
-UniquePtrSet<int> ptr_set(std::move(ptr_vec), base::KEEP_FIRST_OF_DUPES);
-
-// Use raw pointers to lookup keys.
-int* ptr = ptr_set.begin()->get();
-EXPECT_TRUE(ptr_set.find(ptr) == ptr_set.begin());
-```
-
-Example flat_map<std\::string, int>:
-
-```cpp
-base::flat_map<std::string, int> str_to_int({{"a", 1}, {"c", 2},{"b", 2}},
- base::KEEP_FIRST_OF_DUPES);
-
-// Does not construct temporary strings.
-str_to_int.find("c")->second = 3;
-str_to_int.erase("c");
-EXPECT_EQ(str_to_int.end(), str_to_int.find("c")->second);
-
-// NOTE: This does construct a temporary string. This happens since if the
-// item is not in the container, then it needs to be constructed, which is
-// something that transparent comparators don't have to guarantee.
-str_to_int["c"] = 3;
-```
-
-### base::small\_map
-
-A small inline buffer that is brute-force searched that overflows into a full
-std::map or std::unordered\_map. This gives the memory benefit of
-base::flat\_map for small data sizes without the degenerate insertion
-performance for large container sizes.
-
-Since instantiations require both code for a std::map and a brute-force search
-of the inline container, plus a fancy iterator to cover both cases, code size
-is larger.
-
-The initial size in the above table is assuming a very small inline table. The
-actual size will be sizeof(int) + min(sizeof(std::map), sizeof(T) *
-inline\_size).
-
-# Deque
-
-### Usage advice
-
-Chromium code should always use `base::circular_deque` or `base::queue` in
-preference to `std::deque` or `std::queue` due to memory usage and platform
-variation.
-
-The `base::circular_deque` implementation (and the `base::queue` which uses it)
-provide performance consistent across platforms that better matches most
-programmer's expectations on performance (it doesn't waste as much space as
-libc++ and doesn't do as many heap allocations as MSVC). It also generates less
-code tham `std::queue`: using it across the code base saves several hundred
-kilobytes.
-
-Since `base::deque` does not have stable iterators and it will move the objects
-it contains, it may not be appropriate for all uses. If you need these,
-consider using a `std::list` which will provide constant time insert and erase.
-
-### std::deque and std::queue
-
-The implementation of `std::deque` varies considerably which makes it hard to
-reason about. All implementations use a sequence of data blocks referenced by
-an array of pointers. The standard guarantees random access, amortized
-constant operations at the ends, and linear mutations in the middle.
-
-In Microsoft's implementation, each block is the smaller of 16 bytes or the
-size of the contained element. This means in practice that every expansion of
-the deque of non-trivial classes requires a heap allocation. libc++ (on Android
-and Mac) uses 4K blocks which elimiates the problem of many heap allocations,
-but generally wastes a large amount of space (an Android analysis revealed more
-than 2.5MB wasted space from deque alone, resulting in some optimizations).
-libstdc++ uses an intermediate-size 512 byte buffer.
-
-Microsoft's implementation never shrinks the deque capacity, so the capacity
-will always be the maximum number of elements ever contained. libstdc++
-deallocates blocks as they are freed. libc++ keeps up to two empty blocks.
-
-### base::circular_deque and base::queue
-
-A deque implemented as a circular buffer in an array. The underlying array will
-grow like a `std::vector` while the beginning and end of the deque will move
-around. The items will wrap around the underlying buffer so the storage will
-not be contiguous, but fast random access iterators are still possible.
-
-When the underlying buffer is filled, it will be reallocated and the constents
-moved (like a `std::vector`). The underlying buffer will be shrunk if there is
-too much wasted space (_unlike_ a `std::vector`). As a result, iterators are
-not stable across mutations.
-
-# Stack
-
-`std::stack` is like `std::queue` in that it is a wrapper around an underlying
-container. The default container is `std::deque` so everything from the deque
-section applies.
-
-Chromium provides `base/containers/stack.h` which defines `base::stack` that
-should be used in preference to std::stack. This changes the underlying
-container to `base::circular_deque`. The result will be very similar to
-manually specifying a `std::vector` for the underlying implementation except
-that the storage will shrink when it gets too empty (vector will never
-reallocate to a smaller size).
-
-Watch out: with some stack usage patterns it's easy to depend on unstable
-behavior:
-
-```cpp
-base::stack<Foo> stack;
-for (...) {
- Foo& current = stack.top();
- DoStuff(); // May call stack.push(), say if writing a parser.
- current.done = true; // Current may reference deleted item!
-}
-```
-
-## Appendix
-
-### Code for map code size comparison
-
-This just calls insert and query a number of times, with printfs that prevent
-things from being dead-code eliminated.
-
-```cpp
-TEST(Foo, Bar) {
- base::small_map<std::map<std::string, Flubber>> foo;
- foo.insert(std::make_pair("foo", Flubber(8, "bar")));
- foo.insert(std::make_pair("bar", Flubber(8, "bar")));
- foo.insert(std::make_pair("foo1", Flubber(8, "bar")));
- foo.insert(std::make_pair("bar1", Flubber(8, "bar")));
- foo.insert(std::make_pair("foo", Flubber(8, "bar")));
- foo.insert(std::make_pair("bar", Flubber(8, "bar")));
- auto found = foo.find("asdf");
- printf("Found is %d\n", (int)(found == foo.end()));
- found = foo.find("foo");
- printf("Found is %d\n", (int)(found == foo.end()));
- found = foo.find("bar");
- printf("Found is %d\n", (int)(found == foo.end()));
- found = foo.find("asdfhf");
- printf("Found is %d\n", (int)(found == foo.end()));
- found = foo.find("bar1");
- printf("Found is %d\n", (int)(found == foo.end()));
-}
-```
-
diff --git a/base/containers/adapters.h b/base/containers/adapters.h
deleted file mode 100644
index fa671b4..0000000
--- a/base/containers/adapters.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_ADAPTERS_H_
-#define BASE_CONTAINERS_ADAPTERS_H_
-
-#include <stddef.h>
-
-#include <iterator>
-
-#include "base/macros.h"
-
-namespace base {
-
-namespace internal {
-
-// Internal adapter class for implementing base::Reversed.
-template <typename T>
-class ReversedAdapter {
- public:
- using Iterator = decltype(static_cast<T*>(nullptr)->rbegin());
-
- explicit ReversedAdapter(T& t) : t_(t) {}
- ReversedAdapter(const ReversedAdapter& ra) : t_(ra.t_) {}
-
- // TODO(mdempsky): Once we can use C++14 library features, use std::rbegin
- // and std::rend instead, so we can remove the specialization below.
- Iterator begin() const { return t_.rbegin(); }
- Iterator end() const { return t_.rend(); }
-
- private:
- T& t_;
-
- DISALLOW_ASSIGN(ReversedAdapter);
-};
-
-template <typename T, size_t N>
-class ReversedAdapter<T[N]> {
- public:
- using Iterator = std::reverse_iterator<T*>;
-
- explicit ReversedAdapter(T (&t)[N]) : t_(t) {}
- ReversedAdapter(const ReversedAdapter& ra) : t_(ra.t_) {}
-
- Iterator begin() const { return Iterator(&t_[N]); }
- Iterator end() const { return Iterator(&t_[0]); }
-
- private:
- T (&t_)[N];
-
- DISALLOW_ASSIGN(ReversedAdapter);
-};
-
-} // namespace internal
-
-// Reversed returns a container adapter usable in a range-based "for" statement
-// for iterating a reversible container in reverse order.
-//
-// Example:
-//
-// std::vector<int> v = ...;
-// for (int i : base::Reversed(v)) {
-// // iterates through v from back to front
-// }
-template <typename T>
-internal::ReversedAdapter<T> Reversed(T& t) {
- return internal::ReversedAdapter<T>(t);
-}
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_ADAPTERS_H_
diff --git a/base/containers/flat_set.h b/base/containers/flat_set.h
deleted file mode 100644
index bf14c36..0000000
--- a/base/containers/flat_set.h
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_FLAT_SET_H_
-#define BASE_CONTAINERS_FLAT_SET_H_
-
-#include <functional>
-
-#include "base/containers/flat_tree.h"
-#include "base/template_util.h"
-
-namespace base {
-
-// flat_set is a container with a std::set-like interface that stores its
-// contents in a sorted vector.
-//
-// Please see //base/containers/README.md for an overview of which container
-// to select.
-//
-// PROS
-//
-// - Good memory locality.
-// - Low overhead, especially for smaller sets.
-// - Performance is good for more workloads than you might expect (see
-// overview link above).
-// - Supports C++14 set interface.
-//
-// CONS
-//
-// - Inserts and removals are O(n).
-//
-// IMPORTANT NOTES
-//
-// - Iterators are invalidated across mutations.
-// - If possible, construct a flat_set in one operation by inserting into
-// a std::vector and moving that vector into the flat_set constructor.
-// - For multiple removals use base::EraseIf() which is O(n) rather than
-// O(n * removed_items).
-//
-// QUICK REFERENCE
-//
-// Most of the core functionality is inherited from flat_tree. Please see
-// flat_tree.h for more details for most of these functions. As a quick
-// reference, the functions available are:
-//
-// Constructors (inputs need not be sorted):
-// flat_set(InputIterator first, InputIterator last,
-// FlatContainerDupes = KEEP_FIRST_OF_DUPES,
-// const Compare& compare = Compare());
-// flat_set(const flat_set&);
-// flat_set(flat_set&&);
-// flat_set(std::vector<Key>,
-// FlatContainerDupes = KEEP_FIRST_OF_DUPES,
-// const Compare& compare = Compare()); // Re-use storage.
-// flat_set(std::initializer_list<value_type> ilist,
-// FlatContainerDupes = KEEP_FIRST_OF_DUPES,
-// const Compare& comp = Compare());
-//
-// Assignment functions:
-// flat_set& operator=(const flat_set&);
-// flat_set& operator=(flat_set&&);
-// flat_set& operator=(initializer_list<Key>);
-//
-// Memory management functions:
-// void reserve(size_t);
-// size_t capacity() const;
-// void shrink_to_fit();
-//
-// Size management functions:
-// void clear();
-// size_t size() const;
-// size_t max_size() const;
-// bool empty() const;
-//
-// Iterator functions:
-// iterator begin();
-// const_iterator begin() const;
-// const_iterator cbegin() const;
-// iterator end();
-// const_iterator end() const;
-// const_iterator cend() const;
-// reverse_iterator rbegin();
-// const reverse_iterator rbegin() const;
-// const_reverse_iterator crbegin() const;
-// reverse_iterator rend();
-// const_reverse_iterator rend() const;
-// const_reverse_iterator crend() const;
-//
-// Insert and accessor functions:
-// pair<iterator, bool> insert(const key_type&);
-// pair<iterator, bool> insert(key_type&&);
-// void insert(InputIterator first, InputIterator last,
-// FlatContainerDupes = KEEP_FIRST_OF_DUPES);
-// iterator insert(const_iterator hint, const key_type&);
-// iterator insert(const_iterator hint, key_type&&);
-// pair<iterator, bool> emplace(Args&&...);
-// iterator emplace_hint(const_iterator, Args&&...);
-//
-// Erase functions:
-// iterator erase(iterator);
-// iterator erase(const_iterator);
-// iterator erase(const_iterator first, const_iterator& last);
-// template <typename K> size_t erase(const K& key);
-//
-// Comparators (see std::set documentation).
-// key_compare key_comp() const;
-// value_compare value_comp() const;
-//
-// Search functions:
-// template <typename K> size_t count(const K&) const;
-// template <typename K> iterator find(const K&);
-// template <typename K> const_iterator find(const K&) const;
-// template <typename K> pair<iterator, iterator> equal_range(K&);
-// template <typename K> iterator lower_bound(const K&);
-// template <typename K> const_iterator lower_bound(const K&) const;
-// template <typename K> iterator upper_bound(const K&);
-// template <typename K> const_iterator upper_bound(const K&) const;
-//
-// General functions:
-// void swap(flat_set&&);
-//
-// Non-member operators:
-// bool operator==(const flat_set&, const flat_set);
-// bool operator!=(const flat_set&, const flat_set);
-// bool operator<(const flat_set&, const flat_set);
-// bool operator>(const flat_set&, const flat_set);
-// bool operator>=(const flat_set&, const flat_set);
-// bool operator<=(const flat_set&, const flat_set);
-//
-template <class Key, class Compare = std::less<>>
-using flat_set = typename ::base::internal::flat_tree<
- Key,
- Key,
- ::base::internal::GetKeyFromValueIdentity<Key>,
- Compare>;
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_FLAT_SET_H_
diff --git a/base/containers/id_map.h b/base/containers/id_map.h
deleted file mode 100644
index 4c816da..0000000
--- a/base/containers/id_map.h
+++ /dev/null
@@ -1,290 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_ID_MAP_H_
-#define BASE_CONTAINERS_ID_MAP_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <set>
-#include <type_traits>
-#include <unordered_map>
-#include <utility>
-
-#include "base/containers/flat_set.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/sequence_checker.h"
-
-namespace base {
-
-// This object maintains a list of IDs that can be quickly converted to
-// pointers to objects. It is implemented as a hash table, optimized for
-// relatively small data sets (in the common case, there will be exactly one
-// item in the list).
-//
-// Items can be inserted into the container with arbitrary ID, but the caller
-// must ensure they are unique. Inserting IDs and relying on automatically
-// generated ones is not allowed because they can collide.
-
-// The map's value type (the V param) can be any dereferenceable type, such as a
-// raw pointer or smart pointer
-template <typename V, typename K = int32_t>
-class IDMap final {
- public:
- using KeyType = K;
-
- private:
- using T = typename std::remove_reference<decltype(*V())>::type;
-
- using HashTable = std::unordered_map<KeyType, V>;
-
- public:
- IDMap() : iteration_depth_(0), next_id_(1), check_on_null_data_(false) {
- // A number of consumers of IDMap create it on one thread but always
- // access it from a different, but consistent, thread (or sequence)
- // post-construction. The first call to CalledOnValidSequence() will re-bind
- // it.
- DETACH_FROM_SEQUENCE(sequence_checker_);
- }
-
- ~IDMap() {
- // Many IDMap's are static, and hence will be destroyed on the main
- // thread. However, all the accesses may take place on another thread (or
- // sequence), such as the IO thread. Detaching again to clean this up.
- DETACH_FROM_SEQUENCE(sequence_checker_);
- }
-
- // Sets whether Add and Replace should DCHECK if passed in NULL data.
- // Default is false.
- void set_check_on_null_data(bool value) { check_on_null_data_ = value; }
-
- // Adds a view with an automatically generated unique ID. See AddWithID.
- KeyType Add(V data) { return AddInternal(std::move(data)); }
-
- // Adds a new data member with the specified ID. The ID must not be in
- // the list. The caller either must generate all unique IDs itself and use
- // this function, or allow this object to generate IDs and call Add. These
- // two methods may not be mixed, or duplicate IDs may be generated.
- void AddWithID(V data, KeyType id) { AddWithIDInternal(std::move(data), id); }
-
- void Remove(KeyType id) {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- typename HashTable::iterator i = data_.find(id);
- if (i == data_.end() || IsRemoved(id)) {
- NOTREACHED() << "Attempting to remove an item not in the list";
- return;
- }
-
- if (iteration_depth_ == 0) {
- data_.erase(i);
- } else {
- removed_ids_.insert(id);
- }
- }
-
- // Replaces the value for |id| with |new_data| and returns the existing value.
- // Should only be called with an already added id.
- V Replace(KeyType id, V new_data) {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- DCHECK(!check_on_null_data_ || new_data);
- typename HashTable::iterator i = data_.find(id);
- DCHECK(i != data_.end());
- DCHECK(!IsRemoved(id));
-
- using std::swap;
- swap(i->second, new_data);
- return new_data;
- }
-
- void Clear() {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- if (iteration_depth_ == 0) {
- data_.clear();
- } else {
- removed_ids_.reserve(data_.size());
- removed_ids_.insert(KeyIterator(data_.begin()), KeyIterator(data_.end()));
- }
- }
-
- bool IsEmpty() const {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- return size() == 0u;
- }
-
- T* Lookup(KeyType id) const {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- typename HashTable::const_iterator i = data_.find(id);
- if (i == data_.end() || !i->second || IsRemoved(id))
- return nullptr;
- return &*i->second;
- }
-
- size_t size() const {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- return data_.size() - removed_ids_.size();
- }
-
-#if defined(UNIT_TEST)
- int iteration_depth() const {
- return iteration_depth_;
- }
-#endif // defined(UNIT_TEST)
-
- // It is safe to remove elements from the map during iteration. All iterators
- // will remain valid.
- template<class ReturnType>
- class Iterator {
- public:
- Iterator(IDMap<V, K>* map) : map_(map), iter_(map_->data_.begin()) {
- Init();
- }
-
- Iterator(const Iterator& iter)
- : map_(iter.map_),
- iter_(iter.iter_) {
- Init();
- }
-
- const Iterator& operator=(const Iterator& iter) {
- map_ = iter.map;
- iter_ = iter.iter;
- Init();
- return *this;
- }
-
- ~Iterator() {
- DCHECK_CALLED_ON_VALID_SEQUENCE(map_->sequence_checker_);
-
- // We're going to decrement iteration depth. Make sure it's greater than
- // zero so that it doesn't become negative.
- DCHECK_LT(0, map_->iteration_depth_);
-
- if (--map_->iteration_depth_ == 0)
- map_->Compact();
- }
-
- bool IsAtEnd() const {
- DCHECK_CALLED_ON_VALID_SEQUENCE(map_->sequence_checker_);
- return iter_ == map_->data_.end();
- }
-
- KeyType GetCurrentKey() const {
- DCHECK_CALLED_ON_VALID_SEQUENCE(map_->sequence_checker_);
- return iter_->first;
- }
-
- ReturnType* GetCurrentValue() const {
- DCHECK_CALLED_ON_VALID_SEQUENCE(map_->sequence_checker_);
- if (!iter_->second || map_->IsRemoved(iter_->first))
- return nullptr;
- return &*iter_->second;
- }
-
- void Advance() {
- DCHECK_CALLED_ON_VALID_SEQUENCE(map_->sequence_checker_);
- ++iter_;
- SkipRemovedEntries();
- }
-
- private:
- void Init() {
- DCHECK_CALLED_ON_VALID_SEQUENCE(map_->sequence_checker_);
- ++map_->iteration_depth_;
- SkipRemovedEntries();
- }
-
- void SkipRemovedEntries() {
- while (iter_ != map_->data_.end() && map_->IsRemoved(iter_->first))
- ++iter_;
- }
-
- IDMap<V, K>* map_;
- typename HashTable::const_iterator iter_;
- };
-
- typedef Iterator<T> iterator;
- typedef Iterator<const T> const_iterator;
-
- private:
- // Transforms a map iterator to an iterator on the keys of the map.
- // Used by Clear() to populate |removed_ids_| in bulk.
- struct KeyIterator : std::iterator<std::forward_iterator_tag, KeyType> {
- using inner_iterator = typename HashTable::iterator;
- inner_iterator iter_;
-
- KeyIterator(inner_iterator iter) : iter_(iter) {}
- KeyType operator*() const { return iter_->first; }
- KeyIterator& operator++() {
- ++iter_;
- return *this;
- }
- KeyIterator operator++(int) { return KeyIterator(iter_++); }
- bool operator==(const KeyIterator& other) const {
- return iter_ == other.iter_;
- }
- bool operator!=(const KeyIterator& other) const {
- return iter_ != other.iter_;
- }
- };
-
- KeyType AddInternal(V data) {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- DCHECK(!check_on_null_data_ || data);
- KeyType this_id = next_id_;
- DCHECK(data_.find(this_id) == data_.end()) << "Inserting duplicate item";
- data_[this_id] = std::move(data);
- next_id_++;
- return this_id;
- }
-
- void AddWithIDInternal(V data, KeyType id) {
- DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
- DCHECK(!check_on_null_data_ || data);
- if (IsRemoved(id)) {
- removed_ids_.erase(id);
- } else {
- DCHECK(data_.find(id) == data_.end()) << "Inserting duplicate item";
- }
- data_[id] = std::move(data);
- }
-
- bool IsRemoved(KeyType key) const {
- return removed_ids_.find(key) != removed_ids_.end();
- }
-
- void Compact() {
- DCHECK_EQ(0, iteration_depth_);
- for (const auto& i : removed_ids_)
- data_.erase(i);
- removed_ids_.clear();
- }
-
- // Keep track of how many iterators are currently iterating on us to safely
- // handle removing items during iteration.
- int iteration_depth_;
-
- // Keep set of IDs that should be removed after the outermost iteration has
- // finished. This way we manage to not invalidate the iterator when an element
- // is removed.
- base::flat_set<KeyType> removed_ids_;
-
- // The next ID that we will return from Add()
- KeyType next_id_;
-
- HashTable data_;
-
- // See description above setter.
- bool check_on_null_data_;
-
- SEQUENCE_CHECKER(sequence_checker_);
-
- DISALLOW_COPY_AND_ASSIGN(IDMap);
-};
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_ID_MAP_H_
diff --git a/base/containers/linked_list.h b/base/containers/linked_list.h
deleted file mode 100644
index a913bad..0000000
--- a/base/containers/linked_list.h
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_LINKED_LIST_H_
-#define BASE_CONTAINERS_LINKED_LIST_H_
-
-#include "base/macros.h"
-
-// Simple LinkedList type. (See the Q&A section to understand how this
-// differs from std::list).
-//
-// To use, start by declaring the class which will be contained in the linked
-// list, as extending LinkNode (this gives it next/previous pointers).
-//
-// class MyNodeType : public LinkNode<MyNodeType> {
-// ...
-// };
-//
-// Next, to keep track of the list's head/tail, use a LinkedList instance:
-//
-// LinkedList<MyNodeType> list;
-//
-// To add elements to the list, use any of LinkedList::Append,
-// LinkNode::InsertBefore, or LinkNode::InsertAfter:
-//
-// LinkNode<MyNodeType>* n1 = ...;
-// LinkNode<MyNodeType>* n2 = ...;
-// LinkNode<MyNodeType>* n3 = ...;
-//
-// list.Append(n1);
-// list.Append(n3);
-// n3->InsertBefore(n3);
-//
-// Lastly, to iterate through the linked list forwards:
-//
-// for (LinkNode<MyNodeType>* node = list.head();
-// node != list.end();
-// node = node->next()) {
-// MyNodeType* value = node->value();
-// ...
-// }
-//
-// Or to iterate the linked list backwards:
-//
-// for (LinkNode<MyNodeType>* node = list.tail();
-// node != list.end();
-// node = node->previous()) {
-// MyNodeType* value = node->value();
-// ...
-// }
-//
-// Questions and Answers:
-//
-// Q. Should I use std::list or base::LinkedList?
-//
-// A. The main reason to use base::LinkedList over std::list is
-// performance. If you don't care about the performance differences
-// then use an STL container, as it makes for better code readability.
-//
-// Comparing the performance of base::LinkedList<T> to std::list<T*>:
-//
-// * Erasing an element of type T* from base::LinkedList<T> is
-// an O(1) operation. Whereas for std::list<T*> it is O(n).
-// That is because with std::list<T*> you must obtain an
-// iterator to the T* element before you can call erase(iterator).
-//
-// * Insertion operations with base::LinkedList<T> never require
-// heap allocations.
-//
-// Q. How does base::LinkedList implementation differ from std::list?
-//
-// A. Doubly-linked lists are made up of nodes that contain "next" and
-// "previous" pointers that reference other nodes in the list.
-//
-// With base::LinkedList<T>, the type being inserted already reserves
-// space for the "next" and "previous" pointers (base::LinkNode<T>*).
-// Whereas with std::list<T> the type can be anything, so the implementation
-// needs to glue on the "next" and "previous" pointers using
-// some internal node type.
-
-namespace base {
-
-template <typename T>
-class LinkNode {
- public:
- LinkNode() : previous_(nullptr), next_(nullptr) {}
- LinkNode(LinkNode<T>* previous, LinkNode<T>* next)
- : previous_(previous), next_(next) {}
-
- LinkNode(LinkNode<T>&& rhs) {
- next_ = rhs.next_;
- rhs.next_ = nullptr;
- previous_ = rhs.previous_;
- rhs.previous_ = nullptr;
-
- // If the node belongs to a list, next_ and previous_ are both non-null.
- // Otherwise, they are both null.
- if (next_) {
- next_->previous_ = this;
- previous_->next_ = this;
- }
- }
-
- // Insert |this| into the linked list, before |e|.
- void InsertBefore(LinkNode<T>* e) {
- this->next_ = e;
- this->previous_ = e->previous_;
- e->previous_->next_ = this;
- e->previous_ = this;
- }
-
- // Insert |this| into the linked list, after |e|.
- void InsertAfter(LinkNode<T>* e) {
- this->next_ = e->next_;
- this->previous_ = e;
- e->next_->previous_ = this;
- e->next_ = this;
- }
-
- // Remove |this| from the linked list.
- void RemoveFromList() {
- this->previous_->next_ = this->next_;
- this->next_->previous_ = this->previous_;
- // next() and previous() return non-null if and only this node is not in any
- // list.
- this->next_ = nullptr;
- this->previous_ = nullptr;
- }
-
- LinkNode<T>* previous() const {
- return previous_;
- }
-
- LinkNode<T>* next() const {
- return next_;
- }
-
- // Cast from the node-type to the value type.
- const T* value() const {
- return static_cast<const T*>(this);
- }
-
- T* value() {
- return static_cast<T*>(this);
- }
-
- private:
- LinkNode<T>* previous_;
- LinkNode<T>* next_;
-
- DISALLOW_COPY_AND_ASSIGN(LinkNode);
-};
-
-template <typename T>
-class LinkedList {
- public:
- // The "root" node is self-referential, and forms the basis of a circular
- // list (root_.next() will point back to the start of the list,
- // and root_->previous() wraps around to the end of the list).
- LinkedList() : root_(&root_, &root_) {}
-
- // Appends |e| to the end of the linked list.
- void Append(LinkNode<T>* e) {
- e->InsertBefore(&root_);
- }
-
- LinkNode<T>* head() const {
- return root_.next();
- }
-
- LinkNode<T>* tail() const {
- return root_.previous();
- }
-
- const LinkNode<T>* end() const {
- return &root_;
- }
-
- bool empty() const { return head() == end(); }
-
- private:
- LinkNode<T> root_;
-
- DISALLOW_COPY_AND_ASSIGN(LinkedList);
-};
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_LINKED_LIST_H_
diff --git a/base/containers/mru_cache.h b/base/containers/mru_cache.h
deleted file mode 100644
index 4a9f44e..0000000
--- a/base/containers/mru_cache.h
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains a template for a Most Recently Used cache that allows
-// constant-time access to items using a key, but easy identification of the
-// least-recently-used items for removal. Each key can only be associated with
-// one payload item at a time.
-//
-// The key object will be stored twice, so it should support efficient copying.
-//
-// NOTE: While all operations are O(1), this code is written for
-// legibility rather than optimality. If future profiling identifies this as
-// a bottleneck, there is room for smaller values of 1 in the O(1). :]
-
-#ifndef BASE_CONTAINERS_MRU_CACHE_H_
-#define BASE_CONTAINERS_MRU_CACHE_H_
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <functional>
-#include <list>
-#include <map>
-#include <unordered_map>
-#include <utility>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-namespace base {
-namespace trace_event {
-namespace internal {
-
-template <class MruCacheType>
-size_t DoEstimateMemoryUsageForMruCache(const MruCacheType&);
-
-} // namespace internal
-} // namespace trace_event
-
-// MRUCacheBase ----------------------------------------------------------------
-
-// This template is used to standardize map type containers that can be used
-// by MRUCacheBase. This level of indirection is necessary because of the way
-// that template template params and default template params interact.
-template <class KeyType, class ValueType, class CompareType>
-struct MRUCacheStandardMap {
- typedef std::map<KeyType, ValueType, CompareType> Type;
-};
-
-// Base class for the MRU cache specializations defined below.
-template <class KeyType,
- class PayloadType,
- class HashOrCompareType,
- template <typename, typename, typename> class MapType =
- MRUCacheStandardMap>
-class MRUCacheBase {
- public:
- // The payload of the list. This maintains a copy of the key so we can
- // efficiently delete things given an element of the list.
- typedef std::pair<KeyType, PayloadType> value_type;
-
- private:
- typedef std::list<value_type> PayloadList;
- typedef typename MapType<KeyType,
- typename PayloadList::iterator,
- HashOrCompareType>::Type KeyIndex;
-
- public:
- typedef typename PayloadList::size_type size_type;
-
- typedef typename PayloadList::iterator iterator;
- typedef typename PayloadList::const_iterator const_iterator;
- typedef typename PayloadList::reverse_iterator reverse_iterator;
- typedef typename PayloadList::const_reverse_iterator const_reverse_iterator;
-
- enum { NO_AUTO_EVICT = 0 };
-
- // The max_size is the size at which the cache will prune its members to when
- // a new item is inserted. If the caller wants to manager this itself (for
- // example, maybe it has special work to do when something is evicted), it
- // can pass NO_AUTO_EVICT to not restrict the cache size.
- explicit MRUCacheBase(size_type max_size) : max_size_(max_size) {}
-
- virtual ~MRUCacheBase() = default;
-
- size_type max_size() const { return max_size_; }
-
- // Inserts a payload item with the given key. If an existing item has
- // the same key, it is removed prior to insertion. An iterator indicating the
- // inserted item will be returned (this will always be the front of the list).
- //
- // The payload will be forwarded.
- template <typename Payload>
- iterator Put(const KeyType& key, Payload&& payload) {
- // Remove any existing payload with that key.
- typename KeyIndex::iterator index_iter = index_.find(key);
- if (index_iter != index_.end()) {
- // Erase the reference to it. The index reference will be replaced in the
- // code below.
- Erase(index_iter->second);
- } else if (max_size_ != NO_AUTO_EVICT) {
- // New item is being inserted which might make it larger than the maximum
- // size: kick the oldest thing out if necessary.
- ShrinkToSize(max_size_ - 1);
- }
-
- ordering_.emplace_front(key, std::forward<Payload>(payload));
- index_.emplace(key, ordering_.begin());
- return ordering_.begin();
- }
-
- // Retrieves the contents of the given key, or end() if not found. This method
- // has the side effect of moving the requested item to the front of the
- // recency list.
- iterator Get(const KeyType& key) {
- typename KeyIndex::iterator index_iter = index_.find(key);
- if (index_iter == index_.end())
- return end();
- typename PayloadList::iterator iter = index_iter->second;
-
- // Move the touched item to the front of the recency ordering.
- ordering_.splice(ordering_.begin(), ordering_, iter);
- return ordering_.begin();
- }
-
- // Retrieves the payload associated with a given key and returns it via
- // result without affecting the ordering (unlike Get).
- iterator Peek(const KeyType& key) {
- typename KeyIndex::const_iterator index_iter = index_.find(key);
- if (index_iter == index_.end())
- return end();
- return index_iter->second;
- }
-
- const_iterator Peek(const KeyType& key) const {
- typename KeyIndex::const_iterator index_iter = index_.find(key);
- if (index_iter == index_.end())
- return end();
- return index_iter->second;
- }
-
- // Exchanges the contents of |this| by the contents of the |other|.
- void Swap(MRUCacheBase& other) {
- ordering_.swap(other.ordering_);
- index_.swap(other.index_);
- std::swap(max_size_, other.max_size_);
- }
-
- // Erases the item referenced by the given iterator. An iterator to the item
- // following it will be returned. The iterator must be valid.
- iterator Erase(iterator pos) {
- index_.erase(pos->first);
- return ordering_.erase(pos);
- }
-
- // MRUCache entries are often processed in reverse order, so we add this
- // convenience function (not typically defined by STL containers).
- reverse_iterator Erase(reverse_iterator pos) {
- // We have to actually give it the incremented iterator to delete, since
- // the forward iterator that base() returns is actually one past the item
- // being iterated over.
- return reverse_iterator(Erase((++pos).base()));
- }
-
- // Shrinks the cache so it only holds |new_size| items. If |new_size| is
- // bigger or equal to the current number of items, this will do nothing.
- void ShrinkToSize(size_type new_size) {
- for (size_type i = size(); i > new_size; i--)
- Erase(rbegin());
- }
-
- // Deletes everything from the cache.
- void Clear() {
- index_.clear();
- ordering_.clear();
- }
-
- // Returns the number of elements in the cache.
- size_type size() const {
- // We don't use ordering_.size() for the return value because
- // (as a linked list) it can be O(n).
- DCHECK(index_.size() == ordering_.size());
- return index_.size();
- }
-
- // Allows iteration over the list. Forward iteration starts with the most
- // recent item and works backwards.
- //
- // Note that since these iterators are actually iterators over a list, you
- // can keep them as you insert or delete things (as long as you don't delete
- // the one you are pointing to) and they will still be valid.
- iterator begin() { return ordering_.begin(); }
- const_iterator begin() const { return ordering_.begin(); }
- iterator end() { return ordering_.end(); }
- const_iterator end() const { return ordering_.end(); }
-
- reverse_iterator rbegin() { return ordering_.rbegin(); }
- const_reverse_iterator rbegin() const { return ordering_.rbegin(); }
- reverse_iterator rend() { return ordering_.rend(); }
- const_reverse_iterator rend() const { return ordering_.rend(); }
-
- bool empty() const { return ordering_.empty(); }
-
- private:
- template <class MruCacheType>
- friend size_t trace_event::internal::DoEstimateMemoryUsageForMruCache(
- const MruCacheType&);
-
- PayloadList ordering_;
- KeyIndex index_;
-
- size_type max_size_;
-
- DISALLOW_COPY_AND_ASSIGN(MRUCacheBase);
-};
-
-// MRUCache --------------------------------------------------------------------
-
-// A container that does not do anything to free its data. Use this when storing
-// value types (as opposed to pointers) in the list.
-template <class KeyType,
- class PayloadType,
- class CompareType = std::less<KeyType>>
-class MRUCache : public MRUCacheBase<KeyType, PayloadType, CompareType> {
- private:
- using ParentType = MRUCacheBase<KeyType, PayloadType, CompareType>;
-
- public:
- // See MRUCacheBase, noting the possibility of using NO_AUTO_EVICT.
- explicit MRUCache(typename ParentType::size_type max_size)
- : ParentType(max_size) {}
- virtual ~MRUCache() = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MRUCache);
-};
-
-// HashingMRUCache ------------------------------------------------------------
-
-template <class KeyType, class ValueType, class HashType>
-struct MRUCacheHashMap {
- typedef std::unordered_map<KeyType, ValueType, HashType> Type;
-};
-
-// This class is similar to MRUCache, except that it uses std::unordered_map as
-// the map type instead of std::map. Note that your KeyType must be hashable to
-// use this cache or you need to provide a hashing class.
-template <class KeyType, class PayloadType, class HashType = std::hash<KeyType>>
-class HashingMRUCache
- : public MRUCacheBase<KeyType, PayloadType, HashType, MRUCacheHashMap> {
- private:
- using ParentType =
- MRUCacheBase<KeyType, PayloadType, HashType, MRUCacheHashMap>;
-
- public:
- // See MRUCacheBase, noting the possibility of using NO_AUTO_EVICT.
- explicit HashingMRUCache(typename ParentType::size_type max_size)
- : ParentType(max_size) {}
- virtual ~HashingMRUCache() = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(HashingMRUCache);
-};
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_MRU_CACHE_H_
diff --git a/base/containers/ring_buffer.h b/base/containers/ring_buffer.h
deleted file mode 100644
index 4e48907..0000000
--- a/base/containers/ring_buffer.h
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_RING_BUFFER_H_
-#define BASE_CONTAINERS_RING_BUFFER_H_
-
-#include <stddef.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-namespace base {
-
-// base::RingBuffer uses a fixed-size array, unlike base::circular_deque and
-// std::deque, and so, one can access only the last |kSize| elements. Also, you
-// can add elements to the front and read/modify random elements, but cannot
-// remove elements from the back. Therefore, it does not have a |Size| method,
-// only |BufferSize|, which is a constant, and |CurrentIndex|, which is the
-// number of elements added so far.
-//
-// If the above is sufficient for your use case, base::RingBuffer should be more
-// efficient than base::circular_deque.
-template <typename T, size_t kSize>
-class RingBuffer {
- public:
- RingBuffer() : current_index_(0) {}
-
- size_t BufferSize() const { return kSize; }
-
- size_t CurrentIndex() const { return current_index_; }
-
- // tests if a value was saved to this index
- bool IsFilledIndex(size_t n) const { return BufferIndex(n) < current_index_; }
-
- // n = 0 returns the oldest value and
- // n = bufferSize() - 1 returns the most recent value.
- const T& ReadBuffer(size_t n) const {
- DCHECK(IsFilledIndex(n));
- return buffer_[BufferIndex(n)];
- }
-
- T* MutableReadBuffer(size_t n) {
- DCHECK(IsFilledIndex(n));
- return &buffer_[BufferIndex(n)];
- }
-
- void SaveToBuffer(const T& value) {
- buffer_[BufferIndex(0)] = value;
- current_index_++;
- }
-
- void Clear() { current_index_ = 0; }
-
- // Iterator has const access to the RingBuffer it got retrieved from.
- class Iterator {
- public:
- size_t index() const { return index_; }
-
- const T* operator->() const { return &buffer_.ReadBuffer(index_); }
- const T* operator*() const { return &buffer_.ReadBuffer(index_); }
-
- Iterator& operator++() {
- index_++;
- if (index_ == kSize)
- out_of_range_ = true;
- return *this;
- }
-
- Iterator& operator--() {
- if (index_ == 0)
- out_of_range_ = true;
- index_--;
- return *this;
- }
-
- operator bool() const {
- return buffer_.IsFilledIndex(index_) && !out_of_range_;
- }
-
- private:
- Iterator(const RingBuffer<T, kSize>& buffer, size_t index)
- : buffer_(buffer), index_(index), out_of_range_(false) {}
-
- const RingBuffer<T, kSize>& buffer_;
- size_t index_;
- bool out_of_range_;
-
- friend class RingBuffer<T, kSize>;
- };
-
- // Returns an Iterator pointing to the oldest value in the buffer.
- // Example usage (iterate from oldest to newest value):
- // for (RingBuffer<T, kSize>::Iterator it = ring_buffer.Begin(); it; ++it) {}
- Iterator Begin() const {
- if (current_index_ < kSize)
- return Iterator(*this, kSize - current_index_);
- return Iterator(*this, 0);
- }
-
- // Returns an Iterator pointing to the newest value in the buffer.
- // Example usage (iterate backwards from newest to oldest value):
- // for (RingBuffer<T, kSize>::Iterator it = ring_buffer.End(); it; --it) {}
- Iterator End() const { return Iterator(*this, kSize - 1); }
-
- private:
- inline size_t BufferIndex(size_t n) const {
- return (current_index_ + n) % kSize;
- }
-
- T buffer_[kSize];
- size_t current_index_;
-
- DISALLOW_COPY_AND_ASSIGN(RingBuffer);
-};
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_RING_BUFFER_H_
diff --git a/base/containers/small_map.h b/base/containers/small_map.h
deleted file mode 100644
index a235f11..0000000
--- a/base/containers/small_map.h
+++ /dev/null
@@ -1,659 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_SMALL_MAP_H_
-#define BASE_CONTAINERS_SMALL_MAP_H_
-
-#include <stddef.h>
-
-#include <map>
-#include <new>
-#include <string>
-#include <utility>
-
-#include "base/logging.h"
-
-namespace base {
-
-// small_map is a container with a std::map-like interface. It starts out
-// backed by a unsorted array but switches to some other container type if it
-// grows beyond this fixed size.
-//
-// Please see //base/containers/README.md for an overview of which container
-// to select.
-//
-// PROS
-//
-// - Good memory locality and low overhead for smaller maps.
-// - Handles large maps without the degenerate performance of flat_map.
-//
-// CONS
-//
-// - Larger code size than the alternatives.
-//
-// IMPORTANT NOTES
-//
-// - Iterators are invalidated across mutations.
-//
-// DETAILS
-//
-// base::small_map will pick up the comparator from the underlying map type. In
-// std::map only a "less" operator is defined, which requires us to do two
-// comparisons per element when doing the brute-force search in the simple
-// array. std::unordered_map has a key_equal function which will be used.
-//
-// We define default overrides for the common map types to avoid this
-// double-compare, but you should be aware of this if you use your own
-// operator< for your map and supply yor own version of == to the small_map.
-// You can use regular operator== by just doing:
-//
-// base::small_map<std::map<MyKey, MyValue>, 4, std::equal_to<KyKey>>
-//
-//
-// USAGE
-// -----
-//
-// NormalMap: The map type to fall back to. This also defines the key
-// and value types for the small_map.
-// kArraySize: The size of the initial array of results. This will be
-// allocated with the small_map object rather than separately on
-// the heap. Once the map grows beyond this size, the map type
-// will be used instead.
-// EqualKey: A functor which tests two keys for equality. If the wrapped
-// map type has a "key_equal" member (hash_map does), then that will
-// be used by default. If the wrapped map type has a strict weak
-// ordering "key_compare" (std::map does), that will be used to
-// implement equality by default.
-// MapInit: A functor that takes a NormalMap* and uses it to initialize the map.
-// This functor will be called at most once per small_map, when the map
-// exceeds the threshold of kArraySize and we are about to copy values
-// from the array to the map. The functor *must* initialize the
-// NormalMap* argument with placement new, since after it runs we
-// assume that the NormalMap has been initialized.
-//
-// example:
-// base::small_map<std::map<string, int>> days;
-// days["sunday" ] = 0;
-// days["monday" ] = 1;
-// days["tuesday" ] = 2;
-// days["wednesday"] = 3;
-// days["thursday" ] = 4;
-// days["friday" ] = 5;
-// days["saturday" ] = 6;
-
-namespace internal {
-
-template <typename NormalMap>
-class small_map_default_init {
- public:
- void operator()(NormalMap* map) const { new (map) NormalMap(); }
-};
-
-// has_key_equal<M>::value is true iff there exists a type M::key_equal. This is
-// used to dispatch to one of the select_equal_key<> metafunctions below.
-template <typename M>
-struct has_key_equal {
- typedef char sml; // "small" is sometimes #defined so we use an abbreviation.
- typedef struct { char dummy[2]; } big;
- // Two functions, one accepts types that have a key_equal member, and one that
- // accepts anything. They each return a value of a different size, so we can
- // determine at compile-time which function would have been called.
- template <typename U> static big test(typename U::key_equal*);
- template <typename> static sml test(...);
- // Determines if M::key_equal exists by looking at the size of the return
- // type of the compiler-chosen test() function.
- static const bool value = (sizeof(test<M>(0)) == sizeof(big));
-};
-template <typename M> const bool has_key_equal<M>::value;
-
-// Base template used for map types that do NOT have an M::key_equal member,
-// e.g., std::map<>. These maps have a strict weak ordering comparator rather
-// than an equality functor, so equality will be implemented in terms of that
-// comparator.
-//
-// There's a partial specialization of this template below for map types that do
-// have an M::key_equal member.
-template <typename M, bool has_key_equal_value>
-struct select_equal_key {
- struct equal_key {
- bool operator()(const typename M::key_type& left,
- const typename M::key_type& right) {
- // Implements equality in terms of a strict weak ordering comparator.
- typename M::key_compare comp;
- return !comp(left, right) && !comp(right, left);
- }
- };
-};
-
-// Provide overrides to use operator== for key compare for the "normal" map and
-// hash map types. If you override the default comparator or allocator for a
-// map or hash_map, or use another type of map, this won't get used.
-//
-// If we switch to using std::unordered_map for base::hash_map, then the
-// hash_map specialization can be removed.
-template <typename KeyType, typename ValueType>
-struct select_equal_key<std::map<KeyType, ValueType>, false> {
- struct equal_key {
- bool operator()(const KeyType& left, const KeyType& right) {
- return left == right;
- }
- };
-};
-template <typename KeyType, typename ValueType>
-struct select_equal_key<base::hash_map<KeyType, ValueType>, false> {
- struct equal_key {
- bool operator()(const KeyType& left, const KeyType& right) {
- return left == right;
- }
- };
-};
-
-// Partial template specialization handles case where M::key_equal exists, e.g.,
-// hash_map<>.
-template <typename M>
-struct select_equal_key<M, true> {
- typedef typename M::key_equal equal_key;
-};
-
-} // namespace internal
-
-template <typename NormalMap,
- int kArraySize = 4,
- typename EqualKey = typename internal::select_equal_key<
- NormalMap,
- internal::has_key_equal<NormalMap>::value>::equal_key,
- typename MapInit = internal::small_map_default_init<NormalMap>>
-class small_map {
- // We cannot rely on the compiler to reject array of size 0. In
- // particular, gcc 2.95.3 does it but later versions allow 0-length
- // arrays. Therefore, we explicitly reject non-positive kArraySize
- // here.
- static_assert(kArraySize > 0, "default initial size should be positive");
-
- public:
- typedef typename NormalMap::key_type key_type;
- typedef typename NormalMap::mapped_type data_type;
- typedef typename NormalMap::mapped_type mapped_type;
- typedef typename NormalMap::value_type value_type;
- typedef EqualKey key_equal;
-
- small_map() : size_(0), functor_(MapInit()) {}
-
- explicit small_map(const MapInit& functor) : size_(0), functor_(functor) {}
-
- // Allow copy-constructor and assignment, since STL allows them too.
- small_map(const small_map& src) {
- // size_ and functor_ are initted in InitFrom()
- InitFrom(src);
- }
- void operator=(const small_map& src) {
- if (&src == this) return;
-
- // This is not optimal. If src and dest are both using the small
- // array, we could skip the teardown and reconstruct. One problem
- // to be resolved is that the value_type itself is pair<const K,
- // V>, and const K is not assignable.
- Destroy();
- InitFrom(src);
- }
- ~small_map() { Destroy(); }
-
- class const_iterator;
-
- class iterator {
- public:
- typedef typename NormalMap::iterator::iterator_category iterator_category;
- typedef typename NormalMap::iterator::value_type value_type;
- typedef typename NormalMap::iterator::difference_type difference_type;
- typedef typename NormalMap::iterator::pointer pointer;
- typedef typename NormalMap::iterator::reference reference;
-
- inline iterator(): array_iter_(NULL) {}
-
- inline iterator& operator++() {
- if (array_iter_ != NULL) {
- ++array_iter_;
- } else {
- ++hash_iter_;
- }
- return *this;
- }
- inline iterator operator++(int /*unused*/) {
- iterator result(*this);
- ++(*this);
- return result;
- }
- inline iterator& operator--() {
- if (array_iter_ != NULL) {
- --array_iter_;
- } else {
- --hash_iter_;
- }
- return *this;
- }
- inline iterator operator--(int /*unused*/) {
- iterator result(*this);
- --(*this);
- return result;
- }
- inline value_type* operator->() const {
- if (array_iter_ != NULL) {
- return array_iter_;
- } else {
- return hash_iter_.operator->();
- }
- }
-
- inline value_type& operator*() const {
- if (array_iter_ != NULL) {
- return *array_iter_;
- } else {
- return *hash_iter_;
- }
- }
-
- inline bool operator==(const iterator& other) const {
- if (array_iter_ != NULL) {
- return array_iter_ == other.array_iter_;
- } else {
- return other.array_iter_ == NULL && hash_iter_ == other.hash_iter_;
- }
- }
-
- inline bool operator!=(const iterator& other) const {
- return !(*this == other);
- }
-
- bool operator==(const const_iterator& other) const;
- bool operator!=(const const_iterator& other) const;
-
- private:
- friend class small_map;
- friend class const_iterator;
- inline explicit iterator(value_type* init) : array_iter_(init) {}
- inline explicit iterator(const typename NormalMap::iterator& init)
- : array_iter_(NULL), hash_iter_(init) {}
-
- value_type* array_iter_;
- typename NormalMap::iterator hash_iter_;
- };
-
- class const_iterator {
- public:
- typedef typename NormalMap::const_iterator::iterator_category
- iterator_category;
- typedef typename NormalMap::const_iterator::value_type value_type;
- typedef typename NormalMap::const_iterator::difference_type difference_type;
- typedef typename NormalMap::const_iterator::pointer pointer;
- typedef typename NormalMap::const_iterator::reference reference;
-
- inline const_iterator(): array_iter_(NULL) {}
- // Non-explicit ctor lets us convert regular iterators to const iterators
- inline const_iterator(const iterator& other)
- : array_iter_(other.array_iter_), hash_iter_(other.hash_iter_) {}
-
- inline const_iterator& operator++() {
- if (array_iter_ != NULL) {
- ++array_iter_;
- } else {
- ++hash_iter_;
- }
- return *this;
- }
- inline const_iterator operator++(int /*unused*/) {
- const_iterator result(*this);
- ++(*this);
- return result;
- }
-
- inline const_iterator& operator--() {
- if (array_iter_ != NULL) {
- --array_iter_;
- } else {
- --hash_iter_;
- }
- return *this;
- }
- inline const_iterator operator--(int /*unused*/) {
- const_iterator result(*this);
- --(*this);
- return result;
- }
-
- inline const value_type* operator->() const {
- if (array_iter_ != NULL) {
- return array_iter_;
- } else {
- return hash_iter_.operator->();
- }
- }
-
- inline const value_type& operator*() const {
- if (array_iter_ != NULL) {
- return *array_iter_;
- } else {
- return *hash_iter_;
- }
- }
-
- inline bool operator==(const const_iterator& other) const {
- if (array_iter_ != NULL) {
- return array_iter_ == other.array_iter_;
- } else {
- return other.array_iter_ == NULL && hash_iter_ == other.hash_iter_;
- }
- }
-
- inline bool operator!=(const const_iterator& other) const {
- return !(*this == other);
- }
-
- private:
- friend class small_map;
- inline explicit const_iterator(const value_type* init)
- : array_iter_(init) {}
- inline explicit const_iterator(
- const typename NormalMap::const_iterator& init)
- : array_iter_(NULL), hash_iter_(init) {}
-
- const value_type* array_iter_;
- typename NormalMap::const_iterator hash_iter_;
- };
-
- iterator find(const key_type& key) {
- key_equal compare;
- if (size_ >= 0) {
- for (int i = 0; i < size_; i++) {
- if (compare(array_[i].first, key)) {
- return iterator(array_ + i);
- }
- }
- return iterator(array_ + size_);
- } else {
- return iterator(map()->find(key));
- }
- }
-
- const_iterator find(const key_type& key) const {
- key_equal compare;
- if (size_ >= 0) {
- for (int i = 0; i < size_; i++) {
- if (compare(array_[i].first, key)) {
- return const_iterator(array_ + i);
- }
- }
- return const_iterator(array_ + size_);
- } else {
- return const_iterator(map()->find(key));
- }
- }
-
- // Invalidates iterators.
- data_type& operator[](const key_type& key) {
- key_equal compare;
-
- if (size_ >= 0) {
- // operator[] searches backwards, favoring recently-added
- // elements.
- for (int i = size_-1; i >= 0; --i) {
- if (compare(array_[i].first, key)) {
- return array_[i].second;
- }
- }
- if (size_ == kArraySize) {
- ConvertToRealMap();
- return map_[key];
- } else {
- new (&array_[size_]) value_type(key, data_type());
- return array_[size_++].second;
- }
- } else {
- return map_[key];
- }
- }
-
- // Invalidates iterators.
- std::pair<iterator, bool> insert(const value_type& x) {
- key_equal compare;
-
- if (size_ >= 0) {
- for (int i = 0; i < size_; i++) {
- if (compare(array_[i].first, x.first)) {
- return std::make_pair(iterator(array_ + i), false);
- }
- }
- if (size_ == kArraySize) {
- ConvertToRealMap(); // Invalidates all iterators!
- std::pair<typename NormalMap::iterator, bool> ret = map_.insert(x);
- return std::make_pair(iterator(ret.first), ret.second);
- } else {
- new (&array_[size_]) value_type(x);
- return std::make_pair(iterator(array_ + size_++), true);
- }
- } else {
- std::pair<typename NormalMap::iterator, bool> ret = map_.insert(x);
- return std::make_pair(iterator(ret.first), ret.second);
- }
- }
-
- // Invalidates iterators.
- template <class InputIterator>
- void insert(InputIterator f, InputIterator l) {
- while (f != l) {
- insert(*f);
- ++f;
- }
- }
-
- // Invalidates iterators.
- template <typename... Args>
- std::pair<iterator, bool> emplace(Args&&... args) {
- key_equal compare;
-
- if (size_ >= 0) {
- value_type x(std::forward<Args>(args)...);
- for (int i = 0; i < size_; i++) {
- if (compare(array_[i].first, x.first)) {
- return std::make_pair(iterator(array_ + i), false);
- }
- }
- if (size_ == kArraySize) {
- ConvertToRealMap(); // Invalidates all iterators!
- std::pair<typename NormalMap::iterator, bool> ret =
- map_.emplace(std::move(x));
- return std::make_pair(iterator(ret.first), ret.second);
- } else {
- new (&array_[size_]) value_type(std::move(x));
- return std::make_pair(iterator(array_ + size_++), true);
- }
- } else {
- std::pair<typename NormalMap::iterator, bool> ret =
- map_.emplace(std::forward<Args>(args)...);
- return std::make_pair(iterator(ret.first), ret.second);
- }
- }
-
- iterator begin() {
- if (size_ >= 0) {
- return iterator(array_);
- } else {
- return iterator(map_.begin());
- }
- }
- const_iterator begin() const {
- if (size_ >= 0) {
- return const_iterator(array_);
- } else {
- return const_iterator(map_.begin());
- }
- }
-
- iterator end() {
- if (size_ >= 0) {
- return iterator(array_ + size_);
- } else {
- return iterator(map_.end());
- }
- }
- const_iterator end() const {
- if (size_ >= 0) {
- return const_iterator(array_ + size_);
- } else {
- return const_iterator(map_.end());
- }
- }
-
- void clear() {
- if (size_ >= 0) {
- for (int i = 0; i < size_; i++) {
- array_[i].~value_type();
- }
- } else {
- map_.~NormalMap();
- }
- size_ = 0;
- }
-
- // Invalidates iterators. Returns iterator following the last removed element.
- iterator erase(const iterator& position) {
- if (size_ >= 0) {
- int i = position.array_iter_ - array_;
- array_[i].~value_type();
- --size_;
- if (i != size_) {
- new (&array_[i]) value_type(std::move(array_[size_]));
- array_[size_].~value_type();
- return iterator(array_ + i);
- }
- return end();
- }
- return iterator(map_.erase(position.hash_iter_));
- }
-
- size_t erase(const key_type& key) {
- iterator iter = find(key);
- if (iter == end()) return 0u;
- erase(iter);
- return 1u;
- }
-
- size_t count(const key_type& key) const {
- return (find(key) == end()) ? 0 : 1;
- }
-
- size_t size() const {
- if (size_ >= 0) {
- return static_cast<size_t>(size_);
- } else {
- return map_.size();
- }
- }
-
- bool empty() const {
- if (size_ >= 0) {
- return (size_ == 0);
- } else {
- return map_.empty();
- }
- }
-
- // Returns true if we have fallen back to using the underlying map
- // representation.
- bool UsingFullMap() const {
- return size_ < 0;
- }
-
- inline NormalMap* map() {
- CHECK(UsingFullMap());
- return &map_;
- }
- inline const NormalMap* map() const {
- CHECK(UsingFullMap());
- return &map_;
- }
-
- private:
- int size_; // negative = using hash_map
-
- MapInit functor_;
-
- // We want to call constructors and destructors manually, but we don't want to
- // allocate and deallocate the memory used for them separately. Since array_
- // and map_ are mutually exclusive, we'll put them in a union.
- union {
- value_type array_[kArraySize];
- NormalMap map_;
- };
-
- void ConvertToRealMap() {
- // Storage for the elements in the temporary array. This is intentionally
- // declared as a union to avoid having to default-construct |kArraySize|
- // elements, only to move construct over them in the initial loop.
- union Storage {
- Storage() {}
- ~Storage() {}
- value_type array[kArraySize];
- } temp;
-
- // Move the current elements into a temporary array.
- for (int i = 0; i < kArraySize; i++) {
- new (&temp.array[i]) value_type(std::move(array_[i]));
- array_[i].~value_type();
- }
-
- // Initialize the map.
- size_ = -1;
- functor_(&map_);
-
- // Insert elements into it.
- for (int i = 0; i < kArraySize; i++) {
- map_.insert(std::move(temp.array[i]));
- temp.array[i].~value_type();
- }
- }
-
- // Helpers for constructors and destructors.
- void InitFrom(const small_map& src) {
- functor_ = src.functor_;
- size_ = src.size_;
- if (src.size_ >= 0) {
- for (int i = 0; i < size_; i++) {
- new (&array_[i]) value_type(src.array_[i]);
- }
- } else {
- functor_(&map_);
- map_ = src.map_;
- }
- }
- void Destroy() {
- if (size_ >= 0) {
- for (int i = 0; i < size_; i++) {
- array_[i].~value_type();
- }
- } else {
- map_.~NormalMap();
- }
- }
-};
-
-template <typename NormalMap,
- int kArraySize,
- typename EqualKey,
- typename Functor>
-inline bool small_map<NormalMap, kArraySize, EqualKey, Functor>::iterator::
-operator==(const const_iterator& other) const {
- return other == *this;
-}
-template <typename NormalMap,
- int kArraySize,
- typename EqualKey,
- typename Functor>
-inline bool small_map<NormalMap, kArraySize, EqualKey, Functor>::iterator::
-operator!=(const const_iterator& other) const {
- return other != *this;
-}
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_SMALL_MAP_H_
diff --git a/base/containers/stack_container.h b/base/containers/stack_container.h
deleted file mode 100644
index 7d84d07..0000000
--- a/base/containers/stack_container.h
+++ /dev/null
@@ -1,229 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_STACK_CONTAINER_H_
-#define BASE_CONTAINERS_STACK_CONTAINER_H_
-
-#include <stddef.h>
-
-#include <vector>
-
-#include "base/macros.h"
-#include "build_config.h"
-
-namespace base {
-
-// This allocator can be used with STL containers to provide a stack buffer
-// from which to allocate memory and overflows onto the heap. This stack buffer
-// would be allocated on the stack and allows us to avoid heap operations in
-// some situations.
-//
-// STL likes to make copies of allocators, so the allocator itself can't hold
-// the data. Instead, we make the creator responsible for creating a
-// StackAllocator::Source which contains the data. Copying the allocator
-// merely copies the pointer to this shared source, so all allocators created
-// based on our allocator will share the same stack buffer.
-//
-// This stack buffer implementation is very simple. The first allocation that
-// fits in the stack buffer will use the stack buffer. Any subsequent
-// allocations will not use the stack buffer, even if there is unused room.
-// This makes it appropriate for array-like containers, but the caller should
-// be sure to reserve() in the container up to the stack buffer size. Otherwise
-// the container will allocate a small array which will "use up" the stack
-// buffer.
-template<typename T, size_t stack_capacity>
-class StackAllocator : public std::allocator<T> {
- public:
- typedef typename std::allocator<T>::pointer pointer;
- typedef typename std::allocator<T>::size_type size_type;
-
- // Backing store for the allocator. The container owner is responsible for
- // maintaining this for as long as any containers using this allocator are
- // live.
- struct Source {
- Source() : used_stack_buffer_(false) {
- }
-
- // Casts the buffer in its right type.
- T* stack_buffer() { return reinterpret_cast<T*>(stack_buffer_); }
- const T* stack_buffer() const {
- return reinterpret_cast<const T*>(&stack_buffer_);
- }
-
- // The buffer itself. It is not of type T because we don't want the
- // constructors and destructors to be automatically called. Define a POD
- // buffer of the right size instead.
- alignas(T) char stack_buffer_[sizeof(T[stack_capacity])];
-#if defined(__GNUC__) && !defined(ARCH_CPU_X86_FAMILY)
- static_assert(alignof(T) <= 16, "http://crbug.com/115612");
-#endif
-
- // Set when the stack buffer is used for an allocation. We do not track
- // how much of the buffer is used, only that somebody is using it.
- bool used_stack_buffer_;
- };
-
- // Used by containers when they want to refer to an allocator of type U.
- template<typename U>
- struct rebind {
- typedef StackAllocator<U, stack_capacity> other;
- };
-
- // For the straight up copy c-tor, we can share storage.
- StackAllocator(const StackAllocator<T, stack_capacity>& rhs)
- : std::allocator<T>(), source_(rhs.source_) {
- }
-
- // ISO C++ requires the following constructor to be defined,
- // and std::vector in VC++2008SP1 Release fails with an error
- // in the class _Container_base_aux_alloc_real (from <xutility>)
- // if the constructor does not exist.
- // For this constructor, we cannot share storage; there's
- // no guarantee that the Source buffer of Ts is large enough
- // for Us.
- // TODO: If we were fancy pants, perhaps we could share storage
- // iff sizeof(T) == sizeof(U).
- template<typename U, size_t other_capacity>
- StackAllocator(const StackAllocator<U, other_capacity>& other)
- : source_(NULL) {
- }
-
- // This constructor must exist. It creates a default allocator that doesn't
- // actually have a stack buffer. glibc's std::string() will compare the
- // current allocator against the default-constructed allocator, so this
- // should be fast.
- StackAllocator() : source_(NULL) {
- }
-
- explicit StackAllocator(Source* source) : source_(source) {
- }
-
- // Actually do the allocation. Use the stack buffer if nobody has used it yet
- // and the size requested fits. Otherwise, fall through to the standard
- // allocator.
- pointer allocate(size_type n, void* hint = 0) {
- if (source_ != NULL && !source_->used_stack_buffer_
- && n <= stack_capacity) {
- source_->used_stack_buffer_ = true;
- return source_->stack_buffer();
- } else {
- return std::allocator<T>::allocate(n, hint);
- }
- }
-
- // Free: when trying to free the stack buffer, just mark it as free. For
- // non-stack-buffer pointers, just fall though to the standard allocator.
- void deallocate(pointer p, size_type n) {
- if (source_ != NULL && p == source_->stack_buffer())
- source_->used_stack_buffer_ = false;
- else
- std::allocator<T>::deallocate(p, n);
- }
-
- private:
- Source* source_;
-};
-
-// A wrapper around STL containers that maintains a stack-sized buffer that the
-// initial capacity of the vector is based on. Growing the container beyond the
-// stack capacity will transparently overflow onto the heap. The container must
-// support reserve().
-//
-// This will not work with std::string since some implementations allocate
-// more bytes than requested in calls to reserve(), forcing the allocation onto
-// the heap. http://crbug.com/709273
-//
-// WATCH OUT: the ContainerType MUST use the proper StackAllocator for this
-// type. This object is really intended to be used only internally. You'll want
-// to use the wrappers below for different types.
-template<typename TContainerType, int stack_capacity>
-class StackContainer {
- public:
- typedef TContainerType ContainerType;
- typedef typename ContainerType::value_type ContainedType;
- typedef StackAllocator<ContainedType, stack_capacity> Allocator;
-
- // Allocator must be constructed before the container!
- StackContainer() : allocator_(&stack_data_), container_(allocator_) {
- // Make the container use the stack allocation by reserving our buffer size
- // before doing anything else.
- container_.reserve(stack_capacity);
- }
-
- // Getters for the actual container.
- //
- // Danger: any copies of this made using the copy constructor must have
- // shorter lifetimes than the source. The copy will share the same allocator
- // and therefore the same stack buffer as the original. Use std::copy to
- // copy into a "real" container for longer-lived objects.
- ContainerType& container() { return container_; }
- const ContainerType& container() const { return container_; }
-
- // Support operator-> to get to the container. This allows nicer syntax like:
- // StackContainer<...> foo;
- // std::sort(foo->begin(), foo->end());
- ContainerType* operator->() { return &container_; }
- const ContainerType* operator->() const { return &container_; }
-
-#ifdef UNIT_TEST
- // Retrieves the stack source so that that unit tests can verify that the
- // buffer is being used properly.
- const typename Allocator::Source& stack_data() const {
- return stack_data_;
- }
-#endif
-
- protected:
- typename Allocator::Source stack_data_;
- Allocator allocator_;
- ContainerType container_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(StackContainer);
-};
-
-// StackVector -----------------------------------------------------------------
-
-// Example:
-// StackVector<int, 16> foo;
-// foo->push_back(22); // we have overloaded operator->
-// foo[0] = 10; // as well as operator[]
-template<typename T, size_t stack_capacity>
-class StackVector : public StackContainer<
- std::vector<T, StackAllocator<T, stack_capacity> >,
- stack_capacity> {
- public:
- StackVector() : StackContainer<
- std::vector<T, StackAllocator<T, stack_capacity> >,
- stack_capacity>() {
- }
-
- // We need to put this in STL containers sometimes, which requires a copy
- // constructor. We can't call the regular copy constructor because that will
- // take the stack buffer from the original. Here, we create an empty object
- // and make a stack buffer of its own.
- StackVector(const StackVector<T, stack_capacity>& other)
- : StackContainer<
- std::vector<T, StackAllocator<T, stack_capacity> >,
- stack_capacity>() {
- this->container().assign(other->begin(), other->end());
- }
-
- StackVector<T, stack_capacity>& operator=(
- const StackVector<T, stack_capacity>& other) {
- this->container().assign(other->begin(), other->end());
- return *this;
- }
-
- // Vectors are commonly indexed, which isn't very convenient even with
- // operator-> (using "->at()" does exception stuff we don't want).
- T& operator[](size_t i) { return this->container().operator[](i); }
- const T& operator[](size_t i) const {
- return this->container().operator[](i);
- }
-};
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_STACK_CONTAINER_H_
diff --git a/base/containers/unique_ptr_adapters.h b/base/containers/unique_ptr_adapters.h
deleted file mode 100644
index 42fab19..0000000
--- a/base/containers/unique_ptr_adapters.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_UNIQUE_PTR_ADAPTERS_H_
-#define BASE_CONTAINERS_UNIQUE_PTR_ADAPTERS_H_
-
-#include <memory>
-
-namespace base {
-
-// This transparent comparator allows to lookup by raw pointer in
-// a container of unique pointers. This functionality is based on C++14
-// extensions to std::set/std::map interface, and can also be used
-// with base::flat_set/base::flat_map.
-//
-// Example usage:
-// Foo* foo = ...
-// std::set<std::unique_ptr<Foo>, base::UniquePtrComparator> set;
-// set.insert(std::unique_ptr<Foo>(foo));
-// ...
-// auto it = set.find(foo);
-// EXPECT_EQ(foo, it->get());
-//
-// You can find more information about transparent comparisons here:
-// http://en.cppreference.com/w/cpp/utility/functional/less_void
-struct UniquePtrComparator {
- using is_transparent = int;
-
- template <typename T>
- bool operator()(const std::unique_ptr<T>& lhs,
- const std::unique_ptr<T>& rhs) const {
- return lhs < rhs;
- }
-
- template <typename T>
- bool operator()(const T* lhs, const std::unique_ptr<T>& rhs) const {
- return lhs < rhs.get();
- }
-
- template <typename T>
- bool operator()(const std::unique_ptr<T>& lhs, const T* rhs) const {
- return lhs.get() < rhs;
- }
-};
-
-// UniquePtrMatcher is useful for finding an element in a container of
-// unique_ptrs when you have the raw pointer.
-//
-// Example usage:
-// std::vector<std::unique_ptr<Foo>> vector;
-// Foo* element = ...
-// auto iter = std::find_if(vector.begin(), vector.end(),
-// MatchesUniquePtr(element));
-//
-// Example of erasing from container:
-// EraseIf(v, MatchesUniquePtr(element));
-//
-template <class T, class Deleter = std::default_delete<T>>
-struct UniquePtrMatcher {
- explicit UniquePtrMatcher(T* t) : t_(t) {}
-
- bool operator()(const std::unique_ptr<T, Deleter>& o) {
- return o.get() == t_;
- }
-
- private:
- T* const t_;
-};
-
-template <class T, class Deleter = std::default_delete<T>>
-UniquePtrMatcher<T, Deleter> MatchesUniquePtr(T* t) {
- return UniquePtrMatcher<T, Deleter>(t);
-}
-
-} // namespace base
-
-#endif // BASE_CONTAINERS_UNIQUE_PTR_ADAPTERS_H_
diff --git a/base/cpu.cc b/base/cpu.cc
deleted file mode 100644
index 68a6bbc..0000000
--- a/base/cpu.cc
+++ /dev/null
@@ -1,242 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/cpu.h"
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include <algorithm>
-#include <utility>
-
-#include "base/macros.h"
-#include "build_config.h"
-
-#if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
-#include "base/files/file_util.h"
-#endif
-
-#if defined(ARCH_CPU_X86_FAMILY)
-#if defined(COMPILER_MSVC)
-#include <intrin.h>
-#include <immintrin.h> // For _xgetbv()
-#endif
-#endif
-
-namespace base {
-
-CPU::CPU()
- : signature_(0),
- type_(0),
- family_(0),
- model_(0),
- stepping_(0),
- ext_model_(0),
- ext_family_(0),
- has_mmx_(false),
- has_sse_(false),
- has_sse2_(false),
- has_sse3_(false),
- has_ssse3_(false),
- has_sse41_(false),
- has_sse42_(false),
- has_popcnt_(false),
- has_avx_(false),
- has_avx2_(false),
- has_aesni_(false),
- has_non_stop_time_stamp_counter_(false),
- cpu_vendor_("unknown") {
- Initialize();
-}
-
-namespace {
-
-#if defined(ARCH_CPU_X86_FAMILY)
-#if !defined(COMPILER_MSVC)
-
-#if defined(__pic__) && defined(__i386__)
-
-void __cpuid(int cpu_info[4], int info_type) {
- __asm__ volatile(
- "mov %%ebx, %%edi\n"
- "cpuid\n"
- "xchg %%edi, %%ebx\n"
- : "=a"(cpu_info[0]), "=D"(cpu_info[1]), "=c"(cpu_info[2]),
- "=d"(cpu_info[3])
- : "a"(info_type), "c"(0));
-}
-
-#else
-
-void __cpuid(int cpu_info[4], int info_type) {
- __asm__ volatile("cpuid\n"
- : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
- "=d"(cpu_info[3])
- : "a"(info_type), "c"(0));
-}
-
-#endif
-
-// _xgetbv returns the value of an Intel Extended Control Register (XCR).
-// Currently only XCR0 is defined by Intel so |xcr| should always be zero.
-uint64_t _xgetbv(uint32_t xcr) {
- uint32_t eax, edx;
-
- __asm__ volatile (
- "xgetbv" : "=a"(eax), "=d"(edx) : "c"(xcr));
- return (static_cast<uint64_t>(edx) << 32) | eax;
-}
-
-#endif // !defined(COMPILER_MSVC)
-#endif // ARCH_CPU_X86_FAMILY
-
-#if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
-std::string* CpuInfoBrand() {
- static std::string* brand = []() {
- // This function finds the value from /proc/cpuinfo under the key "model
- // name" or "Processor". "model name" is used in Linux 3.8 and later (3.7
- // and later for arm64) and is shown once per CPU. "Processor" is used in
- // earler versions and is shown only once at the top of /proc/cpuinfo
- // regardless of the number CPUs.
- const char kModelNamePrefix[] = "model name\t: ";
- const char kProcessorPrefix[] = "Processor\t: ";
-
- std::string contents;
- ReadFileToString(FilePath("/proc/cpuinfo"), &contents);
- DCHECK(!contents.empty());
-
- std::istringstream iss(contents);
- std::string line;
- while (std::getline(iss, line)) {
- if (line.compare(0, strlen(kModelNamePrefix), kModelNamePrefix) == 0)
- return new std::string(line.substr(strlen(kModelNamePrefix)));
- if (line.compare(0, strlen(kProcessorPrefix), kProcessorPrefix) == 0)
- return new std::string(line.substr(strlen(kProcessorPrefix)));
- }
-
- return new std::string();
- }();
-
- return brand;
-}
-#endif // defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) ||
- // defined(OS_LINUX))
-
-} // namespace
-
-void CPU::Initialize() {
-#if defined(ARCH_CPU_X86_FAMILY)
- int cpu_info[4] = {-1};
- // This array is used to temporarily hold the vendor name and then the brand
- // name. Thus it has to be big enough for both use cases. There are
- // static_asserts below for each of the use cases to make sure this array is
- // big enough.
- char cpu_string[sizeof(cpu_info) * 3 + 1];
-
- // __cpuid with an InfoType argument of 0 returns the number of
- // valid Ids in CPUInfo[0] and the CPU identification string in
- // the other three array elements. The CPU identification string is
- // not in linear order. The code below arranges the information
- // in a human readable form. The human readable order is CPUInfo[1] |
- // CPUInfo[3] | CPUInfo[2]. CPUInfo[2] and CPUInfo[3] are swapped
- // before using memcpy() to copy these three array elements to |cpu_string|.
- __cpuid(cpu_info, 0);
- int num_ids = cpu_info[0];
- std::swap(cpu_info[2], cpu_info[3]);
- static constexpr size_t kVendorNameSize = 3 * sizeof(cpu_info[1]);
- static_assert(kVendorNameSize < arraysize(cpu_string),
- "cpu_string too small");
- memcpy(cpu_string, &cpu_info[1], kVendorNameSize);
- cpu_string[kVendorNameSize] = '\0';
- cpu_vendor_ = cpu_string;
-
- // Interpret CPU feature information.
- if (num_ids > 0) {
- int cpu_info7[4] = {0};
- __cpuid(cpu_info, 1);
- if (num_ids >= 7) {
- __cpuid(cpu_info7, 7);
- }
- signature_ = cpu_info[0];
- stepping_ = cpu_info[0] & 0xf;
- model_ = ((cpu_info[0] >> 4) & 0xf) + ((cpu_info[0] >> 12) & 0xf0);
- family_ = (cpu_info[0] >> 8) & 0xf;
- type_ = (cpu_info[0] >> 12) & 0x3;
- ext_model_ = (cpu_info[0] >> 16) & 0xf;
- ext_family_ = (cpu_info[0] >> 20) & 0xff;
- has_mmx_ = (cpu_info[3] & 0x00800000) != 0;
- has_sse_ = (cpu_info[3] & 0x02000000) != 0;
- has_sse2_ = (cpu_info[3] & 0x04000000) != 0;
- has_sse3_ = (cpu_info[2] & 0x00000001) != 0;
- has_ssse3_ = (cpu_info[2] & 0x00000200) != 0;
- has_sse41_ = (cpu_info[2] & 0x00080000) != 0;
- has_sse42_ = (cpu_info[2] & 0x00100000) != 0;
- has_popcnt_ = (cpu_info[2] & 0x00800000) != 0;
-
- // AVX instructions will generate an illegal instruction exception unless
- // a) they are supported by the CPU,
- // b) XSAVE is supported by the CPU and
- // c) XSAVE is enabled by the kernel.
- // See http://software.intel.com/en-us/blogs/2011/04/14/is-avx-enabled
- //
- // In addition, we have observed some crashes with the xgetbv instruction
- // even after following Intel's example code. (See crbug.com/375968.)
- // Because of that, we also test the XSAVE bit because its description in
- // the CPUID documentation suggests that it signals xgetbv support.
- has_avx_ =
- (cpu_info[2] & 0x10000000) != 0 &&
- (cpu_info[2] & 0x04000000) != 0 /* XSAVE */ &&
- (cpu_info[2] & 0x08000000) != 0 /* OSXSAVE */ &&
- (_xgetbv(0) & 6) == 6 /* XSAVE enabled by kernel */;
- has_aesni_ = (cpu_info[2] & 0x02000000) != 0;
- has_avx2_ = has_avx_ && (cpu_info7[1] & 0x00000020) != 0;
- }
-
- // Get the brand string of the cpu.
- __cpuid(cpu_info, 0x80000000);
- const int max_parameter = cpu_info[0];
-
- static constexpr int kParameterStart = 0x80000002;
- static constexpr int kParameterEnd = 0x80000004;
- static constexpr int kParameterSize = kParameterEnd - kParameterStart + 1;
- static_assert(kParameterSize * sizeof(cpu_info) + 1 == arraysize(cpu_string),
- "cpu_string has wrong size");
-
- if (max_parameter >= kParameterEnd) {
- size_t i = 0;
- for (int parameter = kParameterStart; parameter <= kParameterEnd;
- ++parameter) {
- __cpuid(cpu_info, parameter);
- memcpy(&cpu_string[i], cpu_info, sizeof(cpu_info));
- i += sizeof(cpu_info);
- }
- cpu_string[i] = '\0';
- cpu_brand_ = cpu_string;
- }
-
- static constexpr int kParameterContainingNonStopTimeStampCounter = 0x80000007;
- if (max_parameter >= kParameterContainingNonStopTimeStampCounter) {
- __cpuid(cpu_info, kParameterContainingNonStopTimeStampCounter);
- has_non_stop_time_stamp_counter_ = (cpu_info[3] & (1 << 8)) != 0;
- }
-#elif defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
- cpu_brand_ = *CpuInfoBrand();
-#endif
-}
-
-CPU::IntelMicroArchitecture CPU::GetIntelMicroArchitecture() const {
- if (has_avx2()) return AVX2;
- if (has_avx()) return AVX;
- if (has_sse42()) return SSE42;
- if (has_sse41()) return SSE41;
- if (has_ssse3()) return SSSE3;
- if (has_sse3()) return SSE3;
- if (has_sse2()) return SSE2;
- if (has_sse()) return SSE;
- return PENTIUM;
-}
-
-} // namespace base
diff --git a/base/cpu.h b/base/cpu.h
deleted file mode 100644
index 2c6caea..0000000
--- a/base/cpu.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CPU_H_
-#define BASE_CPU_H_
-
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-
-// Query information about the processor.
-class BASE_EXPORT CPU final {
- public:
- CPU();
-
- enum IntelMicroArchitecture {
- PENTIUM,
- SSE,
- SSE2,
- SSE3,
- SSSE3,
- SSE41,
- SSE42,
- AVX,
- AVX2,
- MAX_INTEL_MICRO_ARCHITECTURE
- };
-
- // Accessors for CPU information.
- const std::string& vendor_name() const { return cpu_vendor_; }
- int signature() const { return signature_; }
- int stepping() const { return stepping_; }
- int model() const { return model_; }
- int family() const { return family_; }
- int type() const { return type_; }
- int extended_model() const { return ext_model_; }
- int extended_family() const { return ext_family_; }
- bool has_mmx() const { return has_mmx_; }
- bool has_sse() const { return has_sse_; }
- bool has_sse2() const { return has_sse2_; }
- bool has_sse3() const { return has_sse3_; }
- bool has_ssse3() const { return has_ssse3_; }
- bool has_sse41() const { return has_sse41_; }
- bool has_sse42() const { return has_sse42_; }
- bool has_popcnt() const { return has_popcnt_; }
- bool has_avx() const { return has_avx_; }
- bool has_avx2() const { return has_avx2_; }
- bool has_aesni() const { return has_aesni_; }
- bool has_non_stop_time_stamp_counter() const {
- return has_non_stop_time_stamp_counter_;
- }
-
- IntelMicroArchitecture GetIntelMicroArchitecture() const;
- const std::string& cpu_brand() const { return cpu_brand_; }
-
- private:
- // Query the processor for CPUID information.
- void Initialize();
-
- int signature_; // raw form of type, family, model, and stepping
- int type_; // process type
- int family_; // family of the processor
- int model_; // model of processor
- int stepping_; // processor revision number
- int ext_model_;
- int ext_family_;
- bool has_mmx_;
- bool has_sse_;
- bool has_sse2_;
- bool has_sse3_;
- bool has_ssse3_;
- bool has_sse41_;
- bool has_sse42_;
- bool has_popcnt_;
- bool has_avx_;
- bool has_avx2_;
- bool has_aesni_;
- bool has_non_stop_time_stamp_counter_;
- std::string cpu_vendor_;
- std::string cpu_brand_;
-};
-
-} // namespace base
-
-#endif // BASE_CPU_H_
diff --git a/base/file_descriptor_posix.h b/base/file_descriptor_posix.h
deleted file mode 100644
index 2a36611..0000000
--- a/base/file_descriptor_posix.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILE_DESCRIPTOR_POSIX_H_
-#define BASE_FILE_DESCRIPTOR_POSIX_H_
-
-#include "base/files/file.h"
-#include "base/files/scoped_file.h"
-
-namespace base {
-
-// -----------------------------------------------------------------------------
-// We introduct a special structure for file descriptors in order that we are
-// able to use template specialisation to special-case their handling.
-//
-// IMPORTANT: This is primarily intended for use when sending file descriptors
-// over IPC. Even if |auto_close| is true, base::FileDescriptor does NOT close()
-// |fd| when going out of scope. Instead, a consumer of a base::FileDescriptor
-// must invoke close() on |fd| if |auto_close| is true.
-//
-// In the case of IPC, the the IPC subsystem knows to close() |fd| after sending
-// a message that contains a base::FileDescriptor if auto_close == true. On the
-// other end, the receiver must make sure to close() |fd| after it has finished
-// processing the IPC message. See the IPC::ParamTraits<> specialization in
-// ipc/ipc_message_utils.h for all the details.
-// -----------------------------------------------------------------------------
-struct FileDescriptor {
- FileDescriptor() : fd(-1), auto_close(false) {}
-
- FileDescriptor(int ifd, bool iauto_close) : fd(ifd), auto_close(iauto_close) {
- }
-
- FileDescriptor(File file) : fd(file.TakePlatformFile()), auto_close(true) {}
- explicit FileDescriptor(ScopedFD fd) : fd(fd.release()), auto_close(true) {}
-
- bool operator==(const FileDescriptor& other) const {
- return (fd == other.fd && auto_close == other.auto_close);
- }
-
- bool operator!=(const FileDescriptor& other) const {
- return !operator==(other);
- }
-
- // A comparison operator so that we can use these as keys in a std::map.
- bool operator<(const FileDescriptor& other) const {
- return other.fd < fd;
- }
-
- int fd;
- // If true, this file descriptor should be closed after it has been used. For
- // example an IPC system might interpret this flag as indicating that the
- // file descriptor it has been given should be closed after use.
- bool auto_close;
-};
-
-} // namespace base
-
-#endif // BASE_FILE_DESCRIPTOR_POSIX_H_
diff --git a/base/file_descriptor_store.cc b/base/file_descriptor_store.cc
deleted file mode 100644
index 71cf2b3..0000000
--- a/base/file_descriptor_store.cc
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/file_descriptor_store.h"
-
-#include <utility>
-
-#include "base/logging.h"
-
-namespace base {
-
-FileDescriptorStore::Descriptor::Descriptor(const std::string& key,
- base::ScopedFD fd)
- : key(key),
- fd(std::move(fd)),
- region(base::MemoryMappedFile::Region::kWholeFile) {}
-
-FileDescriptorStore::Descriptor::Descriptor(
- const std::string& key,
- base::ScopedFD fd,
- base::MemoryMappedFile::Region region)
- : key(key), fd(std::move(fd)), region(region) {}
-
-FileDescriptorStore::Descriptor::Descriptor(
- FileDescriptorStore::Descriptor&& other)
- : key(other.key), fd(std::move(other.fd)), region(other.region) {}
-
-FileDescriptorStore::Descriptor::~Descriptor() = default;
-
-// static
-FileDescriptorStore& FileDescriptorStore::GetInstance() {
- static FileDescriptorStore* store = new FileDescriptorStore;
- return *store;
-}
-
-base::ScopedFD FileDescriptorStore::TakeFD(
- const std::string& key,
- base::MemoryMappedFile::Region* region) {
- base::ScopedFD fd = MaybeTakeFD(key, region);
- if (!fd.is_valid())
- DLOG(DCHECK) << "Unknown global descriptor: " << key;
- return fd;
-}
-
-base::ScopedFD FileDescriptorStore::MaybeTakeFD(
- const std::string& key,
- base::MemoryMappedFile::Region* region) {
- auto iter = descriptors_.find(key);
- if (iter == descriptors_.end())
- return base::ScopedFD();
- *region = iter->second.region;
- base::ScopedFD result = std::move(iter->second.fd);
- descriptors_.erase(iter);
- return result;
-}
-
-void FileDescriptorStore::Set(const std::string& key, base::ScopedFD fd) {
- Set(key, std::move(fd), base::MemoryMappedFile::Region::kWholeFile);
-}
-
-void FileDescriptorStore::Set(const std::string& key,
- base::ScopedFD fd,
- base::MemoryMappedFile::Region region) {
- Descriptor descriptor(key, std::move(fd), region);
- descriptors_.insert(std::make_pair(key, std::move(descriptor)));
-}
-
-FileDescriptorStore::FileDescriptorStore() = default;
-
-FileDescriptorStore::~FileDescriptorStore() = default;
-
-} // namespace base
diff --git a/base/file_descriptor_store.h b/base/file_descriptor_store.h
deleted file mode 100644
index b6bd079..0000000
--- a/base/file_descriptor_store.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILE_DESCRIPTOR_STORE_H_
-#define BASE_FILE_DESCRIPTOR_STORE_H_
-
-#include <map>
-#include <string>
-
-#include "base/files/memory_mapped_file.h"
-#include "base/files/scoped_file.h"
-#include "base/macros.h"
-
-namespace base {
-
-// The file descriptor store is used to associate file descriptors with keys
-// that must be unique.
-// It is used to share file descriptors from a process to its child.
-class BASE_EXPORT FileDescriptorStore {
- public:
- struct Descriptor {
- Descriptor(const std::string& key, base::ScopedFD fd);
- Descriptor(const std::string& key,
- base::ScopedFD fd,
- base::MemoryMappedFile::Region region);
- Descriptor(Descriptor&& other);
- ~Descriptor();
-
- Descriptor& operator=(Descriptor&& other) = default;
-
- // Globally unique key.
- std::string key;
- // Actual FD.
- base::ScopedFD fd;
- // Optional region, defaults to kWholeFile.
- base::MemoryMappedFile::Region region;
- };
- using Mapping = std::map<std::string, Descriptor>;
-
- // Returns the singleton instance of FileDescriptorStore.
- static FileDescriptorStore& GetInstance();
-
- // Gets a descriptor given a key and also populates |region|.
- // It is a fatal error if the key is not known.
- base::ScopedFD TakeFD(const std::string& key,
- base::MemoryMappedFile::Region* region);
-
- // Gets a descriptor given a key. Returns an empty ScopedFD on error.
- base::ScopedFD MaybeTakeFD(const std::string& key,
- base::MemoryMappedFile::Region* region);
-
- // Sets the descriptor for the given |key|. This sets the region associated
- // with |key| to kWholeFile.
- void Set(const std::string& key, base::ScopedFD fd);
-
- // Sets the descriptor and |region| for the given |key|.
- void Set(const std::string& key,
- base::ScopedFD fd,
- base::MemoryMappedFile::Region region);
-
- private:
- FileDescriptorStore();
- ~FileDescriptorStore();
-
- Mapping descriptors_;
-
- DISALLOW_COPY_AND_ASSIGN(FileDescriptorStore);
-};
-
-} // namespace base
-
-#endif // BASE_FILE_DESCRIPTOR_STORE_H_
diff --git a/base/files/file_util.h b/base/files/file_util.h
index 9c7c748..d95410a 100644
--- a/base/files/file_util.h
+++ b/base/files/file_util.h
@@ -30,7 +30,6 @@
#if defined(OS_WIN)
#include "base/win/windows_types.h"
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include "base/file_descriptor_posix.h"
#include "base/logging.h"
#include "base/posix/eintr_wrapper.h"
#endif
diff --git a/base/files/file_util_win.cc b/base/files/file_util_win.cc
index c1a5ced..d59b7e4 100644
--- a/base/files/file_util_win.cc
+++ b/base/files/file_util_win.cc
@@ -23,7 +23,6 @@
#include "base/logging.h"
#include "base/macros.h"
#include "base/process/process_handle.h"
-#include "base/rand_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
@@ -33,6 +32,13 @@
#include "base/win/scoped_handle.h"
#include "base/win/windows_version.h"
+// #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036. See the
+// "Community Additions" comment on MSDN here:
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx
+#define SystemFunction036 NTAPI SystemFunction036
+#include <NTSecAPI.h>
+#undef SystemFunction036
+
namespace base {
namespace {
@@ -258,11 +264,24 @@
bytes[1] & 0x0000ffff'ffffffffULL);
}
+void RandBytes(void* output, size_t output_length) {
+ char* output_ptr = static_cast<char*>(output);
+ while (output_length > 0) {
+ const ULONG output_bytes_this_pass = static_cast<ULONG>(std::min(
+ output_length, static_cast<size_t>(std::numeric_limits<ULONG>::max())));
+ const bool success =
+ RtlGenRandom(output_ptr, output_bytes_this_pass) != FALSE;
+ CHECK(success);
+ output_length -= output_bytes_this_pass;
+ output_ptr += output_bytes_this_pass;
+ }
+}
+
std::string GenerateGUID() {
uint64_t sixteen_bytes[2];
// Use base::RandBytes instead of crypto::RandBytes, because crypto calls the
// base version directly, and to prevent the dependency from base/ to crypto/.
- base::RandBytes(&sixteen_bytes, sizeof(sixteen_bytes));
+ RandBytes(&sixteen_bytes, sizeof(sixteen_bytes));
// Set the GUID to version 4 as described in RFC 4122, section 4.4.
// The format of GUID version 4 must be xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx,
@@ -488,8 +507,7 @@
new_dir_name.assign(prefix);
new_dir_name.append(IntToString16(GetCurrentProcId()));
new_dir_name.push_back('_');
- new_dir_name.append(
- IntToString16(RandInt(0, std::numeric_limits<int16_t>::max())));
+ new_dir_name.append(UTF8ToUTF16(GenerateGUID()));
path_to_create = base_dir.Append(new_dir_name);
if (::CreateDirectory(path_to_create.value().c_str(), NULL)) {
diff --git a/base/format_macros.h b/base/format_macros.h
deleted file mode 100644
index 46cd12c..0000000
--- a/base/format_macros.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FORMAT_MACROS_H_
-#define BASE_FORMAT_MACROS_H_
-
-// This file defines the format macros for some integer types.
-
-// To print a 64-bit value in a portable way:
-// int64_t value;
-// printf("xyz:%" PRId64, value);
-// The "d" in the macro corresponds to %d; you can also use PRIu64 etc.
-//
-// For wide strings, prepend "Wide" to the macro:
-// int64_t value;
-// StringPrintf(L"xyz: %" WidePRId64, value);
-//
-// To print a size_t value in a portable way:
-// size_t size;
-// printf("xyz: %" PRIuS, size);
-// The "u" in the macro corresponds to %u, and S is for "size".
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "build_config.h"
-
-#if (defined(OS_POSIX) || defined(OS_FUCHSIA)) && \
- (defined(_INTTYPES_H) || defined(_INTTYPES_H_)) && !defined(PRId64)
-#error "inttypes.h has already been included before this header file, but "
-#error "without __STDC_FORMAT_MACROS defined."
-#endif
-
-#if (defined(OS_POSIX) || defined(OS_FUCHSIA)) && !defined(__STDC_FORMAT_MACROS)
-#define __STDC_FORMAT_MACROS
-#endif
-
-#include <inttypes.h>
-
-#if defined(OS_WIN)
-
-#if !defined(PRId64) || !defined(PRIu64) || !defined(PRIx64)
-#error "inttypes.h provided by win toolchain should define these."
-#endif
-
-#define WidePRId64 L"I64d"
-#define WidePRIu64 L"I64u"
-#define WidePRIx64 L"I64x"
-
-#if !defined(PRIuS)
-#define PRIuS "Iu"
-#endif
-
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-// GCC will concatenate wide and narrow strings correctly, so nothing needs to
-// be done here.
-#define WidePRId64 PRId64
-#define WidePRIu64 PRIu64
-#define WidePRIx64 PRIx64
-
-#if !defined(PRIuS)
-#define PRIuS "zu"
-#endif
-
-#endif // defined(OS_WIN)
-
-// The size of NSInteger and NSUInteger varies between 32-bit and 64-bit
-// architectures and Apple does not provides standard format macros and
-// recommends casting. This has many drawbacks, so instead define macros
-// for formatting those types.
-#if defined(OS_MACOSX)
-#if defined(ARCH_CPU_64_BITS)
-#if !defined(PRIdNS)
-#define PRIdNS "ld"
-#endif
-#if !defined(PRIuNS)
-#define PRIuNS "lu"
-#endif
-#if !defined(PRIxNS)
-#define PRIxNS "lx"
-#endif
-#else // defined(ARCH_CPU_64_BITS)
-#if !defined(PRIdNS)
-#define PRIdNS "d"
-#endif
-#if !defined(PRIuNS)
-#define PRIuNS "u"
-#endif
-#if !defined(PRIxNS)
-#define PRIxNS "x"
-#endif
-#endif
-#endif // defined(OS_MACOSX)
-
-#endif // BASE_FORMAT_MACROS_H_
diff --git a/base/hash.cc b/base/hash.cc
deleted file mode 100644
index ab5cebc..0000000
--- a/base/hash.cc
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/hash.h"
-
-// Definition in base/third_party/superfasthash/superfasthash.c. (Third-party
-// code did not come with its own header file, so declaring the function here.)
-// Note: This algorithm is also in Blink under Source/wtf/StringHasher.h.
-extern "C" uint32_t SuperFastHash(const char* data, int len);
-
-namespace base {
-
-uint32_t Hash(const void* data, size_t length) {
- // Currently our in-memory hash is the same as the persistent hash. The
- // split between in-memory and persistent hash functions is maintained to
- // allow the in-memory hash function to be updated in the future.
- return PersistentHash(data, length);
-}
-
-uint32_t Hash(const std::string& str) {
- return PersistentHash(str.data(), str.size());
-}
-
-uint32_t Hash(const string16& str) {
- return PersistentHash(str.data(), str.size() * sizeof(char16));
-}
-
-uint32_t PersistentHash(const void* data, size_t length) {
- // This hash function must not change, since it is designed to be persistable
- // to disk.
- if (length > static_cast<size_t>(std::numeric_limits<int>::max())) {
- NOTREACHED();
- return 0;
- }
- return ::SuperFastHash(reinterpret_cast<const char*>(data),
- static_cast<int>(length));
-}
-
-uint32_t PersistentHash(const std::string& str) {
- return PersistentHash(str.data(), str.size());
-}
-
-// Implement hashing for pairs of at-most 32 bit integer values.
-// When size_t is 32 bits, we turn the 64-bit hash code into 32 bits by using
-// multiply-add hashing. This algorithm, as described in
-// Theorem 4.3.3 of the thesis "Über die Komplexität der Multiplikation in
-// eingeschränkten Branchingprogrammmodellen" by Woelfel, is:
-//
-// h32(x32, y32) = (h64(x32, y32) * rand_odd64 + rand16 * 2^16) % 2^64 / 2^32
-//
-// Contact danakj@chromium.org for any questions.
-size_t HashInts32(uint32_t value1, uint32_t value2) {
- uint64_t value1_64 = value1;
- uint64_t hash64 = (value1_64 << 32) | value2;
-
- if (sizeof(size_t) >= sizeof(uint64_t))
- return static_cast<size_t>(hash64);
-
- uint64_t odd_random = 481046412LL << 32 | 1025306955LL;
- uint32_t shift_random = 10121U << 16;
-
- hash64 = hash64 * odd_random + shift_random;
- size_t high_bits =
- static_cast<size_t>(hash64 >> (8 * (sizeof(uint64_t) - sizeof(size_t))));
- return high_bits;
-}
-
-// Implement hashing for pairs of up-to 64-bit integer values.
-// We use the compound integer hash method to produce a 64-bit hash code, by
-// breaking the two 64-bit inputs into 4 32-bit values:
-// http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000
-// Then we reduce our result to 32 bits if required, similar to above.
-size_t HashInts64(uint64_t value1, uint64_t value2) {
- uint32_t short_random1 = 842304669U;
- uint32_t short_random2 = 619063811U;
- uint32_t short_random3 = 937041849U;
- uint32_t short_random4 = 3309708029U;
-
- uint32_t value1a = static_cast<uint32_t>(value1 & 0xffffffff);
- uint32_t value1b = static_cast<uint32_t>((value1 >> 32) & 0xffffffff);
- uint32_t value2a = static_cast<uint32_t>(value2 & 0xffffffff);
- uint32_t value2b = static_cast<uint32_t>((value2 >> 32) & 0xffffffff);
-
- uint64_t product1 = static_cast<uint64_t>(value1a) * short_random1;
- uint64_t product2 = static_cast<uint64_t>(value1b) * short_random2;
- uint64_t product3 = static_cast<uint64_t>(value2a) * short_random3;
- uint64_t product4 = static_cast<uint64_t>(value2b) * short_random4;
-
- uint64_t hash64 = product1 + product2 + product3 + product4;
-
- if (sizeof(size_t) >= sizeof(uint64_t))
- return static_cast<size_t>(hash64);
-
- uint64_t odd_random = 1578233944LL << 32 | 194370989LL;
- uint32_t shift_random = 20591U << 16;
-
- hash64 = hash64 * odd_random + shift_random;
- size_t high_bits =
- static_cast<size_t>(hash64 >> (8 * (sizeof(uint64_t) - sizeof(size_t))));
- return high_bits;
-}
-
-} // namespace base
diff --git a/base/hash.h b/base/hash.h
deleted file mode 100644
index 165899e..0000000
--- a/base/hash.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_HASH_H_
-#define BASE_HASH_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-#include <string>
-#include <utility>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/strings/string16.h"
-
-namespace base {
-
-// Computes a hash of a memory buffer. This hash function is subject to change
-// in the future, so use only for temporary in-memory structures. If you need
-// to persist a change on disk or between computers, use PersistentHash().
-//
-// WARNING: This hash function should not be used for any cryptographic purpose.
-BASE_EXPORT uint32_t Hash(const void* data, size_t length);
-BASE_EXPORT uint32_t Hash(const std::string& str);
-BASE_EXPORT uint32_t Hash(const string16& str);
-
-// Computes a hash of a memory buffer. This hash function must not change so
-// that code can use the hashed values for persistent storage purposes or
-// sending across the network. If a new persistent hash function is desired, a
-// new version will have to be added in addition.
-//
-// WARNING: This hash function should not be used for any cryptographic purpose.
-BASE_EXPORT uint32_t PersistentHash(const void* data, size_t length);
-BASE_EXPORT uint32_t PersistentHash(const std::string& str);
-
-// Hash pairs of 32-bit or 64-bit numbers.
-BASE_EXPORT size_t HashInts32(uint32_t value1, uint32_t value2);
-BASE_EXPORT size_t HashInts64(uint64_t value1, uint64_t value2);
-
-template <typename T1, typename T2>
-inline size_t HashInts(T1 value1, T2 value2) {
- // This condition is expected to be compile-time evaluated and optimised away
- // in release builds.
- if (sizeof(T1) > sizeof(uint32_t) || (sizeof(T2) > sizeof(uint32_t)))
- return HashInts64(value1, value2);
-
- return HashInts32(value1, value2);
-}
-
-// A templated hasher for pairs of integer types. Example:
-//
-// using MyPair = std::pair<int32_t, int32_t>;
-// std::unordered_set<MyPair, base::IntPairHash<MyPair>> set;
-template <typename T>
-struct IntPairHash;
-
-template <typename Type1, typename Type2>
-struct IntPairHash<std::pair<Type1, Type2>> {
- size_t operator()(std::pair<Type1, Type2> value) const {
- return HashInts(value.first, value.second);
- }
-};
-
-} // namespace base
-
-#endif // BASE_HASH_H_
diff --git a/base/json/OWNERS b/base/json/OWNERS
deleted file mode 100644
index 14fce2a..0000000
--- a/base/json/OWNERS
+++ /dev/null
@@ -1 +0,0 @@
-rsesek@chromium.org
diff --git a/base/json/json_correctness_fuzzer.cc b/base/json/json_correctness_fuzzer.cc
deleted file mode 100644
index 1f32d8c..0000000
--- a/base/json/json_correctness_fuzzer.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// A fuzzer that checks correctness of json parser/writer.
-// The fuzzer input is passed through parsing twice,
-// so that presumably valid json is parsed/written again.
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/json/string_escape.h"
-#include "base/logging.h"
-#include "base/values.h"
-
-// Entry point for libFuzzer.
-// We will use the last byte of data as parsing options.
-// The rest will be used as text input to the parser.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- if (size < 2)
- return 0;
-
- int error_code, error_line, error_column;
- std::string error_message;
-
- // Create a copy of input buffer, as otherwise we don't catch
- // overflow that touches the last byte (which is used in options).
- std::unique_ptr<char[]> input(new char[size - 1]);
- memcpy(input.get(), data, size - 1);
-
- base::StringPiece input_string(input.get(), size - 1);
-
- const int options = data[size - 1];
- auto parsed_value = base::JSONReader::ReadAndReturnError(
- input_string, options, &error_code, &error_message, &error_line,
- &error_column);
- if (!parsed_value)
- return 0;
-
- std::string parsed_output;
- bool b = base::JSONWriter::Write(*parsed_value, &parsed_output);
- LOG_ASSERT(b);
-
- auto double_parsed_value = base::JSONReader::ReadAndReturnError(
- parsed_output, options, &error_code, &error_message, &error_line,
- &error_column);
- LOG_ASSERT(double_parsed_value);
- std::string double_parsed_output;
- bool b2 =
- base::JSONWriter::Write(*double_parsed_value, &double_parsed_output);
- LOG_ASSERT(b2);
-
- LOG_ASSERT(parsed_output == double_parsed_output)
- << "Parser/Writer mismatch."
- << "\nInput=" << base::GetQuotedJSONString(parsed_output)
- << "\nOutput=" << base::GetQuotedJSONString(double_parsed_output);
-
- return 0;
-}
diff --git a/base/json/json_reader_fuzzer.cc b/base/json/json_reader_fuzzer.cc
deleted file mode 100644
index a8490da..0000000
--- a/base/json/json_reader_fuzzer.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/json/json_reader.h"
-#include "base/values.h"
-
-int error_code, error_line, error_column;
-std::string error_message;
-
-// Entry point for LibFuzzer.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- if (size < 2)
- return 0;
-
- // Create a copy of input buffer, as otherwise we don't catch
- // overflow that touches the last byte (which is used in options).
- std::unique_ptr<char[]> input(new char[size - 1]);
- memcpy(input.get(), data, size - 1);
-
- base::StringPiece input_string(input.get(), size - 1);
-
- const int options = data[size - 1];
- base::JSONReader::ReadAndReturnError(input_string, options, &error_code,
- &error_message, &error_line,
- &error_column);
-
- return 0;
-}
diff --git a/base/json/string_escape_fuzzer.cc b/base/json/string_escape_fuzzer.cc
deleted file mode 100644
index e44bd4f..0000000
--- a/base/json/string_escape_fuzzer.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/json/string_escape.h"
-
-#include <memory>
-
-std::string escaped_string;
-
-// Entry point for LibFuzzer.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- if (size < 2)
- return 0;
-
- const bool put_in_quotes = data[size - 1];
-
- // Create a copy of input buffer, as otherwise we don't catch
- // overflow that touches the last byte (which is used in put_in_quotes).
- size_t actual_size_char8 = size - 1;
- std::unique_ptr<char[]> input(new char[actual_size_char8]);
- memcpy(input.get(), data, actual_size_char8);
-
- base::StringPiece input_string(input.get(), actual_size_char8);
- base::EscapeJSONString(input_string, put_in_quotes, &escaped_string);
-
- // Test for wide-strings if available size is even.
- if (actual_size_char8 & 1)
- return 0;
-
- size_t actual_size_char16 = actual_size_char8 / 2;
- base::StringPiece16 input_string16(
- reinterpret_cast<base::char16*>(input.get()), actual_size_char16);
- base::EscapeJSONString(input_string16, put_in_quotes, &escaped_string);
-
- return 0;
-}
diff --git a/base/linux_util.cc b/base/linux_util.cc
deleted file mode 100644
index 1f3ae49..0000000
--- a/base/linux_util.cc
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/linux_util.h"
-
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/command_line.h"
-#include "base/files/file_util.h"
-#include "base/memory/singleton.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_tokenizer.h"
-#include "base/strings/string_util.h"
-#include "base/synchronization/lock.h"
-#include "build_config.h"
-
-namespace {
-
-// Not needed for OS_CHROMEOS.
-#if defined(OS_LINUX)
-enum LinuxDistroState {
- STATE_DID_NOT_CHECK = 0,
- STATE_CHECK_STARTED = 1,
- STATE_CHECK_FINISHED = 2,
-};
-
-// Helper class for GetLinuxDistro().
-class LinuxDistroHelper {
- public:
- // Retrieves the Singleton.
- static LinuxDistroHelper* GetInstance() {
- return base::Singleton<LinuxDistroHelper>::get();
- }
-
- // The simple state machine goes from:
- // STATE_DID_NOT_CHECK -> STATE_CHECK_STARTED -> STATE_CHECK_FINISHED.
- LinuxDistroHelper() : state_(STATE_DID_NOT_CHECK) {}
- ~LinuxDistroHelper() = default;
-
- // Retrieve the current state, if we're in STATE_DID_NOT_CHECK,
- // we automatically move to STATE_CHECK_STARTED so nobody else will
- // do the check.
- LinuxDistroState State() {
- base::AutoLock scoped_lock(lock_);
- if (STATE_DID_NOT_CHECK == state_) {
- state_ = STATE_CHECK_STARTED;
- return STATE_DID_NOT_CHECK;
- }
- return state_;
- }
-
- // Indicate the check finished, move to STATE_CHECK_FINISHED.
- void CheckFinished() {
- base::AutoLock scoped_lock(lock_);
- DCHECK_EQ(STATE_CHECK_STARTED, state_);
- state_ = STATE_CHECK_FINISHED;
- }
-
- private:
- base::Lock lock_;
- LinuxDistroState state_;
-};
-#endif // if defined(OS_LINUX)
-
-bool GetTasksForProcess(pid_t pid, std::vector<pid_t>* tids) {
- char buf[256];
- snprintf(buf, sizeof(buf), "/proc/%d/task", pid);
-
- DIR* task = opendir(buf);
- if (!task) {
- DLOG(WARNING) << "Cannot open " << buf;
- return false;
- }
-
- struct dirent* dent;
- while ((dent = readdir(task))) {
- char* endptr;
- const unsigned long int tid_ul = strtoul(dent->d_name, &endptr, 10);
- if (tid_ul == ULONG_MAX || *endptr)
- continue;
- tids->push_back(tid_ul);
- }
- closedir(task);
- return true;
-}
-
-} // namespace
-
-namespace base {
-
-// Account for the terminating null character.
-static const int kDistroSize = 128 + 1;
-
-// We use this static string to hold the Linux distro info. If we
-// crash, the crash handler code will send this in the crash dump.
-char g_linux_distro[kDistroSize] = "Unknown";
-
-std::string GetLinuxDistro() {
- LinuxDistroHelper* distro_state_singleton = LinuxDistroHelper::GetInstance();
- LinuxDistroState state = distro_state_singleton->State();
- if (STATE_CHECK_FINISHED == state)
- return g_linux_distro;
- if (STATE_CHECK_STARTED == state)
- return "Unknown"; // Don't wait for other thread to finish.
- DCHECK_EQ(state, STATE_DID_NOT_CHECK);
- // We do this check only once per process. If it fails, there's
- // little reason to believe it will work if we attempt to run
- // lsb_release again.
- std::vector<std::string> argv;
- argv.push_back("lsb_release");
- argv.push_back("-d");
- std::string output;
- GetAppOutput(CommandLine(argv), &output);
- if (output.length() > 0) {
- // lsb_release -d should return: Description:<tab>Distro Info
- const char field[] = "Description:\t";
- if (output.compare(0, strlen(field), field) == 0) {
- SetLinuxDistro(output.substr(strlen(field)));
- }
- }
- distro_state_singleton->CheckFinished();
- return g_linux_distro;
-}
-
-void SetLinuxDistro(const std::string& distro) {
- std::string trimmed_distro;
- TrimWhitespaceASCII(distro, TRIM_ALL, &trimmed_distro);
- strlcpy(g_linux_distro, trimmed_distro.c_str(), kDistroSize);
-}
-
-pid_t FindThreadIDWithSyscall(pid_t pid, const std::string& expected_data,
- bool* syscall_supported) {
- if (syscall_supported != nullptr)
- *syscall_supported = false;
-
- std::vector<pid_t> tids;
- if (!GetTasksForProcess(pid, &tids))
- return -1;
-
- std::unique_ptr<char[]> syscall_data(new char[expected_data.length()]);
- for (pid_t tid : tids) {
- char buf[256];
- snprintf(buf, sizeof(buf), "/proc/%d/task/%d/syscall", pid, tid);
- int fd = open(buf, O_RDONLY);
- if (fd < 0)
- continue;
- if (syscall_supported != nullptr)
- *syscall_supported = true;
- bool read_ret = ReadFromFD(fd, syscall_data.get(), expected_data.length());
- close(fd);
- if (!read_ret)
- continue;
-
- if (0 == strncmp(expected_data.c_str(), syscall_data.get(),
- expected_data.length())) {
- return tid;
- }
- }
- return -1;
-}
-
-pid_t FindThreadID(pid_t pid, pid_t ns_tid, bool* ns_pid_supported) {
- if (ns_pid_supported)
- *ns_pid_supported = false;
-
- std::vector<pid_t> tids;
- if (!GetTasksForProcess(pid, &tids))
- return -1;
-
- for (pid_t tid : tids) {
- char buf[256];
- snprintf(buf, sizeof(buf), "/proc/%d/task/%d/status", pid, tid);
- std::string status;
- if (!ReadFileToString(FilePath(buf), &status))
- return -1;
- StringTokenizer tokenizer(status, "\n");
- while (tokenizer.GetNext()) {
- StringPiece value_str(tokenizer.token_piece());
- if (!value_str.starts_with("NSpid"))
- continue;
- if (ns_pid_supported)
- *ns_pid_supported = true;
- std::vector<StringPiece> split_value_str = SplitStringPiece(
- value_str, "\t", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
- DCHECK_GE(split_value_str.size(), 2u);
- int value;
- // The last value in the list is the PID in the namespace.
- if (StringToInt(split_value_str.back(), &value) && value == ns_tid) {
- // The second value in the list is the real PID.
- if (StringToInt(split_value_str[1], &value))
- return value;
- }
- break;
- }
- }
- return -1;
-}
-
-} // namespace base
diff --git a/base/linux_util.h b/base/linux_util.h
deleted file mode 100644
index 272e06b..0000000
--- a/base/linux_util.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_LINUX_UTIL_H_
-#define BASE_LINUX_UTIL_H_
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-
-// This is declared here so the crash reporter can access the memory directly
-// in compromised context without going through the standard library.
-BASE_EXPORT extern char g_linux_distro[];
-
-// Get the Linux Distro if we can, or return "Unknown".
-BASE_EXPORT std::string GetLinuxDistro();
-
-// Set the Linux Distro string.
-BASE_EXPORT void SetLinuxDistro(const std::string& distro);
-
-// For a given process |pid|, look through all its threads and find the first
-// thread with /proc/[pid]/task/[thread_id]/syscall whose first N bytes matches
-// |expected_data|, where N is the length of |expected_data|.
-// Returns the thread id or -1 on error. If |syscall_supported| is
-// set to false the kernel does not support syscall in procfs.
-BASE_EXPORT pid_t FindThreadIDWithSyscall(pid_t pid,
- const std::string& expected_data,
- bool* syscall_supported);
-
-// For a given process |pid|, look through all its threads and find the first
-// thread with /proc/[pid]/task/[thread_id]/status where NSpid matches |ns_tid|.
-// Returns the thread id or -1 on error. If |ns_pid_supported| is
-// set to false the kernel does not support NSpid in procfs.
-BASE_EXPORT pid_t FindThreadID(pid_t pid, pid_t ns_tid, bool* ns_pid_supported);
-
-} // namespace base
-
-#endif // BASE_LINUX_UTIL_H_
diff --git a/base/mac/OWNERS b/base/mac/OWNERS
deleted file mode 100644
index 93e90e0..0000000
--- a/base/mac/OWNERS
+++ /dev/null
@@ -1,8 +0,0 @@
-mark@chromium.org
-thakis@chromium.org
-
-# sdk_forward_declarations.[h|mm] will likely need to be modified by Cocoa
-# developers in general.
-per-file sdk_forward_declarations.*=file://chrome/browser/ui/cocoa/OWNERS
-
-# COMPONENT: Internals
diff --git a/base/mac/authorization_util.h b/base/mac/authorization_util.h
deleted file mode 100644
index 4629039..0000000
--- a/base/mac/authorization_util.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_AUTHORIZATION_UTIL_H_
-#define BASE_MAC_AUTHORIZATION_UTIL_H_
-
-// AuthorizationExecuteWithPrivileges fork()s and exec()s the tool, but it
-// does not wait() for it. It also doesn't provide the caller with access to
-// the forked pid. If used irresponsibly, zombie processes will accumulate.
-//
-// Apple's really gotten us between a rock and a hard place, here.
-//
-// Fortunately, AuthorizationExecuteWithPrivileges does give access to the
-// tool's stdout (and stdin) via a FILE* pipe. The tool can output its pid
-// to this pipe, and the main program can read it, and then have something
-// that it can wait() for.
-//
-// The contract is that any tool executed by the wrappers declared in this
-// file must print its pid to stdout on a line by itself before doing anything
-// else.
-//
-// http://developer.apple.com/library/mac/#samplecode/BetterAuthorizationSample/Listings/BetterAuthorizationSampleLib_c.html
-// (Look for "What's This About Zombies?")
-
-#include <CoreFoundation/CoreFoundation.h>
-#include <Security/Authorization.h>
-#include <stdio.h>
-#include <sys/types.h>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace mac {
-
-// Obtains an AuthorizationRef for the rights indicated by |rights|. If
-// necessary, prompts the user for authentication. If the user is prompted,
-// |prompt| will be used as the prompt string and an icon appropriate for the
-// application will be displayed in a prompt dialog. Note that the system
-// appends its own text to the prompt string. |extraFlags| will be ORed
-// together with the default flags. Returns NULL on failure.
-BASE_EXPORT
-AuthorizationRef GetAuthorizationRightsWithPrompt(
- AuthorizationRights* rights,
- CFStringRef prompt,
- AuthorizationFlags extraFlags);
-
-// Obtains an AuthorizationRef (using |GetAuthorizationRightsWithPrompt|) that
-// can be used to run commands as root.
-BASE_EXPORT
-AuthorizationRef AuthorizationCreateToRunAsRoot(CFStringRef prompt);
-
-// Calls straight through to AuthorizationExecuteWithPrivileges. If that
-// call succeeds, |pid| will be set to the pid of the executed tool. If the
-// pid can't be determined, |pid| will be set to -1. |pid| must not be NULL.
-// |pipe| may be NULL, but the tool will always be executed with a pipe in
-// order to read the pid from its stdout.
-BASE_EXPORT
-OSStatus ExecuteWithPrivilegesAndGetPID(AuthorizationRef authorization,
- const char* tool_path,
- AuthorizationFlags options,
- const char** arguments,
- FILE** pipe,
- pid_t* pid);
-
-// Calls ExecuteWithPrivilegesAndGetPID, and if that call succeeds, calls
-// waitpid() to wait for the process to exit. If waitpid() succeeds, the
-// exit status is placed in |exit_status|, otherwise, -1 is stored.
-// |exit_status| may be NULL and this function will still wait for the process
-// to exit.
-BASE_EXPORT
-OSStatus ExecuteWithPrivilegesAndWait(AuthorizationRef authorization,
- const char* tool_path,
- AuthorizationFlags options,
- const char** arguments,
- FILE** pipe,
- int* exit_status);
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_AUTHORIZATION_UTIL_H_
diff --git a/base/mac/authorization_util.mm b/base/mac/authorization_util.mm
deleted file mode 100644
index a3bc4f9..0000000
--- a/base/mac/authorization_util.mm
+++ /dev/null
@@ -1,201 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/authorization_util.h"
-
-#import <Foundation/Foundation.h>
-#include <stddef.h>
-#include <sys/wait.h>
-
-#include <string>
-
-#include "base/logging.h"
-#include "base/mac/bundle_locations.h"
-#include "base/mac/foundation_util.h"
-#include "base/mac/mac_logging.h"
-#include "base/mac/scoped_authorizationref.h"
-#include "base/macros.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-namespace mac {
-
-AuthorizationRef GetAuthorizationRightsWithPrompt(
- AuthorizationRights* rights,
- CFStringRef prompt,
- AuthorizationFlags extraFlags) {
- // Create an empty AuthorizationRef.
- ScopedAuthorizationRef authorization;
- OSStatus status = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment,
- kAuthorizationFlagDefaults,
- authorization.get_pointer());
- if (status != errAuthorizationSuccess) {
- OSSTATUS_LOG(ERROR, status) << "AuthorizationCreate";
- return NULL;
- }
-
- AuthorizationFlags flags = kAuthorizationFlagDefaults |
- kAuthorizationFlagInteractionAllowed |
- kAuthorizationFlagExtendRights |
- kAuthorizationFlagPreAuthorize |
- extraFlags;
-
- // product_logo_32.png is used instead of app.icns because Authorization
- // Services can't deal with .icns files.
- NSString* icon_path =
- [base::mac::FrameworkBundle() pathForResource:@"product_logo_32"
- ofType:@"png"];
- const char* icon_path_c = [icon_path fileSystemRepresentation];
- size_t icon_path_length = icon_path_c ? strlen(icon_path_c) : 0;
-
- // The OS will dispay |prompt| along with a sentence asking the user to type
- // the "password to allow this."
- NSString* prompt_ns = base::mac::CFToNSCast(prompt);
- const char* prompt_c = [prompt_ns UTF8String];
- size_t prompt_length = prompt_c ? strlen(prompt_c) : 0;
-
- AuthorizationItem environment_items[] = {
- {kAuthorizationEnvironmentIcon, icon_path_length, (void*)icon_path_c, 0},
- {kAuthorizationEnvironmentPrompt, prompt_length, (void*)prompt_c, 0}
- };
-
- AuthorizationEnvironment environment = {arraysize(environment_items),
- environment_items};
-
- status = AuthorizationCopyRights(authorization,
- rights,
- &environment,
- flags,
- NULL);
-
- if (status != errAuthorizationSuccess) {
- if (status != errAuthorizationCanceled) {
- OSSTATUS_LOG(ERROR, status) << "AuthorizationCopyRights";
- }
- return NULL;
- }
-
- return authorization.release();
-}
-
-AuthorizationRef AuthorizationCreateToRunAsRoot(CFStringRef prompt) {
- // Specify the "system.privilege.admin" right, which allows
- // AuthorizationExecuteWithPrivileges to run commands as root.
- AuthorizationItem right_items[] = {
- {kAuthorizationRightExecute, 0, NULL, 0}
- };
- AuthorizationRights rights = {arraysize(right_items), right_items};
-
- return GetAuthorizationRightsWithPrompt(&rights, prompt, 0);
-}
-
-OSStatus ExecuteWithPrivilegesAndGetPID(AuthorizationRef authorization,
- const char* tool_path,
- AuthorizationFlags options,
- const char** arguments,
- FILE** pipe,
- pid_t* pid) {
- // pipe may be NULL, but this function needs one. In that case, use a local
- // pipe.
- FILE* local_pipe;
- FILE** pipe_pointer;
- if (pipe) {
- pipe_pointer = pipe;
- } else {
- pipe_pointer = &local_pipe;
- }
-
-// AuthorizationExecuteWithPrivileges is deprecated in macOS 10.7, but no good
-// replacement exists. https://crbug.com/593133.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- // AuthorizationExecuteWithPrivileges wants |char* const*| for |arguments|,
- // but it doesn't actually modify the arguments, and that type is kind of
- // silly and callers probably aren't dealing with that. Put the cast here
- // to make things a little easier on callers.
- OSStatus status = AuthorizationExecuteWithPrivileges(authorization,
- tool_path,
- options,
- (char* const*)arguments,
- pipe_pointer);
-#pragma clang diagnostic pop
- if (status != errAuthorizationSuccess) {
- return status;
- }
-
- int line_pid = -1;
- size_t line_length = 0;
- char* line_c = fgetln(*pipe_pointer, &line_length);
- if (line_c) {
- if (line_length > 0 && line_c[line_length - 1] == '\n') {
- // line_c + line_length is the start of the next line if there is one.
- // Back up one character.
- --line_length;
- }
- std::string line(line_c, line_length);
- if (!base::StringToInt(line, &line_pid)) {
- // StringToInt may have set line_pid to something, but if the conversion
- // was imperfect, use -1.
- LOG(ERROR) << "ExecuteWithPrivilegesAndGetPid: funny line: " << line;
- line_pid = -1;
- }
- } else {
- LOG(ERROR) << "ExecuteWithPrivilegesAndGetPid: no line";
- }
-
- if (!pipe) {
- fclose(*pipe_pointer);
- }
-
- if (pid) {
- *pid = line_pid;
- }
-
- return status;
-}
-
-OSStatus ExecuteWithPrivilegesAndWait(AuthorizationRef authorization,
- const char* tool_path,
- AuthorizationFlags options,
- const char** arguments,
- FILE** pipe,
- int* exit_status) {
- pid_t pid;
- OSStatus status = ExecuteWithPrivilegesAndGetPID(authorization,
- tool_path,
- options,
- arguments,
- pipe,
- &pid);
- if (status != errAuthorizationSuccess) {
- return status;
- }
-
- // exit_status may be NULL, but this function needs it. In that case, use a
- // local version.
- int local_exit_status;
- int* exit_status_pointer;
- if (exit_status) {
- exit_status_pointer = exit_status;
- } else {
- exit_status_pointer = &local_exit_status;
- }
-
- if (pid != -1) {
- pid_t wait_result = HANDLE_EINTR(waitpid(pid, exit_status_pointer, 0));
- if (wait_result != pid) {
- PLOG(ERROR) << "waitpid";
- *exit_status_pointer = -1;
- }
- } else {
- *exit_status_pointer = -1;
- }
-
- return status;
-}
-
-} // namespace mac
-} // namespace base
diff --git a/base/mac/call_with_eh_frame.cc b/base/mac/call_with_eh_frame.cc
deleted file mode 100644
index 35e01bc..0000000
--- a/base/mac/call_with_eh_frame.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/call_with_eh_frame.h"
-
-#include <stdint.h>
-#include <unwind.h>
-
-#include "build_config.h"
-
-namespace base {
-namespace mac {
-
-#if defined(OS_IOS)
-// No iOS assembly implementation exists, so just call the block directly.
-void CallWithEHFrame(void (^block)(void)) {
- block();
-}
-#else // OS_MACOSX
-extern "C" _Unwind_Reason_Code __gxx_personality_v0(int,
- _Unwind_Action,
- uint64_t,
- struct _Unwind_Exception*,
- struct _Unwind_Context*);
-
-_Unwind_Reason_Code CxxPersonalityRoutine(
- int version,
- _Unwind_Action actions,
- uint64_t exception_class,
- struct _Unwind_Exception* exception_object,
- struct _Unwind_Context* context) {
- // Unwinding is a two-phase process: phase one searches for an exception
- // handler, and phase two performs cleanup. For phase one, this custom
- // personality will terminate the search. For phase two, this should delegate
- // back to the standard personality routine.
-
- if ((actions & _UA_SEARCH_PHASE) != 0) {
- // Tell libunwind that this is the end of the stack. When it encounters the
- // CallWithEHFrame, it will stop searching for an exception handler. The
- // result is that no exception handler has been found higher on the stack,
- // and any that are lower on the stack (e.g. in CFRunLoopRunSpecific), will
- // now be skipped. Since this is reporting the end of the stack, and no
- // exception handler will have been found, std::terminate() will be called.
- return _URC_END_OF_STACK;
- }
-
- return __gxx_personality_v0(version, actions, exception_class,
- exception_object, context);
-}
-#endif // defined(OS_IOS)
-
-} // namespace mac
-} // namespace base
diff --git a/base/mac/call_with_eh_frame.h b/base/mac/call_with_eh_frame.h
deleted file mode 100644
index 1f7d5e0..0000000
--- a/base/mac/call_with_eh_frame.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_CALL_WITH_EH_FRAME_H_
-#define BASE_MAC_CALL_WITH_EH_FRAME_H_
-
-#include "base/base_export.h"
-
-namespace base {
-namespace mac {
-
-// Invokes the specified block in a stack frame with a special exception
-// handler. This function creates an exception handling stack frame that
-// specifies a custom C++ exception personality routine, which terminates the
-// search for an exception handler at this frame.
-//
-// The purpose of this function is to prevent a try/catch statement in system
-// libraries, acting as a global exception handler, from handling exceptions
-// in such a way that disrupts the generation of useful stack traces.
-void BASE_EXPORT CallWithEHFrame(void (^block)(void));
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_CALL_WITH_EH_FRAME_H_
diff --git a/base/mac/call_with_eh_frame_asm.S b/base/mac/call_with_eh_frame_asm.S
deleted file mode 100644
index 0e399cf..0000000
--- a/base/mac/call_with_eh_frame_asm.S
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// base::mac::CallWithEHFrame(void () block_pointer)
-#define CALL_WITH_EH_FRAME __ZN4base3mac15CallWithEHFrameEU13block_pointerFvvE
-
- .section __TEXT,__text,regular,pure_instructions
-#if !defined(COMPONENT_BUILD)
- .private_extern CALL_WITH_EH_FRAME
-#endif
- .globl CALL_WITH_EH_FRAME
- .align 4
-CALL_WITH_EH_FRAME:
-
- .cfi_startproc
-
- // Configure the C++ exception handler personality routine. Normally the
- // compiler would emit ___gxx_personality_v0 here. The purpose of this
- // function is to use a custom personality routine.
- .cfi_personality 155, __ZN4base3mac21CxxPersonalityRoutineEi14_Unwind_ActionyP17_Unwind_ExceptionP15_Unwind_Context
- .cfi_lsda 16, CallWithEHFrame_exception_table
-
-Lfunction_start:
- pushq %rbp
- .cfi_def_cfa_offset 16
- .cfi_offset %rbp, -16
- movq %rsp, %rbp
- .cfi_def_cfa_register %rbp
-
- // Load the function pointer from the block descriptor.
- movq 16(%rdi), %rax
-
- // Execute the block in the context of a C++ try{}.
-Ltry_start:
- callq *%rax
-Ltry_end:
- popq %rbp
- ret
-
- // Landing pad for the exception handler. This should never be called, since
- // the personality routine will stop the search for an exception handler,
- // which will cause the runtime to invoke the default terminate handler.
-Lcatch:
- movq %rax, %rdi
- callq ___cxa_begin_catch // The ABI requires a call to the catch handler.
- ud2 // In the event this is called, make it fatal.
-
-Lfunction_end:
- .cfi_endproc
-
-// The C++ exception table that is used to identify this frame as an
-// exception handler. See http://llvm.org/docs/ExceptionHandling.html and
-// http://mentorembedded.github.io/cxx-abi/exceptions.pdf.
- .section __TEXT,__gcc_except_tab
- .align 2
-CallWithEHFrame_exception_table:
- .byte 255 // DW_EH_PE_omit
- .byte 155 // DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4
- .asciz "\242\200\200" // LE int128 for the number of bytes in this table.
- .byte 3 // DW_EH_PE_udata4
- .byte 26 // Callsite table length.
-
-// First callsite.
-CS1_begin = Ltry_start - Lfunction_start
- .long CS1_begin
-CS1_end = Ltry_end - Ltry_start
- .long CS1_end
-
-// First landing pad.
-LP1 = Lcatch - Lfunction_start
- .long LP1
- .byte 1 // Action record.
-
-// Second callsite.
-CS2_begin = Ltry_end - Lfunction_start
- .long CS2_begin
-CS2_end = Lfunction_end - Ltry_end
- .long CS2_end
-
-// Second landing pad (none).
- .long 0
- .byte 0 // No action.
-
-// Action table.
- .byte 1 // Action record 1.
- .byte 0 // No further action to take.
- .long 0 // No type filter for this catch(){} clause.
- .align 2
diff --git a/base/mac/close_nocancel.cc b/base/mac/close_nocancel.cc
deleted file mode 100644
index 8971e73..0000000
--- a/base/mac/close_nocancel.cc
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// http://crbug.com/269623
-// http://openradar.appspot.com/14999594
-//
-// When the default version of close used on Mac OS X fails with EINTR, the
-// file descriptor is not in a deterministic state. It may have been closed,
-// or it may not have been. This makes it impossible to gracefully recover
-// from the error. If the close is retried after the FD has been closed, the
-// subsequent close can report EBADF, or worse, it can close an unrelated FD
-// opened by another thread. If the close is not retried after the FD has been
-// left open, the FD is leaked. Neither of these are good options.
-//
-// Mac OS X provides an alternate version of close, close$NOCANCEL. This
-// version will never fail with EINTR before the FD is actually closed. With
-// this version, it is thus safe to call close without checking for EINTR (as
-// the HANDLE_EINTR macro does) and not risk leaking the FD. In fact, mixing
-// this verison of close with HANDLE_EINTR is hazardous.
-//
-// The $NOCANCEL variants of various system calls are activated by compiling
-// with __DARWIN_NON_CANCELABLE, which prevents them from being pthread
-// cancellation points. Rather than taking such a heavy-handed approach, this
-// file implements an alternative: to use the $NOCANCEL variant of close (thus
-// preventing it from being a pthread cancellation point) without affecting
-// any other system calls.
-//
-// This file operates by providing a close function with the non-$NOCANCEL
-// symbol name expected for the compilation environment as set by <unistd.h>
-// and <sys/cdefs.h> (the DARWIN_ALIAS_C macro). That name is set by an asm
-// label on the declaration of the close function, so the definition of that
-// function receives that name. The function calls the $NOCANCEL variant, which
-// is resolved from libsyscall. By linking with this version of close prior to
-// the libsyscall version, close's implementation is overridden.
-
-#include <sys/cdefs.h>
-#include <unistd.h>
-
-// If the non-cancelable variants of all system calls have already been
-// chosen, do nothing.
-#if !__DARWIN_NON_CANCELABLE
-
-extern "C" {
-
-#if !__DARWIN_ONLY_UNIX_CONFORMANCE
-
-// When there's a choice between UNIX2003 and pre-UNIX2003. There's no
-// close$NOCANCEL symbol in this case, so use close$NOCANCEL$UNIX2003 as the
-// implementation. It does the same thing that close$NOCANCEL would do.
-#define close_implementation close$NOCANCEL$UNIX2003
-
-#else // __DARWIN_ONLY_UNIX_CONFORMANCE
-
-// When only UNIX2003 is supported:
-#define close_implementation close$NOCANCEL
-
-#endif
-
-int close_implementation(int fd);
-
-int close(int fd) {
- return close_implementation(fd);
-}
-
-#undef close_implementation
-
-} // extern "C"
-
-#endif // !__DARWIN_NON_CANCELABLE
diff --git a/base/mac/launch_services_util.h b/base/mac/launch_services_util.h
deleted file mode 100644
index 30d1eec..0000000
--- a/base/mac/launch_services_util.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_LAUNCH_SERVICES_UTIL_H_
-#define BASE_MAC_LAUNCH_SERVICES_UTIL_H_
-
-#import <AppKit/AppKit.h>
-
-#include "base/base_export.h"
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/process/process.h"
-
-namespace base {
-namespace mac {
-
-// Launches the application bundle at |bundle_path|, passing argv[1..] from
-// |command_line| as command line arguments if the app isn't already running.
-// |launch_options| are passed directly to
-// -[NSWorkspace launchApplicationAtURL:options:configuration:error:].
-// Returns a valid process if the app was successfully launched.
-BASE_EXPORT Process
-OpenApplicationWithPath(const FilePath& bundle_path,
- const CommandLine& command_line,
- NSWorkspaceLaunchOptions launch_options);
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_LAUNCH_SERVICES_UTIL_H_
diff --git a/base/mac/launch_services_util.mm b/base/mac/launch_services_util.mm
deleted file mode 100644
index fa6e808..0000000
--- a/base/mac/launch_services_util.mm
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#import "base/mac/launch_services_util.h"
-
-#include "base/logging.h"
-#include "base/strings/sys_string_conversions.h"
-
-namespace base {
-namespace mac {
-
-Process OpenApplicationWithPath(const base::FilePath& bundle_path,
- const CommandLine& command_line,
- NSWorkspaceLaunchOptions launch_options) {
- NSString* bundle_url_spec = base::SysUTF8ToNSString(bundle_path.value());
- NSURL* bundle_url = [NSURL fileURLWithPath:bundle_url_spec isDirectory:YES];
- DCHECK(bundle_url);
- if (!bundle_url) {
- return Process();
- }
-
- // NSWorkspace automatically adds the binary path as the first argument and
- // it should not be included into the list.
- std::vector<std::string> argv = command_line.argv();
- int argc = argv.size();
- NSMutableArray* launch_args = [NSMutableArray arrayWithCapacity:argc - 1];
- for (int i = 1; i < argc; ++i) {
- [launch_args addObject:base::SysUTF8ToNSString(argv[i])];
- }
-
- NSDictionary* configuration = @{
- NSWorkspaceLaunchConfigurationArguments : launch_args,
- };
- NSError* launch_error = nil;
- // TODO(jeremya): this opens a new browser window if Chrome is already
- // running without any windows open.
- NSRunningApplication* app =
- [[NSWorkspace sharedWorkspace] launchApplicationAtURL:bundle_url
- options:launch_options
- configuration:configuration
- error:&launch_error];
- if (launch_error) {
- LOG(ERROR) << base::SysNSStringToUTF8([launch_error localizedDescription]);
- return Process();
- }
- DCHECK(app);
- return Process([app processIdentifier]);
-}
-
-} // namespace mac
-} // namespace base
diff --git a/base/mac/launchd.cc b/base/mac/launchd.cc
deleted file mode 100644
index 0337d2e..0000000
--- a/base/mac/launchd.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/launchd.h"
-
-#include "base/logging.h"
-#include "base/mac/scoped_launch_data.h"
-
-namespace base {
-namespace mac {
-
-// MessageForJob sends a single message to launchd with a simple dictionary
-// mapping |operation| to |job_label|, and returns the result of calling
-// launch_msg to send that message. On failure, returns NULL. The caller
-// assumes ownership of the returned launch_data_t object.
-launch_data_t MessageForJob(const std::string& job_label,
- const char* operation) {
- // launch_data_alloc returns something that needs to be freed.
- ScopedLaunchData message(launch_data_alloc(LAUNCH_DATA_DICTIONARY));
- if (!message.is_valid()) {
- LOG(ERROR) << "launch_data_alloc";
- return NULL;
- }
-
- // launch_data_new_string returns something that needs to be freed, but
- // the dictionary will assume ownership when launch_data_dict_insert is
- // called, so put it in a scoper and .release() it when given to the
- // dictionary.
- ScopedLaunchData job_label_launchd(launch_data_new_string(job_label.c_str()));
- if (!job_label_launchd.is_valid()) {
- LOG(ERROR) << "launch_data_new_string";
- return NULL;
- }
-
- if (!launch_data_dict_insert(message.get(), job_label_launchd.release(),
- operation)) {
- return NULL;
- }
-
- return launch_msg(message.get());
-}
-
-pid_t PIDForJob(const std::string& job_label) {
- ScopedLaunchData response(MessageForJob(job_label, LAUNCH_KEY_GETJOB));
- if (!response.is_valid()) {
- return -1;
- }
-
- launch_data_type_t response_type = launch_data_get_type(response.get());
- if (response_type != LAUNCH_DATA_DICTIONARY) {
- if (response_type == LAUNCH_DATA_ERRNO) {
- LOG(ERROR) << "PIDForJob: error "
- << launch_data_get_errno(response.get());
- } else {
- LOG(ERROR) << "PIDForJob: expected dictionary, got " << response_type;
- }
- return -1;
- }
-
- launch_data_t pid_data =
- launch_data_dict_lookup(response.get(), LAUNCH_JOBKEY_PID);
- if (!pid_data)
- return 0;
-
- if (launch_data_get_type(pid_data) != LAUNCH_DATA_INTEGER) {
- LOG(ERROR) << "PIDForJob: expected integer";
- return -1;
- }
-
- return launch_data_get_integer(pid_data);
-}
-
-} // namespace mac
-} // namespace base
diff --git a/base/mac/launchd.h b/base/mac/launchd.h
deleted file mode 100644
index 9e4514e..0000000
--- a/base/mac/launchd.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_LAUNCHD_H_
-#define BASE_MAC_LAUNCHD_H_
-
-#include <launch.h>
-#include <sys/types.h>
-
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace mac {
-
-// MessageForJob sends a single message to launchd with a simple dictionary
-// mapping |operation| to |job_label|, and returns the result of calling
-// launch_msg to send that message. On failure, returns NULL. The caller
-// assumes ownership of the returned launch_data_t object.
-BASE_EXPORT
-launch_data_t MessageForJob(const std::string& job_label,
- const char* operation);
-
-// Returns the process ID for |job_label| if the job is running, 0 if the job
-// is loaded but not running, or -1 on error.
-BASE_EXPORT
-pid_t PIDForJob(const std::string& job_label);
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_LAUNCHD_H_
diff --git a/base/mac/mach_port_broker.h b/base/mac/mach_port_broker.h
deleted file mode 100644
index 4554b6a..0000000
--- a/base/mac/mach_port_broker.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_MACH_PORT_BROKER_H_
-#define BASE_MAC_MACH_PORT_BROKER_H_
-
-#include <mach/mach.h>
-
-#include <map>
-#include <memory>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/mac/dispatch_source_mach.h"
-#include "base/mac/scoped_mach_port.h"
-#include "base/macros.h"
-#include "base/process/port_provider_mac.h"
-#include "base/process/process_handle.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-// On OS X, the task port of a process is required to collect metrics about the
-// process, and to insert Mach ports into the process. Running |task_for_pid()|
-// is only allowed for privileged code. However, a process has port rights to
-// all its subprocesses, so let the child processes send their Mach port to the
-// parent over IPC.
-//
-// Mach ports can only be sent over Mach IPC, not over the |socketpair()| that
-// the regular IPC system uses. Hence, the child processes opens a Mach
-// connection shortly after launching and ipc their mach data to the parent
-// process. A single |MachPortBroker| with a given name is expected to exist in
-// the parent process.
-//
-// Since this data arrives over a separate channel, it is not available
-// immediately after a child process has been started.
-class BASE_EXPORT MachPortBroker : public base::PortProvider {
- public:
- // For use in child processes. This will send the task port of the current
- // process over Mach IPC to the port registered by name (via this class) in
- // the parent process. Returns true if the message was sent successfully
- // and false if otherwise.
- static bool ChildSendTaskPortToParent(const std::string& name);
-
- // Returns the Mach port name to use when sending or receiving messages.
- // Does the Right Thing in the browser and in child processes.
- static std::string GetMachPortName(const std::string& name, bool is_child);
-
- MachPortBroker(const std::string& name);
- ~MachPortBroker() override;
-
- // Performs any initialization work.
- bool Init();
-
- // Adds a placeholder to the map for the given pid with MACH_PORT_NULL.
- // Callers are expected to later update the port with FinalizePid(). Callers
- // MUST acquire the lock given by GetLock() before calling this method (and
- // release the lock afterwards).
- void AddPlaceholderForPid(base::ProcessHandle pid);
-
- // Removes |pid| from the task port map. Callers MUST acquire the lock given
- // by GetLock() before calling this method (and release the lock afterwards).
- void InvalidatePid(base::ProcessHandle pid);
-
- // The lock that protects this MachPortBroker object. Callers MUST acquire
- // and release this lock around calls to AddPlaceholderForPid(),
- // InvalidatePid(), and FinalizePid();
- base::Lock& GetLock() { return lock_; }
-
- // Implement |base::PortProvider|.
- mach_port_t TaskForPid(base::ProcessHandle process) const override;
-
- private:
- friend class MachPortBrokerTest;
-
- // Message handler that is invoked on |dispatch_source_| when an
- // incoming message needs to be received.
- void HandleRequest();
-
- // Updates the mapping for |pid| to include the given |mach_info|. Does
- // nothing if PlaceholderForPid() has not already been called for the given
- // |pid|. Callers MUST acquire the lock given by GetLock() before calling
- // this method (and release the lock afterwards).
- void FinalizePid(base::ProcessHandle pid, mach_port_t task_port);
-
- // Name used to identify a particular port broker.
- const std::string name_;
-
- // The Mach port on which the server listens.
- base::mac::ScopedMachReceiveRight server_port_;
-
- // The dispatch source and queue on which Mach messages will be received.
- std::unique_ptr<base::DispatchSourceMach> dispatch_source_;
-
- // Stores mach info for every process in the broker.
- typedef std::map<base::ProcessHandle, mach_port_t> MachMap;
- MachMap mach_map_;
-
- // Mutex that guards |mach_map_|.
- mutable base::Lock lock_;
-
- DISALLOW_COPY_AND_ASSIGN(MachPortBroker);
-};
-
-} // namespace base
-
-#endif // BASE_MAC_MACH_PORT_BROKER_H_
diff --git a/base/mac/mach_port_broker.mm b/base/mac/mach_port_broker.mm
deleted file mode 100644
index 6d9fec5..0000000
--- a/base/mac/mach_port_broker.mm
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/mach_port_broker.h"
-
-#include <bsm/libbsm.h>
-#include <servers/bootstrap.h>
-
-#include "base/logging.h"
-#include "base/mac/foundation_util.h"
-#include "base/mac/mach_logging.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-
-namespace base {
-
-namespace {
-
-// Mach message structure used in the child as a sending message.
-struct MachPortBroker_ChildSendMsg {
- mach_msg_header_t header;
- mach_msg_body_t body;
- mach_msg_port_descriptor_t child_task_port;
-};
-
-// Complement to the ChildSendMsg, this is used in the parent for receiving
-// a message. Contains a message trailer with audit information.
-struct MachPortBroker_ParentRecvMsg : public MachPortBroker_ChildSendMsg {
- mach_msg_audit_trailer_t trailer;
-};
-
-} // namespace
-
-// static
-bool MachPortBroker::ChildSendTaskPortToParent(const std::string& name) {
- // Look up the named MachPortBroker port that's been registered with the
- // bootstrap server.
- mach_port_t parent_port;
- kern_return_t kr = bootstrap_look_up(bootstrap_port,
- const_cast<char*>(GetMachPortName(name, true).c_str()), &parent_port);
- if (kr != KERN_SUCCESS) {
- BOOTSTRAP_LOG(ERROR, kr) << "bootstrap_look_up";
- return false;
- }
- base::mac::ScopedMachSendRight scoped_right(parent_port);
-
- // Create the check in message. This will copy a send right on this process'
- // (the child's) task port and send it to the parent.
- MachPortBroker_ChildSendMsg msg;
- bzero(&msg, sizeof(msg));
- msg.header.msgh_bits = MACH_MSGH_BITS_REMOTE(MACH_MSG_TYPE_COPY_SEND) |
- MACH_MSGH_BITS_COMPLEX;
- msg.header.msgh_remote_port = parent_port;
- msg.header.msgh_size = sizeof(msg);
- msg.body.msgh_descriptor_count = 1;
- msg.child_task_port.name = mach_task_self();
- msg.child_task_port.disposition = MACH_MSG_TYPE_PORT_SEND;
- msg.child_task_port.type = MACH_MSG_PORT_DESCRIPTOR;
-
- kr = mach_msg(&msg.header, MACH_SEND_MSG | MACH_SEND_TIMEOUT, sizeof(msg),
- 0, MACH_PORT_NULL, 100 /*milliseconds*/, MACH_PORT_NULL);
- if (kr != KERN_SUCCESS) {
- MACH_LOG(ERROR, kr) << "mach_msg";
- return false;
- }
-
- return true;
-}
-
-// static
-std::string MachPortBroker::GetMachPortName(const std::string& name,
- bool is_child) {
- // In child processes, use the parent's pid.
- const pid_t pid = is_child ? getppid() : getpid();
- return base::StringPrintf(
- "%s.%s.%d", base::mac::BaseBundleID(), name.c_str(), pid);
-}
-
-mach_port_t MachPortBroker::TaskForPid(base::ProcessHandle pid) const {
- base::AutoLock lock(lock_);
- MachPortBroker::MachMap::const_iterator it = mach_map_.find(pid);
- if (it == mach_map_.end())
- return MACH_PORT_NULL;
- return it->second;
-}
-
-MachPortBroker::MachPortBroker(const std::string& name) : name_(name) {}
-
-MachPortBroker::~MachPortBroker() {}
-
-bool MachPortBroker::Init() {
- DCHECK(server_port_.get() == MACH_PORT_NULL);
-
- // Check in with launchd and publish the service name.
- mach_port_t port;
- kern_return_t kr = bootstrap_check_in(
- bootstrap_port, GetMachPortName(name_, false).c_str(), &port);
- if (kr != KERN_SUCCESS) {
- BOOTSTRAP_LOG(ERROR, kr) << "bootstrap_check_in";
- return false;
- }
- server_port_.reset(port);
-
- // Start the dispatch source.
- std::string queue_name =
- base::StringPrintf("%s.MachPortBroker", base::mac::BaseBundleID());
- dispatch_source_.reset(new base::DispatchSourceMach(
- queue_name.c_str(), server_port_.get(), ^{ HandleRequest(); }));
- dispatch_source_->Resume();
-
- return true;
-}
-
-void MachPortBroker::AddPlaceholderForPid(base::ProcessHandle pid) {
- lock_.AssertAcquired();
- DCHECK_EQ(0u, mach_map_.count(pid));
- mach_map_[pid] = MACH_PORT_NULL;
-}
-
-void MachPortBroker::InvalidatePid(base::ProcessHandle pid) {
- lock_.AssertAcquired();
-
- MachMap::iterator mach_it = mach_map_.find(pid);
- if (mach_it != mach_map_.end()) {
- kern_return_t kr = mach_port_deallocate(mach_task_self(), mach_it->second);
- MACH_LOG_IF(WARNING, kr != KERN_SUCCESS, kr) << "mach_port_deallocate";
- mach_map_.erase(mach_it);
- }
-}
-
-void MachPortBroker::HandleRequest() {
- MachPortBroker_ParentRecvMsg msg;
- bzero(&msg, sizeof(msg));
- msg.header.msgh_size = sizeof(msg);
- msg.header.msgh_local_port = server_port_.get();
-
- const mach_msg_option_t options = MACH_RCV_MSG |
- MACH_RCV_TRAILER_TYPE(MACH_RCV_TRAILER_AUDIT) |
- MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT);
-
- kern_return_t kr = mach_msg(&msg.header,
- options,
- 0,
- sizeof(msg),
- server_port_.get(),
- MACH_MSG_TIMEOUT_NONE,
- MACH_PORT_NULL);
- if (kr != KERN_SUCCESS) {
- MACH_LOG(ERROR, kr) << "mach_msg";
- return;
- }
-
- // Use the kernel audit information to make sure this message is from
- // a task that this process spawned. The kernel audit token contains the
- // unspoofable pid of the task that sent the message.
- pid_t child_pid = audit_token_to_pid(msg.trailer.msgh_audit);
- mach_port_t child_task_port = msg.child_task_port.name;
-
- // Take the lock and update the broker information.
- {
- base::AutoLock lock(lock_);
- FinalizePid(child_pid, child_task_port);
- }
- NotifyObservers(child_pid);
-}
-
-void MachPortBroker::FinalizePid(base::ProcessHandle pid,
- mach_port_t task_port) {
- lock_.AssertAcquired();
-
- MachMap::iterator it = mach_map_.find(pid);
- if (it == mach_map_.end()) {
- // Do nothing for unknown pids.
- LOG(ERROR) << "Unknown process " << pid << " is sending Mach IPC messages!";
- return;
- }
-
- DCHECK(it->second == MACH_PORT_NULL);
- if (it->second == MACH_PORT_NULL)
- it->second = task_port;
-}
-
-} // namespace base
diff --git a/base/mac/mach_port_util.cc b/base/mac/mach_port_util.cc
deleted file mode 100644
index 0eee210..0000000
--- a/base/mac/mach_port_util.cc
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/mach_port_util.h"
-
-#include "base/logging.h"
-
-namespace base {
-
-namespace {
-
-// Struct for sending a complex Mach message.
-struct MachSendComplexMessage {
- mach_msg_header_t header;
- mach_msg_body_t body;
- mach_msg_port_descriptor_t data;
-};
-
-// Struct for receiving a complex message.
-struct MachReceiveComplexMessage {
- mach_msg_header_t header;
- mach_msg_body_t body;
- mach_msg_port_descriptor_t data;
- mach_msg_trailer_t trailer;
-};
-
-} // namespace
-
-kern_return_t SendMachPort(mach_port_t endpoint,
- mach_port_t port_to_send,
- int disposition) {
- MachSendComplexMessage send_msg;
- send_msg.header.msgh_bits =
- MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0) | MACH_MSGH_BITS_COMPLEX;
- send_msg.header.msgh_size = sizeof(send_msg);
- send_msg.header.msgh_remote_port = endpoint;
- send_msg.header.msgh_local_port = MACH_PORT_NULL;
- send_msg.header.msgh_reserved = 0;
- send_msg.header.msgh_id = 0;
- send_msg.body.msgh_descriptor_count = 1;
- send_msg.data.name = port_to_send;
- send_msg.data.disposition = disposition;
- send_msg.data.type = MACH_MSG_PORT_DESCRIPTOR;
-
- kern_return_t kr =
- mach_msg(&send_msg.header, MACH_SEND_MSG | MACH_SEND_TIMEOUT,
- send_msg.header.msgh_size,
- 0, // receive limit
- MACH_PORT_NULL, // receive name
- 0, // timeout
- MACH_PORT_NULL); // notification port
-
- if (kr != KERN_SUCCESS)
- mach_port_deallocate(mach_task_self(), endpoint);
-
- return kr;
-}
-
-base::mac::ScopedMachSendRight ReceiveMachPort(mach_port_t port_to_listen_on) {
- MachReceiveComplexMessage recv_msg;
- mach_msg_header_t* recv_hdr = &recv_msg.header;
- recv_hdr->msgh_local_port = port_to_listen_on;
- recv_hdr->msgh_size = sizeof(recv_msg);
-
- kern_return_t kr =
- mach_msg(recv_hdr, MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
- recv_hdr->msgh_size, port_to_listen_on, 0, MACH_PORT_NULL);
- if (kr != KERN_SUCCESS)
- return base::mac::ScopedMachSendRight(MACH_PORT_NULL);
- if (recv_msg.header.msgh_id != 0)
- return base::mac::ScopedMachSendRight(MACH_PORT_NULL);
- return base::mac::ScopedMachSendRight(recv_msg.data.name);
-}
-
-mach_port_name_t CreateIntermediateMachPort(
- mach_port_t task_port,
- base::mac::ScopedMachSendRight port_to_insert,
- MachCreateError* error_code) {
- DCHECK_NE(mach_task_self(), task_port);
- DCHECK_NE(static_cast<mach_port_name_t>(MACH_PORT_NULL), task_port);
-
- // Make a port with receive rights in the destination task.
- mach_port_name_t endpoint;
- kern_return_t kr =
- mach_port_allocate(task_port, MACH_PORT_RIGHT_RECEIVE, &endpoint);
- if (kr != KERN_SUCCESS) {
- if (error_code)
- *error_code = MachCreateError::ERROR_MAKE_RECEIVE_PORT;
- return MACH_PORT_NULL;
- }
-
- // Change its message queue limit so that it accepts one message.
- mach_port_limits limits = {};
- limits.mpl_qlimit = 1;
- kr = mach_port_set_attributes(task_port, endpoint, MACH_PORT_LIMITS_INFO,
- reinterpret_cast<mach_port_info_t>(&limits),
- MACH_PORT_LIMITS_INFO_COUNT);
- if (kr != KERN_SUCCESS) {
- if (error_code)
- *error_code = MachCreateError::ERROR_SET_ATTRIBUTES;
- mach_port_deallocate(task_port, endpoint);
- return MACH_PORT_NULL;
- }
-
- // Get a send right.
- mach_port_t send_once_right;
- mach_msg_type_name_t send_right_type;
- kr =
- mach_port_extract_right(task_port, endpoint, MACH_MSG_TYPE_MAKE_SEND_ONCE,
- &send_once_right, &send_right_type);
- if (kr != KERN_SUCCESS) {
- if (error_code)
- *error_code = MachCreateError::ERROR_EXTRACT_DEST_RIGHT;
- mach_port_deallocate(task_port, endpoint);
- return MACH_PORT_NULL;
- }
- DCHECK_EQ(static_cast<mach_msg_type_name_t>(MACH_MSG_TYPE_PORT_SEND_ONCE),
- send_right_type);
-
- // This call takes ownership of |send_once_right|.
- kr = base::SendMachPort(
- send_once_right, port_to_insert.get(), MACH_MSG_TYPE_COPY_SEND);
- if (kr != KERN_SUCCESS) {
- if (error_code)
- *error_code = MachCreateError::ERROR_SEND_MACH_PORT;
- mach_port_deallocate(task_port, endpoint);
- return MACH_PORT_NULL;
- }
-
- // Endpoint is intentionally leaked into the destination task. An IPC must be
- // sent to the destination task so that it can clean up this port.
- return endpoint;
-}
-
-} // namespace base
diff --git a/base/mac/mach_port_util.h b/base/mac/mach_port_util.h
deleted file mode 100644
index f7a7f32..0000000
--- a/base/mac/mach_port_util.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_MACH_PORT_UTIL_H_
-#define BASE_MAC_MACH_PORT_UTIL_H_
-
-#include <mach/mach.h>
-
-#include "base/base_export.h"
-#include "base/mac/scoped_mach_port.h"
-
-namespace base {
-
-enum class MachCreateError {
- ERROR_MAKE_RECEIVE_PORT,
- ERROR_SET_ATTRIBUTES,
- ERROR_EXTRACT_DEST_RIGHT,
- ERROR_SEND_MACH_PORT,
-};
-
-// Sends a Mach port to |dest_port|. Assumes that |dest_port| is a send once
-// right. Takes ownership of |dest_port|.
-BASE_EXPORT kern_return_t SendMachPort(mach_port_t dest_port,
- mach_port_t port_to_send,
- int disposition);
-
-// Receives a Mach port from |port_to_listen_on|, which should have exactly one
-// queued message. Returns |MACH_PORT_NULL| on any error.
-BASE_EXPORT base::mac::ScopedMachSendRight ReceiveMachPort(
- mach_port_t port_to_listen_on);
-
-// Creates an intermediate Mach port in |task_port| and sends |port_to_insert|
-// as a mach_msg to the intermediate Mach port.
-// |task_port| is the task port of another process.
-// |port_to_insert| must be a send right in the current task's name space.
-// Returns the intermediate port on success, and MACH_PORT_NULL on failure.
-// On failure, |error_code| is set if not null.
-// This method takes ownership of |port_to_insert|. On success, ownership is
-// passed to the intermediate Mach port.
-BASE_EXPORT mach_port_name_t CreateIntermediateMachPort(
- mach_port_t task_port,
- base::mac::ScopedMachSendRight port_to_insert,
- MachCreateError* error_code);
-
-} // namespace base
-
-#endif // BASE_MAC_MACH_PORT_UTIL_H_
diff --git a/base/mac/objc_release_properties.h b/base/mac/objc_release_properties.h
deleted file mode 100644
index d064cf9..0000000
--- a/base/mac/objc_release_properties.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#if defined(__has_feature) && __has_feature(objc_arc)
-#error "ARC manages properties, so base::mac::ReleaseProperties isn't needed."
-#endif
-
-#ifndef BASE_MAC_OBJC_RELEASE_PROPERTIES_H_
-#define BASE_MAC_OBJC_RELEASE_PROPERTIES_H_
-
-#import <Foundation/Foundation.h>
-
-#include "base/base_export.h"
-
-// base::mac::ReleaseProperties(self) can be used in a class's -dealloc method
-// to release all properties marked "retain" or "copy" and backed by instance
-// variables. It only affects properties defined by the calling class, not
-// sub/superclass properties.
-//
-// Example usage:
-//
-// @interface AllaysIBF : NSObject
-//
-// @property(retain, nonatomic) NSString* string;
-// @property(copy, nonatomic) NSMutableDictionary* dictionary;
-// @property(assign, nonatomic) IBFDelegate* delegate;
-//
-// @end // @interface AllaysIBF
-//
-// @implementation AllaysIBF
-//
-// - (void)dealloc {
-// base::mac::ReleaseProperties(self);
-// [super dealloc];
-// }
-//
-// @end // @implementation AllaysIBF
-//
-// self.string and self.dictionary will each be released, but self.delegate
-// will not because it is marked "assign", not "retain" or "copy".
-//
-// Another approach would be to provide a base class to inherit from whose
-// -dealloc walks the property lists of all subclasses to release their
-// properties. Distant subclasses might not expect it and over-release their
-// properties, so don't do that.
-
-namespace base {
-namespace mac {
-
-namespace details {
-
-BASE_EXPORT void ReleaseProperties(id, Class);
-
-} // namespace details
-
-template <typename Self>
-void ReleaseProperties(Self* self) {
- details::ReleaseProperties(self, [Self class]);
-}
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_OBJC_RELEASE_PROPERTIES_H_
diff --git a/base/mac/objc_release_properties.mm b/base/mac/objc_release_properties.mm
deleted file mode 100644
index d0006cf..0000000
--- a/base/mac/objc_release_properties.mm
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/objc_release_properties.h"
-
-#include <memory>
-
-#include <objc/runtime.h>
-
-#include "base/logging.h"
-#include "base/memory/free_deleter.h"
-
-namespace {
-
-bool IsRetained(objc_property_t property) {
- // The format of the string returned by property_getAttributes is documented
- // at
- // http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html#//apple_ref/doc/uid/TP40008048-CH101-SW6
- const char* attribute = property_getAttributes(property);
- while (attribute[0]) {
- switch (attribute[0]) {
- case 'C': // copy
- case '&': // retain
- return true;
- }
- do {
- attribute++;
- } while (attribute[0] && attribute[-1] != ',');
- }
- return false;
-}
-
-id ValueOf(id obj, objc_property_t property) {
- std::unique_ptr<char, base::FreeDeleter> ivar_name(
- property_copyAttributeValue(property, "V")); // instance variable name
- if (!ivar_name)
- return nil;
- id ivar_value = nil;
- Ivar ivar = object_getInstanceVariable(obj, &*ivar_name,
- reinterpret_cast<void**>(&ivar_value));
- DCHECK(ivar);
- return ivar_value;
-}
-
-} // namespace
-
-namespace base {
-namespace mac {
-namespace details {
-
-void ReleaseProperties(id self, Class cls) {
- unsigned int property_count;
- std::unique_ptr<objc_property_t[], base::FreeDeleter> properties(
- class_copyPropertyList(cls, &property_count));
- for (size_t i = 0; i < property_count; ++i) {
- objc_property_t property = properties[i];
- if (!IsRetained(property))
- continue;
- [ValueOf(self, property) release];
- }
-}
-
-} // namespace details
-} // namespace mac
-} // namespace base
diff --git a/base/mac/os_crash_dumps.cc b/base/mac/os_crash_dumps.cc
deleted file mode 100644
index 95af009..0000000
--- a/base/mac/os_crash_dumps.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/os_crash_dumps.h"
-
-#include <signal.h>
-#include <stddef.h>
-#include <unistd.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-namespace base {
-namespace mac {
-
-namespace {
-
-void ExitSignalHandler(int sig) {
- // A call to exit() can call atexit() handlers. If we SIGSEGV due
- // to a corrupt heap, and if we have an atexit handler that
- // allocates or frees memory, we are in trouble if we do not _exit.
- _exit(128 + sig);
-}
-
-} // namespace
-
-void DisableOSCrashDumps() {
- // These are the POSIX signals corresponding to the Mach exceptions that
- // Apple Crash Reporter handles. See ux_exception() in xnu's
- // bsd/uxkern/ux_exception.c and machine_exception() in xnu's
- // bsd/dev/*/unix_signal.c.
- const int signals_to_intercept[] = {
- // Hardware faults
- SIGILL, // EXC_BAD_INSTRUCTION
- SIGTRAP, // EXC_BREAKPOINT
- SIGFPE, // EXC_ARITHMETIC
- SIGBUS, // EXC_BAD_ACCESS
- SIGSEGV, // EXC_BAD_ACCESS
- // Not a hardware fault
- SIGABRT
- };
-
- // For all these signals, just wire things up so we exit immediately.
- for (size_t i = 0; i < arraysize(signals_to_intercept); ++i) {
- struct sigaction act = {};
- act.sa_handler = ExitSignalHandler;
-
- // It is better to allow the signal handler to run on the stack
- // registered with sigaltstack(), if one is present.
- act.sa_flags = SA_ONSTACK;
-
- if (sigemptyset(&act.sa_mask) != 0)
- DPLOG(FATAL) << "sigemptyset() failed";
- if (sigaction(signals_to_intercept[i], &act, NULL) != 0)
- DPLOG(FATAL) << "sigaction() failed";
- }
-}
-
-} // namespace mac
-} // namespace base
diff --git a/base/mac/os_crash_dumps.h b/base/mac/os_crash_dumps.h
deleted file mode 100644
index 31d90fb..0000000
--- a/base/mac/os_crash_dumps.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_OS_CRASH_DUMPS_H_
-#define BASE_MAC_OS_CRASH_DUMPS_H_
-
-#include "base/base_export.h"
-
-namespace base {
-namespace mac {
-
-// On Mac OS X, it can take a really long time for the OS crash handler to
-// process a Chrome crash when debugging symbols are available. This
-// translates into a long wait until the process actually dies. This call
-// disables Apple Crash Reporter entirely.
-BASE_EXPORT void DisableOSCrashDumps();
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_OS_CRASH_DUMPS_H_
diff --git a/base/mac/scoped_aedesc.h b/base/mac/scoped_aedesc.h
deleted file mode 100644
index 7327092..0000000
--- a/base/mac/scoped_aedesc.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_AEDESC_H_
-#define BASE_MAC_SCOPED_AEDESC_H_
-
-#import <CoreServices/CoreServices.h>
-
-#include "base/macros.h"
-
-namespace base {
-namespace mac {
-
-// The ScopedAEDesc is used to scope AppleEvent descriptors. On creation,
-// it will store a NULL descriptor. On destruction, it will dispose of the
-// descriptor.
-//
-// This class is parameterized for additional type safety checks. You can use
-// the generic AEDesc type by not providing a template parameter:
-// ScopedAEDesc<> desc;
-template <typename AEDescType = AEDesc>
-class ScopedAEDesc {
- public:
- ScopedAEDesc() {
- AECreateDesc(typeNull, NULL, 0, &desc_);
- }
-
- ~ScopedAEDesc() {
- AEDisposeDesc(&desc_);
- }
-
- // Used for in parameters.
- operator const AEDescType*() {
- return &desc_;
- }
-
- // Used for out parameters.
- AEDescType* OutPointer() {
- return &desc_;
- }
-
- private:
- AEDescType desc_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedAEDesc);
-};
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_AEDESC_H_
diff --git a/base/mac/scoped_authorizationref.h b/base/mac/scoped_authorizationref.h
deleted file mode 100644
index b83f8df..0000000
--- a/base/mac/scoped_authorizationref.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_AUTHORIZATIONREF_H_
-#define BASE_MAC_SCOPED_AUTHORIZATIONREF_H_
-
-#include <Security/Authorization.h>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-
-// ScopedAuthorizationRef maintains ownership of an AuthorizationRef. It is
-// patterned after the unique_ptr interface.
-
-namespace base {
-namespace mac {
-
-class ScopedAuthorizationRef {
- public:
- explicit ScopedAuthorizationRef(AuthorizationRef authorization = NULL)
- : authorization_(authorization) {
- }
-
- ~ScopedAuthorizationRef() {
- if (authorization_) {
- AuthorizationFree(authorization_, kAuthorizationFlagDestroyRights);
- }
- }
-
- void reset(AuthorizationRef authorization = NULL) {
- if (authorization_ != authorization) {
- if (authorization_) {
- AuthorizationFree(authorization_, kAuthorizationFlagDestroyRights);
- }
- authorization_ = authorization;
- }
- }
-
- bool operator==(AuthorizationRef that) const {
- return authorization_ == that;
- }
-
- bool operator!=(AuthorizationRef that) const {
- return authorization_ != that;
- }
-
- operator AuthorizationRef() const {
- return authorization_;
- }
-
- AuthorizationRef* get_pointer() { return &authorization_; }
-
- AuthorizationRef get() const {
- return authorization_;
- }
-
- void swap(ScopedAuthorizationRef& that) {
- AuthorizationRef temp = that.authorization_;
- that.authorization_ = authorization_;
- authorization_ = temp;
- }
-
- // ScopedAuthorizationRef::release() is like std::unique_ptr<>::release. It is
- // NOT a wrapper for AuthorizationFree(). To force a ScopedAuthorizationRef
- // object to call AuthorizationFree(), use ScopedAuthorizationRef::reset().
- AuthorizationRef release() WARN_UNUSED_RESULT {
- AuthorizationRef temp = authorization_;
- authorization_ = NULL;
- return temp;
- }
-
- private:
- AuthorizationRef authorization_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedAuthorizationRef);
-};
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_AUTHORIZATIONREF_H_
diff --git a/base/mac/scoped_cffiledescriptorref.h b/base/mac/scoped_cffiledescriptorref.h
deleted file mode 100644
index 923a159..0000000
--- a/base/mac/scoped_cffiledescriptorref.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_CFFILEDESCRIPTORREF_H_
-#define BASE_MAC_SCOPED_CFFILEDESCRIPTORREF_H_
-
-#include <CoreFoundation/CoreFoundation.h>
-
-#include "base/scoped_generic.h"
-
-namespace base {
-namespace mac {
-
-namespace internal {
-
-struct ScopedCFFileDescriptorRefTraits {
- static CFFileDescriptorRef InvalidValue() { return nullptr; }
- static void Free(CFFileDescriptorRef ref) {
- CFFileDescriptorInvalidate(ref);
- CFRelease(ref);
- }
-};
-
-} // namespace internal
-
-// ScopedCFFileDescriptorRef is designed after ScopedCFTypeRef<>. On
-// destruction, it will invalidate the file descriptor.
-// ScopedCFFileDescriptorRef (unlike ScopedCFTypeRef<>) does not support RETAIN
-// semantics, copying, or assignment, as doing so would increase the chances
-// that a file descriptor is invalidated while still in use.
-using ScopedCFFileDescriptorRef =
- ScopedGeneric<CFFileDescriptorRef,
- internal::ScopedCFFileDescriptorRefTraits>;
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_CFFILEDESCRIPTORREF_H_
diff --git a/base/mac/scoped_ionotificationportref.h b/base/mac/scoped_ionotificationportref.h
deleted file mode 100644
index 93ebc98..0000000
--- a/base/mac/scoped_ionotificationportref.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_IONOTIFICATIONPORTREF_H_
-#define BASE_MAC_SCOPED_IONOTIFICATIONPORTREF_H_
-
-#include <IOKit/IOKitLib.h>
-
-#include "base/scoped_generic.h"
-
-namespace base {
-namespace mac {
-
-namespace internal {
-
-struct ScopedIONotificationPortRefTraits {
- static IONotificationPortRef InvalidValue() { return nullptr; }
- static void Free(IONotificationPortRef object) {
- IONotificationPortDestroy(object);
- }
-};
-
-} // namepsace internal
-
-using ScopedIONotificationPortRef =
- ScopedGeneric<IONotificationPortRef,
- internal::ScopedIONotificationPortRefTraits>;
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_IONOTIFICATIONPORTREF_H_
diff --git a/base/mac/scoped_ioplugininterface.h b/base/mac/scoped_ioplugininterface.h
deleted file mode 100644
index 872da8e..0000000
--- a/base/mac/scoped_ioplugininterface.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_IOPLUGININTERFACE_H_
-#define BASE_MAC_SCOPED_IOPLUGININTERFACE_H_
-
-#include <IOKit/IOKitLib.h>
-
-#include "base/mac/scoped_typeref.h"
-
-namespace base {
-namespace mac {
-
-namespace internal {
-
-template <typename T>
-struct ScopedIOPluginInterfaceTraits {
- static T InvalidValue() { return nullptr; }
- static T Retain(T t) {
- (*t)->AddRef(t);
- return t;
- }
- static void Release(T t) { (*t)->Release(t); }
-};
-
-} // namespace internal
-
-// Just like ScopedCFTypeRef but for IOCFPlugInInterface and friends
-// (IOUSBInterfaceStruct and IOUSBDeviceStruct320 in particular).
-template <typename T>
-using ScopedIOPluginInterface =
- ScopedTypeRef<T**, internal::ScopedIOPluginInterfaceTraits<T**>>;
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_IOPLUGININTERFACE_H_
diff --git a/base/mac/scoped_launch_data.h b/base/mac/scoped_launch_data.h
deleted file mode 100644
index f4db330..0000000
--- a/base/mac/scoped_launch_data.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_LAUNCH_DATA_H_
-#define BASE_MAC_SCOPED_LAUNCH_DATA_H_
-
-#include <launch.h>
-
-#include "base/scoped_generic.h"
-
-namespace base {
-namespace mac {
-
-namespace internal {
-
-struct ScopedLaunchDataTraits {
- static launch_data_t InvalidValue() { return nullptr; }
- static void Free(launch_data_t ldt) { launch_data_free(ldt); }
-};
-
-} // namespace internal
-
-// Just like std::unique_ptr<> but for launch_data_t.
-using ScopedLaunchData =
- ScopedGeneric<launch_data_t, internal::ScopedLaunchDataTraits>;
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_LAUNCH_DATA_H_
diff --git a/base/mac/scoped_mach_vm.cc b/base/mac/scoped_mach_vm.cc
deleted file mode 100644
index d52c77f..0000000
--- a/base/mac/scoped_mach_vm.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/mac/scoped_mach_vm.h"
-
-namespace base {
-namespace mac {
-
-void ScopedMachVM::reset(vm_address_t address, vm_size_t size) {
- DCHECK_EQ(address % PAGE_SIZE, 0u);
- DCHECK_EQ(size % PAGE_SIZE, 0u);
-
- if (size_) {
- if (address_ < address) {
- vm_deallocate(mach_task_self(),
- address_,
- std::min(size_, address - address_));
- }
- if (address_ + size_ > address + size) {
- vm_address_t deallocate_start = std::max(address_, address + size);
- vm_deallocate(mach_task_self(),
- deallocate_start,
- address_ + size_ - deallocate_start);
- }
- }
-
- address_ = address;
- size_ = size;
-}
-
-} // namespace mac
-} // namespace base
diff --git a/base/mac/scoped_mach_vm.h b/base/mac/scoped_mach_vm.h
deleted file mode 100644
index 58a13f6..0000000
--- a/base/mac/scoped_mach_vm.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_MACH_VM_H_
-#define BASE_MAC_SCOPED_MACH_VM_H_
-
-#include <mach/mach.h>
-#include <stddef.h>
-
-#include <algorithm>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/macros.h"
-
-// Use ScopedMachVM to supervise ownership of pages in the current process
-// through the Mach VM subsystem. Pages allocated with vm_allocate can be
-// released when exiting a scope with ScopedMachVM.
-//
-// The Mach VM subsystem operates on a page-by-page basis, and a single VM
-// allocation managed by a ScopedMachVM object may span multiple pages. As far
-// as Mach is concerned, allocated pages may be deallocated individually. This
-// is in contrast to higher-level allocators such as malloc, where the base
-// address of an allocation implies the size of an allocated block.
-// Consequently, it is not sufficient to just pass the base address of an
-// allocation to ScopedMachVM, it also needs to know the size of the
-// allocation. To avoid any confusion, both the base address and size must
-// be page-aligned.
-//
-// When dealing with Mach VM, base addresses will naturally be page-aligned,
-// but user-specified sizes may not be. If there's a concern that a size is
-// not page-aligned, use the mach_vm_round_page macro to correct it.
-//
-// Example:
-//
-// vm_address_t address = 0;
-// vm_size_t size = 12345; // This requested size is not page-aligned.
-// kern_return_t kr =
-// vm_allocate(mach_task_self(), &address, size, VM_FLAGS_ANYWHERE);
-// if (kr != KERN_SUCCESS) {
-// return false;
-// }
-// ScopedMachVM vm_owner(address, mach_vm_round_page(size));
-
-namespace base {
-namespace mac {
-
-class BASE_EXPORT ScopedMachVM {
- public:
- explicit ScopedMachVM(vm_address_t address = 0, vm_size_t size = 0)
- : address_(address), size_(size) {
- DCHECK_EQ(address % PAGE_SIZE, 0u);
- DCHECK_EQ(size % PAGE_SIZE, 0u);
- }
-
- ~ScopedMachVM() {
- if (size_) {
- vm_deallocate(mach_task_self(), address_, size_);
- }
- }
-
- void reset(vm_address_t address = 0, vm_size_t size = 0);
-
- vm_address_t address() const {
- return address_;
- }
-
- vm_size_t size() const {
- return size_;
- }
-
- void swap(ScopedMachVM& that) {
- std::swap(address_, that.address_);
- std::swap(size_, that.size_);
- }
-
- void release() {
- address_ = 0;
- size_ = 0;
- }
-
- private:
- vm_address_t address_;
- vm_size_t size_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedMachVM);
-};
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_MACH_VM_H_
diff --git a/base/mac/scoped_objc_class_swizzler.h b/base/mac/scoped_objc_class_swizzler.h
deleted file mode 100644
index e18e4ab..0000000
--- a/base/mac/scoped_objc_class_swizzler.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_OBJC_CLASS_SWIZZLER_H_
-#define BASE_MAC_SCOPED_OBJC_CLASS_SWIZZLER_H_
-
-#import <objc/runtime.h>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-
-namespace base {
-namespace mac {
-
-// Within a given scope, swaps method implementations of a class interface, or
-// between two class interfaces. The argument and return types must match.
-class BASE_EXPORT ScopedObjCClassSwizzler {
- public:
- // Given two classes that each respond to |selector|, swap the implementations
- // of those methods.
- ScopedObjCClassSwizzler(Class target, Class source, SEL selector);
-
- // Given two selectors on the same class interface, |target| (e.g. via
- // inheritance or categories), swap the implementations of methods |original|
- // and |alternate|.
- ScopedObjCClassSwizzler(Class target, SEL original, SEL alternate);
-
- ~ScopedObjCClassSwizzler();
-
- // Return a callable function pointer for the replaced method. To call this
- // from the replacing function, the first two arguments should be |self| and
- // |_cmd|. These are followed by the (variadic) method arguments.
- IMP GetOriginalImplementation();
-
- private:
- // Delegated constructor.
- void Init(Class target, Class source, SEL original, SEL alternate);
-
- Method old_selector_impl_;
- Method new_selector_impl_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedObjCClassSwizzler);
-};
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_OBJC_CLASS_SWIZZLER_H_
diff --git a/base/mac/scoped_objc_class_swizzler.mm b/base/mac/scoped_objc_class_swizzler.mm
deleted file mode 100644
index 20e5c56..0000000
--- a/base/mac/scoped_objc_class_swizzler.mm
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#import "base/mac/scoped_objc_class_swizzler.h"
-
-#include <string.h>
-
-#include "base/logging.h"
-
-namespace base {
-namespace mac {
-
-ScopedObjCClassSwizzler::ScopedObjCClassSwizzler(Class target,
- Class source,
- SEL selector)
- : old_selector_impl_(NULL), new_selector_impl_(NULL) {
- Init(target, source, selector, selector);
-}
-
-ScopedObjCClassSwizzler::ScopedObjCClassSwizzler(Class target,
- SEL original,
- SEL alternate)
- : old_selector_impl_(NULL), new_selector_impl_(NULL) {
- Init(target, target, original, alternate);
-}
-
-ScopedObjCClassSwizzler::~ScopedObjCClassSwizzler() {
- if (old_selector_impl_ && new_selector_impl_)
- method_exchangeImplementations(old_selector_impl_, new_selector_impl_);
-}
-
-IMP ScopedObjCClassSwizzler::GetOriginalImplementation() {
- // Note that while the swizzle is in effect the "new" method is actually
- // pointing to the original implementation, since they have been swapped.
- return method_getImplementation(new_selector_impl_);
-}
-
-void ScopedObjCClassSwizzler::Init(Class target,
- Class source,
- SEL original,
- SEL alternate) {
- old_selector_impl_ = class_getInstanceMethod(target, original);
- new_selector_impl_ = class_getInstanceMethod(source, alternate);
- if (!old_selector_impl_ && !new_selector_impl_) {
- // Try class methods.
- old_selector_impl_ = class_getClassMethod(target, original);
- new_selector_impl_ = class_getClassMethod(source, alternate);
- }
-
- DCHECK(old_selector_impl_);
- DCHECK(new_selector_impl_);
- if (!old_selector_impl_ || !new_selector_impl_)
- return;
-
- // The argument and return types must match exactly.
- const char* old_types = method_getTypeEncoding(old_selector_impl_);
- const char* new_types = method_getTypeEncoding(new_selector_impl_);
- DCHECK(old_types);
- DCHECK(new_types);
- DCHECK_EQ(0, strcmp(old_types, new_types));
- if (!old_types || !new_types || strcmp(old_types, new_types)) {
- old_selector_impl_ = new_selector_impl_ = NULL;
- return;
- }
-
- method_exchangeImplementations(old_selector_impl_, new_selector_impl_);
-}
-
-} // namespace mac
-} // namespace base
diff --git a/base/mac/scoped_sending_event.h b/base/mac/scoped_sending_event.h
deleted file mode 100644
index c579cef..0000000
--- a/base/mac/scoped_sending_event.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MAC_SCOPED_SENDING_EVENT_H_
-#define BASE_MAC_SCOPED_SENDING_EVENT_H_
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/message_loop/message_pump_mac.h"
-
-// Nested event loops can pump IPC messages, including
-// script-initiated tab closes, which could release objects that the
-// nested event loop might message. CrAppProtocol defines how to ask
-// the embedding NSApplication subclass if an event is currently being
-// handled, in which case such closes are deferred to the top-level
-// event loop.
-//
-// ScopedSendingEvent allows script-initiated event loops to work like
-// a nested event loop, as such events do not arrive via -sendEvent:.
-// CrAppControlProtocol lets ScopedSendingEvent tell the embedding
-// NSApplication what to return from -handlingSendEvent.
-
-@protocol CrAppControlProtocol<CrAppProtocol>
-- (void)setHandlingSendEvent:(BOOL)handlingSendEvent;
-@end
-
-namespace base {
-namespace mac {
-
-class BASE_EXPORT ScopedSendingEvent {
- public:
- ScopedSendingEvent();
- ~ScopedSendingEvent();
-
- private:
- // The NSApp in control at the time the constructor was run, to be
- // sure the |handling_| setting is restored appropriately.
- NSObject<CrAppControlProtocol>* app_;
- BOOL handling_; // Value of -[app_ handlingSendEvent] at construction.
-
- DISALLOW_COPY_AND_ASSIGN(ScopedSendingEvent);
-};
-
-} // namespace mac
-} // namespace base
-
-#endif // BASE_MAC_SCOPED_SENDING_EVENT_H_
diff --git a/base/mac/scoped_sending_event.mm b/base/mac/scoped_sending_event.mm
deleted file mode 100644
index c3813d8..0000000
--- a/base/mac/scoped_sending_event.mm
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#import "base/mac/scoped_sending_event.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace mac {
-
-ScopedSendingEvent::ScopedSendingEvent()
- : app_(static_cast<NSObject<CrAppControlProtocol>*>(NSApp)) {
- DCHECK([app_ conformsToProtocol:@protocol(CrAppControlProtocol)]);
- handling_ = [app_ isHandlingSendEvent];
- [app_ setHandlingSendEvent:YES];
-}
-
-ScopedSendingEvent::~ScopedSendingEvent() {
- [app_ setHandlingSendEvent:handling_];
-}
-
-} // namespace mac
-} // namespace base
diff --git a/base/memory/ref_counted.cc b/base/memory/ref_counted.cc
index c2d40ef..79ab853 100644
--- a/base/memory/ref_counted.cc
+++ b/base/memory/ref_counted.cc
@@ -4,8 +4,6 @@
#include "base/memory/ref_counted.h"
-#include "base/threading/thread_collision_warner.h"
-
namespace base {
namespace subtle {
diff --git a/base/memory/ref_counted.h b/base/memory/ref_counted.h
index 6466c19..5cb731c 100644
--- a/base/memory/ref_counted.h
+++ b/base/memory/ref_counted.h
@@ -15,7 +15,6 @@
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/scoped_refptr.h"
-#include "base/threading/thread_collision_warner.h"
#include "build_config.h"
namespace base {
diff --git a/base/numerics/OWNERS b/base/numerics/OWNERS
deleted file mode 100644
index 5493fba..0000000
--- a/base/numerics/OWNERS
+++ /dev/null
@@ -1,5 +0,0 @@
-jschuh@chromium.org
-tsepez@chromium.org
-
-
-# COMPONENT: Internals
diff --git a/base/numerics/README.md b/base/numerics/README.md
deleted file mode 100644
index 896b124..0000000
--- a/base/numerics/README.md
+++ /dev/null
@@ -1,409 +0,0 @@
-# `base/numerics`
-
-This directory contains a dependency-free, header-only library of templates
-providing well-defined semantics for safely and performantly handling a variety
-of numeric operations, including most common arithmetic operations and
-conversions.
-
-The public API is broken out into the following header files:
-
-* `checked_math.h` contains the `CheckedNumeric` template class and helper
- functions for performing arithmetic and conversion operations that detect
- errors and boundary conditions (e.g. overflow, truncation, etc.).
-* `clamped_math.h` contains the `ClampedNumeric` template class and
- helper functions for performing fast, clamped (i.e. non-sticky saturating)
- arithmetic operations and conversions.
-* `safe_conversions.h` contains the `StrictNumeric` template class and
- a collection of custom casting templates and helper functions for safely
- converting between a range of numeric types.
-* `safe_math.h` includes all of the previously mentioned headers.
-
-*** aside
-**Note:** The `Numeric` template types implicitly convert from C numeric types
-and `Numeric` templates that are convertable to an underlying C numeric type.
-The conversion priority for `Numeric` type coercions is:
-
-* `StrictNumeric` coerces to `ClampedNumeric` and `CheckedNumeric`
-* `ClampedNumeric` coerces to `CheckedNumeric`
-***
-
-[TOC]
-
-## Common patterns and use-cases
-
-The following covers the preferred style for the most common uses of this
-library. Please don't cargo-cult from anywhere else. 😉
-
-### Performing checked arithmetic conversions
-
-The `checked_cast` template converts between arbitrary arithmetic types, and is
-used for cases where a conversion failure should result in program termination:
-
-```cpp
-// Crash if signed_value is out of range for buff_size.
-size_t buff_size = checked_cast<size_t>(signed_value);
-```
-
-### Performing saturated (clamped) arithmetic conversions
-
-The `saturated_cast` template converts between arbitrary arithmetic types, and
-is used in cases where an out-of-bounds source value should be saturated to the
-corresponding maximum or minimum of the destination type:
-
-```cpp
-// Convert from float with saturation to INT_MAX, INT_MIN, or 0 for NaN.
-int int_value = saturated_cast<int>(floating_point_value);
-```
-
-### Enforcing arithmetic conversions at compile-time
-
-The `strict_cast` enforces type restrictions at compile-time and results in
-emitted code that is identical to a normal `static_cast`. However, a
-`strict_cast` assignment will fail to compile if the destination type cannot
-represent the full range of the source type:
-
-```cpp
-// Throw a compiler error if byte_value is changed to an out-of-range-type.
-int int_value = strict_cast<int>(byte_value);
-```
-
-You can also enforce these compile-time restrictions on function parameters by
-using the `StrictNumeric` template:
-
-```cpp
-// Throw a compiler error if the size argument cannot be represented by a
-// size_t (e.g. passing an int will fail to compile).
-bool AllocateBuffer(void** buffer, StrictCast<size_t> size);
-```
-
-### Comparing values between arbitrary arithmetic types
-
-Both the `StrictNumeric` and `ClampedNumeric` types provide well defined
-comparisons between arbitrary arithmetic types. This allows you to perform
-comparisons that are not legal or would trigger compiler warnings or errors
-under the normal arithmetic promotion rules:
-
-```cpp
-bool foo(unsigned value, int upper_bound) {
- // Converting to StrictNumeric allows this comparison to work correctly.
- if (MakeStrictNum(value) >= upper_bound)
- return false;
-```
-
-*** note
-**Warning:** Do not perform manual conversions using the comparison operators.
-Instead, use the cast templates described in the previous sections, or the
-constexpr template functions `IsValueInRangeForNumericType` and
-`IsTypeInRangeForNumericType`, as these templates properly handle the full range
-of corner cases and employ various optimizations.
-***
-
-### Calculating a buffer size (checked arithmetic)
-
-When making exact calculations—such as for buffer lengths—it's often necessary
-to know when those calculations trigger an overflow, undefined behavior, or
-other boundary conditions. The `CheckedNumeric` template does this by storing
-a bit determining whether or not some arithmetic operation has occured that
-would put the variable in an "invalid" state. Attempting to extract the value
-from a variable in an invalid state will trigger a check/trap condition, that
-by default will result in process termination.
-
-Here's an example of a buffer calculation using a `CheckedNumeric` type (note:
-the AssignIfValid method will trigger a compile error if the result is ignored).
-
-```cpp
-// Calculate the buffer size and detect if an overflow occurs.
-size_t size;
-if (!CheckAdd(kHeaderSize, CheckMul(count, kItemSize)).AssignIfValid(&size)) {
- // Handle an overflow error...
-}
-```
-
-### Calculating clamped coordinates (non-sticky saturating arithmetic)
-
-Certain classes of calculations—such as coordinate calculations—require
-well-defined semantics that always produce a valid result on boundary
-conditions. The `ClampedNumeric` template addresses this by providing
-performant, non-sticky saturating arithmetic operations.
-
-Here's an example of using a `ClampedNumeric` to calculate an operation
-insetting a rectangle.
-
-```cpp
-// Use clamped arithmetic since inset calculations might overflow.
-void Rect::Inset(int left, int top, int right, int bottom) {
- origin_ += Vector2d(left, top);
- set_width(ClampSub(width(), ClampAdd(left, right)));
- set_height(ClampSub(height(), ClampAdd(top, bottom)));
-}
-```
-
-*** note
-The `ClampedNumeric` type is not "sticky", which means the saturation is not
-retained across individual operations. As such, one arithmetic operation may
-result in a saturated value, while the next operation may then "desaturate"
-the value. Here's an example:
-
-```cpp
-ClampedNumeric<int> value = INT_MAX;
-++value; // value is still INT_MAX, due to saturation.
---value; // value is now (INT_MAX - 1), because saturation is not sticky.
-```
-
-***
-
-## Conversion functions and StrictNumeric<> in safe_conversions.h
-
-This header includes a collection of helper `constexpr` templates for safely
-performing a range of conversions, assignments, and tests.
-
-### Safe casting templates
-
-* `as_signed()` - Returns the supplied integral value as a signed type of
- the same width.
-* `as_unsigned()` - Returns the supplied integral value as an unsigned type
- of the same width.
-* `checked_cast<>()` - Analogous to `static_cast<>` for numeric types, except
- that by default it will trigger a crash on an out-of-bounds conversion (e.g.
- overflow, underflow, NaN to integral) or a compile error if the conversion
- error can be detected at compile time. The crash handler can be overridden
- to perform a behavior other than crashing.
-* `saturated_cast<>()` - Analogous to `static_cast` for numeric types, except
- that it returns a saturated result when the specified numeric conversion
- would otherwise overflow or underflow. An NaN source returns 0 by
- default, but can be overridden to return a different result.
-* `strict_cast<>()` - Analogous to `static_cast` for numeric types, except
- this causes a compile failure if the destination type is not large
- enough to contain any value in the source type. It performs no runtime
- checking and thus introduces no runtime overhead.
-
-### Other helper and conversion functions
-
-* `IsValueInRangeForNumericType<>()` - A convenience function that returns
- true if the type supplied as the template parameter can represent the value
- passed as an argument to the function.
-* `IsTypeInRangeForNumericType<>()` - A convenience function that evaluates
- entirely at compile-time and returns true if the destination type (first
- template parameter) can represent the full range of the source type
- (second template parameter).
-* `IsValueNegative()` - A convenience function that will accept any
- arithmetic type as an argument and will return whether the value is less
- than zero. Unsigned types always return false.
-* `SafeUnsignedAbs()` - Returns the absolute value of the supplied integer
- parameter as an unsigned result (thus avoiding an overflow if the value
- is the signed, two's complement minimum).
-
-### StrictNumeric<>
-
-`StrictNumeric<>` is a wrapper type that performs assignments and copies via
-the `strict_cast` template, and can perform valid arithmetic comparisons
-across any range of arithmetic types. `StrictNumeric` is the return type for
-values extracted from a `CheckedNumeric` class instance. The raw numeric value
-is extracted via `static_cast` to the underlying type or any type with
-sufficient range to represent the underlying type.
-
-* `MakeStrictNum()` - Creates a new `StrictNumeric` from the underlying type
- of the supplied arithmetic or StrictNumeric type.
-* `SizeT` - Alias for `StrictNumeric<size_t>`.
-
-## CheckedNumeric<> in checked_math.h
-
-`CheckedNumeric<>` implements all the logic and operators for detecting integer
-boundary conditions such as overflow, underflow, and invalid conversions.
-The `CheckedNumeric` type implicitly converts from floating point and integer
-data types, and contains overloads for basic arithmetic operations (i.e.: `+`,
-`-`, `*`, `/` for all types and `%`, `<<`, `>>`, `&`, `|`, `^` for integers).
-However, *the [variadic template functions
-](#CheckedNumeric_in-checked_math_h-Non_member-helper-functions)
-are the prefered API,* as they remove type ambiguities and help prevent a number
-of common errors. The variadic functions can also be more performant, as they
-eliminate redundant expressions that are unavoidable with the with the operator
-overloads. (Ideally the compiler should optimize those away, but better to avoid
-them in the first place.)
-
-Type promotions are a slightly modified version of the [standard C/C++ numeric
-promotions
-](http://en.cppreference.com/w/cpp/language/implicit_conversion#Numeric_promotions)
-with the two differences being that *there is no default promotion to int*
-and *bitwise logical operations always return an unsigned of the wider type.*
-
-### Members
-
-The unary negation, increment, and decrement operators are supported, along
-with the following unary arithmetic methods, which return a new
-`CheckedNumeric` as a result of the operation:
-
-* `Abs()` - Absolute value.
-* `UnsignedAbs()` - Absolute value as an equal-width unsigned underlying type
- (valid for only integral types).
-* `Max()` - Returns whichever is greater of the current instance or argument.
- The underlying return type is whichever has the greatest magnitude.
-* `Min()` - Returns whichever is lowest of the current instance or argument.
- The underlying return type is whichever has can represent the lowest
- number in the smallest width (e.g. int8_t over unsigned, int over
- int8_t, and float over int).
-
-The following are for converting `CheckedNumeric` instances:
-
-* `type` - The underlying numeric type.
-* `AssignIfValid()` - Assigns the underlying value to the supplied
- destination pointer if the value is currently valid and within the
- range supported by the destination type. Returns true on success.
-* `Cast<>()` - Instance method returning a `CheckedNumeric` derived from
- casting the current instance to a `CheckedNumeric` of the supplied
- destination type.
-
-*** aside
-The following member functions return a `StrictNumeric`, which is valid for
-comparison and assignment operations, but will trigger a compile failure on
-attempts to assign to a type of insufficient range. The underlying value can
-be extracted by an explicit `static_cast` to the underlying type or any type
-with sufficient range to represent the underlying type.
-***
-
-* `IsValid()` - Returns true if the underlying numeric value is valid (i.e.
- has not wrapped or saturated and is not the result of an invalid
- conversion).
-* `ValueOrDie()` - Returns the underlying value. If the state is not valid
- this call will trigger a crash by default (but may be overridden by
- supplying an alternate handler to the template).
-* `ValueOrDefault()` - Returns the current value, or the supplied default if
- the state is not valid (but will not crash).
-
-**Comparison operators are explicitly not provided** for `CheckedNumeric`
-types because they could result in a crash if the type is not in a valid state.
-Patterns like the following should be used instead:
-
-```cpp
-// Either input or padding (or both) may be arbitrary sizes.
-size_t buff_size;
-if (!CheckAdd(input, padding, kHeaderLength).AssignIfValid(&buff_size) ||
- buff_size >= kMaxBuffer) {
- // Handle an error...
-} else {
- // Do stuff on success...
-}
-```
-
-### Non-member helper functions
-
-The following variadic convenience functions, which accept standard arithmetic
-or `CheckedNumeric` types, perform arithmetic operations, and return a
-`CheckedNumeric` result. The supported functions are:
-
-* `CheckAdd()` - Addition.
-* `CheckSub()` - Subtraction.
-* `CheckMul()` - Multiplication.
-* `CheckDiv()` - Division.
-* `CheckMod()` - Modulus (integer only).
-* `CheckLsh()` - Left integer shift (integer only).
-* `CheckRsh()` - Right integer shift (integer only).
-* `CheckAnd()` - Bitwise AND (integer only with unsigned result).
-* `CheckOr()` - Bitwise OR (integer only with unsigned result).
-* `CheckXor()` - Bitwise XOR (integer only with unsigned result).
-* `CheckMax()` - Maximum of supplied arguments.
-* `CheckMin()` - Minimum of supplied arguments.
-
-The following wrapper functions can be used to avoid the template
-disambiguator syntax when converting a destination type.
-
-* `IsValidForType<>()` in place of: `a.template IsValid<>()`
-* `ValueOrDieForType<>()` in place of: `a.template ValueOrDie<>()`
-* `ValueOrDefaultForType<>()` in place of: `a.template ValueOrDefault<>()`
-
-The following general utility methods is are useful for converting from
-arithmetic types to `CheckedNumeric` types:
-
-* `MakeCheckedNum()` - Creates a new `CheckedNumeric` from the underlying type
- of the supplied arithmetic or directly convertible type.
-
-## ClampedNumeric<> in clamped_math.h
-
-`ClampedNumeric<>` implements all the logic and operators for clamped
-(non-sticky saturating) arithmetic operations and conversions. The
-`ClampedNumeric` type implicitly converts back and forth between floating point
-and integer data types, saturating on assignment as appropriate. It contains
-overloads for basic arithmetic operations (i.e.: `+`, `-`, `*`, `/` for
-all types and `%`, `<<`, `>>`, `&`, `|`, `^` for integers) along with comparison
-operators for arithmetic types of any size. However, *the [variadic template
-functions
-](#ClampedNumeric_in-clamped_math_h-Non_member-helper-functions)
-are the prefered API,* as they remove type ambiguities and help prevent
-a number of common errors. The variadic functions can also be more performant,
-as they eliminate redundant expressions that are unavoidable with the operator
-overloads. (Ideally the compiler should optimize those away, but better to avoid
-them in the first place.)
-
-Type promotions are a slightly modified version of the [standard C/C++ numeric
-promotions
-](http://en.cppreference.com/w/cpp/language/implicit_conversion#Numeric_promotions)
-with the two differences being that *there is no default promotion to int*
-and *bitwise logical operations always return an unsigned of the wider type.*
-
-*** aside
-Most arithmetic operations saturate normally, to the numeric limit in the
-direction of the sign. The potentially unusual cases are:
-
-* **Division:** Division by zero returns the saturated limit in the direction
- of sign of the dividend (first argument). The one exception is 0/0, which
- returns zero (although logically is NaN).
-* **Modulus:** Division by zero returns the dividend (first argument).
-* **Left shift:** Non-zero values saturate in the direction of the signed
- limit (max/min), even for shifts larger than the bit width. 0 shifted any
- amount results in 0.
-* **Right shift:** Negative values saturate to -1. Positive or 0 saturates
- to 0. (Effectively just an unbounded arithmetic-right-shift.)
-* **Bitwise operations:** No saturation; bit pattern is identical to
- non-saturated bitwise operations.
-***
-
-### Members
-
-The unary negation, increment, and decrement operators are supported, along
-with the following unary arithmetic methods, which return a new
-`ClampedNumeric` as a result of the operation:
-
-* `Abs()` - Absolute value.
-* `UnsignedAbs()` - Absolute value as an equal-width unsigned underlying type
- (valid for only integral types).
-* `Max()` - Returns whichever is greater of the current instance or argument.
- The underlying return type is whichever has the greatest magnitude.
-* `Min()` - Returns whichever is lowest of the current instance or argument.
- The underlying return type is whichever has can represent the lowest
- number in the smallest width (e.g. int8_t over unsigned, int over
- int8_t, and float over int).
-
-The following are for converting `ClampedNumeric` instances:
-
-* `type` - The underlying numeric type.
-* `RawValue()` - Returns the raw value as the underlying arithmetic type. This
- is useful when e.g. assigning to an auto type or passing as a deduced
- template parameter.
-* `Cast<>()` - Instance method returning a `ClampedNumeric` derived from
- casting the current instance to a `ClampedNumeric` of the supplied
- destination type.
-
-### Non-member helper functions
-
-The following variadic convenience functions, which accept standard arithmetic
-or `ClampedNumeric` types, perform arithmetic operations, and return a
-`ClampedNumeric` result. The supported functions are:
-
-* `ClampAdd()` - Addition.
-* `ClampSub()` - Subtraction.
-* `ClampMul()` - Multiplication.
-* `ClampDiv()` - Division.
-* `ClampMod()` - Modulus (integer only).
-* `ClampLsh()` - Left integer shift (integer only).
-* `ClampRsh()` - Right integer shift (integer only).
-* `ClampAnd()` - Bitwise AND (integer only with unsigned result).
-* `ClampOr()` - Bitwise OR (integer only with unsigned result).
-* `ClampXor()` - Bitwise XOR (integer only with unsigned result).
-* `ClampMax()` - Maximum of supplied arguments.
-* `ClampMin()` - Minimum of supplied arguments.
-
-The following is a general utility method that is useful for converting
-to a `ClampedNumeric` type:
-
-* `MakeClampedNum()` - Creates a new `ClampedNumeric` from the underlying type
- of the supplied arithmetic or directly convertible type.
diff --git a/base/observer_list.h b/base/observer_list.h
deleted file mode 100644
index e900e43..0000000
--- a/base/observer_list.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_OBSERVER_LIST_H_
-#define BASE_OBSERVER_LIST_H_
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <iterator>
-#include <limits>
-#include <utility>
-#include <vector>
-
-#include "base/gtest_prod_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/stl_util.h"
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// OVERVIEW:
-//
-// A list of observers. Unlike a standard vector or list, this container can
-// be modified during iteration without invalidating the iterator. So, it
-// safely handles the case of an observer removing itself or other observers
-// from the list while observers are being notified.
-//
-//
-// WARNING:
-//
-// ObserverList is not thread-compatible. Iterating on the same ObserverList
-// simultaneously in different threads is not safe, even when the ObserverList
-// itself is not modified.
-//
-// For a thread-safe observer list, see ObserverListThreadSafe.
-//
-//
-// TYPICAL USAGE:
-//
-// class MyWidget {
-// public:
-// ...
-//
-// class Observer {
-// public:
-// virtual void OnFoo(MyWidget* w) = 0;
-// virtual void OnBar(MyWidget* w, int x, int y) = 0;
-// };
-//
-// void AddObserver(Observer* obs) {
-// observers_.AddObserver(obs);
-// }
-//
-// void RemoveObserver(const Observer* obs) {
-// observers_.RemoveObserver(obs);
-// }
-//
-// void NotifyFoo() {
-// for (Observer& obs : observers_)
-// obs.OnFoo(this);
-// }
-//
-// void NotifyBar(int x, int y) {
-// for (Observer& obs : observers_)
-// obs.OnBar(this, x, y);
-// }
-//
-// private:
-// base::ObserverList<Observer> observers_;
-// };
-//
-//
-///////////////////////////////////////////////////////////////////////////////
-
-namespace base {
-
-// Enumeration of which observers are notified by ObserverList.
-enum class ObserverListPolicy {
- // Specifies that any observers added during notification are notified.
- // This is the default policy if no policy is provided to the constructor.
- ALL,
-
- // Specifies that observers added while sending out notification are not
- // notified.
- EXISTING_ONLY,
-};
-
-// When check_empty is true, assert that the list is empty on destruction.
-// When allow_reentrancy is false, iterating throught the list while already in
-// the iteration loop will result in DCHECK failure.
-// TODO(oshima): Change the default to non reentrant. https://crbug.com/812109
-template <class ObserverType,
- bool check_empty = false,
- bool allow_reentrancy = true>
-class ObserverList
- : public SupportsWeakPtr<
- ObserverList<ObserverType, check_empty, allow_reentrancy>> {
- public:
- // An iterator class that can be used to access the list of observers.
- class Iter {
- public:
- using iterator_category = std::forward_iterator_tag;
- using value_type = ObserverType;
- using difference_type = ptrdiff_t;
- using pointer = ObserverType*;
- using reference = ObserverType&;
-
- Iter() : index_(0), max_index_(0) {}
-
- explicit Iter(const ObserverList* list)
- : list_(const_cast<ObserverList*>(list)->AsWeakPtr()),
- index_(0),
- max_index_(list->policy_ == ObserverListPolicy::ALL
- ? std::numeric_limits<size_t>::max()
- : list->observers_.size()) {
- DCHECK(list_);
- DCHECK(allow_reentrancy || !list_->live_iterator_count_);
- EnsureValidIndex();
- ++list_->live_iterator_count_;
- }
-
- ~Iter() {
- if (!list_)
- return;
-
- DCHECK_GT(list_->live_iterator_count_, 0);
- if (--list_->live_iterator_count_ == 0)
- list_->Compact();
- }
-
- Iter(const Iter& other)
- : list_(other.list_),
- index_(other.index_),
- max_index_(other.max_index_) {
- if (list_)
- ++list_->live_iterator_count_;
- }
-
- Iter& operator=(Iter other) {
- using std::swap;
- swap(list_, other.list_);
- swap(index_, other.index_);
- swap(max_index_, other.max_index_);
- return *this;
- }
-
- bool operator==(const Iter& other) const {
- return (is_end() && other.is_end()) ||
- (list_.get() == other.list_.get() && index_ == other.index_);
- }
-
- bool operator!=(const Iter& other) const { return !(*this == other); }
-
- Iter& operator++() {
- if (list_) {
- ++index_;
- EnsureValidIndex();
- }
- return *this;
- }
-
- Iter operator++(int) {
- Iter it(*this);
- ++(*this);
- return it;
- }
-
- ObserverType* operator->() const {
- ObserverType* const current = GetCurrent();
- DCHECK(current);
- return current;
- }
-
- ObserverType& operator*() const {
- ObserverType* const current = GetCurrent();
- DCHECK(current);
- return *current;
- }
-
- private:
- FRIEND_TEST_ALL_PREFIXES(ObserverListTest, BasicStdIterator);
- FRIEND_TEST_ALL_PREFIXES(ObserverListTest, StdIteratorRemoveFront);
-
- ObserverType* GetCurrent() const {
- DCHECK(list_);
- DCHECK_LT(index_, clamped_max_index());
- return list_->observers_[index_];
- }
-
- void EnsureValidIndex() {
- DCHECK(list_);
- const size_t max_index = clamped_max_index();
- while (index_ < max_index && !list_->observers_[index_])
- ++index_;
- }
-
- size_t clamped_max_index() const {
- return std::min(max_index_, list_->observers_.size());
- }
-
- bool is_end() const { return !list_ || index_ == clamped_max_index(); }
-
- WeakPtr<ObserverList> list_;
-
- // When initially constructed and each time the iterator is incremented,
- // |index_| is guaranteed to point to a non-null index if the iterator
- // has not reached the end of the ObserverList.
- size_t index_;
- size_t max_index_;
- };
-
- using iterator = Iter;
- using const_iterator = Iter;
-
- const_iterator begin() const {
- // An optimization: do not involve weak pointers for empty list.
- return observers_.empty() ? const_iterator() : const_iterator(this);
- }
-
- const_iterator end() const { return const_iterator(); }
-
- ObserverList() = default;
- explicit ObserverList(ObserverListPolicy policy) : policy_(policy) {}
-
- ~ObserverList() {
- if (check_empty) {
- Compact();
- DCHECK(observers_.empty());
- }
- }
-
- // Add an observer to this list. An observer should not be added to the same
- // list more than once.
- //
- // Precondition: obs != nullptr
- // Precondition: !HasObserver(obs)
- void AddObserver(ObserverType* obs) {
- DCHECK(obs);
- if (HasObserver(obs)) {
- NOTREACHED() << "Observers can only be added once!";
- return;
- }
- observers_.push_back(obs);
- }
-
- // Removes the given observer from this list. Does nothing if this observer is
- // not in this list.
- void RemoveObserver(const ObserverType* obs) {
- DCHECK(obs);
- const auto it = std::find(observers_.begin(), observers_.end(), obs);
- if (it == observers_.end())
- return;
-
- DCHECK_GE(live_iterator_count_, 0);
- if (live_iterator_count_) {
- *it = nullptr;
- } else {
- observers_.erase(it);
- }
- }
-
- // Determine whether a particular observer is in the list.
- bool HasObserver(const ObserverType* obs) const {
- return ContainsValue(observers_, obs);
- }
-
- // Removes all the observers from this list.
- void Clear() {
- DCHECK_GE(live_iterator_count_, 0);
- if (live_iterator_count_) {
- std::fill(observers_.begin(), observers_.end(), nullptr);
- } else {
- observers_.clear();
- }
- }
-
- bool might_have_observers() const { return !observers_.empty(); }
-
- private:
- // Compacts list of observers by removing null pointers.
- void Compact() {
- observers_.erase(std::remove(observers_.begin(), observers_.end(), nullptr),
- observers_.end());
- }
-
- std::vector<ObserverType*> observers_;
-
- // Number of active iterators referencing this ObserverList.
- //
- // This counter is not synchronized although it is modified by const
- // iterators.
- int live_iterator_count_ = 0;
-
- const ObserverListPolicy policy_ = ObserverListPolicy::ALL;
-
- DISALLOW_COPY_AND_ASSIGN(ObserverList);
-};
-
-template <class ObserverType, bool check_empty = false>
-using ReentrantObserverList = ObserverList<ObserverType, check_empty, true>;
-
-} // namespace base
-
-#endif // BASE_OBSERVER_LIST_H_
diff --git a/base/observer_list_threadsafe.h b/base/observer_list_threadsafe.h
deleted file mode 100644
index 05b5a56..0000000
--- a/base/observer_list_threadsafe.h
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_OBSERVER_LIST_THREADSAFE_H_
-#define BASE_OBSERVER_LIST_THREADSAFE_H_
-
-#include <unordered_map>
-
-#include "base/base_export.h"
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/observer_list.h"
-#include "base/sequenced_task_runner.h"
-#include "base/stl_util.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/thread_local.h"
-#include "build_config.h"
-
-// TODO(fdoray): Removing these includes causes IWYU failures in other headers,
-// remove them in a follow- up CL.
-#include "base/memory/ptr_util.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// OVERVIEW:
-//
-// A thread-safe container for a list of observers. This is similar to the
-// observer_list (see observer_list.h), but it is more robust for multi-
-// threaded situations.
-//
-// The following use cases are supported:
-// * Observers can register for notifications from any sequence. They are
-// always notified on the sequence from which they were registered.
-// * Any sequence may trigger a notification via Notify().
-// * Observers can remove themselves from the observer list inside of a
-// callback.
-// * If one sequence is notifying observers concurrently with an observer
-// removing itself from the observer list, the notifications will be
-// silently dropped.
-//
-// The drawback of the threadsafe observer list is that notifications are not
-// as real-time as the non-threadsafe version of this class. Notifications
-// will always be done via PostTask() to another sequence, whereas with the
-// non-thread-safe observer_list, notifications happen synchronously.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-namespace base {
-namespace internal {
-
-class BASE_EXPORT ObserverListThreadSafeBase
- : public RefCountedThreadSafe<ObserverListThreadSafeBase> {
- public:
- ObserverListThreadSafeBase() = default;
-
- protected:
- template <typename ObserverType, typename Method>
- struct Dispatcher;
-
- template <typename ObserverType, typename ReceiverType, typename... Params>
- struct Dispatcher<ObserverType, void (ReceiverType::*)(Params...)> {
- static void Run(void (ReceiverType::*m)(Params...),
- Params... params,
- ObserverType* obj) {
- (obj->*m)(std::forward<Params>(params)...);
- }
- };
-
- struct NotificationDataBase {
- NotificationDataBase(void* observer_list_in, const Location& from_here_in)
- : observer_list(observer_list_in), from_here(from_here_in) {}
-
- void* observer_list;
- Location from_here;
- };
-
- virtual ~ObserverListThreadSafeBase() = default;
-
- static LazyInstance<ThreadLocalPointer<const NotificationDataBase>>::Leaky
- tls_current_notification_;
-
- private:
- friend class RefCountedThreadSafe<ObserverListThreadSafeBase>;
-
- DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafeBase);
-};
-
-} // namespace internal
-
-template <class ObserverType>
-class ObserverListThreadSafe : public internal::ObserverListThreadSafeBase {
- public:
- ObserverListThreadSafe() = default;
- explicit ObserverListThreadSafe(ObserverListPolicy policy)
- : policy_(policy) {}
-
- // Adds |observer| to the list. |observer| must not already be in the list.
- void AddObserver(ObserverType* observer) {
- // TODO(fdoray): Change this to a DCHECK once all call sites have a
- // SequencedTaskRunnerHandle.
- if (!SequencedTaskRunnerHandle::IsSet())
- return;
-
- AutoLock auto_lock(lock_);
-
- // Add |observer| to the list of observers.
- DCHECK(!ContainsKey(observers_, observer));
- const scoped_refptr<SequencedTaskRunner> task_runner =
- SequencedTaskRunnerHandle::Get();
- observers_[observer] = task_runner;
-
- // If this is called while a notification is being dispatched on this thread
- // and |policy_| is ALL, |observer| must be notified (if a notification is
- // being dispatched on another thread in parallel, the notification may or
- // may not make it to |observer| depending on the outcome of the race to
- // |lock_|).
- if (policy_ == ObserverListPolicy::ALL) {
- const NotificationDataBase* current_notification =
- tls_current_notification_.Get().Get();
- if (current_notification && current_notification->observer_list == this) {
- task_runner->PostTask(
- current_notification->from_here,
- BindOnce(
- &ObserverListThreadSafe<ObserverType>::NotifyWrapper, this,
- observer,
- *static_cast<const NotificationData*>(current_notification)));
- }
- }
- }
-
- // Remove an observer from the list if it is in the list.
- //
- // If a notification was sent to the observer but hasn't started to run yet,
- // it will be aborted. If a notification has started to run, removing the
- // observer won't stop it.
- void RemoveObserver(ObserverType* observer) {
- AutoLock auto_lock(lock_);
- observers_.erase(observer);
- }
-
- // Verifies that the list is currently empty (i.e. there are no observers).
- void AssertEmpty() const {
-#if DCHECK_IS_ON()
- AutoLock auto_lock(lock_);
- DCHECK(observers_.empty());
-#endif
- }
-
- // Asynchronously invokes a callback on all observers, on their registration
- // sequence. You cannot assume that at the completion of the Notify call that
- // all Observers have been Notified. The notification may still be pending
- // delivery.
- template <typename Method, typename... Params>
- void Notify(const Location& from_here, Method m, Params&&... params) {
- Callback<void(ObserverType*)> method =
- Bind(&Dispatcher<ObserverType, Method>::Run, m,
- std::forward<Params>(params)...);
-
- AutoLock lock(lock_);
- for (const auto& observer : observers_) {
- observer.second->PostTask(
- from_here,
- BindOnce(&ObserverListThreadSafe<ObserverType>::NotifyWrapper, this,
- observer.first, NotificationData(this, from_here, method)));
- }
- }
-
- private:
- friend class RefCountedThreadSafe<ObserverListThreadSafeBase>;
-
- struct NotificationData : public NotificationDataBase {
- NotificationData(ObserverListThreadSafe* observer_list_in,
- const Location& from_here_in,
- const Callback<void(ObserverType*)>& method_in)
- : NotificationDataBase(observer_list_in, from_here_in),
- method(method_in) {}
-
- Callback<void(ObserverType*)> method;
- };
-
- ~ObserverListThreadSafe() override = default;
-
- void NotifyWrapper(ObserverType* observer,
- const NotificationData& notification) {
- {
- AutoLock auto_lock(lock_);
-
- // Check whether the observer still needs a notification.
- auto it = observers_.find(observer);
- if (it == observers_.end())
- return;
- DCHECK(it->second->RunsTasksInCurrentSequence());
- }
-
- // Keep track of the notification being dispatched on the current thread.
- // This will be used if the callback below calls AddObserver().
- //
- // Note: |tls_current_notification_| may not be nullptr if this runs in a
- // nested loop started by a notification callback. In that case, it is
- // important to save the previous value to restore it later.
- auto& tls_current_notification = tls_current_notification_.Get();
- const NotificationDataBase* const previous_notification =
- tls_current_notification.Get();
- tls_current_notification.Set(¬ification);
-
- // Invoke the callback.
- notification.method.Run(observer);
-
- // Reset the notification being dispatched on the current thread to its
- // previous value.
- tls_current_notification.Set(previous_notification);
- }
-
- const ObserverListPolicy policy_ = ObserverListPolicy::ALL;
-
- // Synchronizes access to |observers_|.
- mutable Lock lock_;
-
- // Keys are observers. Values are the SequencedTaskRunners on which they must
- // be notified.
- std::unordered_map<ObserverType*, scoped_refptr<SequencedTaskRunner>>
- observers_;
-
- DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafe);
-};
-
-} // namespace base
-
-#endif // BASE_OBSERVER_LIST_THREADSAFE_H_
diff --git a/base/posix/unix_domain_socket.cc b/base/posix/unix_domain_socket.cc
deleted file mode 100644
index 17c8a24..0000000
--- a/base/posix/unix_domain_socket.cc
+++ /dev/null
@@ -1,288 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/posix/unix_domain_socket.h"
-
-#include <errno.h>
-#include <sys/socket.h>
-#if !defined(OS_NACL_NONSFI)
-#include <sys/un.h>
-#endif
-#include <unistd.h>
-
-#include <vector>
-
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/pickle.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/stl_util.h"
-#include "build_config.h"
-
-#if !defined(OS_NACL_NONSFI)
-#include <sys/uio.h>
-#endif
-
-namespace base {
-
-const size_t UnixDomainSocket::kMaxFileDescriptors = 16;
-
-#if !defined(OS_NACL_NONSFI)
-bool CreateSocketPair(ScopedFD* one, ScopedFD* two) {
- int raw_socks[2];
-#if defined(OS_MACOSX)
- // macOS does not support SEQPACKET.
- const int flags = SOCK_STREAM;
-#else
- const int flags = SOCK_SEQPACKET;
-#endif
- if (socketpair(AF_UNIX, flags, 0, raw_socks) == -1)
- return false;
-#if defined(OS_MACOSX)
- // On macOS, preventing SIGPIPE is done with socket option.
- const int no_sigpipe = 1;
- if (setsockopt(raw_socks[0], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe,
- sizeof(no_sigpipe)) != 0)
- return false;
- if (setsockopt(raw_socks[1], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe,
- sizeof(no_sigpipe)) != 0)
- return false;
-#endif
- one->reset(raw_socks[0]);
- two->reset(raw_socks[1]);
- return true;
-}
-
-// static
-bool UnixDomainSocket::EnableReceiveProcessId(int fd) {
-#if !defined(OS_MACOSX)
- const int enable = 1;
- return setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable)) == 0;
-#else
- // SO_PASSCRED is not supported on macOS.
- return true;
-#endif // OS_MACOSX
-}
-#endif // !defined(OS_NACL_NONSFI)
-
-// static
-bool UnixDomainSocket::SendMsg(int fd,
- const void* buf,
- size_t length,
- const std::vector<int>& fds) {
- struct msghdr msg = {};
- struct iovec iov = {const_cast<void*>(buf), length};
- msg.msg_iov = &iov;
- msg.msg_iovlen = 1;
-
- char* control_buffer = nullptr;
- if (fds.size()) {
- const unsigned control_len = CMSG_SPACE(sizeof(int) * fds.size());
- control_buffer = new char[control_len];
-
- struct cmsghdr* cmsg;
- msg.msg_control = control_buffer;
- msg.msg_controllen = control_len;
- cmsg = CMSG_FIRSTHDR(&msg);
- cmsg->cmsg_level = SOL_SOCKET;
- cmsg->cmsg_type = SCM_RIGHTS;
- cmsg->cmsg_len = CMSG_LEN(sizeof(int) * fds.size());
- memcpy(CMSG_DATA(cmsg), &fds[0], sizeof(int) * fds.size());
- msg.msg_controllen = cmsg->cmsg_len;
- }
-
-// Avoid a SIGPIPE if the other end breaks the connection.
-// Due to a bug in the Linux kernel (net/unix/af_unix.c) MSG_NOSIGNAL isn't
-// regarded for SOCK_SEQPACKET in the AF_UNIX domain, but it is mandated by
-// POSIX. On Mac MSG_NOSIGNAL is not supported, so we need to ensure that
-// SO_NOSIGPIPE is set during socket creation.
-#if defined(OS_MACOSX)
- const int flags = 0;
- int no_sigpipe = 0;
- socklen_t no_sigpipe_len = sizeof(no_sigpipe);
- DPCHECK(getsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe,
- &no_sigpipe_len) == 0)
- << "Failed ot get socket option.";
- DCHECK(no_sigpipe) << "SO_NOSIGPIPE not set on the socket.";
-#else
- const int flags = MSG_NOSIGNAL;
-#endif // OS_MACOSX
- const ssize_t r = HANDLE_EINTR(sendmsg(fd, &msg, flags));
- const bool ret = static_cast<ssize_t>(length) == r;
- delete[] control_buffer;
- return ret;
-}
-
-// static
-ssize_t UnixDomainSocket::RecvMsg(int fd,
- void* buf,
- size_t length,
- std::vector<ScopedFD>* fds) {
- return UnixDomainSocket::RecvMsgWithPid(fd, buf, length, fds, nullptr);
-}
-
-// static
-ssize_t UnixDomainSocket::RecvMsgWithPid(int fd,
- void* buf,
- size_t length,
- std::vector<ScopedFD>* fds,
- ProcessId* pid) {
- return UnixDomainSocket::RecvMsgWithFlags(fd, buf, length, 0, fds, pid);
-}
-
-// static
-ssize_t UnixDomainSocket::RecvMsgWithFlags(int fd,
- void* buf,
- size_t length,
- int flags,
- std::vector<ScopedFD>* fds,
- ProcessId* out_pid) {
- fds->clear();
-
- struct msghdr msg = {};
- struct iovec iov = {buf, length};
- msg.msg_iov = &iov;
- msg.msg_iovlen = 1;
-
- const size_t kControlBufferSize =
- CMSG_SPACE(sizeof(int) * kMaxFileDescriptors)
-#if !defined(OS_NACL_NONSFI) && !defined(OS_MACOSX)
- // The PNaCl toolchain for Non-SFI binary build and macOS do not support
- // ucred. macOS supports xucred, but this structure is insufficient.
- + CMSG_SPACE(sizeof(struct ucred))
-#endif // OS_NACL_NONSFI or OS_MACOSX
- ;
- char control_buffer[kControlBufferSize];
- msg.msg_control = control_buffer;
- msg.msg_controllen = sizeof(control_buffer);
-
- const ssize_t r = HANDLE_EINTR(recvmsg(fd, &msg, flags));
- if (r == -1)
- return -1;
-
- int* wire_fds = nullptr;
- unsigned wire_fds_len = 0;
- ProcessId pid = -1;
-
- if (msg.msg_controllen > 0) {
- struct cmsghdr* cmsg;
- for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
- const unsigned payload_len = cmsg->cmsg_len - CMSG_LEN(0);
- if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
- DCHECK_EQ(payload_len % sizeof(int), 0u);
- DCHECK_EQ(wire_fds, static_cast<void*>(nullptr));
- wire_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
- wire_fds_len = payload_len / sizeof(int);
- }
-#if !defined(OS_NACL_NONSFI) && !defined(OS_MACOSX)
- // The PNaCl toolchain for Non-SFI binary build and macOS do not support
- // SCM_CREDENTIALS.
- if (cmsg->cmsg_level == SOL_SOCKET &&
- cmsg->cmsg_type == SCM_CREDENTIALS) {
- DCHECK_EQ(payload_len, sizeof(struct ucred));
- DCHECK_EQ(pid, -1);
- pid = reinterpret_cast<struct ucred*>(CMSG_DATA(cmsg))->pid;
- }
-#endif // !defined(OS_NACL_NONSFI) && !defined(OS_MACOSX)
- }
- }
-
- if (msg.msg_flags & MSG_TRUNC || msg.msg_flags & MSG_CTRUNC) {
- if (msg.msg_flags & MSG_CTRUNC) {
- // Extraordinary case, not caller fixable. Log something.
- LOG(ERROR) << "recvmsg returned MSG_CTRUNC flag, buffer len is "
- << msg.msg_controllen;
- }
- for (unsigned i = 0; i < wire_fds_len; ++i)
- close(wire_fds[i]);
- errno = EMSGSIZE;
- return -1;
- }
-
- if (wire_fds) {
- for (unsigned i = 0; i < wire_fds_len; ++i)
- fds->push_back(ScopedFD(wire_fds[i])); // TODO(mdempsky): emplace_back
- }
-
- if (out_pid) {
-#if defined(OS_MACOSX)
- socklen_t pid_size = sizeof(pid);
- if (getsockopt(fd, SOL_LOCAL, LOCAL_PEERPID, &pid, &pid_size) != 0)
- pid = -1;
-#else
- // |pid| will legitimately be -1 if we read EOF, so only DCHECK if we
- // actually received a message. Unfortunately, Linux allows sending zero
- // length messages, which are indistinguishable from EOF, so this check
- // has false negatives.
- if (r > 0 || msg.msg_controllen > 0)
- DCHECK_GE(pid, 0);
-#endif
-
- *out_pid = pid;
- }
-
- return r;
-}
-
-#if !defined(OS_NACL_NONSFI)
-// static
-ssize_t UnixDomainSocket::SendRecvMsg(int fd,
- uint8_t* reply,
- unsigned max_reply_len,
- int* result_fd,
- const Pickle& request) {
- return UnixDomainSocket::SendRecvMsgWithFlags(fd, reply, max_reply_len,
- 0, /* recvmsg_flags */
- result_fd, request);
-}
-
-// static
-ssize_t UnixDomainSocket::SendRecvMsgWithFlags(int fd,
- uint8_t* reply,
- unsigned max_reply_len,
- int recvmsg_flags,
- int* result_fd,
- const Pickle& request) {
- // This socketpair is only used for the IPC and is cleaned up before
- // returning.
- ScopedFD recv_sock, send_sock;
- if (!CreateSocketPair(&recv_sock, &send_sock))
- return -1;
-
- {
- std::vector<int> send_fds;
- send_fds.push_back(send_sock.get());
- if (!SendMsg(fd, request.data(), request.size(), send_fds))
- return -1;
- }
-
- // Close the sending end of the socket right away so that if our peer closes
- // it before sending a response (e.g., from exiting), RecvMsgWithFlags() will
- // return EOF instead of hanging.
- send_sock.reset();
-
- std::vector<ScopedFD> recv_fds;
- // When porting to OSX keep in mind it doesn't support MSG_NOSIGNAL, so the
- // sender might get a SIGPIPE.
- const ssize_t reply_len = RecvMsgWithFlags(
- recv_sock.get(), reply, max_reply_len, recvmsg_flags, &recv_fds, nullptr);
- recv_sock.reset();
- if (reply_len == -1)
- return -1;
-
- // If we received more file descriptors than caller expected, then we treat
- // that as an error.
- if (recv_fds.size() > (result_fd != nullptr ? 1 : 0)) {
- NOTREACHED();
- return -1;
- }
-
- if (result_fd)
- *result_fd = recv_fds.empty() ? -1 : recv_fds[0].release();
-
- return reply_len;
-}
-#endif // !defined(OS_NACL_NONSFI)
-
-} // namespace base
diff --git a/base/posix/unix_domain_socket.h b/base/posix/unix_domain_socket.h
deleted file mode 100644
index 0bbd064..0000000
--- a/base/posix/unix_domain_socket.h
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_POSIX_UNIX_DOMAIN_SOCKET_H_
-#define BASE_POSIX_UNIX_DOMAIN_SOCKET_H_
-
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/types.h>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/files/scoped_file.h"
-#include "base/process/process_handle.h"
-#include "build_config.h"
-
-namespace base {
-
-class Pickle;
-
-#if !defined(OS_NACL_NONSFI)
-// Creates a connected pair of UNIX-domain SOCK_SEQPACKET sockets, and passes
-// ownership of the newly allocated file descriptors to |one| and |two|.
-// Returns true on success.
-bool BASE_EXPORT CreateSocketPair(ScopedFD* one, ScopedFD* two);
-#endif
-
-class BASE_EXPORT UnixDomainSocket {
- public:
- // Maximum number of file descriptors that can be read by RecvMsg().
- static const size_t kMaxFileDescriptors;
-
-#if !defined(OS_NACL_NONSFI)
- // Use to enable receiving process IDs in RecvMsgWithPid. Should be called on
- // the receiving socket (i.e., the socket passed to RecvMsgWithPid). Returns
- // true if successful.
- static bool EnableReceiveProcessId(int fd);
-#endif // !defined(OS_NACL_NONSFI)
-
- // Use sendmsg to write the given msg and include a vector of file
- // descriptors. Returns true if successful.
- static bool SendMsg(int fd,
- const void* msg,
- size_t length,
- const std::vector<int>& fds);
-
- // Use recvmsg to read a message and an array of file descriptors. Returns
- // -1 on failure. Note: will read, at most, |kMaxFileDescriptors| descriptors.
- static ssize_t RecvMsg(int fd,
- void* msg,
- size_t length,
- std::vector<ScopedFD>* fds);
-
- // Same as RecvMsg above, but also returns the sender's process ID (as seen
- // from the caller's namespace). However, before using this function to
- // receive process IDs, EnableReceiveProcessId() should be called on the
- // receiving socket.
- static ssize_t RecvMsgWithPid(int fd,
- void* msg,
- size_t length,
- std::vector<ScopedFD>* fds,
- ProcessId* pid);
-
-#if !defined(OS_NACL_NONSFI)
- // Perform a sendmsg/recvmsg pair.
- // 1. This process creates a UNIX SEQPACKET socketpair. Using
- // connection-oriented sockets (SEQPACKET or STREAM) is critical here,
- // because if one of the ends closes the other one must be notified.
- // 2. This process writes a request to |fd| with an SCM_RIGHTS control
- // message containing on end of the fresh socket pair.
- // 3. This process blocks reading from the other end of the fresh
- // socketpair.
- // 4. The target process receives the request, processes it and writes the
- // reply to the end of the socketpair contained in the request.
- // 5. This process wakes up and continues.
- //
- // fd: descriptor to send the request on
- // reply: buffer for the reply
- // reply_len: size of |reply|
- // result_fd: (may be NULL) the file descriptor returned in the reply
- // (if any)
- // request: the bytes to send in the request
- static ssize_t SendRecvMsg(int fd,
- uint8_t* reply,
- unsigned reply_len,
- int* result_fd,
- const Pickle& request);
-
- // Similar to SendRecvMsg(), but |recvmsg_flags| allows to control the flags
- // of the recvmsg(2) call.
- static ssize_t SendRecvMsgWithFlags(int fd,
- uint8_t* reply,
- unsigned reply_len,
- int recvmsg_flags,
- int* result_fd,
- const Pickle& request);
-#endif // !defined(OS_NACL_NONSFI)
- private:
- // Similar to RecvMsg, but allows to specify |flags| for recvmsg(2).
- static ssize_t RecvMsgWithFlags(int fd,
- void* msg,
- size_t length,
- int flags,
- std::vector<ScopedFD>* fds,
- ProcessId* pid);
-};
-
-} // namespace base
-
-#endif // BASE_POSIX_UNIX_DOMAIN_SOCKET_H_
diff --git a/base/post_task_and_reply_with_result_internal.h b/base/post_task_and_reply_with_result_internal.h
deleted file mode 100644
index 6f50de8..0000000
--- a/base/post_task_and_reply_with_result_internal.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_POST_TASK_AND_REPLY_WITH_RESULT_INTERNAL_H_
-#define BASE_POST_TASK_AND_REPLY_WITH_RESULT_INTERNAL_H_
-
-#include <utility>
-
-#include "base/callback.h"
-
-namespace base {
-
-namespace internal {
-
-// Adapts a function that produces a result via a return value to
-// one that returns via an output parameter.
-template <typename ReturnType>
-void ReturnAsParamAdapter(OnceCallback<ReturnType()> func, ReturnType* result) {
- *result = std::move(func).Run();
-}
-
-// Adapts a T* result to a callblack that expects a T.
-template <typename TaskReturnType, typename ReplyArgType>
-void ReplyAdapter(OnceCallback<void(ReplyArgType)> callback,
- TaskReturnType* result) {
- std::move(callback).Run(std::move(*result));
-}
-
-} // namespace internal
-
-} // namespace base
-
-#endif // BASE_POST_TASK_AND_REPLY_WITH_RESULT_INTERNAL_H_
diff --git a/base/process/port_provider_mac.cc b/base/process/port_provider_mac.cc
deleted file mode 100644
index 23d214c..0000000
--- a/base/process/port_provider_mac.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/port_provider_mac.h"
-
-namespace base {
-
-PortProvider::PortProvider() : lock_(), observer_list_() {}
-PortProvider::~PortProvider() {}
-
-void PortProvider::AddObserver(Observer* observer) {
- base::AutoLock l(lock_);
- observer_list_.AddObserver(observer);
-}
-
-void PortProvider::RemoveObserver(Observer* observer) {
- base::AutoLock l(lock_);
- observer_list_.RemoveObserver(observer);
-}
-
-void PortProvider::NotifyObservers(ProcessHandle process) {
- base::AutoLock l(lock_);
- for (auto& observer : observer_list_)
- observer.OnReceivedTaskPort(process);
-}
-
-} // namespace base
diff --git a/base/process/port_provider_mac.h b/base/process/port_provider_mac.h
deleted file mode 100644
index 2f40297..0000000
--- a/base/process/port_provider_mac.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PROCESS_PORT_PROVIDER_MAC_H_
-#define BASE_PROCESS_PORT_PROVIDER_MAC_H_
-
-#include <mach/mach.h>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/observer_list.h"
-#include "base/process/process_handle.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-// Abstract base class that provides a mapping from ProcessHandle (pid_t) to the
-// Mach task port. This replicates task_for_pid(), which requires root
-// privileges.
-class BASE_EXPORT PortProvider {
- public:
- PortProvider();
- virtual ~PortProvider();
-
- class Observer {
- public:
- virtual ~Observer() {};
- // Called by the PortProvider to notify observers that the task port was
- // received for a given process.
- // No guarantees are made about the thread on which this notification will
- // be sent.
- // Observers must not call AddObserver() or RemoveObserver() in this
- // callback, as doing so will deadlock.
- virtual void OnReceivedTaskPort(ProcessHandle process) = 0;
- };
-
- // Returns the mach task port for |process| if possible, or else
- // |MACH_PORT_NULL|.
- virtual mach_port_t TaskForPid(ProcessHandle process) const = 0;
-
- // Observer interface.
- void AddObserver(Observer* observer);
- void RemoveObserver(Observer* observer);
-
- protected:
- // Called by subclasses to send a notification to observers.
- void NotifyObservers(ProcessHandle process);
-
- private:
- // ObserverList is not thread-safe, so |lock_| ensures consistency of
- // |observer_list_|.
- base::Lock lock_;
- base::ObserverList<Observer> observer_list_;
-
- DISALLOW_COPY_AND_ASSIGN(PortProvider);
-};
-
-} // namespace base
-
-#endif // BASE_PROCESS_PORT_PROVIDER_MAC_H_
diff --git a/base/process/process.h b/base/process/process.h
index 2633355..dbfc701 100644
--- a/base/process/process.h
+++ b/base/process/process.h
@@ -15,10 +15,6 @@
#include "base/win/scoped_handle.h"
#endif
-#if defined(OS_MACOSX)
-#include "base/process/port_provider_mac.h"
-#endif
-
namespace base {
// Provides a move-only encapsulation of a process.
@@ -64,15 +60,6 @@
static Process OpenWithAccess(ProcessId pid, DWORD desired_access);
#endif
- // Creates an object from a |handle| owned by someone else.
- // Don't use this for new code. It is only intended to ease the migration to
- // a strict ownership model.
- // TODO(rvargas) crbug.com/417532: Remove this code.
- static Process DeprecatedGetProcessFromHandle(ProcessHandle handle);
-
- // Returns true if processes can be backgrounded.
- static bool CanBackgroundProcesses();
-
// Terminates the current process immediately with |exit_code|.
[[noreturn]] static void TerminateCurrentProcessImmediately(int exit_code);
@@ -132,38 +119,6 @@
// process though that should be avoided.
void Exited(int exit_code) const;
-#if defined(OS_MACOSX)
- // The Mac needs a Mach port in order to manipulate a process's priority,
- // and there's no good way to get that from base given the pid. These Mac
- // variants of the IsProcessBackgrounded and SetProcessBackgrounded API take
- // a port provider for this reason. See crbug.com/460102
- //
- // A process is backgrounded when its task priority is
- // |TASK_BACKGROUND_APPLICATION|.
- //
- // Returns true if the port_provider can locate a task port for the process
- // and it is backgrounded. If port_provider is null, returns false.
- bool IsProcessBackgrounded(PortProvider* port_provider) const;
-
- // Set the process as backgrounded. If value is
- // true, the priority of the associated task will be set to
- // TASK_BACKGROUND_APPLICATION. If value is false, the
- // priority of the process will be set to TASK_FOREGROUND_APPLICATION.
- //
- // Returns true if the priority was changed, false otherwise. If
- // |port_provider| is null, this is a no-op and it returns false.
- bool SetProcessBackgrounded(PortProvider* port_provider, bool value);
-#else
- // A process is backgrounded when it's priority is lower than normal.
- // Return true if this process is backgrounded, false otherwise.
- bool IsProcessBackgrounded() const;
-
- // Set a process as backgrounded. If value is true, the priority of the
- // process will be lowered. If value is false, the priority of the process
- // will be made "normal" - equivalent to default process priority.
- // Returns true if the priority was changed, false otherwise.
- bool SetProcessBackgrounded(bool value);
-#endif // defined(OS_MACOSX)
// Returns an integer representing the priority of a process. The meaning
// of this value is OS dependent.
int GetPriority() const;
diff --git a/base/process/process_linux.cc b/base/process/process_linux.cc
deleted file mode 100644
index 066c647..0000000
--- a/base/process/process_linux.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process.h"
-
-#include <errno.h>
-#include <sys/resource.h>
-
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/lock.h"
-#include "build_config.h"
-
-namespace base {
-
-namespace {
-
-const int kForegroundPriority = 0;
-
-const int kBackgroundPriority = 5;
-
-bool CanReraisePriority() {
- // We won't be able to raise the priority if we don't have the right rlimit.
- // The limit may be adjusted in /etc/security/limits.conf for PAM systems.
- struct rlimit rlim;
- return (getrlimit(RLIMIT_NICE, &rlim) == 0) &&
- (20 - kForegroundPriority) <= static_cast<int>(rlim.rlim_cur);
-}
-
-} // namespace
-
-// static
-bool Process::CanBackgroundProcesses() {
- static const bool can_reraise_priority = CanReraisePriority();
- return can_reraise_priority;
-}
-
-bool Process::IsProcessBackgrounded() const {
- DCHECK(IsValid());
-
- return GetPriority() == kBackgroundPriority;
-}
-
-bool Process::SetProcessBackgrounded(bool background) {
- DCHECK(IsValid());
-
- if (!CanBackgroundProcesses())
- return false;
-
- int priority = background ? kBackgroundPriority : kForegroundPriority;
- int result = setpriority(PRIO_PROCESS, process_, priority);
- DPCHECK(result == 0);
- return result == 0;
-}
-
-} // namespace base
diff --git a/base/process/process_mac.cc b/base/process/process_mac.cc
deleted file mode 100644
index cd47c62..0000000
--- a/base/process/process_mac.cc
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/process/process.h"
-
-#include <mach/mach.h>
-
-#include "base/mac/mach_logging.h"
-
-namespace base {
-
-bool Process::CanBackgroundProcesses() {
- return false;
-}
-
-bool Process::IsProcessBackgrounded(PortProvider* port_provider) const {
- DCHECK(IsValid());
- if (port_provider == nullptr || !CanBackgroundProcesses())
- return false;
-
- mach_port_t task_port = port_provider->TaskForPid(Pid());
- if (task_port == TASK_NULL)
- return false;
-
- task_category_policy_data_t category_policy;
- mach_msg_type_number_t task_info_count = TASK_CATEGORY_POLICY_COUNT;
- boolean_t get_default = FALSE;
-
- kern_return_t result =
- task_policy_get(task_port, TASK_CATEGORY_POLICY,
- reinterpret_cast<task_policy_t>(&category_policy),
- &task_info_count, &get_default);
- MACH_LOG_IF(ERROR, result != KERN_SUCCESS, result)
- << "task_policy_get TASK_CATEGORY_POLICY";
-
- if (result == KERN_SUCCESS && get_default == FALSE) {
- return category_policy.role == TASK_BACKGROUND_APPLICATION;
- }
- return false;
-}
-
-bool Process::SetProcessBackgrounded(PortProvider* port_provider,
- bool background) {
- DCHECK(IsValid());
- if (port_provider == nullptr || !CanBackgroundProcesses())
- return false;
-
- mach_port_t task_port = port_provider->TaskForPid(Pid());
- if (task_port == TASK_NULL)
- return false;
-
- if (IsProcessBackgrounded(port_provider) == background)
- return true;
-
- task_category_policy category_policy;
- category_policy.role =
- background ? TASK_BACKGROUND_APPLICATION : TASK_FOREGROUND_APPLICATION;
- kern_return_t result =
- task_policy_set(task_port, TASK_CATEGORY_POLICY,
- reinterpret_cast<task_policy_t>(&category_policy),
- TASK_CATEGORY_POLICY_COUNT);
-
- if (result != KERN_SUCCESS) {
- MACH_LOG(ERROR, result) << "task_policy_set TASK_CATEGORY_POLICY";
- return false;
- }
-
- return true;
-}
-
-} // namespace base
diff --git a/base/process/process_posix.cc b/base/process/process_posix.cc
index 57a4f67..3cc9182 100644
--- a/base/process/process_posix.cc
+++ b/base/process/process_posix.cc
@@ -258,19 +258,6 @@
}
// static
-Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle) {
- DCHECK_NE(handle, GetCurrentProcessHandle());
- return Process(handle);
-}
-
-#if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_AIX)
-// static
-bool Process::CanBackgroundProcesses() {
- return false;
-}
-#endif // !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_AIX)
-
-// static
void Process::TerminateCurrentProcessImmediately(int exit_code) {
_exit(exit_code);
}
@@ -346,22 +333,6 @@
void Process::Exited(int exit_code) const {}
-#if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_AIX)
-bool Process::IsProcessBackgrounded() const {
- // See SetProcessBackgrounded().
- DCHECK(IsValid());
- return false;
-}
-
-bool Process::SetProcessBackgrounded(bool value) {
- // Not implemented for POSIX systems other than Linux and Mac. With POSIX, if
- // we were to lower the process priority we wouldn't be able to raise it back
- // to its initial priority.
- NOTIMPLEMENTED();
- return false;
-}
-#endif // !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_AIX)
-
int Process::GetPriority() const {
DCHECK(IsValid());
return getpriority(PRIO_PROCESS, process_);
diff --git a/base/process/process_win.cc b/base/process/process_win.cc
index 48f598f..f5bd59e 100644
--- a/base/process/process_win.cc
+++ b/base/process/process_win.cc
@@ -65,23 +65,6 @@
}
// static
-Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle) {
- DCHECK_NE(handle, ::GetCurrentProcess());
- ProcessHandle out_handle;
- if (!::DuplicateHandle(GetCurrentProcess(), handle,
- GetCurrentProcess(), &out_handle,
- 0, FALSE, DUPLICATE_SAME_ACCESS)) {
- return Process();
- }
- return Process(out_handle);
-}
-
-// static
-bool Process::CanBackgroundProcesses() {
- return true;
-}
-
-// static
void Process::TerminateCurrentProcessImmediately(int exit_code) {
::TerminateProcess(GetCurrentProcess(), exit_code);
// There is some ambiguity over whether the call above can return. Rather than
@@ -182,31 +165,6 @@
void Process::Exited(int exit_code) const {
}
-bool Process::IsProcessBackgrounded() const {
- DCHECK(IsValid());
- DWORD priority = GetPriority();
- if (priority == 0)
- return false; // Failure case.
- return ((priority == BELOW_NORMAL_PRIORITY_CLASS) ||
- (priority == IDLE_PRIORITY_CLASS));
-}
-
-bool Process::SetProcessBackgrounded(bool value) {
- DCHECK(IsValid());
- // Vista and above introduce a real background mode, which not only
- // sets the priority class on the threads but also on the IO generated
- // by it. Unfortunately it can only be set for the calling process.
- DWORD priority;
- if (is_current()) {
- priority = value ? PROCESS_MODE_BACKGROUND_BEGIN :
- PROCESS_MODE_BACKGROUND_END;
- } else {
- priority = value ? IDLE_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS;
- }
-
- return (::SetPriorityClass(Handle(), priority) != 0);
-}
-
int Process::GetPriority() const {
DCHECK(IsValid());
return ::GetPriorityClass(Handle());
diff --git a/base/rand_util.cc b/base/rand_util.cc
deleted file mode 100644
index 5881ef2..0000000
--- a/base/rand_util.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/rand_util.h"
-
-#include <limits.h>
-#include <math.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <limits>
-
-#include "base/logging.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-
-uint64_t RandUint64() {
- uint64_t number;
- RandBytes(&number, sizeof(number));
- return number;
-}
-
-int RandInt(int min, int max) {
- DCHECK_LE(min, max);
-
- uint64_t range = static_cast<uint64_t>(max) - min + 1;
- // |range| is at most UINT_MAX + 1, so the result of RandGenerator(range)
- // is at most UINT_MAX. Hence it's safe to cast it from uint64_t to int64_t.
- int result =
- static_cast<int>(min + static_cast<int64_t>(base::RandGenerator(range)));
- DCHECK_GE(result, min);
- DCHECK_LE(result, max);
- return result;
-}
-
-double RandDouble() {
- return BitsToOpenEndedUnitInterval(base::RandUint64());
-}
-
-double BitsToOpenEndedUnitInterval(uint64_t bits) {
- // We try to get maximum precision by masking out as many bits as will fit
- // in the target type's mantissa, and raising it to an appropriate power to
- // produce output in the range [0, 1). For IEEE 754 doubles, the mantissa
- // is expected to accommodate 53 bits.
-
- static_assert(std::numeric_limits<double>::radix == 2,
- "otherwise use scalbn");
- static const int kBits = std::numeric_limits<double>::digits;
- uint64_t random_bits = bits & ((UINT64_C(1) << kBits) - 1);
- double result = ldexp(static_cast<double>(random_bits), -1 * kBits);
- DCHECK_GE(result, 0.0);
- DCHECK_LT(result, 1.0);
- return result;
-}
-
-uint64_t RandGenerator(uint64_t range) {
- DCHECK_GT(range, 0u);
- // We must discard random results above this number, as they would
- // make the random generator non-uniform (consider e.g. if
- // MAX_UINT64 was 7 and |range| was 5, then a result of 1 would be twice
- // as likely as a result of 3 or 4).
- uint64_t max_acceptable_value =
- (std::numeric_limits<uint64_t>::max() / range) * range - 1;
-
- uint64_t value;
- do {
- value = base::RandUint64();
- } while (value > max_acceptable_value);
-
- return value % range;
-}
-
-std::string RandBytesAsString(size_t length) {
- DCHECK_GT(length, 0u);
- std::string result;
- RandBytes(WriteInto(&result, length + 1), length);
- return result;
-}
-
-} // namespace base
diff --git a/base/rand_util.h b/base/rand_util.h
deleted file mode 100644
index 32c8fc7..0000000
--- a/base/rand_util.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_RAND_UTIL_H_
-#define BASE_RAND_UTIL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <string>
-
-#include "base/base_export.h"
-#include "build_config.h"
-
-namespace base {
-
-// Returns a random number in range [0, UINT64_MAX]. Thread-safe.
-BASE_EXPORT uint64_t RandUint64();
-
-// Returns a random number between min and max (inclusive). Thread-safe.
-BASE_EXPORT int RandInt(int min, int max);
-
-// Returns a random number in range [0, range). Thread-safe.
-BASE_EXPORT uint64_t RandGenerator(uint64_t range);
-
-// Returns a random double in range [0, 1). Thread-safe.
-BASE_EXPORT double RandDouble();
-
-// Given input |bits|, convert with maximum precision to a double in
-// the range [0, 1). Thread-safe.
-BASE_EXPORT double BitsToOpenEndedUnitInterval(uint64_t bits);
-
-// Fills |output_length| bytes of |output| with random data. Thread-safe.
-//
-// Although implementations are required to use a cryptographically secure
-// random number source, code outside of base/ that relies on this should use
-// crypto::RandBytes instead to ensure the requirement is easily discoverable.
-BASE_EXPORT void RandBytes(void* output, size_t output_length);
-
-// Fills a string of length |length| with random data and returns it.
-// |length| should be nonzero. Thread-safe.
-//
-// Note that this is a variation of |RandBytes| with a different return type.
-// The returned string is likely not ASCII/UTF-8. Use with care.
-//
-// Although implementations are required to use a cryptographically secure
-// random number source, code outside of base/ that relies on this should use
-// crypto::RandBytes instead to ensure the requirement is easily discoverable.
-BASE_EXPORT std::string RandBytesAsString(size_t length);
-
-// An STL UniformRandomBitGenerator backed by RandUint64.
-// TODO(tzik): Consider replacing this with a faster implementation.
-class RandomBitGenerator {
- public:
- using result_type = uint64_t;
- static constexpr result_type min() { return 0; }
- static constexpr result_type max() { return UINT64_MAX; }
- result_type operator()() const { return RandUint64(); }
-
- RandomBitGenerator() = default;
- ~RandomBitGenerator() = default;
-};
-
-// Shuffles [first, last) randomly. Thread-safe.
-template <typename Itr>
-void RandomShuffle(Itr first, Itr last) {
- std::shuffle(first, last, RandomBitGenerator());
-}
-
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
-BASE_EXPORT int GetUrandomFD();
-#endif
-
-} // namespace base
-
-#endif // BASE_RAND_UTIL_H_
diff --git a/base/rand_util_nacl.cc b/base/rand_util_nacl.cc
deleted file mode 100644
index b26b408..0000000
--- a/base/rand_util_nacl.cc
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/rand_util.h"
-
-#include <nacl/nacl_random.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/logging.h"
-
-namespace base {
-
-void RandBytes(void* output, size_t output_length) {
- char* output_ptr = static_cast<char*>(output);
- while (output_length > 0) {
- size_t nread;
- const int error = nacl_secure_random(output_ptr, output_length, &nread);
- CHECK_EQ(error, 0);
- CHECK_LE(nread, output_length);
- output_ptr += nread;
- output_length -= nread;
- }
-}
-
-} // namespace base
diff --git a/base/rand_util_posix.cc b/base/rand_util_posix.cc
deleted file mode 100644
index 13ecaf5..0000000
--- a/base/rand_util_posix.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/rand_util.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <unistd.h>
-
-#include "base/files/file_util.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_(HANDLE_EINTR(open("/dev/urandom", O_RDONLY | O_CLOEXEC))) {
- DCHECK_GE(fd_, 0) << "Cannot open /dev/urandom: " << errno;
- }
-
- ~URandomFd() { close(fd_); }
-
- int fd() const { return fd_; }
-
- private:
- const int fd_;
-};
-
-URandomFd* GetInstance() {
- static URandomFd* instance = new URandomFd;
- return instance;
-}
-
-} // namespace
-
-namespace base {
-
-void RandBytes(void* output, size_t output_length) {
- const int urandom_fd = GetInstance()->fd();
- const bool success =
- ReadFromFD(urandom_fd, static_cast<char*>(output), output_length);
- CHECK(success);
-}
-
-int GetUrandomFD(void) {
- return GetInstance()->fd();
-}
-
-} // namespace base
diff --git a/base/rand_util_win.cc b/base/rand_util_win.cc
deleted file mode 100644
index e85c216..0000000
--- a/base/rand_util_win.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/rand_util.h"
-
-#include <windows.h>
-#include <stddef.h>
-#include <stdint.h>
-
-// #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036. See the
-// "Community Additions" comment on MSDN here:
-// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx
-#define SystemFunction036 NTAPI SystemFunction036
-#include <NTSecAPI.h>
-#undef SystemFunction036
-
-#include <algorithm>
-#include <limits>
-
-#include "base/logging.h"
-
-namespace base {
-
-void RandBytes(void* output, size_t output_length) {
- char* output_ptr = static_cast<char*>(output);
- while (output_length > 0) {
- const ULONG output_bytes_this_pass = static_cast<ULONG>(std::min(
- output_length, static_cast<size_t>(std::numeric_limits<ULONG>::max())));
- const bool success =
- RtlGenRandom(output_ptr, output_bytes_this_pass) != FALSE;
- CHECK(success);
- output_length -= output_bytes_this_pass;
- output_ptr += output_bytes_this_pass;
- }
-}
-
-} // namespace base
diff --git a/base/scoped_observer.h b/base/scoped_observer.h
deleted file mode 100644
index 7f1d6fb..0000000
--- a/base/scoped_observer.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SCOPED_OBSERVER_H_
-#define BASE_SCOPED_OBSERVER_H_
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/stl_util.h"
-
-// ScopedObserver is used to keep track of the set of sources an object has
-// attached itself to as an observer. When ScopedObserver is destroyed it
-// removes the object as an observer from all sources it has been added to.
-template <class Source, class Observer>
-class ScopedObserver {
- public:
- explicit ScopedObserver(Observer* observer) : observer_(observer) {}
-
- ~ScopedObserver() {
- RemoveAll();
- }
-
- // Adds the object passed to the constructor as an observer on |source|.
- void Add(Source* source) {
- sources_.push_back(source);
- source->AddObserver(observer_);
- }
-
- // Remove the object passed to the constructor as an observer from |source|.
- void Remove(Source* source) {
- auto it = std::find(sources_.begin(), sources_.end(), source);
- DCHECK(it != sources_.end());
- sources_.erase(it);
- source->RemoveObserver(observer_);
- }
-
- void RemoveAll() {
- for (size_t i = 0; i < sources_.size(); ++i)
- sources_[i]->RemoveObserver(observer_);
- sources_.clear();
- }
-
- bool IsObserving(Source* source) const {
- return base::ContainsValue(sources_, source);
- }
-
- bool IsObservingSources() const { return !sources_.empty(); }
-
- private:
- Observer* observer_;
-
- std::vector<Source*> sources_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedObserver);
-};
-
-#endif // BASE_SCOPED_OBSERVER_H_
diff --git a/base/strings/OWNERS b/base/strings/OWNERS
deleted file mode 100644
index 5381872..0000000
--- a/base/strings/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-per-file safe_sprintf*=jln@chromium.org
-per-file safe_sprintf*=mdempsky@chromium.org
diff --git a/base/strings/latin1_string_conversions.cc b/base/strings/latin1_string_conversions.cc
deleted file mode 100644
index dca62ce..0000000
--- a/base/strings/latin1_string_conversions.cc
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/latin1_string_conversions.h"
-
-namespace base {
-
-string16 Latin1OrUTF16ToUTF16(size_t length,
- const Latin1Char* latin1,
- const char16* utf16) {
- if (!length)
- return string16();
- if (latin1)
- return string16(latin1, latin1 + length);
- return string16(utf16, utf16 + length);
-}
-
-} // namespace base
diff --git a/base/strings/latin1_string_conversions.h b/base/strings/latin1_string_conversions.h
deleted file mode 100644
index 42113ef..0000000
--- a/base/strings/latin1_string_conversions.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_LATIN1_STRING_CONVERSIONS_H_
-#define BASE_STRINGS_LATIN1_STRING_CONVERSIONS_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-
-namespace base {
-
-// This definition of Latin1Char matches the definition of LChar in Blink. We
-// use unsigned char rather than char to make less tempting to mix and match
-// Latin-1 and UTF-8 characters..
-typedef unsigned char Latin1Char;
-
-// This somewhat odd function is designed to help us convert from Blink Strings
-// to string16. A Blink string is either backed by an array of Latin-1
-// characters or an array of UTF-16 characters. This function is called by
-// WebString::operator string16() to convert one or the other character array
-// to string16. This function is defined here rather than in WebString.h to
-// avoid binary bloat in all the callers of the conversion operator.
-BASE_EXPORT string16 Latin1OrUTF16ToUTF16(size_t length,
- const Latin1Char* latin1,
- const char16* utf16);
-
-} // namespace base
-
-#endif // BASE_STRINGS_LATIN1_STRING_CONVERSIONS_H_
diff --git a/base/strings/nullable_string16.cc b/base/strings/nullable_string16.cc
deleted file mode 100644
index 076b282..0000000
--- a/base/strings/nullable_string16.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/nullable_string16.h"
-
-#include <ostream>
-#include <utility>
-
-namespace base {
-NullableString16::NullableString16() = default;
-NullableString16::NullableString16(const NullableString16& other) = default;
-NullableString16::NullableString16(NullableString16&& other) = default;
-
-NullableString16::NullableString16(const string16& string, bool is_null) {
- if (!is_null)
- string_.emplace(string);
-}
-
-NullableString16::NullableString16(Optional<string16> optional_string16)
- : string_(std::move(optional_string16)) {}
-
-NullableString16::~NullableString16() = default;
-NullableString16& NullableString16::operator=(const NullableString16& other) =
- default;
-NullableString16& NullableString16::operator=(NullableString16&& other) =
- default;
-
-std::ostream& operator<<(std::ostream& out, const NullableString16& value) {
- return value.is_null() ? out << "(null)" : out << value.string();
-}
-
-} // namespace base
diff --git a/base/strings/nullable_string16.h b/base/strings/nullable_string16.h
deleted file mode 100644
index abddee0..0000000
--- a/base/strings/nullable_string16.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_NULLABLE_STRING16_H_
-#define BASE_STRINGS_NULLABLE_STRING16_H_
-
-#include <iosfwd>
-
-#include "base/base_export.h"
-#include "base/optional.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-
-// This class is a simple wrapper for string16 which also contains a null
-// state. This should be used only where the difference between null and
-// empty is meaningful.
-class BASE_EXPORT NullableString16 {
- public:
- NullableString16();
- NullableString16(const NullableString16& other);
- NullableString16(NullableString16&& other);
- NullableString16(const string16& string, bool is_null);
- explicit NullableString16(Optional<string16> optional_string16);
- ~NullableString16();
-
- NullableString16& operator=(const NullableString16& other);
- NullableString16& operator=(NullableString16&& other);
-
- const string16& string() const {
- return string_ ? *string_ : EmptyString16();
- }
- bool is_null() const { return !string_; }
- const Optional<string16>& as_optional_string16() const { return string_; }
-
- private:
- Optional<string16> string_;
-};
-
-inline bool operator==(const NullableString16& a, const NullableString16& b) {
- return a.as_optional_string16() == b.as_optional_string16();
-}
-
-inline bool operator!=(const NullableString16& a, const NullableString16& b) {
- return !(a == b);
-}
-
-BASE_EXPORT std::ostream& operator<<(std::ostream& out,
- const NullableString16& value);
-
-} // namespace base
-
-#endif // BASE_STRINGS_NULLABLE_STRING16_H_
diff --git a/base/strings/old_utf_string_conversions.cc b/base/strings/old_utf_string_conversions.cc
deleted file mode 100644
index b6edb29..0000000
--- a/base/strings/old_utf_string_conversions.cc
+++ /dev/null
@@ -1,262 +0,0 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/old_utf_string_conversions.h"
-
-#include <stdint.h>
-
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversion_utils.h"
-#include "build_config.h"
-
-namespace base_old {
-
-using base::IsStringASCII;
-using base::ReadUnicodeCharacter;
-using base::WriteUnicodeCharacter;
-
-template<typename CHAR>
-void PrepareForUTF8Output(const CHAR* src,
- size_t src_len,
- std::string* output) {
- output->clear();
- if (src_len == 0)
- return;
- if (src[0] < 0x80) {
- // Assume that the entire input will be ASCII.
- output->reserve(src_len);
- } else {
- // Assume that the entire input is non-ASCII and will have 3 bytes per char.
- output->reserve(src_len * 3);
- }
-}
-
-template<typename STRING>
-void PrepareForUTF16Or32Output(const char* src,
- size_t src_len,
- STRING* output) {
- output->clear();
- if (src_len == 0)
- return;
- if (static_cast<unsigned char>(src[0]) < 0x80) {
- // Assume the input is all ASCII, which means 1:1 correspondence.
- output->reserve(src_len);
- } else {
- // Otherwise assume that the UTF-8 sequences will have 2 bytes for each
- // character.
- output->reserve(src_len / 2);
- }
-}
-
-namespace {
-
-// Generalized Unicode converter -----------------------------------------------
-
-// Converts the given source Unicode character type to the given destination
-// Unicode character type as a STL string. The given input buffer and size
-// determine the source, and the given output STL string will be replaced by
-// the result.
-template <typename SRC_CHAR, typename DEST_STRING>
-bool ConvertUnicode(const SRC_CHAR* src, size_t src_len, DEST_STRING* output) {
- // ICU requires 32-bit numbers.
- bool success = true;
- int32_t src_len32 = static_cast<int32_t>(src_len);
- for (int32_t i = 0; i < src_len32; i++) {
- uint32_t code_point;
- if (ReadUnicodeCharacter(src, src_len32, &i, &code_point)) {
- WriteUnicodeCharacter(code_point, output);
- } else {
- WriteUnicodeCharacter(0xFFFD, output);
- success = false;
- }
- }
-
- return success;
-}
-
-} // namespace
-
-// UTF-8 <-> Wide --------------------------------------------------------------
-
-bool WideToUTF8(const wchar_t* src, size_t src_len, std::string* output) {
- if (IsStringASCII(std::wstring(src, src_len))) {
- output->assign(src, src + src_len);
- return true;
- } else {
- PrepareForUTF8Output(src, src_len, output);
- return ConvertUnicode(src, src_len, output);
- }
-}
-
-std::string WideToUTF8(const std::wstring& wide) {
- if (IsStringASCII(wide)) {
- return std::string(wide.data(), wide.data() + wide.length());
- }
-
- std::string ret;
- PrepareForUTF8Output(wide.data(), wide.length(), &ret);
- ConvertUnicode(wide.data(), wide.length(), &ret);
- return ret;
-}
-
-bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output) {
- if (IsStringASCII(StringPiece(src, src_len))) {
- output->assign(src, src + src_len);
- return true;
- } else {
- PrepareForUTF16Or32Output(src, src_len, output);
- return ConvertUnicode(src, src_len, output);
- }
-}
-
-std::wstring UTF8ToWide(StringPiece utf8) {
- if (IsStringASCII(utf8)) {
- return std::wstring(utf8.begin(), utf8.end());
- }
-
- std::wstring ret;
- PrepareForUTF16Or32Output(utf8.data(), utf8.length(), &ret);
- ConvertUnicode(utf8.data(), utf8.length(), &ret);
- return ret;
-}
-
-// UTF-16 <-> Wide -------------------------------------------------------------
-
-#if defined(WCHAR_T_IS_UTF16)
-
-// When wide == UTF-16, then conversions are a NOP.
-bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output) {
- output->assign(src, src_len);
- return true;
-}
-
-string16 WideToUTF16(const std::wstring& wide) {
- return wide;
-}
-
-bool UTF16ToWide(const char16* src, size_t src_len, std::wstring* output) {
- output->assign(src, src_len);
- return true;
-}
-
-std::wstring UTF16ToWide(const string16& utf16) {
- return utf16;
-}
-
-#elif defined(WCHAR_T_IS_UTF32)
-
-bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output) {
- output->clear();
- // Assume that normally we won't have any non-BMP characters so the counts
- // will be the same.
- output->reserve(src_len);
- return ConvertUnicode(src, src_len, output);
-}
-
-string16 WideToUTF16(const std::wstring& wide) {
- string16 ret;
- WideToUTF16(wide.data(), wide.length(), &ret);
- return ret;
-}
-
-bool UTF16ToWide(const char16* src, size_t src_len, std::wstring* output) {
- output->clear();
- // Assume that normally we won't have any non-BMP characters so the counts
- // will be the same.
- output->reserve(src_len);
- return ConvertUnicode(src, src_len, output);
-}
-
-std::wstring UTF16ToWide(const string16& utf16) {
- std::wstring ret;
- UTF16ToWide(utf16.data(), utf16.length(), &ret);
- return ret;
-}
-
-#endif // defined(WCHAR_T_IS_UTF32)
-
-// UTF16 <-> UTF8 --------------------------------------------------------------
-
-#if defined(WCHAR_T_IS_UTF32)
-
-bool UTF8ToUTF16(const char* src, size_t src_len, string16* output) {
- if (IsStringASCII(StringPiece(src, src_len))) {
- output->assign(src, src + src_len);
- return true;
- } else {
- PrepareForUTF16Or32Output(src, src_len, output);
- return ConvertUnicode(src, src_len, output);
- }
-}
-
-string16 UTF8ToUTF16(StringPiece utf8) {
- if (IsStringASCII(utf8)) {
- return string16(utf8.begin(), utf8.end());
- }
-
- string16 ret;
- PrepareForUTF16Or32Output(utf8.data(), utf8.length(), &ret);
- // Ignore the success flag of this call, it will do the best it can for
- // invalid input, which is what we want here.
- ConvertUnicode(utf8.data(), utf8.length(), &ret);
- return ret;
-}
-
-bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output) {
- if (IsStringASCII(StringPiece16(src, src_len))) {
- output->assign(src, src + src_len);
- return true;
- } else {
- PrepareForUTF8Output(src, src_len, output);
- return ConvertUnicode(src, src_len, output);
- }
-}
-
-std::string UTF16ToUTF8(StringPiece16 utf16) {
- std::string ret;
- // Ignore the success flag of this call, it will do the best it can for
- // invalid input, which is what we want here.
- UTF16ToUTF8(utf16.data(), utf16.length(), &ret);
- return ret;
-}
-
-#elif defined(WCHAR_T_IS_UTF16)
-// Easy case since we can use the "wide" versions we already wrote above.
-
-bool UTF8ToUTF16(const char* src, size_t src_len, string16* output) {
- return UTF8ToWide(src, src_len, output);
-}
-
-string16 UTF8ToUTF16(StringPiece utf8) {
- return UTF8ToWide(utf8);
-}
-
-bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output) {
- return WideToUTF8(src, src_len, output);
-}
-
-std::string UTF16ToUTF8(StringPiece16 utf16) {
- if (IsStringASCII(utf16))
- return std::string(utf16.data(), utf16.data() + utf16.length());
-
- std::string ret;
- PrepareForUTF8Output(utf16.data(), utf16.length(), &ret);
- ConvertUnicode(utf16.data(), utf16.length(), &ret);
- return ret;
-}
-
-#endif
-
-string16 ASCIIToUTF16(StringPiece ascii) {
- DCHECK(IsStringASCII(ascii)) << ascii;
- return string16(ascii.begin(), ascii.end());
-}
-
-std::string UTF16ToASCII(StringPiece16 utf16) {
- DCHECK(IsStringASCII(utf16)) << UTF16ToUTF8(utf16);
- return std::string(utf16.begin(), utf16.end());
-}
-
-} // namespace base_old
diff --git a/base/strings/old_utf_string_conversions.h b/base/strings/old_utf_string_conversions.h
deleted file mode 100644
index 2f0c6c5..0000000
--- a/base/strings/old_utf_string_conversions.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_OLD_UTF_STRING_CONVERSIONS_H_
-#define BASE_STRINGS_OLD_UTF_STRING_CONVERSIONS_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-
-namespace base_old {
-
-using base::char16;
-using base::string16;
-using base::StringPiece16;
-using base::StringPiece;
-
-// These convert between UTF-8, -16, and -32 strings. They are potentially slow,
-// so avoid unnecessary conversions. The low-level versions return a boolean
-// indicating whether the conversion was 100% valid. In this case, it will still
-// do the best it can and put the result in the output buffer. The versions that
-// return strings ignore this error and just return the best conversion
-// possible.
-BASE_EXPORT bool WideToUTF8(const wchar_t* src,
- size_t src_len,
- std::string* output);
-BASE_EXPORT std::string WideToUTF8(const std::wstring& wide);
-BASE_EXPORT bool UTF8ToWide(const char* src,
- size_t src_len,
- std::wstring* output);
-BASE_EXPORT std::wstring UTF8ToWide(StringPiece utf8);
-
-BASE_EXPORT bool WideToUTF16(const wchar_t* src,
- size_t src_len,
- string16* output);
-BASE_EXPORT string16 WideToUTF16(const std::wstring& wide);
-BASE_EXPORT bool UTF16ToWide(const char16* src,
- size_t src_len,
- std::wstring* output);
-BASE_EXPORT std::wstring UTF16ToWide(const string16& utf16);
-
-BASE_EXPORT bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
-BASE_EXPORT string16 UTF8ToUTF16(StringPiece utf8);
-BASE_EXPORT bool UTF16ToUTF8(const char16* src,
- size_t src_len,
- std::string* output);
-BASE_EXPORT std::string UTF16ToUTF8(StringPiece16 utf16);
-
-// This converts an ASCII string, typically a hardcoded constant, to a UTF16
-// string.
-BASE_EXPORT string16 ASCIIToUTF16(StringPiece ascii);
-
-// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII
-// beforehand.
-BASE_EXPORT std::string UTF16ToASCII(StringPiece16 utf16);
-
-} // namespace base_old
-
-#endif // BASE_STRINGS_OLD_UTF_STRING_CONVERSIONS_H_
diff --git a/base/strings/pattern.cc b/base/strings/pattern.cc
deleted file mode 100644
index f3de0af..0000000
--- a/base/strings/pattern.cc
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/pattern.h"
-
-#include "base/third_party/icu/icu_utf.h"
-
-namespace base {
-
-namespace {
-
-constexpr bool IsWildcard(base_icu::UChar32 character) {
- return character == '*' || character == '?';
-}
-
-// Searches for the next subpattern of |pattern| in |string|, up to the given
-// |maximum_distance|. The subpattern extends from the start of |pattern| up to
-// the first wildcard character (or the end of the string). If the value of
-// |maximum_distance| is negative, the maximum distance is considered infinite.
-template <typename CHAR, typename NEXT>
-constexpr bool SearchForChars(const CHAR** pattern,
- const CHAR* pattern_end,
- const CHAR** string,
- const CHAR* string_end,
- int maximum_distance,
- NEXT next) {
- const CHAR* pattern_start = *pattern;
- const CHAR* string_start = *string;
- bool escape = false;
- while (true) {
- if (*pattern == pattern_end) {
- // If this is the end of the pattern, only accept the end of the string;
- // anything else falls through to the mismatch case.
- if (*string == string_end)
- return true;
- } else {
- // If we have found a wildcard, we're done.
- if (!escape && IsWildcard(**pattern))
- return true;
-
- // Check if the escape character is found. If so, skip it and move to the
- // next character.
- if (!escape && **pattern == '\\') {
- escape = true;
- next(pattern, pattern_end);
- continue;
- }
-
- escape = false;
-
- if (*string == string_end)
- return false;
-
- // 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;
- continue;
- }
- }
-
- // Mismatch. If we have reached the maximum distance, return false,
- // otherwise restart at the beginning of the pattern with the next character
- // in the string.
- // TODO(bauerb): This is a naive implementation of substring search, which
- // could be implemented with a more efficient algorithm, e.g.
- // Knuth-Morris-Pratt (at the expense of requiring preprocessing).
- if (maximum_distance == 0)
- return false;
-
- // Because unlimited distance is represented as -1, this will never reach 0
- // and therefore fail the match above.
- maximum_distance--;
- *pattern = pattern_start;
- next(&string_start, string_end);
- *string = string_start;
- }
-}
-
-// Consumes consecutive wildcard characters (? or *). Returns the maximum number
-// of characters matched by the sequence of wildcards, or -1 if the wildcards
-// match an arbitrary number of characters (which is the case if it contains at
-// least one *).
-template <typename CHAR, typename NEXT>
-constexpr int EatWildcards(const CHAR** pattern, const CHAR* end, NEXT next) {
- int num_question_marks = 0;
- bool has_asterisk = false;
- while (*pattern != end) {
- if (**pattern == '?') {
- num_question_marks++;
- } else if (**pattern == '*') {
- has_asterisk = true;
- } else {
- break;
- }
-
- next(pattern, end);
- }
- return has_asterisk ? -1 : num_question_marks;
-}
-
-template <typename CHAR, typename NEXT>
-constexpr bool MatchPatternT(const CHAR* eval,
- const CHAR* eval_end,
- const CHAR* pattern,
- const CHAR* pattern_end,
- NEXT next) {
- do {
- int maximum_wildcard_length = EatWildcards(&pattern, pattern_end, next);
- if (!SearchForChars(&pattern, pattern_end, &eval, eval_end,
- maximum_wildcard_length, next)) {
- return false;
- }
- } while (pattern != pattern_end);
- return true;
-}
-
-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;
- }
-};
-
-} // namespace
-
-bool MatchPattern(StringPiece eval, StringPiece pattern) {
- return MatchPatternT(eval.data(), eval.data() + eval.size(), pattern.data(),
- pattern.data() + pattern.size(), NextCharUTF8());
-}
-
-bool MatchPattern(StringPiece16 eval, StringPiece16 pattern) {
- return MatchPatternT(eval.data(), eval.data() + eval.size(), pattern.data(),
- pattern.data() + pattern.size(), NextCharUTF16());
-}
-
-} // namespace base
diff --git a/base/strings/pattern.h b/base/strings/pattern.h
deleted file mode 100644
index b5172ab..0000000
--- a/base/strings/pattern.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_PATTERN_H_
-#define BASE_STRINGS_PATTERN_H_
-
-#include "base/base_export.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-
-// 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 ?.
-// ? matches 0 or 1 character, while * matches 0 or more characters.
-BASE_EXPORT bool MatchPattern(StringPiece string, StringPiece pattern);
-BASE_EXPORT bool MatchPattern(StringPiece16 string, StringPiece16 pattern);
-
-} // namespace base
-
-#endif // BASE_STRINGS_PATTERN_H_
diff --git a/base/strings/safe_sprintf.cc b/base/strings/safe_sprintf.cc
deleted file mode 100644
index 8c6e8ca..0000000
--- a/base/strings/safe_sprintf.cc
+++ /dev/null
@@ -1,686 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/safe_sprintf.h"
-
-#include <errno.h>
-#include <string.h>
-
-#include <limits>
-
-#include "base/macros.h"
-#include "build_config.h"
-
-#if !defined(NDEBUG)
-// In debug builds, we use RAW_CHECK() to print useful error messages, if
-// SafeSPrintf() is called with broken arguments.
-// As our contract promises that SafeSPrintf() can be called from any
-// restricted run-time context, it is not actually safe to call logging
-// functions from it; and we only ever do so for debug builds and hope for the
-// best. We should _never_ call any logging function other than RAW_CHECK(),
-// and we should _never_ include any logging code that is active in production
-// builds. Most notably, we should not include these logging functions in
-// unofficial release builds, even though those builds would otherwise have
-// DCHECKS() enabled.
-// In other words; please do not remove the #ifdef around this #include.
-// Instead, in production builds we opt for returning a degraded result,
-// whenever an error is encountered.
-// E.g. The broken function call
-// SafeSPrintf("errno = %d (%x)", errno, strerror(errno))
-// will print something like
-// errno = 13, (%x)
-// instead of
-// errno = 13 (Access denied)
-// In most of the anticipated use cases, that's probably the preferred
-// behavior.
-#include "base/logging.h"
-#define DEBUG_CHECK RAW_CHECK
-#else
-#define DEBUG_CHECK(x) do { if (x) { } } while (0)
-#endif
-
-namespace base {
-namespace strings {
-
-// The code in this file is extremely careful to be async-signal-safe.
-//
-// Most obviously, we avoid calling any code that could dynamically allocate
-// memory. Doing so would almost certainly result in bugs and dead-locks.
-// We also avoid calling any other STL functions that could have unintended
-// side-effects involving memory allocation or access to other shared
-// resources.
-//
-// But on top of that, we also avoid calling other library functions, as many
-// of them have the side-effect of calling getenv() (in order to deal with
-// localization) or accessing errno. The latter sounds benign, but there are
-// several execution contexts where it isn't even possible to safely read let
-// alone write errno.
-//
-// The stated design goal of the SafeSPrintf() function is that it can be
-// called from any context that can safely call C or C++ code (i.e. anything
-// that doesn't require assembly code).
-//
-// For a brief overview of some but not all of the issues with async-signal-
-// safety, refer to:
-// http://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html
-
-namespace {
-const size_t kSSizeMaxConst = ((size_t)(ssize_t)-1) >> 1;
-
-const char kUpCaseHexDigits[] = "0123456789ABCDEF";
-const char kDownCaseHexDigits[] = "0123456789abcdef";
-}
-
-#if defined(NDEBUG)
-// We would like to define kSSizeMax as std::numeric_limits<ssize_t>::max(),
-// but C++ doesn't allow us to do that for constants. Instead, we have to
-// use careful casting and shifting. We later use a static_assert to
-// verify that this worked correctly.
-namespace {
-const size_t kSSizeMax = kSSizeMaxConst;
-}
-#else // defined(NDEBUG)
-// For efficiency, we really need kSSizeMax to be a constant. But for unit
-// tests, it should be adjustable. This allows us to verify edge cases without
-// having to fill the entire available address space. As a compromise, we make
-// kSSizeMax adjustable in debug builds, and then only compile that particular
-// part of the unit test in debug builds.
-namespace {
-static size_t kSSizeMax = kSSizeMaxConst;
-}
-
-namespace internal {
-void SetSafeSPrintfSSizeMaxForTest(size_t max) {
- kSSizeMax = max;
-}
-
-size_t GetSafeSPrintfSSizeMaxForTest() {
- return kSSizeMax;
-}
-}
-#endif // defined(NDEBUG)
-
-namespace {
-class Buffer {
- public:
- // |buffer| is caller-allocated storage that SafeSPrintf() writes to. It
- // has |size| bytes of writable storage. It is the caller's responsibility
- // to ensure that the buffer is at least one byte in size, so that it fits
- // the trailing NUL that will be added by the destructor. The buffer also
- // must be smaller or equal to kSSizeMax in size.
- Buffer(char* buffer, size_t size)
- : buffer_(buffer),
- size_(size - 1), // Account for trailing NUL byte
- count_(0) {
-// MSVS2013's standard library doesn't mark max() as constexpr yet. cl.exe
-// supports static_cast but doesn't really implement constexpr yet so it doesn't
-// complain, but clang does.
-#if __cplusplus >= 201103 && !(defined(__clang__) && defined(OS_WIN))
- static_assert(kSSizeMaxConst ==
- static_cast<size_t>(std::numeric_limits<ssize_t>::max()),
- "kSSizeMaxConst should be the max value of an ssize_t");
-#endif
- DEBUG_CHECK(size > 0);
- DEBUG_CHECK(size <= kSSizeMax);
- }
-
- ~Buffer() {
- // The code calling the constructor guaranteed that there was enough space
- // to store a trailing NUL -- and in debug builds, we are actually
- // verifying this with DEBUG_CHECK()s in the constructor. So, we can
- // always unconditionally write the NUL byte in the destructor. We do not
- // need to adjust the count_, as SafeSPrintf() copies snprintf() in not
- // including the NUL byte in its return code.
- *GetInsertionPoint() = '\000';
- }
-
- // Returns true, iff the buffer is filled all the way to |kSSizeMax-1|. The
- // caller can now stop adding more data, as GetCount() has reached its
- // maximum possible value.
- inline bool OutOfAddressableSpace() const {
- return count_ == static_cast<size_t>(kSSizeMax - 1);
- }
-
- // Returns the number of bytes that would have been emitted to |buffer_|
- // if it was sized sufficiently large. This number can be larger than
- // |size_|, if the caller provided an insufficiently large output buffer.
- // But it will never be bigger than |kSSizeMax-1|.
- inline ssize_t GetCount() const {
- DEBUG_CHECK(count_ < kSSizeMax);
- return static_cast<ssize_t>(count_);
- }
-
- // Emits one |ch| character into the |buffer_| and updates the |count_| of
- // characters that are currently supposed to be in the buffer.
- // Returns "false", iff the buffer was already full.
- // N.B. |count_| increases even if no characters have been written. This is
- // needed so that GetCount() can return the number of bytes that should
- // have been allocated for the |buffer_|.
- inline bool Out(char ch) {
- if (size_ >= 1 && count_ < size_) {
- buffer_[count_] = ch;
- return IncrementCountByOne();
- }
- // |count_| still needs to be updated, even if the buffer has been
- // filled completely. This allows SafeSPrintf() to return the number of
- // bytes that should have been emitted.
- IncrementCountByOne();
- return false;
- }
-
- // Inserts |padding|-|len| bytes worth of padding into the |buffer_|.
- // |count_| will also be incremented by the number of bytes that were meant
- // to be emitted. The |pad| character is typically either a ' ' space
- // or a '0' zero, but other non-NUL values are legal.
- // Returns "false", iff the the |buffer_| filled up (i.e. |count_|
- // overflowed |size_|) at any time during padding.
- inline bool Pad(char pad, size_t padding, size_t len) {
- DEBUG_CHECK(pad);
- DEBUG_CHECK(padding <= kSSizeMax);
- for (; padding > len; --padding) {
- if (!Out(pad)) {
- if (--padding) {
- IncrementCount(padding-len);
- }
- return false;
- }
- }
- return true;
- }
-
- // POSIX doesn't define any async-signal-safe function for converting
- // an integer to ASCII. Define our own version.
- //
- // This also gives us the ability to make the function a little more
- // powerful and have it deal with |padding|, with truncation, and with
- // predicting the length of the untruncated output.
- //
- // IToASCII() converts an integer |i| to ASCII.
- //
- // Unlike similar functions in the standard C library, it never appends a
- // NUL character. This is left for the caller to do.
- //
- // While the function signature takes a signed int64_t, the code decides at
- // run-time whether to treat the argument as signed (int64_t) or as unsigned
- // (uint64_t) based on the value of |sign|.
- //
- // It supports |base|s 2 through 16. Only a |base| of 10 is allowed to have
- // a |sign|. Otherwise, |i| is treated as unsigned.
- //
- // For bases larger than 10, |upcase| decides whether lower-case or upper-
- // case letters should be used to designate digits greater than 10.
- //
- // Padding can be done with either '0' zeros or ' ' spaces. Padding has to
- // be positive and will always be applied to the left of the output.
- //
- // Prepends a |prefix| to the number (e.g. "0x"). This prefix goes to
- // the left of |padding|, if |pad| is '0'; and to the right of |padding|
- // if |pad| is ' '.
- //
- // Returns "false", if the |buffer_| overflowed at any time.
- bool IToASCII(bool sign, bool upcase, int64_t i, int base,
- char pad, size_t padding, const char* prefix);
-
- private:
- // Increments |count_| by |inc| unless this would cause |count_| to
- // overflow |kSSizeMax-1|. Returns "false", iff an overflow was detected;
- // it then clamps |count_| to |kSSizeMax-1|.
- inline bool IncrementCount(size_t inc) {
- // "inc" is either 1 or a "padding" value. Padding is clamped at
- // run-time to at most kSSizeMax-1. So, we know that "inc" is always in
- // the range 1..kSSizeMax-1.
- // This allows us to compute "kSSizeMax - 1 - inc" without incurring any
- // integer overflows.
- DEBUG_CHECK(inc <= kSSizeMax - 1);
- if (count_ > kSSizeMax - 1 - inc) {
- count_ = kSSizeMax - 1;
- return false;
- } else {
- count_ += inc;
- return true;
- }
- }
-
- // Convenience method for the common case of incrementing |count_| by one.
- inline bool IncrementCountByOne() {
- return IncrementCount(1);
- }
-
- // Return the current insertion point into the buffer. This is typically
- // at |buffer_| + |count_|, but could be before that if truncation
- // happened. It always points to one byte past the last byte that was
- // successfully placed into the |buffer_|.
- inline char* GetInsertionPoint() const {
- size_t idx = count_;
- if (idx > size_) {
- idx = size_;
- }
- return buffer_ + idx;
- }
-
- // User-provided buffer that will receive the fully formatted output string.
- char* buffer_;
-
- // Number of bytes that are available in the buffer excluding the trailing
- // NUL byte that will be added by the destructor.
- const size_t size_;
-
- // Number of bytes that would have been emitted to the buffer, if the buffer
- // was sufficiently big. This number always excludes the trailing NUL byte
- // and it is guaranteed to never grow bigger than kSSizeMax-1.
- size_t count_;
-
- DISALLOW_COPY_AND_ASSIGN(Buffer);
-};
-
-
-bool Buffer::IToASCII(bool sign, bool upcase, int64_t i, int base,
- char pad, size_t padding, const char* prefix) {
- // Sanity check for parameters. None of these should ever fail, but see
- // above for the rationale why we can't call CHECK().
- DEBUG_CHECK(base >= 2);
- DEBUG_CHECK(base <= 16);
- DEBUG_CHECK(!sign || base == 10);
- DEBUG_CHECK(pad == '0' || pad == ' ');
- DEBUG_CHECK(padding <= kSSizeMax);
- DEBUG_CHECK(!(sign && prefix && *prefix));
-
- // Handle negative numbers, if the caller indicated that |i| should be
- // treated as a signed number; otherwise treat |i| as unsigned (even if the
- // MSB is set!)
- // Details are tricky, because of limited data-types, but equivalent pseudo-
- // code would look like:
- // if (sign && i < 0)
- // prefix = "-";
- // num = abs(i);
- int minint = 0;
- uint64_t num;
- if (sign && i < 0) {
- prefix = "-";
-
- // Turn our number positive.
- if (i == std::numeric_limits<int64_t>::min()) {
- // The most negative integer needs special treatment.
- minint = 1;
- num = static_cast<uint64_t>(-(i + 1));
- } else {
- // "Normal" negative numbers are easy.
- num = static_cast<uint64_t>(-i);
- }
- } else {
- num = static_cast<uint64_t>(i);
- }
-
- // If padding with '0' zero, emit the prefix or '-' character now. Otherwise,
- // make the prefix accessible in reverse order, so that we can later output
- // it right between padding and the number.
- // We cannot choose the easier approach of just reversing the number, as that
- // fails in situations where we need to truncate numbers that have padding
- // and/or prefixes.
- const char* reverse_prefix = nullptr;
- if (prefix && *prefix) {
- if (pad == '0') {
- while (*prefix) {
- if (padding) {
- --padding;
- }
- Out(*prefix++);
- }
- prefix = nullptr;
- } else {
- for (reverse_prefix = prefix; *reverse_prefix; ++reverse_prefix) {
- }
- }
- } else
- prefix = nullptr;
- const size_t prefix_length = reverse_prefix - prefix;
-
- // Loop until we have converted the entire number. Output at least one
- // character (i.e. '0').
- size_t start = count_;
- size_t discarded = 0;
- bool started = false;
- do {
- // Make sure there is still enough space left in our output buffer.
- if (count_ >= size_) {
- if (start < size_) {
- // It is rare that we need to output a partial number. But if asked
- // to do so, we will still make sure we output the correct number of
- // leading digits.
- // Since we are generating the digits in reverse order, we actually
- // have to discard digits in the order that we have already emitted
- // them. This is essentially equivalent to:
- // memmove(buffer_ + start, buffer_ + start + 1, size_ - start - 1)
- for (char* move = buffer_ + start, *end = buffer_ + size_ - 1;
- move < end;
- ++move) {
- *move = move[1];
- }
- ++discarded;
- --count_;
- } else if (count_ - size_ > 1) {
- // Need to increment either |count_| or |discarded| to make progress.
- // The latter is more efficient, as it eventually triggers fast
- // handling of padding. But we have to ensure we don't accidentally
- // change the overall state (i.e. switch the state-machine from
- // discarding to non-discarding). |count_| needs to always stay
- // bigger than |size_|.
- --count_;
- ++discarded;
- }
- }
-
- // Output the next digit and (if necessary) compensate for the most
- // negative integer needing special treatment. This works because,
- // no matter the bit width of the integer, the lowest-most decimal
- // integer always ends in 2, 4, 6, or 8.
- if (!num && started) {
- if (reverse_prefix > prefix) {
- Out(*--reverse_prefix);
- } else {
- Out(pad);
- }
- } else {
- started = true;
- Out((upcase ? kUpCaseHexDigits : kDownCaseHexDigits)[num%base + minint]);
- }
-
- minint = 0;
- num /= base;
-
- // Add padding, if requested.
- if (padding > 0) {
- --padding;
-
- // Performance optimization for when we are asked to output excessive
- // padding, but our output buffer is limited in size. Even if we output
- // a 64bit number in binary, we would never write more than 64 plus
- // prefix non-padding characters. So, once this limit has been passed,
- // any further state change can be computed arithmetically; we know that
- // by this time, our entire final output consists of padding characters
- // that have all already been output.
- if (discarded > 8*sizeof(num) + prefix_length) {
- IncrementCount(padding);
- padding = 0;
- }
- }
- } while (num || padding || (reverse_prefix > prefix));
-
- // Conversion to ASCII actually resulted in the digits being in reverse
- // order. We can't easily generate them in forward order, as we can't tell
- // the number of characters needed until we are done converting.
- // So, now, we reverse the string (except for the possible '-' sign).
- char* front = buffer_ + start;
- char* back = GetInsertionPoint();
- while (--back > front) {
- char ch = *back;
- *back = *front;
- *front++ = ch;
- }
-
- IncrementCount(discarded);
- return !discarded;
-}
-
-} // anonymous namespace
-
-namespace internal {
-
-ssize_t SafeSNPrintf(char* buf, size_t sz, const char* fmt, const Arg* args,
- const size_t max_args) {
- // Make sure that at least one NUL byte can be written, and that the buffer
- // never overflows kSSizeMax. Not only does that use up most or all of the
- // address space, it also would result in a return code that cannot be
- // represented.
- if (static_cast<ssize_t>(sz) < 1) {
- return -1;
- } else if (sz > kSSizeMax) {
- sz = kSSizeMax;
- }
-
- // Iterate over format string and interpret '%' arguments as they are
- // encountered.
- Buffer buffer(buf, sz);
- size_t padding;
- char pad;
- for (unsigned int cur_arg = 0; *fmt && !buffer.OutOfAddressableSpace(); ) {
- if (*fmt++ == '%') {
- padding = 0;
- pad = ' ';
- char ch = *fmt++;
- format_character_found:
- switch (ch) {
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- // Found a width parameter. Convert to an integer value and store in
- // "padding". If the leading digit is a zero, change the padding
- // character from a space ' ' to a zero '0'.
- pad = ch == '0' ? '0' : ' ';
- for (;;) {
- // The maximum allowed padding fills all the available address
- // space and leaves just enough space to insert the trailing NUL.
- const size_t max_padding = kSSizeMax - 1;
- if (padding > max_padding/10 ||
- 10*padding > max_padding - (ch - '0')) {
- DEBUG_CHECK(padding <= max_padding/10 &&
- 10*padding <= max_padding - (ch - '0'));
- // Integer overflow detected. Skip the rest of the width until
- // we find the format character, then do the normal error handling.
- padding_overflow:
- padding = max_padding;
- while ((ch = *fmt++) >= '0' && ch <= '9') {
- }
- if (cur_arg < max_args) {
- ++cur_arg;
- }
- goto fail_to_expand;
- }
- padding = 10*padding + ch - '0';
- if (padding > max_padding) {
- // This doesn't happen for "sane" values of kSSizeMax. But once
- // kSSizeMax gets smaller than about 10, our earlier range checks
- // are incomplete. Unittests do trigger this artificial corner
- // case.
- DEBUG_CHECK(padding <= max_padding);
- goto padding_overflow;
- }
- ch = *fmt++;
- if (ch < '0' || ch > '9') {
- // Reached the end of the width parameter. This is where the format
- // character is found.
- goto format_character_found;
- }
- }
- break;
- case 'c': { // Output an ASCII character.
- // Check that there are arguments left to be inserted.
- if (cur_arg >= max_args) {
- DEBUG_CHECK(cur_arg < max_args);
- goto fail_to_expand;
- }
-
- // Check that the argument has the expected type.
- const Arg& arg = args[cur_arg++];
- if (arg.type != Arg::INT && arg.type != Arg::UINT) {
- DEBUG_CHECK(arg.type == Arg::INT || arg.type == Arg::UINT);
- goto fail_to_expand;
- }
-
- // Apply padding, if needed.
- buffer.Pad(' ', padding, 1);
-
- // Convert the argument to an ASCII character and output it.
- char as_char = static_cast<char>(arg.integer.i);
- if (!as_char) {
- goto end_of_output_buffer;
- }
- buffer.Out(as_char);
- break; }
- case 'd': // Output a possibly signed decimal value.
- case 'o': // Output an unsigned octal value.
- case 'x': // Output an unsigned hexadecimal value.
- case 'X':
- case 'p': { // Output a pointer value.
- // Check that there are arguments left to be inserted.
- if (cur_arg >= max_args) {
- DEBUG_CHECK(cur_arg < max_args);
- goto fail_to_expand;
- }
-
- const Arg& arg = args[cur_arg++];
- int64_t i;
- const char* prefix = nullptr;
- if (ch != 'p') {
- // Check that the argument has the expected type.
- if (arg.type != Arg::INT && arg.type != Arg::UINT) {
- DEBUG_CHECK(arg.type == Arg::INT || arg.type == Arg::UINT);
- goto fail_to_expand;
- }
- i = arg.integer.i;
-
- if (ch != 'd') {
- // The Arg() constructor automatically performed sign expansion on
- // signed parameters. This is great when outputting a %d decimal
- // number, but can result in unexpected leading 0xFF bytes when
- // outputting a %x hexadecimal number. Mask bits, if necessary.
- // We have to do this here, instead of in the Arg() constructor, as
- // the Arg() constructor cannot tell whether we will output a %d
- // or a %x. Only the latter should experience masking.
- if (arg.integer.width < sizeof(int64_t)) {
- i &= (1LL << (8*arg.integer.width)) - 1;
- }
- }
- } else {
- // Pointer values require an actual pointer or a string.
- if (arg.type == Arg::POINTER) {
- i = reinterpret_cast<uintptr_t>(arg.ptr);
- } else if (arg.type == Arg::STRING) {
- i = reinterpret_cast<uintptr_t>(arg.str);
- } else if (arg.type == Arg::INT &&
- arg.integer.width == sizeof(NULL) &&
- arg.integer.i == 0) { // Allow C++'s version of NULL
- i = 0;
- } else {
- DEBUG_CHECK(arg.type == Arg::POINTER || arg.type == Arg::STRING);
- goto fail_to_expand;
- }
-
- // Pointers always include the "0x" prefix.
- prefix = "0x";
- }
-
- // Use IToASCII() to convert to ASCII representation. For decimal
- // numbers, optionally print a sign. For hexadecimal numbers,
- // distinguish between upper and lower case. %p addresses are always
- // printed as upcase. Supports base 8, 10, and 16. Prints padding
- // and/or prefixes, if so requested.
- buffer.IToASCII(ch == 'd' && arg.type == Arg::INT,
- ch != 'x', i,
- ch == 'o' ? 8 : ch == 'd' ? 10 : 16,
- pad, padding, prefix);
- break; }
- case 's': {
- // Check that there are arguments left to be inserted.
- if (cur_arg >= max_args) {
- DEBUG_CHECK(cur_arg < max_args);
- goto fail_to_expand;
- }
-
- // Check that the argument has the expected type.
- const Arg& arg = args[cur_arg++];
- const char *s;
- if (arg.type == Arg::STRING) {
- s = arg.str ? arg.str : "<NULL>";
- } else if (arg.type == Arg::INT && arg.integer.width == sizeof(NULL) &&
- arg.integer.i == 0) { // Allow C++'s version of NULL
- s = "<NULL>";
- } else {
- DEBUG_CHECK(arg.type == Arg::STRING);
- goto fail_to_expand;
- }
-
- // Apply padding, if needed. This requires us to first check the
- // length of the string that we are outputting.
- if (padding) {
- size_t len = 0;
- for (const char* src = s; *src++; ) {
- ++len;
- }
- buffer.Pad(' ', padding, len);
- }
-
- // Printing a string involves nothing more than copying it into the
- // output buffer and making sure we don't output more bytes than
- // available space; Out() takes care of doing that.
- for (const char* src = s; *src; ) {
- buffer.Out(*src++);
- }
- break; }
- case '%':
- // Quoted percent '%' character.
- goto copy_verbatim;
- fail_to_expand:
- // C++ gives us tools to do type checking -- something that snprintf()
- // could never really do. So, whenever we see arguments that don't
- // match up with the format string, we refuse to output them. But
- // since we have to be extremely conservative about being async-
- // signal-safe, we are limited in the type of error handling that we
- // can do in production builds (in debug builds we can use
- // DEBUG_CHECK() and hope for the best). So, all we do is pass the
- // format string unchanged. That should eventually get the user's
- // attention; and in the meantime, it hopefully doesn't lose too much
- // data.
- default:
- // Unknown or unsupported format character. Just copy verbatim to
- // output.
- buffer.Out('%');
- DEBUG_CHECK(ch);
- if (!ch) {
- goto end_of_format_string;
- }
- buffer.Out(ch);
- break;
- }
- } else {
- copy_verbatim:
- buffer.Out(fmt[-1]);
- }
- }
- end_of_format_string:
- end_of_output_buffer:
- return buffer.GetCount();
-}
-
-} // namespace internal
-
-ssize_t SafeSNPrintf(char* buf, size_t sz, const char* fmt) {
- // Make sure that at least one NUL byte can be written, and that the buffer
- // never overflows kSSizeMax. Not only does that use up most or all of the
- // address space, it also would result in a return code that cannot be
- // represented.
- if (static_cast<ssize_t>(sz) < 1) {
- return -1;
- } else if (sz > kSSizeMax) {
- sz = kSSizeMax;
- }
-
- Buffer buffer(buf, sz);
-
- // In the slow-path, we deal with errors by copying the contents of
- // "fmt" unexpanded. This means, if there are no arguments passed, the
- // SafeSPrintf() function always degenerates to a version of strncpy() that
- // de-duplicates '%' characters.
- const char* src = fmt;
- for (; *src; ++src) {
- buffer.Out(*src);
- DEBUG_CHECK(src[0] != '%' || src[1] == '%');
- if (src[0] == '%' && src[1] == '%') {
- ++src;
- }
- }
- return buffer.GetCount();
-}
-
-} // namespace strings
-} // namespace base
diff --git a/base/strings/safe_sprintf.h b/base/strings/safe_sprintf.h
deleted file mode 100644
index 56a6eaf..0000000
--- a/base/strings/safe_sprintf.h
+++ /dev/null
@@ -1,246 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_SAFE_SPRINTF_H_
-#define BASE_STRINGS_SAFE_SPRINTF_H_
-
-#include "build_config.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-// For ssize_t
-#include <unistd.h>
-#endif
-
-#include "base/base_export.h"
-
-namespace base {
-namespace strings {
-
-#if defined(COMPILER_MSVC)
-// Define ssize_t inside of our namespace.
-#if defined(_WIN64)
-typedef __int64 ssize_t;
-#else
-typedef long ssize_t;
-#endif
-#endif
-
-// SafeSPrintf() is a type-safe and completely self-contained version of
-// snprintf().
-//
-// SafeSNPrintf() is an alternative function signature that can be used when
-// not dealing with fixed-sized buffers. When possible, SafeSPrintf() should
-// always be used instead of SafeSNPrintf()
-//
-// These functions allow for formatting complicated messages from contexts that
-// require strict async-signal-safety. In fact, it is safe to call them from
-// any low-level execution context, as they are guaranteed to make no library
-// or system calls. It deliberately never touches "errno", either.
-//
-// The only exception to this rule is that in debug builds the code calls
-// RAW_CHECK() to help diagnose problems when the format string does not
-// match the rest of the arguments. In release builds, no CHECK()s are used,
-// and SafeSPrintf() instead returns an output string that expands only
-// those arguments that match their format characters. Mismatched arguments
-// are ignored.
-//
-// The code currently only supports a subset of format characters:
-// %c, %o, %d, %x, %X, %p, and %s.
-//
-// SafeSPrintf() aims to be as liberal as reasonably possible. Integer-like
-// values of arbitrary width can be passed to all of the format characters
-// that expect integers. Thus, it is explicitly legal to pass an "int" to
-// "%c", and output will automatically look at the LSB only. It is also
-// explicitly legal to pass either signed or unsigned values, and the format
-// characters will automatically interpret the arguments accordingly.
-//
-// It is still not legal to mix-and-match integer-like values with pointer
-// values. For instance, you cannot pass a pointer to %x, nor can you pass an
-// integer to %p.
-//
-// The one exception is "0" zero being accepted by "%p". This works-around
-// the problem of C++ defining NULL as an integer-like value.
-//
-// All format characters take an optional width parameter. This must be a
-// positive integer. For %d, %o, %x, %X and %p, if the width starts with
-// a leading '0', padding is done with '0' instead of ' ' characters.
-//
-// There are a few features of snprintf()-style format strings, that
-// SafeSPrintf() does not support at this time.
-//
-// If an actual user showed up, there is no particularly strong reason they
-// couldn't be added. But that assumes that the trade-offs between complexity
-// and utility are favorable.
-//
-// For example, adding support for negative padding widths, and for %n are all
-// likely to be viewed positively. They are all clearly useful, low-risk, easy
-// to test, don't jeopardize the async-signal-safety of the code, and overall
-// have little impact on other parts of SafeSPrintf() function.
-//
-// On the other hands, adding support for alternate forms, positional
-// arguments, grouping, wide characters, localization or floating point numbers
-// are all unlikely to ever be added.
-//
-// SafeSPrintf() and SafeSNPrintf() mimic the behavior of snprintf() and they
-// return the number of bytes needed to store the untruncated output. This
-// does *not* include the terminating NUL byte.
-//
-// They return -1, iff a fatal error happened. This typically can only happen,
-// if the buffer size is a) negative, or b) zero (i.e. not even the NUL byte
-// can be written). The return value can never be larger than SSIZE_MAX-1.
-// This ensures that the caller can always add one to the signed return code
-// in order to determine the amount of storage that needs to be allocated.
-//
-// While the code supports type checking and while it is generally very careful
-// to avoid printing incorrect values, it tends to be conservative in printing
-// as much as possible, even when given incorrect parameters. Typically, in
-// case of an error, the format string will not be expanded. (i.e. something
-// like SafeSPrintf(buf, "%p %d", 1, 2) results in "%p 2"). See above for
-// the use of RAW_CHECK() in debug builds, though.
-//
-// Basic example:
-// char buf[20];
-// base::strings::SafeSPrintf(buf, "The answer: %2d", 42);
-//
-// Example with dynamically sized buffer (async-signal-safe). This code won't
-// work on Visual studio, as it requires dynamically allocating arrays on the
-// stack. Consider picking a smaller value for |kMaxSize| if stack size is
-// limited and known. On the other hand, if the parameters to SafeSNPrintf()
-// are trusted and not controllable by the user, you can consider eliminating
-// the check for |kMaxSize| altogether. The current value of SSIZE_MAX is
-// essentially a no-op that just illustrates how to implement an upper bound:
-// const size_t kInitialSize = 128;
-// const size_t kMaxSize = std::numeric_limits<ssize_t>::max();
-// size_t size = kInitialSize;
-// for (;;) {
-// char buf[size];
-// size = SafeSNPrintf(buf, size, "Error message \"%s\"\n", err) + 1;
-// if (sizeof(buf) < kMaxSize && size > kMaxSize) {
-// size = kMaxSize;
-// continue;
-// } else if (size > sizeof(buf))
-// continue;
-// write(2, buf, size-1);
-// break;
-// }
-
-namespace internal {
-// Helpers that use C++ overloading, templates, and specializations to deduce
-// and record type information from function arguments. This allows us to
-// later write a type-safe version of snprintf().
-
-struct Arg {
- enum Type { INT, UINT, STRING, POINTER };
-
- // Any integer-like value.
- Arg(signed char c) : type(INT) {
- integer.i = c;
- integer.width = sizeof(char);
- }
- Arg(unsigned char c) : type(UINT) {
- integer.i = c;
- integer.width = sizeof(char);
- }
- Arg(signed short j) : type(INT) {
- integer.i = j;
- integer.width = sizeof(short);
- }
- Arg(unsigned short j) : type(UINT) {
- integer.i = j;
- integer.width = sizeof(short);
- }
- Arg(signed int j) : type(INT) {
- integer.i = j;
- integer.width = sizeof(int);
- }
- Arg(unsigned int j) : type(UINT) {
- integer.i = j;
- integer.width = sizeof(int);
- }
- Arg(signed long j) : type(INT) {
- integer.i = j;
- integer.width = sizeof(long);
- }
- Arg(unsigned long j) : type(UINT) {
- integer.i = j;
- integer.width = sizeof(long);
- }
- Arg(signed long long j) : type(INT) {
- integer.i = j;
- integer.width = sizeof(long long);
- }
- Arg(unsigned long long j) : type(UINT) {
- integer.i = j;
- integer.width = sizeof(long long);
- }
-
- // A C-style text string.
- Arg(const char* s) : str(s), type(STRING) { }
- Arg(char* s) : str(s), type(STRING) { }
-
- // Any pointer value that can be cast to a "void*".
- template<class T> Arg(T* p) : ptr((void*)p), type(POINTER) { }
-
- union {
- // An integer-like value.
- struct {
- int64_t i;
- unsigned char width;
- } integer;
-
- // A C-style text string.
- const char* str;
-
- // A pointer to an arbitrary object.
- const void* ptr;
- };
- const enum Type type;
-};
-
-// This is the internal function that performs the actual formatting of
-// an snprintf()-style format string.
-BASE_EXPORT ssize_t SafeSNPrintf(char* buf, size_t sz, const char* fmt,
- const Arg* args, size_t max_args);
-
-#if !defined(NDEBUG)
-// In debug builds, allow unit tests to artificially lower the kSSizeMax
-// constant that is used as a hard upper-bound for all buffers. In normal
-// use, this constant should always be std::numeric_limits<ssize_t>::max().
-BASE_EXPORT void SetSafeSPrintfSSizeMaxForTest(size_t max);
-BASE_EXPORT size_t GetSafeSPrintfSSizeMaxForTest();
-#endif
-
-} // namespace internal
-
-template<typename... Args>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, Args... args) {
- // Use Arg() object to record type information and then copy arguments to an
- // array to make it easier to iterate over them.
- const internal::Arg arg_array[] = { args... };
- return internal::SafeSNPrintf(buf, N, fmt, arg_array, sizeof...(args));
-}
-
-template<size_t N, typename... Args>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, Args... args) {
- // Use Arg() object to record type information and then copy arguments to an
- // array to make it easier to iterate over them.
- const internal::Arg arg_array[] = { args... };
- return internal::SafeSNPrintf(buf, N, fmt, arg_array, sizeof...(args));
-}
-
-// Fast-path when we don't actually need to substitute any arguments.
-BASE_EXPORT ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt);
-template<size_t N>
-inline ssize_t SafeSPrintf(char (&buf)[N], const char* fmt) {
- return SafeSNPrintf(buf, N, fmt);
-}
-
-} // namespace strings
-} // namespace base
-
-#endif // BASE_STRINGS_SAFE_SPRINTF_H_
diff --git a/base/strings/strcat.cc b/base/strings/strcat.cc
deleted file mode 100644
index 3d5b2ca..0000000
--- a/base/strings/strcat.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/strcat.h"
-
-namespace base {
-
-namespace {
-
-// Reserves an additional amount of size in the given string, growing by at
-// least 2x. Used by StrAppend().
-//
-// The "at least 2x" growing rule duplicates the exponential growth of
-// std::string. The problem is that most implementations of reserve() will grow
-// exactly to the requested amount instead of exponentially growing like would
-// happen when appending normally. If we didn't do this, an append after the
-// call to StrAppend() would definitely cause a reallocation, and loops with
-// StrAppend() calls would have O(n^2) complexity to execute. Instead, we want
-// StrAppend() to have the same semantics as std::string::append().
-//
-// If the string is empty, we assume that exponential growth is not necessary.
-template <typename String>
-void ReserveAdditional(String* str, typename String::size_type additional) {
- str->reserve(std::max(str->size() + additional, str->size() * 2));
-}
-
-template <typename DestString, typename InputString>
-void StrAppendT(DestString* dest, span<const InputString> pieces) {
- size_t additional_size = 0;
- for (const auto& cur : pieces)
- additional_size += cur.size();
- ReserveAdditional(dest, additional_size);
-
- for (const auto& cur : pieces)
- dest->append(cur.data(), cur.size());
-}
-
-} // namespace
-
-std::string StrCat(span<const StringPiece> pieces) {
- std::string result;
- StrAppendT(&result, pieces);
- return result;
-}
-
-string16 StrCat(span<const StringPiece16> pieces) {
- string16 result;
- StrAppendT(&result, pieces);
- return result;
-}
-
-std::string StrCat(span<const std::string> pieces) {
- std::string result;
- StrAppendT(&result, pieces);
- return result;
-}
-
-string16 StrCat(span<const string16> pieces) {
- string16 result;
- StrAppendT(&result, pieces);
- return result;
-}
-
-void StrAppend(std::string* dest, span<const StringPiece> pieces) {
- StrAppendT(dest, pieces);
-}
-
-void StrAppend(string16* dest, span<const StringPiece16> pieces) {
- StrAppendT(dest, pieces);
-}
-
-void StrAppend(std::string* dest, span<const std::string> pieces) {
- StrAppendT(dest, pieces);
-}
-
-void StrAppend(string16* dest, span<const string16> pieces) {
- StrAppendT(dest, pieces);
-}
-
-} // namespace base
diff --git a/base/strings/strcat.h b/base/strings/strcat.h
deleted file mode 100644
index b2fcaae..0000000
--- a/base/strings/strcat.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_STRCAT_H_
-#define BASE_STRINGS_STRCAT_H_
-
-#include <initializer_list>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/containers/span.h"
-#include "base/strings/string_piece.h"
-#include "build_config.h"
-
-#if defined(OS_WIN)
-// To resolve a conflict with Win32 API StrCat macro.
-#include "base/win/windows_types.h"
-#endif
-
-namespace base {
-
-// StrCat ----------------------------------------------------------------------
-//
-// StrCat is a function to perform concatenation on a sequence of strings.
-// It is preferrable to a sequence of "a + b + c" because it is both faster and
-// generates less code.
-//
-// std::string result = base::StrCat({"foo ", result, "\nfoo ", bar});
-//
-// To join an array of strings with a separator, see base::JoinString in
-// base/strings/string_util.h.
-//
-// MORE INFO
-//
-// StrCat can see all arguments at once, so it can allocate one return buffer
-// of exactly the right size and copy once, as opposed to a sequence of
-// operator+ which generates a series of temporary strings, copying as it goes.
-// And by using StringPiece arguments, StrCat can avoid creating temporary
-// string objects for char* constants.
-//
-// ALTERNATIVES
-//
-// Internal Google / Abseil has a similar StrCat function. That version takes
-// an overloaded number of arguments instead of initializer list (overflowing
-// to initializer list for many arguments). We don't have any legacy
-// requirements and using only initializer_list is simpler and generates
-// roughly the same amount of code at the call sites.
-//
-// Abseil's StrCat also allows numbers by using an intermediate class that can
-// be implicitly constructed from either a string or various number types. This
-// class formats the numbers into a static buffer for increased performance,
-// and the call sites look nice.
-//
-// As-written Abseil's helper class for numbers generates slightly more code
-// than the raw StringPiece version. We can de-inline the helper class'
-// constructors which will cause the StringPiece constructors to be de-inlined
-// for this call and generate slightly less code. This is something we can
-// explore more in the future.
-
-BASE_EXPORT std::string StrCat(span<const StringPiece> pieces);
-BASE_EXPORT string16 StrCat(span<const StringPiece16> pieces);
-BASE_EXPORT std::string StrCat(span<const std::string> pieces);
-BASE_EXPORT string16 StrCat(span<const string16> pieces);
-
-// Initializer list forwards to the array version.
-inline std::string StrCat(std::initializer_list<StringPiece> pieces) {
- return StrCat(make_span(pieces.begin(), pieces.size()));
-}
-inline string16 StrCat(std::initializer_list<StringPiece16> pieces) {
- return StrCat(make_span(pieces.begin(), pieces.size()));
-}
-
-// StrAppend -------------------------------------------------------------------
-//
-// Appends a sequence of strings to a destination. Prefer:
-// StrAppend(&foo, ...);
-// over:
-// foo += StrCat(...);
-// because it avoids a temporary string allocation and copy.
-
-BASE_EXPORT void StrAppend(std::string* dest, span<const StringPiece> pieces);
-BASE_EXPORT void StrAppend(string16* dest, span<const StringPiece16> pieces);
-BASE_EXPORT void StrAppend(std::string* dest, span<const std::string> pieces);
-BASE_EXPORT void StrAppend(string16* dest, span<const string16> pieces);
-
-// Initializer list forwards to the array version.
-inline void StrAppend(std::string* dest,
- std::initializer_list<StringPiece> pieces) {
- return StrAppend(dest, make_span(pieces.begin(), pieces.size()));
-}
-inline void StrAppend(string16* dest,
- std::initializer_list<StringPiece16> pieces) {
- return StrAppend(dest, make_span(pieces.begin(), pieces.size()));
-}
-
-} // namespace base
-
-#endif // BASE_STRINGS_STRCAT_H_
diff --git a/base/strings/string_number_conversions_fuzzer.cc b/base/strings/string_number_conversions_fuzzer.cc
deleted file mode 100644
index 2fed7de..0000000
--- a/base/strings/string_number_conversions_fuzzer.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-#include "base/strings/string_number_conversions.h"
-
-// Entry point for LibFuzzer.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- base::StringPiece string_piece_input(reinterpret_cast<const char*>(data),
- size);
- std::string string_input(reinterpret_cast<const char*>(data), size);
-
- int out_int;
- base::StringToInt(string_piece_input, &out_int);
- unsigned out_uint;
- base::StringToUint(string_piece_input, &out_uint);
- int64_t out_int64;
- base::StringToInt64(string_piece_input, &out_int64);
- uint64_t out_uint64;
- base::StringToUint64(string_piece_input, &out_uint64);
- size_t out_size;
- base::StringToSizeT(string_piece_input, &out_size);
-
- // Test for StringPiece16 if size is even.
- if (size % 2 == 0) {
- base::StringPiece16 string_piece_input16(
- reinterpret_cast<const base::char16*>(data), size / 2);
-
- base::StringToInt(string_piece_input16, &out_int);
- base::StringToUint(string_piece_input16, &out_uint);
- base::StringToInt64(string_piece_input16, &out_int64);
- base::StringToUint64(string_piece_input16, &out_uint64);
- base::StringToSizeT(string_piece_input16, &out_size);
- }
-
- double out_double;
- base::StringToDouble(string_input, &out_double);
-
- base::HexStringToInt(string_piece_input, &out_int);
- base::HexStringToUInt(string_piece_input, &out_uint);
- base::HexStringToInt64(string_piece_input, &out_int64);
- base::HexStringToUInt64(string_piece_input, &out_uint64);
- std::vector<uint8_t> out_bytes;
- base::HexStringToBytes(string_piece_input, &out_bytes);
-
- base::HexEncode(data, size);
-
- // Convert the numbers back to strings.
- base::NumberToString(out_int);
- base::NumberToString16(out_int);
- base::NumberToString(out_uint);
- base::NumberToString16(out_uint);
- base::NumberToString(out_int64);
- base::NumberToString16(out_int64);
- base::NumberToString(out_uint64);
- base::NumberToString16(out_uint64);
- base::NumberToString(out_double);
- base::NumberToString16(out_double);
-
- return 0;
-}
diff --git a/base/strings/string_tokenizer_fuzzer.cc b/base/strings/string_tokenizer_fuzzer.cc
deleted file mode 100644
index 917041b..0000000
--- a/base/strings/string_tokenizer_fuzzer.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "base/strings/string_tokenizer.h"
-
-void GetAllTokens(base::StringTokenizer& t) {
- while (t.GetNext()) {
- (void)t.token();
- }
-}
-
-// Entry point for LibFuzzer.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- uint8_t size_t_bytes = sizeof(size_t);
- if (size < size_t_bytes + 1) {
- return 0;
- }
-
- // Calculate pattern size based on remaining bytes, otherwise fuzzing is
- // inefficient with bailouts in most cases.
- size_t pattern_size =
- *reinterpret_cast<const size_t*>(data) % (size - size_t_bytes);
-
- std::string pattern(reinterpret_cast<const char*>(data + size_t_bytes),
- pattern_size);
- std::string input(
- reinterpret_cast<const char*>(data + size_t_bytes + pattern_size),
- size - pattern_size - size_t_bytes);
-
- // Allow quote_chars and options to be set. Otherwise full coverage
- // won't be possible since IsQuote, FullGetNext and other functions
- // won't be called.
- base::StringTokenizer t(input, pattern);
- GetAllTokens(t);
-
- base::StringTokenizer t_quote(input, pattern);
- t_quote.set_quote_chars("\"");
- GetAllTokens(t_quote);
-
- base::StringTokenizer t_options(input, pattern);
- t_options.set_options(base::StringTokenizer::RETURN_DELIMS);
- GetAllTokens(t_options);
-
- base::StringTokenizer t_quote_and_options(input, pattern);
- t_quote_and_options.set_quote_chars("\"");
- t_quote_and_options.set_options(base::StringTokenizer::RETURN_DELIMS);
- GetAllTokens(t_quote_and_options);
-
- return 0;
-}
diff --git a/base/strings/utf_string_conversions_fuzzer.cc b/base/strings/utf_string_conversions_fuzzer.cc
deleted file mode 100644
index 37d4be2..0000000
--- a/base/strings/utf_string_conversions_fuzzer.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-
-std::string output_std_string;
-std::wstring output_std_wstring;
-base::string16 output_string16;
-
-// Entry point for LibFuzzer.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- base::StringPiece string_piece_input(reinterpret_cast<const char*>(data),
- size);
-
- base::UTF8ToWide(string_piece_input);
- base::UTF8ToWide(reinterpret_cast<const char*>(data), size,
- &output_std_wstring);
- base::UTF8ToUTF16(string_piece_input);
- base::UTF8ToUTF16(reinterpret_cast<const char*>(data), size,
- &output_string16);
-
- // Test for char16.
- if (size % 2 == 0) {
- base::StringPiece16 string_piece_input16(
- reinterpret_cast<const base::char16*>(data), size / 2);
- base::UTF16ToWide(output_string16);
- base::UTF16ToWide(reinterpret_cast<const base::char16*>(data), size / 2,
- &output_std_wstring);
- base::UTF16ToUTF8(string_piece_input16);
- base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(data), size / 2,
- &output_std_string);
- }
-
- // Test for wchar_t.
- size_t wchar_t_size = sizeof(wchar_t);
- if (size % wchar_t_size == 0) {
- base::WideToUTF8(output_std_wstring);
- base::WideToUTF8(reinterpret_cast<const wchar_t*>(data),
- size / wchar_t_size, &output_std_string);
- base::WideToUTF16(output_std_wstring);
- base::WideToUTF16(reinterpret_cast<const wchar_t*>(data),
- size / wchar_t_size, &output_string16);
- }
-
- // Test for ASCII. This condition is needed to avoid hitting instant CHECK
- // failures.
- if (base::IsStringASCII(string_piece_input)) {
- output_string16 = base::ASCIIToUTF16(string_piece_input);
- base::StringPiece16 string_piece_input16(output_string16);
- base::UTF16ToASCII(string_piece_input16);
- }
-
- return 0;
-}
diff --git a/base/strings/utf_string_conversions_regression_fuzzer.cc b/base/strings/utf_string_conversions_regression_fuzzer.cc
deleted file mode 100644
index ca6b4a2..0000000
--- a/base/strings/utf_string_conversions_regression_fuzzer.cc
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright (c) 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/logging.h"
-#include "base/strings/old_utf_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-
-namespace {
-
-void UTF8ToCheck(const uint8_t* data, size_t size) {
- const auto* src = reinterpret_cast<const char*>(data);
- const size_t src_len = size;
-
- // UTF16
- {
- base::string16 new_out;
- bool new_res = base::UTF8ToUTF16(src, src_len, &new_out);
-
- base::string16 old_out;
- bool old_res = base_old::UTF8ToUTF16(src, src_len, &old_out);
-
- CHECK(new_res == old_res);
- CHECK(new_out == old_out);
- }
-
- // Wide
- {
- std::wstring new_out;
- bool new_res = base::UTF8ToWide(src, src_len, &new_out);
-
- std::wstring old_out;
- bool old_res = base_old::UTF8ToWide(src, src_len, &old_out);
-
- CHECK(new_res == old_res);
- CHECK(new_out == old_out);
- }
-}
-
-void UTF16ToCheck(const uint8_t* data, size_t size) {
- const auto* src = reinterpret_cast<const base::char16*>(data);
- const size_t src_len = size / 2;
-
- // UTF8
- {
- std::string new_out;
- bool new_res = base::UTF16ToUTF8(src, src_len, &new_out);
-
- std::string old_out;
- bool old_res = base_old::UTF16ToUTF8(src, src_len, &old_out);
-
- CHECK(new_res == old_res);
- CHECK(new_out == old_out);
- }
-
- // Wide
- {
- std::wstring new_out;
- bool new_res = base::UTF16ToWide(src, src_len, &new_out);
-
- std::wstring old_out;
- bool old_res = base_old::UTF16ToWide(src, src_len, &old_out);
-
- CHECK(new_res == old_res);
- CHECK(new_out == old_out);
- }
-}
-
-void WideToCheck(const uint8_t* data, size_t size) {
- const auto* src = reinterpret_cast<const wchar_t*>(data);
- const size_t src_len = size / 4; // It's OK even if Wide is 16bit.
-
- // UTF8
- {
- std::string new_out;
- bool new_res = base::WideToUTF8(src, src_len, &new_out);
-
- std::string old_out;
- bool old_res = base_old::WideToUTF8(src, src_len, &old_out);
-
- CHECK(new_res == old_res);
- CHECK(new_out == old_out);
- }
-
- // UTF16
- {
- base::string16 new_out;
- bool new_res = base::WideToUTF16(src, src_len, &new_out);
-
- base::string16 old_out;
- bool old_res = base_old::WideToUTF16(src, src_len, &old_out);
-
- CHECK(new_res == old_res);
- CHECK(new_out == old_out);
- }
-}
-
-} // namespace
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- UTF8ToCheck(data, size);
- UTF16ToCheck(data, size);
- WideToCheck(data, size);
- return 0;
-}
diff --git a/base/synchronization/atomic_flag.cc b/base/synchronization/atomic_flag.cc
deleted file mode 100644
index 6cc0e87..0000000
--- a/base/synchronization/atomic_flag.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/synchronization/atomic_flag.h"
-
-#include "base/logging.h"
-
-namespace base {
-
-AtomicFlag::AtomicFlag() {
-}
-
-void AtomicFlag::Set() {
- base::subtle::Release_Store(&flag_, 1);
-}
-
-bool AtomicFlag::IsSet() const {
- return base::subtle::Acquire_Load(&flag_) != 0;
-}
-
-void AtomicFlag::UnsafeResetForTesting() {
- base::subtle::Release_Store(&flag_, 0);
-}
-
-} // namespace base
diff --git a/base/synchronization/atomic_flag.h b/base/synchronization/atomic_flag.h
deleted file mode 100644
index d033054..0000000
--- a/base/synchronization/atomic_flag.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SYNCHRONIZATION_ATOMIC_FLAG_H_
-#define BASE_SYNCHRONIZATION_ATOMIC_FLAG_H_
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-
-namespace base {
-
-// A flag that can safely be set from one thread and read from other threads.
-//
-// This class IS NOT intended for synchronization between threads.
-class BASE_EXPORT AtomicFlag {
- public:
- AtomicFlag();
- ~AtomicFlag() = default;
-
- // Set the flag. Must always be called from the same sequence.
- void Set();
-
- // Returns true iff the flag was set. If this returns true, the current thread
- // is guaranteed to be synchronized with all memory operations on the sequence
- // which invoked Set() up until at least the first call to Set() on it.
- bool IsSet() const;
-
- // Resets the flag. Be careful when using this: callers might not expect
- // IsSet() to return false after returning true once.
- void UnsafeResetForTesting();
-
- private:
- base::subtle::Atomic32 flag_ = 0;
-
- DISALLOW_COPY_AND_ASSIGN(AtomicFlag);
-};
-
-} // namespace base
-
-#endif // BASE_SYNCHRONIZATION_ATOMIC_FLAG_H_
diff --git a/base/synchronization/cancellation_flag.h b/base/synchronization/cancellation_flag.h
deleted file mode 100644
index 39094e2..0000000
--- a/base/synchronization/cancellation_flag.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SYNCHRONIZATION_CANCELLATION_FLAG_H_
-#define BASE_SYNCHRONIZATION_CANCELLATION_FLAG_H_
-
-#include "base/synchronization/atomic_flag.h"
-
-namespace base {
-
-// Use inheritance instead of "using" to allow forward declaration of "class
-// CancellationFlag".
-// TODO(fdoray): Replace CancellationFlag with AtomicFlag throughout the
-// codebase and delete this file. crbug.com/630251
-class CancellationFlag : public AtomicFlag {};
-
-} // namespace base
-
-#endif // BASE_SYNCHRONIZATION_CANCELLATION_FLAG_H_
diff --git a/base/synchronization/spin_wait.h b/base/synchronization/spin_wait.h
deleted file mode 100644
index 9b147cd..0000000
--- a/base/synchronization/spin_wait.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file provides a macro ONLY for use in testing.
-// DO NOT USE IN PRODUCTION CODE. There are much better ways to wait.
-
-// This code is very helpful in testing multi-threaded code, without depending
-// on almost any primitives. This is especially helpful if you are testing
-// those primitive multi-threaded constructs.
-
-// We provide a simple one argument spin wait (for 1 second), and a generic
-// spin wait (for longer periods of time).
-
-#ifndef BASE_SYNCHRONIZATION_SPIN_WAIT_H_
-#define BASE_SYNCHRONIZATION_SPIN_WAIT_H_
-
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-
-// Provide a macro that will wait no longer than 1 second for an asynchronous
-// change is the value of an expression.
-// A typical use would be:
-//
-// SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(0 == f(x));
-//
-// The expression will be evaluated repeatedly until it is true, or until
-// the time (1 second) expires.
-// Since tests generally have a 5 second watch dog timer, this spin loop is
-// typically used to get the padding needed on a given test platform to assure
-// that the test passes, even if load varies, and external events vary.
-
-#define SPIN_FOR_1_SECOND_OR_UNTIL_TRUE(expression) \
- SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(base::TimeDelta::FromSeconds(1), \
- (expression))
-
-#define SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(delta, expression) do { \
- base::TimeTicks start = base::TimeTicks::Now(); \
- const base::TimeDelta kTimeout = delta; \
- while (!(expression)) { \
- if (kTimeout < base::TimeTicks::Now() - start) { \
- EXPECT_LE((base::TimeTicks::Now() - start).InMilliseconds(), \
- kTimeout.InMilliseconds()) << "Timed out"; \
- break; \
- } \
- base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50)); \
- } \
- } while (0)
-
-#endif // BASE_SYNCHRONIZATION_SPIN_WAIT_H_
diff --git a/base/synchronization/waitable_event_perftest.cc b/base/synchronization/waitable_event_perftest.cc
deleted file mode 100644
index 1888077..0000000
--- a/base/synchronization/waitable_event_perftest.cc
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/synchronization/waitable_event.h"
-
-#include <numeric>
-
-#include "base/threading/simple_thread.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/perf/perf_test.h"
-
-namespace base {
-
-namespace {
-
-class TraceWaitableEvent {
- public:
- TraceWaitableEvent(size_t samples)
- : event_(WaitableEvent::ResetPolicy::AUTOMATIC,
- WaitableEvent::InitialState::NOT_SIGNALED),
- samples_(samples) {
- signal_times_.reserve(samples);
- wait_times_.reserve(samples);
- }
-
- ~TraceWaitableEvent() = default;
-
- void Signal() {
- TimeTicks start = TimeTicks::Now();
- event_.Signal();
- signal_times_.push_back(TimeTicks::Now() - start);
- }
-
- void Wait() {
- TimeTicks start = TimeTicks::Now();
- event_.Wait();
- wait_times_.push_back(TimeTicks::Now() - start);
- }
-
- bool TimedWaitUntil(const TimeTicks& end_time) {
- TimeTicks start = TimeTicks::Now();
- bool signaled = event_.TimedWaitUntil(end_time);
- wait_times_.push_back(TimeTicks::Now() - start);
- return signaled;
- }
-
- bool IsSignaled() { return event_.IsSignaled(); }
-
- const std::vector<TimeDelta>& signal_times() const { return signal_times_; }
- const std::vector<TimeDelta>& wait_times() const { return wait_times_; }
- size_t samples() const { return samples_; }
-
- private:
- WaitableEvent event_;
-
- std::vector<TimeDelta> signal_times_;
- std::vector<TimeDelta> wait_times_;
-
- const size_t samples_;
-
- DISALLOW_COPY_AND_ASSIGN(TraceWaitableEvent);
-};
-
-class SignalerThread : public SimpleThread {
- public:
- SignalerThread(TraceWaitableEvent* waiter, TraceWaitableEvent* signaler)
- : SimpleThread("WaitableEventPerfTest signaler"),
- waiter_(waiter),
- signaler_(signaler) {}
-
- ~SignalerThread() override = default;
-
- void Run() override {
- while (!stop_event_.IsSignaled()) {
- if (waiter_)
- waiter_->Wait();
- if (signaler_)
- signaler_->Signal();
- }
- }
-
- // Signals the thread to stop on the next iteration of its loop (which
- // will happen immediately if no |waiter_| is present or is signaled.
- void RequestStop() { stop_event_.Signal(); }
-
- private:
- WaitableEvent stop_event_{WaitableEvent::ResetPolicy::MANUAL,
- WaitableEvent::InitialState::NOT_SIGNALED};
- TraceWaitableEvent* waiter_;
- TraceWaitableEvent* signaler_;
- DISALLOW_COPY_AND_ASSIGN(SignalerThread);
-};
-
-void PrintPerfWaitableEvent(const TraceWaitableEvent* event,
- const std::string& modifier,
- const std::string& trace) {
- TimeDelta signal_time = std::accumulate(
- event->signal_times().begin(), event->signal_times().end(), TimeDelta());
- TimeDelta wait_time = std::accumulate(event->wait_times().begin(),
- event->wait_times().end(), TimeDelta());
- perf_test::PrintResult(
- "signal_time", modifier, trace,
- static_cast<size_t>(signal_time.InNanoseconds()) / event->samples(),
- "ns/sample", true);
- perf_test::PrintResult(
- "wait_time", modifier, trace,
- static_cast<size_t>(wait_time.InNanoseconds()) / event->samples(),
- "ns/sample", true);
-}
-
-} // namespace
-
-TEST(WaitableEventPerfTest, SingleThread) {
- const size_t kSamples = 1000;
-
- TraceWaitableEvent event(kSamples);
-
- for (size_t i = 0; i < kSamples; ++i) {
- event.Signal();
- event.Wait();
- }
-
- PrintPerfWaitableEvent(&event, "", "singlethread-1000-samples");
-}
-
-TEST(WaitableEventPerfTest, MultipleThreads) {
- const size_t kSamples = 1000;
-
- TraceWaitableEvent waiter(kSamples);
- TraceWaitableEvent signaler(kSamples);
-
- // The other thread will wait and signal on the respective opposite events.
- SignalerThread thread(&signaler, &waiter);
- thread.Start();
-
- for (size_t i = 0; i < kSamples; ++i) {
- signaler.Signal();
- waiter.Wait();
- }
-
- // Signal the stop event and then make sure the signaler event it is
- // waiting on is also signaled.
- thread.RequestStop();
- signaler.Signal();
-
- thread.Join();
-
- PrintPerfWaitableEvent(&waiter, "_waiter", "multithread-1000-samples");
- PrintPerfWaitableEvent(&signaler, "_signaler", "multithread-1000-samples");
-}
-
-TEST(WaitableEventPerfTest, Throughput) {
- // Reserve a lot of sample space.
- const size_t kCapacity = 500000;
- TraceWaitableEvent event(kCapacity);
-
- SignalerThread thread(nullptr, &event);
- thread.Start();
-
- TimeTicks end_time = TimeTicks::Now() + TimeDelta::FromSeconds(1);
- size_t count = 0;
- while (event.TimedWaitUntil(end_time)) {
- ++count;
- }
-
- thread.RequestStop();
- thread.Join();
-
- perf_test::PrintResult("counts", "", "throughput", count, "signals", true);
- PrintPerfWaitableEvent(&event, "", "throughput");
-
- // Make sure that allocation didn't happen during the test.
- EXPECT_LE(event.signal_times().capacity(), kCapacity);
- EXPECT_LE(event.wait_times().capacity(), kCapacity);
-}
-
-} // namespace base
diff --git a/base/task/OWNERS b/base/task/OWNERS
deleted file mode 100644
index 0f3ad5e..0000000
--- a/base/task/OWNERS
+++ /dev/null
@@ -1,6 +0,0 @@
-fdoray@chromium.org
-gab@chromium.org
-robliao@chromium.org
-
-# TEAM: scheduler-dev@chromium.org
-# COMPONENT: Internals>TaskScheduler
diff --git a/base/task/README.md b/base/task/README.md
deleted file mode 100644
index 0db116a..0000000
--- a/base/task/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-This directory has the following layout (WIP):
-- base/task/: public APIs for posting tasks and managing task queues.
-- base/task/task_scheduler/: implementation of the TaskScheduler.
-- base/task/sequence_manager/: implementation of the SequenceManager.
-
-Apart from embedders explicitly managing a TaskScheduler and/or SequenceManager
-instance(s) for their process/threads, the vast majority of users should only
-need APIs in base/task/.
-
-Documentation:
-- [Threading and tasks](https://chromium.googlesource.com/chromium/src/+/lkcr/docs/threading_and_tasks.md)
-- [Callbacks](https://chromium.googlesource.com/chromium/src/+/lkcr/docs/callback.md)
diff --git a/base/task/cancelable_task_tracker.cc b/base/task/cancelable_task_tracker.cc
deleted file mode 100644
index f304da8..0000000
--- a/base/task/cancelable_task_tracker.cc
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/task/cancelable_task_tracker.h"
-
-#include <stddef.h>
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback_helpers.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/synchronization/cancellation_flag.h"
-#include "base/task_runner.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-
-namespace base {
-
-namespace {
-
-void RunIfNotCanceled(const CancellationFlag* flag, OnceClosure task) {
- if (!flag->IsSet())
- std::move(task).Run();
-}
-
-void RunIfNotCanceledThenUntrack(const CancellationFlag* flag,
- OnceClosure task,
- OnceClosure untrack) {
- RunIfNotCanceled(flag, std::move(task));
- std::move(untrack).Run();
-}
-
-bool IsCanceled(const CancellationFlag* flag,
- ScopedClosureRunner* cleanup_runner) {
- return flag->IsSet();
-}
-
-void RunAndDeleteFlag(OnceClosure closure, const CancellationFlag* flag) {
- std::move(closure).Run();
- delete flag;
-}
-
-void RunOrPostToTaskRunner(TaskRunner* task_runner, OnceClosure closure) {
- if (task_runner->RunsTasksInCurrentSequence())
- std::move(closure).Run();
- else
- task_runner->PostTask(FROM_HERE, std::move(closure));
-}
-
-} // namespace
-
-// static
-const CancelableTaskTracker::TaskId CancelableTaskTracker::kBadTaskId = 0;
-
-CancelableTaskTracker::CancelableTaskTracker()
- : next_id_(1),weak_factory_(this) {}
-
-CancelableTaskTracker::~CancelableTaskTracker() {
- DCHECK(sequence_checker_.CalledOnValidSequence());
-
- TryCancelAll();
-}
-
-CancelableTaskTracker::TaskId CancelableTaskTracker::PostTask(
- TaskRunner* task_runner,
- const Location& from_here,
- OnceClosure task) {
- DCHECK(sequence_checker_.CalledOnValidSequence());
-
- return PostTaskAndReply(task_runner, from_here, std::move(task), DoNothing());
-}
-
-CancelableTaskTracker::TaskId CancelableTaskTracker::PostTaskAndReply(
- TaskRunner* task_runner,
- const Location& from_here,
- OnceClosure task,
- OnceClosure reply) {
- DCHECK(sequence_checker_.CalledOnValidSequence());
-
- // We need a SequencedTaskRunnerHandle to run |reply|.
- DCHECK(SequencedTaskRunnerHandle::IsSet());
-
- // Owned by reply callback below.
- CancellationFlag* flag = new CancellationFlag();
-
- TaskId id = next_id_;
- next_id_++; // int64_t is big enough that we ignore the potential overflow.
-
- OnceClosure untrack_closure =
- BindOnce(&CancelableTaskTracker::Untrack, weak_factory_.GetWeakPtr(), id);
- bool success = task_runner->PostTaskAndReply(
- from_here, BindOnce(&RunIfNotCanceled, flag, std::move(task)),
- BindOnce(&RunIfNotCanceledThenUntrack, Owned(flag), std::move(reply),
- std::move(untrack_closure)));
-
- if (!success)
- return kBadTaskId;
-
- Track(id, flag);
- return id;
-}
-
-CancelableTaskTracker::TaskId CancelableTaskTracker::NewTrackedTaskId(
- IsCanceledCallback* is_canceled_cb) {
- DCHECK(sequence_checker_.CalledOnValidSequence());
- DCHECK(SequencedTaskRunnerHandle::IsSet());
-
- TaskId id = next_id_;
- next_id_++; // int64_t is big enough that we ignore the potential overflow.
-
- // Will be deleted by |untrack_and_delete_flag| after Untrack().
- CancellationFlag* flag = new CancellationFlag();
-
- OnceClosure untrack_and_delete_flag = BindOnce(
- &RunAndDeleteFlag,
- BindOnce(&CancelableTaskTracker::Untrack, weak_factory_.GetWeakPtr(), id),
- flag);
-
- // Will always run |untrack_and_delete_flag| on current sequence.
- ScopedClosureRunner* untrack_and_delete_flag_runner =
- new ScopedClosureRunner(BindOnce(
- &RunOrPostToTaskRunner, RetainedRef(SequencedTaskRunnerHandle::Get()),
- std::move(untrack_and_delete_flag)));
-
- *is_canceled_cb =
- Bind(&IsCanceled, flag, Owned(untrack_and_delete_flag_runner));
-
- Track(id, flag);
- return id;
-}
-
-void CancelableTaskTracker::TryCancel(TaskId id) {
- DCHECK(sequence_checker_.CalledOnValidSequence());
-
- const auto it = task_flags_.find(id);
- if (it == task_flags_.end()) {
- // Two possibilities:
- //
- // 1. The task has already been untracked.
- // 2. The TaskId is bad or unknown.
- //
- // Since this function is best-effort, it's OK to ignore these.
- return;
- }
- it->second->Set();
-}
-
-void CancelableTaskTracker::TryCancelAll() {
- DCHECK(sequence_checker_.CalledOnValidSequence());
- for (const auto& it : task_flags_)
- it.second->Set();
- weak_factory_.InvalidateWeakPtrs();
- task_flags_.clear();
-}
-
-bool CancelableTaskTracker::HasTrackedTasks() const {
- DCHECK(sequence_checker_.CalledOnValidSequence());
- return !task_flags_.empty();
-}
-
-void CancelableTaskTracker::Track(TaskId id, CancellationFlag* flag) {
- DCHECK(sequence_checker_.CalledOnValidSequence());
- bool success = task_flags_.insert(std::make_pair(id, flag)).second;
- DCHECK(success);
-}
-
-void CancelableTaskTracker::Untrack(TaskId id) {
- DCHECK(sequence_checker_.CalledOnValidSequence());
- size_t num = task_flags_.erase(id);
- DCHECK_EQ(1u, num);
-}
-
-} // namespace base
diff --git a/base/task/cancelable_task_tracker.h b/base/task/cancelable_task_tracker.h
deleted file mode 100644
index e5e6b5e..0000000
--- a/base/task/cancelable_task_tracker.h
+++ /dev/null
@@ -1,158 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// CancelableTaskTracker posts tasks (in the form of a Closure) to a
-// TaskRunner, and is able to cancel the task later if it's not needed
-// anymore. On destruction, CancelableTaskTracker will cancel all
-// tracked tasks.
-//
-// Each cancelable task can be associated with a reply (also a Closure). After
-// the task is run on the TaskRunner, |reply| will be posted back to
-// originating TaskRunner.
-//
-// NOTE:
-//
-// CancelableCallback (base/cancelable_callback.h) and WeakPtr binding are
-// preferred solutions for canceling a task. However, they don't support
-// cancelation from another sequence. This is sometimes a performance critical
-// requirement. E.g. We need to cancel database lookup task on DB thread when
-// user changes inputed text. If it is performance critical to do a best effort
-// cancelation of a task, then CancelableTaskTracker is appropriate, otherwise
-// use one of the other mechanisms.
-//
-// THREAD-SAFETY:
-//
-// 1. A CancelableTaskTracker object must be created, used, and destroyed on a
-// single sequence.
-//
-// 2. It's safe to destroy a CancelableTaskTracker while there are outstanding
-// tasks. This is commonly used to cancel all outstanding tasks.
-//
-// 3. The task is deleted on the target sequence, and the reply are deleted on
-// the originating sequence.
-//
-// 4. IsCanceledCallback can be run or deleted on any sequence.
-#ifndef BASE_TASK_CANCELABLE_TASK_TRACKER_H_
-#define BASE_TASK_CANCELABLE_TASK_TRACKER_H_
-
-#include <stdint.h>
-
-#include <utility>
-
-#include "base/base_export.h"
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/containers/small_map.h"
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/post_task_and_reply_with_result_internal.h"
-#include "base/sequence_checker.h"
-
-namespace base {
-
-class CancellationFlag;
-class Location;
-class TaskRunner;
-
-class BASE_EXPORT CancelableTaskTracker {
- public:
- // All values except kBadTaskId are valid.
- typedef int64_t TaskId;
- static const TaskId kBadTaskId;
-
- typedef Callback<bool()> IsCanceledCallback;
-
- CancelableTaskTracker();
-
- // Cancels all tracked tasks.
- ~CancelableTaskTracker();
-
- TaskId PostTask(TaskRunner* task_runner,
- const Location& from_here,
- OnceClosure task);
-
- TaskId PostTaskAndReply(TaskRunner* task_runner,
- const Location& from_here,
- OnceClosure task,
- OnceClosure reply);
-
- template <typename TaskReturnType, typename ReplyArgType>
- TaskId PostTaskAndReplyWithResult(TaskRunner* task_runner,
- const Location& from_here,
- OnceCallback<TaskReturnType()> task,
- OnceCallback<void(ReplyArgType)> reply) {
- TaskReturnType* result = new TaskReturnType();
- return PostTaskAndReply(
- task_runner, from_here,
- BindOnce(&internal::ReturnAsParamAdapter<TaskReturnType>,
- std::move(task), Unretained(result)),
- BindOnce(&internal::ReplyAdapter<TaskReturnType, ReplyArgType>,
- std::move(reply), Owned(result)));
- }
-
- // Callback version of PostTaskWithTraitsAndReplyWithResult above.
- // Though RepeatingCallback is convertible to OnceCallback, we need this since
- // we can not use template deduction and object conversion at once on the
- // overload resolution.
- // TODO(tzik): Update all callers of the Callback version to use OnceCallback.
- template <typename TaskReturnType, typename ReplyArgType>
- TaskId PostTaskAndReplyWithResult(TaskRunner* task_runner,
- const Location& from_here,
- Callback<TaskReturnType()> task,
- Callback<void(ReplyArgType)> reply) {
- return PostTaskAndReplyWithResult(
- task_runner, from_here,
- static_cast<OnceCallback<TaskReturnType()>>(std::move(task)),
- static_cast<OnceCallback<void(ReplyArgType)>>(std::move(reply)));
- }
-
- // Creates a tracked TaskId and an associated IsCanceledCallback. Client can
- // later call TryCancel() with the returned TaskId, and run |is_canceled_cb|
- // from any thread to check whether the TaskId is canceled.
- //
- // The returned task ID is tracked until the last copy of
- // |is_canceled_cb| is destroyed.
- //
- // Note. This function is used to address some special cancelation requirement
- // in existing code. You SHOULD NOT need this function in new code.
- TaskId NewTrackedTaskId(IsCanceledCallback* is_canceled_cb);
-
- // After calling this function, |task| and |reply| will not run. If the
- // cancelation happens when |task| is running or has finished running, |reply|
- // will not run. If |reply| is running or has finished running, cancellation
- // is a noop.
- //
- // Note. It's OK to cancel a |task| for more than once. The later calls are
- // noops.
- void TryCancel(TaskId id);
-
- // It's OK to call this function for more than once. The later calls are
- // noops.
- void TryCancelAll();
-
- // Returns true iff there are in-flight tasks that are still being
- // tracked.
- bool HasTrackedTasks() const;
-
- private:
- void Track(TaskId id, CancellationFlag* flag);
- void Untrack(TaskId id);
-
- // Typically the number of tasks are 0-2 and occationally 3-4. But since
- // this is a general API that could be used in unexpected ways, use a
- // small_map instead of a flat_map to avoid falling over if there are many
- // tasks.
- small_map<std::map<TaskId, CancellationFlag*>, 4> task_flags_;
-
- TaskId next_id_;
- SequenceChecker sequence_checker_;
-
- WeakPtrFactory<CancelableTaskTracker> weak_factory_;
-
- DISALLOW_COPY_AND_ASSIGN(CancelableTaskTracker);
-};
-
-} // namespace base
-
-#endif // BASE_TASK_CANCELABLE_TASK_TRACKER_H_
diff --git a/base/task/sequence_manager/OWNERS b/base/task/sequence_manager/OWNERS
deleted file mode 100644
index ac6eae8..0000000
--- a/base/task/sequence_manager/OWNERS
+++ /dev/null
@@ -1,6 +0,0 @@
-altimin@chromium.org
-alexclarke@chromium.org
-skyostil@chromium.org
-
-# TEAM: scheduler-dev@chromium.org
-# Component: Blink>Scheduling
diff --git a/base/task/task_scheduler/OWNERS b/base/task/task_scheduler/OWNERS
deleted file mode 100644
index 0f3ad5e..0000000
--- a/base/task/task_scheduler/OWNERS
+++ /dev/null
@@ -1,6 +0,0 @@
-fdoray@chromium.org
-gab@chromium.org
-robliao@chromium.org
-
-# TEAM: scheduler-dev@chromium.org
-# COMPONENT: Internals>TaskScheduler
diff --git a/base/third_party/nspr/LICENSE b/base/third_party/nspr/LICENSE
deleted file mode 100644
index eba7b77..0000000
--- a/base/third_party/nspr/LICENSE
+++ /dev/null
@@ -1,35 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is the Netscape Portable Runtime (NSPR).
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998-2000
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
diff --git a/base/third_party/nspr/OWNERS b/base/third_party/nspr/OWNERS
deleted file mode 100644
index 20ba660..0000000
--- a/base/third_party/nspr/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-rsleevi@chromium.org
-wtc@chromium.org
diff --git a/base/third_party/nspr/README.chromium b/base/third_party/nspr/README.chromium
deleted file mode 100644
index 3659a2c..0000000
--- a/base/third_party/nspr/README.chromium
+++ /dev/null
@@ -1,3 +0,0 @@
-Name: Netscape Portable Runtime (NSPR)
-URL: http://www.mozilla.org/projects/nspr/
-License: MPL 1.1/GPL 2.0/LGPL 2.1
diff --git a/base/third_party/nspr/prtime.cc b/base/third_party/nspr/prtime.cc
deleted file mode 100644
index 8a3f7c0..0000000
--- a/base/third_party/nspr/prtime.cc
+++ /dev/null
@@ -1,1186 +0,0 @@
-/* Portions are Copyright (C) 2011 Google Inc */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is the Netscape Portable Runtime (NSPR).
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998-2000
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-/*
- * prtime.cc --
- * NOTE: The original nspr file name is prtime.c
- *
- * NSPR date and time functions
- *
- * CVS revision 3.37
- */
-
-/*
- * The following functions were copied from the NSPR prtime.c file.
- * PR_ParseTimeString
- * We inlined the new PR_ParseTimeStringToExplodedTime function to avoid
- * copying PR_ExplodeTime and PR_LocalTimeParameters. (The PR_ExplodeTime
- * and PR_ImplodeTime calls cancel each other out.)
- * PR_NormalizeTime
- * PR_GMTParameters
- * PR_ImplodeTime
- * Upstream implementation from
- * http://lxr.mozilla.org/nspr/source/pr/src/misc/prtime.c#221
- * All types and macros are defined in the base/third_party/prtime.h file.
- * These have been copied from the following nspr files. We have only copied
- * over the types we need.
- * 1. prtime.h
- * 2. prtypes.h
- * 3. prlong.h
- *
- * Unit tests are in base/time/pr_time_unittest.cc.
- */
-
-#include <limits.h>
-
-#include "base/logging.h"
-#include "base/third_party/nspr/prtime.h"
-#include "build_config.h"
-
-#include <errno.h> /* for EINVAL */
-#include <time.h>
-
-/*
- * The COUNT_LEAPS macro counts the number of leap years passed by
- * till the start of the given year Y. At the start of the year 4
- * A.D. the number of leap years passed by is 0, while at the start of
- * the year 5 A.D. this count is 1. The number of years divisible by
- * 100 but not divisible by 400 (the non-leap years) is deducted from
- * the count to get the correct number of leap years.
- *
- * The COUNT_DAYS macro counts the number of days since 01/01/01 till the
- * start of the given year Y. The number of days at the start of the year
- * 1 is 0 while the number of days at the start of the year 2 is 365
- * (which is ((2)-1) * 365) and so on. The reference point is 01/01/01
- * midnight 00:00:00.
- */
-
-#define COUNT_LEAPS(Y) (((Y)-1) / 4 - ((Y)-1) / 100 + ((Y)-1) / 400)
-#define COUNT_DAYS(Y) (((Y)-1) * 365 + COUNT_LEAPS(Y))
-#define DAYS_BETWEEN_YEARS(A, B) (COUNT_DAYS(B) - COUNT_DAYS(A))
-
-/* Implements the Unix localtime_r() function for windows */
-#if defined(OS_WIN)
-static void localtime_r(const time_t* secs, struct tm* time) {
- (void) localtime_s(time, secs);
-}
-#endif
-
-/*
- * Static variables used by functions in this file
- */
-
-/*
- * The following array contains the day of year for the last day of
- * each month, where index 1 is January, and day 0 is January 1.
- */
-
-static const int lastDayOfMonth[2][13] = {
- {-1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333, 364},
- {-1, 30, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}
-};
-
-/*
- * The number of days in a month
- */
-
-static const PRInt8 nDays[2][12] = {
- {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
- {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
-};
-
-/*
- *------------------------------------------------------------------------
- *
- * PR_ImplodeTime --
- *
- * Cf. time_t mktime(struct tm *tp)
- * Note that 1 year has < 2^25 seconds. So an PRInt32 is large enough.
- *
- *------------------------------------------------------------------------
- */
-PRTime
-PR_ImplodeTime(const PRExplodedTime *exploded)
-{
- PRExplodedTime copy;
- PRTime retVal;
- PRInt64 secPerDay, usecPerSec;
- PRInt64 temp;
- PRInt64 numSecs64;
- PRInt32 numDays;
- PRInt32 numSecs;
-
- /* Normalize first. Do this on our copy */
- copy = *exploded;
- PR_NormalizeTime(©, PR_GMTParameters);
-
- numDays = DAYS_BETWEEN_YEARS(1970, copy.tm_year);
-
- numSecs = copy.tm_yday * 86400 + copy.tm_hour * 3600 + copy.tm_min * 60 +
- copy.tm_sec;
-
- LL_I2L(temp, numDays);
- LL_I2L(secPerDay, 86400);
- LL_MUL(temp, temp, secPerDay);
- LL_I2L(numSecs64, numSecs);
- LL_ADD(numSecs64, numSecs64, temp);
-
- /* apply the GMT and DST offsets */
- LL_I2L(temp, copy.tm_params.tp_gmt_offset);
- LL_SUB(numSecs64, numSecs64, temp);
- LL_I2L(temp, copy.tm_params.tp_dst_offset);
- LL_SUB(numSecs64, numSecs64, temp);
-
- LL_I2L(usecPerSec, 1000000L);
- LL_MUL(temp, numSecs64, usecPerSec);
- LL_I2L(retVal, copy.tm_usec);
- LL_ADD(retVal, retVal, temp);
-
- return retVal;
-}
-
-/*
- *-------------------------------------------------------------------------
- *
- * IsLeapYear --
- *
- * Returns 1 if the year is a leap year, 0 otherwise.
- *
- *-------------------------------------------------------------------------
- */
-
-static int IsLeapYear(PRInt16 year)
-{
- if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
- return 1;
- else
- return 0;
-}
-
-/*
- * 'secOffset' should be less than 86400 (i.e., a day).
- * 'time' should point to a normalized PRExplodedTime.
- */
-
-static void
-ApplySecOffset(PRExplodedTime *time, PRInt32 secOffset)
-{
- time->tm_sec += secOffset;
-
- /* Note that in this implementation we do not count leap seconds */
- if (time->tm_sec < 0 || time->tm_sec >= 60) {
- time->tm_min += time->tm_sec / 60;
- time->tm_sec %= 60;
- if (time->tm_sec < 0) {
- time->tm_sec += 60;
- time->tm_min--;
- }
- }
-
- if (time->tm_min < 0 || time->tm_min >= 60) {
- time->tm_hour += time->tm_min / 60;
- time->tm_min %= 60;
- if (time->tm_min < 0) {
- time->tm_min += 60;
- time->tm_hour--;
- }
- }
-
- if (time->tm_hour < 0) {
- /* Decrement mday, yday, and wday */
- time->tm_hour += 24;
- time->tm_mday--;
- time->tm_yday--;
- if (time->tm_mday < 1) {
- time->tm_month--;
- if (time->tm_month < 0) {
- time->tm_month = 11;
- time->tm_year--;
- if (IsLeapYear(time->tm_year))
- time->tm_yday = 365;
- else
- time->tm_yday = 364;
- }
- time->tm_mday = nDays[IsLeapYear(time->tm_year)][time->tm_month];
- }
- time->tm_wday--;
- if (time->tm_wday < 0)
- time->tm_wday = 6;
- } else if (time->tm_hour > 23) {
- /* Increment mday, yday, and wday */
- time->tm_hour -= 24;
- time->tm_mday++;
- time->tm_yday++;
- if (time->tm_mday >
- nDays[IsLeapYear(time->tm_year)][time->tm_month]) {
- time->tm_mday = 1;
- time->tm_month++;
- if (time->tm_month > 11) {
- time->tm_month = 0;
- time->tm_year++;
- time->tm_yday = 0;
- }
- }
- time->tm_wday++;
- if (time->tm_wday > 6)
- time->tm_wday = 0;
- }
-}
-
-void
-PR_NormalizeTime(PRExplodedTime *time, PRTimeParamFn params)
-{
- int daysInMonth;
- PRInt32 numDays;
-
- /* Get back to GMT */
- time->tm_sec -= time->tm_params.tp_gmt_offset
- + time->tm_params.tp_dst_offset;
- time->tm_params.tp_gmt_offset = 0;
- time->tm_params.tp_dst_offset = 0;
-
- /* Now normalize GMT */
-
- if (time->tm_usec < 0 || time->tm_usec >= 1000000) {
- time->tm_sec += time->tm_usec / 1000000;
- time->tm_usec %= 1000000;
- if (time->tm_usec < 0) {
- time->tm_usec += 1000000;
- time->tm_sec--;
- }
- }
-
- /* Note that we do not count leap seconds in this implementation */
- if (time->tm_sec < 0 || time->tm_sec >= 60) {
- time->tm_min += time->tm_sec / 60;
- time->tm_sec %= 60;
- if (time->tm_sec < 0) {
- time->tm_sec += 60;
- time->tm_min--;
- }
- }
-
- if (time->tm_min < 0 || time->tm_min >= 60) {
- time->tm_hour += time->tm_min / 60;
- time->tm_min %= 60;
- if (time->tm_min < 0) {
- time->tm_min += 60;
- time->tm_hour--;
- }
- }
-
- if (time->tm_hour < 0 || time->tm_hour >= 24) {
- time->tm_mday += time->tm_hour / 24;
- time->tm_hour %= 24;
- if (time->tm_hour < 0) {
- time->tm_hour += 24;
- time->tm_mday--;
- }
- }
-
- /* Normalize month and year before mday */
- if (time->tm_month < 0 || time->tm_month >= 12) {
- time->tm_year += static_cast<PRInt16>(time->tm_month / 12);
- time->tm_month %= 12;
- if (time->tm_month < 0) {
- time->tm_month += 12;
- time->tm_year--;
- }
- }
-
- /* Now that month and year are in proper range, normalize mday */
-
- if (time->tm_mday < 1) {
- /* mday too small */
- do {
- /* the previous month */
- time->tm_month--;
- if (time->tm_month < 0) {
- time->tm_month = 11;
- time->tm_year--;
- }
- time->tm_mday += nDays[IsLeapYear(time->tm_year)][time->tm_month];
- } while (time->tm_mday < 1);
- } else {
- daysInMonth = nDays[IsLeapYear(time->tm_year)][time->tm_month];
- while (time->tm_mday > daysInMonth) {
- /* mday too large */
- time->tm_mday -= daysInMonth;
- time->tm_month++;
- if (time->tm_month > 11) {
- time->tm_month = 0;
- time->tm_year++;
- }
- daysInMonth = nDays[IsLeapYear(time->tm_year)][time->tm_month];
- }
- }
-
- /* Recompute yday and wday */
- time->tm_yday = static_cast<PRInt16>(time->tm_mday +
- lastDayOfMonth[IsLeapYear(time->tm_year)][time->tm_month]);
-
- numDays = DAYS_BETWEEN_YEARS(1970, time->tm_year) + time->tm_yday;
- time->tm_wday = (numDays + 4) % 7;
- if (time->tm_wday < 0) {
- time->tm_wday += 7;
- }
-
- /* Recompute time parameters */
-
- time->tm_params = params(time);
-
- ApplySecOffset(time, time->tm_params.tp_gmt_offset
- + time->tm_params.tp_dst_offset);
-}
-
-/*
- *------------------------------------------------------------------------
- *
- * PR_GMTParameters --
- *
- * Returns the PRTimeParameters for Greenwich Mean Time.
- * Trivially, both the tp_gmt_offset and tp_dst_offset fields are 0.
- *
- *------------------------------------------------------------------------
- */
-
-PRTimeParameters
-PR_GMTParameters(const PRExplodedTime *gmt)
-{
- PRTimeParameters retVal = { 0, 0 };
- return retVal;
-}
-
-/*
- * The following code implements PR_ParseTimeString(). It is based on
- * ns/lib/xp/xp_time.c, revision 1.25, by Jamie Zawinski <jwz@netscape.com>.
- */
-
-/*
- * We only recognize the abbreviations of a small subset of time zones
- * in North America, Europe, and Japan.
- *
- * PST/PDT: Pacific Standard/Daylight Time
- * MST/MDT: Mountain Standard/Daylight Time
- * CST/CDT: Central Standard/Daylight Time
- * EST/EDT: Eastern Standard/Daylight Time
- * AST: Atlantic Standard Time
- * NST: Newfoundland Standard Time
- * GMT: Greenwich Mean Time
- * BST: British Summer Time
- * MET: Middle Europe Time
- * EET: Eastern Europe Time
- * JST: Japan Standard Time
- */
-
-typedef enum
-{
- TT_UNKNOWN,
-
- TT_SUN, TT_MON, TT_TUE, TT_WED, TT_THU, TT_FRI, TT_SAT,
-
- TT_JAN, TT_FEB, TT_MAR, TT_APR, TT_MAY, TT_JUN,
- TT_JUL, TT_AUG, TT_SEP, TT_OCT, TT_NOV, TT_DEC,
-
- TT_PST, TT_PDT, TT_MST, TT_MDT, TT_CST, TT_CDT, TT_EST, TT_EDT,
- TT_AST, TT_NST, TT_GMT, TT_BST, TT_MET, TT_EET, TT_JST
-} TIME_TOKEN;
-
-/*
- * This parses a time/date string into a PRTime
- * (microseconds after "1-Jan-1970 00:00:00 GMT").
- * It returns PR_SUCCESS on success, and PR_FAILURE
- * if the time/date string can't be parsed.
- *
- * Many formats are handled, including:
- *
- * 14 Apr 89 03:20:12
- * 14 Apr 89 03:20 GMT
- * Fri, 17 Mar 89 4:01:33
- * Fri, 17 Mar 89 4:01 GMT
- * Mon Jan 16 16:12 PDT 1989
- * Mon Jan 16 16:12 +0130 1989
- * 6 May 1992 16:41-JST (Wednesday)
- * 22-AUG-1993 10:59:12.82
- * 22-AUG-1993 10:59pm
- * 22-AUG-1993 12:59am
- * 22-AUG-1993 12:59 PM
- * Friday, August 04, 1995 3:54 PM
- * 06/21/95 04:24:34 PM
- * 20/06/95 21:07
- * 95-06-08 19:32:48 EDT
- * 1995-06-17T23:11:25.342156Z
- *
- * If the input string doesn't contain a description of the timezone,
- * we consult the `default_to_gmt' to decide whether the string should
- * be interpreted relative to the local time zone (PR_FALSE) or GMT (PR_TRUE).
- * The correct value for this argument depends on what standard specified
- * the time string which you are parsing.
- */
-
-PRStatus
-PR_ParseTimeString(
- const char *string,
- PRBool default_to_gmt,
- PRTime *result_imploded)
-{
- PRExplodedTime tm;
- PRExplodedTime *result = &tm;
- TIME_TOKEN dotw = TT_UNKNOWN;
- TIME_TOKEN month = TT_UNKNOWN;
- TIME_TOKEN zone = TT_UNKNOWN;
- int zone_offset = -1;
- int dst_offset = 0;
- int date = -1;
- PRInt32 year = -1;
- int hour = -1;
- int min = -1;
- int sec = -1;
- int usec = -1;
-
- const char *rest = string;
-
- int iterations = 0;
-
- PR_ASSERT(string && result);
- if (!string || !result) return PR_FAILURE;
-
- while (*rest)
- {
-
- if (iterations++ > 1000)
- {
- return PR_FAILURE;
- }
-
- switch (*rest)
- {
- case 'a': case 'A':
- if (month == TT_UNKNOWN &&
- (rest[1] == 'p' || rest[1] == 'P') &&
- (rest[2] == 'r' || rest[2] == 'R'))
- month = TT_APR;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_AST;
- else if (month == TT_UNKNOWN &&
- (rest[1] == 'u' || rest[1] == 'U') &&
- (rest[2] == 'g' || rest[2] == 'G'))
- month = TT_AUG;
- break;
- case 'b': case 'B':
- if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_BST;
- break;
- case 'c': case 'C':
- if (zone == TT_UNKNOWN &&
- (rest[1] == 'd' || rest[1] == 'D') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_CDT;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_CST;
- break;
- case 'd': case 'D':
- if (month == TT_UNKNOWN &&
- (rest[1] == 'e' || rest[1] == 'E') &&
- (rest[2] == 'c' || rest[2] == 'C'))
- month = TT_DEC;
- break;
- case 'e': case 'E':
- if (zone == TT_UNKNOWN &&
- (rest[1] == 'd' || rest[1] == 'D') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_EDT;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 'e' || rest[1] == 'E') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_EET;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_EST;
- break;
- case 'f': case 'F':
- if (month == TT_UNKNOWN &&
- (rest[1] == 'e' || rest[1] == 'E') &&
- (rest[2] == 'b' || rest[2] == 'B'))
- month = TT_FEB;
- else if (dotw == TT_UNKNOWN &&
- (rest[1] == 'r' || rest[1] == 'R') &&
- (rest[2] == 'i' || rest[2] == 'I'))
- dotw = TT_FRI;
- break;
- case 'g': case 'G':
- if (zone == TT_UNKNOWN &&
- (rest[1] == 'm' || rest[1] == 'M') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_GMT;
- break;
- case 'j': case 'J':
- if (month == TT_UNKNOWN &&
- (rest[1] == 'a' || rest[1] == 'A') &&
- (rest[2] == 'n' || rest[2] == 'N'))
- month = TT_JAN;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_JST;
- else if (month == TT_UNKNOWN &&
- (rest[1] == 'u' || rest[1] == 'U') &&
- (rest[2] == 'l' || rest[2] == 'L'))
- month = TT_JUL;
- else if (month == TT_UNKNOWN &&
- (rest[1] == 'u' || rest[1] == 'U') &&
- (rest[2] == 'n' || rest[2] == 'N'))
- month = TT_JUN;
- break;
- case 'm': case 'M':
- if (month == TT_UNKNOWN &&
- (rest[1] == 'a' || rest[1] == 'A') &&
- (rest[2] == 'r' || rest[2] == 'R'))
- month = TT_MAR;
- else if (month == TT_UNKNOWN &&
- (rest[1] == 'a' || rest[1] == 'A') &&
- (rest[2] == 'y' || rest[2] == 'Y'))
- month = TT_MAY;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 'd' || rest[1] == 'D') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_MDT;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 'e' || rest[1] == 'E') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_MET;
- else if (dotw == TT_UNKNOWN &&
- (rest[1] == 'o' || rest[1] == 'O') &&
- (rest[2] == 'n' || rest[2] == 'N'))
- dotw = TT_MON;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_MST;
- break;
- case 'n': case 'N':
- if (month == TT_UNKNOWN &&
- (rest[1] == 'o' || rest[1] == 'O') &&
- (rest[2] == 'v' || rest[2] == 'V'))
- month = TT_NOV;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_NST;
- break;
- case 'o': case 'O':
- if (month == TT_UNKNOWN &&
- (rest[1] == 'c' || rest[1] == 'C') &&
- (rest[2] == 't' || rest[2] == 'T'))
- month = TT_OCT;
- break;
- case 'p': case 'P':
- if (zone == TT_UNKNOWN &&
- (rest[1] == 'd' || rest[1] == 'D') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_PDT;
- else if (zone == TT_UNKNOWN &&
- (rest[1] == 's' || rest[1] == 'S') &&
- (rest[2] == 't' || rest[2] == 'T'))
- zone = TT_PST;
- break;
- case 's': case 'S':
- if (dotw == TT_UNKNOWN &&
- (rest[1] == 'a' || rest[1] == 'A') &&
- (rest[2] == 't' || rest[2] == 'T'))
- dotw = TT_SAT;
- else if (month == TT_UNKNOWN &&
- (rest[1] == 'e' || rest[1] == 'E') &&
- (rest[2] == 'p' || rest[2] == 'P'))
- month = TT_SEP;
- else if (dotw == TT_UNKNOWN &&
- (rest[1] == 'u' || rest[1] == 'U') &&
- (rest[2] == 'n' || rest[2] == 'N'))
- dotw = TT_SUN;
- break;
- case 't': case 'T':
- if (dotw == TT_UNKNOWN &&
- (rest[1] == 'h' || rest[1] == 'H') &&
- (rest[2] == 'u' || rest[2] == 'U'))
- dotw = TT_THU;
- else if (dotw == TT_UNKNOWN &&
- (rest[1] == 'u' || rest[1] == 'U') &&
- (rest[2] == 'e' || rest[2] == 'E'))
- dotw = TT_TUE;
- break;
- case 'u': case 'U':
- if (zone == TT_UNKNOWN &&
- (rest[1] == 't' || rest[1] == 'T') &&
- !(rest[2] >= 'A' && rest[2] <= 'Z') &&
- !(rest[2] >= 'a' && rest[2] <= 'z'))
- /* UT is the same as GMT but UTx is not. */
- zone = TT_GMT;
- break;
- case 'w': case 'W':
- if (dotw == TT_UNKNOWN &&
- (rest[1] == 'e' || rest[1] == 'E') &&
- (rest[2] == 'd' || rest[2] == 'D'))
- dotw = TT_WED;
- break;
-
- case '+': case '-':
- {
- const char *end;
- int sign;
- if (zone_offset != -1)
- {
- /* already got one... */
- rest++;
- break;
- }
- if (zone != TT_UNKNOWN && zone != TT_GMT)
- {
- /* GMT+0300 is legal, but PST+0300 is not. */
- rest++;
- break;
- }
-
- sign = ((*rest == '+') ? 1 : -1);
- rest++; /* move over sign */
- end = rest;
- while (*end >= '0' && *end <= '9')
- end++;
- if (rest == end) /* no digits here */
- break;
-
- if ((end - rest) == 4)
- /* offset in HHMM */
- zone_offset = (((((rest[0]-'0')*10) + (rest[1]-'0')) * 60) +
- (((rest[2]-'0')*10) + (rest[3]-'0')));
- else if ((end - rest) == 2)
- /* offset in hours */
- zone_offset = (((rest[0]-'0')*10) + (rest[1]-'0')) * 60;
- else if ((end - rest) == 1)
- /* offset in hours */
- zone_offset = (rest[0]-'0') * 60;
- else
- /* 3 or >4 */
- break;
-
- zone_offset *= sign;
- zone = TT_GMT;
- break;
- }
-
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- {
- int tmp_hour = -1;
- int tmp_min = -1;
- int tmp_sec = -1;
- int tmp_usec = -1;
- const char *end = rest + 1;
- while (*end >= '0' && *end <= '9')
- end++;
-
- /* end is now the first character after a range of digits. */
-
- if (*end == ':')
- {
- if (hour >= 0 && min >= 0) /* already got it */
- break;
-
- /* We have seen "[0-9]+:", so this is probably HH:MM[:SS] */
- if ((end - rest) > 2)
- /* it is [0-9][0-9][0-9]+: */
- break;
- else if ((end - rest) == 2)
- tmp_hour = ((rest[0]-'0')*10 +
- (rest[1]-'0'));
- else
- tmp_hour = (rest[0]-'0');
-
- /* move over the colon, and parse minutes */
-
- rest = ++end;
- while (*end >= '0' && *end <= '9')
- end++;
-
- if (end == rest)
- /* no digits after first colon? */
- break;
- else if ((end - rest) > 2)
- /* it is [0-9][0-9][0-9]+: */
- break;
- else if ((end - rest) == 2)
- tmp_min = ((rest[0]-'0')*10 +
- (rest[1]-'0'));
- else
- tmp_min = (rest[0]-'0');
-
- /* now go for seconds */
- rest = end;
- if (*rest == ':')
- rest++;
- end = rest;
- while (*end >= '0' && *end <= '9')
- end++;
-
- if (end == rest)
- /* no digits after second colon - that's ok. */
- ;
- else if ((end - rest) > 2)
- /* it is [0-9][0-9][0-9]+: */
- break;
- else if ((end - rest) == 2)
- tmp_sec = ((rest[0]-'0')*10 +
- (rest[1]-'0'));
- else
- tmp_sec = (rest[0]-'0');
-
- /* fractional second */
- rest = end;
- if (*rest == '.')
- {
- rest++;
- end++;
- tmp_usec = 0;
- /* use up to 6 digits, skip over the rest */
- while (*end >= '0' && *end <= '9')
- {
- if (end - rest < 6)
- tmp_usec = tmp_usec * 10 + *end - '0';
- end++;
- }
- int ndigits = end - rest;
- while (ndigits++ < 6)
- tmp_usec *= 10;
- rest = end;
- }
-
- if (*rest == 'Z')
- {
- zone = TT_GMT;
- rest++;
- }
- else if (tmp_hour <= 12)
- {
- /* If we made it here, we've parsed hour and min,
- and possibly sec, so the current token is a time.
- Now skip over whitespace and see if there's an AM
- or PM directly following the time.
- */
- const char *s = end;
- while (*s && (*s == ' ' || *s == '\t'))
- s++;
- if ((s[0] == 'p' || s[0] == 'P') &&
- (s[1] == 'm' || s[1] == 'M'))
- /* 10:05pm == 22:05, and 12:05pm == 12:05 */
- tmp_hour = (tmp_hour == 12 ? 12 : tmp_hour + 12);
- else if (tmp_hour == 12 &&
- (s[0] == 'a' || s[0] == 'A') &&
- (s[1] == 'm' || s[1] == 'M'))
- /* 12:05am == 00:05 */
- tmp_hour = 0;
- }
-
- hour = tmp_hour;
- min = tmp_min;
- sec = tmp_sec;
- usec = tmp_usec;
- rest = end;
- break;
- }
- else if ((*end == '/' || *end == '-') &&
- end[1] >= '0' && end[1] <= '9')
- {
- /* Perhaps this is 6/16/95, 16/6/95, 6-16-95, or 16-6-95
- or even 95-06-05 or 1995-06-22.
- */
- int n1, n2, n3;
- const char *s;
-
- if (month != TT_UNKNOWN)
- /* if we saw a month name, this can't be. */
- break;
-
- s = rest;
-
- n1 = (*s++ - '0'); /* first 1, 2 or 4 digits */
- if (*s >= '0' && *s <= '9')
- {
- n1 = n1*10 + (*s++ - '0');
-
- if (*s >= '0' && *s <= '9') /* optional digits 3 and 4 */
- {
- n1 = n1*10 + (*s++ - '0');
- if (*s < '0' || *s > '9')
- break;
- n1 = n1*10 + (*s++ - '0');
- }
- }
-
- if (*s != '/' && *s != '-') /* slash */
- break;
- s++;
-
- if (*s < '0' || *s > '9') /* second 1 or 2 digits */
- break;
- n2 = (*s++ - '0');
- if (*s >= '0' && *s <= '9')
- n2 = n2*10 + (*s++ - '0');
-
- if (*s != '/' && *s != '-') /* slash */
- break;
- s++;
-
- if (*s < '0' || *s > '9') /* third 1, 2, 4, or 5 digits */
- break;
- n3 = (*s++ - '0');
- if (*s >= '0' && *s <= '9')
- n3 = n3*10 + (*s++ - '0');
-
- if (*s >= '0' && *s <= '9') /* optional digits 3, 4, and 5 */
- {
- n3 = n3*10 + (*s++ - '0');
- if (*s < '0' || *s > '9')
- break;
- n3 = n3*10 + (*s++ - '0');
- if (*s >= '0' && *s <= '9')
- n3 = n3*10 + (*s++ - '0');
- }
-
- if (*s == 'T' && s[1] >= '0' && s[1] <= '9')
- /* followed by ISO 8601 T delimiter and number is ok */
- ;
- else if ((*s >= '0' && *s <= '9') ||
- (*s >= 'A' && *s <= 'Z') ||
- (*s >= 'a' && *s <= 'z'))
- /* but other alphanumerics are not ok */
- break;
-
- /* Ok, we parsed three multi-digit numbers, with / or -
- between them. Now decide what the hell they are
- (DD/MM/YY or MM/DD/YY or [YY]YY/MM/DD.)
- */
-
- if (n1 > 31 || n1 == 0) /* must be [YY]YY/MM/DD */
- {
- if (n2 > 12) break;
- if (n3 > 31) break;
- year = n1;
- if (year < 70)
- year += 2000;
- else if (year < 100)
- year += 1900;
- month = (TIME_TOKEN)(n2 + ((int)TT_JAN) - 1);
- date = n3;
- rest = s;
- break;
- }
-
- if (n1 > 12 && n2 > 12) /* illegal */
- {
- rest = s;
- break;
- }
-
- if (n3 < 70)
- n3 += 2000;
- else if (n3 < 100)
- n3 += 1900;
-
- if (n1 > 12) /* must be DD/MM/YY */
- {
- date = n1;
- month = (TIME_TOKEN)(n2 + ((int)TT_JAN) - 1);
- year = n3;
- }
- else /* assume MM/DD/YY */
- {
- /* #### In the ambiguous case, should we consult the
- locale to find out the local default? */
- month = (TIME_TOKEN)(n1 + ((int)TT_JAN) - 1);
- date = n2;
- year = n3;
- }
- rest = s;
- }
- else if ((*end >= 'A' && *end <= 'Z') ||
- (*end >= 'a' && *end <= 'z'))
- /* Digits followed by non-punctuation - what's that? */
- ;
- else if ((end - rest) == 5) /* five digits is a year */
- year = (year < 0
- ? ((rest[0]-'0')*10000L +
- (rest[1]-'0')*1000L +
- (rest[2]-'0')*100L +
- (rest[3]-'0')*10L +
- (rest[4]-'0'))
- : year);
- else if ((end - rest) == 4) /* four digits is a year */
- year = (year < 0
- ? ((rest[0]-'0')*1000L +
- (rest[1]-'0')*100L +
- (rest[2]-'0')*10L +
- (rest[3]-'0'))
- : year);
- else if ((end - rest) == 2) /* two digits - date or year */
- {
- int n = ((rest[0]-'0')*10 +
- (rest[1]-'0'));
- /* If we don't have a date (day of the month) and we see a number
- less than 32, then assume that is the date.
-
- Otherwise, if we have a date and not a year, assume this is the
- year. If it is less than 70, then assume it refers to the 21st
- century. If it is two digits (>= 70), assume it refers to this
- century. Otherwise, assume it refers to an unambiguous year.
-
- The world will surely end soon.
- */
- if (date < 0 && n < 32)
- date = n;
- else if (year < 0)
- {
- if (n < 70)
- year = 2000 + n;
- else if (n < 100)
- year = 1900 + n;
- else
- year = n;
- }
- /* else what the hell is this. */
- }
- else if ((end - rest) == 1) /* one digit - date */
- date = (date < 0 ? (rest[0]-'0') : date);
- /* else, three or more than five digits - what's that? */
-
- break;
- } /* case '0' .. '9' */
- } /* switch */
-
- /* Skip to the end of this token, whether we parsed it or not.
- Tokens are delimited by whitespace, or ,;-+/()[] but explicitly not .:
- 'T' is also treated as delimiter when followed by a digit (ISO 8601).
- */
- while (*rest &&
- *rest != ' ' && *rest != '\t' &&
- *rest != ',' && *rest != ';' &&
- *rest != '-' && *rest != '+' &&
- *rest != '/' &&
- *rest != '(' && *rest != ')' && *rest != '[' && *rest != ']' &&
- !(*rest == 'T' && rest[1] >= '0' && rest[1] <= '9')
- )
- rest++;
- /* skip over uninteresting chars. */
- SKIP_MORE:
- while (*rest == ' ' || *rest == '\t' ||
- *rest == ',' || *rest == ';' || *rest == '/' ||
- *rest == '(' || *rest == ')' || *rest == '[' || *rest == ']')
- rest++;
-
- /* "-" is ignored at the beginning of a token if we have not yet
- parsed a year (e.g., the second "-" in "30-AUG-1966"), or if
- the character after the dash is not a digit. */
- if (*rest == '-' && ((rest > string &&
- isalpha((unsigned char)rest[-1]) && year < 0) ||
- rest[1] < '0' || rest[1] > '9'))
- {
- rest++;
- goto SKIP_MORE;
- }
-
- /* Skip T that may precede ISO 8601 time. */
- if (*rest == 'T' && rest[1] >= '0' && rest[1] <= '9')
- rest++;
- } /* while */
-
- if (zone != TT_UNKNOWN && zone_offset == -1)
- {
- switch (zone)
- {
- case TT_PST: zone_offset = -8 * 60; break;
- case TT_PDT: zone_offset = -8 * 60; dst_offset = 1 * 60; break;
- case TT_MST: zone_offset = -7 * 60; break;
- case TT_MDT: zone_offset = -7 * 60; dst_offset = 1 * 60; break;
- case TT_CST: zone_offset = -6 * 60; break;
- case TT_CDT: zone_offset = -6 * 60; dst_offset = 1 * 60; break;
- case TT_EST: zone_offset = -5 * 60; break;
- case TT_EDT: zone_offset = -5 * 60; dst_offset = 1 * 60; break;
- case TT_AST: zone_offset = -4 * 60; break;
- case TT_NST: zone_offset = -3 * 60 - 30; break;
- case TT_GMT: zone_offset = 0 * 60; break;
- case TT_BST: zone_offset = 0 * 60; dst_offset = 1 * 60; break;
- case TT_MET: zone_offset = 1 * 60; break;
- case TT_EET: zone_offset = 2 * 60; break;
- case TT_JST: zone_offset = 9 * 60; break;
- default:
- PR_ASSERT (0);
- break;
- }
- }
-
- /* If we didn't find a year, month, or day-of-the-month, we can't
- possibly parse this, and in fact, mktime() will do something random
- (I'm seeing it return "Tue Feb 5 06:28:16 2036", which is no doubt
- a numerologically significant date... */
- if (month == TT_UNKNOWN || date == -1 || year == -1 || year > PR_INT16_MAX)
- return PR_FAILURE;
-
- memset(result, 0, sizeof(*result));
- if (usec != -1)
- result->tm_usec = usec;
- if (sec != -1)
- result->tm_sec = sec;
- if (min != -1)
- result->tm_min = min;
- if (hour != -1)
- result->tm_hour = hour;
- if (date != -1)
- result->tm_mday = date;
- if (month != TT_UNKNOWN)
- result->tm_month = (((int)month) - ((int)TT_JAN));
- if (year != -1)
- result->tm_year = static_cast<PRInt16>(year);
- if (dotw != TT_UNKNOWN)
- result->tm_wday = static_cast<PRInt8>(((int)dotw) - ((int)TT_SUN));
- /*
- * Mainly to compute wday and yday, but normalized time is also required
- * by the check below that works around a Visual C++ 2005 mktime problem.
- */
- PR_NormalizeTime(result, PR_GMTParameters);
- /* The remaining work is to set the gmt and dst offsets in tm_params. */
-
- if (zone == TT_UNKNOWN && default_to_gmt)
- {
- /* No zone was specified, so pretend the zone was GMT. */
- zone = TT_GMT;
- zone_offset = 0;
- }
-
- if (zone_offset == -1)
- {
- /* no zone was specified, and we're to assume that everything
- is local. */
- struct tm localTime;
- time_t secs;
-
- PR_ASSERT(result->tm_month > -1 &&
- result->tm_mday > 0 &&
- result->tm_hour > -1 &&
- result->tm_min > -1 &&
- result->tm_sec > -1);
-
- /*
- * To obtain time_t from a tm structure representing the local
- * time, we call mktime(). However, we need to see if we are
- * on 1-Jan-1970 or before. If we are, we can't call mktime()
- * because mktime() will crash on win16. In that case, we
- * calculate zone_offset based on the zone offset at
- * 00:00:00, 2 Jan 1970 GMT, and subtract zone_offset from the
- * date we are parsing to transform the date to GMT. We also
- * do so if mktime() returns (time_t) -1 (time out of range).
- */
-
- /* month, day, hours, mins and secs are always non-negative
- so we dont need to worry about them. */
- if (result->tm_year >= 1970)
- {
- localTime.tm_sec = result->tm_sec;
- localTime.tm_min = result->tm_min;
- localTime.tm_hour = result->tm_hour;
- localTime.tm_mday = result->tm_mday;
- localTime.tm_mon = result->tm_month;
- localTime.tm_year = result->tm_year - 1900;
- /* Set this to -1 to tell mktime "I don't care". If you set
- it to 0 or 1, you are making assertions about whether the
- date you are handing it is in daylight savings mode or not;
- and if you're wrong, it will "fix" it for you. */
- localTime.tm_isdst = -1;
-
-#if _MSC_VER == 1400 /* 1400 = Visual C++ 2005 (8.0) */
- /*
- * mktime will return (time_t) -1 if the input is a date
- * after 23:59:59, December 31, 3000, US Pacific Time (not
- * UTC as documented):
- * http://msdn.microsoft.com/en-us/library/d1y53h2a(VS.80).aspx
- * But if the year is 3001, mktime also invokes the invalid
- * parameter handler, causing the application to crash. This
- * problem has been reported in
- * http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=266036.
- * We avoid this crash by not calling mktime if the date is
- * out of range. To use a simple test that works in any time
- * zone, we consider year 3000 out of range as well. (See
- * bug 480740.)
- */
- if (result->tm_year >= 3000) {
- /* Emulate what mktime would have done. */
- errno = EINVAL;
- secs = (time_t) -1;
- } else {
- secs = mktime(&localTime);
- }
-#else
- secs = mktime(&localTime);
-#endif
- if (secs != (time_t) -1)
- {
- *result_imploded = (PRInt64)secs * PR_USEC_PER_SEC;
- *result_imploded += result->tm_usec;
- return PR_SUCCESS;
- }
- }
-
- /* So mktime() can't handle this case. We assume the
- zone_offset for the date we are parsing is the same as
- the zone offset on 00:00:00 2 Jan 1970 GMT. */
- secs = 86400;
- localtime_r(&secs, &localTime);
- zone_offset = localTime.tm_min
- + 60 * localTime.tm_hour
- + 1440 * (localTime.tm_mday - 2);
- }
-
- result->tm_params.tp_gmt_offset = zone_offset * 60;
- result->tm_params.tp_dst_offset = dst_offset * 60;
-
- *result_imploded = PR_ImplodeTime(result);
- return PR_SUCCESS;
-}
diff --git a/base/third_party/nspr/prtime.h b/base/third_party/nspr/prtime.h
deleted file mode 100644
index 20bae38..0000000
--- a/base/third_party/nspr/prtime.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/* Portions are Copyright (C) 2011 Google Inc */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is the Netscape Portable Runtime (NSPR).
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998-2000
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-/*
- *---------------------------------------------------------------------------
- *
- * prtime.h --
- *
- * NSPR date and time functions
- * CVS revision 3.10
- * This file contains definitions of NSPR's basic types required by
- * prtime.cc. These types have been copied over from the following NSPR
- * files prtime.h, prtypes.h(CVS revision 3.35), prlong.h(CVS revision 3.13)
- *
- *---------------------------------------------------------------------------
- */
-
-#ifndef BASE_PRTIME_H__
-#define BASE_PRTIME_H__
-
-#include <stdint.h>
-
-#include "base/base_export.h"
-
-typedef int8_t PRInt8;
-typedef int16_t PRInt16;
-typedef int32_t PRInt32;
-typedef int64_t PRInt64;
-typedef int PRIntn;
-
-typedef PRIntn PRBool;
-#define PR_TRUE 1
-#define PR_FALSE 0
-
-typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus;
-
-#define PR_ASSERT DCHECK
-#define PR_CALLBACK
-#define PR_INT16_MAX 32767
-#define NSPR_API(__type) extern __type
-
-/*
- * Long-long (64-bit signed integer type) support macros used by
- * PR_ImplodeTime().
- * See http://lxr.mozilla.org/nspr/source/pr/include/prlong.h
- */
-
-#define LL_I2L(l, i) ((l) = (PRInt64)(i))
-#define LL_MUL(r, a, b) ((r) = (a) * (b))
-#define LL_ADD(r, a, b) ((r) = (a) + (b))
-#define LL_SUB(r, a, b) ((r) = (a) - (b))
-
-/**********************************************************************/
-/************************* TYPES AND CONSTANTS ************************/
-/**********************************************************************/
-
-#define PR_MSEC_PER_SEC 1000UL
-#define PR_USEC_PER_SEC 1000000UL
-#define PR_NSEC_PER_SEC 1000000000UL
-#define PR_USEC_PER_MSEC 1000UL
-#define PR_NSEC_PER_MSEC 1000000UL
-
-/*
- * PRTime --
- *
- * NSPR represents basic time as 64-bit signed integers relative
- * to midnight (00:00:00), January 1, 1970 Greenwich Mean Time (GMT).
- * (GMT is also known as Coordinated Universal Time, UTC.)
- * The units of time are in microseconds. Negative times are allowed
- * to represent times prior to the January 1970 epoch. Such values are
- * intended to be exported to other systems or converted to human
- * readable form.
- *
- * Notes on porting: PRTime corresponds to time_t in ANSI C. NSPR 1.0
- * simply uses PRInt64.
- */
-
-typedef PRInt64 PRTime;
-
-/*
- * Time zone and daylight saving time corrections applied to GMT to
- * obtain the local time of some geographic location
- */
-
-typedef struct PRTimeParameters {
- PRInt32 tp_gmt_offset; /* the offset from GMT in seconds */
- PRInt32 tp_dst_offset; /* contribution of DST in seconds */
-} PRTimeParameters;
-
-/*
- * PRExplodedTime --
- *
- * Time broken down into human-readable components such as year, month,
- * day, hour, minute, second, and microsecond. Time zone and daylight
- * saving time corrections may be applied. If they are applied, the
- * offsets from the GMT must be saved in the 'tm_params' field so that
- * all the information is available to reconstruct GMT.
- *
- * Notes on porting: PRExplodedTime corrresponds to struct tm in
- * ANSI C, with the following differences:
- * - an additional field tm_usec;
- * - replacing tm_isdst by tm_params;
- * - the month field is spelled tm_month, not tm_mon;
- * - we use absolute year, AD, not the year since 1900.
- * The corresponding type in NSPR 1.0 is called PRTime. Below is
- * a table of date/time type correspondence in the three APIs:
- * API time since epoch time in components
- * ANSI C time_t struct tm
- * NSPR 1.0 PRInt64 PRTime
- * NSPR 2.0 PRTime PRExplodedTime
- */
-
-typedef struct PRExplodedTime {
- PRInt32 tm_usec; /* microseconds past tm_sec (0-99999) */
- PRInt32 tm_sec; /* seconds past tm_min (0-61, accomodating
- up to two leap seconds) */
- PRInt32 tm_min; /* minutes past tm_hour (0-59) */
- PRInt32 tm_hour; /* hours past tm_day (0-23) */
- PRInt32 tm_mday; /* days past tm_mon (1-31, note that it
- starts from 1) */
- PRInt32 tm_month; /* months past tm_year (0-11, Jan = 0) */
- PRInt16 tm_year; /* absolute year, AD (note that we do not
- count from 1900) */
-
- PRInt8 tm_wday; /* calculated day of the week
- (0-6, Sun = 0) */
- PRInt16 tm_yday; /* calculated day of the year
- (0-365, Jan 1 = 0) */
-
- PRTimeParameters tm_params; /* time parameters used by conversion */
-} PRExplodedTime;
-
-/*
- * PRTimeParamFn --
- *
- * A function of PRTimeParamFn type returns the time zone and
- * daylight saving time corrections for some geographic location,
- * given the current time in GMT. The input argument gmt should
- * point to a PRExplodedTime that is in GMT, i.e., whose
- * tm_params contains all 0's.
- *
- * For any time zone other than GMT, the computation is intended to
- * consist of two steps:
- * - Figure out the time zone correction, tp_gmt_offset. This number
- * usually depends on the geographic location only. But it may
- * also depend on the current time. For example, all of China
- * is one time zone right now. But this situation may change
- * in the future.
- * - Figure out the daylight saving time correction, tp_dst_offset.
- * This number depends on both the geographic location and the
- * current time. Most of the DST rules are expressed in local
- * current time. If so, one should apply the time zone correction
- * to GMT before applying the DST rules.
- */
-
-typedef PRTimeParameters (PR_CALLBACK *PRTimeParamFn)(const PRExplodedTime *gmt);
-
-/**********************************************************************/
-/****************************** FUNCTIONS *****************************/
-/**********************************************************************/
-
-NSPR_API(PRTime)
-PR_ImplodeTime(const PRExplodedTime *exploded);
-
-/*
- * Adjust exploded time to normalize field overflows after manipulation.
- * Note that the following fields of PRExplodedTime should not be
- * manipulated:
- * - tm_month and tm_year: because the number of days in a month and
- * number of days in a year are not constant, it is ambiguous to
- * manipulate the month and year fields, although one may be tempted
- * to. For example, what does "a month from January 31st" mean?
- * - tm_wday and tm_yday: these fields are calculated by NSPR. Users
- * should treat them as "read-only".
- */
-
-NSPR_API(void) PR_NormalizeTime(
- PRExplodedTime *exploded, PRTimeParamFn params);
-
-/**********************************************************************/
-/*********************** TIME PARAMETER FUNCTIONS *********************/
-/**********************************************************************/
-
-/* Time parameters that represent Greenwich Mean Time */
-NSPR_API(PRTimeParameters) PR_GMTParameters(const PRExplodedTime *gmt);
-
-/*
- * This parses a time/date string into a PRTime
- * (microseconds after "1-Jan-1970 00:00:00 GMT").
- * It returns PR_SUCCESS on success, and PR_FAILURE
- * if the time/date string can't be parsed.
- *
- * Many formats are handled, including:
- *
- * 14 Apr 89 03:20:12
- * 14 Apr 89 03:20 GMT
- * Fri, 17 Mar 89 4:01:33
- * Fri, 17 Mar 89 4:01 GMT
- * Mon Jan 16 16:12 PDT 1989
- * Mon Jan 16 16:12 +0130 1989
- * 6 May 1992 16:41-JST (Wednesday)
- * 22-AUG-1993 10:59:12.82
- * 22-AUG-1993 10:59pm
- * 22-AUG-1993 12:59am
- * 22-AUG-1993 12:59 PM
- * Friday, August 04, 1995 3:54 PM
- * 06/21/95 04:24:34 PM
- * 20/06/95 21:07
- * 95-06-08 19:32:48 EDT
- * 1995-06-17T23:11:25.342156Z
- *
- * If the input string doesn't contain a description of the timezone,
- * we consult the `default_to_gmt' to decide whether the string should
- * be interpreted relative to the local time zone (PR_FALSE) or GMT (PR_TRUE).
- * The correct value for this argument depends on what standard specified
- * the time string which you are parsing.
- */
-
-/*
- * This is the only funtion that should be called from outside base, and only
- * from the unit test.
- */
-
-BASE_EXPORT PRStatus PR_ParseTimeString (
- const char *string,
- PRBool default_to_gmt,
- PRTime *result);
-
-#endif // BASE_PRTIME_H__
diff --git a/base/threading/OWNERS b/base/threading/OWNERS
deleted file mode 100644
index 4198e99..0000000
--- a/base/threading/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-# For thread_resrictions.*
-jam@chromium.org
diff --git a/base/threading/thread_collision_warner.cc b/base/threading/thread_collision_warner.cc
deleted file mode 100644
index 547e11c..0000000
--- a/base/threading/thread_collision_warner.cc
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/threading/thread_collision_warner.h"
-
-#include "base/logging.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-void DCheckAsserter::warn() {
- NOTREACHED() << "Thread Collision";
-}
-
-static subtle::Atomic32 CurrentThread() {
- const PlatformThreadId current_thread_id = PlatformThread::CurrentId();
- // We need to get the thread id into an atomic data type. This might be a
- // truncating conversion, but any loss-of-information just increases the
- // chance of a fault negative, not a false positive.
- const subtle::Atomic32 atomic_thread_id =
- static_cast<subtle::Atomic32>(current_thread_id);
-
- return atomic_thread_id;
-}
-
-void ThreadCollisionWarner::EnterSelf() {
- // If the active thread is 0 then I'll write the current thread ID
- // if two or more threads arrive here only one will succeed to
- // write on valid_thread_id_ the current thread ID.
- subtle::Atomic32 current_thread_id = CurrentThread();
-
- int previous_value = subtle::NoBarrier_CompareAndSwap(&valid_thread_id_,
- 0,
- current_thread_id);
- if (previous_value != 0 && previous_value != current_thread_id) {
- // gotcha! a thread is trying to use the same class and that is
- // not current thread.
- asserter_->warn();
- }
-
- subtle::NoBarrier_AtomicIncrement(&counter_, 1);
-}
-
-void ThreadCollisionWarner::Enter() {
- subtle::Atomic32 current_thread_id = CurrentThread();
-
- if (subtle::NoBarrier_CompareAndSwap(&valid_thread_id_,
- 0,
- current_thread_id) != 0) {
- // gotcha! another thread is trying to use the same class.
- asserter_->warn();
- }
-
- subtle::NoBarrier_AtomicIncrement(&counter_, 1);
-}
-
-void ThreadCollisionWarner::Leave() {
- if (subtle::Barrier_AtomicIncrement(&counter_, -1) == 0) {
- subtle::NoBarrier_Store(&valid_thread_id_, 0);
- }
-}
-
-} // namespace base
diff --git a/base/threading/thread_collision_warner.h b/base/threading/thread_collision_warner.h
deleted file mode 100644
index b6993f6..0000000
--- a/base/threading/thread_collision_warner.h
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_THREAD_COLLISION_WARNER_H_
-#define BASE_THREADING_THREAD_COLLISION_WARNER_H_
-
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-
-// A helper class alongside macros to be used to verify assumptions about thread
-// safety of a class.
-//
-// Example: Queue implementation non thread-safe but still usable if clients
-// are synchronized somehow.
-//
-// In this case the macro DFAKE_SCOPED_LOCK has to be
-// used, it checks that if a thread is inside the push/pop then
-// noone else is still inside the pop/push
-//
-// class NonThreadSafeQueue {
-// public:
-// ...
-// void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... }
-// int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... }
-// ...
-// private:
-// DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Queue implementation non thread-safe but still usable if clients
-// are synchronized somehow, it calls a method to "protect" from
-// a "protected" method
-//
-// In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK
-// has to be used, it checks that if a thread is inside the push/pop
-// then noone else is still inside the pop/push
-//
-// class NonThreadSafeQueue {
-// public:
-// void push(int) {
-// DFAKE_SCOPED_LOCK(push_pop_);
-// ...
-// }
-// int pop() {
-// DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
-// bar();
-// ...
-// }
-// void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... }
-// ...
-// private:
-// DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Queue implementation not usable even if clients are synchronized,
-// so only one thread in the class life cycle can use the two members
-// push/pop.
-//
-// In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the
-// specified
-// critical section the first time a thread enters push or pop, from
-// that time on only that thread is allowed to execute push or pop.
-//
-// class NonThreadSafeQueue {
-// public:
-// ...
-// void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
-// int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
-// ...
-// private:
-// DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Class that has to be contructed/destroyed on same thread, it has
-// a "shareable" method (with external synchronization) and a not
-// shareable method (even with external synchronization).
-//
-// In this case 3 Critical sections have to be defined
-//
-// class ExoticClass {
-// public:
-// ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-// ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-//
-// void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... }
-// void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-// ...
-// private:
-// DFAKE_MUTEX(ctor_dtor_);
-// DFAKE_MUTEX(shareable_section_);
-// };
-
-
-#if !defined(NDEBUG)
-
-// Defines a class member that acts like a mutex. It is used only as a
-// verification tool.
-#define DFAKE_MUTEX(obj) \
- mutable base::ThreadCollisionWarner obj
-// Asserts the call is never called simultaneously in two threads. Used at
-// member function scope.
-#define DFAKE_SCOPED_LOCK(obj) \
- base::ThreadCollisionWarner::ScopedCheck s_check_##obj(&obj)
-// Asserts the call is never called simultaneously in two threads. Used at
-// member function scope. Same as DFAKE_SCOPED_LOCK but allows recursive locks.
-#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) \
- base::ThreadCollisionWarner::ScopedRecursiveCheck sr_check_##obj(&obj)
-// Asserts the code is always executed in the same thread.
-#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) \
- base::ThreadCollisionWarner::Check check_##obj(&obj)
-
-#else
-
-#define DFAKE_MUTEX(obj) typedef void InternalFakeMutexType##obj
-#define DFAKE_SCOPED_LOCK(obj) ((void)0)
-#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) ((void)0)
-#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) ((void)0)
-
-#endif
-
-namespace base {
-
-// The class ThreadCollisionWarner uses an Asserter to notify the collision
-// AsserterBase is the interfaces and DCheckAsserter is the default asserter
-// used. During the unit tests is used another class that doesn't "DCHECK"
-// in case of collision (check thread_collision_warner_unittests.cc)
-struct BASE_EXPORT AsserterBase {
- virtual ~AsserterBase() = default;
- virtual void warn() = 0;
-};
-
-struct BASE_EXPORT DCheckAsserter : public AsserterBase {
- ~DCheckAsserter() override = default;
- void warn() override;
-};
-
-class BASE_EXPORT ThreadCollisionWarner {
- public:
- // The parameter asserter is there only for test purpose
- explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
- : valid_thread_id_(0),
- counter_(0),
- asserter_(asserter) {}
-
- ~ThreadCollisionWarner() {
- delete asserter_;
- }
-
- // This class is meant to be used through the macro
- // DFAKE_SCOPED_LOCK_THREAD_LOCKED
- // it doesn't leave the critical section, as opposed to ScopedCheck,
- // because the critical section being pinned is allowed to be used only
- // from one thread
- class BASE_EXPORT Check {
- public:
- explicit Check(ThreadCollisionWarner* warner)
- : warner_(warner) {
- warner_->EnterSelf();
- }
-
- ~Check() = default;
-
- private:
- ThreadCollisionWarner* warner_;
-
- DISALLOW_COPY_AND_ASSIGN(Check);
- };
-
- // This class is meant to be used through the macro
- // DFAKE_SCOPED_LOCK
- class BASE_EXPORT ScopedCheck {
- public:
- explicit ScopedCheck(ThreadCollisionWarner* warner)
- : warner_(warner) {
- warner_->Enter();
- }
-
- ~ScopedCheck() {
- warner_->Leave();
- }
-
- private:
- ThreadCollisionWarner* warner_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedCheck);
- };
-
- // This class is meant to be used through the macro
- // DFAKE_SCOPED_RECURSIVE_LOCK
- class BASE_EXPORT ScopedRecursiveCheck {
- public:
- explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner)
- : warner_(warner) {
- warner_->EnterSelf();
- }
-
- ~ScopedRecursiveCheck() {
- warner_->Leave();
- }
-
- private:
- ThreadCollisionWarner* warner_;
-
- DISALLOW_COPY_AND_ASSIGN(ScopedRecursiveCheck);
- };
-
- private:
- // This method stores the current thread identifier and does a DCHECK
- // if a another thread has already done it, it is safe if same thread
- // calls this multiple time (recursion allowed).
- void EnterSelf();
-
- // Same as EnterSelf but recursion is not allowed.
- void Enter();
-
- // Removes the thread_id stored in order to allow other threads to
- // call EnterSelf or Enter.
- void Leave();
-
- // This stores the thread id that is inside the critical section, if the
- // value is 0 then no thread is inside.
- volatile subtle::Atomic32 valid_thread_id_;
-
- // Counter to trace how many time a critical section was "pinned"
- // (when allowed) in order to unpin it when counter_ reaches 0.
- volatile subtle::Atomic32 counter_;
-
- // Here only for class unit tests purpose, during the test I need to not
- // DCHECK but notify the collision with something else.
- AsserterBase* asserter_;
-
- DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner);
-};
-
-} // namespace base
-
-#endif // BASE_THREADING_THREAD_COLLISION_WARNER_H_
diff --git a/base/time/OWNERS b/base/time/OWNERS
deleted file mode 100644
index ff0520a..0000000
--- a/base/time/OWNERS
+++ /dev/null
@@ -1,3 +0,0 @@
-miu@chromium.org
-
-# COMPONENT: Internals>Core
diff --git a/base/time/default_tick_clock.cc b/base/time/default_tick_clock.cc
deleted file mode 100644
index 188c3cf..0000000
--- a/base/time/default_tick_clock.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/time/default_tick_clock.h"
-
-#include "base/no_destructor.h"
-
-namespace base {
-
-DefaultTickClock::~DefaultTickClock() = default;
-
-TimeTicks DefaultTickClock::NowTicks() const {
- return TimeTicks::Now();
-}
-
-// static
-const DefaultTickClock* DefaultTickClock::GetInstance() {
- static const base::NoDestructor<DefaultTickClock> default_tick_clock;
- return default_tick_clock.get();
-}
-
-} // namespace base
diff --git a/base/time/default_tick_clock.h b/base/time/default_tick_clock.h
deleted file mode 100644
index 78f8a99..0000000
--- a/base/time/default_tick_clock.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TIME_DEFAULT_TICK_CLOCK_H_
-#define BASE_TIME_DEFAULT_TICK_CLOCK_H_
-
-#include "base/base_export.h"
-#include "base/time/tick_clock.h"
-
-namespace base {
-
-// DefaultClock is a Clock implementation that uses TimeTicks::Now().
-class BASE_EXPORT DefaultTickClock : public TickClock {
- public:
- ~DefaultTickClock() override;
-
- // Simply returns TimeTicks::Now().
- TimeTicks NowTicks() const override;
-
- // Returns a shared instance of DefaultTickClock. This is thread-safe.
- static const DefaultTickClock* GetInstance();
-};
-
-} // namespace base
-
-#endif // BASE_TIME_DEFAULT_TICK_CLOCK_H_
diff --git a/base/time/tick_clock.cc b/base/time/tick_clock.cc
deleted file mode 100644
index 79e396d..0000000
--- a/base/time/tick_clock.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/time/tick_clock.h"
-
-namespace base {
-
-TickClock::~TickClock() = default;
-
-} // namespace base
diff --git a/base/time/tick_clock.h b/base/time/tick_clock.h
deleted file mode 100644
index dc57354..0000000
--- a/base/time/tick_clock.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TIME_TICK_CLOCK_H_
-#define BASE_TIME_TICK_CLOCK_H_
-
-#include "base/base_export.h"
-#include "base/time/time.h"
-
-namespace base {
-
-// A TickClock is an interface for objects that vend TimeTicks. It is
-// intended to be able to test the behavior of classes with respect to
-// non-decreasing time.
-//
-// See DefaultTickClock (base/time/default_tick_clock.h) for the default
-// implementation that simply uses TimeTicks::Now().
-//
-// (Other implementations that use TimeTicks::NowFromSystemTime() should
-// be added as needed.)
-//
-// See SimpleTestTickClock (base/test/simple_test_tick_clock.h) for a
-// simple test implementation.
-//
-// See Clock (base/time/clock.h) for the equivalent interface for Times.
-class BASE_EXPORT TickClock {
- public:
- virtual ~TickClock();
-
- // NowTicks() must be safe to call from any thread. The caller may
- // assume that NowTicks() is monotonic (but not strictly monotonic).
- // In other words, the returned TimeTicks will never decrease with
- // time, although they might "stand still".
- virtual TimeTicks NowTicks() const = 0;
-};
-
-} // namespace base
-
-#endif // BASE_TIME_TICK_CLOCK_H_
diff --git a/base/time/time.cc b/base/time/time.cc
index 577895c..bd746b3 100644
--- a/base/time/time.cc
+++ b/base/time/time.cc
@@ -14,7 +14,6 @@
#include "base/macros.h"
#include "base/no_destructor.h"
#include "base/strings/stringprintf.h"
-#include "base/third_party/nspr/prtime.h"
#include "base/time/time_override.h"
#include "build_config.h"
@@ -291,27 +290,6 @@
}
// static
-bool Time::FromStringInternal(const char* time_string,
- bool is_local,
- Time* parsed_time) {
- DCHECK((time_string != nullptr) && (parsed_time != nullptr));
-
- 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;
-}
-
-// static
bool Time::ExplodedMostlyEquals(const Exploded& lhs, const Exploded& rhs) {
return lhs.year == rhs.year && lhs.month == rhs.month &&
lhs.day_of_month == rhs.day_of_month && lhs.hour == rhs.hour &&
diff --git a/base/time/time.h b/base/time/time.h
index 936c746..eef95f3 100644
--- a/base/time/time.h
+++ b/base/time/time.h
@@ -619,23 +619,6 @@
return FromExploded(true, exploded, time);
}
- // 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) WARN_UNUSED_RESULT {
- return FromStringInternal(time_string, true, parsed_time);
- }
- static bool FromUTCString(const char* time_string,
- Time* parsed_time) WARN_UNUSED_RESULT {
- 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 {
@@ -675,17 +658,6 @@
const Exploded& exploded,
Time* time) WARN_UNUSED_RESULT;
- // 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) WARN_UNUSED_RESULT;
-
// Comparison does not consider |day_of_week| when doing the operation.
static bool ExplodedMostlyEquals(const Exploded& lhs,
const Exploded& rhs) WARN_UNUSED_RESULT;
@@ -866,12 +838,6 @@
return TimeTicks(us);
}
-#if defined(OS_WIN)
- protected:
- typedef DWORD (*TickFunctionType)(void);
- static TickFunctionType SetMockTickFunction(TickFunctionType ticker);
-#endif
-
private:
friend class time_internal::TimeBase<TimeTicks>;
@@ -896,10 +862,8 @@
static bool IsSupported() WARN_UNUSED_RESULT {
#if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
(defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_ANDROID) || \
- defined(OS_FUCHSIA)
+ defined(OS_FUCHSIA) || defined(OS_WIN)
return true;
-#elif defined(OS_WIN)
- return IsSupportedWin();
#else
return false;
#endif
@@ -956,7 +920,6 @@
// allow testing.
static double TSCTicksPerSecond();
- static bool IsSupportedWin() WARN_UNUSED_RESULT;
static void WaitUntilInitializedWin();
#endif
};
diff --git a/base/time/time_to_iso8601.cc b/base/time/time_to_iso8601.cc
deleted file mode 100644
index 27e7bfc..0000000
--- a/base/time/time_to_iso8601.cc
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/time/time_to_iso8601.h"
-
-#include "base/strings/stringprintf.h"
-#include "base/time/time.h"
-
-namespace base {
-
-std::string TimeToISO8601(const Time& t) {
- Time::Exploded exploded;
- t.UTCExplode(&exploded);
- return StringPrintf("%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", exploded.year,
- exploded.month, exploded.day_of_month, exploded.hour,
- exploded.minute, exploded.second, exploded.millisecond);
-}
-
-} // namespace base
diff --git a/base/time/time_to_iso8601.h b/base/time/time_to_iso8601.h
deleted file mode 100644
index 2643484..0000000
--- a/base/time/time_to_iso8601.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TIME_TIME_TO_ISO8601_H_
-#define BASE_TIME_TIME_TO_ISO8601_H_
-
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-
-class Time;
-
-BASE_EXPORT std::string TimeToISO8601(const base::Time& t);
-
-} // namespace base
-
-#endif // BASE_TIME_TIME_TO_ISO8601_H_
diff --git a/base/time/time_win.cc b/base/time/time_win.cc
index 9c6eba0..6767fd6 100644
--- a/base/time/time_win.cc
+++ b/base/time/time_win.cc
@@ -39,7 +39,6 @@
#include "base/atomicops.h"
#include "base/bit_cast.h"
-#include "base/cpu.h"
#include "base/logging.h"
#include "base/synchronization/lock.h"
#include "base/threading/platform_thread.h"
@@ -361,81 +360,6 @@
namespace {
-// We define a wrapper to adapt between the __stdcall and __cdecl call of the
-// mock function, and to avoid a static constructor. Assigning an import to a
-// function pointer directly would require setup code to fetch from the IAT.
-DWORD timeGetTimeWrapper() {
- return timeGetTime();
-}
-
-DWORD (*g_tick_function)(void) = &timeGetTimeWrapper;
-
-// A structure holding the most significant bits of "last seen" and a
-// "rollover" counter.
-union LastTimeAndRolloversState {
- // The state as a single 32-bit opaque value.
- subtle::Atomic32 as_opaque_32;
-
- // The state as usable values.
- struct {
- // The top 8-bits of the "last" time. This is enough to check for rollovers
- // and the small bit-size means fewer CompareAndSwap operations to store
- // changes in state, which in turn makes for fewer retries.
- uint8_t last_8;
- // A count of the number of detected rollovers. Using this as bits 47-32
- // of the upper half of a 64-bit value results in a 48-bit tick counter.
- // This extends the total rollover period from about 49 days to about 8800
- // years while still allowing it to be stored with last_8 in a single
- // 32-bit value.
- uint16_t rollovers;
- } as_values;
-};
-subtle::Atomic32 g_last_time_and_rollovers = 0;
-static_assert(
- sizeof(LastTimeAndRolloversState) <= sizeof(g_last_time_and_rollovers),
- "LastTimeAndRolloversState does not fit in a single atomic word");
-
-// We use timeGetTime() to implement TimeTicks::Now(). This can be problematic
-// because it returns the number of milliseconds since Windows has started,
-// which will roll over the 32-bit value every ~49 days. We try to track
-// rollover ourselves, which works if TimeTicks::Now() is called at least every
-// 48.8 days (not 49 days because only changes in the top 8 bits get noticed).
-TimeTicks RolloverProtectedNow() {
- LastTimeAndRolloversState state;
- DWORD now; // DWORD is always unsigned 32 bits.
-
- while (true) {
- // Fetch the "now" and "last" tick values, updating "last" with "now" and
- // incrementing the "rollovers" counter if the tick-value has wrapped back
- // around. Atomic operations ensure that both "last" and "rollovers" are
- // always updated together.
- int32_t original = subtle::Acquire_Load(&g_last_time_and_rollovers);
- state.as_opaque_32 = original;
- now = g_tick_function();
- uint8_t now_8 = static_cast<uint8_t>(now >> 24);
- if (now_8 < state.as_values.last_8)
- ++state.as_values.rollovers;
- state.as_values.last_8 = now_8;
-
- // If the state hasn't changed, exit the loop.
- if (state.as_opaque_32 == original)
- break;
-
- // Save the changed state. If the existing value is unchanged from the
- // original, exit the loop.
- int32_t check = subtle::Release_CompareAndSwap(
- &g_last_time_and_rollovers, original, state.as_opaque_32);
- if (check == original)
- break;
-
- // Another thread has done something in between so retry from the top.
- }
-
- return TimeTicks() +
- TimeDelta::FromMilliseconds(
- now + (static_cast<uint64_t>(state.as_values.rollovers) << 32));
-}
-
// Discussion of tick counter options on Windows:
//
// (1) CPU cycle counter. (Retrieved via RDTSC)
@@ -511,35 +435,12 @@
return TimeTicks() + QPCValueToTimeDelta(QPCNowRaw());
}
-bool IsBuggyAthlon(const CPU& cpu) {
- // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is unreliable.
- return cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15;
-}
-
void InitializeNowFunctionPointer() {
LARGE_INTEGER ticks_per_sec = {};
if (!QueryPerformanceFrequency(&ticks_per_sec))
ticks_per_sec.QuadPart = 0;
- // If Windows cannot provide a QPC implementation, TimeTicks::Now() must use
- // the low-resolution clock.
- //
- // If the QPC implementation is expensive and/or unreliable, TimeTicks::Now()
- // will still use the low-resolution clock. A CPU lacking a non-stop time
- // counter will cause Windows to provide an alternate QPC implementation that
- // works, but is expensive to use. Certain Athlon CPUs are known to make the
- // QPC implementation unreliable.
- //
- // Otherwise, Now uses the high-resolution QPC clock. As of 21 August 2015,
- // ~72% of users fall within this category.
- TimeTicksNowFunction now_function;
- CPU cpu;
- if (ticks_per_sec.QuadPart <= 0 ||
- !cpu.has_non_stop_time_stamp_counter() || IsBuggyAthlon(cpu)) {
- now_function = &RolloverProtectedNow;
- } else {
- now_function = &QPCNow;
- }
+ TimeTicksNowFunction now_function = &QPCNow;
// Threading note 1: In an unlikely race condition, it's possible for two or
// more threads to enter InitializeNowFunctionPointer() in parallel. This is
@@ -569,15 +470,6 @@
} // namespace
-// static
-TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
- TickFunctionType ticker) {
- TickFunctionType old = g_tick_function;
- g_tick_function = ticker;
- subtle::NoBarrier_Store(&g_last_time_and_rollovers, 0);
- return old;
-}
-
namespace subtle {
TimeTicks TimeTicksNowIgnoringOverride() {
return g_time_ticks_now_ignoring_override_function();
@@ -646,13 +538,6 @@
}
// static
-bool ThreadTicks::IsSupportedWin() {
- static bool is_supported =
- CPU().has_non_stop_time_stamp_counter() && !IsBuggyAthlon(CPU());
- return is_supported;
-}
-
-// static
void ThreadTicks::WaitUntilInitializedWin() {
while (TSCTicksPerSecond() == 0)
::Sleep(10);
diff --git a/base/timer/mock_timer.cc b/base/timer/mock_timer.cc
deleted file mode 100644
index ca0893b..0000000
--- a/base/timer/mock_timer.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/timer/mock_timer.h"
-
-namespace base {
-
-MockTimer::MockTimer(bool retain_user_task, bool is_repeating)
- : Timer(retain_user_task, is_repeating),
- is_running_(false) {
-}
-
-MockTimer::MockTimer(const Location& posted_from,
- TimeDelta delay,
- const base::Closure& user_task,
- bool is_repeating)
- : Timer(true, is_repeating), delay_(delay), is_running_(false) {}
-
-MockTimer::~MockTimer() = default;
-
-bool MockTimer::IsRunning() const {
- return is_running_;
-}
-
-base::TimeDelta MockTimer::GetCurrentDelay() const {
- return delay_;
-}
-
-void MockTimer::Start(const Location& posted_from,
- TimeDelta delay,
- const base::Closure& user_task) {
- delay_ = delay;
- user_task_ = user_task;
- Reset();
-}
-
-void MockTimer::Stop() {
- is_running_ = false;
- if (!retain_user_task())
- user_task_.Reset();
-}
-
-void MockTimer::Reset() {
- DCHECK(!user_task_.is_null());
- is_running_ = true;
-}
-
-void MockTimer::Fire() {
- DCHECK(is_running_);
- base::Closure old_task = user_task_;
- if (is_repeating())
- Reset();
- else
- Stop();
- old_task.Run();
-}
-
-} // namespace base
diff --git a/base/timer/mock_timer.h b/base/timer/mock_timer.h
deleted file mode 100644
index 49394b2..0000000
--- a/base/timer/mock_timer.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TIMER_MOCK_TIMER_H_
-#define BASE_TIMER_MOCK_TIMER_H_
-
-#include "base/timer/timer.h"
-
-namespace base {
-
-class BASE_EXPORT MockTimer : public Timer {
- public:
- MockTimer(bool retain_user_task, bool is_repeating);
- MockTimer(const Location& posted_from,
- TimeDelta delay,
- const base::Closure& user_task,
- bool is_repeating);
- ~MockTimer() override;
-
- // base::Timer implementation.
- bool IsRunning() const override;
- base::TimeDelta GetCurrentDelay() const override;
- void Start(const Location& posted_from,
- base::TimeDelta delay,
- const base::Closure& user_task) override;
- void Stop() override;
- void Reset() override;
-
- // Testing methods.
- void Fire();
-
- private:
- base::Closure user_task_;
- TimeDelta delay_;
- bool is_running_;
-};
-
-} // namespace base
-
-#endif // BASE_TIMER_MOCK_TIMER_H_
diff --git a/base/win/OWNERS b/base/win/OWNERS
deleted file mode 100644
index 4593b2c..0000000
--- a/base/win/OWNERS
+++ /dev/null
@@ -1,7 +0,0 @@
-brucedawson@chromium.org
-grt@chromium.org
-jschuh@chromium.org
-robliao@chromium.org
-scottmg@chromium.org
-
-# COMPONENT: Internals>PlatformIntegration
diff --git a/build/gen.py b/build/gen.py
index d72f39b..ed92d2f 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -236,7 +236,6 @@
'base/files/file_util.cc',
'base/files/scoped_file.cc',
'base/files/scoped_temp_dir.cc',
- 'base/hash.cc',
'base/json/json_parser.cc',
'base/json/json_reader.cc',
'base/json/json_string_value_serializer.cc',
@@ -250,9 +249,7 @@
'base/process/memory.cc',
'base/process/process_handle.cc',
'base/process/process_iterator.cc',
- 'base/rand_util.cc',
'base/sha1.cc',
- 'base/strings/pattern.cc',
'base/strings/string_number_conversions.cc',
'base/strings/string_piece.cc',
'base/strings/string_split.cc',
@@ -261,13 +258,8 @@
'base/strings/stringprintf.cc',
'base/strings/utf_string_conversion_utils.cc',
'base/strings/utf_string_conversions.cc',
- 'base/synchronization/atomic_flag.cc',
'base/third_party/icu/icu_utf.cc',
- 'base/third_party/nspr/prtime.cc',
- 'base/threading/thread_collision_warner.cc',
'base/time/clock.cc',
- 'base/time/default_tick_clock.cc',
- 'base/time/tick_clock.cc',
'base/time/time.cc',
'base/timer/elapsed_timer.cc',
'base/value_iterators.cc',
@@ -360,7 +352,6 @@
'tools/gn/output_file.cc',
'tools/gn/parse_node_value_adapter.cc',
'tools/gn/parser.cc',
- 'tools/gn/parser_fuzzer.cc',
'tools/gn/parse_tree.cc',
'tools/gn/path_output.cc',
'tools/gn/pattern.cc',
@@ -484,7 +475,6 @@
'base/process/kill_posix.cc',
'base/process/process_handle_posix.cc',
'base/process/process_posix.cc',
- 'base/rand_util_posix.cc',
'base/strings/string16.cc',
'base/synchronization/condition_variable_posix.cc',
'base/synchronization/lock_impl_posix.cc',
@@ -499,7 +489,6 @@
'base/process/process_handle_linux.cc',
'base/process/process_info_linux.cc',
'base/process/process_iterator_linux.cc',
- 'base/process/process_linux.cc',
'base/strings/sys_string_conversions_posix.cc',
'base/synchronization/waitable_event_posix.cc',
'base/time/time_exploded_posix.cc',
@@ -519,13 +508,10 @@
static_libraries['base']['sources'].extend([
'base/files/file_util_mac.mm',
'base/mac/bundle_locations.mm',
- 'base/mac/call_with_eh_frame.cc',
- 'base/mac/call_with_eh_frame_asm.S',
'base/mac/dispatch_source_mach.cc',
'base/mac/foundation_util.mm',
'base/mac/mach_logging.cc',
'base/mac/scoped_mach_port.cc',
- 'base/mac/scoped_mach_vm.cc',
'base/mac/scoped_nsautorelease_pool.mm',
'base/process/process_handle_mac.cc',
'base/process/process_info_mac.cc',
@@ -546,7 +532,6 @@
if is_win:
static_libraries['base']['sources'].extend([
- 'base/cpu.cc',
'base/files/file_enumerator_win.cc',
'base/files/file_util_win.cc',
'base/files/file_win.cc',
@@ -556,7 +541,6 @@
'base/process/process_info_win.cc',
'base/process/process_iterator_win.cc',
'base/process/process_win.cc',
- 'base/rand_util_win.cc',
'base/strings/sys_string_conversions_win.cc',
'base/synchronization/condition_variable_win.cc',
'base/synchronization/lock_impl_win.cc',
diff --git a/tools/gn/OWNERS b/tools/gn/OWNERS
deleted file mode 100644
index 82224cd..0000000
--- a/tools/gn/OWNERS
+++ /dev/null
@@ -1,3 +0,0 @@
-brettw@chromium.org
-dpranke@chromium.org
-sdefresne@chromium.org
diff --git a/tools/gn/README.md b/tools/gn/README.md
deleted file mode 100644
index fd0d9c5..0000000
--- a/tools/gn/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# What is GN?
-
-GN is a meta-build system that generates [Ninja](https://ninja-build.org)
-build files so that you can build Chromium with Ninja.
-
-## I want more info on GN!
-
-Read these links:
-
- * [Quick start](docs/quick_start.md)
- * [FAQ](docs/faq.md)
- * [Language and operation details](docs/language.md)
- * [Reference](docs/reference.md): The built-in `gn help` documentation.
- * [Style guide](docs/style_guide.md)
- * [Cross compiling and toolchains](docs/cross_compiles.md)
- * [Hacking on GN itself](docs/hacking.md)
- * [Standaline GN projects](docs/standalone.md)
- * [Pushing new binaries](docs/update_binaries.md)
diff --git a/tools/gn/bin/compare_test_lists.py b/tools/gn/bin/compare_test_lists.py
deleted file mode 100644
index 37fb1bf..0000000
--- a/tools/gn/bin/compare_test_lists.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# Copyright 2015 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-# This script compares the gtest test list for two different builds.
-#
-# Usage:
-# compare_test_lists.py <build_dir_1> <build_dir_2> <binary_name>
-#
-# For example, from the "src" directory:
-# python tools/gn/bin/compare_test_lists.py out/Debug out/gnbuild ipc_tests
-#
-# This will compile the given binary in both output directories, then extracts
-# the test lists and prints missing or extra tests between the first and the
-# second build.
-
-import os
-import subprocess
-import sys
-
-def BuildBinary(build_dir, binary_name):
- """Builds the given binary in the given directory with Ninja.
-
- Returns True on success."""
- return subprocess.call(["ninja", "-C", build_dir, binary_name]) == 0
-
-
-def GetTestList(path_to_binary):
- """Returns a set of full test names.
-
- Each test will be of the form "Case.Test". There will be a separate line
- for each combination of Case/Test (there are often multiple tests in each
- case).
-
- Throws an exception on failure."""
- raw_output = subprocess.check_output([path_to_binary, "--gtest_list_tests"])
- input_lines = raw_output.split('\n')
-
- # The format of the gtest_list_tests output is:
- # "Case1."
- # " Test1 # <Optional extra stuff>"
- # " Test2"
- # "Case2."
- # " Test1"
- case_name = '' # Includes trailing dot.
- test_set = set()
- for line in input_lines:
- if len(line) > 1:
- if line[0] == ' ':
- # Indented means a test in previous case.
- test_set.add(case_name + line[:line.find('#')].strip())
- else:
- # New test case.
- case_name = line.strip()
-
- return test_set
-
-
-def PrintSetDiff(a_name, a, b_name, b, binary_name):
- """Prints the test list difference between the given sets a and b.
-
- a_name and b_name will be used to refer to the directories of the two sets,
- and the binary name will be shown as the source of the output."""
-
- a_not_b = list(a - b)
- if len(a_not_b):
- print "\n", binary_name, "tests in", a_name, "but not", b_name
- a_not_b.sort()
- for cur in a_not_b:
- print " ", cur
-
- b_not_a = list(b - a)
- if len(b_not_a):
- print "\n", binary_name, "tests in", b_name, "but not", a_name
- b_not_a.sort()
- for cur in b_not_a:
- print " ", cur
-
- if len(a_not_b) == 0 and len(b_not_a) == 0:
- print "\nTests match!"
-
-
-def Run(a_dir, b_dir, binary_name):
- if not BuildBinary(a_dir, binary_name):
- print "Building", binary_name, "in", a_dir, "failed"
- return 1
- if not BuildBinary(b_dir, binary_name):
- print "Building", binary_name, "in", b_dir, "failed"
- return 1
-
- a_tests = GetTestList(os.path.join(a_dir, binary_name))
- b_tests = GetTestList(os.path.join(b_dir, binary_name))
-
- PrintSetDiff(a_dir, a_tests, b_dir, b_tests, binary_name)
-
-
-if len(sys.argv) != 4:
- print "Usage: compare_test_lists.py <build_dir_1> <build_dir_2> " \
- "<test_binary_name>"
- sys.exit(1)
-sys.exit(Run(sys.argv[1], sys.argv[2], sys.argv[3]))
diff --git a/tools/gn/bin/roll_gn.py b/tools/gn/bin/roll_gn.py
deleted file mode 100755
index cf4c878..0000000
--- a/tools/gn/bin/roll_gn.py
+++ /dev/null
@@ -1,461 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2014 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""An auto-roller for GN binaries into Chromium.
-
-This script is used to update the GN binaries that a Chromium
-checkout uses. In order to update the binaries, one must follow
-four steps in order:
-
-1. Trigger try jobs to build a new GN binary at tip-of-tree and upload
- the newly-built binaries into the right Google CloudStorage bucket.
-2. Wait for the try jobs to complete.
-3. Update the buildtools repo with the .sha1 hashes of the newly built
- binaries.
-4. Update Chromium's DEPS file to the new version of the buildtools repo.
-
-The script has four commands that correspond to the four steps above:
-'build', 'wait', 'roll_buildtools', and 'roll_deps'.
-
-The script has a fifth command, 'roll', that runs the four in order.
-
-If given no arguments, the script will run the 'roll' command.
-
-It can only be run on linux in a clean Chromium checkout; it should
-error out in most cases if something bad happens, but the error checking
-isn't yet foolproof.
-
-"""
-
-from __future__ import print_function
-
-import argparse
-import json
-import os
-import re
-import subprocess
-import sys
-import tempfile
-import time
-import urllib2
-
-
-depot_tools_path = os.path.abspath(os.path.normpath(os.path.join(
- os.path.dirname(__file__), '..', '..', '..', 'third_party', 'depot_tools')))
-if not depot_tools_path in sys.path:
- sys.path.insert(0, depot_tools_path)
-
-
-CHROMIUM_REPO = 'https://chromium.googlesource.com/chromium/src.git'
-
-COMMITISH_DIGITS = 10
-
-UNKNOWN, PENDING, STARTED, SUCCESS = (
- 'unknown', 'pending', 'started', 'success')
-
-class BuildResult(object):
- def __init__(self):
- self.masterName = '-'
- self.builderName = '-'
- self.buildNumber = '-'
- self.state = UNKNOWN
- self.sha1 = '-'
- self.url = '-'
-
-
-class GNRoller(object):
- def __init__(self):
- self.chromium_src_dir = None
- self.buildtools_dir = None
- self.old_gn_commitish = None
- self.new_gn_commitish = None
- self.old_gn_version = None
- self.new_gn_version = None
- self.reviewer = 'dpranke@chromium.org'
- if os.getenv('USER') == 'dpranke':
- self.reviewer = 'brettw@chromium.org'
-
- def Roll(self):
- parser = argparse.ArgumentParser()
- parser.usage = __doc__
- parser.add_argument('command', nargs='?', default='roll',
- help='build|roll|roll_buildtools|roll_deps|wait'
- ' (%(default)s is the default)')
-
- args = parser.parse_args()
- command = args.command
- ret = self.SetUp()
- if not ret and command in ('roll', 'build'):
- ret = self.TriggerBuild()
- if not ret and command in ('roll', 'wait'):
- ret = self.WaitForBuildToFinish()
- if not ret and command in ('roll', 'roll_buildtools'):
- ret = self.RollBuildtools()
- if not ret and command in ('roll', 'roll_deps'):
- ret = self.RollDEPS()
-
- return ret
-
- def SetUp(self):
- if sys.platform not in ('darwin', 'linux2'):
- print('roll_gn is only tested and working on Linux and Mac for now.')
- return 1
-
- ret, out, _ = self.Call('git config --get remote.origin.url')
- origin = out.strip()
- if ret or origin != CHROMIUM_REPO:
- print('Not in a Chromium repo? git config --get remote.origin.url '
- 'returned %d: %s' % (ret, origin))
- return 1
-
- ret, _, _ = self.Call('git diff -q')
- if ret:
- print("Checkout is dirty, exiting")
- return 1
-
- _, out, _ = self.Call('git rev-parse --show-toplevel', cwd=os.getcwd())
- self.chromium_src_dir = out.strip()
- self.buildtools_dir = os.path.join(self.chromium_src_dir, 'buildtools')
-
- self.new_gn_commitish, self.new_gn_version = self.GetNewVersions()
-
- _, out, _ = self.Call('gn --version')
- self.old_gn_version = out.strip()
-
- _, out, _ = self.Call('git crrev-parse %s' % self.old_gn_version)
- self.old_gn_commitish = out.strip()
- return 0
-
- def GetNewVersions(self):
- _, out, _ = self.Call('git log -1 --grep Cr-Commit-Position')
- commit_msg = out.splitlines()
- first_line = commit_msg[0]
- new_gn_commitish = first_line.split()[1]
-
- last_line = commit_msg[-1]
- new_gn_version = re.sub('.*master@{#(\d+)}', '\\1', last_line)
-
- return new_gn_commitish, new_gn_version
-
- def TriggerBuild(self):
- ret, _, _ = self.Call('git new-branch build_gn_%s' % self.new_gn_version)
- if ret:
- print('Failed to create a new branch for build_gn_%s' %
- self.new_gn_version)
- return 1
-
- self.MakeDummyDepsChange()
-
- ret, out, err = self.Call('git commit -a -m "Build gn at %s"' %
- self.new_gn_version)
- if ret:
- print('git commit failed: %s' % out + err)
- return 1
-
- print('Uploading CL to build GN at {#%s} - %s' %
- (self.new_gn_version, self.new_gn_commitish))
- ret, out, err = self.Call('git cl upload -f')
- if ret:
- print('git-cl upload failed: %s' % out + err)
- return 1
-
- print('Starting try jobs')
- self.Call('git-cl try -m tryserver.chromium.linux '
- '-b linux_chromium_gn_upload -r %s' % self.new_gn_commitish)
- self.Call('git-cl try -m tryserver.chromium.mac '
- '-b mac_chromium_gn_upload -r %s' % self.new_gn_commitish)
- self.Call('git-cl try -m tryserver.chromium.win '
- '-b win_chromium_gn_upload -r %s' % self.new_gn_commitish)
-
- return 0
-
- def MakeDummyDepsChange(self):
- with open('DEPS') as fp:
- deps_content = fp.read()
- new_deps = deps_content.replace("'buildtools_revision':",
- "'buildtools_revision': ")
-
- with open('DEPS', 'w') as fp:
- fp.write(new_deps)
-
- def WaitForBuildToFinish(self):
- ret = self.CheckoutBuildBranch()
- if ret:
- return ret
-
- print('Checking build')
- results = self.CheckBuild()
- while (any(r.state in (PENDING, STARTED) for r in results.values())):
- print()
- print('Sleeping for 30 seconds')
- time.sleep(30)
- print('Checking build')
- results = self.CheckBuild()
-
- ret = 0 if all(r.state == SUCCESS for r in results.values()) else 1
- if ret:
- print('Build failed.')
- else:
- print('Builds ready.')
-
- # Close the build CL and move off of the build branch back to whatever
- # we were on before.
- self.Call('git-cl set-close')
- self.MoveToLastHead()
-
- return ret
-
- def CheckoutBuildBranch(self):
- ret, out, err = self.Call('git checkout build_gn_%s' % self.new_gn_version)
- if ret:
- print('Failed to check out build_gn_%s' % self.new_gn_version)
- if out:
- print(out)
- if err:
- print(err, file=sys.stderr)
- return ret
-
- def CheckBuild(self):
- _, out, _ = self.Call('git-cl try-results')
-
- builders = {
- 'linux_chromium_gn_upload': 'linux64',
- 'mac_chromium_gn_upload': 'mac',
- 'win_chromium_gn_upload': 'win'
- }
-
- results = {}
- for platform in ('linux64', 'mac', 'win'):
- results[platform] = BuildResult()
-
- state = PENDING
- for line in out.splitlines():
- fields = line.strip().split()
- if fields[0] == 'Started:':
- state = STARTED
- if fields[0] == 'Successes:':
- state = SUCCESS
- elif fields[0] == 'Total':
- pass
- elif fields[0] in builders:
- builder = fields[0]
- platform = builders[builder]
- result = results[platform]
- result.masterName = ('tryserver.chromium.%s' %
- platform.replace('linux64', 'linux'))
- result.builderName = builder
- result.url = fields[1]
- if result.url.startswith('id'):
- result.state = PENDING
- else:
- result.state = state
- result.buildNumber = int(result.url[result.url.rfind('/')+1:])
-
- for result in results.values():
- if result.state == SUCCESS:
- url = 'https://luci-milo.appspot.com/prpc/milo.BuildInfo/Get'
- data = json.dumps({"buildbot": {
- 'masterName': result.masterName,
- 'builderName': result.builderName,
- 'buildNumber': result.buildNumber,
- }})
- headers = {
- 'content-type': 'application/json',
- 'accept': 'application/json',
- }
-
- req = urllib2.Request(url, data, headers)
- resp = urllib2.urlopen(req)
- data = resp.read()
- resp.close()
-
- # The first line of the response is garbage; skip it.
- js = json.loads(data.splitlines()[1])
-
- sha1_step_name = 'gn sha1'
- for step in js['step']['substep']:
- if step['step']['name'] == sha1_step_name:
- sha1 = step['step']['text'][-1]
-
- result.sha1 = sha1
-
- for platform, r in results.items():
- print(platform)
- print(' sha1: %s' % r.sha1)
- print(' state: %s' % r.state)
- print(' build: %s' % r.buildNumber)
- print(' url: %s' % r.url)
- print()
-
- return results
-
- def RollBuildtools(self):
- ret = self.CheckoutBuildBranch()
- if ret:
- return ret
-
- results = self.CheckBuild()
- if (len(results) < 3 or
- not all(r.state == SUCCESS for r in results.values()) or
- not all(r.sha1 != '-' for r in results.values())):
- print("Roll isn't done or didn't succeed, exiting:")
- return 1
-
- desc = self.GetBuildtoolsDesc()
-
- self.Call('git new-branch roll_buildtools_gn_%s' % self.new_gn_version,
- cwd=self.buildtools_dir)
-
- for platform in results:
- fname = 'gn.exe.sha1' if platform == 'win' else 'gn.sha1'
- path = os.path.join(self.buildtools_dir, platform, fname)
- with open(path, 'w') as fp:
- fp.write('%s\n' % results[platform].sha1)
-
- desc_file = tempfile.NamedTemporaryFile(delete=False)
- try:
- desc_file.write(desc)
- desc_file.close()
- self.Call('git commit -a -F %s' % desc_file.name,
- cwd=self.buildtools_dir)
- self.Call('git-cl upload -f --send-mail',
- cwd=self.buildtools_dir)
- finally:
- os.remove(desc_file.name)
-
- ret, out, err = self.Call('git cl land', cwd=self.buildtools_dir)
- if ret:
- print("buildtools git cl land failed: %d" % ret)
- if out:
- print(out)
- if err:
- print(err)
- return ret
-
- # Fetch the revision we just committed so that RollDEPS will find it.
- self.Call('git fetch', cwd=self.buildtools_dir)
-
- # Reset buildtools to the new commit so that we're not still on the
- # merged branch.
- self.Call('git checkout origin/master', cwd=self.buildtools_dir)
-
- _, out, _ = self.Call('git rev-parse origin/master',
- cwd=self.buildtools_dir)
- new_buildtools_commitish = out.strip()
- print('Ready to roll buildtools to %s in DEPS' % new_buildtools_commitish)
-
- return 0
-
- def RollDEPS(self):
- ret, _, _ = self.Call('git new-branch roll_gn_%s' % self.new_gn_version)
- if ret:
- print('Failed to create a new branch for roll_gn_%s' %
- self.new_gn_version)
- return 1
-
- _, out, _ = self.Call('git rev-parse origin/master',
- cwd=self.buildtools_dir)
- new_buildtools_commitish = out.strip()
-
- new_deps_lines = []
- old_buildtools_commitish = ''
- with open(os.path.join(self.chromium_src_dir, 'DEPS')) as fp:
- for l in fp.readlines():
- m = re.match(".*'buildtools_revision':.*'(.+)',", l)
- if m:
- old_buildtools_commitish = m.group(1)
- new_deps_lines.append(" 'buildtools_revision': '%s',\n" %
- new_buildtools_commitish)
- else:
- new_deps_lines.append(l)
-
- if not old_buildtools_commitish:
- print('Could not update DEPS properly, exiting')
- return 1
-
- with open('DEPS', 'w') as fp:
- fp.write(''.join(new_deps_lines))
-
- desc = self.GetDEPSRollDesc(old_buildtools_commitish,
- new_buildtools_commitish)
- desc_file = tempfile.NamedTemporaryFile(delete=False)
- try:
- desc_file.write(desc)
- desc_file.close()
- self.Call('git commit -a -F %s' % desc_file.name)
- self.Call('git-cl upload -f --send-mail --use-commit-queue')
- finally:
- os.remove(desc_file.name)
-
- # Move off of the roll branch onto whatever we were on before.
- # Do not explicitly close the roll CL issue, however; the CQ
- # will close it when the roll lands, assuming it does so.
- self.MoveToLastHead()
-
- return 0
-
- def MoveToLastHead(self):
- # When this is called, there will be a commit + a checkout as
- # the two most recent entries in the reflog, assuming nothing as
- # modified the repo while this script has been running.
- _, out, _ = self.Call('git reflog -2')
- m = re.search('moving from ([^\s]+)', out)
- last_head = m.group(1)
- self.Call('git checkout %s' % last_head)
-
- def GetBuildtoolsDesc(self):
- gn_changes = self.GetGNChanges()
- return (
- 'Roll gn %s..%s (r%s:r%s)\n'
- '\n'
- '%s'
- '\n'
- 'TBR=%s\n' % (
- self.old_gn_commitish[:COMMITISH_DIGITS],
- self.new_gn_commitish[:COMMITISH_DIGITS],
- self.old_gn_version,
- self.new_gn_version,
- gn_changes,
- self.reviewer,
- ))
-
- def GetDEPSRollDesc(self, old_buildtools_commitish, new_buildtools_commitish):
- gn_changes = self.GetGNChanges()
-
- return (
- 'Roll buildtools %s..%s\n'
- '\n'
- ' In order to roll GN %s..%s (r%s:r%s) and pick up\n'
- ' the following changes:\n'
- '\n'
- '%s'
- '\n'
- 'TBR=%s\n' % (
- old_buildtools_commitish[:COMMITISH_DIGITS],
- new_buildtools_commitish[:COMMITISH_DIGITS],
- self.old_gn_commitish[:COMMITISH_DIGITS],
- self.new_gn_commitish[:COMMITISH_DIGITS],
- self.old_gn_version,
- self.new_gn_version,
- gn_changes,
- self.reviewer,
- ))
-
- def GetGNChanges(self):
- _, out, _ = self.Call(
- "git log --pretty=' %h %s' " +
- "%s..%s tools/gn" % (self.old_gn_commitish, self.new_gn_commitish))
- return out
-
- def Call(self, cmd, cwd=None):
- proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True,
- cwd=(cwd or self.chromium_src_dir))
- out, err = proc.communicate()
- return proc.returncode, out or '', err or ''
-
-
-if __name__ == '__main__':
- roller = GNRoller()
- sys.exit(roller.Roll())
diff --git a/tools/gn/bootstrap/OWNERS b/tools/gn/bootstrap/OWNERS
deleted file mode 100644
index 21aeec2..0000000
--- a/tools/gn/bootstrap/OWNERS
+++ /dev/null
@@ -1,4 +0,0 @@
-# It's OK to TBR changes to bootstrap.py that edits the file lists to bring
-# them in line with the Chrome build. For more substantial changes, please
-# send a normal review.
-*
diff --git a/tools/gn/misc/OWNERS b/tools/gn/misc/OWNERS
deleted file mode 100644
index 4d2bd88..0000000
--- a/tools/gn/misc/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-scottmg@chromium.org
-erg@chromium.org
diff --git a/tools/gn/bin/help_as_html.py b/tools/gn/misc/help_as_html.py
similarity index 100%
rename from tools/gn/bin/help_as_html.py
rename to tools/gn/misc/help_as_html.py
diff --git a/tools/gn/bin/gn-format.py b/tools/gn/misc/vim/gn-format.py
similarity index 100%
rename from tools/gn/bin/gn-format.py
rename to tools/gn/misc/vim/gn-format.py
diff --git a/tools/gn/parser_fuzzer.cc b/tools/gn/parser_fuzzer.cc
deleted file mode 100644
index e40da78..0000000
--- a/tools/gn/parser_fuzzer.cc
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <stdint.h>
-
-#include "tools/gn/input_file.h"
-#include "tools/gn/parser.h"
-#include "tools/gn/source_file.h"
-#include "tools/gn/tokenizer.h"
-
-namespace {
-
-enum { kMaxContentDepth = 256, kMaxDodgy = 256 };
-
-// Some auto generated input is too unreasonable for fuzzing GN.
-// We see stack overflow when the parser hits really deeply "nested" input.
-// (I.E.: certain input that causes nested parsing function calls).
-//
-// Abstract max limits are undesirable in the release GN code, so some sanity
-// checks in the fuzzer to prevent stack overflow are done here.
-// - 1) Too many opening bracket, paren, or brace in a row.
-// - 2) Too many '!', '<' or '>' operators in a row.
-bool SanityCheckContent(const std::vector<Token>& tokens) {
- int depth = 0;
- int dodgy_count = 0;
- for (const auto& token : tokens) {
- switch (token.type()) {
- case Token::LEFT_PAREN:
- case Token::LEFT_BRACKET:
- case Token::LEFT_BRACE:
- ++depth;
- break;
- case Token::RIGHT_PAREN:
- case Token::RIGHT_BRACKET:
- case Token::RIGHT_BRACE:
- --depth;
- break;
- case Token::BANG:
- case Token::LESS_THAN:
- case Token::GREATER_THAN:
- ++dodgy_count;
- break;
- default:
- break;
- }
- // Bail out as soon as a boundary is hit, inside the loop.
- if (depth >= kMaxContentDepth || dodgy_count >= kMaxDodgy)
- return false;
- }
-
- return true;
-}
-
-} // namespace
-
-extern "C" int LLVMFuzzerTestOneInput(const unsigned char* data, size_t size) {
- SourceFile source;
- InputFile input(source);
- input.SetContents(std::string(reinterpret_cast<const char*>(data), size));
-
- Err err;
- std::vector<Token> tokens = Tokenizer::Tokenize(&input, &err);
- if (!SanityCheckContent(tokens))
- return 0;
-
- if (!err.has_error())
- Parser::Parse(tokens, &err);
-
- return 0;
-}
diff --git a/tools/gn/tutorial/hello.cc b/tools/gn/tutorial/hello.cc
deleted file mode 100644
index 8b25cd9..0000000
--- a/tools/gn/tutorial/hello.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "tools/gn/tutorial/hello.h"
-
-#include <stdio.h>
-
-void Hello(const char* who) {
- printf("Hello, %s.\n", who);
-}
-
-#if defined(TWO_PEOPLE)
-void Hello(const char* one, const char* two) {
- printf("Hello, %s and %s.\n", one, two);
-}
-#endif
diff --git a/tools/gn/tutorial/hello.h b/tools/gn/tutorial/hello.h
deleted file mode 100644
index 253fe24..0000000
--- a/tools/gn/tutorial/hello.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef TOOLS_GN_TUTORIAL_HELLO_H_
-#define TOOLS_GN_TUTORIAL_HELLO_H_
-
-void Hello(const char* who);
-
-#if defined(TWO_PEOPLE)
-void Hello(const char* one, const char* two);
-#endif
-
-#endif // TOOLS_GN_TUTORIAL_HELLO_H_
diff --git a/tools/gn/tutorial/hello_world.cc b/tools/gn/tutorial/hello_world.cc
deleted file mode 100644
index 84ffc3f..0000000
--- a/tools/gn/tutorial/hello_world.cc
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <stdio.h>
-
-int main() {
- printf("Hello, world.\n");
- return 0;
-}
diff --git a/tools/gn/tutorial/say_hello.cc b/tools/gn/tutorial/say_hello.cc
deleted file mode 100644
index d8092bd..0000000
--- a/tools/gn/tutorial/say_hello.cc
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "tools/gn/tutorial/hello.h"
-
-int main() {
-#if defined(TWO_PEOPLE)
- Hello("Bill", "Joy");
-#else
- Hello("everyone");
-#endif
- return 0;
-}
