Update from https://crrev.com/307664
This includes changes to the following:
mojo/tools/roll/cc_strip_video.patch due to
https://codereview.chromium.org/786583002 (renaming files)
ui/compositor/compositor.h due to https://codereview.chromium.org/783373002
(adding a parameter to ApplyViewportDeltas)
services/surfaces/surfaces_scheduler due to
https://codereview.chromium.org/767083005 (renaming a method)
TBR=jamesr@chromium.org
Review URL: https://codereview.chromium.org/787803004
diff --git a/DEPS b/DEPS
index 3ff8a41..22f9112 100644
--- a/DEPS
+++ b/DEPS
@@ -22,11 +22,11 @@
'libcxx_revision': '48198f9110397fff47fe7c37cbfa296be7d44d3d',
'libcxxabi_revision': '4ad1009ab3a59fa7a6896d74d5e4de5885697f95',
'sfntly_revision': '1bdaae8fc788a5ac8936d68bf24f37d977a13dac',
- 'skia_revision': 'cf56009d9058d25933d9840bf6cf9fdf6a80f647',
+ 'skia_revision': 'f9d09c969f8ffa664bc5cd40a71077e3dc46e0aa',
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling Skia
# and V8 without interference from each other.
- 'v8_revision': '4f77f25857dd9ca5b51749006d6183c3eeb2d49b',
+ 'v8_revision': '49dd4474ba5b874fd2ac982be8c34d09052dcd85',
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling ANGLE
# and whatever else without interference from each other.
@@ -34,7 +34,7 @@
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling build tools
# and whatever else without interference from each other.
- 'buildtools_revision': '535aff24c308a715751028173e569596bcfe12a7',
+ 'buildtools_revision': '05dd6a24723170d7c6ff35b537ee02947f619891',
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling PDFium
# and whatever else without interference from each other.
@@ -42,7 +42,7 @@
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling BoringSSL
# and whatever else without interference from each other.
- 'boringssl_revision': '00505ec2e1e4c3047b4f61a306f2ac1372fa7640',
+ 'boringssl_revision': '306e520cda7d2f0afee9ba634dae629f994b096c',
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling lss
# and whatever else without interference from each other.
diff --git a/base/android/java/src/org/chromium/base/TraceEvent.java b/base/android/java/src/org/chromium/base/TraceEvent.java
index 1c7e534..164ccf8 100644
--- a/base/android/java/src/org/chromium/base/TraceEvent.java
+++ b/base/android/java/src/org/chromium/base/TraceEvent.java
@@ -221,15 +221,6 @@
}
/**
- * Convenience wrapper around the versions of startAsync() that take string parameters.
- * @param id The id of the asynchronous event.
- * @see #begin()
- */
- public static void startAsync(long id) {
- if (sEnabled) nativeStartAsync(getCallerName(), id, null);
- }
-
- /**
* Triggers the 'start' native trace event with no arguments.
* @param name The name of the event.
* @param id The id of the asynchronous event.
@@ -249,15 +240,6 @@
}
/**
- * Convenience wrapper around the versions of finishAsync() that take string parameters.
- * @param id The id of the asynchronous event.
- * @see #begin()
- */
- public static void finishAsync(long id) {
- if (sEnabled) nativeFinishAsync(getCallerName(), id, null);
- }
-
- /**
* Triggers the 'finish' native trace event with no arguments.
* @param name The name of the event.
* @param id The id of the asynchronous event.
diff --git a/base/id_map.h b/base/id_map.h
index 9cbc1f8..852c138 100644
--- a/base/id_map.h
+++ b/base/id_map.h
@@ -53,13 +53,14 @@
Releaser<OS, 0>::release_all(&data_);
}
- // Sets whether Add should CHECK if passed in NULL data. Default is false.
+ // 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(T* data) {
DCHECK(CalledOnValidThread());
- CHECK(!check_on_null_data_ || data);
+ DCHECK(!check_on_null_data_ || data);
KeyType this_id = next_id_;
DCHECK(data_.find(this_id) == data_.end()) << "Inserting duplicate item";
data_[this_id] = data;
@@ -73,7 +74,7 @@
// two methods may not be mixed, or duplicate IDs may be generated
void AddWithID(T* data, KeyType id) {
DCHECK(CalledOnValidThread());
- CHECK(!check_on_null_data_ || data);
+ DCHECK(!check_on_null_data_ || data);
DCHECK(data_.find(id) == data_.end()) << "Inserting duplicate item";
data_[id] = data;
}
@@ -94,6 +95,25 @@
}
}
+ // Replaces the value for |id| with |new_data| and returns a pointer to the
+ // existing value. If there is no entry for |id|, the map is not altered and
+ // nullptr is returned. The OwnershipSemantics of the map have no effect on
+ // how the existing value is treated, the IDMap does not delete the existing
+ // value being replaced.
+ T* Replace(KeyType id, T* new_data) {
+ DCHECK(CalledOnValidThread());
+ DCHECK(!check_on_null_data_ || new_data);
+ typename HashTable::iterator i = data_.find(id);
+ if (i == data_.end()) {
+ NOTREACHED() << "Attempting to replace an item not in the list";
+ return nullptr;
+ }
+
+ T* temp = i->second;
+ i->second = new_data;
+ return temp;
+ }
+
void Clear() {
DCHECK(CalledOnValidThread());
if (iteration_depth_ == 0) {
diff --git a/base/id_map_unittest.cc b/base/id_map_unittest.cc
index c005a69..a9fb2b9 100644
--- a/base/id_map_unittest.cc
+++ b/base/id_map_unittest.cc
@@ -53,6 +53,9 @@
EXPECT_EQ(&obj1, map.Lookup(1));
EXPECT_EQ(&obj2, map.Lookup(2));
+ EXPECT_EQ(&obj2, map.Replace(2, &obj1));
+ EXPECT_EQ(&obj1, map.Lookup(2));
+
EXPECT_EQ(0, map.iteration_depth());
}
diff --git a/base/strings/string_util_unittest.cc b/base/strings/string_util_unittest.cc
index f29baac..923116d 100644
--- a/base/strings/string_util_unittest.cc
+++ b/base/strings/string_util_unittest.cc
@@ -494,10 +494,10 @@
const char chars_with_nul[] = "test\0string";
const int length_with_nul = arraysize(chars_with_nul) - 1;
std::string string_with_nul(chars_with_nul, length_with_nul);
- std::wstring wide_with_nul = ASCIIToWide(string_with_nul);
- EXPECT_EQ(static_cast<std::wstring::size_type>(length_with_nul),
- wide_with_nul.length());
- std::string narrow_with_nul = UTF16ToASCII(WideToUTF16(wide_with_nul));
+ base::string16 string16_with_nul = ASCIIToUTF16(string_with_nul);
+ EXPECT_EQ(static_cast<base::string16::size_type>(length_with_nul),
+ string16_with_nul.length());
+ std::string narrow_with_nul = UTF16ToASCII(string16_with_nul);
EXPECT_EQ(static_cast<std::string::size_type>(length_with_nul),
narrow_with_nul.length());
EXPECT_EQ(0, string_with_nul.compare(narrow_with_nul));
diff --git a/base/strings/utf_string_conversions.cc b/base/strings/utf_string_conversions.cc
index 9796eec..1480d48 100644
--- a/base/strings/utf_string_conversions.cc
+++ b/base/strings/utf_string_conversions.cc
@@ -209,11 +209,6 @@
#endif
-std::wstring ASCIIToWide(const StringPiece& ascii) {
- DCHECK(IsStringASCII(ascii)) << ascii;
- return std::wstring(ascii.begin(), ascii.end());
-}
-
string16 ASCIIToUTF16(const StringPiece& ascii) {
DCHECK(IsStringASCII(ascii)) << ascii;
return string16(ascii.begin(), ascii.end());
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index 13e0b71..06a3bc6 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -39,9 +39,8 @@
std::string* output);
BASE_EXPORT std::string UTF16ToUTF8(const string16& utf16);
-// These convert an ASCII string, typically a hardcoded constant, to a
-// UTF16/Wide string.
-BASE_EXPORT std::wstring ASCIIToWide(const StringPiece& ascii);
+// This converts an ASCII string, typically a hardcoded constant, to a UTF16
+// string.
BASE_EXPORT string16 ASCIIToUTF16(const StringPiece& ascii);
// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII
diff --git a/base/tuple.h b/base/tuple.h
index 12f7f84..16f5124 100644
--- a/base/tuple.h
+++ b/base/tuple.h
@@ -31,6 +31,29 @@
#include "base/bind_helpers.h"
+// Index sequences
+//
+// Minimal clone of the similarly-named C++14 functionality.
+
+template <size_t...>
+struct IndexSequence {};
+
+template <size_t... Ns>
+struct MakeIndexSequenceImpl;
+
+template <size_t... Ns>
+struct MakeIndexSequenceImpl<0, Ns...> {
+ using Type = IndexSequence<Ns...>;
+};
+
+template <size_t N, size_t... Ns>
+struct MakeIndexSequenceImpl<N, Ns...> {
+ using Type = typename MakeIndexSequenceImpl<N - 1, N - 1, Ns...>::Type;
+};
+
+template <size_t N>
+using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;
+
// Traits ----------------------------------------------------------------------
//
// A simple traits class for tuple arguments.
@@ -53,9 +76,6 @@
typedef P& ParamType;
};
-template <class P>
-struct TupleTypes { };
-
// Tuple -----------------------------------------------------------------------
//
// This set of classes is useful for bundling 0 or more heterogeneous data types
@@ -70,73 +90,70 @@
// want filled by the dispatchee, and the tuple is merely a container for that
// output (a "tier"). See MakeRefTuple and its usages.
-struct Tuple0 {
- typedef Tuple0 ValueTuple;
- typedef Tuple0 RefTuple;
- typedef Tuple0 ParamTuple;
-};
+template <typename... Ts>
+struct Tuple;
-template <class A>
-struct Tuple1 {
+template <>
+struct Tuple<> {};
+
+template <typename A>
+struct Tuple<A> {
public:
typedef A TypeA;
- Tuple1() {}
- explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {}
+ Tuple() {}
+ explicit Tuple(typename TupleTraits<A>::ParamType a) : a(a) {}
A a;
};
-template <class A, class B>
-struct Tuple2 {
+template <typename A, typename B>
+struct Tuple<A, B> {
public:
typedef A TypeA;
typedef B TypeB;
- Tuple2() {}
- Tuple2(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b)
- : a(a), b(b) {
- }
+ Tuple() {}
+ Tuple(typename TupleTraits<A>::ParamType a,
+ typename TupleTraits<B>::ParamType b)
+ : a(a), b(b) {}
A a;
B b;
};
-template <class A, class B, class C>
-struct Tuple3 {
+template <typename A, typename B, typename C>
+struct Tuple<A, B, C> {
public:
typedef A TypeA;
typedef B TypeB;
typedef C TypeC;
- Tuple3() {}
- Tuple3(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b,
- typename TupleTraits<C>::ParamType c)
- : a(a), b(b), c(c){
- }
+ Tuple() {}
+ Tuple(typename TupleTraits<A>::ParamType a,
+ typename TupleTraits<B>::ParamType b,
+ typename TupleTraits<C>::ParamType c)
+ : a(a), b(b), c(c) {}
A a;
B b;
C c;
};
-template <class A, class B, class C, class D>
-struct Tuple4 {
+template <typename A, typename B, typename C, typename D>
+struct Tuple<A, B, C, D> {
public:
typedef A TypeA;
typedef B TypeB;
typedef C TypeC;
typedef D TypeD;
- Tuple4() {}
- Tuple4(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b,
- typename TupleTraits<C>::ParamType c,
- typename TupleTraits<D>::ParamType d)
- : a(a), b(b), c(c), d(d) {
- }
+ Tuple() {}
+ Tuple(typename TupleTraits<A>::ParamType a,
+ typename TupleTraits<B>::ParamType b,
+ typename TupleTraits<C>::ParamType c,
+ typename TupleTraits<D>::ParamType d)
+ : a(a), b(b), c(c), d(d) {}
A a;
B b;
@@ -144,8 +161,8 @@
D d;
};
-template <class A, class B, class C, class D, class E>
-struct Tuple5 {
+template <typename A, typename B, typename C, typename D, typename E>
+struct Tuple<A, B, C, D, E> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -153,14 +170,13 @@
typedef D TypeD;
typedef E TypeE;
- Tuple5() {}
- Tuple5(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b,
- typename TupleTraits<C>::ParamType c,
- typename TupleTraits<D>::ParamType d,
- typename TupleTraits<E>::ParamType e)
- : a(a), b(b), c(c), d(d), e(e) {
- }
+ Tuple() {}
+ Tuple(typename TupleTraits<A>::ParamType a,
+ typename TupleTraits<B>::ParamType b,
+ typename TupleTraits<C>::ParamType c,
+ typename TupleTraits<D>::ParamType d,
+ typename TupleTraits<E>::ParamType e)
+ : a(a), b(b), c(c), d(d), e(e) {}
A a;
B b;
@@ -169,8 +185,13 @@
E e;
};
-template <class A, class B, class C, class D, class E, class F>
-struct Tuple6 {
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F>
+struct Tuple<A, B, C, D, E, F> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -179,15 +200,14 @@
typedef E TypeE;
typedef F TypeF;
- Tuple6() {}
- Tuple6(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b,
- typename TupleTraits<C>::ParamType c,
- typename TupleTraits<D>::ParamType d,
- typename TupleTraits<E>::ParamType e,
- typename TupleTraits<F>::ParamType f)
- : a(a), b(b), c(c), d(d), e(e), f(f) {
- }
+ Tuple() {}
+ Tuple(typename TupleTraits<A>::ParamType a,
+ typename TupleTraits<B>::ParamType b,
+ typename TupleTraits<C>::ParamType c,
+ typename TupleTraits<D>::ParamType d,
+ typename TupleTraits<E>::ParamType e,
+ typename TupleTraits<F>::ParamType f)
+ : a(a), b(b), c(c), d(d), e(e), f(f) {}
A a;
B b;
@@ -197,8 +217,14 @@
F f;
};
-template <class A, class B, class C, class D, class E, class F, class G>
-struct Tuple7 {
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G>
+struct Tuple<A, B, C, D, E, F, G> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -208,16 +234,15 @@
typedef F TypeF;
typedef G TypeG;
- Tuple7() {}
- Tuple7(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b,
- typename TupleTraits<C>::ParamType c,
- typename TupleTraits<D>::ParamType d,
- typename TupleTraits<E>::ParamType e,
- typename TupleTraits<F>::ParamType f,
- typename TupleTraits<G>::ParamType g)
- : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {
- }
+ Tuple() {}
+ Tuple(typename TupleTraits<A>::ParamType a,
+ typename TupleTraits<B>::ParamType b,
+ typename TupleTraits<C>::ParamType c,
+ typename TupleTraits<D>::ParamType d,
+ typename TupleTraits<E>::ParamType e,
+ typename TupleTraits<F>::ParamType f,
+ typename TupleTraits<G>::ParamType g)
+ : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {}
A a;
B b;
@@ -228,9 +253,15 @@
G g;
};
-template <class A, class B, class C, class D, class E, class F, class G,
- class H>
-struct Tuple8 {
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G,
+ typename H>
+struct Tuple<A, B, C, D, E, F, G, H> {
public:
typedef A TypeA;
typedef B TypeB;
@@ -241,17 +272,16 @@
typedef G TypeG;
typedef H TypeH;
- Tuple8() {}
- Tuple8(typename TupleTraits<A>::ParamType a,
- typename TupleTraits<B>::ParamType b,
- typename TupleTraits<C>::ParamType c,
- typename TupleTraits<D>::ParamType d,
- typename TupleTraits<E>::ParamType e,
- typename TupleTraits<F>::ParamType f,
- typename TupleTraits<G>::ParamType g,
- typename TupleTraits<H>::ParamType h)
- : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {
- }
+ Tuple() {}
+ Tuple(typename TupleTraits<A>::ParamType a,
+ typename TupleTraits<B>::ParamType b,
+ typename TupleTraits<C>::ParamType c,
+ typename TupleTraits<D>::ParamType d,
+ typename TupleTraits<E>::ParamType e,
+ typename TupleTraits<F>::ParamType f,
+ typename TupleTraits<G>::ParamType g,
+ typename TupleTraits<H>::ParamType h)
+ : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {}
A a;
B b;
@@ -263,157 +293,144 @@
H h;
};
+// Deprecated compat aliases
+
+using Tuple0 = Tuple<>;
+template <typename A>
+using Tuple1 = Tuple<A>;
+template <typename A, typename B>
+using Tuple2 = Tuple<A, B>;
+template <typename A, typename B, typename C>
+using Tuple3 = Tuple<A, B, C>;
+template <typename A, typename B, typename C, typename D>
+using Tuple4 = Tuple<A, B, C, D>;
+template <typename A, typename B, typename C, typename D, typename E>
+using Tuple5 = Tuple<A, B, C, D, E>;
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F>
+using Tuple6 = Tuple<A, B, C, D, E, F>;
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G>
+using Tuple7 = Tuple<A, B, C, D, E, F, G>;
+template <typename A,
+ typename B,
+ typename C,
+ typename D,
+ typename E,
+ typename F,
+ typename G,
+ typename H>
+using Tuple8 = Tuple<A, B, C, D, E, F, G, H>;
+
+// Tuple element --------------------------------------------------------------
+
+template <size_t N, typename T>
+struct TupleElement;
+
+template <typename T, typename... Ts>
+struct TupleElement<0, Tuple<T, Ts...>> {
+ using Type = T;
+};
+
+template <size_t N, typename T, typename... Ts>
+struct TupleElement<N, Tuple<T, Ts...>> {
+ using Type = typename TupleElement<N - 1, Tuple<Ts...>>::Type;
+};
+
+// Tuple getters --------------------------------------------------------------
+
+template <size_t, typename T>
+struct TupleGetter;
+
+template <typename... Ts>
+struct TupleGetter<0, Tuple<Ts...>> {
+ using Elem = typename TupleElement<0, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.a; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.a; }
+};
+
+template <typename... Ts>
+struct TupleGetter<1, Tuple<Ts...>> {
+ using Elem = typename TupleElement<1, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.b; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.b; }
+};
+
+template <typename... Ts>
+struct TupleGetter<2, Tuple<Ts...>> {
+ using Elem = typename TupleElement<2, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.c; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.c; }
+};
+
+template <typename... Ts>
+struct TupleGetter<3, Tuple<Ts...>> {
+ using Elem = typename TupleElement<3, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.d; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.d; }
+};
+
+template <typename... Ts>
+struct TupleGetter<4, Tuple<Ts...>> {
+ using Elem = typename TupleElement<4, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.e; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.e; }
+};
+
+template <typename... Ts>
+struct TupleGetter<5, Tuple<Ts...>> {
+ using Elem = typename TupleElement<5, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.f; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.f; }
+};
+
+template <typename... Ts>
+struct TupleGetter<6, Tuple<Ts...>> {
+ using Elem = typename TupleElement<6, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.g; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.g; }
+};
+
+template <typename... Ts>
+struct TupleGetter<7, Tuple<Ts...>> {
+ using Elem = typename TupleElement<7, Tuple<Ts...>>::Type;
+ static Elem& Get(Tuple<Ts...>& t) { return t.h; }
+ static const Elem& Get(const Tuple<Ts...>& t) { return t.h; }
+};
+
+template <size_t I, typename... Ts>
+typename TupleElement<I, Tuple<Ts...>>::Type& get(Tuple<Ts...>& tuple) {
+ return TupleGetter<I, Tuple<Ts...>>::Get(tuple);
+}
+
+template <size_t I, typename... Ts>
+const typename TupleElement<I, Tuple<Ts...>>::Type& get(
+ const Tuple<Ts...>& tuple) {
+ return TupleGetter<I, Tuple<Ts...>>::Get(tuple);
+}
+
// Tuple types ----------------------------------------------------------------
//
// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the
// definitions of class types the tuple takes as parameters.
-template <>
-struct TupleTypes< Tuple0 > {
- typedef Tuple0 ValueTuple;
- typedef Tuple0 RefTuple;
- typedef Tuple0 ParamTuple;
-};
+template <typename T>
+struct TupleTypes;
-template <class A>
-struct TupleTypes< Tuple1<A> > {
- typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple;
- typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple;
- typedef Tuple1<typename TupleTraits<A>::ParamType> ParamTuple;
-};
-
-template <class A, class B>
-struct TupleTypes< Tuple2<A, B> > {
- typedef Tuple2<typename TupleTraits<A>::ValueType,
- typename TupleTraits<B>::ValueType> ValueTuple;
-typedef Tuple2<typename TupleTraits<A>::RefType,
- typename TupleTraits<B>::RefType> RefTuple;
- typedef Tuple2<typename TupleTraits<A>::ParamType,
- typename TupleTraits<B>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C>
-struct TupleTypes< Tuple3<A, B, C> > {
- typedef Tuple3<typename TupleTraits<A>::ValueType,
- typename TupleTraits<B>::ValueType,
- typename TupleTraits<C>::ValueType> ValueTuple;
-typedef Tuple3<typename TupleTraits<A>::RefType,
- typename TupleTraits<B>::RefType,
- typename TupleTraits<C>::RefType> RefTuple;
- typedef Tuple3<typename TupleTraits<A>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D>
-struct TupleTypes< Tuple4<A, B, C, D> > {
- typedef Tuple4<typename TupleTraits<A>::ValueType,
- typename TupleTraits<B>::ValueType,
- typename TupleTraits<C>::ValueType,
- typename TupleTraits<D>::ValueType> ValueTuple;
-typedef Tuple4<typename TupleTraits<A>::RefType,
- typename TupleTraits<B>::RefType,
- typename TupleTraits<C>::RefType,
- typename TupleTraits<D>::RefType> RefTuple;
- typedef Tuple4<typename TupleTraits<A>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E>
-struct TupleTypes< Tuple5<A, B, C, D, E> > {
- typedef Tuple5<typename TupleTraits<A>::ValueType,
- typename TupleTraits<B>::ValueType,
- typename TupleTraits<C>::ValueType,
- typename TupleTraits<D>::ValueType,
- typename TupleTraits<E>::ValueType> ValueTuple;
-typedef Tuple5<typename TupleTraits<A>::RefType,
- typename TupleTraits<B>::RefType,
- typename TupleTraits<C>::RefType,
- typename TupleTraits<D>::RefType,
- typename TupleTraits<E>::RefType> RefTuple;
- typedef Tuple5<typename TupleTraits<A>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType,
- typename TupleTraits<E>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E, class F>
-struct TupleTypes< Tuple6<A, B, C, D, E, F> > {
- typedef Tuple6<typename TupleTraits<A>::ValueType,
- typename TupleTraits<B>::ValueType,
- typename TupleTraits<C>::ValueType,
- typename TupleTraits<D>::ValueType,
- typename TupleTraits<E>::ValueType,
- typename TupleTraits<F>::ValueType> ValueTuple;
-typedef Tuple6<typename TupleTraits<A>::RefType,
- typename TupleTraits<B>::RefType,
- typename TupleTraits<C>::RefType,
- typename TupleTraits<D>::RefType,
- typename TupleTraits<E>::RefType,
- typename TupleTraits<F>::RefType> RefTuple;
- typedef Tuple6<typename TupleTraits<A>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType,
- typename TupleTraits<E>::ParamType,
- typename TupleTraits<F>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E, class F, class G>
-struct TupleTypes< Tuple7<A, B, C, D, E, F, G> > {
- typedef Tuple7<typename TupleTraits<A>::ValueType,
- typename TupleTraits<B>::ValueType,
- typename TupleTraits<C>::ValueType,
- typename TupleTraits<D>::ValueType,
- typename TupleTraits<E>::ValueType,
- typename TupleTraits<F>::ValueType,
- typename TupleTraits<G>::ValueType> ValueTuple;
-typedef Tuple7<typename TupleTraits<A>::RefType,
- typename TupleTraits<B>::RefType,
- typename TupleTraits<C>::RefType,
- typename TupleTraits<D>::RefType,
- typename TupleTraits<E>::RefType,
- typename TupleTraits<F>::RefType,
- typename TupleTraits<G>::RefType> RefTuple;
- typedef Tuple7<typename TupleTraits<A>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType,
- typename TupleTraits<E>::ParamType,
- typename TupleTraits<F>::ParamType,
- typename TupleTraits<G>::ParamType> ParamTuple;
-};
-
-template <class A, class B, class C, class D, class E, class F, class G,
- class H>
-struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> > {
- typedef Tuple8<typename TupleTraits<A>::ValueType,
- typename TupleTraits<B>::ValueType,
- typename TupleTraits<C>::ValueType,
- typename TupleTraits<D>::ValueType,
- typename TupleTraits<E>::ValueType,
- typename TupleTraits<F>::ValueType,
- typename TupleTraits<G>::ValueType,
- typename TupleTraits<H>::ValueType> ValueTuple;
-typedef Tuple8<typename TupleTraits<A>::RefType,
- typename TupleTraits<B>::RefType,
- typename TupleTraits<C>::RefType,
- typename TupleTraits<D>::RefType,
- typename TupleTraits<E>::RefType,
- typename TupleTraits<F>::RefType,
- typename TupleTraits<G>::RefType,
- typename TupleTraits<H>::RefType> RefTuple;
- typedef Tuple8<typename TupleTraits<A>::ParamType,
- typename TupleTraits<B>::ParamType,
- typename TupleTraits<C>::ParamType,
- typename TupleTraits<D>::ParamType,
- typename TupleTraits<E>::ParamType,
- typename TupleTraits<F>::ParamType,
- typename TupleTraits<G>::ParamType,
- typename TupleTraits<H>::ParamType> ParamTuple;
+template <typename... Ts>
+struct TupleTypes<Tuple<Ts...>> {
+ using ValueTuple = Tuple<typename TupleTraits<Ts>::ValueType...>;
+ using RefTuple = Tuple<typename TupleTraits<Ts>::RefType...>;
+ using ParamTuple = Tuple<typename TupleTraits<Ts>::ParamType...>;
};
// Tuple creators -------------------------------------------------------------
@@ -421,105 +438,17 @@
// Helper functions for constructing tuples while inferring the template
// argument types.
-inline Tuple0 MakeTuple() {
- return Tuple0();
-}
-
-template <class A>
-inline Tuple1<A> MakeTuple(const A& a) {
- return Tuple1<A>(a);
-}
-
-template <class A, class B>
-inline Tuple2<A, B> MakeTuple(const A& a, const B& b) {
- return Tuple2<A, B>(a, b);
-}
-
-template <class A, class B, class C>
-inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c) {
- return Tuple3<A, B, C>(a, b, c);
-}
-
-template <class A, class B, class C, class D>
-inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c,
- const D& d) {
- return Tuple4<A, B, C, D>(a, b, c, d);
-}
-
-template <class A, class B, class C, class D, class E>
-inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c,
- const D& d, const E& e) {
- return Tuple5<A, B, C, D, E>(a, b, c, d, e);
-}
-
-template <class A, class B, class C, class D, class E, class F>
-inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c,
- const D& d, const E& e, const F& f) {
- return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G>
-inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c,
- const D& d, const E& e, const F& f,
- const G& g) {
- return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G,
- class H>
-inline Tuple8<A, B, C, D, E, F, G, H> MakeTuple(const A& a, const B& b,
- const C& c, const D& d,
- const E& e, const F& f,
- const G& g, const H& h) {
- return Tuple8<A, B, C, D, E, F, G, H>(a, b, c, d, e, f, g, h);
+template <typename... Ts>
+inline Tuple<Ts...> MakeTuple(const Ts&... arg) {
+ return Tuple<Ts...>(arg...);
}
// The following set of helpers make what Boost refers to as "Tiers" - a tuple
// of references.
-template <class A>
-inline Tuple1<A&> MakeRefTuple(A& a) {
- return Tuple1<A&>(a);
-}
-
-template <class A, class B>
-inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b) {
- return Tuple2<A&, B&>(a, b);
-}
-
-template <class A, class B, class C>
-inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c) {
- return Tuple3<A&, B&, C&>(a, b, c);
-}
-
-template <class A, class B, class C, class D>
-inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d) {
- return Tuple4<A&, B&, C&, D&>(a, b, c, d);
-}
-
-template <class A, class B, class C, class D, class E>
-inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e) {
- return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);
-}
-
-template <class A, class B, class C, class D, class E, class F>
-inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e,
- F& f) {
- return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G>
-inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d,
- E& e, F& f, G& g) {
- return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);
-}
-
-template <class A, class B, class C, class D, class E, class F, class G,
- class H>
-inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c,
- D& d, E& e, F& f,
- G& g, H& h) {
- return Tuple8<A&, B&, C&, D&, E&, F&, G&, H&>(a, b, c, d, e, f, g, h);
+template <typename... Ts>
+inline Tuple<Ts&...> MakeRefTuple(Ts&... arg) {
+ return Tuple<Ts&...>(arg...);
}
// Dispatchers ----------------------------------------------------------------
@@ -533,759 +462,94 @@
// Non-Static Dispatchers with no out params.
-template <class ObjT, class Method>
-inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg) {
- (obj->*method)();
-}
-
-template <class ObjT, class Method, class A>
+template <typename ObjT, typename Method, typename A>
inline void DispatchToMethod(ObjT* obj, Method method, const A& arg) {
(obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
}
-template <class ObjT, class Method, class A>
-inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
+template <typename ObjT, typename Method, typename... Ts, size_t... Ns>
+inline void DispatchToMethodImpl(ObjT* obj,
+ Method method,
+ const Tuple<Ts...>& arg,
+ IndexSequence<Ns...>) {
+ (obj->*method)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
}
-template<class ObjT, class Method, class A, class B>
+template <typename ObjT, typename Method, typename... Ts>
inline void DispatchToMethod(ObjT* obj,
Method method,
- const Tuple2<A, B>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b));
-}
-
-template<class ObjT, class Method, class A, class B, class C>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<A, B, C>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<A, B, C, D>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<A, B, C, D, E>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<A, B, C, D, E, F>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F, class G>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple7<A, B, C, D, E, F, G>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F, class G, class H>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple8<A, B, C, D, E, F, G, H>& arg) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g),
- base::internal::UnwrapTraits<H>::Unwrap(arg.h));
+ const Tuple<Ts...>& arg) {
+ DispatchToMethodImpl(obj, method, arg, MakeIndexSequence<sizeof...(Ts)>());
}
// Static Dispatchers with no out params.
-template <class Function>
-inline void DispatchToFunction(Function function, const Tuple0& arg) {
- (*function)();
+template <typename Function, typename A>
+inline void DispatchToMethod(Function function, const A& arg) {
+ (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg));
}
-template <class Function, class A>
-inline void DispatchToFunction(Function function, const A& arg) {
- (*function)(arg);
+template <typename Function, typename... Ts, size_t... Ns>
+inline void DispatchToFunctionImpl(Function function,
+ const Tuple<Ts...>& arg,
+ IndexSequence<Ns...>) {
+ (*function)(base::internal::UnwrapTraits<Ts>::Unwrap(get<Ns>(arg))...);
}
-template <class Function, class A>
-inline void DispatchToFunction(Function function, const Tuple1<A>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
+template <typename Function, typename... Ts>
+inline void DispatchToFunction(Function function, const Tuple<Ts...>& arg) {
+ DispatchToFunctionImpl(function, arg, MakeIndexSequence<sizeof...(Ts)>());
}
-template<class Function, class A, class B>
-inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b));
+// Dispatchers with out parameters.
+
+template <typename ObjT,
+ typename Method,
+ typename In,
+ typename... OutTs,
+ size_t... OutNs>
+inline void DispatchToMethodImpl(ObjT* obj,
+ Method method,
+ const In& in,
+ Tuple<OutTs...>* out,
+ IndexSequence<OutNs...>) {
+ (obj->*method)(base::internal::UnwrapTraits<In>::Unwrap(in),
+ &get<OutNs>(*out)...);
}
-template<class Function, class A, class B, class C>
-inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class Function, class A, class B, class C, class D>
-inline void DispatchToFunction(Function function,
- const Tuple4<A, B, C, D>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class Function, class A, class B, class C, class D, class E>
-inline void DispatchToFunction(Function function,
- const Tuple5<A, B, C, D, E>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class Function, class A, class B, class C, class D, class E, class F>
-inline void DispatchToFunction(Function function,
- const Tuple6<A, B, C, D, E, F>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-template<class Function, class A, class B, class C, class D, class E, class F,
- class G>
-inline void DispatchToFunction(Function function,
- const Tuple7<A, B, C, D, E, F, G>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g));
-}
-
-template<class Function, class A, class B, class C, class D, class E, class F,
- class G, class H>
-inline void DispatchToFunction(Function function,
- const Tuple8<A, B, C, D, E, F, G, H>& arg) {
- (*function)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f),
- base::internal::UnwrapTraits<G>::Unwrap(arg.g),
- base::internal::UnwrapTraits<H>::Unwrap(arg.h));
-}
-
-// Dispatchers with 0 out param (as a Tuple0).
-
-template <class ObjT, class Method>
+template <typename ObjT, typename Method, typename In, typename... OutTs>
inline void DispatchToMethod(ObjT* obj,
Method method,
- const Tuple0& arg, Tuple0*) {
- (obj->*method)();
+ const In& in,
+ Tuple<OutTs...>* out) {
+ DispatchToMethodImpl(obj, method, in, out,
+ MakeIndexSequence<sizeof...(OutTs)>());
}
-template <class ObjT, class Method, class A>
-inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg));
+template <typename ObjT,
+ typename Method,
+ typename... InTs,
+ typename... OutTs,
+ size_t... InNs,
+ size_t... OutNs>
+inline void DispatchToMethodImpl(ObjT* obj,
+ Method method,
+ const Tuple<InTs...>& in,
+ Tuple<OutTs...>* out,
+ IndexSequence<InNs...>,
+ IndexSequence<OutNs...>) {
+ (obj->*method)(base::internal::UnwrapTraits<InTs>::Unwrap(get<InNs>(in))...,
+ &get<OutNs>(*out)...);
}
-template <class ObjT, class Method, class A>
+template <typename ObjT, typename Method, typename... InTs, typename... OutTs>
inline void DispatchToMethod(ObjT* obj,
Method method,
- const Tuple1<A>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a));
-}
-
-template<class ObjT, class Method, class A, class B>
-inline void DispatchToMethod(ObjT* obj,
- Method method,
- const Tuple2<A, B>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b));
-}
-
-template<class ObjT, class Method, class A, class B, class C>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<A, B, C>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<A, B, C, D>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<A, B, C, D, E>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e));
-}
-
-template<class ObjT, class Method, class A, class B, class C, class D, class E,
- class F>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<A, B, C, D, E, F>& arg, Tuple0*) {
- (obj->*method)(base::internal::UnwrapTraits<A>::Unwrap(arg.a),
- base::internal::UnwrapTraits<B>::Unwrap(arg.b),
- base::internal::UnwrapTraits<C>::Unwrap(arg.c),
- base::internal::UnwrapTraits<D>::Unwrap(arg.d),
- base::internal::UnwrapTraits<E>::Unwrap(arg.e),
- base::internal::UnwrapTraits<F>::Unwrap(arg.f));
-}
-
-// Dispatchers with 1 out param.
-
-template<class ObjT, class Method,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple0& in,
- Tuple1<OutA>* out) {
- (obj->*method)(&out->a);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const InA& in,
- Tuple1<OutA>* out) {
- (obj->*method)(in, &out->a);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple1<InA>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class InE, class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple1<OutA>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a);
-}
-
-// Dispatchers with 2 out params.
-
-template<class ObjT, class Method,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple0& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(&out->a, &out->b);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const InA& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(in, &out->a, &out->b);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple1<InA>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(
- base::internal::UnwrapTraits<InA>::Unwrap(in.a), &out->a, &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple2<OutA, OutB>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b);
-}
-
-// Dispatchers with 3 out params.
-
-template<class ObjT, class Method,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple0& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(&out->a, &out->b, &out->c);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const InA& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(in, &out->a, &out->b, &out->c);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple1<InA>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b,
- &out->c);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB, class OutC>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple3<OutA, OutB, OutC>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b,
- &out->c);
-}
-
-// Dispatchers with 4 out params.
-
-template<class ObjT, class Method,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple0& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(&out->a, &out->b, &out->c, &out->d);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const InA& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple1<InA>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB, class OutC, class OutD>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple4<OutA, OutB, OutC, OutD>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b,
- &out->c,
- &out->d);
-}
-
-// Dispatchers with 5 out params.
-
-template<class ObjT, class Method,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple0& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const InA& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method, class InA,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple1<InA>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple2<InA, InB>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple3<InA, InB, InC>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method, class InA, class InB, class InC, class InD,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple4<InA, InB, InC, InD>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple5<InA, InB, InC, InD, InE>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
-}
-
-template<class ObjT, class Method,
- class InA, class InB, class InC, class InD, class InE, class InF,
- class OutA, class OutB, class OutC, class OutD, class OutE>
-inline void DispatchToMethod(ObjT* obj, Method method,
- const Tuple6<InA, InB, InC, InD, InE, InF>& in,
- Tuple5<OutA, OutB, OutC, OutD, OutE>* out) {
- (obj->*method)(base::internal::UnwrapTraits<InA>::Unwrap(in.a),
- base::internal::UnwrapTraits<InB>::Unwrap(in.b),
- base::internal::UnwrapTraits<InC>::Unwrap(in.c),
- base::internal::UnwrapTraits<InD>::Unwrap(in.d),
- base::internal::UnwrapTraits<InE>::Unwrap(in.e),
- base::internal::UnwrapTraits<InF>::Unwrap(in.f),
- &out->a,
- &out->b,
- &out->c,
- &out->d,
- &out->e);
+ const Tuple<InTs...>& in,
+ Tuple<OutTs...>* out) {
+ DispatchToMethodImpl(obj, method, in, out,
+ MakeIndexSequence<sizeof...(InTs)>(),
+ MakeIndexSequence<sizeof...(OutTs)>());
}
#endif // BASE_TUPLE_H__
diff --git a/build/OWNERS b/build/OWNERS
index 72e8ffc..d1529af 100644
--- a/build/OWNERS
+++ b/build/OWNERS
@@ -1 +1,3 @@
-*
+cjhopman@chromium.org
+scottmg@chromium.org
+thakis@chromium.org
diff --git a/build/all.gyp b/build/all.gyp
index 9c325fb..149ac0a 100644
--- a/build/all.gyp
+++ b/build/all.gyp
@@ -36,8 +36,14 @@
'../url/url.gyp:*',
],
'conditions': [
+ ['OS!="ios" and OS!="mac"', {
+ 'dependencies': [
+ '../ui/touch_selection/ui_touch_selection.gyp:*',
+ ],
+ }],
['OS=="ios"', {
'dependencies': [
+ '../chrome/chrome.gyp:browser',
'../ios/ios.gyp:*',
# NOTE: This list of targets is present because
# mojo_base.gyp:mojo_base cannot be built on iOS, as
@@ -312,6 +318,11 @@
'../url/url.gyp:url_unittests',
],
'conditions': [
+ ['OS!="ios" and OS!="mac"', {
+ 'dependencies': [
+ '../ui/touch_selection/ui_touch_selection.gyp:ui_touch_selection_unittests',
+ ],
+ }],
['OS!="ios" and OS!="android"', {
'dependencies': [
'../cc/blink/cc_blink_tests.gyp:cc_blink_unittests',
@@ -463,8 +474,10 @@
}],
['disable_nacl==0 and disable_nacl_untrusted==0', {
'dependencies': [
- '../mojo/mojo_nacl.gyp:*',
- '../testing/gtest_nacl.gyp:*',
+ '../mojo/mojo_nacl.gyp:mojo_nacl',
+ '../mojo/mojo_nacl.gyp:monacl_codegen',
+ '../mojo/mojo_nacl.gyp:monacl_sel',
+ '../mojo/mojo_nacl.gyp:monacl_shell',
],
}],
],
@@ -536,6 +549,7 @@
'../chrome/chrome.gyp:load_library_perf_tests',
'../chrome/chrome.gyp:performance_browser_tests',
'../chrome/chrome.gyp:sync_performance_tests',
+ '../content/content_shell_and_tests.gyp:content_shell',
'../media/media.gyp:media_perftests',
'../tools/perf/clear_system_cache/clear_system_cache.gyp:*',
'../tools/telemetry/telemetry.gyp:*',
@@ -834,6 +848,7 @@
'../tools/android/findbugs_plugin/findbugs_plugin.gyp:findbugs_plugin_test',
'../ui/base/ui_base_tests.gyp:ui_base_unittests',
'../ui/events/events.gyp:events_unittests',
+ '../ui/touch_selection/ui_touch_selection.gyp:ui_touch_selection_unittests',
# Unit test bundles packaged as an apk.
'../android_webview/android_webview.gyp:android_webview_test_apk',
'../android_webview/android_webview.gyp:android_webview_unittests_apk',
@@ -862,6 +877,7 @@
'../ui/base/ui_base_tests.gyp:ui_base_unittests_apk',
'../ui/events/events.gyp:events_unittests_apk',
'../ui/gfx/gfx_tests.gyp:gfx_unittests_apk',
+ '../ui/touch_selection/ui_touch_selection.gyp:ui_touch_selection_unittests_apk',
],
'conditions': [
['enable_webrtc==1 and "<(libpeer_target_type)"=="static_library"', {
@@ -1075,6 +1091,7 @@
'../ui/base/ui_base_tests.gyp:ui_base_unittests',
'../ui/events/events.gyp:events_unittests',
'../ui/gfx/gfx_tests.gyp:gfx_unittests',
+ '../ui/touch_selection/ui_touch_selection.gyp:ui_touch_selection_unittests',
'../ui/views/views.gyp:views_unittests',
'../url/url.gyp:url_unittests',
],
@@ -1179,6 +1196,7 @@
'../ui/events/events.gyp:events_unittests',
'../ui/gfx/gfx_tests.gyp:gfx_unittests',
'../ui/keyboard/keyboard.gyp:keyboard_unittests',
+ '../ui/touch_selection/ui_touch_selection.gyp:ui_touch_selection_unittests',
'../url/url.gyp:url_unittests',
],
},
@@ -1219,6 +1237,7 @@
'../third_party/widevine/cdm/widevine_cdm.gyp:widevinecdmadapter',
'../ui/base/ui_base_tests.gyp:ui_base_unittests',
'../ui/gfx/gfx_tests.gyp:gfx_unittests',
+ '../ui/touch_selection/ui_touch_selection.gyp:ui_touch_selection_unittests',
'../ui/views/views.gyp:views_unittests',
'../url/url.gyp:url_unittests',
],
@@ -1267,6 +1286,7 @@
'../ui/keyboard/keyboard.gyp:*',
'../ui/message_center/message_center.gyp:*',
'../ui/snapshot/snapshot.gyp:snapshot_unittests',
+ '../ui/touch_selection/ui_touch_selection.gyp:ui_touch_selection_unittests',
'../ui/views/examples/examples.gyp:views_examples_with_content_exe',
'../ui/views/views.gyp:views',
'../ui/views/views.gyp:views_unittests',
diff --git a/build/android/OWNERS b/build/android/OWNERS
new file mode 100644
index 0000000..bd675fb
--- /dev/null
+++ b/build/android/OWNERS
@@ -0,0 +1,2 @@
+jbudorick@chromium.org
+klundberg@chromium.org
diff --git a/build/android/adb_run_mojo_shell b/build/android/adb_run_mojo_shell
index 18e796d..b585e4a 100755
--- a/build/android/adb_run_mojo_shell
+++ b/build/android/adb_run_mojo_shell
@@ -5,10 +5,12 @@
# found in the LICENSE file.
optional_url=$1
+parameters=$2
adb logcat -c
adb shell am start -S \
-a android.intent.action.VIEW \
-n org.chromium.mojo_shell_apk/.MojoShellActivity \
+ ${parameters:+--esa parameters "$parameters"} \
${optional_url:+-d "$optional_url"}
adb logcat -s MojoShellApplication MojoShellActivity chromium
diff --git a/build/android/gyp/write_build_config.py b/build/android/gyp/write_build_config.py
index a14ef77..bf887e3 100755
--- a/build/android/gyp/write_build_config.py
+++ b/build/android/gyp/write_build_config.py
@@ -95,13 +95,14 @@
if not options.type in [
- 'java_library', 'android_resources', 'android_apk']:
+ 'java_library', 'android_resources', 'android_apk', 'deps_dex']:
raise Exception('Unknown type: <%s>' % options.type)
required_options = ['build_config'] + {
'java_library': ['jar_path'],
'android_resources': ['resources_zip'],
- 'android_apk': ['jar_path', 'dex_path', 'resources_zip']
+ 'android_apk': ['jar_path', 'dex_path', 'resources_zip'],
+ 'deps_dex': ['dex_path']
}[options.type]
if options.native_libs:
@@ -213,10 +214,8 @@
c['package_name'] for c in all_resources_deps if 'package_name' in c]
- # Dependencies for the final dex file of an apk or the standalone .dex.jar
- # output of a library.
- if options.type == 'android_apk' or (options.type == "java_library"
- and options.supports_android):
+ # Dependencies for the final dex file of an apk or a 'deps_dex'.
+ if options.type in ['android_apk', 'deps_dex']:
config['final_dex'] = {}
dex_config = config['final_dex']
# TODO(cjhopman): proguard version
diff --git a/build/android/pylib/device/device_utils.py b/build/android/pylib/device/device_utils.py
index 403f235..553e960 100644
--- a/build/android/pylib/device/device_utils.py
+++ b/build/android/pylib/device/device_utils.py
@@ -19,6 +19,7 @@
import pylib.android_commands
from pylib import cmd_helper
+from pylib import constants
from pylib.device import adb_wrapper
from pylib.device import decorators
from pylib.device import device_errors
@@ -42,7 +43,17 @@
Returns:
A list containing the configured AVDs.
"""
- return pylib.android_commands.GetAVDs()
+ lines = cmd_helper.GetCmdOutput([
+ os.path.join(constants.ANDROID_SDK_ROOT, 'tools', 'android'),
+ 'list', 'avd']).splitlines()
+ avds = []
+ for line in lines:
+ if 'Name:' not in line:
+ continue
+ key, value = (s.strip() for s in line.split(':', 1))
+ if key == 'Name':
+ avds.append(value)
+ return avds
@decorators.WithExplicitTimeoutAndRetries(
@@ -343,30 +354,15 @@
DeviceUnreachableError on missing device.
"""
package_name = apk_helper.GetPackageName(apk_path)
- device_path = self.old_interface.GetApplicationPath(package_name)
+ device_path = self.GetApplicationPath(package_name)
if device_path is not None:
- files_changed = self.old_interface.GetFilesChanged(
- apk_path, device_path, ignore_filenames=True)
- if len(files_changed) > 0:
- should_install = True
- if not reinstall:
- out = self.old_interface.Uninstall(package_name)
- for line in out.splitlines():
- if 'Failure' in line:
- raise device_errors.CommandFailedError(line.strip(), str(self))
- else:
- should_install = False
+ should_install = bool(self._GetChangedFilesImpl(apk_path, device_path))
+ if should_install and not reinstall:
+ self.adb.Uninstall(package_name)
else:
should_install = True
if should_install:
- try:
- out = self.old_interface.Install(apk_path, reinstall=reinstall)
- for line in out.splitlines():
- if 'Failure' in line:
- raise device_errors.CommandFailedError(line.strip(), str(self))
- except AssertionError as e:
- raise device_errors.CommandFailedError(
- str(e), str(self)), None, sys.exc_info()[2]
+ self.adb.Install(apk_path, reinstall=reinstall)
@decorators.WithTimeoutAndRetriesFromInstance()
def RunShellCommand(self, cmd, check_return=False, cwd=None, env=None,
diff --git a/build/android/pylib/device/device_utils_test.py b/build/android/pylib/device/device_utils_test.py
index 512a7d4..c451ef3 100755
--- a/build/android/pylib/device/device_utils_test.py
+++ b/build/android/pylib/device/device_utils_test.py
@@ -69,6 +69,21 @@
device_utils.DeviceUtils('')
+class DeviceUtilsGetAVDsTest(mock_calls.TestCase):
+
+ def testGetAVDs(self):
+ with self.assertCall(
+ mock.call.pylib.cmd_helper.GetCmdOutput([mock.ANY, 'list', 'avd']),
+ 'Available Android Virtual Devices:\n'
+ ' Name: my_android5.0\n'
+ ' Path: /some/path/to/.android/avd/my_android5.0.avd\n'
+ ' Target: Android 5.0 (API level 21)\n'
+ ' Tag/ABI: default/x86\n'
+ ' Skin: WVGA800\n'):
+ self.assertEquals(['my_android5.0'],
+ device_utils.GetAVDs())
+
+
class MockTempFile(object):
def __init__(self, name='/tmp/some/file'):
@@ -496,86 +511,61 @@
self.device.Reboot(block=True)
-class DeviceUtilsInstallTest(DeviceUtilsOldImplTest):
+class DeviceUtilsInstallTest(DeviceUtilsNewImplTest):
def testInstall_noPriorInstall(self):
- with mock.patch('os.path.isfile', return_value=True), (
- mock.patch('pylib.utils.apk_helper.GetPackageName',
- return_value='this.is.a.test.package')):
- with self.assertCallsSequence([
- ("adb -s 0123456789abcdef shell 'pm path this.is.a.test.package'",
- ''),
- ("adb -s 0123456789abcdef install /fake/test/app.apk",
- 'Success\r\n')]):
- self.device.Install('/fake/test/app.apk', retries=0)
+ with self.assertCalls(
+ (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
+ 'this.is.a.test.package'),
+ (self.call.device.GetApplicationPath('this.is.a.test.package'), None),
+ self.call.adb.Install('/fake/test/app.apk', reinstall=False)):
+ self.device.Install('/fake/test/app.apk', retries=0)
def testInstall_differentPriorInstall(self):
- def mockGetFilesChanged(host_path, device_path, ignore_filenames):
- return [(host_path, device_path)]
-
- with mock.patch('os.path.isfile', return_value=True), (
- mock.patch('os.path.exists', return_value=True)), (
- mock.patch('pylib.utils.apk_helper.GetPackageName',
- return_value='this.is.a.test.package')), (
- mock.patch('pylib.constants.GetOutDirectory',
- return_value='/fake/test/out')), (
- mock.patch('pylib.android_commands.AndroidCommands.GetFilesChanged',
- side_effect=mockGetFilesChanged)):
- with self.assertCallsSequence([
- ("adb -s 0123456789abcdef shell 'pm path this.is.a.test.package'",
- 'package:/fake/data/app/this.is.a.test.package.apk\r\n'),
- # GetFilesChanged is mocked, so its adb calls are omitted.
- ('adb -s 0123456789abcdef uninstall this.is.a.test.package',
- 'Success\r\n'),
- ('adb -s 0123456789abcdef install /fake/test/app.apk',
- 'Success\r\n')]):
- self.device.Install('/fake/test/app.apk', retries=0)
+ with self.assertCalls(
+ (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
+ 'this.is.a.test.package'),
+ (self.call.device.GetApplicationPath('this.is.a.test.package'),
+ '/fake/data/app/this.is.a.test.package.apk'),
+ (self.call.device._GetChangedFilesImpl(
+ '/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk'),
+ [('/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk')]),
+ self.call.adb.Uninstall('this.is.a.test.package'),
+ self.call.adb.Install('/fake/test/app.apk', reinstall=False)):
+ self.device.Install('/fake/test/app.apk', retries=0)
def testInstall_differentPriorInstall_reinstall(self):
- def mockGetFilesChanged(host_path, device_path, ignore_filenames):
- return [(host_path, device_path)]
-
- with mock.patch('os.path.isfile', return_value=True), (
- mock.patch('pylib.utils.apk_helper.GetPackageName',
- return_value='this.is.a.test.package')), (
- mock.patch('pylib.constants.GetOutDirectory',
- return_value='/fake/test/out')), (
- mock.patch('pylib.android_commands.AndroidCommands.GetFilesChanged',
- side_effect=mockGetFilesChanged)):
- with self.assertCallsSequence([
- ("adb -s 0123456789abcdef shell 'pm path this.is.a.test.package'",
- 'package:/fake/data/app/this.is.a.test.package.apk\r\n'),
- # GetFilesChanged is mocked, so its adb calls are omitted.
- ('adb -s 0123456789abcdef install -r /fake/test/app.apk',
- 'Success\r\n')]):
- self.device.Install('/fake/test/app.apk', reinstall=True, retries=0)
+ with self.assertCalls(
+ (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
+ 'this.is.a.test.package'),
+ (self.call.device.GetApplicationPath('this.is.a.test.package'),
+ '/fake/data/app/this.is.a.test.package.apk'),
+ (self.call.device._GetChangedFilesImpl(
+ '/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk'),
+ [('/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk')]),
+ self.call.adb.Install('/fake/test/app.apk', reinstall=True)):
+ self.device.Install('/fake/test/app.apk', reinstall=True, retries=0)
def testInstall_identicalPriorInstall(self):
- def mockGetFilesChanged(host_path, device_path, ignore_filenames):
- return []
-
- with mock.patch('pylib.utils.apk_helper.GetPackageName',
- return_value='this.is.a.test.package'), (
- mock.patch('pylib.android_commands.AndroidCommands.GetFilesChanged',
- side_effect=mockGetFilesChanged)):
- with self.assertCallsSequence([
- ("adb -s 0123456789abcdef shell 'pm path this.is.a.test.package'",
- 'package:/fake/data/app/this.is.a.test.package.apk\r\n')
- # GetFilesChanged is mocked, so its adb calls are omitted.
- ]):
- self.device.Install('/fake/test/app.apk', retries=0)
+ with self.assertCalls(
+ (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
+ 'this.is.a.test.package'),
+ (self.call.device.GetApplicationPath('this.is.a.test.package'),
+ '/fake/data/app/this.is.a.test.package.apk'),
+ (self.call.device._GetChangedFilesImpl(
+ '/fake/test/app.apk', '/fake/data/app/this.is.a.test.package.apk'),
+ [])):
+ self.device.Install('/fake/test/app.apk', retries=0)
def testInstall_fails(self):
- with mock.patch('os.path.isfile', return_value=True), (
- mock.patch('pylib.utils.apk_helper.GetPackageName',
- return_value='this.is.a.test.package')):
- with self.assertCallsSequence([
- ("adb -s 0123456789abcdef shell 'pm path this.is.a.test.package'",
- ''),
- ("adb -s 0123456789abcdef install /fake/test/app.apk",
- 'Failure\r\n')]):
- with self.assertRaises(device_errors.CommandFailedError):
- self.device.Install('/fake/test/app.apk', retries=0)
+ with self.assertCalls(
+ (mock.call.pylib.utils.apk_helper.GetPackageName('/fake/test/app.apk'),
+ 'this.is.a.test.package'),
+ (self.call.device.GetApplicationPath('this.is.a.test.package'), None),
+ (self.call.adb.Install('/fake/test/app.apk', reinstall=False),
+ self.CommandError('Failure\r\n'))):
+ with self.assertRaises(device_errors.CommandFailedError):
+ self.device.Install('/fake/test/app.apk', retries=0)
class DeviceUtilsRunShellCommandTest(DeviceUtilsNewImplTest):
diff --git a/build/android/pylib/gtest/gtest_config.py b/build/android/pylib/gtest/gtest_config.py
index 0cb8b35..20aaf68 100644
--- a/build/android/pylib/gtest/gtest_config.py
+++ b/build/android/pylib/gtest/gtest_config.py
@@ -36,6 +36,7 @@
'sql_unittests',
'sync_unit_tests',
'ui_base_unittests',
+ 'ui_touch_selection_unittests',
'unit_tests',
'webkit_unit_tests',
]
diff --git a/build/android/test_runner.py b/build/android/test_runner.py
index 1c06331..68827b9 100755
--- a/build/android/test_runner.py
+++ b/build/android/test_runner.py
@@ -864,8 +864,8 @@
results=results,
test_type=test.TestType(),
test_package=test_run.TestPackage(),
- annotation=args.annotations,
- flakiness_server=args.flakiness_dashboard_server)
+ annotation=getattr(args, 'annotations', None),
+ flakiness_server=getattr(args, 'flakiness_dashboard_server', None))
if args.json_results_file:
json_results.GenerateJsonResultsFile(
diff --git a/build/build-ctags.sh b/build/build-ctags.sh
index 825da27..61e017e 100755
--- a/build/build-ctags.sh
+++ b/build/build-ctags.sh
@@ -36,7 +36,7 @@
# errors about components that you just happen to have not built (NaCl, for
# example).
$(ctags_cmd "$extraexcludes") 2> /dev/null || fail $1
- mv -f .tmp_tags .tags
+ mv -f .tmp_tags tags
}
# We always build the top level but leave all submodules as optional.
diff --git a/build/common.gypi b/build/common.gypi
index 204a133..c899e14 100644
--- a/build/common.gypi
+++ b/build/common.gypi
@@ -1974,7 +1974,7 @@
'enable_pepper_cdms%': 0,
}],
- ['OS=="android"', {
+ ['OS=="android" or chromecast==1', {
'enable_browser_cdms%': 1,
}, {
'enable_browser_cdms%': 0,
diff --git a/build/config/android/config.gni b/build/config/android/config.gni
index 82405dd..60934c2 100644
--- a/build/config/android/config.gni
+++ b/build/config/android/config.gni
@@ -12,7 +12,9 @@
if (has_chrome_android_internal) {
import("//clank/config.gni")
- } else {
+ }
+
+ if (!defined(default_android_sdk_root)) {
default_android_sdk_root = "//third_party/android_tools/sdk"
default_android_sdk_version = "21"
default_android_sdk_build_tools_version = "21.0.1"
diff --git a/build/config/android/internal_rules.gni b/build/config/android/internal_rules.gni
index ce6e428..3772769 100644
--- a/build/config/android/internal_rules.gni
+++ b/build/config/android/internal_rules.gni
@@ -66,12 +66,13 @@
testonly = invoker.testonly
}
- assert(defined(invoker.sources))
assert(defined(invoker.output))
action(target_name) {
script = "//build/android/gyp/dex.py"
depfile = "$target_gen_dir/$target_name.d"
- sources = invoker.sources
+ if (defined(invoker.sources)) {
+ sources = invoker.sources
+ }
outputs = [
depfile,
invoker.output,
@@ -103,7 +104,9 @@
args += invoker.args
}
- args += rebase_path(invoker.sources, root_build_dir)
+ if (defined(invoker.sources)) {
+ args += rebase_path(invoker.sources, root_build_dir)
+ }
}
}
@@ -163,7 +166,7 @@
build_config = invoker.build_config
assert(type == "android_apk" || type == "java_library" ||
- type == "android_resources")
+ type == "android_resources" || type == "deps_dex")
action(target_name) {
script = "//build/android/gyp/write_build_config.py"
@@ -201,11 +204,12 @@
is_java_library = type == "java_library"
is_apk = type == "android_apk"
is_android_resources = type == "android_resources"
+ is_deps_dex = type == "deps_dex"
- supports_android = is_apk || is_android_resources ||
+ supports_android = is_apk || is_android_resources || is_deps_dex ||
(is_java_library && defined(invoker.supports_android) &&
invoker.supports_android)
- requires_android = is_apk || is_android_resources ||
+ requires_android = is_apk || is_android_resources || is_deps_dex ||
(is_java_library && defined(invoker.requires_android) &&
invoker.requires_android)
@@ -216,6 +220,7 @@
assert(is_java_library || true)
assert(is_apk || true)
assert(is_android_resources || true)
+ assert(is_deps_dex || true)
if (is_java_library || is_apk) {
args += [
@@ -224,7 +229,7 @@
]
}
- if (is_apk || (is_java_library && supports_android)) {
+ if (is_apk || is_deps_dex || (is_java_library && supports_android)) {
args += [
"--dex-path",
rebase_path(invoker.dex_path, root_build_dir),
@@ -898,22 +903,6 @@
]
output = _dex_path
}
-
- if (defined(invoker.standalone_dex_path)) {
- _final_deps += [ ":${_template_name}__standalone_dex" ]
- _rebased_build_config = rebase_path(_build_config, root_build_dir)
- dex("${_template_name}__standalone_dex") {
- sources = [
- _jar_path,
- ]
- inputs = [
- _build_config,
- ]
- output = invoker.standalone_dex_path
- dex_arg_key = "${_rebased_build_config}:final_dex:dependency_dex_files"
- args = [ "--inputs=@FileArg($dex_arg_key)" ]
- }
- }
}
group(target_name) {
@@ -1061,3 +1050,25 @@
}
}
}
+
+# Produces a single .dex.jar out of a set of Java dependencies.
+template("deps_dex") {
+ build_config = "$target_gen_dir/${target_name}.build_config"
+ write_build_config("${target_name}__build_config") {
+ type = "deps_dex"
+ deps = invoker.deps
+
+ build_config = build_config
+ dex_path = invoker.dex_path
+ }
+
+ rebased_build_config = rebase_path(build_config, root_build_dir)
+ dex(target_name) {
+ inputs = [
+ build_config,
+ ]
+ output = invoker.dex_path
+ dex_arg_key = "${rebased_build_config}:final_dex:dependency_dex_files"
+ args = [ "--inputs=@FileArg($dex_arg_key)" ]
+ }
+}
diff --git a/build/config/android/rules.gni b/build/config/android/rules.gni
index 5d0cb37..5075da9 100644
--- a/build/config/android/rules.gni
+++ b/build/config/android/rules.gni
@@ -922,8 +922,6 @@
#
# dex_path: If set, the resulting .dex.jar file will be placed under this
# path.
-# standalone_dex_path: If set, a standalone .dex.jar containing the code from
-# the library and all dependencies will be placed under this path.
#
#
# Example
@@ -986,9 +984,6 @@
if (defined(invoker.dex_path)) {
dex_path = invoker.dex_path
}
- if (defined(invoker.standalone_dex_path)) {
- standalone_dex_path = invoker.standalone_dex_path
- }
supports_android = true
requires_android = true
@@ -1005,6 +1000,20 @@
}
}
+# Declare a target that packages a set of Java dependencies into a standalone
+# .dex.jar.
+#
+# Variables
+# deps: specifies the dependencies of this target. Android libraries in deps
+# will be packaged into the resulting .dex.jar file.
+# dex_path: location at which the output file will be put
+template("android_standalone_library") {
+ deps_dex(target_name) {
+ deps = invoker.deps
+ dex_path = invoker.dex_path
+ }
+}
+
# Declare an Android library target for a prebuilt jar
#
# This target creates an Android library containing java code and Android
@@ -1399,8 +1408,7 @@
group(target_name) {
deps = final_deps
if (defined(invoker.datadeps)) {
- # TODO(cjhopman): Fix this when group datadeps works.
- deps += invoker.datadeps
+ datadeps = invoker.datadeps
}
}
}
@@ -1455,6 +1463,9 @@
"//tools/android/forwarder2",
"//tools/android/md5sum",
]
+ if (defined(invoker.datadeps)) {
+ datadeps += invoker.datadeps
+ }
}
}
diff --git a/build/ios/grit_whitelist.txt b/build/ios/grit_whitelist.txt
index 17d9f89..0d9faa0 100644
--- a/build/ios/grit_whitelist.txt
+++ b/build/ios/grit_whitelist.txt
@@ -153,6 +153,7 @@
IDS_AUTOFILL_FIELD_LABEL_STATE
IDS_AUTOFILL_FIELD_LABEL_ZIP_CODE
IDS_AUTOFILL_OPTIONS_POPUP
+IDS_AUTOFILL_PASSWORD_FIELD_SUGGESTIONS_TITLE
IDS_AUTOFILL_SCAN_CREDIT_CARD
IDS_AUTOFILL_WARNING_FORM_DISABLED
IDS_AUTOFILL_WARNING_INSECURE_CONNECTION
diff --git a/build/sanitizers/sanitizer_options.cc b/build/sanitizers/sanitizer_options.cc
index a3b05c1..614a4a6 100644
--- a/build/sanitizers/sanitizer_options.cc
+++ b/build/sanitizers/sanitizer_options.cc
@@ -71,7 +71,8 @@
#elif defined(OS_MACOSX)
const char *kAsanDefaultOptions =
"strict_memcmp=0 replace_intrin=0 check_printf=1 use_sigaltstack=1 "
- "strip_path_prefix=Release/../../ fast_unwind_on_fatal=1 ";
+ "strip_path_prefix=Release/../../ fast_unwind_on_fatal=1 "
+ "detect_stack_use_after_return=1 ";
static const char kNaClDefaultOptions[] = "handle_segv=0";
static const char kNaClFlag[] = "--type=nacl-loader";
#endif // OS_LINUX
diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 0e1a6a3..592fd6e 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -320,8 +320,8 @@
"quads/yuv_video_draw_quad.h",
"resources/bitmap_content_layer_updater.cc",
"resources/bitmap_content_layer_updater.h",
- "resources/bitmap_raster_worker_pool.cc",
- "resources/bitmap_raster_worker_pool.h",
+ "resources/bitmap_tile_task_worker_pool.cc",
+ "resources/bitmap_tile_task_worker_pool.h",
"resources/bitmap_skpicture_content_layer_updater.cc",
"resources/bitmap_skpicture_content_layer_updater.h",
"resources/clip_display_item.cc",
@@ -342,8 +342,8 @@
"resources/eviction_tile_priority_queue.h",
"resources/filter_display_item.cc",
"resources/filter_display_item.h",
- "resources/gpu_raster_worker_pool.cc",
- "resources/gpu_raster_worker_pool.h",
+ "resources/gpu_tile_task_worker_pool.cc",
+ "resources/gpu_tile_task_worker_pool.h",
"resources/image_layer_updater.cc",
"resources/image_layer_updater.h",
"resources/layer_painter.h",
@@ -357,8 +357,8 @@
"resources/managed_tile_state.h",
"resources/memory_history.cc",
"resources/memory_history.h",
- "resources/one_copy_raster_worker_pool.cc",
- "resources/one_copy_raster_worker_pool.h",
+ "resources/one_copy_tile_task_worker_pool.cc",
+ "resources/one_copy_tile_task_worker_pool.h",
"resources/picture.cc",
"resources/picture.h",
"resources/picture_layer_tiling.cc",
@@ -369,8 +369,8 @@
"resources/picture_pile.h",
"resources/picture_pile_impl.cc",
"resources/picture_pile_impl.h",
- "resources/pixel_buffer_raster_worker_pool.cc",
- "resources/pixel_buffer_raster_worker_pool.h",
+ "resources/pixel_buffer_tile_task_worker_pool.cc",
+ "resources/pixel_buffer_tile_task_worker_pool.h",
"resources/platform_color.h",
"resources/prioritized_resource.cc",
"resources/prioritized_resource.h",
@@ -385,10 +385,10 @@
"resources/raster_source_helper.h",
"resources/raster_tile_priority_queue.cc",
"resources/raster_tile_priority_queue.h",
- "resources/raster_worker_pool.cc",
- "resources/raster_worker_pool.h",
- "resources/rasterizer.cc",
- "resources/rasterizer.h",
+ "resources/tile_task_worker_pool.cc",
+ "resources/tile_task_worker_pool.h",
+ "resources/tile_task_runner.cc",
+ "resources/tile_task_runner.h",
"resources/release_callback.h",
"resources/resource.cc",
"resources/resource.h",
@@ -449,8 +449,8 @@
"resources/ui_resource_client.h",
"resources/ui_resource_request.cc",
"resources/ui_resource_request.h",
- "resources/zero_copy_raster_worker_pool.cc",
- "resources/zero_copy_raster_worker_pool.h",
+ "resources/zero_copy_tile_task_worker_pool.cc",
+ "resources/zero_copy_tile_task_worker_pool.h",
"scheduler/begin_frame_source.cc",
"scheduler/begin_frame_source.h",
"scheduler/delay_based_time_source.cc",
@@ -755,7 +755,7 @@
"resources/picture_pile_unittest.cc",
"resources/picture_unittest.cc",
"resources/prioritized_resource_unittest.cc",
- "resources/raster_worker_pool_unittest.cc",
+ "resources/tile_task_worker_pool_unittest.cc",
"resources/resource_provider_unittest.cc",
"resources/resource_update_controller_unittest.cc",
"resources/scoped_resource_unittest.cc",
@@ -835,7 +835,7 @@
"layers/picture_layer_impl_perftest.cc",
"resources/picture_layer_tiling_perftest.cc",
"resources/picture_pile_impl_perftest.cc",
- "resources/raster_worker_pool_perftest.cc",
+ "resources/tile_task_worker_pool_perftest.cc",
"resources/task_graph_runner_perftest.cc",
"resources/tile_manager_perftest.cc",
"test/cc_test_suite.cc",
diff --git a/cc/base/scoped_ptr_vector.h b/cc/base/scoped_ptr_vector.h
index 164b27c..b552d73 100644
--- a/cc/base/scoped_ptr_vector.h
+++ b/cc/base/scoped_ptr_vector.h
@@ -159,6 +159,30 @@
std::swap(*writable_a, *writable_b);
}
+ // This acts like std::remove_if but with one key difference. The values to be
+ // removed to will each appear exactly once at or after the returned iterator,
+ // so that erase(foo.remove_if(P), foo.end()) will not leak or double-free the
+ // pointers in the vector.
+ template <typename Predicate>
+ iterator remove_if(Predicate predicate) {
+ typename std::vector<T*>::iterator it =
+ std::find_if(data_.begin(), data_.end(), predicate);
+ typename std::vector<T*>::iterator end = data_.end();
+ if (it == end)
+ return it;
+ typename std::vector<T*>::iterator result = it;
+ ++it;
+ for (; it != end; ++it) {
+ if (!static_cast<bool>(predicate(*it))) {
+ // Swap here instead of just assign to |result| so that all the
+ // pointers are preserved to be deleted afterward.
+ std::swap(*result, *it);
+ ++result;
+ }
+ }
+ return result;
+ }
+
template<class Compare>
inline void sort(Compare comp) {
std::sort(data_.begin(), data_.end(), comp);
diff --git a/cc/base/scoped_ptr_vector_unittest.cc b/cc/base/scoped_ptr_vector_unittest.cc
index 391ab48..7b9a86b 100644
--- a/cc/base/scoped_ptr_vector_unittest.cc
+++ b/cc/base/scoped_ptr_vector_unittest.cc
@@ -101,5 +101,84 @@
EXPECT_EQ(2u, even_numbers.size());
}
+class DataWithDestruction {
+ public:
+ static scoped_ptr<DataWithDestruction> Create(int i, int* destroy_count) {
+ return make_scoped_ptr(new DataWithDestruction(i, destroy_count));
+ }
+ int data() const { return data_; }
+ ~DataWithDestruction() { ++(*destroy_count_); }
+
+ private:
+ explicit DataWithDestruction(int i, int* destroy_count)
+ : data_(i), destroy_count_(destroy_count) {}
+ int data_;
+ int* destroy_count_;
+};
+
+TEST(ScopedPtrVectorTest, RemoveIf) {
+ ScopedPtrVector<DataWithDestruction> v;
+ int destroyed[6] = {0};
+ v.push_back(DataWithDestruction::Create(1, &destroyed[0]));
+ v.push_back(DataWithDestruction::Create(2, &destroyed[1]));
+ v.push_back(DataWithDestruction::Create(3, &destroyed[2]));
+ v.push_back(DataWithDestruction::Create(3, &destroyed[3]));
+ v.push_back(DataWithDestruction::Create(4, &destroyed[4]));
+ v.push_back(DataWithDestruction::Create(5, &destroyed[5]));
+
+ int expect_destroyed[6] = {0};
+
+ // Removing more than one thing that matches.
+ auto is_three = [](DataWithDestruction* d) { return d->data() == 3; };
+ v.erase(v.remove_if(is_three), v.end());
+ EXPECT_EQ(4u, v.size());
+ expect_destroyed[2]++;
+ expect_destroyed[3]++;
+ for (size_t i = 0; i < arraysize(destroyed); ++i)
+ EXPECT_EQ(expect_destroyed[i], destroyed[i]) << i;
+ {
+ int expect_data[4] = {1, 2, 4, 5};
+ for (size_t i = 0; i < arraysize(expect_data); ++i)
+ EXPECT_EQ(expect_data[i], v[i]->data()) << i;
+ }
+
+ // Removing from the back of the vector.
+ auto is_five = [](DataWithDestruction* d) { return d->data() == 5; };
+ v.erase(v.remove_if(is_five), v.end());
+ EXPECT_EQ(3u, v.size());
+ expect_destroyed[5]++;
+ for (size_t i = 0; i < arraysize(destroyed); ++i)
+ EXPECT_EQ(expect_destroyed[i], destroyed[i]) << i;
+ {
+ int expect_data[3] = {1, 2, 4};
+ for (size_t i = 0; i < arraysize(expect_data); ++i)
+ EXPECT_EQ(expect_data[i], v[i]->data()) << i;
+ }
+
+ // Removing from the front of the vector.
+ auto is_one = [](DataWithDestruction* d) { return d->data() == 1; };
+ v.erase(v.remove_if(is_one), v.end());
+ EXPECT_EQ(2u, v.size());
+ expect_destroyed[0]++;
+ for (size_t i = 0; i < arraysize(destroyed); ++i)
+ EXPECT_EQ(expect_destroyed[i], destroyed[i]) << i;
+ {
+ int expect_data[2] = {2, 4};
+ for (size_t i = 0; i < arraysize(expect_data); ++i)
+ EXPECT_EQ(expect_data[i], v[i]->data()) << i;
+ }
+
+ // Removing things that aren't in the vector does nothing.
+ v.erase(v.remove_if(is_one), v.end());
+ EXPECT_EQ(2u, v.size());
+ for (size_t i = 0; i < arraysize(destroyed); ++i)
+ EXPECT_EQ(expect_destroyed[i], destroyed[i]) << i;
+ {
+ int expect_data[2] = {2, 4};
+ for (size_t i = 0; i < arraysize(expect_data); ++i)
+ EXPECT_EQ(expect_data[i], v[i]->data()) << i;
+ }
+}
+
} // namespace
} // namespace cc
diff --git a/cc/blink/web_layer_impl_fixed_bounds_unittest.cc b/cc/blink/web_layer_impl_fixed_bounds_unittest.cc
index 083b0cf..c9fd4fa 100644
--- a/cc/blink/web_layer_impl_fixed_bounds_unittest.cc
+++ b/cc/blink/web_layer_impl_fixed_bounds_unittest.cc
@@ -53,8 +53,8 @@
original_point.y() * bounds.height / fixed_bounds.height(),
original_point.z());
// Test if the bounds scale is correctly applied in transform.
- EXPECT_EQ(scaled_point,
- TransformPoint(layer->layer()->transform(), original_point));
+ EXPECT_POINT3F_EQ(scaled_point, TransformPoint(layer->layer()->transform(),
+ original_point));
}
TEST(WebLayerImplFixedBoundsTest, BoundsScaleSimple) {
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 5967098..43e4b20 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -355,8 +355,8 @@
'quads/yuv_video_draw_quad.h',
'resources/bitmap_content_layer_updater.cc',
'resources/bitmap_content_layer_updater.h',
- 'resources/bitmap_raster_worker_pool.cc',
- 'resources/bitmap_raster_worker_pool.h',
+ 'resources/bitmap_tile_task_worker_pool.cc',
+ 'resources/bitmap_tile_task_worker_pool.h',
'resources/bitmap_skpicture_content_layer_updater.cc',
'resources/bitmap_skpicture_content_layer_updater.h',
'resources/clip_display_item.cc',
@@ -377,8 +377,8 @@
'resources/eviction_tile_priority_queue.h',
'resources/filter_display_item.cc',
'resources/filter_display_item.h',
- 'resources/gpu_raster_worker_pool.cc',
- 'resources/gpu_raster_worker_pool.h',
+ 'resources/gpu_tile_task_worker_pool.cc',
+ 'resources/gpu_tile_task_worker_pool.h',
'resources/image_layer_updater.cc',
'resources/image_layer_updater.h',
'resources/layer_painter.h',
@@ -392,8 +392,8 @@
'resources/managed_tile_state.h',
'resources/memory_history.cc',
'resources/memory_history.h',
- 'resources/one_copy_raster_worker_pool.cc',
- 'resources/one_copy_raster_worker_pool.h',
+ 'resources/one_copy_tile_task_worker_pool.cc',
+ 'resources/one_copy_tile_task_worker_pool.h',
'resources/picture.cc',
'resources/picture.h',
'resources/picture_layer_tiling.cc',
@@ -404,8 +404,8 @@
'resources/picture_pile.h',
'resources/picture_pile_impl.cc',
'resources/picture_pile_impl.h',
- 'resources/pixel_buffer_raster_worker_pool.cc',
- 'resources/pixel_buffer_raster_worker_pool.h',
+ 'resources/pixel_buffer_tile_task_worker_pool.cc',
+ 'resources/pixel_buffer_tile_task_worker_pool.h',
'resources/platform_color.h',
'resources/prioritized_resource.cc',
'resources/prioritized_resource.h',
@@ -420,10 +420,10 @@
'resources/raster_source_helper.h',
'resources/raster_tile_priority_queue.cc',
'resources/raster_tile_priority_queue.h',
- 'resources/raster_worker_pool.cc',
- 'resources/raster_worker_pool.h',
- 'resources/rasterizer.cc',
- 'resources/rasterizer.h',
+ 'resources/tile_task_worker_pool.cc',
+ 'resources/tile_task_worker_pool.h',
+ 'resources/tile_task_runner.cc',
+ 'resources/tile_task_runner.h',
'resources/recording_source.h',
'resources/release_callback.h',
'resources/resource.cc',
@@ -487,8 +487,8 @@
'resources/ui_resource_request.h',
'resources/video_resource_updater.cc',
'resources/video_resource_updater.h',
- 'resources/zero_copy_raster_worker_pool.cc',
- 'resources/zero_copy_raster_worker_pool.h',
+ 'resources/zero_copy_tile_task_worker_pool.cc',
+ 'resources/zero_copy_tile_task_worker_pool.h',
'scheduler/begin_frame_source.cc',
'scheduler/begin_frame_source.h',
'scheduler/delay_based_time_source.cc',
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index d0b1000..c32fcba 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -82,7 +82,7 @@
'resources/picture_pile_unittest.cc',
'resources/picture_unittest.cc',
'resources/prioritized_resource_unittest.cc',
- 'resources/raster_worker_pool_unittest.cc',
+ 'resources/tile_task_worker_pool_unittest.cc',
'resources/resource_provider_unittest.cc',
'resources/resource_update_controller_unittest.cc',
'resources/scoped_resource_unittest.cc',
@@ -341,7 +341,7 @@
'layers/picture_layer_impl_perftest.cc',
'resources/picture_layer_tiling_perftest.cc',
'resources/picture_pile_impl_perftest.cc',
- 'resources/raster_worker_pool_perftest.cc',
+ 'resources/tile_task_worker_pool_perftest.cc',
'resources/task_graph_runner_perftest.cc',
'resources/tile_manager_perftest.cc',
'test/cc_test_suite.cc',
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index c1fc809..c00d0b9 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -12,7 +12,7 @@
#include "cc/debug/lap_timer.h"
#include "cc/layers/layer_impl.h"
#include "cc/layers/picture_layer_impl.h"
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/tile_task_worker_pool.h"
#include "cc/trees/layer_tree_host_common.h"
#include "cc/trees/layer_tree_host_impl.h"
#include "ui/gfx/geometry/rect.h"
@@ -207,7 +207,7 @@
return;
}
- TaskGraphRunner* task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
+ TaskGraphRunner* task_graph_runner = TileTaskWorkerPool::GetTaskGraphRunner();
DCHECK(task_graph_runner);
if (!task_namespace_.IsValid())
@@ -240,8 +240,7 @@
graph.nodes.push_back(
TaskGraph::Node(benchmark_raster_task.get(),
- RasterWorkerPool::kBenchmarkRasterTaskPriority,
- 0u));
+ TileTaskWorkerPool::kBenchmarkTaskPriority, 0u));
task_graph_runner->ScheduleTasks(task_namespace_, &graph);
task_graph_runner->WaitForTasksToFinishRunning(task_namespace_);
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 6ec1f0a..54cfac8 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -39,13 +39,6 @@
// tiling's scale if the desired scale is within this ratio.
const float kSnapToExistingTilingRatio = 1.2f;
-// Estimate skewport 60 frames ahead for pre-rasterization on the CPU.
-const float kCpuSkewportTargetTimeInFrames = 60.0f;
-
-// Don't pre-rasterize on the GPU (except for kBackflingGuardDistancePixels in
-// TileManager::BinFromTilePriority).
-const float kGpuSkewportTargetTimeInFrames = 0.0f;
-
// Even for really wide viewports, at some point GPU raster should use
// less than 4 tiles to fill the viewport. This is set to 256 as a
// sane minimum for now, but we might want to tune this for low-end.
@@ -630,12 +623,8 @@
int flags = 0;
- // TODO(vmpstr): Revisit this. For now, enabling analysis means that we get as
- // much savings on memory as we can. However, for some cases like ganesh or
- // small layers, the amount of time we spend analyzing might not justify
- // memory savings that we can get. Note that we don't handle solid color
- // masks, so we shouldn't bother analyzing those.
- // Bugs: crbug.com/397198, crbug.com/396908
+ // We don't handle solid color masks, so we shouldn't bother analyzing those.
+ // Otherwise, always analyze to maximize memory savings.
if (!is_mask_)
flags = Tile::USE_PICTURE_ANALYSIS;
@@ -684,13 +673,9 @@
}
float PictureLayerImpl::GetSkewportTargetTimeInSeconds() const {
- float skewport_target_time_in_frames =
- layer_tree_impl()->use_gpu_rasterization()
- ? kGpuSkewportTargetTimeInFrames
- : kCpuSkewportTargetTimeInFrames;
- return skewport_target_time_in_frames *
- layer_tree_impl()->begin_impl_frame_interval().InSecondsF() *
- layer_tree_impl()->settings().skewport_target_time_multiplier;
+ return layer_tree_impl()->use_gpu_rasterization()
+ ? 0.f
+ : layer_tree_impl()->settings().skewport_target_time_in_seconds;
}
int PictureLayerImpl::GetSkewportExtrapolationLimitInContentPixels() const {
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 4d3b751..90a36f7 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -3824,7 +3824,7 @@
resource_limit);
host_impl_.SetMemoryPolicy(policy);
host_impl_.SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
- host_impl_.ManageTiles();
+ host_impl_.PrepareTiles();
scoped_ptr<RenderPass> render_pass = RenderPass::Create();
AppendQuadsData data;
diff --git a/cc/quads/draw_polygon_unittest.cc b/cc/quads/draw_polygon_unittest.cc
index 360a014..27cfed4 100644
--- a/cc/quads/draw_polygon_unittest.cc
+++ b/cc/quads/draw_polygon_unittest.cc
@@ -19,11 +19,16 @@
#define EXPECT_FLOAT_WITHIN_EPSILON_OF(a, b) \
EXPECT_TRUE(std::abs(a - b) < std::numeric_limits<float>::epsilon());
+#define EXPECT_POINT_EQ(point_a, point_b) \
+ EXPECT_FLOAT_EQ(point_a.x(), point_b.x()); \
+ EXPECT_FLOAT_EQ(point_a.y(), point_b.y()); \
+ EXPECT_FLOAT_EQ(point_a.z(), point_b.z());
+
static void ValidatePoints(const DrawPolygon& polygon,
const std::vector<gfx::Point3F>& points) {
EXPECT_EQ(polygon.points().size(), points.size());
for (size_t i = 0; i < points.size(); i++) {
- EXPECT_EQ(polygon.points()[i], points[i]);
+ EXPECT_POINT_EQ(polygon.points()[i], points[i]);
}
}
diff --git a/cc/resources/bitmap_raster_worker_pool.cc b/cc/resources/bitmap_raster_worker_pool.cc
deleted file mode 100644
index a7adf4e..0000000
--- a/cc/resources/bitmap_raster_worker_pool.cc
+++ /dev/null
@@ -1,206 +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 "cc/resources/bitmap_raster_worker_pool.h"
-
-#include <algorithm>
-
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
-#include "base/strings/stringprintf.h"
-#include "cc/debug/traced_value.h"
-#include "cc/resources/raster_buffer.h"
-#include "cc/resources/raster_source.h"
-#include "cc/resources/resource.h"
-
-namespace cc {
-namespace {
-
-class RasterBufferImpl : public RasterBuffer {
- public:
- RasterBufferImpl(ResourceProvider* resource_provider,
- const Resource* resource)
- : lock_(resource_provider, resource->id()), resource_(resource) {}
-
- // Overridden from RasterBuffer:
- void Playback(const RasterSource* raster_source,
- const gfx::Rect& rect,
- float scale) override {
- RasterWorkerPool::PlaybackToMemory(lock_.sk_bitmap().getPixels(),
- resource_->format(), resource_->size(),
- 0, raster_source, rect, scale);
- }
-
- private:
- ResourceProvider::ScopedWriteLockSoftware lock_;
- const Resource* resource_;
-
- DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
-};
-
-} // namespace
-
-// static
-scoped_ptr<RasterWorkerPool> BitmapRasterWorkerPool::Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider) {
- return make_scoped_ptr<RasterWorkerPool>(new BitmapRasterWorkerPool(
- task_runner, task_graph_runner, resource_provider));
-}
-
-BitmapRasterWorkerPool::BitmapRasterWorkerPool(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider)
- : task_runner_(task_runner),
- task_graph_runner_(task_graph_runner),
- namespace_token_(task_graph_runner->GetNamespaceToken()),
- resource_provider_(resource_provider),
- raster_finished_weak_ptr_factory_(this) {
-}
-
-BitmapRasterWorkerPool::~BitmapRasterWorkerPool() {
-}
-
-Rasterizer* BitmapRasterWorkerPool::AsRasterizer() {
- return this;
-}
-
-void BitmapRasterWorkerPool::SetClient(RasterizerClient* client) {
- client_ = client;
-}
-
-void BitmapRasterWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "BitmapRasterWorkerPool::Shutdown");
-
- TaskGraph empty;
- task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
- task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-}
-
-void BitmapRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
- TRACE_EVENT0("cc", "BitmapRasterWorkerPool::ScheduleTasks");
-
- if (raster_pending_.none())
- TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
-
- // Mark all task sets as pending.
- raster_pending_.set();
-
- unsigned priority = kRasterTaskPriorityBase;
-
- graph_.Reset();
-
- // Cancel existing OnRasterFinished callbacks.
- raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
-
- scoped_refptr<RasterizerTask> new_raster_finished_tasks[kNumberOfTaskSets];
-
- size_t task_count[kNumberOfTaskSets] = {0};
-
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
- task_runner_.get(),
- base::Bind(&BitmapRasterWorkerPool::OnRasterFinished,
- raster_finished_weak_ptr_factory_.GetWeakPtr(),
- task_set));
- }
-
- for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
- it != queue->items.end();
- ++it) {
- const RasterTaskQueue::Item& item = *it;
- RasterTask* task = item.task;
- DCHECK(!task->HasCompleted());
-
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- if (!item.task_sets[task_set])
- continue;
-
- ++task_count[task_set];
-
- graph_.edges.push_back(
- TaskGraph::Edge(task, new_raster_finished_tasks[task_set].get()));
- }
-
- InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
- }
-
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- InsertNodeForTask(&graph_,
- new_raster_finished_tasks[task_set].get(),
- kRasterFinishedTaskPriority,
- task_count[task_set]);
- }
-
- ScheduleTasksOnOriginThread(this, &graph_);
- task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
-
- std::copy(new_raster_finished_tasks,
- new_raster_finished_tasks + kNumberOfTaskSets,
- raster_finished_tasks_);
-
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
-}
-
-void BitmapRasterWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "BitmapRasterWorkerPool::CheckForCompletedTasks");
-
- task_graph_runner_->CollectCompletedTasks(namespace_token_,
- &completed_tasks_);
- for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end();
- ++it) {
- RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
-
- task->RunReplyOnOriginThread();
- }
- completed_tasks_.clear();
-}
-
-scoped_ptr<RasterBuffer> BitmapRasterWorkerPool::AcquireBufferForRaster(
- const Resource* resource) {
- return make_scoped_ptr<RasterBuffer>(
- new RasterBufferImpl(resource_provider_, resource));
-}
-
-void BitmapRasterWorkerPool::ReleaseBufferForRaster(
- scoped_ptr<RasterBuffer> buffer) {
- // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
-}
-
-void BitmapRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
- TRACE_EVENT1(
- "cc", "BitmapRasterWorkerPool::OnRasterFinished", "task_set", task_set);
-
- DCHECK(raster_pending_[task_set]);
- raster_pending_[task_set] = false;
- if (raster_pending_.any()) {
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
- } else {
- TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
- }
- client_->DidFinishRunningTasks(task_set);
-}
-
-scoped_refptr<base::debug::ConvertableToTraceFormat>
-BitmapRasterWorkerPool::StateAsValue() const {
- scoped_refptr<base::debug::TracedValue> state =
- new base::debug::TracedValue();
-
- state->BeginArray("tasks_pending");
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set)
- state->AppendBoolean(raster_pending_[task_set]);
- state->EndArray();
- return state;
-}
-
-} // namespace cc
diff --git a/cc/resources/bitmap_raster_worker_pool.h b/cc/resources/bitmap_raster_worker_pool.h
deleted file mode 100644
index 624318b..0000000
--- a/cc/resources/bitmap_raster_worker_pool.h
+++ /dev/null
@@ -1,79 +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 CC_RESOURCES_BITMAP_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_BITMAP_RASTER_WORKER_POOL_H_
-
-#include "base/memory/weak_ptr.h"
-#include "base/values.h"
-#include "cc/resources/raster_worker_pool.h"
-#include "cc/resources/rasterizer.h"
-
-namespace base {
-namespace debug {
-class ConvertableToTraceFormat;
-}
-}
-
-namespace cc {
-class ResourceProvider;
-
-class CC_EXPORT BitmapRasterWorkerPool : public RasterWorkerPool,
- public Rasterizer,
- public RasterizerTaskClient {
- public:
- ~BitmapRasterWorkerPool() override;
-
- static scoped_ptr<RasterWorkerPool> Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider);
-
- // Overridden from RasterWorkerPool:
- Rasterizer* AsRasterizer() override;
-
- // Overridden from Rasterizer:
- void SetClient(RasterizerClient* client) override;
- void Shutdown() override;
- void ScheduleTasks(RasterTaskQueue* queue) override;
- void CheckForCompletedTasks() override;
-
- // Overridden from RasterizerTaskClient:
- scoped_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource) override;
- void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
-
- protected:
- BitmapRasterWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider);
-
- private:
- void OnRasterFinished(TaskSet task_set);
- scoped_refptr<base::debug::ConvertableToTraceFormat> StateAsValue() const;
-
- scoped_refptr<base::SequencedTaskRunner> task_runner_;
- TaskGraphRunner* task_graph_runner_;
- const NamespaceToken namespace_token_;
- RasterizerClient* client_;
- ResourceProvider* resource_provider_;
-
- TaskSetCollection raster_pending_;
-
- scoped_refptr<RasterizerTask> raster_finished_tasks_[kNumberOfTaskSets];
-
- // Task graph used when scheduling tasks and vector used to gather
- // completed tasks.
- TaskGraph graph_;
- Task::Vector completed_tasks_;
-
- base::WeakPtrFactory<BitmapRasterWorkerPool>
- raster_finished_weak_ptr_factory_;
-
- DISALLOW_COPY_AND_ASSIGN(BitmapRasterWorkerPool);
-};
-
-} // namespace cc
-
-#endif // CC_RESOURCES_BITMAP_RASTER_WORKER_POOL_H_
diff --git a/cc/resources/bitmap_tile_task_worker_pool.cc b/cc/resources/bitmap_tile_task_worker_pool.cc
new file mode 100644
index 0000000..c4bd1f2
--- /dev/null
+++ b/cc/resources/bitmap_tile_task_worker_pool.cc
@@ -0,0 +1,201 @@
+// 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 "cc/resources/bitmap_tile_task_worker_pool.h"
+
+#include <algorithm>
+
+#include "base/debug/trace_event.h"
+#include "base/debug/trace_event_argument.h"
+#include "base/strings/stringprintf.h"
+#include "cc/debug/traced_value.h"
+#include "cc/resources/raster_buffer.h"
+#include "cc/resources/raster_source.h"
+#include "cc/resources/resource.h"
+
+namespace cc {
+namespace {
+
+class RasterBufferImpl : public RasterBuffer {
+ public:
+ RasterBufferImpl(ResourceProvider* resource_provider,
+ const Resource* resource)
+ : lock_(resource_provider, resource->id()), resource_(resource) {}
+
+ // Overridden from RasterBuffer:
+ void Playback(const RasterSource* raster_source,
+ const gfx::Rect& rect,
+ float scale) override {
+ TileTaskWorkerPool::PlaybackToMemory(lock_.sk_bitmap().getPixels(),
+ resource_->format(), resource_->size(),
+ 0, raster_source, rect, scale);
+ }
+
+ private:
+ ResourceProvider::ScopedWriteLockSoftware lock_;
+ const Resource* resource_;
+
+ DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
+};
+
+} // namespace
+
+// static
+scoped_ptr<TileTaskWorkerPool> BitmapTileTaskWorkerPool::Create(
+ base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider) {
+ return make_scoped_ptr<TileTaskWorkerPool>(new BitmapTileTaskWorkerPool(
+ task_runner, task_graph_runner, resource_provider));
+}
+
+BitmapTileTaskWorkerPool::BitmapTileTaskWorkerPool(
+ base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider)
+ : task_runner_(task_runner),
+ task_graph_runner_(task_graph_runner),
+ namespace_token_(task_graph_runner->GetNamespaceToken()),
+ resource_provider_(resource_provider),
+ task_set_finished_weak_ptr_factory_(this) {
+}
+
+BitmapTileTaskWorkerPool::~BitmapTileTaskWorkerPool() {
+}
+
+TileTaskRunner* BitmapTileTaskWorkerPool::AsTileTaskRunner() {
+ return this;
+}
+
+void BitmapTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) {
+ client_ = client;
+}
+
+void BitmapTileTaskWorkerPool::Shutdown() {
+ TRACE_EVENT0("cc", "BitmapTileTaskWorkerPool::Shutdown");
+
+ TaskGraph empty;
+ task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
+ task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
+}
+
+void BitmapTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) {
+ TRACE_EVENT0("cc", "BitmapTileTaskWorkerPool::ScheduleTasks");
+
+ if (tasks_pending_.none())
+ TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
+
+ // Mark all task sets as pending.
+ tasks_pending_.set();
+
+ unsigned priority = kTileTaskPriorityBase;
+
+ graph_.Reset();
+
+ // Cancel existing OnTaskSetFinished callbacks.
+ task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
+
+ scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets];
+
+ size_t task_count[kNumberOfTaskSets] = {0};
+
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
+ new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask(
+ task_runner_.get(),
+ base::Bind(&BitmapTileTaskWorkerPool::OnTaskSetFinished,
+ task_set_finished_weak_ptr_factory_.GetWeakPtr(), task_set));
+ }
+
+ for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+ it != queue->items.end(); ++it) {
+ const TileTaskQueue::Item& item = *it;
+ RasterTask* task = item.task;
+ DCHECK(!task->HasCompleted());
+
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
+ if (!item.task_sets[task_set])
+ continue;
+
+ ++task_count[task_set];
+
+ graph_.edges.push_back(
+ TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get()));
+ }
+
+ InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
+ }
+
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
+ InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(),
+ kTaskSetFinishedTaskPriority, task_count[task_set]);
+ }
+
+ ScheduleTasksOnOriginThread(this, &graph_);
+ task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
+
+ std::copy(new_task_set_finished_tasks,
+ new_task_set_finished_tasks + kNumberOfTaskSets,
+ task_set_finished_tasks_);
+
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
+ StateAsValue());
+}
+
+void BitmapTileTaskWorkerPool::CheckForCompletedTasks() {
+ TRACE_EVENT0("cc", "BitmapTileTaskWorkerPool::CheckForCompletedTasks");
+
+ task_graph_runner_->CollectCompletedTasks(namespace_token_,
+ &completed_tasks_);
+ for (Task::Vector::const_iterator it = completed_tasks_.begin();
+ it != completed_tasks_.end(); ++it) {
+ TileTask* task = static_cast<TileTask*>(it->get());
+
+ task->WillComplete();
+ task->CompleteOnOriginThread(this);
+ task->DidComplete();
+
+ task->RunReplyOnOriginThread();
+ }
+ completed_tasks_.clear();
+}
+
+scoped_ptr<RasterBuffer> BitmapTileTaskWorkerPool::AcquireBufferForRaster(
+ const Resource* resource) {
+ return make_scoped_ptr<RasterBuffer>(
+ new RasterBufferImpl(resource_provider_, resource));
+}
+
+void BitmapTileTaskWorkerPool::ReleaseBufferForRaster(
+ scoped_ptr<RasterBuffer> buffer) {
+ // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
+}
+
+void BitmapTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) {
+ TRACE_EVENT1("cc", "BitmapTileTaskWorkerPool::OnTaskSetFinished", "task_set",
+ task_set);
+
+ DCHECK(tasks_pending_[task_set]);
+ tasks_pending_[task_set] = false;
+ if (tasks_pending_.any()) {
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running",
+ "state", StateAsValue());
+ } else {
+ TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
+ }
+ client_->DidFinishRunningTileTasks(task_set);
+}
+
+scoped_refptr<base::debug::ConvertableToTraceFormat>
+BitmapTileTaskWorkerPool::StateAsValue() const {
+ scoped_refptr<base::debug::TracedValue> state =
+ new base::debug::TracedValue();
+
+ state->BeginArray("tasks_pending");
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set)
+ state->AppendBoolean(tasks_pending_[task_set]);
+ state->EndArray();
+ return state;
+}
+
+} // namespace cc
diff --git a/cc/resources/bitmap_tile_task_worker_pool.h b/cc/resources/bitmap_tile_task_worker_pool.h
new file mode 100644
index 0000000..4f5d970
--- /dev/null
+++ b/cc/resources/bitmap_tile_task_worker_pool.h
@@ -0,0 +1,79 @@
+// 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 CC_RESOURCES_BITMAP_TILE_TASK_WORKER_POOL_H_
+#define CC_RESOURCES_BITMAP_TILE_TASK_WORKER_POOL_H_
+
+#include "base/memory/weak_ptr.h"
+#include "base/values.h"
+#include "cc/resources/tile_task_runner.h"
+#include "cc/resources/tile_task_worker_pool.h"
+
+namespace base {
+namespace debug {
+class ConvertableToTraceFormat;
+}
+}
+
+namespace cc {
+class ResourceProvider;
+
+class CC_EXPORT BitmapTileTaskWorkerPool : public TileTaskWorkerPool,
+ public TileTaskRunner,
+ public TileTaskClient {
+ public:
+ ~BitmapTileTaskWorkerPool() override;
+
+ static scoped_ptr<TileTaskWorkerPool> Create(
+ base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider);
+
+ // Overridden from TileTaskWorkerPool:
+ TileTaskRunner* AsTileTaskRunner() override;
+
+ // Overridden from TileTaskRunner:
+ void SetClient(TileTaskRunnerClient* client) override;
+ void Shutdown() override;
+ void ScheduleTasks(TileTaskQueue* queue) override;
+ void CheckForCompletedTasks() override;
+
+ // Overridden from TileTaskClient:
+ scoped_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource) override;
+ void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
+
+ protected:
+ BitmapTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider);
+
+ private:
+ void OnTaskSetFinished(TaskSet task_set);
+ scoped_refptr<base::debug::ConvertableToTraceFormat> StateAsValue() const;
+
+ scoped_refptr<base::SequencedTaskRunner> task_runner_;
+ TaskGraphRunner* task_graph_runner_;
+ const NamespaceToken namespace_token_;
+ TileTaskRunnerClient* client_;
+ ResourceProvider* resource_provider_;
+
+ TaskSetCollection tasks_pending_;
+
+ scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets];
+
+ // Task graph used when scheduling tasks and vector used to gather
+ // completed tasks.
+ TaskGraph graph_;
+ Task::Vector completed_tasks_;
+
+ base::WeakPtrFactory<BitmapTileTaskWorkerPool>
+ task_set_finished_weak_ptr_factory_;
+
+ DISALLOW_COPY_AND_ASSIGN(BitmapTileTaskWorkerPool);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_BITMAP_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/resources/gpu_raster_worker_pool.h b/cc/resources/gpu_raster_worker_pool.h
deleted file mode 100644
index c5ff13f..0000000
--- a/cc/resources/gpu_raster_worker_pool.h
+++ /dev/null
@@ -1,83 +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 CC_RESOURCES_GPU_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_GPU_RASTER_WORKER_POOL_H_
-
-#include "base/memory/weak_ptr.h"
-#include "cc/resources/raster_worker_pool.h"
-#include "cc/resources/rasterizer.h"
-#include "third_party/skia/include/core/SkMultiPictureDraw.h"
-
-namespace cc {
-class ContextProvider;
-class ResourceProvider;
-
-class CC_EXPORT GpuRasterWorkerPool : public RasterWorkerPool,
- public Rasterizer,
- public RasterizerTaskClient {
- public:
- ~GpuRasterWorkerPool() override;
-
- static scoped_ptr<RasterWorkerPool> Create(
- base::SequencedTaskRunner* task_runner,
- ContextProvider* context_provider,
- ResourceProvider* resource_provider,
- bool use_distance_field_text);
-
- // Overridden from RasterWorkerPool:
- Rasterizer* AsRasterizer() override;
-
- // Overridden from Rasterizer:
- void SetClient(RasterizerClient* client) override;
- void Shutdown() override;
- void ScheduleTasks(RasterTaskQueue* queue) override;
- void CheckForCompletedTasks() override;
-
- // Overridden from RasterizerTaskClient:
- scoped_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource) override;
- void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
-
- private:
- GpuRasterWorkerPool(base::SequencedTaskRunner* task_runner,
- ContextProvider* context_provider,
- ResourceProvider* resource_provider,
- bool use_distance_field_text);
-
- void OnRasterFinished(TaskSet task_set);
- void ScheduleRunTasksOnOriginThread();
- void RunTasksOnOriginThread();
- void RunTaskOnOriginThread(RasterizerTask* task);
-
- scoped_refptr<base::SequencedTaskRunner> task_runner_;
- scoped_ptr<TaskGraphRunner> task_graph_runner_;
- const NamespaceToken namespace_token_;
- RasterizerClient* client_;
- ContextProvider* context_provider_;
- ResourceProvider* resource_provider_;
- SkMultiPictureDraw multi_picture_draw_;
-
- bool run_tasks_on_origin_thread_pending_;
- bool use_distance_field_text_;
-
- TaskSetCollection raster_pending_;
-
- scoped_refptr<RasterizerTask> raster_finished_tasks_[kNumberOfTaskSets];
-
- // Task graph used when scheduling tasks and vector used to gather
- // completed tasks.
- TaskGraph graph_;
- Task::Vector completed_tasks_;
-
- base::WeakPtrFactory<GpuRasterWorkerPool> raster_finished_weak_ptr_factory_;
-
- base::WeakPtrFactory<GpuRasterWorkerPool> weak_ptr_factory_;
-
- DISALLOW_COPY_AND_ASSIGN(GpuRasterWorkerPool);
-};
-
-} // namespace cc
-
-#endif // CC_RESOURCES_GPU_RASTER_WORKER_POOL_H_
diff --git a/cc/resources/gpu_raster_worker_pool.cc b/cc/resources/gpu_tile_task_worker_pool.cc
similarity index 60%
rename from cc/resources/gpu_raster_worker_pool.cc
rename to cc/resources/gpu_tile_task_worker_pool.cc
index d29855a..2cd4edd 100644
--- a/cc/resources/gpu_raster_worker_pool.cc
+++ b/cc/resources/gpu_tile_task_worker_pool.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/resources/gpu_raster_worker_pool.h"
+#include "cc/resources/gpu_tile_task_worker_pool.h"
#include <algorithm>
@@ -50,10 +50,8 @@
SkPictureRecorder recorder;
gfx::Size size = resource_->size();
const int flags = SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag;
- skia::RefPtr<SkCanvas> canvas =
- skia::SharePtr(recorder.beginRecording(size.width(), size.height(),
- NULL, flags));
-
+ skia::RefPtr<SkCanvas> canvas = skia::SharePtr(
+ recorder.beginRecording(size.width(), size.height(), NULL, flags));
canvas->save();
raster_source->PlaybackToCanvas(canvas.get(), rect, scale);
@@ -76,22 +74,21 @@
} // namespace
// static
-scoped_ptr<RasterWorkerPool> GpuRasterWorkerPool::Create(
+scoped_ptr<TileTaskWorkerPool> GpuTileTaskWorkerPool::Create(
base::SequencedTaskRunner* task_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
bool use_distance_field_text) {
- return make_scoped_ptr<RasterWorkerPool>(
- new GpuRasterWorkerPool(task_runner,
- context_provider,
- resource_provider,
- use_distance_field_text));
+ return make_scoped_ptr<TileTaskWorkerPool>(
+ new GpuTileTaskWorkerPool(task_runner, context_provider,
+ resource_provider, use_distance_field_text));
}
-GpuRasterWorkerPool::GpuRasterWorkerPool(base::SequencedTaskRunner* task_runner,
- ContextProvider* context_provider,
- ResourceProvider* resource_provider,
- bool use_distance_field_text)
+GpuTileTaskWorkerPool::GpuTileTaskWorkerPool(
+ base::SequencedTaskRunner* task_runner,
+ ContextProvider* context_provider,
+ ResourceProvider* resource_provider,
+ bool use_distance_field_text)
: task_runner_(task_runner),
task_graph_runner_(new TaskGraphRunner),
namespace_token_(task_graph_runner_->GetNamespaceToken()),
@@ -99,60 +96,58 @@
resource_provider_(resource_provider),
run_tasks_on_origin_thread_pending_(false),
use_distance_field_text_(use_distance_field_text),
- raster_finished_weak_ptr_factory_(this),
+ task_set_finished_weak_ptr_factory_(this),
weak_ptr_factory_(this) {
DCHECK(context_provider_);
}
-GpuRasterWorkerPool::~GpuRasterWorkerPool() {
+GpuTileTaskWorkerPool::~GpuTileTaskWorkerPool() {
DCHECK_EQ(0u, completed_tasks_.size());
}
-Rasterizer* GpuRasterWorkerPool::AsRasterizer() {
+TileTaskRunner* GpuTileTaskWorkerPool::AsTileTaskRunner() {
return this;
}
-void GpuRasterWorkerPool::SetClient(RasterizerClient* client) {
+void GpuTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) {
client_ = client;
}
-void GpuRasterWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "GpuRasterWorkerPool::Shutdown");
+void GpuTileTaskWorkerPool::Shutdown() {
+ TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::Shutdown");
TaskGraph empty;
task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
}
-void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
- TRACE_EVENT0("cc", "GpuRasterWorkerPool::ScheduleTasks");
+void GpuTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) {
+ TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::ScheduleTasks");
// Mark all task sets as pending.
- raster_pending_.set();
+ tasks_pending_.set();
- unsigned priority = kRasterTaskPriorityBase;
+ unsigned priority = kTileTaskPriorityBase;
graph_.Reset();
- // Cancel existing OnRasterFinished callbacks.
- raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
+ // Cancel existing OnTaskSetFinished callbacks.
+ task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
- scoped_refptr<RasterizerTask> new_raster_finished_tasks[kNumberOfTaskSets];
+ scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets];
size_t task_count[kNumberOfTaskSets] = {0};
for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
+ new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask(
task_runner_.get(),
- base::Bind(&GpuRasterWorkerPool::OnRasterFinished,
- raster_finished_weak_ptr_factory_.GetWeakPtr(),
- task_set));
+ base::Bind(&GpuTileTaskWorkerPool::OnTaskSetFinished,
+ task_set_finished_weak_ptr_factory_.GetWeakPtr(), task_set));
}
- for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
- it != queue->items.end();
- ++it) {
- const RasterTaskQueue::Item& item = *it;
+ for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+ it != queue->items.end(); ++it) {
+ const TileTaskQueue::Item& item = *it;
RasterTask* task = item.task;
DCHECK(!task->HasCompleted());
@@ -163,17 +158,15 @@
++task_count[task_set];
graph_.edges.push_back(
- TaskGraph::Edge(task, new_raster_finished_tasks[task_set].get()));
+ TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get()));
}
InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
}
for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- InsertNodeForTask(&graph_,
- new_raster_finished_tasks[task_set].get(),
- kRasterFinishedTaskPriority,
- task_count[task_set]);
+ InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(),
+ kTaskSetFinishedTaskPriority, task_count[task_set]);
}
ScheduleTasksOnOriginThread(this, &graph_);
@@ -181,20 +174,19 @@
ScheduleRunTasksOnOriginThread();
- std::copy(new_raster_finished_tasks,
- new_raster_finished_tasks + kNumberOfTaskSets,
- raster_finished_tasks_);
+ std::copy(new_task_set_finished_tasks,
+ new_task_set_finished_tasks + kNumberOfTaskSets,
+ task_set_finished_tasks_);
}
-void GpuRasterWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "GpuRasterWorkerPool::CheckForCompletedTasks");
+void GpuTileTaskWorkerPool::CheckForCompletedTasks() {
+ TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::CheckForCompletedTasks");
task_graph_runner_->CollectCompletedTasks(namespace_token_,
&completed_tasks_);
for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end();
- ++it) {
- RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
+ it != completed_tasks_.end(); ++it) {
+ TileTask* task = static_cast<TileTask*>(it->get());
task->WillComplete();
task->CompleteOnOriginThread(this);
@@ -205,42 +197,39 @@
completed_tasks_.clear();
}
-scoped_ptr<RasterBuffer> GpuRasterWorkerPool::AcquireBufferForRaster(
+scoped_ptr<RasterBuffer> GpuTileTaskWorkerPool::AcquireBufferForRaster(
const Resource* resource) {
return make_scoped_ptr<RasterBuffer>(
- new RasterBufferImpl(resource_provider_,
- resource,
- &multi_picture_draw_,
+ new RasterBufferImpl(resource_provider_, resource, &multi_picture_draw_,
use_distance_field_text_));
}
-void GpuRasterWorkerPool::ReleaseBufferForRaster(
+void GpuTileTaskWorkerPool::ReleaseBufferForRaster(
scoped_ptr<RasterBuffer> buffer) {
// Nothing to do here. RasterBufferImpl destructor cleans up after itself.
}
-void GpuRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
- TRACE_EVENT1(
- "cc", "GpuRasterWorkerPool::OnRasterFinished", "task_set", task_set);
+void GpuTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) {
+ TRACE_EVENT1("cc", "GpuTileTaskWorkerPool::OnTaskSetFinished", "task_set",
+ task_set);
- DCHECK(raster_pending_[task_set]);
- raster_pending_[task_set] = false;
- client_->DidFinishRunningTasks(task_set);
+ DCHECK(tasks_pending_[task_set]);
+ tasks_pending_[task_set] = false;
+ client_->DidFinishRunningTileTasks(task_set);
}
-void GpuRasterWorkerPool::ScheduleRunTasksOnOriginThread() {
+void GpuTileTaskWorkerPool::ScheduleRunTasksOnOriginThread() {
if (run_tasks_on_origin_thread_pending_)
return;
task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&GpuRasterWorkerPool::RunTasksOnOriginThread,
- weak_ptr_factory_.GetWeakPtr()));
+ FROM_HERE, base::Bind(&GpuTileTaskWorkerPool::RunTasksOnOriginThread,
+ weak_ptr_factory_.GetWeakPtr()));
run_tasks_on_origin_thread_pending_ = true;
}
-void GpuRasterWorkerPool::RunTasksOnOriginThread() {
- TRACE_EVENT0("cc", "GpuRasterWorkerPool::RunTasksOnOriginThread");
+void GpuTileTaskWorkerPool::RunTasksOnOriginThread() {
+ TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::RunTasksOnOriginThread");
DCHECK(run_tasks_on_origin_thread_pending_);
run_tasks_on_origin_thread_pending_ = false;
diff --git a/cc/resources/gpu_tile_task_worker_pool.h b/cc/resources/gpu_tile_task_worker_pool.h
new file mode 100644
index 0000000..363b0a6
--- /dev/null
+++ b/cc/resources/gpu_tile_task_worker_pool.h
@@ -0,0 +1,84 @@
+// 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 CC_RESOURCES_GPU_TILE_TASK_WORKER_POOL_H_
+#define CC_RESOURCES_GPU_TILE_TASK_WORKER_POOL_H_
+
+#include "base/memory/weak_ptr.h"
+#include "cc/resources/tile_task_runner.h"
+#include "cc/resources/tile_task_worker_pool.h"
+#include "third_party/skia/include/core/SkMultiPictureDraw.h"
+
+namespace cc {
+class ContextProvider;
+class ResourceProvider;
+
+class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
+ public TileTaskRunner,
+ public TileTaskClient {
+ public:
+ ~GpuTileTaskWorkerPool() override;
+
+ static scoped_ptr<TileTaskWorkerPool> Create(
+ base::SequencedTaskRunner* task_runner,
+ ContextProvider* context_provider,
+ ResourceProvider* resource_provider,
+ bool use_distance_field_text);
+
+ // Overridden from TileTaskWorkerPool:
+ TileTaskRunner* AsTileTaskRunner() override;
+
+ // Overridden from TileTaskRunner:
+ void SetClient(TileTaskRunnerClient* client) override;
+ void Shutdown() override;
+ void ScheduleTasks(TileTaskQueue* queue) override;
+ void CheckForCompletedTasks() override;
+
+ // Overridden from TileTaskClient:
+ scoped_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource) override;
+ void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
+
+ private:
+ GpuTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
+ ContextProvider* context_provider,
+ ResourceProvider* resource_provider,
+ bool use_distance_field_text);
+
+ void OnTaskSetFinished(TaskSet task_set);
+ void ScheduleRunTasksOnOriginThread();
+ void RunTasksOnOriginThread();
+ void RunTaskOnOriginThread(TileTask* task);
+
+ scoped_refptr<base::SequencedTaskRunner> task_runner_;
+ scoped_ptr<TaskGraphRunner> task_graph_runner_;
+ const NamespaceToken namespace_token_;
+ TileTaskRunnerClient* client_;
+ ContextProvider* context_provider_;
+ ResourceProvider* resource_provider_;
+ SkMultiPictureDraw multi_picture_draw_;
+
+ bool run_tasks_on_origin_thread_pending_;
+ bool use_distance_field_text_;
+
+ TaskSetCollection tasks_pending_;
+
+ scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets];
+
+ // Task graph used when scheduling tasks and vector used to gather
+ // completed tasks.
+ TaskGraph graph_;
+ Task::Vector completed_tasks_;
+
+ base::WeakPtrFactory<GpuTileTaskWorkerPool>
+ task_set_finished_weak_ptr_factory_;
+
+ base::WeakPtrFactory<GpuTileTaskWorkerPool> weak_ptr_factory_;
+
+ DISALLOW_COPY_AND_ASSIGN(GpuTileTaskWorkerPool);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_GPU_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/resources/managed_tile_state.h b/cc/resources/managed_tile_state.h
index a0905c7..faba93c 100644
--- a/cc/resources/managed_tile_state.h
+++ b/cc/resources/managed_tile_state.h
@@ -7,11 +7,11 @@
#include "base/memory/scoped_ptr.h"
#include "cc/resources/platform_color.h"
-#include "cc/resources/rasterizer.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/scoped_resource.h"
#include "cc/resources/tile_priority.h"
+#include "cc/resources/tile_task_runner.h"
namespace cc {
diff --git a/cc/resources/one_copy_raster_worker_pool.cc b/cc/resources/one_copy_tile_task_worker_pool.cc
similarity index 73%
rename from cc/resources/one_copy_raster_worker_pool.cc
rename to cc/resources/one_copy_tile_task_worker_pool.cc
index a8b838e..dcb8dea 100644
--- a/cc/resources/one_copy_raster_worker_pool.cc
+++ b/cc/resources/one_copy_tile_task_worker_pool.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/resources/one_copy_raster_worker_pool.h"
+#include "cc/resources/one_copy_tile_task_worker_pool.h"
#include <algorithm>
#include <limits>
@@ -22,7 +22,7 @@
class RasterBufferImpl : public RasterBuffer {
public:
- RasterBufferImpl(OneCopyRasterWorkerPool* worker_pool,
+ RasterBufferImpl(OneCopyTileTaskWorkerPool* worker_pool,
ResourceProvider* resource_provider,
ResourcePool* resource_pool,
const Resource* resource)
@@ -61,7 +61,7 @@
}
private:
- OneCopyRasterWorkerPool* worker_pool_;
+ OneCopyTileTaskWorkerPool* worker_pool_;
ResourceProvider* resource_provider_;
ResourcePool* resource_pool_;
const Resource* resource_;
@@ -87,32 +87,29 @@
} // namespace
-OneCopyRasterWorkerPool::CopyOperation::CopyOperation(
+OneCopyTileTaskWorkerPool::CopyOperation::CopyOperation(
scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
scoped_ptr<ScopedResource> src,
const Resource* dst)
: write_lock(write_lock.Pass()), src(src.Pass()), dst(dst) {
}
-OneCopyRasterWorkerPool::CopyOperation::~CopyOperation() {
+OneCopyTileTaskWorkerPool::CopyOperation::~CopyOperation() {
}
// static
-scoped_ptr<RasterWorkerPool> OneCopyRasterWorkerPool::Create(
+scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
ResourcePool* resource_pool) {
- return make_scoped_ptr<RasterWorkerPool>(
- new OneCopyRasterWorkerPool(task_runner,
- task_graph_runner,
- context_provider,
- resource_provider,
- resource_pool));
+ return make_scoped_ptr<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool(
+ task_runner, task_graph_runner, context_provider, resource_provider,
+ resource_pool));
}
-OneCopyRasterWorkerPool::OneCopyRasterWorkerPool(
+OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
@@ -134,24 +131,24 @@
check_for_completed_copy_operations_pending_(false),
shutdown_(false),
weak_ptr_factory_(this),
- raster_finished_weak_ptr_factory_(this) {
+ task_set_finished_weak_ptr_factory_(this) {
DCHECK(context_provider_);
}
-OneCopyRasterWorkerPool::~OneCopyRasterWorkerPool() {
+OneCopyTileTaskWorkerPool::~OneCopyTileTaskWorkerPool() {
DCHECK_EQ(scheduled_copy_operation_count_, 0u);
}
-Rasterizer* OneCopyRasterWorkerPool::AsRasterizer() {
+TileTaskRunner* OneCopyTileTaskWorkerPool::AsTileTaskRunner() {
return this;
}
-void OneCopyRasterWorkerPool::SetClient(RasterizerClient* client) {
+void OneCopyTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) {
client_ = client;
}
-void OneCopyRasterWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "OneCopyRasterWorkerPool::Shutdown");
+void OneCopyTileTaskWorkerPool::Shutdown() {
+ TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::Shutdown");
{
base::AutoLock lock(lock_);
@@ -165,40 +162,38 @@
task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
}
-void OneCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
- TRACE_EVENT0("cc", "OneCopyRasterWorkerPool::ScheduleTasks");
+void OneCopyTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) {
+ TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::ScheduleTasks");
- if (raster_pending_.none())
+ if (tasks_pending_.none())
TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
// Mark all task sets as pending.
- raster_pending_.set();
+ tasks_pending_.set();
- unsigned priority = kRasterTaskPriorityBase;
+ unsigned priority = kTileTaskPriorityBase;
graph_.Reset();
- // Cancel existing OnRasterFinished callbacks.
- raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
+ // Cancel existing OnTaskSetFinished callbacks.
+ task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
- scoped_refptr<RasterizerTask> new_raster_finished_tasks[kNumberOfTaskSets];
+ scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets];
size_t task_count[kNumberOfTaskSets] = {0};
for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
+ new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask(
task_runner_.get(),
- base::Bind(&OneCopyRasterWorkerPool::OnRasterFinished,
- raster_finished_weak_ptr_factory_.GetWeakPtr(),
- task_set));
+ base::Bind(&OneCopyTileTaskWorkerPool::OnTaskSetFinished,
+ task_set_finished_weak_ptr_factory_.GetWeakPtr(), task_set));
}
resource_pool_->CheckBusyResources(false);
- for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
- it != queue->items.end();
- ++it) {
- const RasterTaskQueue::Item& item = *it;
+ for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+ it != queue->items.end(); ++it) {
+ const TileTaskQueue::Item& item = *it;
RasterTask* task = item.task;
DCHECK(!task->HasCompleted());
@@ -209,42 +204,39 @@
++task_count[task_set];
graph_.edges.push_back(
- TaskGraph::Edge(task, new_raster_finished_tasks[task_set].get()));
+ TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get()));
}
InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
}
for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- InsertNodeForTask(&graph_,
- new_raster_finished_tasks[task_set].get(),
- kRasterFinishedTaskPriority,
- task_count[task_set]);
+ InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(),
+ kTaskSetFinishedTaskPriority, task_count[task_set]);
}
ScheduleTasksOnOriginThread(this, &graph_);
task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
- std::copy(new_raster_finished_tasks,
- new_raster_finished_tasks + kNumberOfTaskSets,
- raster_finished_tasks_);
+ std::copy(new_task_set_finished_tasks,
+ new_task_set_finished_tasks + kNumberOfTaskSets,
+ task_set_finished_tasks_);
resource_pool_->ReduceResourceUsage();
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
+ StateAsValue());
}
-void OneCopyRasterWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "OneCopyRasterWorkerPool::CheckForCompletedTasks");
+void OneCopyTileTaskWorkerPool::CheckForCompletedTasks() {
+ TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::CheckForCompletedTasks");
task_graph_runner_->CollectCompletedTasks(namespace_token_,
&completed_tasks_);
for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end();
- ++it) {
- RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
+ it != completed_tasks_.end(); ++it) {
+ TileTask* task = static_cast<TileTask*>(it->get());
task->WillComplete();
task->CompleteOnOriginThread(this);
@@ -255,20 +247,20 @@
completed_tasks_.clear();
}
-scoped_ptr<RasterBuffer> OneCopyRasterWorkerPool::AcquireBufferForRaster(
+scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
const Resource* resource) {
DCHECK_EQ(resource->format(), resource_pool_->resource_format());
return make_scoped_ptr<RasterBuffer>(
new RasterBufferImpl(this, resource_provider_, resource_pool_, resource));
}
-void OneCopyRasterWorkerPool::ReleaseBufferForRaster(
+void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
scoped_ptr<RasterBuffer> buffer) {
// Nothing to do here. RasterBufferImpl destructor cleans up after itself.
}
CopySequenceNumber
-OneCopyRasterWorkerPool::PlaybackAndScheduleCopyOnWorkerThread(
+OneCopyTileTaskWorkerPool::PlaybackAndScheduleCopyOnWorkerThread(
scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
scoped_ptr<ScopedResource> src,
const Resource* dst,
@@ -313,13 +305,9 @@
gfx::GpuMemoryBuffer* gpu_memory_buffer = write_lock->GetGpuMemoryBuffer();
if (gpu_memory_buffer) {
- RasterWorkerPool::PlaybackToMemory(gpu_memory_buffer->Map(),
- src->format(),
- src->size(),
- gpu_memory_buffer->GetStride(),
- raster_source,
- rect,
- scale);
+ TileTaskWorkerPool::PlaybackToMemory(
+ gpu_memory_buffer->Map(), src->format(), src->size(),
+ gpu_memory_buffer->GetStride(), raster_source, rect, scale);
gpu_memory_buffer->Unmap();
}
}
@@ -335,15 +323,14 @@
if ((sequence % kCopyFlushPeriod) == 0) {
task_runner_->PostTask(
FROM_HERE,
- base::Bind(&OneCopyRasterWorkerPool::AdvanceLastFlushedCopyTo,
- weak_ptr_factory_.GetWeakPtr(),
- sequence));
+ base::Bind(&OneCopyTileTaskWorkerPool::AdvanceLastFlushedCopyTo,
+ weak_ptr_factory_.GetWeakPtr(), sequence));
}
return sequence;
}
-void OneCopyRasterWorkerPool::AdvanceLastIssuedCopyTo(
+void OneCopyTileTaskWorkerPool::AdvanceLastIssuedCopyTo(
CopySequenceNumber sequence) {
if (last_issued_copy_operation_ >= sequence)
return;
@@ -352,7 +339,7 @@
last_issued_copy_operation_ = sequence;
}
-void OneCopyRasterWorkerPool::AdvanceLastFlushedCopyTo(
+void OneCopyTileTaskWorkerPool::AdvanceLastFlushedCopyTo(
CopySequenceNumber sequence) {
if (last_flushed_copy_operation_ >= sequence)
return;
@@ -364,24 +351,24 @@
last_flushed_copy_operation_ = last_issued_copy_operation_;
}
-void OneCopyRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
- TRACE_EVENT1(
- "cc", "OneCopyRasterWorkerPool::OnRasterFinished", "task_set", task_set);
+void OneCopyTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) {
+ TRACE_EVENT1("cc", "OneCopyTileTaskWorkerPool::OnTaskSetFinished", "task_set",
+ task_set);
- DCHECK(raster_pending_[task_set]);
- raster_pending_[task_set] = false;
- if (raster_pending_.any()) {
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
+ DCHECK(tasks_pending_[task_set]);
+ tasks_pending_[task_set] = false;
+ if (tasks_pending_.any()) {
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running",
+ "state", StateAsValue());
} else {
TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
}
- client_->DidFinishRunningTasks(task_set);
+ client_->DidFinishRunningTileTasks(task_set);
}
-void OneCopyRasterWorkerPool::IssueCopyOperations(int64 count) {
- TRACE_EVENT1(
- "cc", "OneCopyRasterWorkerPool::IssueCopyOperations", "count", count);
+void OneCopyTileTaskWorkerPool::IssueCopyOperations(int64 count) {
+ TRACE_EVENT1("cc", "OneCopyTileTaskWorkerPool::IssueCopyOperations", "count",
+ count);
CopyOperation::Deque copy_operations;
@@ -417,7 +404,7 @@
}
}
-void OneCopyRasterWorkerPool::
+void OneCopyTileTaskWorkerPool::
ScheduleCheckForCompletedCopyOperationsWithLockAcquired(
bool wait_if_needed) {
lock_.AssertAcquired();
@@ -438,9 +425,8 @@
task_runner_->PostDelayedTask(
FROM_HERE,
- base::Bind(&OneCopyRasterWorkerPool::CheckForCompletedCopyOperations,
- weak_ptr_factory_.GetWeakPtr(),
- wait_if_needed),
+ base::Bind(&OneCopyTileTaskWorkerPool::CheckForCompletedCopyOperations,
+ weak_ptr_factory_.GetWeakPtr(), wait_if_needed),
next_check_for_completed_copy_operations_time - now);
last_check_for_completed_copy_operations_time_ =
@@ -448,12 +434,11 @@
check_for_completed_copy_operations_pending_ = true;
}
-void OneCopyRasterWorkerPool::CheckForCompletedCopyOperations(
+void OneCopyTileTaskWorkerPool::CheckForCompletedCopyOperations(
bool wait_if_needed) {
TRACE_EVENT1("cc",
- "OneCopyRasterWorkerPool::CheckForCompletedCopyOperations",
- "wait_if_needed",
- wait_if_needed);
+ "OneCopyTileTaskWorkerPool::CheckForCompletedCopyOperations",
+ "wait_if_needed", wait_if_needed);
resource_pool_->CheckBusyResources(wait_if_needed);
@@ -474,13 +459,13 @@
}
scoped_refptr<base::debug::ConvertableToTraceFormat>
-OneCopyRasterWorkerPool::StateAsValue() const {
+OneCopyTileTaskWorkerPool::StateAsValue() const {
scoped_refptr<base::debug::TracedValue> state =
new base::debug::TracedValue();
state->BeginArray("tasks_pending");
for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set)
- state->AppendBoolean(raster_pending_[task_set]);
+ state->AppendBoolean(tasks_pending_[task_set]);
state->EndArray();
state->BeginDictionary("staging_state");
StagingStateAsValueInto(state.get());
@@ -489,7 +474,7 @@
return state;
}
-void OneCopyRasterWorkerPool::StagingStateAsValueInto(
+void OneCopyTileTaskWorkerPool::StagingStateAsValueInto(
base::debug::TracedValue* staging_state) const {
staging_state->SetInteger("staging_resource_count",
resource_pool_->total_resource_count());
diff --git a/cc/resources/one_copy_raster_worker_pool.h b/cc/resources/one_copy_tile_task_worker_pool.h
similarity index 70%
rename from cc/resources/one_copy_raster_worker_pool.h
rename to cc/resources/one_copy_tile_task_worker_pool.h
index b209da2..c5b30ba 100644
--- a/cc/resources/one_copy_raster_worker_pool.h
+++ b/cc/resources/one_copy_tile_task_worker_pool.h
@@ -2,17 +2,17 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_
+#ifndef CC_RESOURCES_ONE_COPY_TILE_TASK_WORKER_POOL_H_
+#define CC_RESOURCES_ONE_COPY_TILE_TASK_WORKER_POOL_H_
#include "base/memory/weak_ptr.h"
#include "base/synchronization/lock.h"
#include "base/values.h"
#include "cc/base/scoped_ptr_deque.h"
#include "cc/output/context_provider.h"
-#include "cc/resources/raster_worker_pool.h"
-#include "cc/resources/rasterizer.h"
#include "cc/resources/resource_provider.h"
+#include "cc/resources/tile_task_runner.h"
+#include "cc/resources/tile_task_worker_pool.h"
namespace base {
namespace debug {
@@ -27,29 +27,29 @@
typedef int64 CopySequenceNumber;
-class CC_EXPORT OneCopyRasterWorkerPool : public RasterWorkerPool,
- public Rasterizer,
- public RasterizerTaskClient {
+class CC_EXPORT OneCopyTileTaskWorkerPool : public TileTaskWorkerPool,
+ public TileTaskRunner,
+ public TileTaskClient {
public:
- ~OneCopyRasterWorkerPool() override;
+ ~OneCopyTileTaskWorkerPool() override;
- static scoped_ptr<RasterWorkerPool> Create(
+ static scoped_ptr<TileTaskWorkerPool> Create(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
ResourcePool* resource_pool);
- // Overridden from RasterWorkerPool:
- Rasterizer* AsRasterizer() override;
+ // Overridden from TileTaskWorkerPool:
+ TileTaskRunner* AsTileTaskRunner() override;
- // Overridden from Rasterizer:
- void SetClient(RasterizerClient* client) override;
+ // Overridden from TileTaskRunner:
+ void SetClient(TileTaskRunnerClient* client) override;
void Shutdown() override;
- void ScheduleTasks(RasterTaskQueue* queue) override;
+ void ScheduleTasks(TileTaskQueue* queue) override;
void CheckForCompletedTasks() override;
- // Overridden from RasterizerTaskClient:
+ // Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
const Resource* resource) override;
void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
@@ -69,11 +69,11 @@
void AdvanceLastIssuedCopyTo(CopySequenceNumber sequence);
protected:
- OneCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ContextProvider* context_provider,
- ResourceProvider* resource_provider,
- ResourcePool* resource_pool);
+ OneCopyTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ContextProvider* context_provider,
+ ResourceProvider* resource_provider,
+ ResourcePool* resource_pool);
private:
struct CopyOperation {
@@ -90,7 +90,7 @@
const Resource* dst;
};
- void OnRasterFinished(TaskSet task_set);
+ void OnTaskSetFinished(TaskSet task_set);
void AdvanceLastFlushedCopyTo(CopySequenceNumber sequence);
void IssueCopyOperations(int64 count);
void ScheduleCheckForCompletedCopyOperationsWithLockAcquired(
@@ -102,12 +102,12 @@
scoped_refptr<base::SequencedTaskRunner> task_runner_;
TaskGraphRunner* task_graph_runner_;
const NamespaceToken namespace_token_;
- RasterizerClient* client_;
+ TileTaskRunnerClient* client_;
ContextProvider* context_provider_;
ResourceProvider* resource_provider_;
ResourcePool* resource_pool_;
- TaskSetCollection raster_pending_;
- scoped_refptr<RasterizerTask> raster_finished_tasks_[kNumberOfTaskSets];
+ TaskSetCollection tasks_pending_;
+ scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets];
CopySequenceNumber last_issued_copy_operation_;
CopySequenceNumber last_flushed_copy_operation_;
@@ -127,15 +127,15 @@
base::TimeTicks last_check_for_completed_copy_operations_time_;
bool shutdown_;
- base::WeakPtrFactory<OneCopyRasterWorkerPool> weak_ptr_factory_;
+ base::WeakPtrFactory<OneCopyTileTaskWorkerPool> weak_ptr_factory_;
// "raster finished" tasks need their own factory as they need to be
// canceled when ScheduleTasks() is called.
- base::WeakPtrFactory<OneCopyRasterWorkerPool>
- raster_finished_weak_ptr_factory_;
+ base::WeakPtrFactory<OneCopyTileTaskWorkerPool>
+ task_set_finished_weak_ptr_factory_;
- DISALLOW_COPY_AND_ASSIGN(OneCopyRasterWorkerPool);
+ DISALLOW_COPY_AND_ASSIGN(OneCopyTileTaskWorkerPool);
};
} // namespace cc
-#endif // CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_
+#endif // CC_RESOURCES_ONE_COPY_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/resources/picture_pile.cc b/cc/resources/picture_pile.cc
index c3050c3..698fe2c 100644
--- a/cc/resources/picture_pile.cc
+++ b/cc/resources/picture_pile.cc
@@ -10,7 +10,7 @@
#include "cc/base/region.h"
#include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/tile_task_worker_pool.h"
#include "skia/ext/analysis_canvas.h"
namespace {
@@ -545,7 +545,7 @@
// raster thread doesn't provide any benefit. This might change
// in the future but we avoid it for now to reduce the cost of
// Picture::Create.
- bool gather_pixel_refs = RasterWorkerPool::GetNumRasterThreads() > 1;
+ bool gather_pixel_refs = TileTaskWorkerPool::GetNumWorkerThreads() > 1;
for (int i = 0; i < repeat_count; i++) {
picture = Picture::Create(padded_record_rect, painter, tile_grid_info_,
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_tile_task_worker_pool.cc
similarity index 76%
rename from cc/resources/pixel_buffer_raster_worker_pool.cc
rename to cc/resources/pixel_buffer_tile_task_worker_pool.cc
index 175e7d4..7256f94 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_tile_task_worker_pool.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/resources/pixel_buffer_raster_worker_pool.h"
+#include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
#include <algorithm>
@@ -41,9 +41,9 @@
if (!memory_)
return;
- RasterWorkerPool::PlaybackToMemory(memory_, resource_->format(),
- resource_->size(), stride_,
- raster_source, rect, scale);
+ TileTaskWorkerPool::PlaybackToMemory(memory_, resource_->format(),
+ resource_->size(), stride_,
+ raster_source, rect, scale);
}
private:
@@ -89,28 +89,25 @@
} // namespace
-PixelBufferRasterWorkerPool::RasterTaskState::RasterTaskState(
+PixelBufferTileTaskWorkerPool::RasterTaskState::RasterTaskState(
RasterTask* task,
const TaskSetCollection& task_sets)
: type(UNSCHEDULED), task(task), task_sets(task_sets) {
}
// static
-scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create(
+scoped_ptr<TileTaskWorkerPool> PixelBufferTileTaskWorkerPool::Create(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
size_t max_transfer_buffer_usage_bytes) {
- return make_scoped_ptr<RasterWorkerPool>(
- new PixelBufferRasterWorkerPool(task_runner,
- task_graph_runner,
- context_provider,
- resource_provider,
- max_transfer_buffer_usage_bytes));
+ return make_scoped_ptr<TileTaskWorkerPool>(new PixelBufferTileTaskWorkerPool(
+ task_runner, task_graph_runner, context_provider, resource_provider,
+ max_transfer_buffer_usage_bytes));
}
-PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
+PixelBufferTileTaskWorkerPool::PixelBufferTileTaskWorkerPool(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
@@ -128,16 +125,17 @@
has_performed_uploads_since_last_flush_(false),
check_for_completed_raster_task_notifier_(
task_runner,
- base::Bind(&PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks,
- base::Unretained(this)),
+ base::Bind(
+ &PixelBufferTileTaskWorkerPool::CheckForCompletedRasterTasks,
+ base::Unretained(this)),
base::TimeDelta::FromMilliseconds(
kCheckForCompletedRasterTasksDelayMs)),
- raster_finished_weak_ptr_factory_(this) {
+ task_set_finished_weak_ptr_factory_(this) {
DCHECK(context_provider_);
std::fill(task_counts_, task_counts_ + kNumberOfTaskSets, 0);
}
-PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
+PixelBufferTileTaskWorkerPool::~PixelBufferTileTaskWorkerPool() {
DCHECK_EQ(0u, raster_task_states_.size());
DCHECK_EQ(0u, raster_tasks_with_pending_upload_.size());
DCHECK_EQ(0u, completed_raster_tasks_.size());
@@ -145,14 +143,16 @@
DCHECK(NonEmptyTaskSetsFromTaskCounts(task_counts_).none());
}
-Rasterizer* PixelBufferRasterWorkerPool::AsRasterizer() { return this; }
+TileTaskRunner* PixelBufferTileTaskWorkerPool::AsTileTaskRunner() {
+ return this;
+}
-void PixelBufferRasterWorkerPool::SetClient(RasterizerClient* client) {
+void PixelBufferTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) {
client_ = client;
}
-void PixelBufferRasterWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::Shutdown");
+void PixelBufferTileTaskWorkerPool::Shutdown() {
+ TRACE_EVENT0("cc", "PixelBufferTileTaskWorkerPool::Shutdown");
shutdown_ = true;
@@ -166,8 +166,7 @@
check_for_completed_raster_task_notifier_.Shutdown();
for (RasterTaskState::Vector::iterator it = raster_task_states_.begin();
- it != raster_task_states_.end();
- ++it) {
+ it != raster_task_states_.end(); ++it) {
RasterTaskState& state = *it;
// All unscheduled tasks need to be canceled.
@@ -179,8 +178,8 @@
DCHECK_EQ(completed_raster_tasks_.size(), raster_task_states_.size());
}
-void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
- TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleTasks");
+void PixelBufferTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) {
+ TRACE_EVENT0("cc", "PixelBufferTileTaskWorkerPool::ScheduleTasks");
if (should_notify_client_if_no_tasks_are_pending_.none())
TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
@@ -189,27 +188,24 @@
std::fill(task_counts_, task_counts_ + kNumberOfTaskSets, 0);
// Update raster task state and remove items from old queue.
- for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
- it != queue->items.end();
- ++it) {
- const RasterTaskQueue::Item& item = *it;
+ for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+ it != queue->items.end(); ++it) {
+ const TileTaskQueue::Item& item = *it;
RasterTask* task = item.task;
// Remove any old items that are associated with this task. The result is
// that the old queue is left with all items not present in this queue,
// which we use below to determine what tasks need to be canceled.
- RasterTaskQueue::Item::Vector::iterator old_it =
- std::find_if(raster_tasks_.items.begin(),
- raster_tasks_.items.end(),
- RasterTaskQueue::Item::TaskComparator(task));
+ TileTaskQueue::Item::Vector::iterator old_it =
+ std::find_if(raster_tasks_.items.begin(), raster_tasks_.items.end(),
+ TileTaskQueue::Item::TaskComparator(task));
if (old_it != raster_tasks_.items.end()) {
std::swap(*old_it, raster_tasks_.items.back());
raster_tasks_.items.pop_back();
}
RasterTaskState::Vector::iterator state_it =
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
if (state_it != raster_task_states_.end()) {
RasterTaskState& state = *state_it;
@@ -230,16 +226,14 @@
}
// Determine what tasks in old queue need to be canceled.
- for (RasterTaskQueue::Item::Vector::const_iterator it =
+ for (TileTaskQueue::Item::Vector::const_iterator it =
raster_tasks_.items.begin();
- it != raster_tasks_.items.end();
- ++it) {
- const RasterTaskQueue::Item& item = *it;
+ it != raster_tasks_.items.end(); ++it) {
+ const TileTaskQueue::Item& item = *it;
RasterTask* task = item.task;
RasterTaskState::Vector::iterator state_it =
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
// We've already processed completion if we can't find a RasterTaskState for
// this task.
@@ -277,33 +271,30 @@
// Reschedule check for completed raster tasks.
check_for_completed_raster_task_notifier_.Schedule();
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, StateName(), "state", StateAsValue());
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, StateName(),
+ "state", StateAsValue());
}
-void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::CheckForCompletedTasks");
+void PixelBufferTileTaskWorkerPool::CheckForCompletedTasks() {
+ TRACE_EVENT0("cc", "PixelBufferTileTaskWorkerPool::CheckForCompletedTasks");
CheckForCompletedRasterizerTasks();
CheckForCompletedUploads();
FlushUploads();
- for (RasterizerTask::Vector::const_iterator it =
+ for (TileTask::Vector::const_iterator it =
completed_image_decode_tasks_.begin();
- it != completed_image_decode_tasks_.end();
- ++it) {
- RasterizerTask* task = it->get();
+ it != completed_image_decode_tasks_.end(); ++it) {
+ TileTask* task = it->get();
task->RunReplyOnOriginThread();
}
completed_image_decode_tasks_.clear();
for (RasterTask::Vector::const_iterator it = completed_raster_tasks_.begin();
- it != completed_raster_tasks_.end();
- ++it) {
+ it != completed_raster_tasks_.end(); ++it) {
RasterTask* task = it->get();
RasterTaskState::Vector::iterator state_it =
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
DCHECK(state_it != raster_task_states_.end());
DCHECK_EQ(RasterTaskState::COMPLETED, state_it->type);
@@ -316,22 +307,20 @@
completed_raster_tasks_.clear();
}
-scoped_ptr<RasterBuffer> PixelBufferRasterWorkerPool::AcquireBufferForRaster(
+scoped_ptr<RasterBuffer> PixelBufferTileTaskWorkerPool::AcquireBufferForRaster(
const Resource* resource) {
return make_scoped_ptr<RasterBuffer>(
new RasterBufferImpl(resource_provider_, resource));
}
-void PixelBufferRasterWorkerPool::ReleaseBufferForRaster(
+void PixelBufferTileTaskWorkerPool::ReleaseBufferForRaster(
scoped_ptr<RasterBuffer> buffer) {
// Nothing to do here. RasterBufferImpl destructor cleans up after itself.
}
-void PixelBufferRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
- TRACE_EVENT2("cc",
- "PixelBufferRasterWorkerPool::OnRasterFinished",
- "task_set",
- task_set,
+void PixelBufferTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) {
+ TRACE_EVENT2("cc", "PixelBufferTileTaskWorkerPool::OnTaskSetFinished",
+ "task_set", task_set,
"should_notify_client_if_no_tasks_are_pending",
should_notify_client_if_no_tasks_are_pending_[task_set]);
@@ -339,7 +328,7 @@
// already been notified.
if (!should_notify_client_if_no_tasks_are_pending_[task_set])
return;
- raster_finished_tasks_pending_[task_set] = false;
+ task_set_finished_tasks_pending_[task_set] = false;
// This reduces latency between the time when all tasks required for
// activation have finished running and the time when the client is
@@ -347,7 +336,7 @@
CheckForCompletedRasterTasks();
}
-void PixelBufferRasterWorkerPool::FlushUploads() {
+void PixelBufferTileTaskWorkerPool::FlushUploads() {
if (!has_performed_uploads_since_last_flush_)
return;
@@ -355,20 +344,19 @@
has_performed_uploads_since_last_flush_ = false;
}
-void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
+void PixelBufferTileTaskWorkerPool::CheckForCompletedUploads() {
RasterTask::Vector tasks_with_completed_uploads;
// First check if any have completed.
while (!raster_tasks_with_pending_upload_.empty()) {
RasterTask* task = raster_tasks_with_pending_upload_.front().get();
- DCHECK(std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ DCHECK(std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(task)) !=
raster_task_states_.end());
- DCHECK_EQ(RasterTaskState::UPLOADING,
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
- RasterTaskState::TaskComparator(task))->type);
+ DCHECK_EQ(
+ RasterTaskState::UPLOADING,
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
+ RasterTaskState::TaskComparator(task))->type);
// Uploads complete in the order they are issued.
if (!resource_provider_->DidSetPixelsComplete(task->resource()->id()))
@@ -390,8 +378,7 @@
while (it != raster_tasks_with_pending_upload_.end()) {
RasterTask* task = it->get();
RasterTaskState::Vector::const_iterator state_it =
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
DCHECK(state_it != raster_task_states_.end());
const RasterTaskState& state = *state_it;
@@ -413,8 +400,7 @@
// all previous uploads, we would rather wait only once downstream.
for (RasterTask::Vector::reverse_iterator it =
tasks_with_uploads_to_force.rbegin();
- it != tasks_with_uploads_to_force.rend();
- ++it) {
+ it != tasks_with_uploads_to_force.rend(); ++it) {
RasterTask* task = it->get();
resource_provider_->ForceSetPixelsToComplete(task->resource()->id());
@@ -426,12 +412,10 @@
// to |completed_raster_tasks_|.
for (RasterTask::Vector::const_iterator it =
tasks_with_completed_uploads.begin();
- it != tasks_with_completed_uploads.end();
- ++it) {
+ it != tasks_with_completed_uploads.end(); ++it) {
RasterTask* task = it->get();
RasterTaskState::Vector::iterator state_it =
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
DCHECK(state_it != raster_task_states_.end());
RasterTaskState& state = *state_it;
@@ -454,9 +438,9 @@
}
}
-void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
+void PixelBufferTileTaskWorkerPool::CheckForCompletedRasterTasks() {
TRACE_EVENT0("cc",
- "PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks");
+ "PixelBufferTileTaskWorkerPool::CheckForCompletedRasterTasks");
// Since this function can be called directly, cancel any pending checks.
check_for_completed_raster_task_notifier_.Cancel();
@@ -470,7 +454,7 @@
// Determine what client notifications to generate.
TaskSetCollection will_notify_client_that_no_tasks_are_pending =
should_notify_client_if_no_tasks_are_pending_ &
- ~raster_finished_tasks_pending_ & ~PendingTasks();
+ ~task_set_finished_tasks_pending_ & ~PendingTasks();
// Adjust the need to generate notifications before scheduling more tasks.
should_notify_client_if_no_tasks_are_pending_ &=
@@ -480,8 +464,8 @@
if (PendingRasterTaskCount())
ScheduleMoreTasks();
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, StateName(), "state", StateAsValue());
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, StateName(),
+ "state", StateAsValue());
// Schedule another check for completed raster tasks while there are
// pending raster tasks or pending uploads.
@@ -495,17 +479,17 @@
for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
if (will_notify_client_that_no_tasks_are_pending[task_set]) {
DCHECK(!PendingTasks()[task_set]);
- client_->DidFinishRunningTasks(task_set);
+ client_->DidFinishRunningTileTasks(task_set);
}
}
}
-void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
- TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleMoreTasks");
+void PixelBufferTileTaskWorkerPool::ScheduleMoreTasks() {
+ TRACE_EVENT0("cc", "PixelBufferTileTaskWorkerPool::ScheduleMoreTasks");
RasterTaskVector tasks[kNumberOfTaskSets];
- unsigned priority = kRasterTaskPriorityBase;
+ unsigned priority = kTileTaskPriorityBase;
graph_.Reset();
@@ -513,19 +497,17 @@
TaskSetCollection did_throttle_raster_tasks;
size_t scheduled_raster_task_count = 0;
- for (RasterTaskQueue::Item::Vector::const_iterator it =
+ for (TileTaskQueue::Item::Vector::const_iterator it =
raster_tasks_.items.begin();
- it != raster_tasks_.items.end();
- ++it) {
- const RasterTaskQueue::Item& item = *it;
+ it != raster_tasks_.items.end(); ++it) {
+ const TileTaskQueue::Item& item = *it;
RasterTask* task = item.task;
DCHECK(item.task_sets.any());
// |raster_task_states_| contains the state of all tasks that we have not
// yet run reply callbacks for.
RasterTaskState::Vector::iterator state_it =
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
if (state_it == raster_task_states_.end())
continue;
@@ -581,36 +563,34 @@
}
}
- // Cancel existing OnRasterFinished callbacks.
- raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
+ // Cancel existing OnTaskSetFinished callbacks.
+ task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
- scoped_refptr<RasterizerTask> new_raster_finished_tasks[kNumberOfTaskSets];
+ scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets];
size_t scheduled_task_counts[kNumberOfTaskSets] = {0};
for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
scheduled_task_counts[task_set] = tasks[task_set].container().size();
DCHECK_LE(scheduled_task_counts[task_set], task_counts_[task_set]);
- // Schedule OnRasterFinished call for task set only when notification is
+ // Schedule OnTaskSetFinished call for task set only when notification is
// pending and throttling is not preventing all pending tasks in the set
// from being scheduled.
if (!did_throttle_raster_tasks[task_set] &&
should_notify_client_if_no_tasks_are_pending_[task_set]) {
- new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
+ new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask(
task_runner_.get(),
- base::Bind(&PixelBufferRasterWorkerPool::OnRasterFinished,
- raster_finished_weak_ptr_factory_.GetWeakPtr(),
+ base::Bind(&PixelBufferTileTaskWorkerPool::OnTaskSetFinished,
+ task_set_finished_weak_ptr_factory_.GetWeakPtr(),
task_set));
- raster_finished_tasks_pending_[task_set] = true;
- InsertNodeForTask(&graph_,
- new_raster_finished_tasks[task_set].get(),
- kRasterFinishedTaskPriority,
+ task_set_finished_tasks_pending_[task_set] = true;
+ InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(),
+ kTaskSetFinishedTaskPriority,
scheduled_task_counts[task_set]);
for (RasterTaskVector::ContainerType::const_iterator it =
tasks[task_set].container().begin();
- it != tasks[task_set].container().end();
- ++it) {
+ it != tasks[task_set].container().end(); ++it) {
graph_.edges.push_back(
- TaskGraph::Edge(*it, new_raster_finished_tasks[task_set].get()));
+ TaskGraph::Edge(*it, new_task_set_finished_tasks[task_set].get()));
}
}
}
@@ -622,23 +602,23 @@
scheduled_raster_task_count_ = scheduled_raster_task_count;
- std::copy(new_raster_finished_tasks,
- new_raster_finished_tasks + kNumberOfTaskSets,
- raster_finished_tasks_);
+ std::copy(new_task_set_finished_tasks,
+ new_task_set_finished_tasks + kNumberOfTaskSets,
+ task_set_finished_tasks_);
}
-unsigned PixelBufferRasterWorkerPool::PendingRasterTaskCount() const {
+unsigned PixelBufferTileTaskWorkerPool::PendingRasterTaskCount() const {
unsigned num_completed_raster_tasks =
raster_tasks_with_pending_upload_.size() + completed_raster_tasks_.size();
DCHECK_GE(raster_task_states_.size(), num_completed_raster_tasks);
return raster_task_states_.size() - num_completed_raster_tasks;
}
-TaskSetCollection PixelBufferRasterWorkerPool::PendingTasks() const {
+TaskSetCollection PixelBufferTileTaskWorkerPool::PendingTasks() const {
return NonEmptyTaskSetsFromTaskCounts(task_counts_);
}
-const char* PixelBufferRasterWorkerPool::StateName() const {
+const char* PixelBufferTileTaskWorkerPool::StateName() const {
if (scheduled_raster_task_count_)
return "rasterizing";
if (PendingRasterTaskCount())
@@ -649,16 +629,15 @@
return "finishing";
}
-void PixelBufferRasterWorkerPool::CheckForCompletedRasterizerTasks() {
- TRACE_EVENT0("cc",
- "PixelBufferRasterWorkerPool::CheckForCompletedRasterizerTasks");
+void PixelBufferTileTaskWorkerPool::CheckForCompletedRasterizerTasks() {
+ TRACE_EVENT0(
+ "cc", "PixelBufferTileTaskWorkerPool::CheckForCompletedRasterizerTasks");
task_graph_runner_->CollectCompletedTasks(namespace_token_,
&completed_tasks_);
for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end();
- ++it) {
- RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
+ it != completed_tasks_.end(); ++it) {
+ TileTask* task = static_cast<TileTask*>(it->get());
RasterTask* raster_task = task->AsRasterTask();
if (!raster_task) {
@@ -671,8 +650,7 @@
}
RasterTaskState::Vector::iterator state_it =
- std::find_if(raster_task_states_.begin(),
- raster_task_states_.end(),
+ std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
RasterTaskState::TaskComparator(raster_task));
DCHECK(state_it != raster_task_states_.end());
@@ -689,10 +667,9 @@
raster_task->CompleteOnOriginThread(this);
raster_task->DidComplete();
- RasterTaskQueue::Item::Vector::const_iterator item_it =
- std::find_if(raster_tasks_.items.begin(),
- raster_tasks_.items.end(),
- RasterTaskQueue::Item::TaskComparator(raster_task));
+ TileTaskQueue::Item::Vector::const_iterator item_it =
+ std::find_if(raster_tasks_.items.begin(), raster_tasks_.items.end(),
+ TileTaskQueue::Item::TaskComparator(raster_task));
if (item_it != raster_tasks_.items.end()) {
state.type = RasterTaskState::UNSCHEDULED;
continue;
@@ -721,7 +698,7 @@
}
scoped_refptr<base::debug::ConvertableToTraceFormat>
-PixelBufferRasterWorkerPool::StateAsValue() const {
+PixelBufferTileTaskWorkerPool::StateAsValue() const {
scoped_refptr<base::debug::TracedValue> state =
new base::debug::TracedValue();
state->SetInteger("completed_count", completed_raster_tasks_.size());
@@ -737,7 +714,7 @@
return state;
}
-void PixelBufferRasterWorkerPool::ThrottleStateAsValueInto(
+void PixelBufferTileTaskWorkerPool::ThrottleStateAsValueInto(
base::debug::TracedValue* throttle_state) const {
throttle_state->SetInteger("bytes_available_for_upload",
max_bytes_pending_upload_ - bytes_pending_upload_);
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.h b/cc/resources/pixel_buffer_tile_task_worker_pool.h
similarity index 64%
rename from cc/resources/pixel_buffer_raster_worker_pool.h
rename to cc/resources/pixel_buffer_tile_task_worker_pool.h
index 7fb45ec..1135dc9 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.h
+++ b/cc/resources/pixel_buffer_tile_task_worker_pool.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_RESOURCES_PIXEL_BUFFER_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_PIXEL_BUFFER_RASTER_WORKER_POOL_H_
+#ifndef CC_RESOURCES_PIXEL_BUFFER_TILE_TASK_WORKER_POOL_H_
+#define CC_RESOURCES_PIXEL_BUFFER_TILE_TASK_WORKER_POOL_H_
#include <deque>
#include <vector>
@@ -12,8 +12,8 @@
#include "base/values.h"
#include "cc/base/delayed_unique_notifier.h"
#include "cc/output/context_provider.h"
-#include "cc/resources/raster_worker_pool.h"
-#include "cc/resources/rasterizer.h"
+#include "cc/resources/tile_task_runner.h"
+#include "cc/resources/tile_task_worker_pool.h"
namespace base {
namespace debug {
@@ -25,29 +25,29 @@
namespace cc {
class ResourceProvider;
-class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool,
- public Rasterizer,
- public RasterizerTaskClient {
+class CC_EXPORT PixelBufferTileTaskWorkerPool : public TileTaskWorkerPool,
+ public TileTaskRunner,
+ public TileTaskClient {
public:
- ~PixelBufferRasterWorkerPool() override;
+ ~PixelBufferTileTaskWorkerPool() override;
- static scoped_ptr<RasterWorkerPool> Create(
+ static scoped_ptr<TileTaskWorkerPool> Create(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
size_t max_transfer_buffer_usage_bytes);
- // Overridden from RasterWorkerPool:
- Rasterizer* AsRasterizer() override;
+ // Overridden from TileTaskWorkerPool:
+ TileTaskRunner* AsTileTaskRunner() override;
- // Overridden from Rasterizer:
- void SetClient(RasterizerClient* client) override;
+ // Overridden from TileTaskRunner:
+ void SetClient(TileTaskRunnerClient* client) override;
void Shutdown() override;
- void ScheduleTasks(RasterTaskQueue* queue) override;
+ void ScheduleTasks(TileTaskQueue* queue) override;
void CheckForCompletedTasks() override;
- // Overridden from RasterizerTaskClient:
+ // Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
const Resource* resource) override;
void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
@@ -77,13 +77,13 @@
typedef std::deque<scoped_refptr<RasterTask>> RasterTaskDeque;
- PixelBufferRasterWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ContextProvider* context_provider,
- ResourceProvider* resource_provider,
- size_t max_transfer_buffer_usage_bytes);
+ PixelBufferTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ContextProvider* context_provider,
+ ResourceProvider* resource_provider,
+ size_t max_transfer_buffer_usage_bytes);
- void OnRasterFinished(TaskSet task_set);
+ void OnTaskSetFinished(TaskSet task_set);
void FlushUploads();
void CheckForCompletedUploads();
void CheckForCompletedRasterTasks();
@@ -99,17 +99,17 @@
scoped_refptr<base::SequencedTaskRunner> task_runner_;
TaskGraphRunner* task_graph_runner_;
const NamespaceToken namespace_token_;
- RasterizerClient* client_;
+ TileTaskRunnerClient* client_;
ContextProvider* context_provider_;
ResourceProvider* resource_provider_;
bool shutdown_;
- RasterTaskQueue raster_tasks_;
+ TileTaskQueue raster_tasks_;
RasterTaskState::Vector raster_task_states_;
RasterTaskDeque raster_tasks_with_pending_upload_;
RasterTask::Vector completed_raster_tasks_;
- RasterizerTask::Vector completed_image_decode_tasks_;
+ TileTask::Vector completed_image_decode_tasks_;
size_t scheduled_raster_task_count_;
size_t task_counts_[kNumberOfTaskSets];
@@ -118,23 +118,23 @@
bool has_performed_uploads_since_last_flush_;
TaskSetCollection should_notify_client_if_no_tasks_are_pending_;
- TaskSetCollection raster_finished_tasks_pending_;
+ TaskSetCollection task_set_finished_tasks_pending_;
DelayedUniqueNotifier check_for_completed_raster_task_notifier_;
- scoped_refptr<RasterizerTask> raster_finished_tasks_[kNumberOfTaskSets];
+ scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets];
// Task graph used when scheduling tasks and vector used to gather
// completed tasks.
TaskGraph graph_;
Task::Vector completed_tasks_;
- base::WeakPtrFactory<PixelBufferRasterWorkerPool>
- raster_finished_weak_ptr_factory_;
+ base::WeakPtrFactory<PixelBufferTileTaskWorkerPool>
+ task_set_finished_weak_ptr_factory_;
- DISALLOW_COPY_AND_ASSIGN(PixelBufferRasterWorkerPool);
+ DISALLOW_COPY_AND_ASSIGN(PixelBufferTileTaskWorkerPool);
};
} // namespace cc
-#endif // CC_RESOURCES_PIXEL_BUFFER_RASTER_WORKER_POOL_H_
+#endif // CC_RESOURCES_PIXEL_BUFFER_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
deleted file mode 100644
index ca951f6..0000000
--- a/cc/resources/raster_worker_pool.cc
+++ /dev/null
@@ -1,266 +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 "cc/resources/raster_worker_pool.h"
-
-#include <algorithm>
-
-#include "base/debug/trace_event.h"
-#include "base/lazy_instance.h"
-#include "base/strings/stringprintf.h"
-#include "base/threading/simple_thread.h"
-#include "cc/base/scoped_ptr_deque.h"
-#include "cc/resources/raster_source.h"
-#include "skia/ext/refptr.h"
-#include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkSurface.h"
-
-namespace cc {
-namespace {
-
-class RasterTaskGraphRunner : public TaskGraphRunner,
- public base::DelegateSimpleThread::Delegate {
- public:
- RasterTaskGraphRunner() {
- size_t num_threads = RasterWorkerPool::GetNumRasterThreads();
- while (workers_.size() < num_threads) {
- scoped_ptr<base::DelegateSimpleThread> worker =
- make_scoped_ptr(new base::DelegateSimpleThread(
- this,
- base::StringPrintf("CompositorRasterWorker%u",
- static_cast<unsigned>(workers_.size() + 1))
- .c_str()));
- worker->Start();
-#if defined(OS_ANDROID) || defined(OS_LINUX)
- worker->SetThreadPriority(base::kThreadPriority_Background);
-#endif
- workers_.push_back(worker.Pass());
- }
- }
-
- ~RasterTaskGraphRunner() override { NOTREACHED(); }
-
- private:
- // Overridden from base::DelegateSimpleThread::Delegate:
- void Run() override { TaskGraphRunner::Run(); }
-
- ScopedPtrDeque<base::DelegateSimpleThread> workers_;
-};
-
-base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
- LAZY_INSTANCE_INITIALIZER;
-
-const int kDefaultNumRasterThreads = 1;
-
-int g_num_raster_threads = 0;
-
-class RasterFinishedTaskImpl : public RasterizerTask {
- public:
- explicit RasterFinishedTaskImpl(
- base::SequencedTaskRunner* task_runner,
- const base::Closure& on_raster_finished_callback)
- : task_runner_(task_runner),
- on_raster_finished_callback_(on_raster_finished_callback) {}
-
- // Overridden from Task:
- void RunOnWorkerThread() override {
- TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
- RasterFinished();
- }
-
- // Overridden from RasterizerTask:
- void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
- void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
- void RunReplyOnOriginThread() override {}
-
- protected:
- ~RasterFinishedTaskImpl() override {}
-
- void RasterFinished() {
- task_runner_->PostTask(FROM_HERE, on_raster_finished_callback_);
- }
-
- private:
- scoped_refptr<base::SequencedTaskRunner> task_runner_;
- const base::Closure on_raster_finished_callback_;
-
- DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
-};
-
-} // namespace
-
-// This allows a micro benchmark system to run tasks with highest priority,
-// since it should finish as quickly as possible.
-unsigned RasterWorkerPool::kBenchmarkRasterTaskPriority = 0u;
-// Task priorities that make sure raster finished tasks run before any
-// remaining raster tasks.
-unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 1u;
-unsigned RasterWorkerPool::kRasterTaskPriorityBase = 2u;
-
-RasterWorkerPool::RasterWorkerPool() {}
-
-RasterWorkerPool::~RasterWorkerPool() {}
-
-// static
-void RasterWorkerPool::SetNumRasterThreads(int num_threads) {
- DCHECK_LT(0, num_threads);
- DCHECK_EQ(0, g_num_raster_threads);
-
- g_num_raster_threads = num_threads;
-}
-
-// static
-int RasterWorkerPool::GetNumRasterThreads() {
- if (!g_num_raster_threads)
- g_num_raster_threads = kDefaultNumRasterThreads;
-
- return g_num_raster_threads;
-}
-
-// static
-TaskGraphRunner* RasterWorkerPool::GetTaskGraphRunner() {
- return g_task_graph_runner.Pointer();
-}
-
-// static
-scoped_refptr<RasterizerTask> RasterWorkerPool::CreateRasterFinishedTask(
- base::SequencedTaskRunner* task_runner,
- const base::Closure& on_raster_finished_callback) {
- return make_scoped_refptr(
- new RasterFinishedTaskImpl(task_runner, on_raster_finished_callback));
-}
-
-// static
-void RasterWorkerPool::ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
- TaskGraph* graph) {
- TRACE_EVENT0("cc", "Rasterizer::ScheduleTasksOnOriginThread");
-
- for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
- it != graph->nodes.end();
- ++it) {
- TaskGraph::Node& node = *it;
- RasterizerTask* task = static_cast<RasterizerTask*>(node.task);
-
- if (!task->HasBeenScheduled()) {
- task->WillSchedule();
- task->ScheduleOnOriginThread(client);
- task->DidSchedule();
- }
- }
-}
-
-// static
-void RasterWorkerPool::InsertNodeForTask(TaskGraph* graph,
- RasterizerTask* task,
- unsigned priority,
- size_t dependencies) {
- DCHECK(std::find_if(graph->nodes.begin(),
- graph->nodes.end(),
- TaskGraph::Node::TaskComparator(task)) ==
- graph->nodes.end());
- graph->nodes.push_back(TaskGraph::Node(task, priority, dependencies));
-}
-
-// static
-void RasterWorkerPool::InsertNodesForRasterTask(
- TaskGraph* graph,
- RasterTask* raster_task,
- const ImageDecodeTask::Vector& decode_tasks,
- unsigned priority) {
- size_t dependencies = 0u;
-
- // Insert image decode tasks.
- for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
- it != decode_tasks.end();
- ++it) {
- ImageDecodeTask* decode_task = it->get();
-
- // Skip if already decoded.
- if (decode_task->HasCompleted())
- continue;
-
- dependencies++;
-
- // Add decode task if it doesn't already exists in graph.
- TaskGraph::Node::Vector::iterator decode_it =
- std::find_if(graph->nodes.begin(),
- graph->nodes.end(),
- TaskGraph::Node::TaskComparator(decode_task));
- if (decode_it == graph->nodes.end())
- InsertNodeForTask(graph, decode_task, priority, 0u);
-
- graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
- }
-
- InsertNodeForTask(graph, raster_task, priority, dependencies);
-}
-
-static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
- switch (format) {
- case RGBA_4444:
- case RGBA_8888:
- case BGRA_8888:
- return true;
- case ALPHA_8:
- case LUMINANCE_8:
- case RGB_565:
- case ETC1:
- case RED_8:
- return false;
- }
- NOTREACHED();
- return false;
-}
-
-// static
-void RasterWorkerPool::PlaybackToMemory(void* memory,
- ResourceFormat format,
- const gfx::Size& size,
- int stride,
- const RasterSource* raster_source,
- const gfx::Rect& rect,
- float scale) {
- DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format;
-
- // Uses kPremul_SkAlphaType since the result is not known to be opaque.
- SkImageInfo info =
- SkImageInfo::MakeN32(size.width(), size.height(), kPremul_SkAlphaType);
- SkColorType buffer_color_type = ResourceFormatToSkColorType(format);
- bool needs_copy = buffer_color_type != info.colorType();
-
- // Use unknown pixel geometry to disable LCD text.
- SkSurfaceProps surface_props(0, kUnknown_SkPixelGeometry);
- if (raster_source->CanUseLCDText()) {
- // LegacyFontHost will get LCD text and skia figures out what type to use.
- surface_props = SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
- }
-
- if (!stride)
- stride = info.minRowBytes();
-
- if (!needs_copy) {
- skia::RefPtr<SkSurface> surface = skia::AdoptRef(
- SkSurface::NewRasterDirect(info, memory, stride, &surface_props));
- skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
- raster_source->PlaybackToCanvas(canvas.get(), rect, scale);
- return;
- }
-
- skia::RefPtr<SkSurface> surface =
- skia::AdoptRef(SkSurface::NewRaster(info, &surface_props));
- skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
- raster_source->PlaybackToCanvas(canvas.get(), rect, scale);
-
- SkImageInfo dst_info = info;
- dst_info.fColorType = buffer_color_type;
- // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
- // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
- // is fixed.
- const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
- DCHECK_EQ(0u, dst_row_bytes % 4);
- bool success = canvas->readPixels(dst_info, memory, dst_row_bytes, 0, 0);
- DCHECK_EQ(true, success);
-}
-
-} // namespace cc
diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc
deleted file mode 100644
index d86155a..0000000
--- a/cc/resources/raster_worker_pool_perftest.cc
+++ /dev/null
@@ -1,533 +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 "cc/resources/raster_worker_pool.h"
-
-#include "base/test/test_simple_task_runner.h"
-#include "base/time/time.h"
-#include "cc/debug/lap_timer.h"
-#include "cc/output/context_provider.h"
-#include "cc/resources/bitmap_raster_worker_pool.h"
-#include "cc/resources/gpu_raster_worker_pool.h"
-#include "cc/resources/one_copy_raster_worker_pool.h"
-#include "cc/resources/pixel_buffer_raster_worker_pool.h"
-#include "cc/resources/raster_buffer.h"
-#include "cc/resources/rasterizer.h"
-#include "cc/resources/resource_pool.h"
-#include "cc/resources/resource_provider.h"
-#include "cc/resources/scoped_resource.h"
-#include "cc/resources/zero_copy_raster_worker_pool.h"
-#include "cc/test/fake_output_surface.h"
-#include "cc/test/fake_output_surface_client.h"
-#include "cc/test/test_context_support.h"
-#include "cc/test/test_gpu_memory_buffer_manager.h"
-#include "cc/test/test_shared_bitmap_manager.h"
-#include "cc/test/test_web_graphics_context_3d.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/perf/perf_test.h"
-#include "third_party/khronos/GLES2/gl2.h"
-
-namespace cc {
-namespace {
-
-class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
- // Overridden from gpu::gles2::GLES2Interface:
- GLuint CreateImageCHROMIUM(ClientBuffer buffer,
- GLsizei width,
- GLsizei height,
- GLenum internalformat) override {
- return 1u;
- }
- void GenBuffers(GLsizei n, GLuint* buffers) override {
- for (GLsizei i = 0; i < n; ++i)
- buffers[i] = 1u;
- }
- void GenTextures(GLsizei n, GLuint* textures) override {
- for (GLsizei i = 0; i < n; ++i)
- textures[i] = 1u;
- }
- void GetIntegerv(GLenum pname, GLint* params) override {
- if (pname == GL_MAX_TEXTURE_SIZE)
- *params = INT_MAX;
- }
- void GenQueriesEXT(GLsizei n, GLuint* queries) override {
- for (GLsizei i = 0; i < n; ++i)
- queries[i] = 1u;
- }
- void GetQueryObjectuivEXT(GLuint query,
- GLenum pname,
- GLuint* params) override {
- if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
- *params = 1;
- }
-};
-
-class PerfContextProvider : public ContextProvider {
- public:
- PerfContextProvider() : context_gl_(new PerfGLES2Interface) {}
-
- bool BindToCurrentThread() override { return true; }
- Capabilities ContextCapabilities() override {
- Capabilities capabilities;
- capabilities.gpu.image = true;
- capabilities.gpu.sync_query = true;
- return capabilities;
- }
- gpu::gles2::GLES2Interface* ContextGL() override { return context_gl_.get(); }
- gpu::ContextSupport* ContextSupport() override { return &support_; }
- class GrContext* GrContext() override {
- return NULL;
- }
- bool IsContextLost() override { return false; }
- void VerifyContexts() override {}
- void DeleteCachedResources() override {}
- bool DestroyedOnMainThread() override { return false; }
- void SetLostContextCallback(const LostContextCallback& cb) override {}
- void SetMemoryPolicyChangedCallback(
- const MemoryPolicyChangedCallback& cb) override {}
-
- private:
- ~PerfContextProvider() override {}
-
- scoped_ptr<PerfGLES2Interface> context_gl_;
- TestContextSupport support_;
-};
-
-enum RasterWorkerPoolType {
- RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
- RASTER_WORKER_POOL_TYPE_ZERO_COPY,
- RASTER_WORKER_POOL_TYPE_ONE_COPY,
- RASTER_WORKER_POOL_TYPE_GPU,
- RASTER_WORKER_POOL_TYPE_BITMAP
-};
-
-static const int kTimeLimitMillis = 2000;
-static const int kWarmupRuns = 5;
-static const int kTimeCheckInterval = 10;
-
-class PerfImageDecodeTaskImpl : public ImageDecodeTask {
- public:
- PerfImageDecodeTaskImpl() {}
-
- // Overridden from Task:
- void RunOnWorkerThread() override {}
-
- // Overridden from RasterizerTask:
- void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
- void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
- void RunReplyOnOriginThread() override { Reset(); }
-
- void Reset() {
- did_run_ = false;
- did_complete_ = false;
- }
-
- protected:
- ~PerfImageDecodeTaskImpl() override {}
-
- private:
- DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl);
-};
-
-class PerfRasterTaskImpl : public RasterTask {
- public:
- PerfRasterTaskImpl(scoped_ptr<ScopedResource> resource,
- ImageDecodeTask::Vector* dependencies)
- : RasterTask(resource.get(), dependencies), resource_(resource.Pass()) {}
-
- // Overridden from Task:
- void RunOnWorkerThread() override {}
-
- // Overridden from RasterizerTask:
- void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
- raster_buffer_ = client->AcquireBufferForRaster(resource());
- }
- void CompleteOnOriginThread(RasterizerTaskClient* client) override {
- client->ReleaseBufferForRaster(raster_buffer_.Pass());
- }
- void RunReplyOnOriginThread() override { Reset(); }
-
- void Reset() {
- did_run_ = false;
- did_complete_ = false;
- }
-
- protected:
- ~PerfRasterTaskImpl() override {}
-
- private:
- scoped_ptr<ScopedResource> resource_;
- scoped_ptr<RasterBuffer> raster_buffer_;
-
- DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl);
-};
-
-class RasterWorkerPoolPerfTestBase {
- public:
- typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
-
- enum NamedTaskSet { ALL, REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW };
-
- RasterWorkerPoolPerfTestBase()
- : context_provider_(make_scoped_refptr(new PerfContextProvider)),
- task_runner_(new base::TestSimpleTaskRunner),
- task_graph_runner_(new TaskGraphRunner),
- timer_(kWarmupRuns,
- base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
- kTimeCheckInterval) {}
-
- void CreateImageDecodeTasks(unsigned num_image_decode_tasks,
- ImageDecodeTask::Vector* image_decode_tasks) {
- for (unsigned i = 0; i < num_image_decode_tasks; ++i)
- image_decode_tasks->push_back(new PerfImageDecodeTaskImpl);
- }
-
- void CreateRasterTasks(unsigned num_raster_tasks,
- const ImageDecodeTask::Vector& image_decode_tasks,
- RasterTaskVector* raster_tasks) {
- const gfx::Size size(1, 1);
-
- for (unsigned i = 0; i < num_raster_tasks; ++i) {
- scoped_ptr<ScopedResource> resource(
- ScopedResource::Create(resource_provider_.get()));
- resource->Allocate(
- size, ResourceProvider::TextureHintImmutable, RGBA_8888);
-
- ImageDecodeTask::Vector dependencies = image_decode_tasks;
- raster_tasks->push_back(
- new PerfRasterTaskImpl(resource.Pass(), &dependencies));
- }
- }
-
- void BuildRasterTaskQueue(RasterTaskQueue* queue,
- const RasterTaskVector& raster_tasks) {
- for (size_t i = 0u; i < raster_tasks.size(); ++i) {
- bool required_for_activation = (i % 2) == 0;
- TaskSetCollection task_set_collection;
- task_set_collection[ALL] = true;
- task_set_collection[REQUIRED_FOR_ACTIVATION] = required_for_activation;
- queue->items.push_back(
- RasterTaskQueue::Item(raster_tasks[i].get(), task_set_collection));
- }
- }
-
- protected:
- scoped_refptr<ContextProvider> context_provider_;
- FakeOutputSurfaceClient output_surface_client_;
- scoped_ptr<FakeOutputSurface> output_surface_;
- scoped_ptr<ResourceProvider> resource_provider_;
- scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
- scoped_ptr<TaskGraphRunner> task_graph_runner_;
- LapTimer timer_;
-};
-
-class RasterWorkerPoolPerfTest
- : public RasterWorkerPoolPerfTestBase,
- public testing::TestWithParam<RasterWorkerPoolType>,
- public RasterizerClient {
- public:
- // Overridden from testing::Test:
- void SetUp() override {
- switch (GetParam()) {
- case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
- Create3dOutputSurfaceAndResourceProvider();
- raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
- task_runner_.get(),
- task_graph_runner_.get(),
- context_provider_.get(),
- resource_provider_.get(),
- std::numeric_limits<size_t>::max());
- break;
- case RASTER_WORKER_POOL_TYPE_ZERO_COPY:
- Create3dOutputSurfaceAndResourceProvider();
- raster_worker_pool_ =
- ZeroCopyRasterWorkerPool::Create(task_runner_.get(),
- task_graph_runner_.get(),
- resource_provider_.get());
- break;
- case RASTER_WORKER_POOL_TYPE_ONE_COPY:
- Create3dOutputSurfaceAndResourceProvider();
- staging_resource_pool_ = ResourcePool::Create(
- resource_provider_.get(), GL_TEXTURE_2D, RGBA_8888);
- raster_worker_pool_ =
- OneCopyRasterWorkerPool::Create(task_runner_.get(),
- task_graph_runner_.get(),
- context_provider_.get(),
- resource_provider_.get(),
- staging_resource_pool_.get());
- break;
- case RASTER_WORKER_POOL_TYPE_GPU:
- Create3dOutputSurfaceAndResourceProvider();
- raster_worker_pool_ =
- GpuRasterWorkerPool::Create(task_runner_.get(),
- context_provider_.get(),
- resource_provider_.get(),
- false);
- break;
- case RASTER_WORKER_POOL_TYPE_BITMAP:
- CreateSoftwareOutputSurfaceAndResourceProvider();
- raster_worker_pool_ =
- BitmapRasterWorkerPool::Create(task_runner_.get(),
- task_graph_runner_.get(),
- resource_provider_.get());
- break;
- }
-
- DCHECK(raster_worker_pool_);
- raster_worker_pool_->AsRasterizer()->SetClient(this);
- }
- void TearDown() override {
- raster_worker_pool_->AsRasterizer()->Shutdown();
- raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
- }
-
- // Overriden from RasterizerClient:
- void DidFinishRunningTasks(TaskSet task_set) override {
- raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
- }
- TaskSetCollection TasksThatShouldBeForcedToComplete() const override {
- return TaskSetCollection();
- }
-
- void RunMessageLoopUntilAllTasksHaveCompleted() {
- task_graph_runner_->RunUntilIdle();
- task_runner_->RunUntilIdle();
- }
-
- void RunScheduleTasksTest(const std::string& test_name,
- unsigned num_raster_tasks,
- unsigned num_image_decode_tasks) {
- ImageDecodeTask::Vector image_decode_tasks;
- RasterTaskVector raster_tasks;
- CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
- CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
-
- // Avoid unnecessary heap allocations by reusing the same queue.
- RasterTaskQueue queue;
-
- timer_.Reset();
- do {
- queue.Reset();
- BuildRasterTaskQueue(&queue, raster_tasks);
- raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue);
- raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
- timer_.NextLap();
- } while (!timer_.HasTimeLimitExpired());
-
- RasterTaskQueue empty;
- raster_worker_pool_->AsRasterizer()->ScheduleTasks(&empty);
- RunMessageLoopUntilAllTasksHaveCompleted();
-
- perf_test::PrintResult("schedule_tasks",
- TestModifierString(),
- test_name,
- timer_.LapsPerSecond(),
- "runs/s",
- true);
- }
-
- void RunScheduleAlternateTasksTest(const std::string& test_name,
- unsigned num_raster_tasks,
- unsigned num_image_decode_tasks) {
- const size_t kNumVersions = 2;
- ImageDecodeTask::Vector image_decode_tasks[kNumVersions];
- RasterTaskVector raster_tasks[kNumVersions];
- for (size_t i = 0; i < kNumVersions; ++i) {
- CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
- CreateRasterTasks(
- num_raster_tasks, image_decode_tasks[i], &raster_tasks[i]);
- }
-
- // Avoid unnecessary heap allocations by reusing the same queue.
- RasterTaskQueue queue;
-
- size_t count = 0;
- timer_.Reset();
- do {
- queue.Reset();
- BuildRasterTaskQueue(&queue, raster_tasks[count % kNumVersions]);
- raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue);
- raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
- ++count;
- timer_.NextLap();
- } while (!timer_.HasTimeLimitExpired());
-
- RasterTaskQueue empty;
- raster_worker_pool_->AsRasterizer()->ScheduleTasks(&empty);
- RunMessageLoopUntilAllTasksHaveCompleted();
-
- perf_test::PrintResult("schedule_alternate_tasks",
- TestModifierString(),
- test_name,
- timer_.LapsPerSecond(),
- "runs/s",
- true);
- }
-
- void RunScheduleAndExecuteTasksTest(const std::string& test_name,
- unsigned num_raster_tasks,
- unsigned num_image_decode_tasks) {
- ImageDecodeTask::Vector image_decode_tasks;
- RasterTaskVector raster_tasks;
- CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
- CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
-
- // Avoid unnecessary heap allocations by reusing the same queue.
- RasterTaskQueue queue;
-
- timer_.Reset();
- do {
- queue.Reset();
- BuildRasterTaskQueue(&queue, raster_tasks);
- raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue);
- RunMessageLoopUntilAllTasksHaveCompleted();
- timer_.NextLap();
- } while (!timer_.HasTimeLimitExpired());
-
- RasterTaskQueue empty;
- raster_worker_pool_->AsRasterizer()->ScheduleTasks(&empty);
- RunMessageLoopUntilAllTasksHaveCompleted();
-
- perf_test::PrintResult("schedule_and_execute_tasks",
- TestModifierString(),
- test_name,
- timer_.LapsPerSecond(),
- "runs/s",
- true);
- }
-
- private:
- void Create3dOutputSurfaceAndResourceProvider() {
- output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
- CHECK(output_surface_->BindToClient(&output_surface_client_));
- resource_provider_ = ResourceProvider::Create(output_surface_.get(),
- NULL,
- &gpu_memory_buffer_manager_,
- NULL,
- 0,
- false,
- 1).Pass();
- }
-
- void CreateSoftwareOutputSurfaceAndResourceProvider() {
- output_surface_ = FakeOutputSurface::CreateSoftware(
- make_scoped_ptr(new SoftwareOutputDevice));
- CHECK(output_surface_->BindToClient(&output_surface_client_));
- resource_provider_ = ResourceProvider::Create(output_surface_.get(),
- &shared_bitmap_manager_,
- NULL,
- NULL,
- 0,
- false,
- 1).Pass();
- }
-
- std::string TestModifierString() const {
- switch (GetParam()) {
- case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
- return std::string("_pixel_raster_worker_pool");
- case RASTER_WORKER_POOL_TYPE_ZERO_COPY:
- return std::string("_zero_copy_raster_worker_pool");
- case RASTER_WORKER_POOL_TYPE_ONE_COPY:
- return std::string("_one_copy_raster_worker_pool");
- case RASTER_WORKER_POOL_TYPE_GPU:
- return std::string("_gpu_raster_worker_pool");
- case RASTER_WORKER_POOL_TYPE_BITMAP:
- return std::string("_bitmap_raster_worker_pool");
- }
- NOTREACHED();
- return std::string();
- }
-
- scoped_ptr<ResourcePool> staging_resource_pool_;
- scoped_ptr<RasterWorkerPool> raster_worker_pool_;
- TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
- TestSharedBitmapManager shared_bitmap_manager_;
-};
-
-TEST_P(RasterWorkerPoolPerfTest, ScheduleTasks) {
- RunScheduleTasksTest("1_0", 1, 0);
- RunScheduleTasksTest("32_0", 32, 0);
- RunScheduleTasksTest("1_1", 1, 1);
- RunScheduleTasksTest("32_1", 32, 1);
- RunScheduleTasksTest("1_4", 1, 4);
- RunScheduleTasksTest("32_4", 32, 4);
-}
-
-TEST_P(RasterWorkerPoolPerfTest, ScheduleAlternateTasks) {
- RunScheduleAlternateTasksTest("1_0", 1, 0);
- RunScheduleAlternateTasksTest("32_0", 32, 0);
- RunScheduleAlternateTasksTest("1_1", 1, 1);
- RunScheduleAlternateTasksTest("32_1", 32, 1);
- RunScheduleAlternateTasksTest("1_4", 1, 4);
- RunScheduleAlternateTasksTest("32_4", 32, 4);
-}
-
-TEST_P(RasterWorkerPoolPerfTest, ScheduleAndExecuteTasks) {
- RunScheduleAndExecuteTasksTest("1_0", 1, 0);
- RunScheduleAndExecuteTasksTest("32_0", 32, 0);
- RunScheduleAndExecuteTasksTest("1_1", 1, 1);
- RunScheduleAndExecuteTasksTest("32_1", 32, 1);
- RunScheduleAndExecuteTasksTest("1_4", 1, 4);
- RunScheduleAndExecuteTasksTest("32_4", 32, 4);
-}
-
-INSTANTIATE_TEST_CASE_P(RasterWorkerPoolPerfTests,
- RasterWorkerPoolPerfTest,
- ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
- RASTER_WORKER_POOL_TYPE_ZERO_COPY,
- RASTER_WORKER_POOL_TYPE_ONE_COPY,
- RASTER_WORKER_POOL_TYPE_GPU,
- RASTER_WORKER_POOL_TYPE_BITMAP));
-
-class RasterWorkerPoolCommonPerfTest : public RasterWorkerPoolPerfTestBase,
- public testing::Test {
- public:
- // Overridden from testing::Test:
- void SetUp() override {
- output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
- CHECK(output_surface_->BindToClient(&output_surface_client_));
- resource_provider_ =
- ResourceProvider::Create(
- output_surface_.get(), NULL, NULL, NULL, 0, false, 1).Pass();
- }
-
- void RunBuildRasterTaskQueueTest(const std::string& test_name,
- unsigned num_raster_tasks,
- unsigned num_image_decode_tasks) {
- ImageDecodeTask::Vector image_decode_tasks;
- RasterTaskVector raster_tasks;
- CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
- CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
-
- // Avoid unnecessary heap allocations by reusing the same queue.
- RasterTaskQueue queue;
-
- timer_.Reset();
- do {
- queue.Reset();
- BuildRasterTaskQueue(&queue, raster_tasks);
- timer_.NextLap();
- } while (!timer_.HasTimeLimitExpired());
-
- perf_test::PrintResult("build_raster_task_queue",
- "",
- test_name,
- timer_.LapsPerSecond(),
- "runs/s",
- true);
- }
-};
-
-TEST_F(RasterWorkerPoolCommonPerfTest, BuildRasterTaskQueue) {
- RunBuildRasterTaskQueueTest("1_0", 1, 0);
- RunBuildRasterTaskQueueTest("32_0", 32, 0);
- RunBuildRasterTaskQueueTest("1_1", 1, 1);
- RunBuildRasterTaskQueueTest("32_1", 32, 1);
- RunBuildRasterTaskQueueTest("1_4", 1, 4);
- RunBuildRasterTaskQueueTest("32_4", 32, 4);
-}
-
-} // namespace
-} // namespace cc
diff --git a/cc/resources/rasterizer.cc b/cc/resources/rasterizer.cc
deleted file mode 100644
index 4ce8987..0000000
--- a/cc/resources/rasterizer.cc
+++ /dev/null
@@ -1,80 +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 "cc/resources/rasterizer.h"
-
-#include <algorithm>
-
-namespace cc {
-
-RasterizerTask::RasterizerTask() : did_schedule_(false), did_complete_(false) {}
-
-RasterizerTask::~RasterizerTask() {
- // Debugging CHECKs to help track down a use-after-free.
- CHECK(!did_schedule_);
- CHECK(!did_run_ || did_complete_);
-}
-
-ImageDecodeTask* RasterizerTask::AsImageDecodeTask() { return NULL; }
-
-RasterTask* RasterizerTask::AsRasterTask() { return NULL; }
-
-void RasterizerTask::WillSchedule() { DCHECK(!did_schedule_); }
-
-void RasterizerTask::DidSchedule() {
- did_schedule_ = true;
- did_complete_ = false;
-}
-
-bool RasterizerTask::HasBeenScheduled() const { return did_schedule_; }
-
-void RasterizerTask::WillComplete() { DCHECK(!did_complete_); }
-
-void RasterizerTask::DidComplete() {
- DCHECK(did_schedule_);
- DCHECK(!did_complete_);
- did_schedule_ = false;
- did_complete_ = true;
-}
-
-bool RasterizerTask::HasCompleted() const { return did_complete_; }
-
-ImageDecodeTask::ImageDecodeTask() {}
-
-ImageDecodeTask::~ImageDecodeTask() {}
-
-ImageDecodeTask* ImageDecodeTask::AsImageDecodeTask() { return this; }
-
-RasterTask::RasterTask(const Resource* resource,
- ImageDecodeTask::Vector* dependencies)
- : resource_(resource) {
- dependencies_.swap(*dependencies);
-}
-
-RasterTask::~RasterTask() {}
-
-RasterTask* RasterTask::AsRasterTask() { return this; }
-
-RasterTaskQueue::Item::Item(RasterTask* task,
- const TaskSetCollection& task_sets)
- : task(task), task_sets(task_sets) {
- DCHECK(task_sets.any());
-}
-
-RasterTaskQueue::Item::~Item() {}
-
-RasterTaskQueue::RasterTaskQueue() {
-}
-
-RasterTaskQueue::~RasterTaskQueue() {}
-
-void RasterTaskQueue::Swap(RasterTaskQueue* other) {
- items.swap(other->items);
-}
-
-void RasterTaskQueue::Reset() {
- items.clear();
-}
-
-} // namespace cc
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 66f95da..7ab1fbf 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -18,8 +18,8 @@
#include "cc/debug/traced_value.h"
#include "cc/layers/picture_layer_impl.h"
#include "cc/resources/raster_buffer.h"
-#include "cc/resources/rasterizer.h"
#include "cc/resources/tile.h"
+#include "cc/resources/tile_task_runner.h"
#include "ui/gfx/geometry/rect_conversions.h"
namespace cc {
@@ -73,12 +73,12 @@
Raster(raster_source_.get());
}
- // Overridden from RasterizerTask:
- void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
+ // Overridden from TileTask:
+ void ScheduleOnOriginThread(TileTaskClient* client) override {
DCHECK(!raster_buffer_);
raster_buffer_ = client->AcquireBufferForRaster(resource());
}
- void CompleteOnOriginThread(RasterizerTaskClient* client) override {
+ void CompleteOnOriginThread(TileTaskClient* client) override {
client->ReleaseBufferForRaster(raster_buffer_.Pass());
}
void RunReplyOnOriginThread() override {
@@ -158,9 +158,9 @@
pixel_ref_->unlockPixels();
}
- // Overridden from RasterizerTask:
- void ScheduleOnOriginThread(RasterizerTaskClient* client) override {}
- void CompleteOnOriginThread(RasterizerTaskClient* client) override {}
+ // Overridden from TileTask:
+ void ScheduleOnOriginThread(TileTaskClient* client) override {}
+ void CompleteOnOriginThread(TileTaskClient* client) override {}
void RunReplyOnOriginThread() override { reply_.Run(!HasFinishedRunning()); }
protected:
@@ -208,28 +208,25 @@
TileManagerClient* client,
base::SequencedTaskRunner* task_runner,
ResourcePool* resource_pool,
- Rasterizer* rasterizer,
+ TileTaskRunner* tile_task_runner,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
size_t scheduled_raster_task_limit) {
- return make_scoped_ptr(new TileManager(client,
- task_runner,
- resource_pool,
- rasterizer,
- rendering_stats_instrumentation,
- scheduled_raster_task_limit));
+ return make_scoped_ptr(new TileManager(
+ client, task_runner, resource_pool, tile_task_runner,
+ rendering_stats_instrumentation, scheduled_raster_task_limit));
}
TileManager::TileManager(
TileManagerClient* client,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
ResourcePool* resource_pool,
- Rasterizer* rasterizer,
+ TileTaskRunner* tile_task_runner,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
size_t scheduled_raster_task_limit)
: client_(client),
task_runner_(task_runner),
resource_pool_(resource_pool),
- rasterizer_(rasterizer),
+ tile_task_runner_(tile_task_runner),
scheduled_raster_task_limit_(scheduled_raster_task_limit),
all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
rendering_stats_instrumentation_(rendering_stats_instrumentation),
@@ -244,7 +241,7 @@
base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
did_notify_ready_to_activate_(false),
did_notify_ready_to_draw_(false) {
- rasterizer_->SetClient(this);
+ tile_task_runner_->SetClient(this);
}
TileManager::~TileManager() {
@@ -252,14 +249,14 @@
// our memory usage to drop to zero.
global_state_ = GlobalStateThatImpactsTilePriority();
- RasterTaskQueue empty;
- rasterizer_->ScheduleTasks(&empty);
+ TileTaskQueue empty;
+ tile_task_runner_->ScheduleTasks(&empty);
orphan_raster_tasks_.clear();
// This should finish all pending tasks and release any uninitialized
// resources.
- rasterizer_->Shutdown();
- rasterizer_->CheckForCompletedTasks();
+ tile_task_runner_->Shutdown();
+ tile_task_runner_->CheckForCompletedTasks();
FreeResourcesForReleasedTiles();
CleanUpReleasedTiles();
@@ -312,8 +309,8 @@
}
}
-void TileManager::DidFinishRunningTasks(TaskSet task_set) {
- TRACE_EVENT1("cc", "TileManager::DidFinishRunningTasks", "task_set",
+void TileManager::DidFinishRunningTileTasks(TaskSet task_set) {
+ TRACE_EVENT1("cc", "TileManager::DidFinishRunningTileTasks", "task_set",
TaskSetName(task_set));
switch (task_set) {
@@ -328,7 +325,7 @@
!memory_usage_above_limit)
return;
- rasterizer_->CheckForCompletedTasks();
+ tile_task_runner_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
TileVector tiles_that_need_to_be_rasterized;
@@ -400,15 +397,16 @@
NOTREACHED();
}
-void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
- TRACE_EVENT0("cc", "TileManager::ManageTiles");
+void TileManager::PrepareTiles(
+ const GlobalStateThatImpactsTilePriority& state) {
+ TRACE_EVENT0("cc", "TileManager::PrepareTiles");
global_state_ = state;
// We need to call CheckForCompletedTasks() once in-between each call
// to ScheduleTasks() to prevent canceled tasks from being scheduled.
if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
- rasterizer_->CheckForCompletedTasks();
+ tile_task_runner_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
}
@@ -418,16 +416,13 @@
TileVector tiles_that_need_to_be_rasterized;
AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
- // Schedule rasterizer tasks.
+ // Schedule tile tasks.
ScheduleTasks(tiles_that_need_to_be_rasterized);
did_notify_ready_to_activate_ = false;
did_notify_ready_to_draw_ = false;
- TRACE_EVENT_INSTANT1("cc",
- "DidManage",
- TRACE_EVENT_SCOPE_THREAD,
- "state",
+ TRACE_EVENT_INSTANT1("cc", "DidPrepare", TRACE_EVENT_SCOPE_THREAD, "state",
BasicStateAsValue());
TRACE_COUNTER_ID1("cc",
@@ -440,7 +435,7 @@
void TileManager::UpdateVisibleTiles() {
TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
- rasterizer_->CheckForCompletedTasks();
+ tile_task_runner_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
TRACE_EVENT_INSTANT1(
@@ -698,7 +693,7 @@
task_sets.set(REQUIRED_FOR_DRAW);
task_sets.set(ALL);
raster_queue_.items.push_back(
- RasterTaskQueue::Item(mts.raster_task.get(), task_sets));
+ TileTaskQueue::Item(mts.raster_task.get(), task_sets));
}
// We must reduce the amount of unused resoruces before calling
@@ -708,7 +703,7 @@
// Schedule running of |raster_queue_|. This replaces any previously
// scheduled tasks and effectively cancels all tasks not present
// in |raster_queue_|.
- rasterizer_->ScheduleTasks(&raster_queue_);
+ tile_task_runner_->ScheduleTasks(&raster_queue_);
// It's now safe to clean up orphan tasks as raster worker pool is not
// allowed to keep around unreferenced raster tasks after ScheduleTasks() has
@@ -853,9 +848,10 @@
return tile;
}
-void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
- rasterizer_ = rasterizer;
- rasterizer_->SetClient(this);
+void TileManager::SetTileTaskRunnerForTesting(
+ TileTaskRunner* tile_task_runner) {
+ tile_task_runner_ = tile_task_runner;
+ tile_task_runner_->SetClient(this);
}
bool TileManager::IsReadyToActivate() const {
@@ -884,7 +880,7 @@
void TileManager::CheckIfReadyToActivate() {
TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
- rasterizer_->CheckForCompletedTasks();
+ tile_task_runner_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
if (did_notify_ready_to_activate_)
@@ -899,7 +895,7 @@
void TileManager::CheckIfReadyToDraw() {
TRACE_EVENT0("cc", "TileManager::CheckIfReadyToDraw");
- rasterizer_->CheckForCompletedTasks();
+ tile_task_runner_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
if (did_notify_ready_to_draw_)
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 8d19520..638fecb 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -22,9 +22,9 @@
#include "cc/resources/memory_history.h"
#include "cc/resources/raster_source.h"
#include "cc/resources/raster_tile_priority_queue.h"
-#include "cc/resources/rasterizer.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/tile.h"
+#include "cc/resources/tile_task_runner.h"
namespace base {
namespace debug {
@@ -86,7 +86,7 @@
// should no longer have any memory assigned to them. Tile objects are "owned"
// by layers; they automatically register with the manager when they are
// created, and unregister from the manager when they are deleted.
-class CC_EXPORT TileManager : public RasterizerClient,
+class CC_EXPORT TileManager : public TileTaskRunnerClient,
public RefCountedManager<Tile> {
public:
enum NamedTaskSet {
@@ -101,12 +101,17 @@
TileManagerClient* client,
base::SequencedTaskRunner* task_runner,
ResourcePool* resource_pool,
- Rasterizer* rasterizer,
+ TileTaskRunner* tile_task_runner,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
size_t scheduled_raster_task_limit);
~TileManager() override;
- void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
+ // Assigns tile memory and schedules work to prepare tiles for drawing.
+ // - Runs client_->NotifyReadyToActivate() when all tiles required for
+ // activation are prepared, or failed to prepare due to OOM.
+ // - Runs client_->NotifyReadyToDraw() when all tiles required draw are
+ // prepared, or failed to prepare due to OOM.
+ void PrepareTiles(const GlobalStateThatImpactsTilePriority& state);
void UpdateVisibleTiles();
@@ -146,7 +151,7 @@
global_state_ = state;
}
- void SetRasterizerForTesting(Rasterizer* rasterizer);
+ void SetTileTaskRunnerForTesting(TileTaskRunner* tile_task_runner);
void FreeResourcesAndCleanUpReleasedTilesForTesting() {
FreeResourcesForReleasedTiles();
@@ -170,7 +175,7 @@
TileManager(TileManagerClient* client,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
ResourcePool* resource_pool,
- Rasterizer* rasterizer,
+ TileTaskRunner* tile_task_runner,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
size_t scheduled_raster_task_limit);
@@ -181,8 +186,8 @@
friend class Tile;
void Release(Tile* tile) override;
- // Overriden from RasterizerClient:
- void DidFinishRunningTasks(TaskSet task_set) override;
+ // Overriden from TileTaskRunnerClient:
+ void DidFinishRunningTileTasks(TaskSet task_set) override;
TaskSetCollection TasksThatShouldBeForcedToComplete() const override;
typedef std::vector<Tile*> TileVector;
@@ -245,7 +250,7 @@
TileManagerClient* client_;
scoped_refptr<base::SequencedTaskRunner> task_runner_;
ResourcePool* resource_pool_;
- Rasterizer* rasterizer_;
+ TileTaskRunner* tile_task_runner_;
GlobalStateThatImpactsTilePriority global_state_;
size_t scheduled_raster_task_limit_;
@@ -275,7 +280,7 @@
ResourceFormat resource_format_;
// Queue used when scheduling raster tasks.
- RasterTaskQueue raster_queue_;
+ TileTaskQueue raster_queue_;
std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index 2204ab8..fe3338a 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -34,16 +34,14 @@
static const int kWarmupRuns = 5;
static const int kTimeCheckInterval = 10;
-class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
+class FakeTileTaskRunnerImpl : public TileTaskRunner, public TileTaskClient {
public:
- // Overridden from Rasterizer:
- void SetClient(RasterizerClient* client) override {}
+ // Overridden from TileTaskRunner:
+ void SetClient(TileTaskRunnerClient* client) override {}
void Shutdown() override {}
- void ScheduleTasks(RasterTaskQueue* queue) override {
- for (RasterTaskQueue::Item::Vector::const_iterator it =
- queue->items.begin();
- it != queue->items.end();
- ++it) {
+ void ScheduleTasks(TileTaskQueue* queue) override {
+ for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+ it != queue->items.end(); ++it) {
RasterTask* task = it->task;
task->WillSchedule();
@@ -68,7 +66,7 @@
completed_tasks_.clear();
}
- // Overridden from RasterizerTaskClient:
+ // Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
const Resource* resource) override {
return nullptr;
@@ -78,7 +76,7 @@
private:
RasterTask::Vector completed_tasks_;
};
-base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
+base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner =
LAZY_INSTANCE_INITIALIZER;
class TileManagerPerfTest : public testing::Test {
@@ -118,7 +116,8 @@
virtual void InitializeRenderer() {
host_impl_.InitializeRenderer(FakeOutputSurface::Create3d().Pass());
- tile_manager()->SetRasterizerForTesting(g_fake_rasterizer.Pointer());
+ tile_manager()->SetTileTaskRunnerForTesting(
+ g_fake_tile_task_runner.Pointer());
}
void SetupDefaultTrees(const gfx::Size& layer_bounds) {
@@ -392,9 +391,9 @@
return state;
}
- void RunManageTilesTest(const std::string& test_name,
- int layer_count,
- int approximate_tile_count_per_layer) {
+ void RunPrepareTilesTest(const std::string& test_name,
+ int layer_count,
+ int approximate_tile_count_per_layer) {
std::vector<LayerImpl*> layers =
CreateLayers(layer_count, approximate_tile_count_per_layer);
timer_.Reset();
@@ -408,14 +407,14 @@
}
GlobalStateThatImpactsTilePriority global_state(GlobalStateForTest());
- tile_manager()->ManageTiles(global_state);
+ tile_manager()->PrepareTiles(global_state);
tile_manager()->UpdateVisibleTiles();
timer_.NextLap();
host_impl_.ResetCurrentBeginFrameArgsForNextFrame();
} while (!timer_.HasTimeLimitExpired());
- perf_test::PrintResult(
- "manage_tiles", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
+ perf_test::PrintResult("prepare_tiles", "", test_name,
+ timer_.LapsPerSecond(), "runs/s", true);
}
TileManager* tile_manager() { return host_impl_.tile_manager(); }
@@ -439,16 +438,16 @@
const gfx::Size TileManagerPerfTest::kDefaultTileSize(100, 100);
-TEST_F(TileManagerPerfTest, ManageTiles) {
- RunManageTilesTest("2_100", 2, 100);
- RunManageTilesTest("2_500", 2, 500);
- RunManageTilesTest("2_1000", 2, 1000);
- RunManageTilesTest("10_100", 10, 100);
- RunManageTilesTest("10_500", 10, 500);
- RunManageTilesTest("10_1000", 10, 1000);
- RunManageTilesTest("50_100", 100, 100);
- RunManageTilesTest("50_500", 100, 500);
- RunManageTilesTest("50_1000", 100, 1000);
+TEST_F(TileManagerPerfTest, PrepareTiles) {
+ RunPrepareTilesTest("2_100", 2, 100);
+ RunPrepareTilesTest("2_500", 2, 500);
+ RunPrepareTilesTest("2_1000", 2, 1000);
+ RunPrepareTilesTest("10_100", 10, 100);
+ RunPrepareTilesTest("10_500", 10, 500);
+ RunPrepareTilesTest("10_1000", 10, 1000);
+ RunPrepareTilesTest("50_100", 100, 100);
+ RunPrepareTilesTest("50_500", 100, 500);
+ RunPrepareTilesTest("50_1000", 100, 1000);
}
TEST_F(TileManagerPerfTest, RasterTileQueueConstruct) {
diff --git a/cc/resources/tile_task_runner.cc b/cc/resources/tile_task_runner.cc
new file mode 100644
index 0000000..8775d32
--- /dev/null
+++ b/cc/resources/tile_task_runner.cc
@@ -0,0 +1,101 @@
+// 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 "cc/resources/tile_task_runner.h"
+
+#include <algorithm>
+
+namespace cc {
+
+TileTask::TileTask() : did_schedule_(false), did_complete_(false) {
+}
+
+TileTask::~TileTask() {
+ // Debugging CHECKs to help track down a use-after-free.
+ CHECK(!did_schedule_);
+ CHECK(!did_run_ || did_complete_);
+}
+
+ImageDecodeTask* TileTask::AsImageDecodeTask() {
+ return NULL;
+}
+
+RasterTask* TileTask::AsRasterTask() {
+ return NULL;
+}
+
+void TileTask::WillSchedule() {
+ DCHECK(!did_schedule_);
+}
+
+void TileTask::DidSchedule() {
+ did_schedule_ = true;
+ did_complete_ = false;
+}
+
+bool TileTask::HasBeenScheduled() const {
+ return did_schedule_;
+}
+
+void TileTask::WillComplete() {
+ DCHECK(!did_complete_);
+}
+
+void TileTask::DidComplete() {
+ DCHECK(did_schedule_);
+ DCHECK(!did_complete_);
+ did_schedule_ = false;
+ did_complete_ = true;
+}
+
+bool TileTask::HasCompleted() const {
+ return did_complete_;
+}
+
+ImageDecodeTask::ImageDecodeTask() {
+}
+
+ImageDecodeTask::~ImageDecodeTask() {
+}
+
+ImageDecodeTask* ImageDecodeTask::AsImageDecodeTask() {
+ return this;
+}
+
+RasterTask::RasterTask(const Resource* resource,
+ ImageDecodeTask::Vector* dependencies)
+ : resource_(resource) {
+ dependencies_.swap(*dependencies);
+}
+
+RasterTask::~RasterTask() {
+}
+
+RasterTask* RasterTask::AsRasterTask() {
+ return this;
+}
+
+TileTaskQueue::Item::Item(RasterTask* task, const TaskSetCollection& task_sets)
+ : task(task), task_sets(task_sets) {
+ DCHECK(task_sets.any());
+}
+
+TileTaskQueue::Item::~Item() {
+}
+
+TileTaskQueue::TileTaskQueue() {
+}
+
+TileTaskQueue::~TileTaskQueue() {
+}
+
+void TileTaskQueue::Swap(TileTaskQueue* other) {
+ items.swap(other->items);
+}
+
+void TileTaskQueue::Reset() {
+ items.clear();
+}
+
+} // namespace cc
diff --git a/cc/resources/rasterizer.h b/cc/resources/tile_task_runner.h
similarity index 70%
rename from cc/resources/rasterizer.h
rename to cc/resources/tile_task_runner.h
index db84c22..1de0f4f 100644
--- a/cc/resources/rasterizer.h
+++ b/cc/resources/tile_task_runner.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_RESOURCES_RASTERIZER_H_
-#define CC_RESOURCES_RASTERIZER_H_
+#ifndef CC_RESOURCES_TILE_TASK_RUNNER_H_
+#define CC_RESOURCES_TILE_TASK_RUNNER_H_
#include <bitset>
#include <vector>
@@ -18,22 +18,22 @@
class Resource;
class RasterBuffer;
-class CC_EXPORT RasterizerTaskClient {
+class CC_EXPORT TileTaskClient {
public:
virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
const Resource* resource) = 0;
virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) = 0;
protected:
- virtual ~RasterizerTaskClient() {}
+ virtual ~TileTaskClient() {}
};
-class CC_EXPORT RasterizerTask : public Task {
+class CC_EXPORT TileTask : public Task {
public:
- typedef std::vector<scoped_refptr<RasterizerTask>> Vector;
+ typedef std::vector<scoped_refptr<TileTask>> Vector;
- virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) = 0;
- virtual void CompleteOnOriginThread(RasterizerTaskClient* client) = 0;
+ virtual void ScheduleOnOriginThread(TileTaskClient* client) = 0;
+ virtual void CompleteOnOriginThread(TileTaskClient* client) = 0;
virtual void RunReplyOnOriginThread() = 0;
// Type-checking downcast routines.
@@ -49,18 +49,18 @@
bool HasCompleted() const;
protected:
- RasterizerTask();
- ~RasterizerTask() override;
+ TileTask();
+ ~TileTask() override;
bool did_schedule_;
bool did_complete_;
};
-class CC_EXPORT ImageDecodeTask : public RasterizerTask {
+class CC_EXPORT ImageDecodeTask : public TileTask {
public:
typedef std::vector<scoped_refptr<ImageDecodeTask>> Vector;
- // Overridden from RasterizerTask:
+ // Overridden from TileTask:
ImageDecodeTask* AsImageDecodeTask() override;
protected:
@@ -68,11 +68,11 @@
~ImageDecodeTask() override;
};
-class CC_EXPORT RasterTask : public RasterizerTask {
+class CC_EXPORT RasterTask : public TileTask {
public:
typedef std::vector<scoped_refptr<RasterTask>> Vector;
- // Overridden from RasterizerTask:
+ // Overridden from TileTask:
RasterTask* AsRasterTask() override;
const Resource* resource() const { return resource_; }
@@ -95,16 +95,16 @@
typedef size_t TaskSet;
typedef std::bitset<kNumberOfTaskSets> TaskSetCollection;
-class CC_EXPORT RasterizerClient {
+class CC_EXPORT TileTaskRunnerClient {
public:
- virtual void DidFinishRunningTasks(TaskSet task_set) = 0;
+ virtual void DidFinishRunningTileTasks(TaskSet task_set) = 0;
virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const = 0;
protected:
- virtual ~RasterizerClient() {}
+ virtual ~TileTaskRunnerClient() {}
};
-struct CC_EXPORT RasterTaskQueue {
+struct CC_EXPORT TileTaskQueue {
struct CC_EXPORT Item {
class TaskComparator {
public:
@@ -125,44 +125,45 @@
TaskSetCollection task_sets;
};
- RasterTaskQueue();
- ~RasterTaskQueue();
+ TileTaskQueue();
+ ~TileTaskQueue();
- void Swap(RasterTaskQueue* other);
+ void Swap(TileTaskQueue* other);
void Reset();
Item::Vector items;
};
-// This interface can be used to schedule and run raster tasks. The client will
+// This interface can be used to schedule and run tile tasks. The client will
// be notified asynchronously when the set of tasks marked as "required for
-// activation" have finished running and when all scheduled tasks have finished
-// running. The client can call CheckForCompletedTasks() at any time to dispatch
+// activation" have finished running, when tasks marked "required for draw"
+// have finished running, and when all scheduled tasks have finished running.
+// The client can call CheckForCompletedTasks() at any time to dispatch
// pending completion callbacks for all tasks that have finished running.
-class CC_EXPORT Rasterizer {
+class CC_EXPORT TileTaskRunner {
public:
// Set the client instance to be notified when finished running tasks.
- virtual void SetClient(RasterizerClient* client) = 0;
+ virtual void SetClient(TileTaskRunnerClient* client) = 0;
// Tells the worker pool to shutdown after canceling all previously scheduled
// tasks. Reply callbacks are still guaranteed to run when
// CheckForCompletedTasks() is called.
virtual void Shutdown() = 0;
- // Schedule running of raster tasks in |queue| and all dependencies.
+ // Schedule running of tile tasks in |queue| and all dependencies.
// Previously scheduled tasks that are not in |queue| will be canceled unless
// already running. Once scheduled, reply callbacks are guaranteed to run for
// all tasks even if they later get canceled by another call to
// ScheduleTasks().
- virtual void ScheduleTasks(RasterTaskQueue* queue) = 0;
+ virtual void ScheduleTasks(TileTaskQueue* queue) = 0;
// Check for completed tasks and dispatch reply callbacks.
virtual void CheckForCompletedTasks() = 0;
protected:
- virtual ~Rasterizer() {}
+ virtual ~TileTaskRunner() {}
};
} // namespace cc
-#endif // CC_RESOURCES_RASTERIZER_H_
+#endif // CC_RESOURCES_TILE_TASK_RUNNER_H_
diff --git a/cc/resources/tile_task_worker_pool.cc b/cc/resources/tile_task_worker_pool.cc
new file mode 100644
index 0000000..1c0d6b9
--- /dev/null
+++ b/cc/resources/tile_task_worker_pool.cc
@@ -0,0 +1,263 @@
+// 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 "cc/resources/tile_task_worker_pool.h"
+
+#include <algorithm>
+
+#include "base/debug/trace_event.h"
+#include "base/lazy_instance.h"
+#include "base/strings/stringprintf.h"
+#include "base/threading/simple_thread.h"
+#include "cc/base/scoped_ptr_deque.h"
+#include "cc/resources/raster_source.h"
+#include "skia/ext/refptr.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkSurface.h"
+
+namespace cc {
+namespace {
+
+class TileTaskGraphRunner : public TaskGraphRunner,
+ public base::DelegateSimpleThread::Delegate {
+ public:
+ TileTaskGraphRunner() {
+ size_t num_threads = TileTaskWorkerPool::GetNumWorkerThreads();
+ while (workers_.size() < num_threads) {
+ scoped_ptr<base::DelegateSimpleThread> worker =
+ make_scoped_ptr(new base::DelegateSimpleThread(
+ this, base::StringPrintf(
+ "CompositorTileWorker%u",
+ static_cast<unsigned>(workers_.size() + 1)).c_str()));
+ worker->Start();
+#if defined(OS_ANDROID) || defined(OS_LINUX)
+ worker->SetThreadPriority(base::kThreadPriority_Background);
+#endif
+ workers_.push_back(worker.Pass());
+ }
+ }
+
+ ~TileTaskGraphRunner() override { NOTREACHED(); }
+
+ private:
+ // Overridden from base::DelegateSimpleThread::Delegate:
+ void Run() override { TaskGraphRunner::Run(); }
+
+ ScopedPtrDeque<base::DelegateSimpleThread> workers_;
+};
+
+base::LazyInstance<TileTaskGraphRunner>::Leaky g_task_graph_runner =
+ LAZY_INSTANCE_INITIALIZER;
+
+const int kDefaultNumWorkerThreads = 1;
+
+int g_num_worker_threads = 0;
+
+class TaskSetFinishedTaskImpl : public TileTask {
+ public:
+ explicit TaskSetFinishedTaskImpl(
+ base::SequencedTaskRunner* task_runner,
+ const base::Closure& on_task_set_finished_callback)
+ : task_runner_(task_runner),
+ on_task_set_finished_callback_(on_task_set_finished_callback) {}
+
+ // Overridden from Task:
+ void RunOnWorkerThread() override {
+ TRACE_EVENT0("cc", "TaskSetFinishedTaskImpl::RunOnWorkerThread");
+ TaskSetFinished();
+ }
+
+ // Overridden from TileTask:
+ void ScheduleOnOriginThread(TileTaskClient* client) override {}
+ void CompleteOnOriginThread(TileTaskClient* client) override {}
+ void RunReplyOnOriginThread() override {}
+
+ protected:
+ ~TaskSetFinishedTaskImpl() override {}
+
+ void TaskSetFinished() {
+ task_runner_->PostTask(FROM_HERE, on_task_set_finished_callback_);
+ }
+
+ private:
+ scoped_refptr<base::SequencedTaskRunner> task_runner_;
+ const base::Closure on_task_set_finished_callback_;
+
+ DISALLOW_COPY_AND_ASSIGN(TaskSetFinishedTaskImpl);
+};
+
+} // namespace
+
+// This allows a micro benchmark system to run tasks with highest priority,
+// since it should finish as quickly as possible.
+unsigned TileTaskWorkerPool::kBenchmarkTaskPriority = 0u;
+// Task priorities that make sure task set finished tasks run before any
+// other remaining tasks.
+unsigned TileTaskWorkerPool::kTaskSetFinishedTaskPriority = 1u;
+unsigned TileTaskWorkerPool::kTileTaskPriorityBase = 2u;
+
+TileTaskWorkerPool::TileTaskWorkerPool() {
+}
+
+TileTaskWorkerPool::~TileTaskWorkerPool() {
+}
+
+// static
+void TileTaskWorkerPool::SetNumWorkerThreads(int num_threads) {
+ DCHECK_LT(0, num_threads);
+ DCHECK_EQ(0, g_num_worker_threads);
+
+ g_num_worker_threads = num_threads;
+}
+
+// static
+int TileTaskWorkerPool::GetNumWorkerThreads() {
+ if (!g_num_worker_threads)
+ g_num_worker_threads = kDefaultNumWorkerThreads;
+
+ return g_num_worker_threads;
+}
+
+// static
+TaskGraphRunner* TileTaskWorkerPool::GetTaskGraphRunner() {
+ return g_task_graph_runner.Pointer();
+}
+
+// static
+scoped_refptr<TileTask> TileTaskWorkerPool::CreateTaskSetFinishedTask(
+ base::SequencedTaskRunner* task_runner,
+ const base::Closure& on_task_set_finished_callback) {
+ return make_scoped_refptr(
+ new TaskSetFinishedTaskImpl(task_runner, on_task_set_finished_callback));
+}
+
+// static
+void TileTaskWorkerPool::ScheduleTasksOnOriginThread(TileTaskClient* client,
+ TaskGraph* graph) {
+ TRACE_EVENT0("cc", "TileTaskWorkerPool::ScheduleTasksOnOriginThread");
+
+ for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
+ it != graph->nodes.end(); ++it) {
+ TaskGraph::Node& node = *it;
+ TileTask* task = static_cast<TileTask*>(node.task);
+
+ if (!task->HasBeenScheduled()) {
+ task->WillSchedule();
+ task->ScheduleOnOriginThread(client);
+ task->DidSchedule();
+ }
+ }
+}
+
+// static
+void TileTaskWorkerPool::InsertNodeForTask(TaskGraph* graph,
+ TileTask* task,
+ unsigned priority,
+ size_t dependencies) {
+ DCHECK(std::find_if(graph->nodes.begin(), graph->nodes.end(),
+ TaskGraph::Node::TaskComparator(task)) ==
+ graph->nodes.end());
+ graph->nodes.push_back(TaskGraph::Node(task, priority, dependencies));
+}
+
+// static
+void TileTaskWorkerPool::InsertNodesForRasterTask(
+ TaskGraph* graph,
+ RasterTask* raster_task,
+ const ImageDecodeTask::Vector& decode_tasks,
+ unsigned priority) {
+ size_t dependencies = 0u;
+
+ // Insert image decode tasks.
+ for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
+ it != decode_tasks.end(); ++it) {
+ ImageDecodeTask* decode_task = it->get();
+
+ // Skip if already decoded.
+ if (decode_task->HasCompleted())
+ continue;
+
+ dependencies++;
+
+ // Add decode task if it doesn't already exists in graph.
+ TaskGraph::Node::Vector::iterator decode_it =
+ std::find_if(graph->nodes.begin(), graph->nodes.end(),
+ TaskGraph::Node::TaskComparator(decode_task));
+ if (decode_it == graph->nodes.end())
+ InsertNodeForTask(graph, decode_task, priority, 0u);
+
+ graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
+ }
+
+ InsertNodeForTask(graph, raster_task, priority, dependencies);
+}
+
+static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
+ switch (format) {
+ case RGBA_4444:
+ case RGBA_8888:
+ case BGRA_8888:
+ return true;
+ case ALPHA_8:
+ case LUMINANCE_8:
+ case RGB_565:
+ case ETC1:
+ case RED_8:
+ return false;
+ }
+ NOTREACHED();
+ return false;
+}
+
+// static
+void TileTaskWorkerPool::PlaybackToMemory(void* memory,
+ ResourceFormat format,
+ const gfx::Size& size,
+ int stride,
+ const RasterSource* raster_source,
+ const gfx::Rect& rect,
+ float scale) {
+ DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format;
+
+ // Uses kPremul_SkAlphaType since the result is not known to be opaque.
+ SkImageInfo info =
+ SkImageInfo::MakeN32(size.width(), size.height(), kPremul_SkAlphaType);
+ SkColorType buffer_color_type = ResourceFormatToSkColorType(format);
+ bool needs_copy = buffer_color_type != info.colorType();
+
+ // Use unknown pixel geometry to disable LCD text.
+ SkSurfaceProps surface_props(0, kUnknown_SkPixelGeometry);
+ if (raster_source->CanUseLCDText()) {
+ // LegacyFontHost will get LCD text and skia figures out what type to use.
+ surface_props = SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
+ }
+
+ if (!stride)
+ stride = info.minRowBytes();
+
+ if (!needs_copy) {
+ skia::RefPtr<SkSurface> surface = skia::AdoptRef(
+ SkSurface::NewRasterDirect(info, memory, stride, &surface_props));
+ skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
+ raster_source->PlaybackToCanvas(canvas.get(), rect, scale);
+ return;
+ }
+
+ skia::RefPtr<SkSurface> surface =
+ skia::AdoptRef(SkSurface::NewRaster(info, &surface_props));
+ skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
+ raster_source->PlaybackToCanvas(canvas.get(), rect, scale);
+
+ SkImageInfo dst_info = info;
+ dst_info.fColorType = buffer_color_type;
+ // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
+ // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
+ // is fixed.
+ const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
+ DCHECK_EQ(0u, dst_row_bytes % 4);
+ bool success = canvas->readPixels(dst_info, memory, dst_row_bytes, 0, 0);
+ DCHECK_EQ(true, success);
+}
+
+} // namespace cc
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/tile_task_worker_pool.h
similarity index 72%
rename from cc/resources/raster_worker_pool.h
rename to cc/resources/tile_task_worker_pool.h
index 5259f83..0440655 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/tile_task_worker_pool.h
@@ -2,10 +2,10 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_RESOURCES_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_RASTER_WORKER_POOL_H_
+#ifndef CC_RESOURCES_TILE_TASK_WORKER_POOL_H_
+#define CC_RESOURCES_TILE_TASK_WORKER_POOL_H_
-#include "cc/resources/rasterizer.h"
+#include "cc/resources/tile_task_runner.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
@@ -17,42 +17,42 @@
class RasterSource;
class RenderingStatsInstrumentation;
-class CC_EXPORT RasterWorkerPool {
+class CC_EXPORT TileTaskWorkerPool {
public:
- static unsigned kBenchmarkRasterTaskPriority;
- static unsigned kRasterFinishedTaskPriority;
- static unsigned kRasterTaskPriorityBase;
+ static unsigned kBenchmarkTaskPriority;
+ static unsigned kTaskSetFinishedTaskPriority;
+ static unsigned kTileTaskPriorityBase;
- RasterWorkerPool();
- virtual ~RasterWorkerPool();
+ TileTaskWorkerPool();
+ virtual ~TileTaskWorkerPool();
// Set the number of threads to use for the global TaskGraphRunner instance.
// This can only be called once and must be called prior to
- // GetNumRasterThreads().
- static void SetNumRasterThreads(int num_threads);
+ // GetNumWorkerThreads().
+ static void SetNumWorkerThreads(int num_threads);
// Returns the number of threads used for the global TaskGraphRunner instance.
- static int GetNumRasterThreads();
+ static int GetNumWorkerThreads();
// Returns a pointer to the global TaskGraphRunner instance.
static TaskGraphRunner* GetTaskGraphRunner();
- // Utility function that can be used to create a "raster finished" task that
+ // Utility function that can be used to create a "Task set finished" task that
// posts |callback| to |task_runner| when run.
- static scoped_refptr<RasterizerTask> CreateRasterFinishedTask(
+ static scoped_refptr<TileTask> CreateTaskSetFinishedTask(
base::SequencedTaskRunner* task_runner,
const base::Closure& callback);
// Utility function that can be used to call ::ScheduleOnOriginThread() for
// each task in |graph|.
- static void ScheduleTasksOnOriginThread(RasterizerTaskClient* client,
+ static void ScheduleTasksOnOriginThread(TileTaskClient* client,
TaskGraph* graph);
// Utility function that can be used to build a task graph. Inserts a node
// that represents |task| in |graph|. See TaskGraph definition for valid
// |priority| values.
static void InsertNodeForTask(TaskGraph* graph,
- RasterizerTask* task,
+ TileTask* task,
unsigned priority,
size_t dependencies);
@@ -75,9 +75,9 @@
float scale);
// Type-checking downcast routine.
- virtual Rasterizer* AsRasterizer() = 0;
+ virtual TileTaskRunner* AsTileTaskRunner() = 0;
};
} // namespace cc
-#endif // CC_RESOURCES_RASTER_WORKER_POOL_H_
+#endif // CC_RESOURCES_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/resources/tile_task_worker_pool_perftest.cc b/cc/resources/tile_task_worker_pool_perftest.cc
new file mode 100644
index 0000000..2c64029
--- /dev/null
+++ b/cc/resources/tile_task_worker_pool_perftest.cc
@@ -0,0 +1,502 @@
+// 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 "cc/resources/tile_task_worker_pool.h"
+
+#include "base/test/test_simple_task_runner.h"
+#include "base/time/time.h"
+#include "cc/debug/lap_timer.h"
+#include "cc/output/context_provider.h"
+#include "cc/resources/bitmap_tile_task_worker_pool.h"
+#include "cc/resources/gpu_tile_task_worker_pool.h"
+#include "cc/resources/one_copy_tile_task_worker_pool.h"
+#include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
+#include "cc/resources/raster_buffer.h"
+#include "cc/resources/resource_pool.h"
+#include "cc/resources/resource_provider.h"
+#include "cc/resources/scoped_resource.h"
+#include "cc/resources/tile_task_runner.h"
+#include "cc/resources/zero_copy_tile_task_worker_pool.h"
+#include "cc/test/fake_output_surface.h"
+#include "cc/test/fake_output_surface_client.h"
+#include "cc/test/test_context_support.h"
+#include "cc/test/test_gpu_memory_buffer_manager.h"
+#include "cc/test/test_shared_bitmap_manager.h"
+#include "cc/test/test_web_graphics_context_3d.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/perf/perf_test.h"
+#include "third_party/khronos/GLES2/gl2.h"
+
+namespace cc {
+namespace {
+
+class PerfGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
+ // Overridden from gpu::gles2::GLES2Interface:
+ GLuint CreateImageCHROMIUM(ClientBuffer buffer,
+ GLsizei width,
+ GLsizei height,
+ GLenum internalformat) override {
+ return 1u;
+ }
+ void GenBuffers(GLsizei n, GLuint* buffers) override {
+ for (GLsizei i = 0; i < n; ++i)
+ buffers[i] = 1u;
+ }
+ void GenTextures(GLsizei n, GLuint* textures) override {
+ for (GLsizei i = 0; i < n; ++i)
+ textures[i] = 1u;
+ }
+ void GetIntegerv(GLenum pname, GLint* params) override {
+ if (pname == GL_MAX_TEXTURE_SIZE)
+ *params = INT_MAX;
+ }
+ void GenQueriesEXT(GLsizei n, GLuint* queries) override {
+ for (GLsizei i = 0; i < n; ++i)
+ queries[i] = 1u;
+ }
+ void GetQueryObjectuivEXT(GLuint query,
+ GLenum pname,
+ GLuint* params) override {
+ if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
+ *params = 1;
+ }
+};
+
+class PerfContextProvider : public ContextProvider {
+ public:
+ PerfContextProvider() : context_gl_(new PerfGLES2Interface) {}
+
+ bool BindToCurrentThread() override { return true; }
+ Capabilities ContextCapabilities() override {
+ Capabilities capabilities;
+ capabilities.gpu.image = true;
+ capabilities.gpu.sync_query = true;
+ return capabilities;
+ }
+ gpu::gles2::GLES2Interface* ContextGL() override { return context_gl_.get(); }
+ gpu::ContextSupport* ContextSupport() override { return &support_; }
+ class GrContext* GrContext() override {
+ return NULL;
+ }
+ bool IsContextLost() override { return false; }
+ void VerifyContexts() override {}
+ void DeleteCachedResources() override {}
+ bool DestroyedOnMainThread() override { return false; }
+ void SetLostContextCallback(const LostContextCallback& cb) override {}
+ void SetMemoryPolicyChangedCallback(
+ const MemoryPolicyChangedCallback& cb) override {}
+
+ private:
+ ~PerfContextProvider() override {}
+
+ scoped_ptr<PerfGLES2Interface> context_gl_;
+ TestContextSupport support_;
+};
+
+enum TileTaskWorkerPoolType {
+ TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER,
+ TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_GPU,
+ TILE_TASK_WORKER_POOL_TYPE_BITMAP
+};
+
+static const int kTimeLimitMillis = 2000;
+static const int kWarmupRuns = 5;
+static const int kTimeCheckInterval = 10;
+
+class PerfImageDecodeTaskImpl : public ImageDecodeTask {
+ public:
+ PerfImageDecodeTaskImpl() {}
+
+ // Overridden from Task:
+ void RunOnWorkerThread() override {}
+
+ // Overridden from TileTask:
+ void ScheduleOnOriginThread(TileTaskClient* client) override {}
+ void CompleteOnOriginThread(TileTaskClient* client) override {}
+ void RunReplyOnOriginThread() override { Reset(); }
+
+ void Reset() {
+ did_run_ = false;
+ did_complete_ = false;
+ }
+
+ protected:
+ ~PerfImageDecodeTaskImpl() override {}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl);
+};
+
+class PerfRasterTaskImpl : public RasterTask {
+ public:
+ PerfRasterTaskImpl(scoped_ptr<ScopedResource> resource,
+ ImageDecodeTask::Vector* dependencies)
+ : RasterTask(resource.get(), dependencies), resource_(resource.Pass()) {}
+
+ // Overridden from Task:
+ void RunOnWorkerThread() override {}
+
+ // Overridden from TileTask:
+ void ScheduleOnOriginThread(TileTaskClient* client) override {
+ raster_buffer_ = client->AcquireBufferForRaster(resource());
+ }
+ void CompleteOnOriginThread(TileTaskClient* client) override {
+ client->ReleaseBufferForRaster(raster_buffer_.Pass());
+ }
+ void RunReplyOnOriginThread() override { Reset(); }
+
+ void Reset() {
+ did_run_ = false;
+ did_complete_ = false;
+ }
+
+ protected:
+ ~PerfRasterTaskImpl() override {}
+
+ private:
+ scoped_ptr<ScopedResource> resource_;
+ scoped_ptr<RasterBuffer> raster_buffer_;
+
+ DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl);
+};
+
+class TileTaskWorkerPoolPerfTestBase {
+ public:
+ typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
+
+ enum NamedTaskSet { ALL, REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW };
+
+ TileTaskWorkerPoolPerfTestBase()
+ : context_provider_(make_scoped_refptr(new PerfContextProvider)),
+ task_runner_(new base::TestSimpleTaskRunner),
+ task_graph_runner_(new TaskGraphRunner),
+ timer_(kWarmupRuns,
+ base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
+ kTimeCheckInterval) {}
+
+ void CreateImageDecodeTasks(unsigned num_image_decode_tasks,
+ ImageDecodeTask::Vector* image_decode_tasks) {
+ for (unsigned i = 0; i < num_image_decode_tasks; ++i)
+ image_decode_tasks->push_back(new PerfImageDecodeTaskImpl);
+ }
+
+ void CreateRasterTasks(unsigned num_raster_tasks,
+ const ImageDecodeTask::Vector& image_decode_tasks,
+ RasterTaskVector* raster_tasks) {
+ const gfx::Size size(1, 1);
+
+ for (unsigned i = 0; i < num_raster_tasks; ++i) {
+ scoped_ptr<ScopedResource> resource(
+ ScopedResource::Create(resource_provider_.get()));
+ resource->Allocate(size, ResourceProvider::TextureHintImmutable,
+ RGBA_8888);
+
+ ImageDecodeTask::Vector dependencies = image_decode_tasks;
+ raster_tasks->push_back(
+ new PerfRasterTaskImpl(resource.Pass(), &dependencies));
+ }
+ }
+
+ void BuildTileTaskQueue(TileTaskQueue* queue,
+ const RasterTaskVector& raster_tasks) {
+ for (size_t i = 0u; i < raster_tasks.size(); ++i) {
+ bool required_for_activation = (i % 2) == 0;
+ TaskSetCollection task_set_collection;
+ task_set_collection[ALL] = true;
+ task_set_collection[REQUIRED_FOR_ACTIVATION] = required_for_activation;
+ queue->items.push_back(
+ TileTaskQueue::Item(raster_tasks[i].get(), task_set_collection));
+ }
+ }
+
+ protected:
+ scoped_refptr<ContextProvider> context_provider_;
+ FakeOutputSurfaceClient output_surface_client_;
+ scoped_ptr<FakeOutputSurface> output_surface_;
+ scoped_ptr<ResourceProvider> resource_provider_;
+ scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+ scoped_ptr<TaskGraphRunner> task_graph_runner_;
+ LapTimer timer_;
+};
+
+class TileTaskWorkerPoolPerfTest
+ : public TileTaskWorkerPoolPerfTestBase,
+ public testing::TestWithParam<TileTaskWorkerPoolType>,
+ public TileTaskRunnerClient {
+ public:
+ // Overridden from testing::Test:
+ void SetUp() override {
+ switch (GetParam()) {
+ case TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER:
+ Create3dOutputSurfaceAndResourceProvider();
+ tile_task_worker_pool_ = PixelBufferTileTaskWorkerPool::Create(
+ task_runner_.get(), task_graph_runner_.get(),
+ context_provider_.get(), resource_provider_.get(),
+ std::numeric_limits<size_t>::max());
+ break;
+ case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
+ Create3dOutputSurfaceAndResourceProvider();
+ tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
+ task_runner_.get(), task_graph_runner_.get(),
+ resource_provider_.get());
+ break;
+ case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
+ Create3dOutputSurfaceAndResourceProvider();
+ staging_resource_pool_ = ResourcePool::Create(resource_provider_.get(),
+ GL_TEXTURE_2D, RGBA_8888);
+ tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
+ task_runner_.get(), task_graph_runner_.get(),
+ context_provider_.get(), resource_provider_.get(),
+ staging_resource_pool_.get());
+ break;
+ case TILE_TASK_WORKER_POOL_TYPE_GPU:
+ Create3dOutputSurfaceAndResourceProvider();
+ tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
+ task_runner_.get(), context_provider_.get(),
+ resource_provider_.get(), false);
+ break;
+ case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
+ CreateSoftwareOutputSurfaceAndResourceProvider();
+ tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create(
+ task_runner_.get(), task_graph_runner_.get(),
+ resource_provider_.get());
+ break;
+ }
+
+ DCHECK(tile_task_worker_pool_);
+ tile_task_worker_pool_->AsTileTaskRunner()->SetClient(this);
+ }
+ void TearDown() override {
+ tile_task_worker_pool_->AsTileTaskRunner()->Shutdown();
+ tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
+ }
+
+ // Overriden from TileTaskRunnerClient:
+ void DidFinishRunningTileTasks(TaskSet task_set) override {
+ tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
+ }
+ TaskSetCollection TasksThatShouldBeForcedToComplete() const override {
+ return TaskSetCollection();
+ }
+
+ void RunMessageLoopUntilAllTasksHaveCompleted() {
+ task_graph_runner_->RunUntilIdle();
+ task_runner_->RunUntilIdle();
+ }
+
+ void RunScheduleTasksTest(const std::string& test_name,
+ unsigned num_raster_tasks,
+ unsigned num_image_decode_tasks) {
+ ImageDecodeTask::Vector image_decode_tasks;
+ RasterTaskVector raster_tasks;
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+
+ // Avoid unnecessary heap allocations by reusing the same queue.
+ TileTaskQueue queue;
+
+ timer_.Reset();
+ do {
+ queue.Reset();
+ BuildTileTaskQueue(&queue, raster_tasks);
+ tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
+ tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ TileTaskQueue empty;
+ tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty);
+ RunMessageLoopUntilAllTasksHaveCompleted();
+
+ perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name,
+ timer_.LapsPerSecond(), "runs/s", true);
+ }
+
+ void RunScheduleAlternateTasksTest(const std::string& test_name,
+ unsigned num_raster_tasks,
+ unsigned num_image_decode_tasks) {
+ const size_t kNumVersions = 2;
+ ImageDecodeTask::Vector image_decode_tasks[kNumVersions];
+ RasterTaskVector raster_tasks[kNumVersions];
+ for (size_t i = 0; i < kNumVersions; ++i) {
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks[i],
+ &raster_tasks[i]);
+ }
+
+ // Avoid unnecessary heap allocations by reusing the same queue.
+ TileTaskQueue queue;
+
+ size_t count = 0;
+ timer_.Reset();
+ do {
+ queue.Reset();
+ BuildTileTaskQueue(&queue, raster_tasks[count % kNumVersions]);
+ tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
+ tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
+ ++count;
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ TileTaskQueue empty;
+ tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty);
+ RunMessageLoopUntilAllTasksHaveCompleted();
+
+ perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(),
+ test_name, timer_.LapsPerSecond(), "runs/s", true);
+ }
+
+ void RunScheduleAndExecuteTasksTest(const std::string& test_name,
+ unsigned num_raster_tasks,
+ unsigned num_image_decode_tasks) {
+ ImageDecodeTask::Vector image_decode_tasks;
+ RasterTaskVector raster_tasks;
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+
+ // Avoid unnecessary heap allocations by reusing the same queue.
+ TileTaskQueue queue;
+
+ timer_.Reset();
+ do {
+ queue.Reset();
+ BuildTileTaskQueue(&queue, raster_tasks);
+ tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
+ RunMessageLoopUntilAllTasksHaveCompleted();
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ TileTaskQueue empty;
+ tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&empty);
+ RunMessageLoopUntilAllTasksHaveCompleted();
+
+ perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(),
+ test_name, timer_.LapsPerSecond(), "runs/s", true);
+ }
+
+ private:
+ void Create3dOutputSurfaceAndResourceProvider() {
+ output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
+ CHECK(output_surface_->BindToClient(&output_surface_client_));
+ resource_provider_ = ResourceProvider::Create(output_surface_.get(), NULL,
+ &gpu_memory_buffer_manager_,
+ NULL, 0, false, 1).Pass();
+ }
+
+ void CreateSoftwareOutputSurfaceAndResourceProvider() {
+ output_surface_ = FakeOutputSurface::CreateSoftware(
+ make_scoped_ptr(new SoftwareOutputDevice));
+ CHECK(output_surface_->BindToClient(&output_surface_client_));
+ resource_provider_ =
+ ResourceProvider::Create(output_surface_.get(), &shared_bitmap_manager_,
+ NULL, NULL, 0, false, 1).Pass();
+ }
+
+ std::string TestModifierString() const {
+ switch (GetParam()) {
+ case TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER:
+ return std::string("_pixel_tile_task_worker_pool");
+ case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
+ return std::string("_zero_copy_tile_task_worker_pool");
+ case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
+ return std::string("_one_copy_tile_task_worker_pool");
+ case TILE_TASK_WORKER_POOL_TYPE_GPU:
+ return std::string("_gpu_tile_task_worker_pool");
+ case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
+ return std::string("_bitmap_tile_task_worker_pool");
+ }
+ NOTREACHED();
+ return std::string();
+ }
+
+ scoped_ptr<ResourcePool> staging_resource_pool_;
+ scoped_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
+ TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
+ TestSharedBitmapManager shared_bitmap_manager_;
+};
+
+TEST_P(TileTaskWorkerPoolPerfTest, ScheduleTasks) {
+ RunScheduleTasksTest("1_0", 1, 0);
+ RunScheduleTasksTest("32_0", 32, 0);
+ RunScheduleTasksTest("1_1", 1, 1);
+ RunScheduleTasksTest("32_1", 32, 1);
+ RunScheduleTasksTest("1_4", 1, 4);
+ RunScheduleTasksTest("32_4", 32, 4);
+}
+
+TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAlternateTasks) {
+ RunScheduleAlternateTasksTest("1_0", 1, 0);
+ RunScheduleAlternateTasksTest("32_0", 32, 0);
+ RunScheduleAlternateTasksTest("1_1", 1, 1);
+ RunScheduleAlternateTasksTest("32_1", 32, 1);
+ RunScheduleAlternateTasksTest("1_4", 1, 4);
+ RunScheduleAlternateTasksTest("32_4", 32, 4);
+}
+
+TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAndExecuteTasks) {
+ RunScheduleAndExecuteTasksTest("1_0", 1, 0);
+ RunScheduleAndExecuteTasksTest("32_0", 32, 0);
+ RunScheduleAndExecuteTasksTest("1_1", 1, 1);
+ RunScheduleAndExecuteTasksTest("32_1", 32, 1);
+ RunScheduleAndExecuteTasksTest("1_4", 1, 4);
+ RunScheduleAndExecuteTasksTest("32_4", 32, 4);
+}
+
+INSTANTIATE_TEST_CASE_P(
+ TileTaskWorkerPoolPerfTests,
+ TileTaskWorkerPoolPerfTest,
+ ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER,
+ TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_GPU,
+ TILE_TASK_WORKER_POOL_TYPE_BITMAP));
+
+class TileTaskWorkerPoolCommonPerfTest : public TileTaskWorkerPoolPerfTestBase,
+ public testing::Test {
+ public:
+ // Overridden from testing::Test:
+ void SetUp() override {
+ output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
+ CHECK(output_surface_->BindToClient(&output_surface_client_));
+ resource_provider_ =
+ ResourceProvider::Create(output_surface_.get(), NULL, NULL, NULL, 0,
+ false, 1).Pass();
+ }
+
+ void RunBuildTileTaskQueueTest(const std::string& test_name,
+ unsigned num_raster_tasks,
+ unsigned num_image_decode_tasks) {
+ ImageDecodeTask::Vector image_decode_tasks;
+ RasterTaskVector raster_tasks;
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+
+ // Avoid unnecessary heap allocations by reusing the same queue.
+ TileTaskQueue queue;
+
+ timer_.Reset();
+ do {
+ queue.Reset();
+ BuildTileTaskQueue(&queue, raster_tasks);
+ timer_.NextLap();
+ } while (!timer_.HasTimeLimitExpired());
+
+ perf_test::PrintResult("build_raster_task_queue", "", test_name,
+ timer_.LapsPerSecond(), "runs/s", true);
+ }
+};
+
+TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskQueue) {
+ RunBuildTileTaskQueueTest("1_0", 1, 0);
+ RunBuildTileTaskQueueTest("32_0", 32, 0);
+ RunBuildTileTaskQueueTest("1_1", 1, 1);
+ RunBuildTileTaskQueueTest("32_1", 32, 1);
+ RunBuildTileTaskQueueTest("1_4", 1, 4);
+ RunBuildTileTaskQueueTest("32_4", 32, 4);
+}
+
+} // namespace
+} // namespace cc
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/tile_task_worker_pool_unittest.cc
similarity index 64%
rename from cc/resources/raster_worker_pool_unittest.cc
rename to cc/resources/tile_task_worker_pool_unittest.cc
index 0518f64..02ca225 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/tile_task_worker_pool_unittest.cc
@@ -2,24 +2,24 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/tile_task_worker_pool.h"
#include <limits>
#include <vector>
#include "base/cancelable_callback.h"
-#include "cc/resources/bitmap_raster_worker_pool.h"
-#include "cc/resources/gpu_raster_worker_pool.h"
-#include "cc/resources/one_copy_raster_worker_pool.h"
+#include "cc/resources/bitmap_tile_task_worker_pool.h"
+#include "cc/resources/gpu_tile_task_worker_pool.h"
+#include "cc/resources/one_copy_tile_task_worker_pool.h"
#include "cc/resources/picture_pile.h"
#include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/pixel_buffer_raster_worker_pool.h"
+#include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
#include "cc/resources/raster_buffer.h"
-#include "cc/resources/rasterizer.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/scoped_resource.h"
-#include "cc/resources/zero_copy_raster_worker_pool.h"
+#include "cc/resources/tile_task_runner.h"
+#include "cc/resources/zero_copy_tile_task_worker_pool.h"
#include "cc/test/fake_output_surface.h"
#include "cc/test/fake_output_surface_client.h"
#include "cc/test/fake_picture_pile_impl.h"
@@ -36,12 +36,12 @@
// buffer constant.
const size_t kLargeResourceDimension = 1000U;
-enum RasterWorkerPoolType {
- RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
- RASTER_WORKER_POOL_TYPE_ZERO_COPY,
- RASTER_WORKER_POOL_TYPE_ONE_COPY,
- RASTER_WORKER_POOL_TYPE_GPU,
- RASTER_WORKER_POOL_TYPE_BITMAP
+enum TileTaskWorkerPoolType {
+ TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER,
+ TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_GPU,
+ TILE_TASK_WORKER_POOL_TYPE_BITMAP
};
class TestRasterTaskImpl : public RasterTask {
@@ -62,11 +62,11 @@
raster_buffer_->Playback(picture_pile_.get(), gfx::Rect(0, 0, 1, 1), 1.0);
}
- // Overridden from RasterizerTask:
- void ScheduleOnOriginThread(RasterizerTaskClient* client) override {
+ // Overridden from TileTask:
+ void ScheduleOnOriginThread(TileTaskClient* client) override {
raster_buffer_ = client->AcquireBufferForRaster(resource());
}
- void CompleteOnOriginThread(RasterizerTaskClient* client) override {
+ void CompleteOnOriginThread(TileTaskClient* client) override {
client->ReleaseBufferForRaster(raster_buffer_.Pass());
}
void RunReplyOnOriginThread() override {
@@ -98,7 +98,7 @@
TestRasterTaskImpl::RunOnWorkerThread();
}
- // Overridden from RasterizerTask:
+ // Overridden from TileTask:
void RunReplyOnOriginThread() override {}
protected:
@@ -110,9 +110,9 @@
DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl);
};
-class RasterWorkerPoolTest
- : public testing::TestWithParam<RasterWorkerPoolType>,
- public RasterizerClient {
+class TileTaskWorkerPoolTest
+ : public testing::TestWithParam<TileTaskWorkerPoolType>,
+ public TileTaskRunnerClient {
public:
struct RasterTaskResult {
unsigned id;
@@ -123,7 +123,7 @@
enum NamedTaskSet { ALL, REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW };
- RasterWorkerPoolTest()
+ TileTaskWorkerPoolTest()
: context_provider_(TestContextProvider::Create()),
timeout_seconds_(5),
timed_out_(false) {}
@@ -131,63 +131,55 @@
// Overridden from testing::Test:
void SetUp() override {
switch (GetParam()) {
- case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
+ case TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER:
Create3dOutputSurfaceAndResourceProvider();
- raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
+ tile_task_worker_pool_ = PixelBufferTileTaskWorkerPool::Create(
base::MessageLoopProxy::current().get(),
- RasterWorkerPool::GetTaskGraphRunner(),
- context_provider_.get(),
- resource_provider_.get(),
- kMaxTransferBufferUsageBytes);
+ TileTaskWorkerPool::GetTaskGraphRunner(), context_provider_.get(),
+ resource_provider_.get(), kMaxTransferBufferUsageBytes);
break;
- case RASTER_WORKER_POOL_TYPE_ZERO_COPY:
+ case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
Create3dOutputSurfaceAndResourceProvider();
- raster_worker_pool_ = ZeroCopyRasterWorkerPool::Create(
+ tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
base::MessageLoopProxy::current().get(),
- RasterWorkerPool::GetTaskGraphRunner(),
- resource_provider_.get());
+ TileTaskWorkerPool::GetTaskGraphRunner(), resource_provider_.get());
break;
- case RASTER_WORKER_POOL_TYPE_ONE_COPY:
+ case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
Create3dOutputSurfaceAndResourceProvider();
- staging_resource_pool_ = ResourcePool::Create(
- resource_provider_.get(), GL_TEXTURE_2D, RGBA_8888);
- raster_worker_pool_ = OneCopyRasterWorkerPool::Create(
+ staging_resource_pool_ = ResourcePool::Create(resource_provider_.get(),
+ GL_TEXTURE_2D, RGBA_8888);
+ tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
base::MessageLoopProxy::current().get(),
- RasterWorkerPool::GetTaskGraphRunner(),
- context_provider_.get(),
- resource_provider_.get(),
- staging_resource_pool_.get());
+ TileTaskWorkerPool::GetTaskGraphRunner(), context_provider_.get(),
+ resource_provider_.get(), staging_resource_pool_.get());
break;
- case RASTER_WORKER_POOL_TYPE_GPU:
+ case TILE_TASK_WORKER_POOL_TYPE_GPU:
Create3dOutputSurfaceAndResourceProvider();
- raster_worker_pool_ =
- GpuRasterWorkerPool::Create(base::MessageLoopProxy::current().get(),
- context_provider_.get(),
- resource_provider_.get(),
- false);
+ tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
+ base::MessageLoopProxy::current().get(), context_provider_.get(),
+ resource_provider_.get(), false);
break;
- case RASTER_WORKER_POOL_TYPE_BITMAP:
+ case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
CreateSoftwareOutputSurfaceAndResourceProvider();
- raster_worker_pool_ = BitmapRasterWorkerPool::Create(
+ tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create(
base::MessageLoopProxy::current().get(),
- RasterWorkerPool::GetTaskGraphRunner(),
- resource_provider_.get());
+ TileTaskWorkerPool::GetTaskGraphRunner(), resource_provider_.get());
break;
}
- DCHECK(raster_worker_pool_);
- raster_worker_pool_->AsRasterizer()->SetClient(this);
+ DCHECK(tile_task_worker_pool_);
+ tile_task_worker_pool_->AsTileTaskRunner()->SetClient(this);
}
void TearDown() override {
- raster_worker_pool_->AsRasterizer()->Shutdown();
- raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
+ tile_task_worker_pool_->AsTileTaskRunner()->Shutdown();
+ tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
}
- // Overriden from RasterWorkerPoolClient:
- void DidFinishRunningTasks(TaskSet task_set) override {
+ // Overriden from TileTaskWorkerPoolClient:
+ void DidFinishRunningTileTasks(TaskSet task_set) override {
if (task_set == ALL) {
- raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
+ tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
base::MessageLoop::current()->Quit();
}
}
@@ -197,11 +189,10 @@
void RunMessageLoopUntilAllTasksHaveCompleted() {
if (timeout_seconds_) {
- timeout_.Reset(
- base::Bind(&RasterWorkerPoolTest::OnTimeout, base::Unretained(this)));
+ timeout_.Reset(base::Bind(&TileTaskWorkerPoolTest::OnTimeout,
+ base::Unretained(this)));
base::MessageLoopProxy::current()->PostDelayedTask(
- FROM_HERE,
- timeout_.callback(),
+ FROM_HERE, timeout_.callback(),
base::TimeDelta::FromSeconds(timeout_seconds_));
}
@@ -213,17 +204,16 @@
}
void ScheduleTasks() {
- RasterTaskQueue queue;
+ TileTaskQueue queue;
for (RasterTaskVector::const_iterator it = tasks_.begin();
- it != tasks_.end();
- ++it) {
+ it != tasks_.end(); ++it) {
TaskSetCollection task_sets;
task_sets[ALL] = true;
- queue.items.push_back(RasterTaskQueue::Item(it->get(), task_sets));
+ queue.items.push_back(TileTaskQueue::Item(it->get(), task_sets));
}
- raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue);
+ tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&queue);
}
void AppendTask(unsigned id, const gfx::Size& size) {
@@ -235,10 +225,8 @@
ImageDecodeTask::Vector empty;
tasks_.push_back(new TestRasterTaskImpl(
const_resource,
- base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
- base::Unretained(this),
- base::Passed(&resource),
- id),
+ base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted,
+ base::Unretained(this), base::Passed(&resource), id),
&empty));
}
@@ -255,12 +243,9 @@
ImageDecodeTask::Vector empty;
tasks_.push_back(new BlockingTestRasterTaskImpl(
const_resource,
- base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
- base::Unretained(this),
- base::Passed(&resource),
- id),
- lock,
- &empty));
+ base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted,
+ base::Unretained(this), base::Passed(&resource), id),
+ lock, &empty));
}
const std::vector<RasterTaskResult>& completed_tasks() const {
@@ -273,26 +258,18 @@
CHECK(output_surface_->BindToClient(&output_surface_client_));
TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
context3d->set_support_sync_query(true);
- resource_provider_ = ResourceProvider::Create(output_surface_.get(),
- NULL,
+ resource_provider_ = ResourceProvider::Create(output_surface_.get(), NULL,
&gpu_memory_buffer_manager_,
- NULL,
- 0,
- false,
- 1).Pass();
+ NULL, 0, false, 1).Pass();
}
void CreateSoftwareOutputSurfaceAndResourceProvider() {
output_surface_ = FakeOutputSurface::CreateSoftware(
make_scoped_ptr(new SoftwareOutputDevice));
CHECK(output_surface_->BindToClient(&output_surface_client_));
- resource_provider_ = ResourceProvider::Create(output_surface_.get(),
- &shared_bitmap_manager_,
- NULL,
- NULL,
- 0,
- false,
- 1).Pass();
+ resource_provider_ =
+ ResourceProvider::Create(output_surface_.get(), &shared_bitmap_manager_,
+ NULL, NULL, 0, false, 1).Pass();
}
void OnTaskCompleted(scoped_ptr<ScopedResource> resource,
@@ -316,7 +293,7 @@
scoped_ptr<FakeOutputSurface> output_surface_;
scoped_ptr<ResourceProvider> resource_provider_;
scoped_ptr<ResourcePool> staging_resource_pool_;
- scoped_ptr<RasterWorkerPool> raster_worker_pool_;
+ scoped_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
TestSharedBitmapManager shared_bitmap_manager_;
base::CancelableClosure timeout_;
@@ -326,7 +303,7 @@
std::vector<RasterTaskResult> completed_tasks_;
};
-TEST_P(RasterWorkerPoolTest, Basic) {
+TEST_P(TileTaskWorkerPoolTest, Basic) {
AppendTask(0u);
AppendTask(1u);
ScheduleTasks();
@@ -338,8 +315,8 @@
EXPECT_FALSE(completed_tasks()[1].canceled);
}
-TEST_P(RasterWorkerPoolTest, FailedMapResource) {
- if (GetParam() == RASTER_WORKER_POOL_TYPE_BITMAP)
+TEST_P(TileTaskWorkerPoolTest, FailedMapResource) {
+ if (GetParam() == TILE_TASK_WORKER_POOL_TYPE_BITMAP)
return;
TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
@@ -354,8 +331,8 @@
}
// This test checks that replacing a pending raster task with another does
-// not prevent the DidFinishRunningTasks notification from being sent.
-TEST_P(RasterWorkerPoolTest, FalseThrottling) {
+// not prevent the DidFinishRunningTileTasks notification from being sent.
+TEST_P(TileTaskWorkerPoolTest, FalseThrottling) {
base::Lock lock;
// Schedule a task that is prevented from completing with a lock.
@@ -365,7 +342,7 @@
// Schedule another task to replace the still-pending task. Because the old
// task is not a throttled task in the new task set, it should not prevent
- // DidFinishRunningTasks from getting signaled.
+ // DidFinishRunningTileTasks from getting signaled.
RasterTaskVector tasks;
tasks.swap(tasks_);
AppendTask(1u);
@@ -377,7 +354,7 @@
RunMessageLoopUntilAllTasksHaveCompleted();
}
-TEST_P(RasterWorkerPoolTest, LargeResources) {
+TEST_P(TileTaskWorkerPoolTest, LargeResources) {
gfx::Size size(kLargeResourceDimension, kLargeResourceDimension);
{
@@ -398,13 +375,14 @@
RunMessageLoopUntilAllTasksHaveCompleted();
}
-INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests,
- RasterWorkerPoolTest,
- ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
- RASTER_WORKER_POOL_TYPE_ZERO_COPY,
- RASTER_WORKER_POOL_TYPE_ONE_COPY,
- RASTER_WORKER_POOL_TYPE_GPU,
- RASTER_WORKER_POOL_TYPE_BITMAP));
+INSTANTIATE_TEST_CASE_P(
+ TileTaskWorkerPoolTests,
+ TileTaskWorkerPoolTest,
+ ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER,
+ TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
+ TILE_TASK_WORKER_POOL_TYPE_GPU,
+ TILE_TASK_WORKER_POOL_TYPE_BITMAP));
} // namespace
} // namespace cc
diff --git a/cc/resources/zero_copy_raster_worker_pool.cc b/cc/resources/zero_copy_raster_worker_pool.cc
deleted file mode 100644
index ca2bc9b..0000000
--- a/cc/resources/zero_copy_raster_worker_pool.cc
+++ /dev/null
@@ -1,211 +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 "cc/resources/zero_copy_raster_worker_pool.h"
-
-#include <algorithm>
-
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
-#include "base/strings/stringprintf.h"
-#include "cc/debug/traced_value.h"
-#include "cc/resources/raster_buffer.h"
-#include "cc/resources/resource.h"
-#include "ui/gfx/gpu_memory_buffer.h"
-
-namespace cc {
-namespace {
-
-class RasterBufferImpl : public RasterBuffer {
- public:
- RasterBufferImpl(ResourceProvider* resource_provider,
- const Resource* resource)
- : lock_(resource_provider, resource->id()), resource_(resource) {}
-
- // Overridden from RasterBuffer:
- void Playback(const RasterSource* raster_source,
- const gfx::Rect& rect,
- float scale) override {
- gfx::GpuMemoryBuffer* gpu_memory_buffer = lock_.GetGpuMemoryBuffer();
- if (!gpu_memory_buffer)
- return;
-
- RasterWorkerPool::PlaybackToMemory(
- gpu_memory_buffer->Map(), resource_->format(), resource_->size(),
- gpu_memory_buffer->GetStride(), raster_source, rect, scale);
- gpu_memory_buffer->Unmap();
- }
-
- private:
- ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock_;
- const Resource* resource_;
-
- DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
-};
-
-} // namespace
-
-// static
-scoped_ptr<RasterWorkerPool> ZeroCopyRasterWorkerPool::Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider) {
- return make_scoped_ptr<RasterWorkerPool>(new ZeroCopyRasterWorkerPool(
- task_runner, task_graph_runner, resource_provider));
-}
-
-ZeroCopyRasterWorkerPool::ZeroCopyRasterWorkerPool(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider)
- : task_runner_(task_runner),
- task_graph_runner_(task_graph_runner),
- namespace_token_(task_graph_runner->GetNamespaceToken()),
- resource_provider_(resource_provider),
- raster_finished_weak_ptr_factory_(this) {
-}
-
-ZeroCopyRasterWorkerPool::~ZeroCopyRasterWorkerPool() {
-}
-
-Rasterizer* ZeroCopyRasterWorkerPool::AsRasterizer() {
- return this;
-}
-
-void ZeroCopyRasterWorkerPool::SetClient(RasterizerClient* client) {
- client_ = client;
-}
-
-void ZeroCopyRasterWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "ZeroCopyRasterWorkerPool::Shutdown");
-
- TaskGraph empty;
- task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
- task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-}
-
-void ZeroCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
- TRACE_EVENT0("cc", "ZeroCopyRasterWorkerPool::ScheduleTasks");
-
- if (raster_pending_.none())
- TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
-
- // Mark all task sets as pending.
- raster_pending_.set();
-
- unsigned priority = kRasterTaskPriorityBase;
-
- graph_.Reset();
-
- // Cancel existing OnRasterFinished callbacks.
- raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
-
- scoped_refptr<RasterizerTask> new_raster_finished_tasks[kNumberOfTaskSets];
-
- size_t task_count[kNumberOfTaskSets] = {0};
-
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
- task_runner_.get(),
- base::Bind(&ZeroCopyRasterWorkerPool::OnRasterFinished,
- raster_finished_weak_ptr_factory_.GetWeakPtr(),
- task_set));
- }
-
- for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
- it != queue->items.end();
- ++it) {
- const RasterTaskQueue::Item& item = *it;
- RasterTask* task = item.task;
- DCHECK(!task->HasCompleted());
-
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- if (!item.task_sets[task_set])
- continue;
-
- ++task_count[task_set];
-
- graph_.edges.push_back(
- TaskGraph::Edge(task, new_raster_finished_tasks[task_set].get()));
- }
-
- InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
- }
-
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
- InsertNodeForTask(&graph_,
- new_raster_finished_tasks[task_set].get(),
- kRasterFinishedTaskPriority,
- task_count[task_set]);
- }
-
- ScheduleTasksOnOriginThread(this, &graph_);
- task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
-
- std::copy(new_raster_finished_tasks,
- new_raster_finished_tasks + kNumberOfTaskSets,
- raster_finished_tasks_);
-
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
-}
-
-void ZeroCopyRasterWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "ZeroCopyRasterWorkerPool::CheckForCompletedTasks");
-
- task_graph_runner_->CollectCompletedTasks(namespace_token_,
- &completed_tasks_);
- for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end();
- ++it) {
- RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
-
- task->RunReplyOnOriginThread();
- }
- completed_tasks_.clear();
-}
-
-scoped_ptr<RasterBuffer> ZeroCopyRasterWorkerPool::AcquireBufferForRaster(
- const Resource* resource) {
- return make_scoped_ptr<RasterBuffer>(
- new RasterBufferImpl(resource_provider_, resource));
-}
-
-void ZeroCopyRasterWorkerPool::ReleaseBufferForRaster(
- scoped_ptr<RasterBuffer> buffer) {
- // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
-}
-
-void ZeroCopyRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
- TRACE_EVENT1(
- "cc", "ZeroCopyRasterWorkerPool::OnRasterFinished", "task_set", task_set);
-
- DCHECK(raster_pending_[task_set]);
- raster_pending_[task_set] = false;
- if (raster_pending_.any()) {
- TRACE_EVENT_ASYNC_STEP_INTO1(
- "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
- } else {
- TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
- }
- client_->DidFinishRunningTasks(task_set);
-}
-
-scoped_refptr<base::debug::ConvertableToTraceFormat>
-ZeroCopyRasterWorkerPool::StateAsValue() const {
- scoped_refptr<base::debug::TracedValue> state =
- new base::debug::TracedValue();
-
- state->BeginArray("tasks_pending");
- for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set)
- state->AppendBoolean(raster_pending_[task_set]);
- state->EndArray();
- return state;
-}
-
-} // namespace cc
diff --git a/cc/resources/zero_copy_raster_worker_pool.h b/cc/resources/zero_copy_raster_worker_pool.h
deleted file mode 100644
index d1f583e..0000000
--- a/cc/resources/zero_copy_raster_worker_pool.h
+++ /dev/null
@@ -1,79 +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 CC_RESOURCES_ZERO_COPY_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_ZERO_COPY_RASTER_WORKER_POOL_H_
-
-#include "base/memory/weak_ptr.h"
-#include "base/values.h"
-#include "cc/resources/raster_worker_pool.h"
-#include "cc/resources/rasterizer.h"
-
-namespace base {
-namespace debug {
-class ConvertableToTraceFormat;
-}
-}
-
-namespace cc {
-class ResourceProvider;
-
-class CC_EXPORT ZeroCopyRasterWorkerPool : public RasterWorkerPool,
- public Rasterizer,
- public RasterizerTaskClient {
- public:
- ~ZeroCopyRasterWorkerPool() override;
-
- static scoped_ptr<RasterWorkerPool> Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider);
-
- // Overridden from RasterWorkerPool:
- Rasterizer* AsRasterizer() override;
-
- // Overridden from Rasterizer:
- void SetClient(RasterizerClient* client) override;
- void Shutdown() override;
- void ScheduleTasks(RasterTaskQueue* queue) override;
- void CheckForCompletedTasks() override;
-
- // Overridden from RasterizerTaskClient:
- scoped_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource) override;
- void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
-
- protected:
- ZeroCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider);
-
- private:
- void OnRasterFinished(TaskSet task_set);
- scoped_refptr<base::debug::ConvertableToTraceFormat> StateAsValue() const;
-
- scoped_refptr<base::SequencedTaskRunner> task_runner_;
- TaskGraphRunner* task_graph_runner_;
- const NamespaceToken namespace_token_;
- RasterizerClient* client_;
- ResourceProvider* resource_provider_;
-
- TaskSetCollection raster_pending_;
-
- scoped_refptr<RasterizerTask> raster_finished_tasks_[kNumberOfTaskSets];
-
- // Task graph used when scheduling tasks and vector used to gather
- // completed tasks.
- TaskGraph graph_;
- Task::Vector completed_tasks_;
-
- base::WeakPtrFactory<ZeroCopyRasterWorkerPool>
- raster_finished_weak_ptr_factory_;
-
- DISALLOW_COPY_AND_ASSIGN(ZeroCopyRasterWorkerPool);
-};
-
-} // namespace cc
-
-#endif // CC_RESOURCES_ZERO_COPY_RASTER_WORKER_POOL_H_
diff --git a/cc/resources/zero_copy_tile_task_worker_pool.cc b/cc/resources/zero_copy_tile_task_worker_pool.cc
new file mode 100644
index 0000000..6ef78f4
--- /dev/null
+++ b/cc/resources/zero_copy_tile_task_worker_pool.cc
@@ -0,0 +1,206 @@
+// 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 "cc/resources/zero_copy_tile_task_worker_pool.h"
+
+#include <algorithm>
+
+#include "base/debug/trace_event.h"
+#include "base/debug/trace_event_argument.h"
+#include "base/strings/stringprintf.h"
+#include "cc/debug/traced_value.h"
+#include "cc/resources/raster_buffer.h"
+#include "cc/resources/resource.h"
+#include "ui/gfx/gpu_memory_buffer.h"
+
+namespace cc {
+namespace {
+
+class RasterBufferImpl : public RasterBuffer {
+ public:
+ RasterBufferImpl(ResourceProvider* resource_provider,
+ const Resource* resource)
+ : lock_(resource_provider, resource->id()), resource_(resource) {}
+
+ // Overridden from RasterBuffer:
+ void Playback(const RasterSource* raster_source,
+ const gfx::Rect& rect,
+ float scale) override {
+ gfx::GpuMemoryBuffer* gpu_memory_buffer = lock_.GetGpuMemoryBuffer();
+ if (!gpu_memory_buffer)
+ return;
+
+ TileTaskWorkerPool::PlaybackToMemory(
+ gpu_memory_buffer->Map(), resource_->format(), resource_->size(),
+ gpu_memory_buffer->GetStride(), raster_source, rect, scale);
+ gpu_memory_buffer->Unmap();
+ }
+
+ private:
+ ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock_;
+ const Resource* resource_;
+
+ DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
+};
+
+} // namespace
+
+// static
+scoped_ptr<TileTaskWorkerPool> ZeroCopyTileTaskWorkerPool::Create(
+ base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider) {
+ return make_scoped_ptr<TileTaskWorkerPool>(new ZeroCopyTileTaskWorkerPool(
+ task_runner, task_graph_runner, resource_provider));
+}
+
+ZeroCopyTileTaskWorkerPool::ZeroCopyTileTaskWorkerPool(
+ base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider)
+ : task_runner_(task_runner),
+ task_graph_runner_(task_graph_runner),
+ namespace_token_(task_graph_runner->GetNamespaceToken()),
+ resource_provider_(resource_provider),
+ task_set_finished_weak_ptr_factory_(this) {
+}
+
+ZeroCopyTileTaskWorkerPool::~ZeroCopyTileTaskWorkerPool() {
+}
+
+TileTaskRunner* ZeroCopyTileTaskWorkerPool::AsTileTaskRunner() {
+ return this;
+}
+
+void ZeroCopyTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) {
+ client_ = client;
+}
+
+void ZeroCopyTileTaskWorkerPool::Shutdown() {
+ TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::Shutdown");
+
+ TaskGraph empty;
+ task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
+ task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
+}
+
+void ZeroCopyTileTaskWorkerPool::ScheduleTasks(TileTaskQueue* queue) {
+ TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::ScheduleTasks");
+
+ if (tasks_pending_.none())
+ TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
+
+ // Mark all task sets as pending.
+ tasks_pending_.set();
+
+ unsigned priority = kTileTaskPriorityBase;
+
+ graph_.Reset();
+
+ // Cancel existing OnTaskSetFinished callbacks.
+ task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
+
+ scoped_refptr<TileTask> new_task_set_finished_tasks[kNumberOfTaskSets];
+
+ size_t task_count[kNumberOfTaskSets] = {0};
+
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
+ new_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask(
+ task_runner_.get(),
+ base::Bind(&ZeroCopyTileTaskWorkerPool::OnTaskSetFinished,
+ task_set_finished_weak_ptr_factory_.GetWeakPtr(), task_set));
+ }
+
+ for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+ it != queue->items.end(); ++it) {
+ const TileTaskQueue::Item& item = *it;
+ RasterTask* task = item.task;
+ DCHECK(!task->HasCompleted());
+
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
+ if (!item.task_sets[task_set])
+ continue;
+
+ ++task_count[task_set];
+
+ graph_.edges.push_back(
+ TaskGraph::Edge(task, new_task_set_finished_tasks[task_set].get()));
+ }
+
+ InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
+ }
+
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
+ InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(),
+ kTaskSetFinishedTaskPriority, task_count[task_set]);
+ }
+
+ ScheduleTasksOnOriginThread(this, &graph_);
+ task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
+
+ std::copy(new_task_set_finished_tasks,
+ new_task_set_finished_tasks + kNumberOfTaskSets,
+ task_set_finished_tasks_);
+
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
+ StateAsValue());
+}
+
+void ZeroCopyTileTaskWorkerPool::CheckForCompletedTasks() {
+ TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::CheckForCompletedTasks");
+
+ task_graph_runner_->CollectCompletedTasks(namespace_token_,
+ &completed_tasks_);
+ for (Task::Vector::const_iterator it = completed_tasks_.begin();
+ it != completed_tasks_.end(); ++it) {
+ TileTask* task = static_cast<TileTask*>(it->get());
+
+ task->WillComplete();
+ task->CompleteOnOriginThread(this);
+ task->DidComplete();
+
+ task->RunReplyOnOriginThread();
+ }
+ completed_tasks_.clear();
+}
+
+scoped_ptr<RasterBuffer> ZeroCopyTileTaskWorkerPool::AcquireBufferForRaster(
+ const Resource* resource) {
+ return make_scoped_ptr<RasterBuffer>(
+ new RasterBufferImpl(resource_provider_, resource));
+}
+
+void ZeroCopyTileTaskWorkerPool::ReleaseBufferForRaster(
+ scoped_ptr<RasterBuffer> buffer) {
+ // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
+}
+
+void ZeroCopyTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) {
+ TRACE_EVENT1("cc", "ZeroCopyTileTaskWorkerPool::OnTaskSetFinished",
+ "task_set", task_set);
+
+ DCHECK(tasks_pending_[task_set]);
+ tasks_pending_[task_set] = false;
+ if (tasks_pending_.any()) {
+ TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running",
+ "state", StateAsValue());
+ } else {
+ TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
+ }
+ client_->DidFinishRunningTileTasks(task_set);
+}
+
+scoped_refptr<base::debug::ConvertableToTraceFormat>
+ZeroCopyTileTaskWorkerPool::StateAsValue() const {
+ scoped_refptr<base::debug::TracedValue> state =
+ new base::debug::TracedValue();
+
+ state->BeginArray("tasks_pending");
+ for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set)
+ state->AppendBoolean(tasks_pending_[task_set]);
+ state->EndArray();
+ return state;
+}
+
+} // namespace cc
diff --git a/cc/resources/zero_copy_tile_task_worker_pool.h b/cc/resources/zero_copy_tile_task_worker_pool.h
new file mode 100644
index 0000000..9cc5ee9
--- /dev/null
+++ b/cc/resources/zero_copy_tile_task_worker_pool.h
@@ -0,0 +1,79 @@
+// 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 CC_RESOURCES_ZERO_COPY_TILE_TASK_WORKER_POOL_H_
+#define CC_RESOURCES_ZERO_COPY_TILE_TASK_WORKER_POOL_H_
+
+#include "base/memory/weak_ptr.h"
+#include "base/values.h"
+#include "cc/resources/tile_task_runner.h"
+#include "cc/resources/tile_task_worker_pool.h"
+
+namespace base {
+namespace debug {
+class ConvertableToTraceFormat;
+}
+}
+
+namespace cc {
+class ResourceProvider;
+
+class CC_EXPORT ZeroCopyTileTaskWorkerPool : public TileTaskWorkerPool,
+ public TileTaskRunner,
+ public TileTaskClient {
+ public:
+ ~ZeroCopyTileTaskWorkerPool() override;
+
+ static scoped_ptr<TileTaskWorkerPool> Create(
+ base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider);
+
+ // Overridden from TileTaskWorkerPool:
+ TileTaskRunner* AsTileTaskRunner() override;
+
+ // Overridden from TileTaskRunner:
+ void SetClient(TileTaskRunnerClient* client) override;
+ void Shutdown() override;
+ void ScheduleTasks(TileTaskQueue* queue) override;
+ void CheckForCompletedTasks() override;
+
+ // Overridden from TileTaskClient:
+ scoped_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource) override;
+ void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
+
+ protected:
+ ZeroCopyTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
+ TaskGraphRunner* task_graph_runner,
+ ResourceProvider* resource_provider);
+
+ private:
+ void OnTaskSetFinished(TaskSet task_set);
+ scoped_refptr<base::debug::ConvertableToTraceFormat> StateAsValue() const;
+
+ scoped_refptr<base::SequencedTaskRunner> task_runner_;
+ TaskGraphRunner* task_graph_runner_;
+ const NamespaceToken namespace_token_;
+ TileTaskRunnerClient* client_;
+ ResourceProvider* resource_provider_;
+
+ TaskSetCollection tasks_pending_;
+
+ scoped_refptr<TileTask> task_set_finished_tasks_[kNumberOfTaskSets];
+
+ // Task graph used when scheduling tasks and vector used to gather
+ // completed tasks.
+ TaskGraph graph_;
+ Task::Vector completed_tasks_;
+
+ base::WeakPtrFactory<ZeroCopyTileTaskWorkerPool>
+ task_set_finished_weak_ptr_factory_;
+
+ DISALLOW_COPY_AND_ASSIGN(ZeroCopyTileTaskWorkerPool);
+};
+
+} // namespace cc
+
+#endif // CC_RESOURCES_ZERO_COPY_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/scheduler/begin_frame_source.cc b/cc/scheduler/begin_frame_source.cc
index 89b794e..8ef3b67 100644
--- a/cc/scheduler/begin_frame_source.cc
+++ b/cc/scheduler/begin_frame_source.cc
@@ -146,9 +146,9 @@
BackToBackBeginFrameSource::BackToBackBeginFrameSource(
base::SingleThreadTaskRunner* task_runner)
: BeginFrameSourceMixIn(),
- weak_factory_(this),
task_runner_(task_runner),
- send_begin_frame_posted_(false) {
+ send_begin_frame_posted_(false),
+ weak_factory_(this) {
DCHECK(task_runner);
DCHECK_EQ(needs_begin_frames_, false);
DCHECK_EQ(send_begin_frame_posted_, false);
diff --git a/cc/scheduler/begin_frame_source.h b/cc/scheduler/begin_frame_source.h
index 28359d3..d3dd9de 100644
--- a/cc/scheduler/begin_frame_source.h
+++ b/cc/scheduler/begin_frame_source.h
@@ -185,7 +185,6 @@
base::SingleThreadTaskRunner* task_runner);
virtual base::TimeTicks Now(); // Now overridable for testing
- base::WeakPtrFactory<BackToBackBeginFrameSource> weak_factory_;
base::SingleThreadTaskRunner* task_runner_;
bool send_begin_frame_posted_;
@@ -194,6 +193,9 @@
void OnNeedsBeginFramesChange(bool needs_begin_frames) override;
void BeginFrame();
+
+ private:
+ base::WeakPtrFactory<BackToBackBeginFrameSource> weak_factory_;
};
// A frame source which is locked to an external parameters provides from a
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index 5a70ec6..3e7653f 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -224,9 +224,9 @@
ProcessScheduledActions();
}
-void Scheduler::SetNeedsManageTiles() {
- DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_MANAGE_TILES));
- state_machine_.SetNeedsManageTiles();
+void Scheduler::SetNeedsPrepareTiles() {
+ DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_PREPARE_TILES));
+ state_machine_.SetNeedsPrepareTiles();
ProcessScheduledActions();
}
@@ -266,8 +266,8 @@
ProcessScheduledActions();
}
-void Scheduler::DidManageTiles() {
- state_machine_.DidManageTiles();
+void Scheduler::DidPrepareTiles() {
+ state_machine_.DidPrepareTiles();
}
void Scheduler::DidLoseOutputSurface() {
@@ -711,8 +711,8 @@
case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
client_->ScheduledActionBeginOutputSurfaceCreation();
break;
- case SchedulerStateMachine::ACTION_MANAGE_TILES:
- client_->ScheduledActionManageTiles();
+ case SchedulerStateMachine::ACTION_PREPARE_TILES:
+ client_->ScheduledActionPrepareTiles();
break;
}
} while (action != SchedulerStateMachine::ACTION_NONE);
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index 1175d73..27dbee3 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -42,7 +42,7 @@
virtual void ScheduledActionCommit() = 0;
virtual void ScheduledActionActivateSyncTree() = 0;
virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
- virtual void ScheduledActionManageTiles() = 0;
+ virtual void ScheduledActionPrepareTiles() = 0;
virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
virtual base::TimeDelta DrawDurationEstimate() = 0;
virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() = 0;
@@ -119,7 +119,7 @@
void SetNeedsAnimate();
- void SetNeedsManageTiles();
+ void SetNeedsPrepareTiles();
void SetMaxSwapsPending(int max);
void DidSwapBuffers();
@@ -130,7 +130,7 @@
void NotifyReadyToCommit();
void BeginMainFrameAborted(bool did_handle);
- void DidManageTiles();
+ void DidPrepareTiles();
void DidLoseOutputSurface();
void DidCreateAndInitializeOutputSurface();
@@ -143,8 +143,8 @@
bool CommitPending() const { return state_machine_.CommitPending(); }
bool RedrawPending() const { return state_machine_.RedrawPending(); }
- bool ManageTilesPending() const {
- return state_machine_.ManageTilesPending();
+ bool PrepareTilesPending() const {
+ return state_machine_.PrepareTilesPending();
}
bool MainThreadIsInHighLatencyMode() const {
return state_machine_.MainThreadIsInHighLatencyMode();
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index 8e87c0f..dc3fa36 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -26,13 +26,13 @@
last_frame_number_swap_performed_(-1),
last_frame_number_swap_requested_(-1),
last_frame_number_begin_main_frame_sent_(-1),
- manage_tiles_funnel_(0),
+ prepare_tiles_funnel_(0),
consecutive_checkerboard_animations_(0),
max_pending_swaps_(1),
pending_swaps_(0),
needs_redraw_(false),
needs_animate_(false),
- needs_manage_tiles_(false),
+ needs_prepare_tiles_(false),
needs_commit_(false),
inside_poll_for_anticipated_draw_triggers_(false),
visible_(false),
@@ -140,8 +140,8 @@
return "ACTION_DRAW_AND_SWAP_ABORT";
case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION";
- case ACTION_MANAGE_TILES:
- return "ACTION_MANAGE_TILES";
+ case ACTION_PREPARE_TILES:
+ return "ACTION_PREPARE_TILES";
}
NOTREACHED();
return "???";
@@ -206,14 +206,14 @@
state->SetInteger("last_frame_number_begin_main_frame_sent",
last_frame_number_begin_main_frame_sent_);
- state->SetInteger("manage_tiles_funnel", manage_tiles_funnel_);
+ state->SetInteger("prepare_tiles_funnel", prepare_tiles_funnel_);
state->SetInteger("consecutive_checkerboard_animations",
consecutive_checkerboard_animations_);
state->SetInteger("max_pending_swaps_", max_pending_swaps_);
state->SetInteger("pending_swaps_", pending_swaps_);
state->SetBoolean("needs_redraw", needs_redraw_);
state->SetBoolean("needs_animate_", needs_animate_);
- state->SetBoolean("needs_manage_tiles", needs_manage_tiles_);
+ state->SetBoolean("needs_prepare_tiles", needs_prepare_tiles_);
state->SetBoolean("needs_commit", needs_commit_);
state->SetBoolean("visible", visible_);
state->SetBoolean("can_start", can_start_);
@@ -244,9 +244,9 @@
void SchedulerStateMachine::AdvanceCurrentFrameNumber() {
current_frame_number_++;
- // "Drain" the ManageTiles funnel.
- if (manage_tiles_funnel_ > 0)
- manage_tiles_funnel_--;
+ // "Drain" the PrepareTiles funnel.
+ if (prepare_tiles_funnel_ > 0)
+ prepare_tiles_funnel_--;
skip_begin_main_frame_to_reduce_latency_ =
skip_next_begin_main_frame_to_reduce_latency_;
@@ -481,20 +481,20 @@
return true;
}
-bool SchedulerStateMachine::ShouldManageTiles() const {
- // ManageTiles only really needs to be called immediately after commit
+bool SchedulerStateMachine::ShouldPrepareTiles() const {
+ // PrepareTiles only really needs to be called immediately after commit
// and then periodically after that. Use a funnel to make sure we average
- // one ManageTiles per BeginImplFrame in the long run.
- if (manage_tiles_funnel_ > 0)
+ // one PrepareTiles per BeginImplFrame in the long run.
+ if (prepare_tiles_funnel_ > 0)
return false;
// Limiting to once per-frame is not enough, since we only want to
- // manage tiles _after_ draws. Polling for draw triggers and
+ // prepare tiles _after_ draws. Polling for draw triggers and
// begin-frame are mutually exclusive, so we limit to these two cases.
if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
!inside_poll_for_anticipated_draw_triggers_)
return false;
- return needs_manage_tiles_;
+ return needs_prepare_tiles_;
}
SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
@@ -512,8 +512,8 @@
else
return ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
}
- if (ShouldManageTiles())
- return ACTION_MANAGE_TILES;
+ if (ShouldPrepareTiles())
+ return ACTION_PREPARE_TILES;
if (ShouldSendBeginMainFrame())
return ACTION_SEND_BEGIN_MAIN_FRAME;
if (ShouldBeginOutputSurfaceCreation())
@@ -580,8 +580,8 @@
DCHECK(!active_tree_needs_first_draw_);
return;
- case ACTION_MANAGE_TILES:
- UpdateStateOnManageTiles();
+ case ACTION_PREPARE_TILES:
+ UpdateStateOnPrepareTiles();
return;
}
}
@@ -673,8 +673,8 @@
last_frame_number_swap_requested_ = current_frame_number_;
}
-void SchedulerStateMachine::UpdateStateOnManageTiles() {
- needs_manage_tiles_ = false;
+void SchedulerStateMachine::UpdateStateOnPrepareTiles() {
+ needs_prepare_tiles_ = false;
}
void SchedulerStateMachine::SetSkipNextBeginMainFrameToReduceLatency() {
@@ -779,7 +779,7 @@
// Changing priorities may allow us to activate (given the new priorities),
// which may result in a new frame.
- if (needs_manage_tiles_)
+ if (needs_prepare_tiles_)
return true;
// If we just sent a swap request, it's likely that we are going to produce
@@ -939,11 +939,10 @@
needs_animate_ = true;
}
-void SchedulerStateMachine::SetNeedsManageTiles() {
- if (!needs_manage_tiles_) {
- TRACE_EVENT0("cc",
- "SchedulerStateMachine::SetNeedsManageTiles");
- needs_manage_tiles_ = true;
+void SchedulerStateMachine::SetNeedsPrepareTiles() {
+ if (!needs_prepare_tiles_) {
+ TRACE_EVENT0("cc", "SchedulerStateMachine::SetNeedsPrepareTiles");
+ needs_prepare_tiles_ = true;
}
}
@@ -1037,10 +1036,10 @@
}
}
-void SchedulerStateMachine::DidManageTiles() {
- needs_manage_tiles_ = false;
- // "Fill" the ManageTiles funnel.
- manage_tiles_funnel_++;
+void SchedulerStateMachine::DidPrepareTiles() {
+ needs_prepare_tiles_ = false;
+ // "Fill" the PrepareTiles funnel.
+ prepare_tiles_funnel_++;
}
void SchedulerStateMachine::DidLoseOutputSurface() {
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index 6e30694..7ee039a 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -97,7 +97,7 @@
CommitState commit_state() const { return commit_state_; }
bool RedrawPending() const { return needs_redraw_; }
- bool ManageTilesPending() const { return needs_manage_tiles_; }
+ bool PrepareTilesPending() const { return needs_prepare_tiles_; }
enum Action {
ACTION_NONE,
@@ -109,7 +109,7 @@
ACTION_DRAW_AND_SWAP_FORCED,
ACTION_DRAW_AND_SWAP_ABORT,
ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
- ACTION_MANAGE_TILES,
+ ACTION_PREPARE_TILES,
};
static const char* ActionToString(Action action);
@@ -165,9 +165,9 @@
void SetNeedsAnimate();
bool needs_animate() const { return needs_animate_; }
- // Indicates that manage-tiles is required. This guarantees another
- // ManageTiles will occur shortly (even if no redraw is required).
- void SetNeedsManageTiles();
+ // Indicates that prepare-tiles is required. This guarantees another
+ // PrepareTiles will occur shortly (even if no redraw is required).
+ void SetNeedsPrepareTiles();
// Sets how many swaps can be pending to the OutputSurface.
void SetMaxSwapsPending(int max);
@@ -230,7 +230,7 @@
return active_tree_needs_first_draw_;
}
- void DidManageTiles();
+ void DidPrepareTiles();
void DidLoseOutputSurface();
void DidCreateAndInitializeOutputSurface();
bool HasInitializedOutputSurface() const;
@@ -278,7 +278,7 @@
bool ShouldActivatePendingTree() const;
bool ShouldSendBeginMainFrame() const;
bool ShouldCommit() const;
- bool ShouldManageTiles() const;
+ bool ShouldPrepareTiles() const;
void AdvanceCurrentFrameNumber();
bool HasAnimatedThisFrame() const;
@@ -289,7 +289,7 @@
void UpdateStateOnCommit(bool commit_was_aborted);
void UpdateStateOnActivation();
void UpdateStateOnDraw(bool did_request_swap);
- void UpdateStateOnManageTiles();
+ void UpdateStateOnPrepareTiles();
const SchedulerSettings settings_;
@@ -307,17 +307,17 @@
int last_frame_number_swap_requested_;
int last_frame_number_begin_main_frame_sent_;
- // manage_tiles_funnel_ is "filled" each time ManageTiles is called
+ // prepare_tiles_funnel_ is "filled" each time PrepareTiles is called
// and "drained" on each BeginImplFrame. If the funnel gets too full,
- // we start throttling ACTION_MANAGE_TILES such that we average one
- // ManageTile per BeginImplFrame.
- int manage_tiles_funnel_;
+ // we start throttling ACTION_PREPARE_TILES such that we average one
+ // PrepareTiles per BeginImplFrame.
+ int prepare_tiles_funnel_;
int consecutive_checkerboard_animations_;
int max_pending_swaps_;
int pending_swaps_;
bool needs_redraw_;
bool needs_animate_;
- bool needs_manage_tiles_;
+ bool needs_prepare_tiles_;
bool needs_commit_;
bool inside_poll_for_anticipated_draw_triggers_;
bool visible_;
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index 0997049..46242e3 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -263,8 +263,8 @@
actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
states_.push_back(scheduler_->AsValue());
}
- void ScheduledActionManageTiles() override {
- actions_.push_back("ScheduledActionManageTiles");
+ void ScheduledActionPrepareTiles() override {
+ actions_.push_back("ScheduledActionPrepareTiles");
states_.push_back(scheduler_->AsValue());
}
void DidAnticipatedDrawTimeChange(base::TimeTicks) override {
@@ -808,17 +808,17 @@
EXPECT_EQ(2, client.num_draws());
}
-class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
+class SchedulerClientNeedsPrepareTilesInDraw : public FakeSchedulerClient {
public:
DrawResult ScheduledActionDrawAndSwapIfPossible() override {
- scheduler_->SetNeedsManageTiles();
+ scheduler_->SetNeedsPrepareTiles();
return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
}
};
-// Test manage tiles is independant of draws.
-TEST(SchedulerTest, ManageTiles) {
- SchedulerClientNeedsManageTilesInDraw client;
+// Test prepare tiles is independant of draws.
+TEST(SchedulerTest, PrepareTiles) {
+ SchedulerClientNeedsPrepareTilesInDraw client;
SchedulerSettings scheduler_settings;
scheduler_settings.use_external_begin_frame_source = true;
TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
@@ -827,16 +827,16 @@
scheduler->SetCanDraw(true);
InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
- // Request both draw and manage tiles. ManageTiles shouldn't
+ // Request both draw and prepare tiles. PrepareTiles shouldn't
// be trigged until BeginImplFrame.
client.Reset();
- scheduler->SetNeedsManageTiles();
+ scheduler->SetNeedsPrepareTiles();
scheduler->SetNeedsRedraw();
EXPECT_TRUE(scheduler->RedrawPending());
- EXPECT_TRUE(scheduler->ManageTilesPending());
+ EXPECT_TRUE(scheduler->PrepareTilesPending());
EXPECT_TRUE(client.needs_begin_frames());
EXPECT_EQ(0, client.num_draws());
- EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_FALSE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
// We have no immediate actions to perform, so the BeginImplFrame should post
@@ -852,18 +852,18 @@
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(1, client.num_draws());
EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_TRUE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
- client.ActionIndex("ScheduledActionManageTiles"));
+ client.ActionIndex("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->RedrawPending());
- EXPECT_FALSE(scheduler->ManageTilesPending());
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
- // Request a draw. We don't need a ManageTiles yet.
+ // Request a draw. We don't need a PrepareTiles yet.
client.Reset();
scheduler->SetNeedsRedraw();
EXPECT_TRUE(scheduler->RedrawPending());
- EXPECT_FALSE(scheduler->ManageTilesPending());
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
EXPECT_TRUE(client.needs_begin_frames());
EXPECT_EQ(0, client.num_draws());
@@ -875,18 +875,18 @@
EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
- // Draw. The draw will trigger SetNeedsManageTiles, and
- // then the ManageTiles action will be triggered after the Draw.
- // Afterwards, neither a draw nor ManageTiles are pending.
+ // Draw. The draw will trigger SetNeedsPrepareTiles, and
+ // then the PrepareTiles action will be triggered after the Draw.
+ // Afterwards, neither a draw nor PrepareTiles are pending.
client.Reset();
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(1, client.num_draws());
EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_TRUE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
- client.ActionIndex("ScheduledActionManageTiles"));
+ client.ActionIndex("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->RedrawPending());
- EXPECT_FALSE(scheduler->ManageTilesPending());
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
// We need a BeginImplFrame where we don't swap to go idle.
@@ -900,16 +900,16 @@
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
EXPECT_EQ(0, client.num_draws());
- // Now trigger a ManageTiles outside of a draw. We will then need
- // a begin-frame for the ManageTiles, but we don't need a draw.
+ // Now trigger a PrepareTiles outside of a draw. We will then need
+ // a begin-frame for the PrepareTiles, but we don't need a draw.
client.Reset();
EXPECT_FALSE(client.needs_begin_frames());
- scheduler->SetNeedsManageTiles();
+ scheduler->SetNeedsPrepareTiles();
EXPECT_TRUE(client.needs_begin_frames());
- EXPECT_TRUE(scheduler->ManageTilesPending());
+ EXPECT_TRUE(scheduler->PrepareTilesPending());
EXPECT_FALSE(scheduler->RedrawPending());
- // BeginImplFrame. There will be no draw, only ManageTiles.
+ // BeginImplFrame. There will be no draw, only PrepareTiles.
client.Reset();
client.AdvanceFrame();
EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
@@ -918,13 +918,13 @@
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(0, client.num_draws());
EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_TRUE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
}
-// Test that ManageTiles only happens once per frame. If an external caller
-// initiates it, then the state machine should not ManageTiles on that frame.
-TEST(SchedulerTest, ManageTilesOncePerFrame) {
+// Test that PrepareTiles only happens once per frame. If an external caller
+// initiates it, then the state machine should not PrepareTiles on that frame.
+TEST(SchedulerTest, PrepareTilesOncePerFrame) {
FakeSchedulerClient client;
SchedulerSettings scheduler_settings;
scheduler_settings.use_external_begin_frame_source = true;
@@ -934,8 +934,9 @@
scheduler->SetCanDraw(true);
InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
- // If DidManageTiles during a frame, then ManageTiles should not occur again.
- scheduler->SetNeedsManageTiles();
+ // If DidPrepareTiles during a frame, then PrepareTiles should not occur
+ // again.
+ scheduler->SetNeedsPrepareTiles();
scheduler->SetNeedsRedraw();
client.Reset();
client.AdvanceFrame();
@@ -943,21 +944,21 @@
EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
- EXPECT_TRUE(scheduler->ManageTilesPending());
- scheduler->DidManageTiles(); // An explicit ManageTiles.
- EXPECT_FALSE(scheduler->ManageTilesPending());
+ EXPECT_TRUE(scheduler->PrepareTilesPending());
+ scheduler->DidPrepareTiles(); // An explicit PrepareTiles.
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
client.Reset();
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(1, client.num_draws());
EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_FALSE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->RedrawPending());
- EXPECT_FALSE(scheduler->ManageTilesPending());
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
- // Next frame without DidManageTiles should ManageTiles with draw.
- scheduler->SetNeedsManageTiles();
+ // Next frame without DidPrepareTiles should PrepareTiles with draw.
+ scheduler->SetNeedsPrepareTiles();
scheduler->SetNeedsRedraw();
client.Reset();
client.AdvanceFrame();
@@ -969,18 +970,18 @@
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(1, client.num_draws());
EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_TRUE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
- client.ActionIndex("ScheduledActionManageTiles"));
+ client.ActionIndex("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->RedrawPending());
- EXPECT_FALSE(scheduler->ManageTilesPending());
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
- scheduler->DidManageTiles(); // Corresponds to ScheduledActionManageTiles
+ scheduler->DidPrepareTiles(); // Corresponds to ScheduledActionPrepareTiles
- // If we get another DidManageTiles within the same frame, we should
- // not ManageTiles on the next frame.
- scheduler->DidManageTiles(); // An explicit ManageTiles.
- scheduler->SetNeedsManageTiles();
+ // If we get another DidPrepareTiles within the same frame, we should
+ // not PrepareTiles on the next frame.
+ scheduler->DidPrepareTiles(); // An explicit PrepareTiles.
+ scheduler->SetNeedsPrepareTiles();
scheduler->SetNeedsRedraw();
client.Reset();
client.AdvanceFrame();
@@ -988,22 +989,23 @@
EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
- EXPECT_TRUE(scheduler->ManageTilesPending());
+ EXPECT_TRUE(scheduler->PrepareTilesPending());
client.Reset();
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(1, client.num_draws());
EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_FALSE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->RedrawPending());
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
- // If we get another DidManageTiles, we should not ManageTiles on the next
- // frame. This verifies we don't alternate calling ManageTiles once and twice.
- EXPECT_TRUE(scheduler->ManageTilesPending());
- scheduler->DidManageTiles(); // An explicit ManageTiles.
- EXPECT_FALSE(scheduler->ManageTilesPending());
- scheduler->SetNeedsManageTiles();
+ // If we get another DidPrepareTiles, we should not PrepareTiles on the next
+ // frame. This verifies we don't alternate calling PrepareTiles once and
+ // twice.
+ EXPECT_TRUE(scheduler->PrepareTilesPending());
+ scheduler->DidPrepareTiles(); // An explicit PrepareTiles.
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
+ scheduler->SetNeedsPrepareTiles();
scheduler->SetNeedsRedraw();
client.Reset();
client.AdvanceFrame();
@@ -1011,18 +1013,18 @@
EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
- EXPECT_TRUE(scheduler->ManageTilesPending());
+ EXPECT_TRUE(scheduler->PrepareTilesPending());
client.Reset();
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(1, client.num_draws());
EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_FALSE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->RedrawPending());
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
- // Next frame without DidManageTiles should ManageTiles with draw.
- scheduler->SetNeedsManageTiles();
+ // Next frame without DidPrepareTiles should PrepareTiles with draw.
+ scheduler->SetNeedsPrepareTiles();
scheduler->SetNeedsRedraw();
client.Reset();
client.AdvanceFrame();
@@ -1034,17 +1036,17 @@
client.task_runner().RunPendingTasks(); // Run posted deadline.
EXPECT_EQ(1, client.num_draws());
EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
- EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
+ EXPECT_TRUE(client.HasAction("ScheduledActionPrepareTiles"));
EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
- client.ActionIndex("ScheduledActionManageTiles"));
+ client.ActionIndex("ScheduledActionPrepareTiles"));
EXPECT_FALSE(scheduler->RedrawPending());
- EXPECT_FALSE(scheduler->ManageTilesPending());
+ EXPECT_FALSE(scheduler->PrepareTilesPending());
EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
- scheduler->DidManageTiles(); // Corresponds to ScheduledActionManageTiles
+ scheduler->DidPrepareTiles(); // Corresponds to ScheduledActionPrepareTiles
}
TEST(SchedulerTest, TriggerBeginFrameDeadlineEarly) {
- SchedulerClientNeedsManageTilesInDraw client;
+ SchedulerClientNeedsPrepareTilesInDraw client;
SchedulerSettings scheduler_settings;
scheduler_settings.use_external_begin_frame_source = true;
TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
@@ -1891,7 +1893,7 @@
DidLoseOutputSurfaceAfterReadyToCommit(true);
}
-TEST(SchedulerTest, DidLoseOutputSurfaceAfterSetNeedsManageTiles) {
+TEST(SchedulerTest, DidLoseOutputSurfaceAfterSetNeedsPrepareTiles) {
FakeSchedulerClient client;
SchedulerSettings scheduler_settings;
scheduler_settings.use_external_begin_frame_source = true;
@@ -1902,7 +1904,7 @@
InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
client.Reset();
- scheduler->SetNeedsManageTiles();
+ scheduler->SetNeedsPrepareTiles();
scheduler->SetNeedsRedraw();
EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client);
@@ -1918,7 +1920,7 @@
client.Reset();
client.task_runner().RunPendingTasks(); // Run posted deadline.
- EXPECT_ACTION("ScheduledActionManageTiles", client, 0, 2);
+ EXPECT_ACTION("ScheduledActionPrepareTiles", client, 0, 2);
EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client, 1, 2);
}
diff --git a/cc/test/fake_layer_tree_host_client.h b/cc/test/fake_layer_tree_host_client.h
index d64a5b2..6f24116 100644
--- a/cc/test/fake_layer_tree_host_client.h
+++ b/cc/test/fake_layer_tree_host_client.h
@@ -36,6 +36,7 @@
void Layout() override {}
void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
const gfx::Vector2d& outer_delta,
+ const gfx::Vector2dF& elastic_overscroll_delta,
float page_scale,
float top_controls_delta) override {}
void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
diff --git a/cc/test/fake_layer_tree_host_impl.h b/cc/test/fake_layer_tree_host_impl.h
index 7403c07..fe9bc4f 100644
--- a/cc/test/fake_layer_tree_host_impl.h
+++ b/cc/test/fake_layer_tree_host_impl.h
@@ -35,7 +35,7 @@
static int RecursiveUpdateNumChildren(LayerImpl* layer);
using LayerTreeHostImpl::ActivateSyncTree;
- using LayerTreeHostImpl::manage_tiles_needed;
+ using LayerTreeHostImpl::prepare_tiles_needed;
private:
BeginFrameArgs current_begin_frame_args_;
diff --git a/cc/test/fake_layer_tree_host_impl_client.h b/cc/test/fake_layer_tree_host_impl_client.h
index ced02a6..98aafa0 100644
--- a/cc/test/fake_layer_tree_host_impl_client.h
+++ b/cc/test/fake_layer_tree_host_impl_client.h
@@ -28,7 +28,7 @@
void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) override {}
void SetNeedsAnimateOnImplThread() override {}
void SetNeedsCommitOnImplThread() override {}
- void SetNeedsManageTilesOnImplThread() override {}
+ void SetNeedsPrepareTilesOnImplThread() override {}
void PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> events) override {}
bool ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes,
@@ -38,7 +38,7 @@
void PostDelayedScrollbarFadeOnImplThread(const base::Closure& start_fade,
base::TimeDelta delay) override {}
void DidActivateSyncTree() override {}
- void DidManageTiles() override {}
+ void DidPrepareTiles() override {}
};
} // namespace cc
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index 8aa343b..f85946a 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -9,22 +9,20 @@
#include "base/lazy_instance.h"
#include "cc/resources/raster_buffer.h"
-#include "cc/resources/rasterizer.h"
+#include "cc/resources/tile_task_runner.h"
namespace cc {
namespace {
-class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
+class FakeTileTaskRunnerImpl : public TileTaskRunner, public TileTaskClient {
public:
- // Overridden from Rasterizer:
- void SetClient(RasterizerClient* client) override {}
+ // Overridden from TileTaskRunner:
+ void SetClient(TileTaskRunnerClient* client) override {}
void Shutdown() override {}
- void ScheduleTasks(RasterTaskQueue* queue) override {
- for (RasterTaskQueue::Item::Vector::const_iterator it =
- queue->items.begin();
- it != queue->items.end();
- ++it) {
+ void ScheduleTasks(TileTaskQueue* queue) override {
+ for (TileTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
+ it != queue->items.end(); ++it) {
RasterTask* task = it->task;
task->WillSchedule();
@@ -49,7 +47,7 @@
completed_tasks_.clear();
}
- // Overridden from RasterizerTaskClient:
+ // Overridden from TileTaskClient:
scoped_ptr<RasterBuffer> AcquireBufferForRaster(
const Resource* resource) override {
return nullptr;
@@ -59,7 +57,7 @@
private:
RasterTask::Vector completed_tasks_;
};
-base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
+base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner =
LAZY_INSTANCE_INITIALIZER;
} // namespace
@@ -68,7 +66,7 @@
: TileManager(client,
base::MessageLoopProxy::current(),
NULL,
- g_fake_rasterizer.Pointer(),
+ g_fake_tile_task_runner.Pointer(),
NULL,
std::numeric_limits<size_t>::max()) {
}
@@ -78,7 +76,7 @@
: TileManager(client,
base::MessageLoopProxy::current(),
resource_pool,
- g_fake_rasterizer.Pointer(),
+ g_fake_tile_task_runner.Pointer(),
NULL,
std::numeric_limits<size_t>::max()) {
}
diff --git a/cc/test/geometry_test_utils.h b/cc/test/geometry_test_utils.h
index 38112a8..3f3197c 100644
--- a/cc/test/geometry_test_utils.h
+++ b/cc/test/geometry_test_utils.h
@@ -29,6 +29,13 @@
EXPECT_NEAR((expected).height(), (actual).height(), (abs_error)); \
} while (false)
+#define EXPECT_POINT3F_EQ(expected, actual) \
+do { \
+ EXPECT_FLOAT_EQ((expected).x(), (actual).x()); \
+ EXPECT_FLOAT_EQ((expected).y(), (actual).y()); \
+ EXPECT_FLOAT_EQ((expected).z(), (actual).z()); \
+} while (false)
+
#define EXPECT_VECTOR_EQ(expected, actual) \
do { \
EXPECT_EQ((expected).x(), (actual).x()); \
diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index 1839643..d5b5127 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc
@@ -5,13 +5,13 @@
#include "cc/test/layer_tree_pixel_resource_test.h"
#include "cc/layers/layer.h"
-#include "cc/resources/bitmap_raster_worker_pool.h"
-#include "cc/resources/gpu_raster_worker_pool.h"
-#include "cc/resources/one_copy_raster_worker_pool.h"
-#include "cc/resources/pixel_buffer_raster_worker_pool.h"
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/bitmap_tile_task_worker_pool.h"
+#include "cc/resources/gpu_tile_task_worker_pool.h"
+#include "cc/resources/one_copy_tile_task_worker_pool.h"
+#include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
#include "cc/resources/resource_pool.h"
-#include "cc/resources/zero_copy_raster_worker_pool.h"
+#include "cc/resources/tile_task_worker_pool.h"
+#include "cc/resources/zero_copy_tile_task_worker_pool.h"
#include "cc/test/fake_output_surface.h"
#include "gpu/GLES2/gl2extchromium.h"
@@ -46,7 +46,7 @@
PixelResourceTestCase test_case)
: staging_texture_target_(GL_INVALID_VALUE),
draw_texture_target_(GL_INVALID_VALUE),
- resource_pool_option_(BITMAP_RASTER_WORKER_POOL),
+ resource_pool_option_(BITMAP_TILE_TASK_WORKER_POOL),
test_case_(test_case) {
InitializeFromTestCase(test_case);
}
@@ -58,63 +58,63 @@
test_type_ = PIXEL_TEST_SOFTWARE;
staging_texture_target_ = GL_INVALID_VALUE;
draw_texture_target_ = GL_INVALID_VALUE;
- resource_pool_option_ = BITMAP_RASTER_WORKER_POOL;
+ resource_pool_option_ = BITMAP_TILE_TASK_WORKER_POOL;
return;
case GL_GPU_RASTER_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_INVALID_VALUE;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = GPU_RASTER_WORKER_POOL;
+ resource_pool_option_ = GPU_TILE_TASK_WORKER_POOL;
return;
case GL_ONE_COPY_2D_STAGING_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_TEXTURE_2D;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ONE_COPY_RASTER_WORKER_POOL;
+ resource_pool_option_ = ONE_COPY_TILE_TASK_WORKER_POOL;
return;
case GL_ONE_COPY_RECT_STAGING_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_TEXTURE_RECTANGLE_ARB;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ONE_COPY_RASTER_WORKER_POOL;
+ resource_pool_option_ = ONE_COPY_TILE_TASK_WORKER_POOL;
return;
case GL_ONE_COPY_EXTERNAL_STAGING_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_TEXTURE_EXTERNAL_OES;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ONE_COPY_RASTER_WORKER_POOL;
+ resource_pool_option_ = ONE_COPY_TILE_TASK_WORKER_POOL;
return;
case GL_ZERO_COPY_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_INVALID_VALUE;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ZERO_COPY_RASTER_WORKER_POOL;
+ resource_pool_option_ = ZERO_COPY_TILE_TASK_WORKER_POOL;
return;
case GL_ZERO_COPY_RECT_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_INVALID_VALUE;
draw_texture_target_ = GL_TEXTURE_RECTANGLE_ARB;
- resource_pool_option_ = ZERO_COPY_RASTER_WORKER_POOL;
+ resource_pool_option_ = ZERO_COPY_TILE_TASK_WORKER_POOL;
return;
case GL_ZERO_COPY_EXTERNAL_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_INVALID_VALUE;
draw_texture_target_ = GL_TEXTURE_EXTERNAL_OES;
- resource_pool_option_ = ZERO_COPY_RASTER_WORKER_POOL;
+ resource_pool_option_ = ZERO_COPY_TILE_TASK_WORKER_POOL;
return;
case GL_ASYNC_UPLOAD_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
staging_texture_target_ = GL_INVALID_VALUE;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = PIXEL_BUFFER_RASTER_WORKER_POOL;
+ resource_pool_option_ = PIXEL_BUFFER_TILE_TASK_WORKER_POOL;
return;
}
NOTREACHED();
}
-void LayerTreeHostPixelResourceTest::CreateResourceAndRasterWorkerPool(
+void LayerTreeHostPixelResourceTest::CreateResourceAndTileTaskWorkerPool(
LayerTreeHostImpl* host_impl,
- scoped_ptr<RasterWorkerPool>* raster_worker_pool,
+ scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool) {
base::SingleThreadTaskRunner* task_runner =
@@ -129,7 +129,7 @@
size_t max_transfer_buffer_usage_bytes = 1024u * 1024u * 60u;
switch (resource_pool_option_) {
- case BITMAP_RASTER_WORKER_POOL:
+ case BITMAP_TILE_TASK_WORKER_POOL:
EXPECT_FALSE(context_provider);
EXPECT_EQ(PIXEL_TEST_SOFTWARE, test_type_);
*resource_pool =
@@ -137,12 +137,11 @@
draw_texture_target_,
resource_provider->best_texture_format());
- *raster_worker_pool =
- BitmapRasterWorkerPool::Create(task_runner,
- RasterWorkerPool::GetTaskGraphRunner(),
- resource_provider);
+ *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
+ resource_provider);
break;
- case GPU_RASTER_WORKER_POOL:
+ case GPU_TILE_TASK_WORKER_POOL:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
*resource_pool =
@@ -150,13 +149,11 @@
draw_texture_target_,
resource_provider->best_texture_format());
- *raster_worker_pool =
- GpuRasterWorkerPool::Create(task_runner,
- context_provider,
- resource_provider,
- use_distance_field_text);
+ *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
+ task_runner, context_provider, resource_provider,
+ use_distance_field_text);
break;
- case ZERO_COPY_RASTER_WORKER_POOL:
+ case ZERO_COPY_TILE_TASK_WORKER_POOL:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
EXPECT_TRUE(host_impl->GetRendererCapabilities().using_image);
@@ -165,12 +162,11 @@
draw_texture_target_,
resource_provider->best_texture_format());
- *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
- task_runner,
- RasterWorkerPool::GetTaskGraphRunner(),
+ *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
resource_provider);
break;
- case ONE_COPY_RASTER_WORKER_POOL:
+ case ONE_COPY_TILE_TASK_WORKER_POOL:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
EXPECT_TRUE(host_impl->GetRendererCapabilities().using_image);
@@ -184,14 +180,11 @@
draw_texture_target_,
resource_provider->best_texture_format());
- *raster_worker_pool = OneCopyRasterWorkerPool::Create(
- task_runner,
- RasterWorkerPool::GetTaskGraphRunner(),
- context_provider,
- resource_provider,
- staging_resource_pool->get());
+ *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
+ context_provider, resource_provider, staging_resource_pool->get());
break;
- case PIXEL_BUFFER_RASTER_WORKER_POOL:
+ case PIXEL_BUFFER_TILE_TASK_WORKER_POOL:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
*resource_pool = ResourcePool::Create(
@@ -199,12 +192,9 @@
draw_texture_target_,
resource_provider->memory_efficient_texture_format());
- *raster_worker_pool = PixelBufferRasterWorkerPool::Create(
- task_runner,
- RasterWorkerPool::GetTaskGraphRunner(),
- context_provider,
- resource_provider,
- max_transfer_buffer_usage_bytes);
+ *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
+ context_provider, resource_provider, max_transfer_buffer_usage_bytes);
break;
}
}
diff --git a/cc/test/layer_tree_pixel_resource_test.h b/cc/test/layer_tree_pixel_resource_test.h
index da3da25..08900a2 100644
--- a/cc/test/layer_tree_pixel_resource_test.h
+++ b/cc/test/layer_tree_pixel_resource_test.h
@@ -11,7 +11,7 @@
namespace cc {
class LayerTreeHostImpl;
-class RasterWorkerPool;
+class TileTaskWorkerPool;
class ResourcePool;
// Enumerate the various combinations of renderer, resource pool, staging
@@ -34,27 +34,27 @@
public:
explicit LayerTreeHostPixelResourceTest(PixelResourceTestCase test_case);
- void CreateResourceAndRasterWorkerPool(
+ void CreateResourceAndTileTaskWorkerPool(
LayerTreeHostImpl* host_impl,
- scoped_ptr<RasterWorkerPool>* raster_worker_pool,
+ scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool) override;
void RunPixelResourceTest(scoped_refptr<Layer> content_root,
base::FilePath file_name);
- enum RasterWorkerPoolOption {
- BITMAP_RASTER_WORKER_POOL,
- GPU_RASTER_WORKER_POOL,
- ZERO_COPY_RASTER_WORKER_POOL,
- ONE_COPY_RASTER_WORKER_POOL,
- PIXEL_BUFFER_RASTER_WORKER_POOL,
+ enum TileTaskWorkerPoolOption {
+ BITMAP_TILE_TASK_WORKER_POOL,
+ GPU_TILE_TASK_WORKER_POOL,
+ ZERO_COPY_TILE_TASK_WORKER_POOL,
+ ONE_COPY_TILE_TASK_WORKER_POOL,
+ PIXEL_BUFFER_TILE_TASK_WORKER_POOL,
};
protected:
unsigned staging_texture_target_;
unsigned draw_texture_target_;
- RasterWorkerPoolOption resource_pool_option_;
+ TileTaskWorkerPoolOption resource_pool_option_;
private:
void InitializeFromTestCase(PixelResourceTestCase test_case);
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 5be1240..d6411ec 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -45,13 +45,13 @@
return draw_result;
}
-void TestHooks::CreateResourceAndRasterWorkerPool(
+void TestHooks::CreateResourceAndTileTaskWorkerPool(
LayerTreeHostImpl* host_impl,
- scoped_ptr<RasterWorkerPool>* raster_worker_pool,
+ scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool) {
- host_impl->LayerTreeHostImpl::CreateResourceAndRasterWorkerPool(
- raster_worker_pool, resource_pool, staging_resource_pool);
+ host_impl->LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
+ tile_task_worker_pool, resource_pool, staging_resource_pool);
}
class ExternalBeginFrameSourceForTest
@@ -153,9 +153,9 @@
test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
}
- void ScheduledActionManageTiles() override {
- ThreadProxy::ScheduledActionManageTiles();
- test_hooks_->ScheduledActionManageTiles();
+ void ScheduledActionPrepareTiles() override {
+ ThreadProxy::ScheduledActionPrepareTiles();
+ test_hooks_->ScheduledActionPrepareTiles();
}
ThreadProxyForTest(
@@ -211,12 +211,12 @@
block_notify_ready_to_activate_for_testing_(false),
notify_ready_to_activate_was_blocked_(false) {}
- void CreateResourceAndRasterWorkerPool(
- scoped_ptr<RasterWorkerPool>* raster_worker_pool,
+ void CreateResourceAndTileTaskWorkerPool(
+ scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool) override {
- test_hooks_->CreateResourceAndRasterWorkerPool(
- this, raster_worker_pool, resource_pool, staging_resource_pool);
+ test_hooks_->CreateResourceAndTileTaskWorkerPool(
+ this, tile_task_worker_pool, resource_pool, staging_resource_pool);
}
void WillBeginImplFrame(const BeginFrameArgs& args) override {
@@ -362,11 +362,11 @@
void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
const gfx::Vector2d& outer_delta,
+ const gfx::Vector2dF& elastic_overscroll_delta,
float page_scale,
float top_controls_delta) override {
- test_hooks_->ApplyViewportDeltas(inner_delta,
- outer_delta,
- page_scale,
+ test_hooks_->ApplyViewportDeltas(inner_delta, outer_delta,
+ elastic_overscroll_delta, page_scale,
top_controls_delta);
}
void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index 863100b..4176265 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -35,9 +35,9 @@
void ReadSettings(const LayerTreeSettings& settings);
- virtual void CreateResourceAndRasterWorkerPool(
+ virtual void CreateResourceAndTileTaskWorkerPool(
LayerTreeHostImpl* host_impl,
- scoped_ptr<RasterWorkerPool>* raster_worker_pool,
+ scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool);
virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
@@ -67,10 +67,12 @@
bool has_unfinished_animation) {}
virtual void WillAnimateLayers(LayerTreeHostImpl* host_impl,
base::TimeTicks monotonic_time) {}
- virtual void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
- const gfx::Vector2d& outer_delta,
- float scale,
- float top_controls_delta) {}
+ virtual void ApplyViewportDeltas(
+ const gfx::Vector2d& inner_delta,
+ const gfx::Vector2d& outer_delta,
+ const gfx::Vector2dF& elastic_overscroll_delta,
+ float scale,
+ float top_controls_delta) {}
virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
float scale,
float top_controls_delta) {}
@@ -98,7 +100,7 @@
virtual void ScheduledActionAnimate() {}
virtual void ScheduledActionCommit() {}
virtual void ScheduledActionBeginOutputSurfaceCreation() {}
- virtual void ScheduledActionManageTiles() {}
+ virtual void ScheduledActionPrepareTiles() {}
// Implementation of AnimationDelegate:
void NotifyAnimationStarted(base::TimeTicks monotonic_time,
diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc
index 76966e9..aecd657 100644
--- a/cc/test/pixel_test.cc
+++ b/cc/test/pixel_test.cc
@@ -15,9 +15,9 @@
#include "cc/output/gl_renderer.h"
#include "cc/output/output_surface_client.h"
#include "cc/output/software_renderer.h"
-#include "cc/resources/raster_worker_pool.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/texture_mailbox_deleter.h"
+#include "cc/resources/tile_task_worker_pool.h"
#include "cc/test/fake_output_surface_client.h"
#include "cc/test/paths.h"
#include "cc/test/pixel_test_output_surface.h"
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 22b1196..4d03449 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -1160,9 +1160,8 @@
// TODO(ccameron): pass the elastic overscroll here so that input events
// may be translated appropriately.
client_->ApplyViewportDeltas(
- inner_viewport_scroll_delta,
- outer_viewport_scroll_delta,
- info->page_scale_delta,
+ inner_viewport_scroll_delta, outer_viewport_scroll_delta,
+ info->elastic_overscroll_delta, info->page_scale_delta,
info->top_controls_delta);
}
}
diff --git a/cc/trees/layer_tree_host_client.h b/cc/trees/layer_tree_host_client.h
index 5b02964..5846343 100644
--- a/cc/trees/layer_tree_host_client.h
+++ b/cc/trees/layer_tree_host_client.h
@@ -11,6 +11,7 @@
namespace gfx {
class Vector2d;
+class Vector2dF;
}
namespace cc {
@@ -27,10 +28,12 @@
virtual void BeginMainFrame(const BeginFrameArgs& args) = 0;
virtual void DidBeginMainFrame() = 0;
virtual void Layout() = 0;
- virtual void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
- const gfx::Vector2d& outer_delta,
- float page_scale,
- float top_controls_delta) = 0;
+ virtual void ApplyViewportDeltas(
+ const gfx::Vector2d& inner_delta,
+ const gfx::Vector2d& outer_delta,
+ const gfx::Vector2dF& elastic_overscroll_delta,
+ float page_scale,
+ float top_controls_delta) = 0;
virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
float page_scale,
float top_controls_delta) = 0;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index e19c9a2..dd485ba 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -47,20 +47,20 @@
#include "cc/quads/shared_quad_state.h"
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
-#include "cc/resources/bitmap_raster_worker_pool.h"
+#include "cc/resources/bitmap_tile_task_worker_pool.h"
#include "cc/resources/eviction_tile_priority_queue.h"
-#include "cc/resources/gpu_raster_worker_pool.h"
+#include "cc/resources/gpu_tile_task_worker_pool.h"
#include "cc/resources/memory_history.h"
-#include "cc/resources/one_copy_raster_worker_pool.h"
+#include "cc/resources/one_copy_tile_task_worker_pool.h"
#include "cc/resources/picture_layer_tiling.h"
-#include "cc/resources/pixel_buffer_raster_worker_pool.h"
+#include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
#include "cc/resources/prioritized_resource_manager.h"
#include "cc/resources/raster_tile_priority_queue.h"
-#include "cc/resources/raster_worker_pool.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/texture_mailbox_deleter.h"
+#include "cc/resources/tile_task_worker_pool.h"
#include "cc/resources/ui_resource_bitmap.h"
-#include "cc/resources/zero_copy_raster_worker_pool.h"
+#include "cc/resources/zero_copy_tile_task_worker_pool.h"
#include "cc/scheduler/delay_based_time_source.h"
#include "cc/trees/damage_tracker.h"
#include "cc/trees/layer_tree_host.h"
@@ -309,7 +309,7 @@
sync_tree()->UpdateDrawProperties();
// Start working on newly created tiles immediately if needed.
if (tile_manager_ && tile_priorities_dirty_)
- ManageTiles();
+ PrepareTiles();
else
NotifyReadyToActivate();
} else {
@@ -382,16 +382,16 @@
AnimateTopControls(monotonic_time);
}
-void LayerTreeHostImpl::ManageTiles() {
+void LayerTreeHostImpl::PrepareTiles() {
if (!tile_manager_)
return;
if (!tile_priorities_dirty_)
return;
tile_priorities_dirty_ = false;
- tile_manager_->ManageTiles(global_tile_state_);
+ tile_manager_->PrepareTiles(global_tile_state_);
- client_->DidManageTiles();
+ client_->DidPrepareTiles();
}
void LayerTreeHostImpl::StartPageScaleAnimation(
@@ -1186,9 +1186,9 @@
void LayerTreeHostImpl::DidModifyTilePriorities() {
DCHECK(settings_.impl_side_painting);
- // Mark priorities as dirty and schedule a ManageTiles().
+ // Mark priorities as dirty and schedule a PrepareTiles().
tile_priorities_dirty_ = true;
- client_->SetNeedsManageTilesOnImplThread();
+ client_->SetNeedsPrepareTilesOnImplThread();
}
void LayerTreeHostImpl::GetPictureLayerImplPairs(
@@ -1857,7 +1857,7 @@
// Evict tiles immediately if invisible since this tab may never get another
// draw or timer tick.
if (!visible_)
- ManageTiles();
+ PrepareTiles();
if (!renderer_)
return;
@@ -1950,9 +1950,9 @@
DCHECK(output_surface_);
DCHECK(resource_provider_);
- CreateResourceAndRasterWorkerPool(
- &raster_worker_pool_, &resource_pool_, &staging_resource_pool_);
- DCHECK(raster_worker_pool_);
+ CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_,
+ &staging_resource_pool_);
+ DCHECK(tile_task_worker_pool_);
DCHECK(resource_pool_);
base::SingleThreadTaskRunner* task_runner =
@@ -1962,18 +1962,16 @@
size_t scheduled_raster_task_limit =
IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max()
: settings_.scheduled_raster_task_limit;
- tile_manager_ = TileManager::Create(this,
- task_runner,
- resource_pool_.get(),
- raster_worker_pool_->AsRasterizer(),
- rendering_stats_instrumentation_,
- scheduled_raster_task_limit);
+ tile_manager_ = TileManager::Create(
+ this, task_runner, resource_pool_.get(),
+ tile_task_worker_pool_->AsTileTaskRunner(),
+ rendering_stats_instrumentation_, scheduled_raster_task_limit);
UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
}
-void LayerTreeHostImpl::CreateResourceAndRasterWorkerPool(
- scoped_ptr<RasterWorkerPool>* raster_worker_pool,
+void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
+ scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool) {
base::SingleThreadTaskRunner* task_runner =
@@ -1988,10 +1986,9 @@
GL_TEXTURE_2D,
resource_provider_->best_texture_format());
- *raster_worker_pool =
- BitmapRasterWorkerPool::Create(task_runner,
- RasterWorkerPool::GetTaskGraphRunner(),
- resource_provider_.get());
+ *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
+ resource_provider_.get());
return;
}
@@ -2001,11 +1998,9 @@
GL_TEXTURE_2D,
resource_provider_->best_texture_format());
- *raster_worker_pool =
- GpuRasterWorkerPool::Create(task_runner,
- context_provider,
- resource_provider_.get(),
- settings_.use_distance_field_text);
+ *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
+ task_runner, context_provider, resource_provider_.get(),
+ settings_.use_distance_field_text);
return;
}
@@ -2029,10 +2024,10 @@
single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
} else {
- task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
+ task_graph_runner = TileTaskWorkerPool::GetTaskGraphRunner();
}
- *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
+ *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
task_runner, task_graph_runner, resource_provider_.get());
return;
}
@@ -2046,9 +2041,10 @@
ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D,
resource_provider_->best_texture_format());
- *raster_worker_pool = OneCopyRasterWorkerPool::Create(
- task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
- resource_provider_.get(), staging_resource_pool_.get());
+ *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
+ context_provider, resource_provider_.get(),
+ staging_resource_pool_.get());
return;
}
}
@@ -2057,8 +2053,8 @@
resource_provider_.get(), GL_TEXTURE_2D,
resource_provider_->memory_efficient_texture_format());
- *raster_worker_pool = PixelBufferRasterWorkerPool::Create(
- task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
+ *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
+ task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), context_provider,
resource_provider_.get(),
GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
settings_.renderer_settings.refresh_rate));
@@ -2068,7 +2064,7 @@
tile_manager_ = nullptr;
resource_pool_ = nullptr;
staging_resource_pool_ = nullptr;
- raster_worker_pool_ = nullptr;
+ tile_task_worker_pool_ = nullptr;
single_thread_synchronous_task_graph_runner_ = nullptr;
}
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 1702e09..54a16aa 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -51,7 +51,7 @@
class PaintTimeCounter;
class PictureLayerImpl;
class RasterTilePriorityQueue;
-class RasterWorkerPool;
+class TileTaskWorkerPool;
class RenderPassDrawQuad;
class RenderingStatsInstrumentation;
class ResourcePool;
@@ -92,7 +92,7 @@
virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) = 0;
virtual void SetNeedsAnimateOnImplThread() = 0;
virtual void SetNeedsCommitOnImplThread() = 0;
- virtual void SetNeedsManageTilesOnImplThread() = 0;
+ virtual void SetNeedsPrepareTilesOnImplThread() = 0;
virtual void PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> events) = 0;
// Returns true if resources were deleted by this call.
@@ -105,7 +105,7 @@
const base::Closure& start_fade,
base::TimeDelta delay) = 0;
virtual void DidActivateSyncTree() = 0;
- virtual void DidManageTiles() = 0;
+ virtual void DidPrepareTiles() = 0;
protected:
virtual ~LayerTreeHostImplClient() {}
@@ -200,7 +200,7 @@
void DidAnimateScrollOffset();
void SetViewportDamage(const gfx::Rect& damage_rect);
- virtual void ManageTiles();
+ virtual void PrepareTiles();
// Returns DRAW_SUCCESS unless problems occured preparing the frame, and we
// should try to avoid displaying the frame. If PrepareToDraw is called,
@@ -499,8 +499,8 @@
// Only valid for synchronous (non-scheduled) single-threaded case.
void SynchronouslyInitializeAllTiles();
- virtual void CreateResourceAndRasterWorkerPool(
- scoped_ptr<RasterWorkerPool>* raster_worker_pool,
+ virtual void CreateResourceAndTileTaskWorkerPool(
+ scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
scoped_ptr<ResourcePool>* resource_pool,
scoped_ptr<ResourcePool>* staging_resource_pool);
@@ -523,7 +523,7 @@
return animation_registrar_->active_animation_controllers();
}
- bool manage_tiles_needed() const { return tile_priorities_dirty_; }
+ bool prepare_tiles_needed() const { return tile_priorities_dirty_; }
LayerTreeHostImplClient* client_;
Proxy* proxy_;
@@ -610,7 +610,7 @@
scoped_ptr<TileManager> tile_manager_;
bool use_gpu_rasterization_;
GpuRasterizationStatus gpu_rasterization_status_;
- scoped_ptr<RasterWorkerPool> raster_worker_pool_;
+ scoped_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
scoped_ptr<ResourcePool> resource_pool_;
scoped_ptr<ResourcePool> staging_resource_pool_;
scoped_ptr<Renderer> renderer_;
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 3ef9445..9049a84 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -86,7 +86,7 @@
did_request_commit_(false),
did_request_redraw_(false),
did_request_animate_(false),
- did_request_manage_tiles_(false),
+ did_request_prepare_tiles_(false),
reduce_memory_result_(true),
current_limit_bytes_(0),
current_priority_cutoff_value_(0) {
@@ -129,8 +129,8 @@
did_request_redraw_ = true;
}
void SetNeedsAnimateOnImplThread() override { did_request_animate_ = true; }
- void SetNeedsManageTilesOnImplThread() override {
- did_request_manage_tiles_ = true;
+ void SetNeedsPrepareTilesOnImplThread() override {
+ did_request_prepare_tiles_ = true;
}
void SetNeedsCommitOnImplThread() override { did_request_commit_ = true; }
void PostAnimationEventsToMainThreadOnImplThread(
@@ -149,7 +149,7 @@
requested_scrollbar_animation_delay_ = delay;
}
void DidActivateSyncTree() override {}
- void DidManageTiles() override {}
+ void DidPrepareTiles() override {}
void set_reduce_memory_result(bool reduce_memory_result) {
reduce_memory_result_ = reduce_memory_result;
@@ -390,7 +390,7 @@
bool did_request_commit_;
bool did_request_redraw_;
bool did_request_animate_;
- bool did_request_manage_tiles_;
+ bool did_request_prepare_tiles_;
bool reduce_memory_result_;
base::Closure scrollbar_fade_start_;
base::TimeDelta requested_scrollbar_animation_delay_;
@@ -6502,7 +6502,7 @@
EXPECT_TRUE(host_impl_->RequiresHighResToDraw());
}
-class LayerTreeHostImplTestManageTiles : public LayerTreeHostImplTest {
+class LayerTreeHostImplTestPrepareTiles : public LayerTreeHostImplTest {
public:
void SetUp() override {
LayerTreeSettings settings;
@@ -6518,11 +6518,11 @@
FakeLayerTreeHostImpl* fake_host_impl_;
};
-TEST_F(LayerTreeHostImplTestManageTiles, ManageTilesWhenInvisible) {
+TEST_F(LayerTreeHostImplTestPrepareTiles, PrepareTilesWhenInvisible) {
fake_host_impl_->DidModifyTilePriorities();
- EXPECT_TRUE(fake_host_impl_->manage_tiles_needed());
+ EXPECT_TRUE(fake_host_impl_->prepare_tiles_needed());
fake_host_impl_->SetVisible(false);
- EXPECT_FALSE(fake_host_impl_->manage_tiles_needed());
+ EXPECT_FALSE(fake_host_impl_->prepare_tiles_needed());
}
TEST_F(LayerTreeHostImplTest, UIResourceManagement) {
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index d70d832..06c522a 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -5496,11 +5496,11 @@
EndTest();
}
- void ApplyViewportDeltas(
- const gfx::Vector2d& inner,
- const gfx::Vector2d& outer,
- float scale_delta,
- float top_controls_delta) override {
+ void ApplyViewportDeltas(const gfx::Vector2d& inner,
+ const gfx::Vector2d& outer,
+ const gfx::Vector2dF& elastic_overscroll_delta,
+ float scale_delta,
+ float top_controls_delta) override {
EXPECT_EQ(info_.page_scale_delta, scale_delta);
EXPECT_EQ(info_.top_controls_delta, top_controls_delta);
deltas_sent_to_client_ = true;
@@ -5910,10 +5910,11 @@
MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles);
-class LayerTreeHostTestOneActivatePerManageTiles : public LayerTreeHostTest {
+class LayerTreeHostTestOneActivatePerPrepareTiles : public LayerTreeHostTest {
public:
- LayerTreeHostTestOneActivatePerManageTiles()
- : notify_ready_to_activate_count_(0u), scheduled_manage_tiles_count_(0) {}
+ LayerTreeHostTestOneActivatePerPrepareTiles()
+ : notify_ready_to_activate_count_(0u),
+ scheduled_prepare_tiles_count_(0) {}
void SetupTree() override {
client_.set_fill_with_nonsolid_color(true);
@@ -5942,27 +5943,27 @@
EndTestAfterDelayMs(100);
}
- void ScheduledActionManageTiles() override {
- ++scheduled_manage_tiles_count_;
+ void ScheduledActionPrepareTiles() override {
+ ++scheduled_prepare_tiles_count_;
}
void AfterTest() override {
- // Expect at most a notification for each scheduled manage tiles, plus one
+ // Expect at most a notification for each scheduled prepare tiles, plus one
// for the initial commit (which doesn't go through scheduled actions).
// The reason this is not an equality is because depending on timing, we
- // might get a manage tiles but not yet get a notification that we're
+ // might get a prepare tiles but not yet get a notification that we're
// ready to activate. The intent of a test is to ensure that we don't
- // get more than one notification per manage tiles, so this is OK.
+ // get more than one notification per prepare tiles, so this is OK.
EXPECT_LE(notify_ready_to_activate_count_,
- 1u + scheduled_manage_tiles_count_);
+ 1u + scheduled_prepare_tiles_count_);
}
protected:
FakeContentLayerClient client_;
size_t notify_ready_to_activate_count_;
- size_t scheduled_manage_tiles_count_;
+ size_t scheduled_prepare_tiles_count_;
};
-MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerManageTiles);
+MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerPrepareTiles);
} // namespace cc
diff --git a/cc/trees/layer_tree_host_unittest_no_message_loop.cc b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
index a0b2bdf..1e04ad9 100644
--- a/cc/trees/layer_tree_host_unittest_no_message_loop.cc
+++ b/cc/trees/layer_tree_host_unittest_no_message_loop.cc
@@ -60,6 +60,7 @@
void Layout() override {}
void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
const gfx::Vector2d& outer_delta,
+ const gfx::Vector2dF& elastic_overscroll_delta,
float page_scale,
float top_controls_delta) override {}
void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index 508e7ea..d8d8728 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -54,7 +54,7 @@
use_pinch_virtual_viewport(false),
// At 256x256 tiles, 128 tiles cover an area of 2048x4096 pixels.
max_tiles_for_interest_area(128),
- skewport_target_time_multiplier(1.0f),
+ skewport_target_time_in_seconds(1.0f),
skewport_extrapolation_limit_in_content_pixels(2000),
max_unused_resource_memory_percentage(100),
max_memory_for_prepaint_percentage(100),
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index 1892b39..b847d1f 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -65,7 +65,7 @@
bool use_pinch_zoom_scrollbars;
bool use_pinch_virtual_viewport;
size_t max_tiles_for_interest_area;
- float skewport_target_time_multiplier;
+ float skewport_target_time_in_seconds;
int skewport_extrapolation_limit_in_content_pixels;
size_t max_unused_resource_memory_percentage;
size_t max_memory_for_prepaint_percentage;
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index dfce808..b1248e0 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -372,10 +372,10 @@
scheduler_on_impl_thread_->SetNeedsAnimate();
}
-void SingleThreadProxy::SetNeedsManageTilesOnImplThread() {
- TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsManageTilesOnImplThread");
+void SingleThreadProxy::SetNeedsPrepareTilesOnImplThread() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsPrepareTilesOnImplThread");
if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->SetNeedsManageTiles();
+ scheduler_on_impl_thread_->SetNeedsPrepareTiles();
}
void SingleThreadProxy::SetNeedsRedrawRectOnImplThread(
@@ -438,11 +438,11 @@
timing_history_.DidActivateSyncTree();
}
-void SingleThreadProxy::DidManageTiles() {
+void SingleThreadProxy::DidPrepareTiles() {
DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
DCHECK(Proxy::IsImplThread());
if (scheduler_on_impl_thread_)
- scheduler_on_impl_thread_->DidManageTiles();
+ scheduler_on_impl_thread_->DidPrepareTiles();
}
void SingleThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
@@ -507,7 +507,7 @@
if (layer_tree_host_impl_->settings().impl_side_painting) {
layer_tree_host_impl_->ActivateSyncTree();
layer_tree_host_impl_->active_tree()->UpdateDrawProperties();
- layer_tree_host_impl_->ManageTiles();
+ layer_tree_host_impl_->PrepareTiles();
layer_tree_host_impl_->SynchronouslyInitializeAllTiles();
}
@@ -771,11 +771,11 @@
}
}
-void SingleThreadProxy::ScheduledActionManageTiles() {
- TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionManageTiles");
+void SingleThreadProxy::ScheduledActionPrepareTiles() {
+ TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionPrepareTiles");
DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
DebugScopedSetImplThread impl(this);
- layer_tree_host_impl_->ManageTiles();
+ layer_tree_host_impl_->PrepareTiles();
}
void SingleThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
diff --git a/cc/trees/single_thread_proxy.h b/cc/trees/single_thread_proxy.h
index 3eba6bb..d3f41a5 100644
--- a/cc/trees/single_thread_proxy.h
+++ b/cc/trees/single_thread_proxy.h
@@ -70,7 +70,7 @@
void ScheduledActionAnimate() override;
void ScheduledActionActivateSyncTree() override;
void ScheduledActionBeginOutputSurfaceCreation() override;
- void ScheduledActionManageTiles() override;
+ void ScheduledActionPrepareTiles() override;
void DidAnticipatedDrawTimeChange(base::TimeTicks time) override;
base::TimeDelta DrawDurationEstimate() override;
base::TimeDelta BeginMainFrameToCommitDurationEstimate() override;
@@ -93,7 +93,7 @@
void SetNeedsRedrawOnImplThread() override;
void SetNeedsRedrawRectOnImplThread(const gfx::Rect& dirty_rect) override;
void SetNeedsAnimateOnImplThread() override;
- void SetNeedsManageTilesOnImplThread() override;
+ void SetNeedsPrepareTilesOnImplThread() override;
void SetNeedsCommitOnImplThread() override;
void PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> events) override;
@@ -104,7 +104,7 @@
void PostDelayedScrollbarFadeOnImplThread(const base::Closure& start_fade,
base::TimeDelta delay) override {}
void DidActivateSyncTree() override;
- void DidManageTiles() override;
+ void DidPrepareTiles() override;
void SetDebugState(const LayerTreeDebugState& debug_state) override {}
void RequestNewOutputSurface();
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index 4793cc5..e6ab017 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -81,10 +81,11 @@
commit_requested(false),
commit_request_sent_to_impl_thread(false),
started(false),
- manage_tiles_pending(false),
+ prepare_tiles_pending(false),
can_cancel_commit(true),
defer_commits(false),
- weak_factory(proxy) {}
+ weak_factory(proxy) {
+}
ThreadProxy::MainThreadOnly::~MainThreadOnly() {}
@@ -468,9 +469,9 @@
impl().scheduler->SetNeedsAnimate();
}
-void ThreadProxy::SetNeedsManageTilesOnImplThread() {
+void ThreadProxy::SetNeedsPrepareTilesOnImplThread() {
DCHECK(IsImplThread());
- impl().scheduler->SetNeedsManageTiles();
+ impl().scheduler->SetNeedsPrepareTiles();
}
void ThreadProxy::SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) {
@@ -1050,10 +1051,10 @@
return result;
}
-void ThreadProxy::ScheduledActionManageTiles() {
- TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionManageTiles");
+void ThreadProxy::ScheduledActionPrepareTiles() {
+ TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionPrepareTiles");
DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
- impl().layer_tree_host_impl->ManageTiles();
+ impl().layer_tree_host_impl->PrepareTiles();
}
DrawResult ThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
@@ -1342,9 +1343,9 @@
impl().timing_history.DidActivateSyncTree();
}
-void ThreadProxy::DidManageTiles() {
+void ThreadProxy::DidPrepareTiles() {
DCHECK(IsImplThread());
- impl().scheduler->DidManageTiles();
+ impl().scheduler->DidPrepareTiles();
}
} // namespace cc
diff --git a/cc/trees/thread_proxy.h b/cc/trees/thread_proxy.h
index d6d53a8..14733f7 100644
--- a/cc/trees/thread_proxy.h
+++ b/cc/trees/thread_proxy.h
@@ -72,7 +72,7 @@
bool commit_request_sent_to_impl_thread;
bool started;
- bool manage_tiles_pending;
+ bool prepare_tiles_pending;
bool can_cancel_commit;
bool defer_commits;
@@ -195,7 +195,7 @@
void SetNeedsRedrawOnImplThread() override;
void SetNeedsRedrawRectOnImplThread(const gfx::Rect& dirty_rect) override;
void SetNeedsAnimateOnImplThread() override;
- void SetNeedsManageTilesOnImplThread() override;
+ void SetNeedsPrepareTilesOnImplThread() override;
void SetNeedsCommitOnImplThread() override;
void PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> queue) override;
@@ -206,7 +206,7 @@
void PostDelayedScrollbarFadeOnImplThread(const base::Closure& start_fade,
base::TimeDelta delay) override;
void DidActivateSyncTree() override;
- void DidManageTiles() override;
+ void DidPrepareTiles() override;
// SchedulerClient implementation
void WillBeginImplFrame(const BeginFrameArgs& args) override;
@@ -217,7 +217,7 @@
void ScheduledActionCommit() override;
void ScheduledActionActivateSyncTree() override;
void ScheduledActionBeginOutputSurfaceCreation() override;
- void ScheduledActionManageTiles() override;
+ void ScheduledActionPrepareTiles() override;
void DidAnticipatedDrawTimeChange(base::TimeTicks time) override;
base::TimeDelta DrawDurationEstimate() override;
base::TimeDelta BeginMainFrameToCommitDurationEstimate() override;
diff --git a/crypto/p224_spake.cc b/crypto/p224_spake.cc
index f20b10c..05fe68c 100644
--- a/crypto/p224_spake.cc
+++ b/crypto/p224_spake.cc
@@ -7,6 +7,8 @@
#include <crypto/p224_spake.h>
+#include <algorithm>
+
#include <base/logging.h>
#include <crypto/p224.h>
#include <crypto/random.h>
@@ -105,14 +107,18 @@
// x_ is a random scalar.
RandBytes(x_, sizeof(x_));
- // X = g**x_
- p224::Point X;
- p224::ScalarBaseMult(x_, &X);
-
// Calculate |password| hash to get SPAKE password value.
SHA256HashString(std::string(password.data(), password.length()),
pw_, sizeof(pw_));
+ Init();
+}
+
+void P224EncryptedKeyExchange::Init() {
+ // X = g**x_
+ p224::Point X;
+ p224::ScalarBaseMult(x_, &X);
+
// The client masks the Diffie-Hellman value, X, by adding M**pw and the
// server uses N**pw.
p224::Point MNpw;
@@ -253,4 +259,10 @@
return key_;
}
+void P224EncryptedKeyExchange::SetXForTesting(const std::string& x) {
+ memset(&x_, 0, sizeof(x_));
+ memcpy(&x_, x.data(), std::min(x.size(), sizeof(x_)));
+ Init();
+}
+
} // namespace crypto
diff --git a/crypto/p224_spake.h b/crypto/p224_spake.h
index 61451a3..08769b7 100644
--- a/crypto/p224_spake.h
+++ b/crypto/p224_spake.h
@@ -5,6 +5,7 @@
#ifndef CRYPTO_P224_SPAKE_H_
#define CRYPTO_P224_SPAKE_H_
+#include <base/gtest_prod_util.h>
#include <base/strings/string_piece.h>
#include <crypto/p224.h>
#include <crypto/sha2.h>
@@ -14,7 +15,7 @@
// P224EncryptedKeyExchange implements SPAKE2, a variant of Encrypted
// Key Exchange. It allows two parties that have a secret common
// password to establish a common secure key by exchanging messages
-// over unsecure channel without disclosing the password.
+// over an insecure channel without disclosing the password.
//
// The password can be low entropy as authenticating with an attacker only
// gives the attacker a one-shot password oracle. No other information about
@@ -85,6 +86,13 @@
kStateDone,
};
+ FRIEND_TEST_ALL_PREFIXES(MutualAuth, ExpectedValues);
+
+ void Init();
+
+ // Sets internal random scalar. Should be used by tests only.
+ void SetXForTesting(const std::string& x);
+
State state_;
const bool is_server_;
// next_message_ contains a value for GetMessage() to return.
@@ -104,7 +112,7 @@
// file).
uint8 x_[p224::kScalarBytes];
// pw_ is SHA256(P(password), P(session))[:28] where P() prepends a uint32,
- // big-endian length prefix (see paper refereneced in .cc file).
+ // big-endian length prefix (see paper referenced in .cc file).
uint8 pw_[p224::kScalarBytes];
// expected_authenticator_ is used to store the hash value expected from the
// other party.
diff --git a/crypto/p224_spake_unittest.cc b/crypto/p224_spake_unittest.cc
index 6651c8d..6dd8e88 100644
--- a/crypto/p224_spake_unittest.cc
+++ b/crypto/p224_spake_unittest.cc
@@ -2,16 +2,22 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "crypto/p224_spake.h"
+
#include <string>
-#include <crypto/p224_spake.h>
#include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace crypto {
namespace {
+std::string HexEncodeString(const std::string& binary_data) {
+ return base::HexEncode(binary_data.c_str(), binary_data.size());
+}
+
bool RunExchange(P224EncryptedKeyExchange* client,
P224EncryptedKeyExchange* server,
bool is_password_same) {
@@ -71,6 +77,42 @@
EXPECT_FALSE(RunExchange(&client, &server, false));
}
+TEST(MutualAuth, ExpectedValues) {
+ P224EncryptedKeyExchange client(P224EncryptedKeyExchange::kPeerTypeClient,
+ kPassword);
+ client.SetXForTesting("Client x");
+ P224EncryptedKeyExchange server(P224EncryptedKeyExchange::kPeerTypeServer,
+ kPassword);
+ server.SetXForTesting("Server x");
+
+ std::string client_message = client.GetMessage();
+ EXPECT_EQ(
+ "3508EF7DECC8AB9F9C439FBB0154288BBECC0A82E8448F4CF29554EB"
+ "BE9D486686226255EAD1D077C635B1A41F46AC91D7F7F32CED9EC3E0",
+ HexEncodeString(client_message));
+
+ std::string server_message = server.GetMessage();
+ EXPECT_EQ(
+ "A3088C18B75D2C2B107105661AEC85424777475EB29F1DDFB8C14AFB"
+ "F1603D0DF38413A00F420ACF2059E7997C935F5A957A193D09A2B584",
+ HexEncodeString(server_message));
+
+ EXPECT_EQ(P224EncryptedKeyExchange::kResultPending,
+ client.ProcessMessage(server_message));
+ EXPECT_EQ(P224EncryptedKeyExchange::kResultPending,
+ server.ProcessMessage(client_message));
+
+ EXPECT_EQ(client.GetUnverifiedKey(), server.GetUnverifiedKey());
+ // Must stay the same. External implementations should be able to pair with.
+ EXPECT_EQ(
+ "CE7CCFC435CDA4F01EC8826788B1F8B82EF7D550A34696B371096E64"
+ "C487D4FE193F7D1A6FF6820BC7F807796BA3889E8F999BBDEFC32FFA",
+ HexEncodeString(server.GetUnverifiedKey()));
+
+ EXPECT_TRUE(RunExchange(&client, &server, true));
+ EXPECT_EQ(client.GetKey(), server.GetKey());
+}
+
TEST(MutualAuth, Fuzz) {
static const unsigned kIterations = 40;
diff --git a/gpu/GLES2/gl2chromium_autogen.h b/gpu/GLES2/gl2chromium_autogen.h
index 454c67b..d35de42 100644
--- a/gpu/GLES2/gl2chromium_autogen.h
+++ b/gpu/GLES2/gl2chromium_autogen.h
@@ -268,6 +268,7 @@
#define glDiscardBackbufferCHROMIUM GLES2_GET_FUN(DiscardBackbufferCHROMIUM)
#define glScheduleOverlayPlaneCHROMIUM \
GLES2_GET_FUN(ScheduleOverlayPlaneCHROMIUM)
+#define glSwapInterval GLES2_GET_FUN(SwapInterval)
#define glMatrixLoadfCHROMIUM GLES2_GET_FUN(MatrixLoadfCHROMIUM)
#define glMatrixLoadIdentityCHROMIUM GLES2_GET_FUN(MatrixLoadIdentityCHROMIUM)
#define glBlendBarrierKHR GLES2_GET_FUN(BlendBarrierKHR)
diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index b057477..0b86db6 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -2206,6 +2206,14 @@
'extension': True,
'trace_level': 1,
},
+ 'SwapInterval': {
+ 'impl_func': False,
+ 'decoder_func': 'DoSwapInterval',
+ 'unit_test': False,
+ 'client_test': False,
+ 'extension': True,
+ 'trace_level': 1,
+ },
'TexImage2D': {
'type': 'Manual',
'data_transfer_methods': ['shm'],
@@ -2703,7 +2711,7 @@
'type': 'Custom',
'impl_func': False,
'client_test': False,
- 'cmd_args': 'GLuint bucket_id',
+ 'cmd_args': 'GLuint category_bucket_id, GLuint name_bucket_id',
'extension': True,
'chromium': True,
},
diff --git a/gpu/command_buffer/client/gles2_c_lib_autogen.h b/gpu/command_buffer/client/gles2_c_lib_autogen.h
index c1a1114..766ce56 100644
--- a/gpu/command_buffer/client/gles2_c_lib_autogen.h
+++ b/gpu/command_buffer/client/gles2_c_lib_autogen.h
@@ -1010,8 +1010,9 @@
void GLES2ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
gles2::GetGLContext()->ReleaseTexImage2DCHROMIUM(target, imageId);
}
-void GLES2TraceBeginCHROMIUM(const char* name) {
- gles2::GetGLContext()->TraceBeginCHROMIUM(name);
+void GLES2TraceBeginCHROMIUM(const char* category_name,
+ const char* trace_name) {
+ gles2::GetGLContext()->TraceBeginCHROMIUM(category_name, trace_name);
}
void GLES2TraceEndCHROMIUM() {
gles2::GetGLContext()->TraceEndCHROMIUM();
@@ -1082,6 +1083,9 @@
plane_z_order, plane_transform, overlay_texture_id, bounds_x, bounds_y,
bounds_width, bounds_height, uv_x, uv_y, uv_width, uv_height);
}
+void GLES2SwapInterval(GLint interval) {
+ gles2::GetGLContext()->SwapInterval(interval);
+}
void GLES2MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
gles2::GetGLContext()->MatrixLoadfCHROMIUM(matrixMode, m);
}
@@ -2070,6 +2074,10 @@
reinterpret_cast<GLES2FunctionPointer>(glScheduleOverlayPlaneCHROMIUM),
},
{
+ "glSwapInterval",
+ reinterpret_cast<GLES2FunctionPointer>(glSwapInterval),
+ },
+ {
"glMatrixLoadfCHROMIUM",
reinterpret_cast<GLES2FunctionPointer>(glMatrixLoadfCHROMIUM),
},
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index dc43a41..7b2faae 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -2021,11 +2021,11 @@
}
}
-void TraceBeginCHROMIUM(GLuint bucket_id) {
+void TraceBeginCHROMIUM(GLuint category_bucket_id, GLuint name_bucket_id) {
gles2::cmds::TraceBeginCHROMIUM* c =
GetCmdSpace<gles2::cmds::TraceBeginCHROMIUM>();
if (c) {
- c->Init(bucket_id);
+ c->Init(category_bucket_id, name_bucket_id);
}
}
@@ -2163,6 +2163,13 @@
}
}
+void SwapInterval(GLint interval) {
+ gles2::cmds::SwapInterval* c = GetCmdSpace<gles2::cmds::SwapInterval>();
+ if (c) {
+ c->Init(interval);
+ }
+}
+
void MatrixLoadfCHROMIUMImmediate(GLenum matrixMode, const GLfloat* m) {
const uint32_t size =
gles2::cmds::MatrixLoadfCHROMIUMImmediate::ComputeSize();
diff --git a/gpu/command_buffer/client/gles2_implementation.cc b/gpu/command_buffer/client/gles2_implementation.cc
index 4c148e9..19a005f 100644
--- a/gpu/command_buffer/client/gles2_implementation.cc
+++ b/gpu/command_buffer/client/gles2_implementation.cc
@@ -873,6 +873,13 @@
}
}
+void GLES2Implementation::SwapInterval(int interval) {
+ GPU_CLIENT_SINGLE_THREAD_CHECK();
+ GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glSwapInterval("
+ << interval << ")");
+ helper_->SwapInterval(interval);
+}
+
void GLES2Implementation::BindAttribLocation(
GLuint program, GLuint index, const char* name) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
@@ -3477,32 +3484,38 @@
debug_marker_manager_.PopGroup();
}
-void GLES2Implementation::TraceBeginCHROMIUM(const char* name) {
+void GLES2Implementation::TraceBeginCHROMIUM(
+ const char* category_name, const char* trace_name) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTraceBeginCHROMIUM("
- << name << ")");
- if (current_trace_name_.get()) {
+ << category_name << ", " << trace_name << ")");
+ if (current_trace_category_.get() || current_trace_name_.get()) {
SetGLError(GL_INVALID_OPERATION, "glTraceBeginCHROMIUM",
"trace already running");
return;
}
- TRACE_EVENT_COPY_ASYNC_BEGIN0("gpu", name, this);
- SetBucketAsCString(kResultBucketId, name);
- helper_->TraceBeginCHROMIUM(kResultBucketId);
+ TRACE_EVENT_COPY_ASYNC_BEGIN0(category_name, trace_name, this);
+ SetBucketAsCString(kResultBucketId, category_name);
+ SetBucketAsCString(kResultBucketId + 1, category_name);
+ helper_->TraceBeginCHROMIUM(kResultBucketId, kResultBucketId + 1);
helper_->SetBucketSize(kResultBucketId, 0);
- current_trace_name_.reset(new std::string(name));
+ helper_->SetBucketSize(kResultBucketId + 1, 0);
+ current_trace_category_.reset(new std::string(category_name));
+ current_trace_name_.reset(new std::string(trace_name));
}
void GLES2Implementation::TraceEndCHROMIUM() {
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTraceEndCHROMIUM(" << ")");
- if (!current_trace_name_.get()) {
+ if (!current_trace_category_.get() || !current_trace_name_.get()) {
SetGLError(GL_INVALID_OPERATION, "glTraceEndCHROMIUM",
"missing begin trace");
return;
}
helper_->TraceEndCHROMIUM();
- TRACE_EVENT_COPY_ASYNC_END0("gpu", current_trace_name_->c_str(), this);
+ TRACE_EVENT_COPY_ASYNC_END0(current_trace_category_->c_str(),
+ current_trace_name_->c_str(), this);
+ current_trace_category_.reset();
current_trace_name_.reset();
}
diff --git a/gpu/command_buffer/client/gles2_implementation.h b/gpu/command_buffer/client/gles2_implementation.h
index df6e014..e473006 100644
--- a/gpu/command_buffer/client/gles2_implementation.h
+++ b/gpu/command_buffer/client/gles2_implementation.h
@@ -717,6 +717,7 @@
GLES2ImplementationErrorMessageCallback* error_message_callback_;
+ scoped_ptr<std::string> current_trace_category_;
scoped_ptr<std::string> current_trace_name_;
GpuControl* gpu_control_;
diff --git a/gpu/command_buffer/client/gles2_implementation_autogen.h b/gpu/command_buffer/client/gles2_implementation_autogen.h
index 48bccd5..7d03d88 100644
--- a/gpu/command_buffer/client/gles2_implementation_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_autogen.h
@@ -751,7 +751,8 @@
void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) override;
-void TraceBeginCHROMIUM(const char* name) override;
+void TraceBeginCHROMIUM(const char* category_name,
+ const char* trace_name) override;
void TraceEndCHROMIUM() override;
@@ -805,6 +806,8 @@
GLfloat uv_width,
GLfloat uv_height) override;
+void SwapInterval(GLint interval) override;
+
void MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) override;
void MatrixLoadIdentityCHROMIUM(GLenum matrixMode) override;
diff --git a/gpu/command_buffer/client/gles2_interface_autogen.h b/gpu/command_buffer/client/gles2_interface_autogen.h
index 5970747..f6317bb 100644
--- a/gpu/command_buffer/client/gles2_interface_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_autogen.h
@@ -543,7 +543,8 @@
GLenum subscription) = 0;
virtual void BindTexImage2DCHROMIUM(GLenum target, GLint imageId) = 0;
virtual void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) = 0;
-virtual void TraceBeginCHROMIUM(const char* name) = 0;
+virtual void TraceBeginCHROMIUM(const char* category_name,
+ const char* trace_name) = 0;
virtual void TraceEndCHROMIUM() = 0;
virtual void AsyncTexSubImage2DCHROMIUM(GLenum target,
GLint level,
@@ -584,6 +585,7 @@
GLfloat uv_y,
GLfloat uv_width,
GLfloat uv_height) = 0;
+virtual void SwapInterval(GLint interval) = 0;
virtual void MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) = 0;
virtual void MatrixLoadIdentityCHROMIUM(GLenum matrixMode) = 0;
virtual void BlendBarrierKHR() = 0;
diff --git a/gpu/command_buffer/client/gles2_interface_stub_autogen.h b/gpu/command_buffer/client/gles2_interface_stub_autogen.h
index 01a7e07..cbab14f 100644
--- a/gpu/command_buffer/client/gles2_interface_stub_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_stub_autogen.h
@@ -529,7 +529,8 @@
GLenum subscription) override;
void BindTexImage2DCHROMIUM(GLenum target, GLint imageId) override;
void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) override;
-void TraceBeginCHROMIUM(const char* name) override;
+void TraceBeginCHROMIUM(const char* category_name,
+ const char* trace_name) override;
void TraceEndCHROMIUM() override;
void AsyncTexSubImage2DCHROMIUM(GLenum target,
GLint level,
@@ -570,6 +571,7 @@
GLfloat uv_y,
GLfloat uv_width,
GLfloat uv_height) override;
+void SwapInterval(GLint interval) override;
void MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) override;
void MatrixLoadIdentityCHROMIUM(GLenum matrixMode) override;
void BlendBarrierKHR() override;
diff --git a/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h b/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
index a5797f0..c3d2803 100644
--- a/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
@@ -932,7 +932,8 @@
void GLES2InterfaceStub::ReleaseTexImage2DCHROMIUM(GLenum /* target */,
GLint /* imageId */) {
}
-void GLES2InterfaceStub::TraceBeginCHROMIUM(const char* /* name */) {
+void GLES2InterfaceStub::TraceBeginCHROMIUM(const char* /* category_name */,
+ const char* /* trace_name */) {
}
void GLES2InterfaceStub::TraceEndCHROMIUM() {
}
@@ -991,6 +992,8 @@
GLfloat /* uv_width */,
GLfloat /* uv_height */) {
}
+void GLES2InterfaceStub::SwapInterval(GLint /* interval */) {
+}
void GLES2InterfaceStub::MatrixLoadfCHROMIUM(GLenum /* matrixMode */,
const GLfloat* /* m */) {
}
diff --git a/gpu/command_buffer/client/gles2_trace_implementation_autogen.h b/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
index b88ec6a..f952d58 100644
--- a/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
+++ b/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
@@ -529,7 +529,8 @@
GLenum subscription) override;
void BindTexImage2DCHROMIUM(GLenum target, GLint imageId) override;
void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) override;
-void TraceBeginCHROMIUM(const char* name) override;
+void TraceBeginCHROMIUM(const char* category_name,
+ const char* trace_name) override;
void TraceEndCHROMIUM() override;
void AsyncTexSubImage2DCHROMIUM(GLenum target,
GLint level,
@@ -570,6 +571,7 @@
GLfloat uv_y,
GLfloat uv_width,
GLfloat uv_height) override;
+void SwapInterval(GLint interval) override;
void MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) override;
void MatrixLoadIdentityCHROMIUM(GLenum matrixMode) override;
void BlendBarrierKHR() override;
diff --git a/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h b/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
index 70729c3..c9f8b93 100644
--- a/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
@@ -1612,9 +1612,10 @@
gl_->ReleaseTexImage2DCHROMIUM(target, imageId);
}
-void GLES2TraceImplementation::TraceBeginCHROMIUM(const char* name) {
+void GLES2TraceImplementation::TraceBeginCHROMIUM(const char* category_name,
+ const char* trace_name) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TraceBeginCHROMIUM");
- gl_->TraceBeginCHROMIUM(name);
+ gl_->TraceBeginCHROMIUM(category_name, trace_name);
}
void GLES2TraceImplementation::TraceEndCHROMIUM() {
@@ -1717,6 +1718,11 @@
bounds_width, bounds_height, uv_x, uv_y, uv_width, uv_height);
}
+void GLES2TraceImplementation::SwapInterval(GLint interval) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SwapInterval");
+ gl_->SwapInterval(interval);
+}
+
void GLES2TraceImplementation::MatrixLoadfCHROMIUM(GLenum matrixMode,
const GLfloat* m) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MatrixLoadfCHROMIUM");
diff --git a/gpu/command_buffer/cmd_buffer_functions.txt b/gpu/command_buffer/cmd_buffer_functions.txt
index 03b851f..f0b1627 100644
--- a/gpu/command_buffer/cmd_buffer_functions.txt
+++ b/gpu/command_buffer/cmd_buffer_functions.txt
@@ -236,7 +236,7 @@
GL_APICALL void GL_APIENTRY glUniformValuebufferCHROMIUM (GLintUniformLocation location, GLenumValueBufferTarget target, GLenumSubscriptionTarget subscription);
GL_APICALL void GL_APIENTRY glBindTexImage2DCHROMIUM (GLenumTextureBindTarget target, GLint imageId);
GL_APICALL void GL_APIENTRY glReleaseTexImage2DCHROMIUM (GLenumTextureBindTarget target, GLint imageId);
-GL_APICALL void GL_APIENTRY glTraceBeginCHROMIUM (const char* name);
+GL_APICALL void GL_APIENTRY glTraceBeginCHROMIUM (const char* category_name, const char* trace_name);
GL_APICALL void GL_APIENTRY glTraceEndCHROMIUM (void);
GL_APICALL void GL_APIENTRY glAsyncTexSubImage2DCHROMIUM (GLenumTextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenumTextureFormat format, GLenumPixelType type, const void* data);
GL_APICALL void GL_APIENTRY glAsyncTexImage2DCHROMIUM (GLenumTextureTarget target, GLint level, GLenumTextureInternalFormat internalformat, GLsizei width, GLsizei height, GLintTextureBorder border, GLenumTextureFormat format, GLenumPixelType type, const void* pixels);
@@ -249,6 +249,7 @@
GL_APICALL void GL_APIENTRY glDrawBuffersEXT (GLsizei count, const GLenum* bufs);
GL_APICALL void GL_APIENTRY glDiscardBackbufferCHROMIUM (void);
GL_APICALL void GL_APIENTRY glScheduleOverlayPlaneCHROMIUM (GLint plane_z_order, GLenum plane_transform, GLuint overlay_texture_id, GLint bounds_x, GLint bounds_y, GLint bounds_width, GLint bounds_height, GLfloat uv_x, GLfloat uv_y, GLfloat uv_width, GLfloat uv_height);
+GL_APICALL void GL_APIENTRY glSwapInterval (GLint interval);
// Extension CHROMIUM_path_rendering.
GL_APICALL void GL_APIENTRY glMatrixLoadfCHROMIUM (GLenumMatrixMode matrixMode, const GLfloat* m);
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index 923d5a1..bdee4e6 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -9746,26 +9746,30 @@
void SetHeader() { header.SetCmd<ValueType>(); }
- void Init(GLuint _bucket_id) {
+ void Init(GLuint _category_bucket_id, GLuint _name_bucket_id) {
SetHeader();
- bucket_id = _bucket_id;
+ category_bucket_id = _category_bucket_id;
+ name_bucket_id = _name_bucket_id;
}
- void* Set(void* cmd, GLuint _bucket_id) {
- static_cast<ValueType*>(cmd)->Init(_bucket_id);
+ void* Set(void* cmd, GLuint _category_bucket_id, GLuint _name_bucket_id) {
+ static_cast<ValueType*>(cmd)->Init(_category_bucket_id, _name_bucket_id);
return NextCmdAddress<ValueType>(cmd);
}
gpu::CommandHeader header;
- uint32_t bucket_id;
+ uint32_t category_bucket_id;
+ uint32_t name_bucket_id;
};
-COMPILE_ASSERT(sizeof(TraceBeginCHROMIUM) == 8,
- Sizeof_TraceBeginCHROMIUM_is_not_8);
+COMPILE_ASSERT(sizeof(TraceBeginCHROMIUM) == 12,
+ Sizeof_TraceBeginCHROMIUM_is_not_12);
COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, header) == 0,
OffsetOf_TraceBeginCHROMIUM_header_not_0);
-COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, bucket_id) == 4,
- OffsetOf_TraceBeginCHROMIUM_bucket_id_not_4);
+COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, category_bucket_id) == 4,
+ OffsetOf_TraceBeginCHROMIUM_category_bucket_id_not_4);
+COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, name_bucket_id) == 8,
+ OffsetOf_TraceBeginCHROMIUM_name_bucket_id_not_8);
struct TraceEndCHROMIUM {
typedef TraceEndCHROMIUM ValueType;
@@ -10351,6 +10355,38 @@
COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_height) == 44,
OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_height_not_44);
+struct SwapInterval {
+ typedef SwapInterval ValueType;
+ static const CommandId kCmdId = kSwapInterval;
+ static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+ static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+
+ static uint32_t ComputeSize() {
+ return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT
+ }
+
+ void SetHeader() { header.SetCmd<ValueType>(); }
+
+ void Init(GLint _interval) {
+ SetHeader();
+ interval = _interval;
+ }
+
+ void* Set(void* cmd, GLint _interval) {
+ static_cast<ValueType*>(cmd)->Init(_interval);
+ return NextCmdAddress<ValueType>(cmd);
+ }
+
+ gpu::CommandHeader header;
+ int32_t interval;
+};
+
+COMPILE_ASSERT(sizeof(SwapInterval) == 8, Sizeof_SwapInterval_is_not_8);
+COMPILE_ASSERT(offsetof(SwapInterval, header) == 0,
+ OffsetOf_SwapInterval_header_not_0);
+COMPILE_ASSERT(offsetof(SwapInterval, interval) == 4,
+ OffsetOf_SwapInterval_interval_not_4);
+
struct MatrixLoadfCHROMIUMImmediate {
typedef MatrixLoadfCHROMIUMImmediate ValueType;
static const CommandId kCmdId = kMatrixLoadfCHROMIUMImmediate;
diff --git a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
index 7473650..49c108c 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -3662,11 +3662,13 @@
TEST_F(GLES2FormatTest, TraceBeginCHROMIUM) {
cmds::TraceBeginCHROMIUM& cmd = *GetBufferAs<cmds::TraceBeginCHROMIUM>();
- void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
+ void* next_cmd =
+ cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12));
EXPECT_EQ(static_cast<uint32_t>(cmds::TraceBeginCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
+ EXPECT_EQ(static_cast<GLuint>(11), cmd.category_bucket_id);
+ EXPECT_EQ(static_cast<GLuint>(12), cmd.name_bucket_id);
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
@@ -3860,6 +3862,16 @@
CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
}
+TEST_F(GLES2FormatTest, SwapInterval) {
+ cmds::SwapInterval& cmd = *GetBufferAs<cmds::SwapInterval>();
+ void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11));
+ EXPECT_EQ(static_cast<uint32_t>(cmds::SwapInterval::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+ EXPECT_EQ(static_cast<GLint>(11), cmd.interval);
+ CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
+}
+
TEST_F(GLES2FormatTest, MatrixLoadfCHROMIUMImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
diff --git a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
index 94aa86c..4fe80f8 100644
--- a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
@@ -240,9 +240,10 @@
OP(DrawBuffersEXTImmediate) /* 481 */ \
OP(DiscardBackbufferCHROMIUM) /* 482 */ \
OP(ScheduleOverlayPlaneCHROMIUM) /* 483 */ \
- OP(MatrixLoadfCHROMIUMImmediate) /* 484 */ \
- OP(MatrixLoadIdentityCHROMIUM) /* 485 */ \
- OP(BlendBarrierKHR) /* 486 */
+ OP(SwapInterval) /* 484 */ \
+ OP(MatrixLoadfCHROMIUMImmediate) /* 485 */ \
+ OP(MatrixLoadIdentityCHROMIUM) /* 486 */ \
+ OP(BlendBarrierKHR) /* 487 */
enum CommandId {
kStartPoint = cmd::kLastCommonId, // All GLES2 commands start after this.
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 919d8d8..f97710e 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -880,6 +880,9 @@
// Wrapper for SwapBuffers.
void DoSwapBuffers();
+ // Wrapper for SwapInterval.
+ void DoSwapInterval(int interval);
+
// Wrapper for CopyTexSubImage2D.
void DoCopyTexSubImage2D(
GLenum target,
@@ -1869,6 +1872,8 @@
scoped_ptr<GPUTracer> gpu_tracer_;
scoped_ptr<GPUStateTracer> gpu_state_tracer_;
const unsigned char* cb_command_trace_category_;
+ const unsigned char* gpu_decoder_category_;
+ const unsigned char* gpu_group_marker_category_;
int gpu_trace_level_;
bool gpu_trace_commands_;
bool gpu_debug_commands_;
@@ -2384,6 +2389,10 @@
.texsubimage2d_faster_than_teximage2d),
cb_command_trace_category_(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
TRACE_DISABLED_BY_DEFAULT("cb_command"))),
+ gpu_decoder_category_(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
+ TRACE_DISABLED_BY_DEFAULT("gpu_decoder"))),
+ gpu_group_marker_category_(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
+ TRACE_DISABLED_BY_DEFAULT("gpu_group_marker"))),
gpu_trace_level_(2),
gpu_trace_commands_(false),
gpu_debug_commands_(false),
@@ -3481,7 +3490,7 @@
void GLES2DecoderImpl::BeginDecoding() {
gpu_tracer_->BeginDecoding();
- gpu_trace_commands_ = gpu_tracer_->IsTracing();
+ gpu_trace_commands_ = gpu_tracer_->IsTracing() && *gpu_decoder_category_;
gpu_debug_commands_ = log_commands() || debug() || gpu_trace_commands_ ||
(*cb_command_trace_category_ != 0);
}
@@ -3958,7 +3967,9 @@
if (DebugImpl && gpu_trace_commands_) {
if (CMD_FLAG_GET_TRACE_LEVEL(info.cmd_flags) <= gpu_trace_level_) {
doing_gpu_trace = true;
- gpu_tracer_->Begin(GetCommandName(command), kTraceDecoder);
+ gpu_tracer_->Begin(TRACE_DISABLED_BY_DEFAULT("gpu_decoder"),
+ GetCommandName(command),
+ kTraceDecoder);
}
}
@@ -9724,6 +9735,11 @@
ExitCommandProcessingEarly();
}
+void GLES2DecoderImpl::DoSwapInterval(int interval)
+{
+ context_->SetSwapInterval(interval);
+}
+
error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
uint32 immediate_data_size,
const void* cmd_data) {
@@ -10960,12 +10976,17 @@
}
std::string name = length ? std::string(marker, length) : std::string(marker);
debug_marker_manager_.PushGroup(name);
- gpu_tracer_->Begin(name, kTraceGroupMarker);
+ if (*gpu_group_marker_category_) {
+ gpu_tracer_->Begin(TRACE_DISABLED_BY_DEFAULT("gpu_group_marker"), name,
+ kTraceGroupMarker);
+ }
}
void GLES2DecoderImpl::DoPopGroupMarkerEXT(void) {
debug_marker_manager_.PopGroup();
- gpu_tracer_->End(kTraceGroupMarker);
+ if (*gpu_group_marker_category_) {
+ gpu_tracer_->End(kTraceGroupMarker);
+ }
}
void GLES2DecoderImpl::DoBindTexImage2DCHROMIUM(
@@ -11059,16 +11080,23 @@
const void* cmd_data) {
const gles2::cmds::TraceBeginCHROMIUM& c =
*static_cast<const gles2::cmds::TraceBeginCHROMIUM*>(cmd_data);
- Bucket* bucket = GetBucket(c.bucket_id);
- if (!bucket || bucket->size() == 0) {
+ Bucket* category_bucket = GetBucket(c.category_bucket_id);
+ Bucket* name_bucket = GetBucket(c.name_bucket_id);
+ if (!category_bucket || category_bucket->size() == 0 ||
+ !name_bucket || name_bucket->size() == 0) {
return error::kInvalidArguments;
}
- std::string command_name;
- if (!bucket->GetAsString(&command_name)) {
+
+ std::string category_name;
+ std::string trace_name;
+ if (!category_bucket->GetAsString(&category_name) ||
+ !name_bucket->GetAsString(&trace_name)) {
return error::kInvalidArguments;
}
- TRACE_EVENT_COPY_ASYNC_BEGIN0("gpu", command_name.c_str(), this);
- if (!gpu_tracer_->Begin(command_name, kTraceCHROMIUM)) {
+
+ TRACE_EVENT_COPY_ASYNC_BEGIN0(category_name.c_str(), trace_name.c_str(),
+ this);
+ if (!gpu_tracer_->Begin(category_name, trace_name, kTraceCHROMIUM)) {
LOCAL_SET_GL_ERROR(
GL_INVALID_OPERATION,
"glTraceBeginCHROMIUM", "unable to create begin trace");
@@ -11078,13 +11106,15 @@
}
void GLES2DecoderImpl::DoTraceEndCHROMIUM() {
- if (gpu_tracer_->CurrentName().empty()) {
+ if (gpu_tracer_->CurrentCategory().empty() ||
+ gpu_tracer_->CurrentName().empty()) {
LOCAL_SET_GL_ERROR(
GL_INVALID_OPERATION,
"glTraceEndCHROMIUM", "no trace begin found");
return;
}
- TRACE_EVENT_COPY_ASYNC_END0("gpu", gpu_tracer_->CurrentName().c_str(), this);
+ TRACE_EVENT_COPY_ASYNC_END0(gpu_tracer_->CurrentCategory().c_str(),
+ gpu_tracer_->CurrentName().c_str(), this);
gpu_tracer_->End(kTraceCHROMIUM);
}
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index b84fc2a..f81b56a 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -3989,6 +3989,16 @@
return error::kNoError;
}
+error::Error GLES2DecoderImpl::HandleSwapInterval(uint32_t immediate_data_size,
+ const void* cmd_data) {
+ const gles2::cmds::SwapInterval& c =
+ *static_cast<const gles2::cmds::SwapInterval*>(cmd_data);
+ (void)c;
+ GLint interval = static_cast<GLint>(c.interval);
+ DoSwapInterval(interval);
+ return error::kNoError;
+}
+
error::Error GLES2DecoderImpl::HandleMatrixLoadfCHROMIUMImmediate(
uint32_t immediate_data_size,
const void* cmd_data) {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
index 3fadaf0..86b61ac 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
@@ -37,12 +37,16 @@
INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest3, ::testing::Bool());
TEST_P(GLES2DecoderTest3, TraceBeginCHROMIUM) {
- const uint32 kBucketId = 123;
+ const uint32 kCategoryBucketId = 123;
+ const uint32 kNameBucketId = 234;
+
+ const char kCategory[] = "test_category";
const char kName[] = "test_command";
- SetBucketAsCString(kBucketId, kName);
+ SetBucketAsCString(kCategoryBucketId, kCategory);
+ SetBucketAsCString(kNameBucketId, kName);
TraceBeginCHROMIUM begin_cmd;
- begin_cmd.Init(kBucketId);
+ begin_cmd.Init(kCategoryBucketId, kNameBucketId);
EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
}
@@ -53,12 +57,16 @@
EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
- const uint32 kBucketId = 123;
+ const uint32 kCategoryBucketId = 123;
+ const uint32 kNameBucketId = 234;
+
+ const char kCategory[] = "test_category";
const char kName[] = "test_command";
- SetBucketAsCString(kBucketId, kName);
+ SetBucketAsCString(kCategoryBucketId, kCategory);
+ SetBucketAsCString(kNameBucketId, kName);
TraceBeginCHROMIUM begin_cmd;
- begin_cmd.Init(kBucketId);
+ begin_cmd.Init(kCategoryBucketId, kNameBucketId);
EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
end_cmd.Init();
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
index 4509676..6de18e0 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
@@ -70,4 +70,5 @@
// TODO(gman): DiscardBackbufferCHROMIUM
// TODO(gman): ScheduleOverlayPlaneCHROMIUM
+// TODO(gman): SwapInterval
#endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/gpu_tracer.cc b/gpu/command_buffer/service/gpu_tracer.cc
index 024e4b6..d7cd1b8 100644
--- a/gpu/command_buffer/service/gpu_tracer.cc
+++ b/gpu/command_buffer/service/gpu_tracer.cc
@@ -18,8 +18,9 @@
static const unsigned int kProcessInterval = 16;
static TraceOutputter* g_outputter_thread = NULL;
-TraceMarker::TraceMarker(const std::string& name)
- : name_(name),
+TraceMarker::TraceMarker(const std::string& category, const std::string& name)
+ : category_(category),
+ name_(name),
trace_(NULL) {
}
@@ -41,29 +42,30 @@
TraceOutputter::~TraceOutputter() { g_outputter_thread = NULL; }
-void TraceOutputter::Trace(const std::string& name,
+void TraceOutputter::Trace(const std::string& category,
+ const std::string& name,
int64 start_time,
int64 end_time) {
- TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
- TRACE_DISABLED_BY_DEFAULT("gpu.device"),
- name.c_str(),
- local_trace_id_,
- named_thread_.thread_id(),
- start_time);
- TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0(
- TRACE_DISABLED_BY_DEFAULT("gpu.device"),
- name.c_str(),
- local_trace_id_,
- named_thread_.thread_id(),
- end_time);
+ TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category.c_str(),
+ name.c_str(),
+ local_trace_id_,
+ named_thread_.thread_id(),
+ start_time);
+ TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0(category.c_str(),
+ name.c_str(),
+ local_trace_id_,
+ named_thread_.thread_id(),
+ end_time);
++local_trace_id_;
}
GPUTrace::GPUTrace(scoped_refptr<Outputter> outputter,
+ const std::string& category,
const std::string& name,
int64 offset,
GpuTracerType tracer_type)
- : name_(name),
+ : category_(category),
+ name_(name),
outputter_(outputter),
offset_(offset),
start_time_(0),
@@ -94,9 +96,10 @@
}
}
-void GPUTrace::Start() {
- TRACE_EVENT_COPY_ASYNC_BEGIN0(
- TRACE_DISABLED_BY_DEFAULT("gpu.service"), name().c_str(), this);
+void GPUTrace::Start(bool trace_service) {
+ if (trace_service) {
+ TRACE_EVENT_COPY_ASYNC_BEGIN0(category().c_str(), name().c_str(), this);
+ }
switch (tracer_type_) {
case kTracerTypeInvalid:
@@ -123,7 +126,7 @@
}
}
-void GPUTrace::End() {
+void GPUTrace::End(bool tracing_service) {
end_requested_ = true;
switch (tracer_type_) {
case kTracerTypeInvalid:
@@ -136,8 +139,9 @@
break;
}
- TRACE_EVENT_COPY_ASYNC_END0(
- TRACE_DISABLED_BY_DEFAULT("gpu.service"), name().c_str(), this);
+ if (tracing_service) {
+ TRACE_EVENT_COPY_ASYNC_END0(category().c_str(), name().c_str(), this);
+ }
}
bool GPUTrace::IsAvailable() {
@@ -171,7 +175,7 @@
start_time_ = (begin_stamp / base::Time::kNanosecondsPerMicrosecond) +
offset_;
end_time_ = (end_stamp / base::Time::kNanosecondsPerMicrosecond) + offset_;
- outputter_->Trace(name(), start_time_, end_time_);
+ outputter_->Trace(category(), name(), start_time_, end_time_);
}
GPUTracer::GPUTracer(gles2::GLES2Decoder* decoder)
@@ -215,8 +219,10 @@
// Begin a Trace for all active markers
for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
for (size_t i = 0; i < markers_[n].size(); i++) {
- markers_[n][i].trace_ = CreateTrace(markers_[n][i].name_);
- markers_[n][i].trace_->Start();
+ TraceMarker& trace_marker = markers_[n][i];
+ trace_marker.trace_ = CreateTrace(trace_marker.category_,
+ trace_marker.name_);
+ trace_marker.trace_->Start(*gpu_trace_srv_category != 0);
}
}
}
@@ -232,7 +238,7 @@
for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
for (size_t i = 0; i < markers_[n].size(); i++) {
if (markers_[n][i].trace_.get()) {
- markers_[n][i].trace_->End();
+ markers_[n][i].trace_->End(*gpu_trace_srv_category != 0);
if (markers_[n][i].trace_->IsEnabled())
traces_.push_back(markers_[n][i].trace_);
markers_[n][i].trace_ = 0;
@@ -249,7 +255,8 @@
return true;
}
-bool GPUTracer::Begin(const std::string& name, GpuTracerSource source) {
+bool GPUTracer::Begin(const std::string& category, const std::string& name,
+ GpuTracerSource source) {
if (!gpu_executing_)
return false;
@@ -257,12 +264,12 @@
// Push new marker from given 'source'
last_tracer_source_ = source;
- markers_[source].push_back(TraceMarker(name));
+ markers_[source].push_back(TraceMarker(category, name));
// Create trace
if (IsTracing()) {
- scoped_refptr<GPUTrace> trace = CreateTrace(name);
- trace->Start();
+ scoped_refptr<GPUTrace> trace = CreateTrace(category, name);
+ trace->Start(*gpu_trace_srv_category != 0);
markers_[source].back().trace_ = trace;
}
@@ -280,7 +287,7 @@
if (IsTracing()) {
scoped_refptr<GPUTrace> trace = markers_[source].back().trace_;
if (trace.get()) {
- trace->End();
+ trace->End(*gpu_trace_srv_category != 0);
if (trace->IsEnabled())
traces_.push_back(trace);
IssueProcessTask();
@@ -297,6 +304,15 @@
return (*gpu_trace_srv_category != 0) || (*gpu_trace_dev_category != 0);
}
+const std::string& GPUTracer::CurrentCategory() const {
+ if (last_tracer_source_ >= 0 &&
+ last_tracer_source_ < NUM_TRACER_SOURCES &&
+ !markers_[last_tracer_source_].empty()) {
+ return markers_[last_tracer_source_].back().category_;
+ }
+ return base::EmptyString();
+}
+
const std::string& GPUTracer::CurrentName() const {
if (last_tracer_source_ >= 0 &&
last_tracer_source_ < NUM_TRACER_SOURCES &&
@@ -306,11 +322,12 @@
return base::EmptyString();
}
-scoped_refptr<GPUTrace> GPUTracer::CreateTrace(const std::string& name) {
+scoped_refptr<GPUTrace> GPUTracer::CreateTrace(const std::string& category,
+ const std::string& name) {
GpuTracerType tracer_type = *gpu_trace_dev_category ? tracer_type_ :
kTracerTypeInvalid;
- return new GPUTrace(outputter_, name, timer_offset_, tracer_type);
+ return new GPUTrace(outputter_, category, name, timer_offset_, tracer_type);
}
void GPUTracer::Process() {
diff --git a/gpu/command_buffer/service/gpu_tracer.h b/gpu/command_buffer/service/gpu_tracer.h
index 2e81b4e..6033220 100644
--- a/gpu/command_buffer/service/gpu_tracer.h
+++ b/gpu/command_buffer/service/gpu_tracer.h
@@ -42,9 +42,10 @@
// Marker structure for a Trace.
struct TraceMarker {
- TraceMarker(const std::string& name);
+ TraceMarker(const std::string& category, const std::string& name);
~TraceMarker();
+ std::string category_;
std::string name_;
scoped_refptr<GPUTrace> trace_;
};
@@ -62,7 +63,8 @@
bool EndDecoding();
// Begin a trace marker.
- bool Begin(const std::string& name, GpuTracerSource source);
+ bool Begin(const std::string& category, const std::string& name,
+ GpuTracerSource source);
// End the last started trace marker.
bool End(GpuTracerSource source);
@@ -71,11 +73,13 @@
// Retrieve the name of the current open trace.
// Returns empty string if no current open trace.
+ const std::string& CurrentCategory() const;
const std::string& CurrentName() const;
private:
// Trace Processing.
- scoped_refptr<GPUTrace> CreateTrace(const std::string& name);
+ scoped_refptr<GPUTrace> CreateTrace(const std::string& category,
+ const std::string& name);
void Process();
void ProcessTraces();
@@ -103,7 +107,8 @@
class Outputter : public base::RefCounted<Outputter> {
public:
- virtual void Trace(const std::string& name,
+ virtual void Trace(const std::string& category,
+ const std::string& name,
int64 start_time,
int64 end_time) = 0;
@@ -115,7 +120,8 @@
class TraceOutputter : public Outputter {
public:
static scoped_refptr<TraceOutputter> Create(const std::string& name);
- void Trace(const std::string& name,
+ void Trace(const std::string& category,
+ const std::string& name,
int64 start_time,
int64 end_time) override;
@@ -134,15 +140,18 @@
: public base::RefCounted<GPUTrace> {
public:
GPUTrace(scoped_refptr<Outputter> outputter,
+ const std::string& category,
const std::string& name,
int64 offset,
GpuTracerType tracer_type);
bool IsEnabled() { return tracer_type_ != kTracerTypeInvalid; }
+
+ const std::string& category() { return category_; }
const std::string& name() { return name_; }
- void Start();
- void End();
+ void Start(bool trace_service);
+ void End(bool tracing_service);
bool IsAvailable();
void Process();
@@ -153,6 +162,7 @@
friend class base::RefCounted<GPUTrace>;
+ std::string category_;
std::string name_;
scoped_refptr<Outputter> outputter_;
diff --git a/gpu/command_buffer/service/gpu_tracer_unittest.cc b/gpu/command_buffer/service/gpu_tracer_unittest.cc
index 2a7a94c..ccf4d6d 100644
--- a/gpu/command_buffer/service/gpu_tracer_unittest.cc
+++ b/gpu/command_buffer/service/gpu_tracer_unittest.cc
@@ -22,8 +22,9 @@
class MockOutputter : public Outputter {
public:
MockOutputter() {}
- MOCK_METHOD3(Trace,
- void(const std::string& name, int64 start_time, int64 end_time));
+ MOCK_METHOD4(Trace,
+ void(const std::string& category, const std::string& name,
+ int64 start_time, int64 end_time));
protected:
~MockOutputter() {}
@@ -113,6 +114,7 @@
SetupTimerQueryMocks();
// Expected results
+ const std::string category_name("trace_category");
const std::string trace_name("trace_test");
const int64 offset_time = 3231;
const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
@@ -125,20 +127,21 @@
// Expected Outputter::Trace call
EXPECT_CALL(*outputter,
- Trace(trace_name, expect_start_time, expect_end_time));
+ Trace(category_name, trace_name,
+ expect_start_time, expect_end_time));
scoped_refptr<GPUTrace> trace =
- new GPUTrace(outputter_ref, trace_name, offset_time,
- GetTracerType());
+ new GPUTrace(outputter_ref, category_name, trace_name,
+ offset_time, GetTracerType());
gl_fake_queries_.SetCurrentGLTime(start_timestamp);
- trace->Start();
+ trace->Start(true);
// Shouldn't be available before End() call
gl_fake_queries_.SetCurrentGLTime(end_timestamp);
EXPECT_FALSE(trace->IsAvailable());
- trace->End();
+ trace->End(true);
// Shouldn't be available until the queries complete
gl_fake_queries_.SetCurrentGLTime(end_timestamp -
diff --git a/gpu/config/software_rendering_list_json.cc b/gpu/config/software_rendering_list_json.cc
index b9f5e3a..e97c41a 100644
--- a/gpu/config/software_rendering_list_json.cc
+++ b/gpu/config/software_rendering_list_json.cc
@@ -18,7 +18,7 @@
{
"name": "software rendering list",
// Please update the version number whenever you change this file.
- "version": "9.13",
+ "version": "9.14",
"entries": [
{
"id": 1,
@@ -1050,23 +1050,35 @@
},
{
"id": 96,
- "description": "GPU rasterization is whitelisted on select devices on Android",
- "cr_bugs": [362779],
+ "description": "GPU rasterization whitelist",
+ "cr_bugs": [362779,424970],
"os": {
"type": "android"
},
"exceptions": [
{
- "machine_model_name": ["Nexus 4", "Nexus 5", "Nexus 7",
- "XT1049", "XT1050", "XT1052", "XT1053",
- "XT1055", "XT1056", "XT1058", "XT1060",
- "HTC One",
- "C5303", "C6603", "C6903",
- "GT-I9195",
- "GT-I9505",
- "SAMSUNG-SCH-I337", "SCH-I545", "SGH-M919",
- "SM-N900", "SM-N9005", "SPH-L720",
- "XT907", "XT1032", "XT1033", "XT1080"]
+ "os": {
+ "type": "android"
+ },
+ "gl_renderer": "Adreno (TM) 3.*"
+ },
+ {
+ "os": {
+ "type": "android"
+ },
+ "gl_renderer": "NVIDIA.*"
+ },
+ {
+ "os": {
+ "type": "android"
+ },
+ "gl_renderer": "VideoCore IV.*"
+ },
+ {
+ "os": {
+ "type": "android"
+ },
+ "gl_renderer": "Immersion.*"
},
{
"os": {
diff --git a/gpu/skia_bindings/gl_bindings_skia_cmd_buffer.cc b/gpu/skia_bindings/gl_bindings_skia_cmd_buffer.cc
index 3b5460e..1e997ba 100644
--- a/gpu/skia_bindings/gl_bindings_skia_cmd_buffer.cc
+++ b/gpu/skia_bindings/gl_bindings_skia_cmd_buffer.cc
@@ -69,6 +69,7 @@
functions->fGetProgramiv = glGetProgramiv;
functions->fGetShaderInfoLog = glGetShaderInfoLog;
functions->fGetShaderiv = glGetShaderiv;
+ functions->fGetShaderPrecisionFormat = glGetShaderPrecisionFormat;
functions->fGetString = glGetString;
functions->fGetUniformLocation = glGetUniformLocation;
functions->fInsertEventMarker = glInsertEventMarkerEXT;
diff --git a/mojo/tools/roll/cc_strip_video.patch b/mojo/tools/roll/cc_strip_video.patch
index 4bbaf1c..df14109 100644
--- a/mojo/tools/roll/cc_strip_video.patch
+++ b/mojo/tools/roll/cc_strip_video.patch
@@ -22,8 +22,8 @@
"resources/ui_resource_request.h",
- "resources/video_resource_updater.cc",
- "resources/video_resource_updater.h",
- "resources/zero_copy_raster_worker_pool.cc",
- "resources/zero_copy_raster_worker_pool.h",
+ "resources/zero_copy_tile_task_worker_pool.cc",
+ "resources/zero_copy_tile_task_worker_pool.h",
"scheduler/begin_frame_source.cc",
@@ -588,8 +579,6 @@ source_set("test_support") {
"test/fake_tile_manager_client.h",
diff --git a/net/base/layered_network_delegate.cc b/net/base/layered_network_delegate.cc
new file mode 100644
index 0000000..95e4236
--- /dev/null
+++ b/net/base/layered_network_delegate.cc
@@ -0,0 +1,274 @@
+// 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 "net/base/layered_network_delegate.h"
+
+namespace net {
+
+LayeredNetworkDelegate::LayeredNetworkDelegate(
+ scoped_ptr<NetworkDelegate> nested_network_delegate)
+ : nested_network_delegate_(nested_network_delegate.Pass()) {
+}
+
+LayeredNetworkDelegate::~LayeredNetworkDelegate() {
+}
+
+int LayeredNetworkDelegate::OnBeforeURLRequest(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url) {
+ OnBeforeURLRequestInternal(request, callback, new_url);
+ return nested_network_delegate_->NotifyBeforeURLRequest(request, callback,
+ new_url);
+}
+
+void LayeredNetworkDelegate::OnBeforeURLRequestInternal(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url) {
+}
+
+void LayeredNetworkDelegate::OnResolveProxy(const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result) {
+ OnResolveProxyInternal(url, load_flags, proxy_service, result);
+ nested_network_delegate_->NotifyResolveProxy(url, load_flags, proxy_service,
+ result);
+}
+
+void LayeredNetworkDelegate::OnResolveProxyInternal(
+ const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result) {
+}
+
+void LayeredNetworkDelegate::OnProxyFallback(const ProxyServer& bad_proxy,
+ int net_error) {
+ OnProxyFallbackInternal(bad_proxy, net_error);
+ nested_network_delegate_->NotifyProxyFallback(bad_proxy, net_error);
+}
+
+void LayeredNetworkDelegate::OnProxyFallbackInternal(
+ const ProxyServer& bad_proxy,
+ int net_error) {
+}
+
+int LayeredNetworkDelegate::OnBeforeSendHeaders(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers) {
+ OnBeforeSendHeadersInternal(request, callback, headers);
+ return nested_network_delegate_->NotifyBeforeSendHeaders(request, callback,
+ headers);
+}
+
+void LayeredNetworkDelegate::OnBeforeSendHeadersInternal(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers) {
+}
+
+void LayeredNetworkDelegate::OnBeforeSendProxyHeaders(
+ URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers) {
+ OnBeforeSendProxyHeadersInternal(request, proxy_info, headers);
+ nested_network_delegate_->NotifyBeforeSendProxyHeaders(request, proxy_info,
+ headers);
+}
+
+void LayeredNetworkDelegate::OnBeforeSendProxyHeadersInternal(
+ URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers) {
+}
+
+void LayeredNetworkDelegate::OnSendHeaders(URLRequest* request,
+ const HttpRequestHeaders& headers) {
+ OnSendHeadersInternal(request, headers);
+ nested_network_delegate_->NotifySendHeaders(request, headers);
+}
+
+void LayeredNetworkDelegate::OnSendHeadersInternal(
+ URLRequest* request,
+ const HttpRequestHeaders& headers) {
+}
+
+int LayeredNetworkDelegate::OnHeadersReceived(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url) {
+ OnHeadersReceivedInternal(request, callback, original_response_headers,
+ override_response_headers,
+ allowed_unsafe_redirect_url);
+ return nested_network_delegate_->NotifyHeadersReceived(
+ request, callback, original_response_headers, override_response_headers,
+ allowed_unsafe_redirect_url);
+}
+
+void LayeredNetworkDelegate::OnHeadersReceivedInternal(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url) {
+}
+
+void LayeredNetworkDelegate::OnBeforeRedirect(URLRequest* request,
+ const GURL& new_location) {
+ OnBeforeRedirectInternal(request, new_location);
+ nested_network_delegate_->NotifyBeforeRedirect(request, new_location);
+}
+
+void LayeredNetworkDelegate::OnBeforeRedirectInternal(
+ URLRequest* request,
+ const GURL& new_location) {
+}
+
+void LayeredNetworkDelegate::OnResponseStarted(URLRequest* request) {
+ OnResponseStartedInternal(request);
+ nested_network_delegate_->NotifyResponseStarted(request);
+}
+
+void LayeredNetworkDelegate::OnResponseStartedInternal(URLRequest* request) {
+}
+
+void LayeredNetworkDelegate::OnRawBytesRead(const URLRequest& request,
+ int bytes_read) {
+ OnRawBytesReadInternal(request, bytes_read);
+ nested_network_delegate_->NotifyRawBytesRead(request, bytes_read);
+}
+
+void LayeredNetworkDelegate::OnRawBytesReadInternal(const URLRequest& request,
+ int bytes_read) {
+}
+
+void LayeredNetworkDelegate::OnCompleted(URLRequest* request, bool started) {
+ OnCompletedInternal(request, started);
+ nested_network_delegate_->NotifyCompleted(request, started);
+}
+
+void LayeredNetworkDelegate::OnCompletedInternal(URLRequest* request,
+ bool started) {
+}
+
+void LayeredNetworkDelegate::OnURLRequestDestroyed(URLRequest* request) {
+ OnURLRequestDestroyedInternal(request);
+ nested_network_delegate_->NotifyURLRequestDestroyed(request);
+}
+
+void LayeredNetworkDelegate::OnURLRequestDestroyedInternal(
+ URLRequest* request) {
+}
+
+void LayeredNetworkDelegate::OnPACScriptError(int line_number,
+ const base::string16& error) {
+ OnPACScriptErrorInternal(line_number, error);
+ nested_network_delegate_->NotifyPACScriptError(line_number, error);
+}
+
+void LayeredNetworkDelegate::OnPACScriptErrorInternal(
+ int line_number,
+ const base::string16& error) {
+}
+
+NetworkDelegate::AuthRequiredResponse LayeredNetworkDelegate::OnAuthRequired(
+ URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials) {
+ OnAuthRequiredInternal(request, auth_info, callback, credentials);
+ return nested_network_delegate_->NotifyAuthRequired(request, auth_info,
+ callback, credentials);
+}
+
+void LayeredNetworkDelegate::OnAuthRequiredInternal(
+ URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials) {
+}
+
+bool LayeredNetworkDelegate::OnCanGetCookies(const URLRequest& request,
+ const CookieList& cookie_list) {
+ OnCanGetCookiesInternal(request, cookie_list);
+ return nested_network_delegate_->CanGetCookies(request, cookie_list);
+}
+
+void LayeredNetworkDelegate::OnCanGetCookiesInternal(
+ const URLRequest& request,
+ const CookieList& cookie_list) {
+}
+
+bool LayeredNetworkDelegate::OnCanSetCookie(const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options) {
+ OnCanSetCookieInternal(request, cookie_line, options);
+ return nested_network_delegate_->CanSetCookie(request, cookie_line, options);
+}
+
+void LayeredNetworkDelegate::OnCanSetCookieInternal(
+ const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options) {
+}
+
+bool LayeredNetworkDelegate::OnCanAccessFile(const URLRequest& request,
+ const base::FilePath& path) const {
+ OnCanAccessFileInternal(request, path);
+ return nested_network_delegate_->CanAccessFile(request, path);
+}
+
+void LayeredNetworkDelegate::OnCanAccessFileInternal(
+ const URLRequest& request,
+ const base::FilePath& path) const {
+}
+
+bool LayeredNetworkDelegate::OnCanThrottleRequest(
+ const URLRequest& request) const {
+ OnCanThrottleRequestInternal(request);
+ return nested_network_delegate_->CanThrottleRequest(request);
+}
+
+void LayeredNetworkDelegate::OnCanThrottleRequestInternal(
+ const URLRequest& request) const {
+}
+
+bool LayeredNetworkDelegate::OnCanEnablePrivacyMode(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const {
+ OnCanEnablePrivacyModeInternal(url, first_party_for_cookies);
+ return nested_network_delegate_->CanEnablePrivacyMode(
+ url, first_party_for_cookies);
+}
+
+void LayeredNetworkDelegate::OnCanEnablePrivacyModeInternal(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const {
+}
+
+bool LayeredNetworkDelegate::
+ OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const {
+ OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal(
+ request, target_url, referrer_url);
+ return nested_network_delegate_
+ ->CancelURLRequestWithPolicyViolatingReferrerHeader(request, target_url,
+ referrer_url);
+}
+
+void LayeredNetworkDelegate::
+ OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const {
+}
+
+} // namespace net
diff --git a/net/base/layered_network_delegate.h b/net/base/layered_network_delegate.h
new file mode 100644
index 0000000..93c9d11
--- /dev/null
+++ b/net/base/layered_network_delegate.h
@@ -0,0 +1,171 @@
+// 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 NET_BASE_LAYERED_NETWORK_DELEGATE_H_
+#define NET_BASE_LAYERED_NETWORK_DELEGATE_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string16.h"
+#include "net/base/completion_callback.h"
+#include "net/base/network_delegate.h"
+#include "net/cookies/canonical_cookie.h"
+
+class GURL;
+
+namespace base {
+class FilePath;
+}
+
+namespace net {
+
+class CookieOptions;
+class HttpRequestHeaders;
+class HttpResponseHeaders;
+class ProxyInfo;
+class ProxyServer;
+class ProxyService;
+class URLRequest;
+
+// WrappingNetworkDelegate takes a |network_delegate| and extends it. When
+// On*() is called, the On*Internal() method of this is first called and then
+// the On*() of |network_delegate| is called. On*Internal() methods have no
+// return values, and cannot prevent calling into the nested network delegate.
+class NET_EXPORT LayeredNetworkDelegate : public NetworkDelegate {
+ public:
+ explicit LayeredNetworkDelegate(
+ scoped_ptr<NetworkDelegate> nested_network_delegate);
+ ~LayeredNetworkDelegate() override;
+
+ // NetworkDelegate implementation:
+ int OnBeforeURLRequest(URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url) final override;
+ void OnResolveProxy(const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result) final override;
+ void OnProxyFallback(const ProxyServer& bad_proxy,
+ int net_error) final override;
+ int OnBeforeSendHeaders(URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers) final override;
+ void OnBeforeSendProxyHeaders(URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers) final override;
+ void OnSendHeaders(URLRequest* request,
+ const HttpRequestHeaders& headers) final override;
+ int OnHeadersReceived(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url) final override;
+ void OnBeforeRedirect(URLRequest* request,
+ const GURL& new_location) final override;
+ void OnResponseStarted(URLRequest* request) final override;
+ void OnRawBytesRead(const URLRequest& request, int bytes_read) final override;
+ void OnCompleted(URLRequest* request, bool started) final override;
+ void OnURLRequestDestroyed(URLRequest* request) final override;
+ void OnPACScriptError(int line_number,
+ const base::string16& error) final override;
+ AuthRequiredResponse OnAuthRequired(
+ URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials) final override;
+ bool OnCanGetCookies(const URLRequest& request,
+ const CookieList& cookie_list) final override;
+ bool OnCanSetCookie(const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options) final override;
+ bool OnCanAccessFile(const URLRequest& request,
+ const base::FilePath& path) const final override;
+ bool OnCanThrottleRequest(const URLRequest& request) const final override;
+ bool OnCanEnablePrivacyMode(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const final override;
+ bool OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const final override;
+
+ protected:
+ virtual void OnBeforeURLRequestInternal(URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url);
+
+ virtual void OnResolveProxyInternal(const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result);
+
+ virtual void OnProxyFallbackInternal(const ProxyServer& bad_proxy,
+ int net_error);
+
+ virtual void OnBeforeSendHeadersInternal(URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers);
+
+ virtual void OnBeforeSendProxyHeadersInternal(URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers);
+
+ virtual void OnSendHeadersInternal(URLRequest* request,
+ const HttpRequestHeaders& headers);
+
+ virtual void OnHeadersReceivedInternal(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url);
+
+ virtual void OnBeforeRedirectInternal(URLRequest* request,
+ const GURL& new_location);
+
+ virtual void OnResponseStartedInternal(URLRequest* request);
+
+ virtual void OnRawBytesReadInternal(const URLRequest& request,
+ int bytes_read);
+
+ virtual void OnCompletedInternal(URLRequest* request, bool started);
+
+ virtual void OnURLRequestDestroyedInternal(URLRequest* request);
+
+ virtual void OnPACScriptErrorInternal(int line_number,
+ const base::string16& error);
+
+ virtual void OnCanGetCookiesInternal(const URLRequest& request,
+ const CookieList& cookie_list);
+
+ virtual void OnCanSetCookieInternal(const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options);
+
+ virtual void OnAuthRequiredInternal(URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials);
+
+ virtual void OnCanAccessFileInternal(const URLRequest& request,
+ const base::FilePath& path) const;
+
+ virtual void OnCanThrottleRequestInternal(const URLRequest& request) const;
+
+ virtual void OnCanEnablePrivacyModeInternal(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const;
+
+ virtual void OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const;
+
+ private:
+ scoped_ptr<NetworkDelegate> nested_network_delegate_;
+};
+
+} // namespace net
+
+#endif // NET_BASE_LAYERED_NETWORK_DELEGATE_H_
diff --git a/net/base/layered_network_delegate_unittest.cc b/net/base/layered_network_delegate_unittest.cc
new file mode 100644
index 0000000..d68568e
--- /dev/null
+++ b/net/base/layered_network_delegate_unittest.cc
@@ -0,0 +1,389 @@
+// 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 "net/base/layered_network_delegate.h"
+
+#include <map>
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/auth.h"
+#include "net/base/net_errors.h"
+#include "net/base/network_delegate_impl.h"
+#include "net/base/request_priority.h"
+#include "net/base/test_completion_callback.h"
+#include "net/http/http_response_headers.h"
+#include "net/proxy/proxy_config_service.h"
+#include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace net {
+namespace {
+
+typedef std::map<const char*, int> CountersMap;
+
+class TestNetworkDelegateImpl : public NetworkDelegateImpl {
+ public:
+ TestNetworkDelegateImpl(CountersMap* layered_network_delegate_counters)
+ : layered_network_delegate_counters_(layered_network_delegate_counters) {}
+
+ ~TestNetworkDelegateImpl() override {}
+
+ // NetworkDelegateImpl implementation:
+ int OnBeforeURLRequest(URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url) override {
+ IncrementAndCompareCounter("on_before_url_request_count");
+ return OK;
+ }
+
+ void OnResolveProxy(const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result) override {
+ IncrementAndCompareCounter("on_resolve_proxy_count");
+ }
+
+ void OnProxyFallback(const ProxyServer& bad_proxy, int net_error) override {
+ IncrementAndCompareCounter("on_proxy_fallback_count");
+ }
+
+ int OnBeforeSendHeaders(URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers) override {
+ IncrementAndCompareCounter("on_before_send_headers_count");
+ return OK;
+ }
+
+ void OnBeforeSendProxyHeaders(URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers) override {
+ IncrementAndCompareCounter("on_before_send_proxy_headers_count");
+ }
+
+ void OnSendHeaders(URLRequest* request,
+ const HttpRequestHeaders& headers) override {
+ IncrementAndCompareCounter("on_send_headers_count");
+ }
+
+ int OnHeadersReceived(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url) override {
+ IncrementAndCompareCounter("on_headers_received_count");
+ return OK;
+ }
+
+ void OnBeforeRedirect(URLRequest* request,
+ const GURL& new_location) override {
+ IncrementAndCompareCounter("on_before_redirect_count");
+ }
+
+ void OnResponseStarted(URLRequest* request) override {
+ IncrementAndCompareCounter("on_response_started_count");
+ }
+
+ void OnRawBytesRead(const URLRequest& request, int bytes_read) override {
+ IncrementAndCompareCounter("on_raw_bytes_read_count");
+ }
+
+ void OnCompleted(URLRequest* request, bool started) override {
+ IncrementAndCompareCounter("on_completed_count");
+ }
+
+ void OnURLRequestDestroyed(URLRequest* request) override {
+ IncrementAndCompareCounter("on_url_request_destroyed_count");
+ }
+
+ void OnPACScriptError(int line_number, const base::string16& error) override {
+ IncrementAndCompareCounter("on_pac_script_error_count");
+ }
+
+ AuthRequiredResponse OnAuthRequired(URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials) override {
+ IncrementAndCompareCounter("on_auth_required_count");
+ return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+ }
+
+ bool OnCanGetCookies(const URLRequest& request,
+ const CookieList& cookie_list) override {
+ IncrementAndCompareCounter("on_can_get_cookies_count");
+ return false;
+ }
+
+ bool OnCanSetCookie(const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options) override {
+ IncrementAndCompareCounter("on_can_set_cookie_count");
+ return false;
+ }
+
+ bool OnCanAccessFile(const URLRequest& request,
+ const base::FilePath& path) const override {
+ IncrementAndCompareCounter("on_can_access_file_count");
+ return false;
+ }
+
+ bool OnCanThrottleRequest(const URLRequest& request) const override {
+ IncrementAndCompareCounter("on_can_throttle_request_count");
+ return false;
+ }
+
+ bool OnCanEnablePrivacyMode(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const override {
+ IncrementAndCompareCounter("on_can_enable_privacy_mode_count");
+ return false;
+ }
+
+ bool OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const override {
+ IncrementAndCompareCounter(
+ "on_cancel_url_request_with_policy_violating_referrer_header_count");
+ return false;
+ }
+
+ private:
+ void IncrementAndCompareCounter(const char* counter_name) const {
+ ++counters_[counter_name];
+ EXPECT_EQ((*layered_network_delegate_counters_)[counter_name],
+ counters_[counter_name]);
+ }
+
+ mutable CountersMap counters_;
+ mutable CountersMap* layered_network_delegate_counters_;
+
+ DISALLOW_COPY_AND_ASSIGN(TestNetworkDelegateImpl);
+};
+
+class TestLayeredNetworkDelegate : public LayeredNetworkDelegate {
+ public:
+ TestLayeredNetworkDelegate(scoped_ptr<NetworkDelegate> network_delegate,
+ CountersMap* counters)
+ : LayeredNetworkDelegate(network_delegate.Pass()),
+ context_(true),
+ counters_(counters) {
+ context_.Init();
+ }
+
+ ~TestLayeredNetworkDelegate() override {}
+
+ void CallAndVerify() {
+ scoped_refptr<AuthChallengeInfo> auth_challenge(new AuthChallengeInfo());
+ scoped_ptr<URLRequest> request =
+ context_.CreateRequest(GURL(), IDLE, &delegate_, NULL);
+ scoped_ptr<HttpRequestHeaders> request_headers(new HttpRequestHeaders());
+ scoped_refptr<HttpResponseHeaders> response_headers(
+ new HttpResponseHeaders(""));
+ TestCompletionCallback completion_callback;
+ scoped_ptr<ProxyService> proxy_service(ProxyService::CreateDirect());
+ scoped_ptr<ProxyInfo> proxy_info(new ProxyInfo());
+
+ EXPECT_EQ(OK, OnBeforeURLRequest(request.get(),
+ completion_callback.callback(), NULL));
+ OnResolveProxy(GURL(), 0, *proxy_service, proxy_info.get());
+ OnProxyFallback(ProxyServer(), 0);
+ EXPECT_EQ(OK, OnBeforeSendHeaders(NULL, completion_callback.callback(),
+ request_headers.get()));
+ OnBeforeSendProxyHeaders(NULL, ProxyInfo(), request_headers.get());
+ OnSendHeaders(NULL, *request_headers);
+ EXPECT_EQ(OK, OnHeadersReceived(NULL, completion_callback.callback(),
+ response_headers.get(), NULL, NULL));
+ OnResponseStarted(request.get());
+ OnRawBytesRead(*request, 0);
+ OnCompleted(request.get(), false);
+ OnURLRequestDestroyed(request.get());
+ OnPACScriptError(0, base::string16());
+ EXPECT_EQ(
+ NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION,
+ OnAuthRequired(request.get(), *auth_challenge, AuthCallback(), NULL));
+ EXPECT_FALSE(OnCanGetCookies(*request, CookieList()));
+ EXPECT_FALSE(OnCanSetCookie(*request, std::string(), NULL));
+ EXPECT_FALSE(OnCanAccessFile(*request, base::FilePath()));
+ EXPECT_FALSE(OnCanThrottleRequest(*request));
+ EXPECT_FALSE(OnCanEnablePrivacyMode(GURL(), GURL()));
+ EXPECT_FALSE(OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+ *request, GURL(), GURL()));
+ }
+
+ protected:
+ void OnBeforeURLRequestInternal(URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url) override {
+ ++(*counters_)["on_before_url_request_count"];
+ EXPECT_EQ(1, (*counters_)["on_before_url_request_count"]);
+ }
+
+ void OnResolveProxyInternal(const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result) override {
+ ++(*counters_)["on_resolve_proxy_count"];
+ EXPECT_EQ(1, (*counters_)["on_resolve_proxy_count"]);
+ }
+
+ void OnProxyFallbackInternal(const ProxyServer& bad_proxy,
+ int net_error) override {
+ ++(*counters_)["on_proxy_fallback_count"];
+ EXPECT_EQ(1, (*counters_)["on_proxy_fallback_count"]);
+ }
+
+ void OnBeforeSendHeadersInternal(URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers) override {
+ ++(*counters_)["on_before_send_headers_count"];
+ EXPECT_EQ(1, (*counters_)["on_before_send_headers_count"]);
+ }
+
+ void OnBeforeSendProxyHeadersInternal(URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers) override {
+ ++(*counters_)["on_before_send_proxy_headers_count"];
+ EXPECT_EQ(1, (*counters_)["on_before_send_proxy_headers_count"]);
+ }
+
+ void OnSendHeadersInternal(URLRequest* request,
+ const HttpRequestHeaders& headers) override {
+ ++(*counters_)["on_send_headers_count"];
+ EXPECT_EQ(1, (*counters_)["on_send_headers_count"]);
+ }
+
+ void OnHeadersReceivedInternal(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url) override {
+ ++(*counters_)["on_headers_received_count"];
+ EXPECT_EQ(1, (*counters_)["on_headers_received_count"]);
+ }
+
+ void OnBeforeRedirectInternal(URLRequest* request,
+ const GURL& new_location) override {
+ ++(*counters_)["on_before_redirect_count"];
+ EXPECT_EQ(1, (*counters_)["on_before_redirect_count"]);
+ }
+
+ void OnResponseStartedInternal(URLRequest* request) override {
+ ++(*counters_)["on_response_started_count"];
+ EXPECT_EQ(1, (*counters_)["on_response_started_count"]);
+ }
+
+ void OnRawBytesReadInternal(const URLRequest& request,
+ int bytes_read) override {
+ ++(*counters_)["on_raw_bytes_read_count"];
+ EXPECT_EQ(1, (*counters_)["on_raw_bytes_read_count"]);
+ }
+
+ void OnCompletedInternal(URLRequest* request, bool started) override {
+ ++(*counters_)["on_completed_count"];
+ EXPECT_EQ(1, (*counters_)["on_completed_count"]);
+ }
+
+ void OnURLRequestDestroyedInternal(URLRequest* request) override {
+ ++(*counters_)["on_url_request_destroyed_count"];
+ EXPECT_EQ(1, (*counters_)["on_url_request_destroyed_count"]);
+ }
+
+ void OnPACScriptErrorInternal(int line_number,
+ const base::string16& error) override {
+ ++(*counters_)["on_pac_script_error_count"];
+ EXPECT_EQ(1, (*counters_)["on_pac_script_error_count"]);
+ }
+
+ void OnAuthRequiredInternal(URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials) override {
+ ++(*counters_)["on_auth_required_count"];
+ EXPECT_EQ(1, (*counters_)["on_auth_required_count"]);
+ }
+
+ void OnCanGetCookiesInternal(const URLRequest& request,
+ const CookieList& cookie_list) override {
+ ++(*counters_)["on_can_get_cookies_count"];
+ EXPECT_EQ(1, (*counters_)["on_can_get_cookies_count"]);
+ }
+
+ void OnCanSetCookieInternal(const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options) override {
+ ++(*counters_)["on_can_set_cookie_count"];
+ EXPECT_EQ(1, (*counters_)["on_can_set_cookie_count"]);
+ }
+
+ void OnCanAccessFileInternal(const URLRequest& request,
+ const base::FilePath& path) const override {
+ ++(*counters_)["on_can_access_file_count"];
+ EXPECT_EQ(1, (*counters_)["on_can_access_file_count"]);
+ }
+
+ void OnCanThrottleRequestInternal(const URLRequest& request) const override {
+ ++(*counters_)["on_can_throttle_request_count"];
+ EXPECT_EQ(1, (*counters_)["on_can_throttle_request_count"]);
+ }
+
+ void OnCanEnablePrivacyModeInternal(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const override {
+ ++(*counters_)["on_can_enable_privacy_mode_count"];
+ EXPECT_EQ(1, (*counters_)["on_can_enable_privacy_mode_count"]);
+ }
+
+ void OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const override {
+ ++(*counters_)
+ ["on_cancel_url_request_with_policy_"
+ "violating_referrer_header_count"];
+ EXPECT_EQ(1, (*counters_)
+ ["on_cancel_url_request_with_policy_"
+ "violating_referrer_header_count"]);
+ }
+
+ private:
+ TestURLRequestContext context_;
+ TestDelegate delegate_;
+ mutable CountersMap* counters_;
+
+ DISALLOW_COPY_AND_ASSIGN(TestLayeredNetworkDelegate);
+};
+
+} // namespace
+
+class LayeredNetworkDelegateTest : public testing::Test {
+ public:
+ LayeredNetworkDelegateTest() {
+ scoped_ptr<TestNetworkDelegateImpl> test_network_delegate(
+ new TestNetworkDelegateImpl(&layered_network_delegate_counters));
+ test_network_delegate_ = test_network_delegate.get();
+ layered_network_delegate_ =
+ scoped_ptr<TestLayeredNetworkDelegate>(new TestLayeredNetworkDelegate(
+ test_network_delegate.Pass(), &layered_network_delegate_counters));
+ }
+
+ CountersMap layered_network_delegate_counters;
+ TestNetworkDelegateImpl* test_network_delegate_;
+ scoped_ptr<TestLayeredNetworkDelegate> layered_network_delegate_;
+};
+
+TEST_F(LayeredNetworkDelegateTest, VerifyLayeredNetworkDelegateInternal) {
+ layered_network_delegate_->CallAndVerify();
+}
+
+} // namespace net
diff --git a/net/base/net_util.cc b/net/base/net_util.cc
index 6f28068..3b49dff 100644
--- a/net/base/net_util.cc
+++ b/net/base/net_util.cc
@@ -107,7 +107,6 @@
143, // imap2
179, // BGP
389, // ldap
- 443, // https / wss (see https://crbug.com/436451)
465, // smtp+ssl
512, // print / exec
513, // login
@@ -145,11 +144,6 @@
22, // ssh
};
-// HTTPS and WSS override the following restricted port.
-static const int kAllowedHttpsOrWssPorts[] = {
- 443, // https / wss
-};
-
bool IPNumberPrefixCheck(const IPAddressNumber& ip_number,
const unsigned char* ip_prefix,
size_t prefix_length_in_bits) {
@@ -326,29 +320,6 @@
return IsPortAllowedByDefault(port);
}
-bool IsPortAllowedByHttpsOrWss(int port) {
- int array_size = arraysize(kAllowedHttpsOrWssPorts);
- for (int i = 0; i < array_size; i++) {
- if (kAllowedHttpsOrWssPorts[i] == port) {
- return true;
- }
- }
- // Port not explicitly allowed by HTTPS or WSS, so return the default
- // restrictions.
- return IsPortAllowedByDefault(port);
-}
-
-bool IsEffectivePortAllowedByScheme(const GURL& url) {
- int port = url.EffectiveIntPort();
- if (url.SchemeIs("ftp")) {
- return IsPortAllowedByFtp(port);
- } else if (url.SchemeIs("https") || url.SchemeIs("wss")) {
- return IsPortAllowedByHttpsOrWss(port);
- } else {
- return IsPortAllowedByDefault(port);
- }
-}
-
bool IsPortAllowedByOverride(int port) {
if (g_explicitly_allowed_ports.Get().empty())
return false;
diff --git a/net/base/net_util.h b/net/base/net_util.h
index 9802097..9e9dbad 100644
--- a/net/base/net_util.h
+++ b/net/base/net_util.h
@@ -260,15 +260,6 @@
// protocol. Returns true if |port| is allowed, false if it is restricted.
NET_EXPORT_PRIVATE bool IsPortAllowedByFtp(int port);
-// Checks |port| against a list of ports which are restricted by the HTTPS/WSS
-// protocols. Returns true if |port| is allowed, false if it is restricted.
-NET_EXPORT_PRIVATE bool IsPortAllowedByHttpsOrWss(int port);
-
-// Checks the effective port of the |url| against a list of ports which are
-// restricted by the scheme of the |url|. Returns true if the port is allowed,
-// false if it is restricted.
-NET_EXPORT_PRIVATE bool IsEffectivePortAllowedByScheme(const GURL& url);
-
// Check if banned |port| has been overriden by an entry in
// |explicitly_allowed_ports_|.
NET_EXPORT_PRIVATE bool IsPortAllowedByOverride(int port);
diff --git a/net/base/network_delegate.cc b/net/base/network_delegate.cc
index d4aa19e..b6858da 100644
--- a/net/base/network_delegate.cc
+++ b/net/base/network_delegate.cc
@@ -242,108 +242,4 @@
request, target_url, referrer_url);
}
-int NetworkDelegate::OnBeforeURLRequest(URLRequest* request,
- const CompletionCallback& callback,
- GURL* new_url) {
- return OK;
-}
-
-void NetworkDelegate::OnResolveProxy(
- const GURL& url,
- int load_flags,
- const ProxyService& proxy_service,
- ProxyInfo* result) {
-}
-
-void NetworkDelegate::OnProxyFallback(const ProxyServer& bad_proxy,
- int net_error) {
-}
-
-int NetworkDelegate::OnBeforeSendHeaders(URLRequest* request,
- const CompletionCallback& callback,
- HttpRequestHeaders* headers) {
- return OK;
-}
-
-void NetworkDelegate::OnBeforeSendProxyHeaders(
- URLRequest* request,
- const ProxyInfo& proxy_info,
- HttpRequestHeaders* headers) {
-}
-
-void NetworkDelegate::OnSendHeaders(URLRequest* request,
- const HttpRequestHeaders& headers) {
-}
-
-int NetworkDelegate::OnHeadersReceived(
- URLRequest* request,
- const CompletionCallback& callback,
- const HttpResponseHeaders* original_response_headers,
- scoped_refptr<HttpResponseHeaders>* override_response_headers,
- GURL* allowed_unsafe_redirect_url) {
- return OK;
-}
-
-void NetworkDelegate::OnBeforeRedirect(URLRequest* request,
- const GURL& new_location) {
-}
-
-void NetworkDelegate::OnResponseStarted(URLRequest* request) {
-}
-
-void NetworkDelegate::OnRawBytesRead(const URLRequest& request,
- int bytes_read) {
-}
-
-void NetworkDelegate::OnCompleted(URLRequest* request, bool started) {
-}
-
-void NetworkDelegate::OnURLRequestDestroyed(URLRequest* request) {
-}
-
-void NetworkDelegate::OnPACScriptError(int line_number,
- const base::string16& error) {
-}
-
-NetworkDelegate::AuthRequiredResponse NetworkDelegate::OnAuthRequired(
- URLRequest* request,
- const AuthChallengeInfo& auth_info,
- const AuthCallback& callback,
- AuthCredentials* credentials) {
- return AUTH_REQUIRED_RESPONSE_NO_ACTION;
-}
-
-bool NetworkDelegate::OnCanGetCookies(const URLRequest& request,
- const CookieList& cookie_list) {
- return true;
-}
-
-bool NetworkDelegate::OnCanSetCookie(const URLRequest& request,
- const std::string& cookie_line,
- CookieOptions* options) {
- return true;
-}
-
-bool NetworkDelegate::OnCanAccessFile(const URLRequest& request,
- const base::FilePath& path) const {
- return false;
-}
-
-bool NetworkDelegate::OnCanThrottleRequest(const URLRequest& request) const {
- return false;
-}
-
-bool NetworkDelegate::OnCanEnablePrivacyMode(
- const GURL& url,
- const GURL& first_party_for_cookies) const {
- return false;
-}
-
-bool NetworkDelegate::OnCancelURLRequestWithPolicyViolatingReferrerHeader(
- const URLRequest& request,
- const GURL& target_url,
- const GURL& referrer_url) const {
- return false;
-}
-
} // namespace net
diff --git a/net/base/network_delegate.h b/net/base/network_delegate.h
index a169fc6..5af2ac1 100644
--- a/net/base/network_delegate.h
+++ b/net/base/network_delegate.h
@@ -128,7 +128,7 @@
// The default implementation returns OK (continue with request).
virtual int OnBeforeURLRequest(URLRequest* request,
const CompletionCallback& callback,
- GURL* new_url);
+ GURL* new_url) = 0;
// Called as the proxy is being resolved for |url|. Allows the delegate to
// override the proxy resolution decision made by ProxyService. The delegate
@@ -136,14 +136,13 @@
virtual void OnResolveProxy(const GURL& url,
int load_flags,
const ProxyService& proxy_service,
- ProxyInfo* result);
+ ProxyInfo* result) = 0;
// Called when use of |bad_proxy| fails due to |net_error|. |net_error| is
// the network error encountered, if any, and OK if the fallback was
// for a reason other than a network error (e.g. the proxy service was
// explicitly directed to skip a proxy).
- virtual void OnProxyFallback(const ProxyServer& bad_proxy,
- int net_error);
+ virtual void OnProxyFallback(const ProxyServer& bad_proxy, int net_error) = 0;
// Called right before the HTTP headers are sent. Allows the delegate to
// read/write |headers| before they get sent out. |callback| and |headers| are
@@ -152,20 +151,20 @@
// See OnBeforeURLRequest for return value description. Returns OK by default.
virtual int OnBeforeSendHeaders(URLRequest* request,
const CompletionCallback& callback,
- HttpRequestHeaders* headers);
+ HttpRequestHeaders* headers) = 0;
// Called after a proxy connection. Allows the delegate to read/write
// |headers| before they get sent out. |headers| is valid only until
// OnCompleted or OnURLRequestDestroyed is called for this request.
virtual void OnBeforeSendProxyHeaders(URLRequest* request,
const ProxyInfo& proxy_info,
- HttpRequestHeaders* headers);
+ HttpRequestHeaders* headers) = 0;
// Called right before the HTTP request(s) are being sent to the network.
// |headers| is only valid until OnCompleted or OnURLRequestDestroyed is
// called for this request.
virtual void OnSendHeaders(URLRequest* request,
- const HttpRequestHeaders& headers);
+ const HttpRequestHeaders& headers) = 0;
// Called for HTTP requests when the headers have been received.
// |original_response_headers| contains the headers as received over the
@@ -185,33 +184,33 @@
const CompletionCallback& callback,
const HttpResponseHeaders* original_response_headers,
scoped_refptr<HttpResponseHeaders>* override_response_headers,
- GURL* allowed_unsafe_redirect_url);
+ GURL* allowed_unsafe_redirect_url) = 0;
// Called right after a redirect response code was received.
// |new_location| is only valid until OnURLRequestDestroyed is called for this
// request.
virtual void OnBeforeRedirect(URLRequest* request,
- const GURL& new_location);
+ const GURL& new_location) = 0;
// This corresponds to URLRequestDelegate::OnResponseStarted.
- virtual void OnResponseStarted(URLRequest* request);
+ virtual void OnResponseStarted(URLRequest* request) = 0;
// Called every time we read raw bytes.
- virtual void OnRawBytesRead(const URLRequest& request, int bytes_read);
+ virtual void OnRawBytesRead(const URLRequest& request, int bytes_read) = 0;
// Indicates that the URL request has been completed or failed.
// |started| indicates whether the request has been started. If false,
// some information like the socket address is not available.
- virtual void OnCompleted(URLRequest* request, bool started);
+ virtual void OnCompleted(URLRequest* request, bool started) = 0;
// Called when an URLRequest is being destroyed. Note that the request is
// being deleted, so it's not safe to call any methods that may result in
// a virtual method call.
- virtual void OnURLRequestDestroyed(URLRequest* request);
+ virtual void OnURLRequestDestroyed(URLRequest* request) = 0;
// Corresponds to ProxyResolverJSBindings::OnError.
virtual void OnPACScriptError(int line_number,
- const base::string16& error);
+ const base::string16& error) = 0;
// Called when a request receives an authentication challenge
// specified by |auth_info|, and is unable to respond using cached
@@ -234,38 +233,38 @@
URLRequest* request,
const AuthChallengeInfo& auth_info,
const AuthCallback& callback,
- AuthCredentials* credentials);
+ AuthCredentials* credentials) = 0;
// Called when reading cookies to allow the network delegate to block access
// to the cookie. This method will never be invoked when
// LOAD_DO_NOT_SEND_COOKIES is specified.
virtual bool OnCanGetCookies(const URLRequest& request,
- const CookieList& cookie_list);
+ const CookieList& cookie_list) = 0;
// Called when a cookie is set to allow the network delegate to block access
// to the cookie. This method will never be invoked when
// LOAD_DO_NOT_SAVE_COOKIES is specified.
virtual bool OnCanSetCookie(const URLRequest& request,
const std::string& cookie_line,
- CookieOptions* options);
+ CookieOptions* options) = 0;
// Called when a file access is attempted to allow the network delegate to
// allow or block access to the given file path. Returns true if access is
// allowed.
virtual bool OnCanAccessFile(const URLRequest& request,
- const base::FilePath& path) const;
+ const base::FilePath& path) const = 0;
// Returns true if the given request may be rejected when the
// URLRequestThrottlerManager believes the server servicing the
// request is overloaded or down.
- virtual bool OnCanThrottleRequest(const URLRequest& request) const;
+ virtual bool OnCanThrottleRequest(const URLRequest& request) const = 0;
// Returns true if the given |url| has to be requested over connection that
// is not tracked by the server. Usually is false, unless user privacy
// settings block cookies from being get or set.
virtual bool OnCanEnablePrivacyMode(
const GURL& url,
- const GURL& first_party_for_cookies) const;
+ const GURL& first_party_for_cookies) const = 0;
// Called when the |referrer_url| for requesting |target_url| during handling
// of the |request| is does not comply with the referrer policy (e.g. a
@@ -275,7 +274,7 @@
virtual bool OnCancelURLRequestWithPolicyViolatingReferrerHeader(
const URLRequest& request,
const GURL& target_url,
- const GURL& referrer_url) const;
+ const GURL& referrer_url) const = 0;
};
} // namespace net
diff --git a/net/base/network_delegate_impl.cc b/net/base/network_delegate_impl.cc
new file mode 100644
index 0000000..f10bee3
--- /dev/null
+++ b/net/base/network_delegate_impl.cc
@@ -0,0 +1,115 @@
+// 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 "net/base/network_delegate_impl.h"
+
+#include "net/base/net_errors.h"
+
+namespace net {
+
+int NetworkDelegateImpl::OnBeforeURLRequest(URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url) {
+ return OK;
+}
+
+void NetworkDelegateImpl::OnResolveProxy(const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result) {
+}
+
+void NetworkDelegateImpl::OnProxyFallback(const ProxyServer& bad_proxy,
+ int net_error) {
+}
+
+int NetworkDelegateImpl::OnBeforeSendHeaders(URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers) {
+ return OK;
+}
+
+void NetworkDelegateImpl::OnBeforeSendProxyHeaders(
+ URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers) {
+}
+
+void NetworkDelegateImpl::OnSendHeaders(URLRequest* request,
+ const HttpRequestHeaders& headers) {
+}
+
+int NetworkDelegateImpl::OnHeadersReceived(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url) {
+ return OK;
+}
+
+void NetworkDelegateImpl::OnBeforeRedirect(URLRequest* request,
+ const GURL& new_location) {
+}
+
+void NetworkDelegateImpl::OnResponseStarted(URLRequest* request) {
+}
+
+void NetworkDelegateImpl::OnRawBytesRead(const URLRequest& request,
+ int bytes_read) {
+}
+
+void NetworkDelegateImpl::OnCompleted(URLRequest* request, bool started) {
+}
+
+void NetworkDelegateImpl::OnURLRequestDestroyed(URLRequest* request) {
+}
+
+void NetworkDelegateImpl::OnPACScriptError(int line_number,
+ const base::string16& error) {
+}
+
+NetworkDelegate::AuthRequiredResponse NetworkDelegateImpl::OnAuthRequired(
+ URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials) {
+ return AUTH_REQUIRED_RESPONSE_NO_ACTION;
+}
+
+bool NetworkDelegateImpl::OnCanGetCookies(const URLRequest& request,
+ const CookieList& cookie_list) {
+ return true;
+}
+
+bool NetworkDelegateImpl::OnCanSetCookie(const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options) {
+ return true;
+}
+
+bool NetworkDelegateImpl::OnCanAccessFile(const URLRequest& request,
+ const base::FilePath& path) const {
+ return false;
+}
+
+bool NetworkDelegateImpl::OnCanThrottleRequest(
+ const URLRequest& request) const {
+ return false;
+}
+
+bool NetworkDelegateImpl::OnCanEnablePrivacyMode(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const {
+ return false;
+}
+
+bool NetworkDelegateImpl::OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const {
+ return false;
+}
+
+} // namespace net
diff --git a/net/base/network_delegate_impl.h b/net/base/network_delegate_impl.h
new file mode 100644
index 0000000..f5e9def
--- /dev/null
+++ b/net/base/network_delegate_impl.h
@@ -0,0 +1,200 @@
+// 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 NET_BASE_NETWORK_DELEGATE_IMPL_H_
+#define NET_BASE_NETWORK_DELEGATE_IMPL_H_
+
+#include "base/strings/string16.h"
+#include "net/base/completion_callback.h"
+#include "net/base/network_delegate.h"
+#include "net/cookies/canonical_cookie.h"
+
+class GURL;
+
+namespace base {
+class FilePath;
+}
+
+namespace net {
+
+class CookieOptions;
+class HttpRequestHeaders;
+class HttpResponseHeaders;
+class ProxyInfo;
+class ProxyServer;
+class ProxyService;
+class URLRequest;
+
+class NET_EXPORT NetworkDelegateImpl : public NetworkDelegate {
+ public:
+ virtual ~NetworkDelegateImpl() {}
+
+ private:
+ // This is the interface for subclasses of NetworkDelegate to implement. These
+ // member functions will be called by the respective public notification
+ // member function, which will perform basic sanity checking.
+
+ // Called before a request is sent. Allows the delegate to rewrite the URL
+ // being fetched by modifying |new_url|. If set, the URL must be valid. The
+ // reference fragment from the original URL is not automatically appended to
+ // |new_url|; callers are responsible for copying the reference fragment if
+ // desired.
+ // |callback| and |new_url| are valid only until OnURLRequestDestroyed is
+ // called for this request. Returns a net status code, generally either OK to
+ // continue with the request or ERR_IO_PENDING if the result is not ready yet.
+ // A status code other than OK and ERR_IO_PENDING will cancel the request and
+ // report the status code as the reason.
+ //
+ // The default implementation returns OK (continue with request).
+ int OnBeforeURLRequest(URLRequest* request,
+ const CompletionCallback& callback,
+ GURL* new_url) override;
+
+ // Called as the proxy is being resolved for |url|. Allows the delegate to
+ // override the proxy resolution decision made by ProxyService. The delegate
+ // may override the decision by modifying the ProxyInfo |result|.
+ void OnResolveProxy(const GURL& url,
+ int load_flags,
+ const ProxyService& proxy_service,
+ ProxyInfo* result) override;
+
+ // Called when use of |bad_proxy| fails due to |net_error|. |net_error| is
+ // the network error encountered, if any, and OK if the fallback was
+ // for a reason other than a network error (e.g. the proxy service was
+ // explicitly directed to skip a proxy).
+ void OnProxyFallback(const ProxyServer& bad_proxy, int net_error) override;
+
+ // Called right before the HTTP headers are sent. Allows the delegate to
+ // read/write |headers| before they get sent out. |callback| and |headers| are
+ // valid only until OnCompleted or OnURLRequestDestroyed is called for this
+ // request.
+ // See OnBeforeURLRequest for return value description. Returns OK by default.
+ int OnBeforeSendHeaders(URLRequest* request,
+ const CompletionCallback& callback,
+ HttpRequestHeaders* headers) override;
+
+ // Called after a proxy connection. Allows the delegate to read/write
+ // |headers| before they get sent out. |headers| is valid only until
+ // OnCompleted or OnURLRequestDestroyed is called for this request.
+ void OnBeforeSendProxyHeaders(URLRequest* request,
+ const ProxyInfo& proxy_info,
+ HttpRequestHeaders* headers) override;
+
+ // Called right before the HTTP request(s) are being sent to the network.
+ // |headers| is only valid until OnCompleted or OnURLRequestDestroyed is
+ // called for this request.
+ void OnSendHeaders(URLRequest* request,
+ const HttpRequestHeaders& headers) override;
+
+ // Called for HTTP requests when the headers have been received.
+ // |original_response_headers| contains the headers as received over the
+ // network, these must not be modified. |override_response_headers| can be set
+ // to new values, that should be considered as overriding
+ // |original_response_headers|.
+ // If the response is a redirect, and the Location response header value is
+ // identical to |allowed_unsafe_redirect_url|, then the redirect is never
+ // blocked and the reference fragment is not copied from the original URL
+ // to the redirection target.
+ //
+ // |callback|, |original_response_headers|, and |override_response_headers|
+ // are only valid until OnURLRequestDestroyed is called for this request.
+ // See OnBeforeURLRequest for return value description. Returns OK by default.
+ int OnHeadersReceived(
+ URLRequest* request,
+ const CompletionCallback& callback,
+ const HttpResponseHeaders* original_response_headers,
+ scoped_refptr<HttpResponseHeaders>* override_response_headers,
+ GURL* allowed_unsafe_redirect_url) override;
+
+ // Called right after a redirect response code was received.
+ // |new_location| is only valid until OnURLRequestDestroyed is called for this
+ // request.
+ void OnBeforeRedirect(URLRequest* request, const GURL& new_location) override;
+
+ // This corresponds to URLRequestDelegate::OnResponseStarted.
+ void OnResponseStarted(URLRequest* request) override;
+
+ // Called every time we read raw bytes.
+ void OnRawBytesRead(const URLRequest& request, int bytes_read) override;
+
+ // Indicates that the URL request has been completed or failed.
+ // |started| indicates whether the request has been started. If false,
+ // some information like the socket address is not available.
+ void OnCompleted(URLRequest* request, bool started) override;
+
+ // Called when an URLRequest is being destroyed. Note that the request is
+ // being deleted, so it's not safe to call any methods that may result in
+ // a virtual method call.
+ void OnURLRequestDestroyed(URLRequest* request) override;
+
+ // Corresponds to ProxyResolverJSBindings::OnError.
+ void OnPACScriptError(int line_number, const base::string16& error) override;
+
+ // Called when a request receives an authentication challenge
+ // specified by |auth_info|, and is unable to respond using cached
+ // credentials. |callback| and |credentials| must be non-NULL, and must
+ // be valid until OnURLRequestDestroyed is called for |request|.
+ //
+ // The following return values are allowed:
+ // - AUTH_REQUIRED_RESPONSE_NO_ACTION: |auth_info| is observed, but
+ // no action is being taken on it.
+ // - AUTH_REQUIRED_RESPONSE_SET_AUTH: |credentials| is filled in with
+ // a username and password, which should be used in a response to
+ // |auth_info|.
+ // - AUTH_REQUIRED_RESPONSE_CANCEL_AUTH: The authentication challenge
+ // should not be attempted.
+ // - AUTH_REQUIRED_RESPONSE_IO_PENDING: The action will be decided
+ // asynchronously. |callback| will be invoked when the decision is made,
+ // and one of the other AuthRequiredResponse values will be passed in with
+ // the same semantics as described above.
+ AuthRequiredResponse OnAuthRequired(URLRequest* request,
+ const AuthChallengeInfo& auth_info,
+ const AuthCallback& callback,
+ AuthCredentials* credentials) override;
+
+ // Called when reading cookies to allow the network delegate to block access
+ // to the cookie. This method will never be invoked when
+ // LOAD_DO_NOT_SEND_COOKIES is specified.
+ bool OnCanGetCookies(const URLRequest& request,
+ const CookieList& cookie_list) override;
+
+ // Called when a cookie is set to allow the network delegate to block access
+ // to the cookie. This method will never be invoked when
+ // LOAD_DO_NOT_SAVE_COOKIES is specified.
+ bool OnCanSetCookie(const URLRequest& request,
+ const std::string& cookie_line,
+ CookieOptions* options) override;
+
+ // Called when a file access is attempted to allow the network delegate to
+ // allow or block access to the given file path. Returns true if access is
+ // allowed.
+ bool OnCanAccessFile(const URLRequest& request,
+ const base::FilePath& path) const override;
+
+ // Returns true if the given request may be rejected when the
+ // URLRequestThrottlerManager believes the server servicing the
+ // request is overloaded or down.
+ bool OnCanThrottleRequest(const URLRequest& request) const override;
+
+ // Returns true if the given |url| has to be requested over connection that
+ // is not tracked by the server. Usually is false, unless user privacy
+ // settings block cookies from being get or set.
+ bool OnCanEnablePrivacyMode(
+ const GURL& url,
+ const GURL& first_party_for_cookies) const override;
+
+ // Called when the |referrer_url| for requesting |target_url| during handling
+ // of the |request| is does not comply with the referrer policy (e.g. a
+ // secure referrer for an insecure initial target).
+ // Returns true if the request should be cancelled. Otherwise, the referrer
+ // header is stripped from the request.
+ bool OnCancelURLRequestWithPolicyViolatingReferrerHeader(
+ const URLRequest& request,
+ const GURL& target_url,
+ const GURL& referrer_url) const override;
+};
+
+} // namespace net
+
+#endif // NET_BASE_NETWORK_DELEGATE_IMPL_H_
diff --git a/net/base/test_completion_callback.h b/net/base/test_completion_callback.h
index c1f715c..11ebb05 100644
--- a/net/base/test_completion_callback.h
+++ b/net/base/test_completion_callback.h
@@ -7,7 +7,6 @@
#include "base/callback.h"
#include "base/compiler_specific.h"
-#include "base/tuple.h"
#include "net/base/completion_callback.h"
#include "net/base/net_errors.h"
diff --git a/net/disk_cache/disk_cache_test_util.h b/net/disk_cache/disk_cache_test_util.h
index ad6b6ac..0f40f5e 100644
--- a/net/disk_cache/disk_cache_test_util.h
+++ b/net/disk_cache/disk_cache_test_util.h
@@ -10,7 +10,6 @@
#include "base/files/file_path.h"
#include "base/message_loop/message_loop.h"
#include "base/timer/timer.h"
-#include "base/tuple.h"
#include "build/build_config.h"
// Re-creates a given test file inside the cache test folder.
diff --git a/net/http/http_stream_factory_impl_job.cc b/net/http/http_stream_factory_impl_job.cc
index 5887d2a..8369443 100644
--- a/net/http/http_stream_factory_impl_job.cc
+++ b/net/http/http_stream_factory_impl_job.cc
@@ -623,15 +623,15 @@
&request_info_.url, &origin_url_,
priority_));
+ // Don't connect to restricted ports.
+ bool is_port_allowed = IsPortAllowedByDefault(origin_.port());
if (request_info_.url.SchemeIs("ftp")) {
// Never share connection with other jobs for FTP requests.
DCHECK(!waiting_job_);
- }
- // Don't connect to restricted ports.
- // Note: origin_.port() == request_info_.url.EffectiveIntPort()
- if (!IsEffectivePortAllowedByScheme(request_info_.url) &&
- !IsPortAllowedByOverride(origin_.port())) {
+ is_port_allowed = IsPortAllowedByFtp(origin_.port());
+ }
+ if (!is_port_allowed && !IsPortAllowedByOverride(origin_.port())) {
if (waiting_job_) {
waiting_job_->Resume(this);
waiting_job_ = NULL;
diff --git a/net/net.gypi b/net/net.gypi
index f9f6d23..7d7d2f0 100644
--- a/net/net.gypi
+++ b/net/net.gypi
@@ -266,6 +266,8 @@
'base/network_config_watcher_mac.h',
'base/network_delegate.cc',
'base/network_delegate.h',
+ 'base/network_delegate_impl.cc',
+ 'base/network_delegate_impl.h',
'base/nss_memio.c',
'base/nss_memio.h',
'base/platform_mime_util.h',
@@ -308,6 +310,8 @@
'base/winsock_init.h',
'base/winsock_util.cc',
'base/winsock_util.h',
+ 'base/layered_network_delegate.cc',
+ 'base/layered_network_delegate.h',
'cert/cert_database_android.cc',
'cert/cert_database_ios.cc',
'cert/cert_database_mac.cc',
@@ -1299,6 +1303,7 @@
'base/upload_bytes_element_reader_unittest.cc',
'base/upload_file_element_reader_unittest.cc',
'base/url_util_unittest.cc',
+ 'base/layered_network_delegate_unittest.cc',
'cert/cert_policy_enforcer_unittest.cc',
'cert/cert_verify_proc_unittest.cc',
'cert/crl_set_unittest.cc',
diff --git a/net/proxy/network_delegate_error_observer_unittest.cc b/net/proxy/network_delegate_error_observer_unittest.cc
index da87f8d..0a2e01a 100644
--- a/net/proxy/network_delegate_error_observer_unittest.cc
+++ b/net/proxy/network_delegate_error_observer_unittest.cc
@@ -9,14 +9,14 @@
#include "base/message_loop/message_loop_proxy.h"
#include "base/threading/thread.h"
#include "net/base/net_errors.h"
-#include "net/base/network_delegate.h"
+#include "net/base/network_delegate_impl.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
-class TestNetworkDelegate : public net::NetworkDelegate {
+class TestNetworkDelegate : public net::NetworkDelegateImpl {
public:
TestNetworkDelegate() : got_pac_error_(false) {}
~TestNetworkDelegate() override {}
diff --git a/net/proxy/proxy_script_fetcher_impl_unittest.cc b/net/proxy/proxy_script_fetcher_impl_unittest.cc
index 4c5bd4c..52c248f 100644
--- a/net/proxy/proxy_script_fetcher_impl_unittest.cc
+++ b/net/proxy/proxy_script_fetcher_impl_unittest.cc
@@ -12,6 +12,7 @@
#include "base/strings/utf_string_conversions.h"
#include "net/base/filename_util.h"
#include "net/base/load_flags.h"
+#include "net/base/network_delegate_impl.h"
#include "net/base/test_completion_callback.h"
#include "net/cert/mock_cert_verifier.h"
#include "net/disk_cache/disk_cache.h"
@@ -107,7 +108,7 @@
// without introducing layering violations. Also causes a test failure if a
// request is seen that doesn't set a load flag to bypass revocation checking.
-class BasicNetworkDelegate : public NetworkDelegate {
+class BasicNetworkDelegate : public NetworkDelegateImpl {
public:
BasicNetworkDelegate() {}
~BasicNetworkDelegate() override {}
diff --git a/net/proxy/proxy_service_unittest.cc b/net/proxy/proxy_service_unittest.cc
index cfaaccf..84ce101 100644
--- a/net/proxy/proxy_service_unittest.cc
+++ b/net/proxy/proxy_service_unittest.cc
@@ -14,7 +14,7 @@
#include "net/base/net_errors.h"
#include "net/base/net_log.h"
#include "net/base/net_log_unittest.h"
-#include "net/base/network_delegate.h"
+#include "net/base/network_delegate_impl.h"
#include "net/base/test_completion_callback.h"
#include "net/proxy/dhcp_proxy_script_fetcher.h"
#include "net/proxy/mock_proxy_resolver.h"
@@ -158,7 +158,7 @@
};
// A test network delegate that exercises the OnResolveProxy callback.
-class TestResolveProxyNetworkDelegate : public NetworkDelegate {
+class TestResolveProxyNetworkDelegate : public NetworkDelegateImpl {
public:
TestResolveProxyNetworkDelegate()
: on_resolve_proxy_called_(false),
@@ -205,7 +205,7 @@
};
// A test network delegate that exercises the OnProxyFallback callback.
-class TestProxyFallbackNetworkDelegate : public NetworkDelegate {
+class TestProxyFallbackNetworkDelegate : public NetworkDelegateImpl {
public:
TestProxyFallbackNetworkDelegate()
: on_proxy_fallback_called_(false),
@@ -507,7 +507,7 @@
// Now, imagine that connecting to foopy:8080 fails: there is nothing
// left to fallback to, since our proxy list was NOT terminated by
// DIRECT.
- NetworkDelegate network_delegate;
+ NetworkDelegateImpl network_delegate;
TestCompletionCallback callback2;
ProxyServer expected_proxy_server = info.proxy_server();
rv = service.ReconsiderProxyAfterError(
@@ -618,7 +618,7 @@
EXPECT_EQ("foobar:10", info.proxy_server().ToURI());
// Fallback 2.
- NetworkDelegate network_delegate;
+ NetworkDelegateImpl network_delegate;
ProxyServer expected_proxy_server3 = info.proxy_server();
TestCompletionCallback callback3;
rv = service.ReconsiderProxyAfterError(url, net::LOAD_NORMAL,
diff --git a/net/socket/client_socket_pool_manager.cc b/net/socket/client_socket_pool_manager.cc
index bc7d111..8b6c17c 100644
--- a/net/socket/client_socket_pool_manager.cc
+++ b/net/socket/client_socket_pool_manager.cc
@@ -129,7 +129,8 @@
// should be the same for all connections, whereas version_max may
// change for version fallbacks.
std::string prefix = "ssl/";
- if (ssl_config_for_origin.version_max != kDefaultSSLVersionMax) {
+ if (ssl_config_for_origin.version_max !=
+ SSLClientSocket::GetMaxSupportedSSLVersion()) {
switch (ssl_config_for_origin.version_max) {
case SSL_PROTOCOL_VERSION_TLS1_2:
prefix = "ssl(max:3.3)/";
diff --git a/net/ssl/ssl_config.cc b/net/ssl/ssl_config.cc
index 8efdd58..56cb75c 100644
--- a/net/ssl/ssl_config.cc
+++ b/net/ssl/ssl_config.cc
@@ -4,12 +4,12 @@
#include "net/ssl/ssl_config.h"
+#include "net/socket/ssl_client_socket.h"
+
namespace net {
const uint16 kDefaultSSLVersionMin = SSL_PROTOCOL_VERSION_TLS1;
-const uint16 kDefaultSSLVersionMax = SSL_PROTOCOL_VERSION_TLS1_2;
-
const uint16 kDefaultSSLVersionFallbackMin = SSL_PROTOCOL_VERSION_TLS1;
SSLConfig::CertAndStatus::CertAndStatus() : cert_status(0) {}
@@ -20,7 +20,7 @@
: rev_checking_enabled(false),
rev_checking_required_local_anchors(false),
version_min(kDefaultSSLVersionMin),
- version_max(kDefaultSSLVersionMax),
+ version_max(SSLClientSocket::GetMaxSupportedSSLVersion()),
version_fallback_min(kDefaultSSLVersionFallbackMin),
channel_id_enabled(true),
false_start_enabled(true),
diff --git a/net/ssl/ssl_config.h b/net/ssl/ssl_config.h
index 1deaf6e..5a0c0fa 100644
--- a/net/ssl/ssl_config.h
+++ b/net/ssl/ssl_config.h
@@ -29,8 +29,8 @@
// Default minimum protocol version.
NET_EXPORT extern const uint16 kDefaultSSLVersionMin;
-// Default maximum protocol version.
-NET_EXPORT extern const uint16 kDefaultSSLVersionMax;
+// For maximum supported protocol version, use
+// SSLClientSocket::GetMaxSupportedSSLVersion().
// Default minimum protocol version that it's acceptable to fallback to.
NET_EXPORT extern const uint16 kDefaultSSLVersionFallbackMin;
diff --git a/net/test/android/javatests/src/org/chromium/net/test/util/TestWebServer.java b/net/test/android/javatests/src/org/chromium/net/test/util/TestWebServer.java
index 6121a2a..dd40220 100644
--- a/net/test/android/javatests/src/org/chromium/net/test/util/TestWebServer.java
+++ b/net/test/android/javatests/src/org/chromium/net/test/util/TestWebServer.java
@@ -612,8 +612,9 @@
HttpParams params = new BasicHttpParams();
params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_0);
while (!mIsCancelled) {
+ Socket socket = null;
try {
- Socket socket = mSocket.accept();
+ socket = mSocket.accept();
DefaultHttpServerConnection conn = new DefaultHttpServerConnection();
conn.bind(socket, params);
@@ -628,8 +629,9 @@
HttpResponse response = mServer.getResponse(request);
conn.sendResponseHeader(response);
conn.sendResponseEntity(response);
- conn.close();
+ conn.close();
+ socket = null;
} catch (IOException e) {
// normal during shutdown, ignore
Log.w(TAG, e);
@@ -641,6 +643,18 @@
// DefaultHttpServerConnection's close() throws an
// UnsupportedOperationException.
Log.w(TAG, e);
+ } finally {
+ // Since DefaultHttpServerConnection can raise an exception
+ // during conn.close() (in the case of SSL), we always force
+ // the socket to close, since it may be left open. This will
+ // be a no-op if the connection managed to close the socket.
+ if (socket != null) {
+ try {
+ socket.close();
+ } catch (IOException ignored) {
+ // safe to ignore
+ }
+ }
}
}
try {
diff --git a/net/url_request/url_request_context_builder.cc b/net/url_request/url_request_context_builder.cc
index 838aa7b..c2e1135 100644
--- a/net/url_request/url_request_context_builder.cc
+++ b/net/url_request/url_request_context_builder.cc
@@ -14,7 +14,7 @@
#include "base/threading/thread.h"
#include "net/base/cache_type.h"
#include "net/base/net_errors.h"
-#include "net/base/network_delegate.h"
+#include "net/base/network_delegate_impl.h"
#include "net/cert/cert_verifier.h"
#include "net/cookies/cookie_monster.h"
#include "net/dns/host_resolver.h"
@@ -48,7 +48,7 @@
namespace {
-class BasicNetworkDelegate : public NetworkDelegate {
+class BasicNetworkDelegate : public NetworkDelegateImpl {
public:
BasicNetworkDelegate() {}
~BasicNetworkDelegate() override {}
diff --git a/net/url_request/url_request_test_util.h b/net/url_request/url_request_test_util.h
index 1c385b2..9ad66a1 100644
--- a/net/url_request/url_request_test_util.h
+++ b/net/url_request/url_request_test_util.h
@@ -23,7 +23,7 @@
#include "net/base/io_buffer.h"
#include "net/base/load_timing_info.h"
#include "net/base/net_errors.h"
-#include "net/base/network_delegate.h"
+#include "net/base/network_delegate_impl.h"
#include "net/base/request_priority.h"
#include "net/base/sdch_manager.h"
#include "net/cert/cert_verifier.h"
@@ -220,7 +220,7 @@
//-----------------------------------------------------------------------------
-class TestNetworkDelegate : public NetworkDelegate {
+class TestNetworkDelegate : public NetworkDelegateImpl {
public:
enum Options {
NO_GET_COOKIES = 1 << 0,
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 099a319..3835aef 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -5437,25 +5437,6 @@
}
}
-// Make sure an HTTP request using the "unsafe" port 443 fails.
-// See: https://crbug.com/436451
-TEST_F(URLRequestTestHTTP, UnsafePort) {
- TestDelegate d;
- {
- scoped_ptr<URLRequest> r(default_context_.CreateRequest(
- GURL("http://www.google.com:443/"), DEFAULT_PRIORITY, &d, NULL));
-
- r->Start();
- EXPECT_TRUE(r->is_pending());
-
- base::RunLoop().Run();
-
- EXPECT_FALSE(r->is_pending());
- EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
- EXPECT_EQ(ERR_UNSAFE_PORT, r->status().error());
- }
-}
-
// Tests that redirection to an unsafe URL is allowed when it has been marked as
// safe.
TEST_F(URLRequestTestHTTP, UnsafeRedirectToWhitelistedUnsafeURL) {
diff --git a/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions_unittests.cc b/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions_unittests.cc
index 264ee4d..01ad1f2 100644
--- a/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions_unittests.cc
+++ b/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions_unittests.cc
@@ -227,8 +227,8 @@
};
BPF_TEST_C(ParameterRestrictions, prlimit64_allowed, RestrictPrlimit64Policy) {
- BPF_ASSERT_EQ(0, syscall(__NR_prlimit64, 0, RLIMIT_AS, NULL, NULL));
- BPF_ASSERT_EQ(0, syscall(__NR_prlimit64, getpid(), RLIMIT_AS, NULL, NULL));
+ BPF_ASSERT_EQ(0, sys_prlimit64(0, RLIMIT_AS, NULL, NULL));
+ BPF_ASSERT_EQ(0, sys_prlimit64(getpid(), RLIMIT_AS, NULL, NULL));
}
BPF_DEATH_TEST_C(ParameterRestrictions,
@@ -237,7 +237,7 @@
RestrictPrlimit64Policy) {
const pid_t kInitPID = 1;
BPF_ASSERT_NE(kInitPID, getpid());
- syscall(__NR_prlimit64, kInitPID, RLIMIT_AS, NULL, NULL);
+ sys_prlimit64(kInitPID, RLIMIT_AS, NULL, NULL);
}
} // namespace
diff --git a/sandbox/linux/services/syscall_wrappers.cc b/sandbox/linux/services/syscall_wrappers.cc
index ede4964..c368519 100644
--- a/sandbox/linux/services/syscall_wrappers.cc
+++ b/sandbox/linux/services/syscall_wrappers.cc
@@ -4,7 +4,9 @@
#include "sandbox/linux/services/syscall_wrappers.h"
+#include <sys/resource.h>
#include <sys/syscall.h>
+#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
@@ -62,4 +64,11 @@
return syscall(__NR_seccomp, operation, flags, args);
}
+int sys_prlimit64(pid_t pid,
+ int resource,
+ const struct rlimit64* new_limit,
+ struct rlimit64* old_limit) {
+ return syscall(__NR_prlimit64, pid, resource, new_limit, old_limit);
+}
+
} // namespace sandbox
diff --git a/sandbox/linux/services/syscall_wrappers.h b/sandbox/linux/services/syscall_wrappers.h
index 15ec81b..64028f7 100644
--- a/sandbox/linux/services/syscall_wrappers.h
+++ b/sandbox/linux/services/syscall_wrappers.h
@@ -10,6 +10,7 @@
#include "sandbox/sandbox_export.h"
struct sock_fprog;
+struct rlimit64;
namespace sandbox {
@@ -38,6 +39,12 @@
unsigned int flags,
const struct sock_fprog* args);
+// Some libcs do not expose a prlimit64 wrapper.
+SANDBOX_EXPORT int sys_prlimit64(pid_t pid,
+ int resource,
+ const struct rlimit64* new_limit,
+ struct rlimit64* old_limit);
+
} // namespace sandbox
#endif // SANDBOX_LINUX_SERVICES_SYSCALL_WRAPPERS_H_
diff --git a/services/surfaces/surfaces_scheduler.cc b/services/surfaces/surfaces_scheduler.cc
index cc3df42..6e099f4 100644
--- a/services/surfaces/surfaces_scheduler.cc
+++ b/services/surfaces/surfaces_scheduler.cc
@@ -64,7 +64,7 @@
scheduler_->DidCreateAndInitializeOutputSurface();
}
-void SurfacesScheduler::ScheduledActionManageTiles() {
+void SurfacesScheduler::ScheduledActionPrepareTiles() {
}
void SurfacesScheduler::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
diff --git a/services/surfaces/surfaces_scheduler.h b/services/surfaces/surfaces_scheduler.h
index 01a5da9..e985973 100644
--- a/services/surfaces/surfaces_scheduler.h
+++ b/services/surfaces/surfaces_scheduler.h
@@ -36,7 +36,7 @@
void ScheduledActionCommit() override;
void ScheduledActionActivateSyncTree() override;
void ScheduledActionBeginOutputSurfaceCreation() override;
- void ScheduledActionManageTiles() override;
+ void ScheduledActionPrepareTiles() override;
void DidAnticipatedDrawTimeChange(base::TimeTicks time) override;
base::TimeDelta DrawDurationEstimate() override;
base::TimeDelta BeginMainFrameToCommitDurationEstimate() override;
diff --git a/skia/ext/analysis_canvas.cc b/skia/ext/analysis_canvas.cc
index 17e8390..e5e702e 100644
--- a/skia/ext/analysis_canvas.cc
+++ b/skia/ext/analysis_canvas.cc
@@ -203,14 +203,6 @@
++draw_op_count_;
}
-void AnalysisCanvas::drawBitmapMatrix(const SkBitmap& bitmap,
- const SkMatrix& matrix,
- const SkPaint* paint) {
- is_solid_color_ = false;
- is_transparent_ = false;
- ++draw_op_count_;
-}
-
void AnalysisCanvas::drawBitmapNine(const SkBitmap& bitmap,
const SkIRect& center,
const SkRect& dst,
diff --git a/skia/ext/analysis_canvas.h b/skia/ext/analysis_canvas.h
index 105ff2c..53a91d3 100644
--- a/skia/ext/analysis_canvas.h
+++ b/skia/ext/analysis_canvas.h
@@ -48,9 +48,6 @@
const SkRect& dst,
const SkPaint* paint,
DrawBitmapRectFlags flags) override;
- void drawBitmapMatrix(const SkBitmap&,
- const SkMatrix&,
- const SkPaint* paint = NULL) override;
void drawBitmapNine(const SkBitmap& bitmap,
const SkIRect& center,
const SkRect& dst,
diff --git a/skia/ext/benchmarking_canvas.cc b/skia/ext/benchmarking_canvas.cc
index 64d3f6c..72541cd 100644
--- a/skia/ext/benchmarking_canvas.cc
+++ b/skia/ext/benchmarking_canvas.cc
@@ -6,6 +6,7 @@
#include "base/logging.h"
#include "base/time/time.h"
#include "skia/ext/benchmarking_canvas.h"
+#include "third_party/skia/include/core/SkSurface.h"
#include "third_party/skia/include/utils/SkProxyCanvas.h"
namespace skia {
@@ -24,9 +25,9 @@
public:
TimingCanvas(int width, int height, const BenchmarkingCanvas* track_canvas)
: tracking_canvas_(track_canvas) {
- canvas_ = skia::AdoptRef(SkCanvas::NewRasterN32(width, height));
+ surface_ = skia::AdoptRef(SkSurface::NewRasterPMColor(width, height));
- setProxy(canvas_.get());
+ setProxy(surface_->getCanvas());
}
~TimingCanvas() override {}
@@ -106,13 +107,6 @@
SkProxyCanvas::drawBitmapRectToRect(bitmap, src, dst, paint, flags);
}
- void drawBitmapMatrix(const SkBitmap& bitmap,
- const SkMatrix& m,
- const SkPaint* paint = NULL) override {
- AutoStamper stamper(this);
- SkProxyCanvas::drawBitmapMatrix(bitmap, m, paint);
- }
-
void drawSprite(const SkBitmap& bitmap,
int left,
int top,
@@ -213,7 +207,7 @@
typedef base::hash_map<size_t, base::TimeDelta> TimingsMap;
TimingsMap timings_map_;
- skia::RefPtr<SkCanvas> canvas_;
+ skia::RefPtr<SkSurface> surface_;
friend class AutoStamper;
const BenchmarkingCanvas* tracking_canvas_;
diff --git a/skia/ext/bitmap_platform_device_cairo.cc b/skia/ext/bitmap_platform_device_cairo.cc
index e9dcf3b..a331bed 100644
--- a/skia/ext/bitmap_platform_device_cairo.cc
+++ b/skia/ext/bitmap_platform_device_cairo.cc
@@ -185,12 +185,6 @@
return cairo_;
}
-void BitmapPlatformDevice::DrawToNativeContext(
- PlatformSurface surface, int x, int y, const PlatformRect* src_rect) {
- // Should never be called on Linux.
- SkASSERT(false);
-}
-
void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform,
const SkRegion& region,
const SkClipStack&) {
diff --git a/skia/ext/bitmap_platform_device_cairo.h b/skia/ext/bitmap_platform_device_cairo.h
index 67a2f19..938dd15 100644
--- a/skia/ext/bitmap_platform_device_cairo.h
+++ b/skia/ext/bitmap_platform_device_cairo.h
@@ -89,8 +89,6 @@
// Overridden from PlatformDevice:
virtual cairo_t* BeginPlatformPaint() override;
- virtual void DrawToNativeContext(PlatformSurface surface, int x, int y,
- const PlatformRect* src_rect) override;
protected:
virtual SkBaseDevice* onCreateCompatibleDevice(const CreateInfo& info)
diff --git a/skia/ext/bitmap_platform_device_mac.cc b/skia/ext/bitmap_platform_device_mac.cc
index 53569c8..ff7c2ad 100644
--- a/skia/ext/bitmap_platform_device_mac.cc
+++ b/skia/ext/bitmap_platform_device_mac.cc
@@ -200,37 +200,6 @@
SetMatrixClip(transform, region);
}
-void BitmapPlatformDevice::DrawToNativeContext(CGContextRef context, int x,
- int y, const CGRect* src_rect) {
- bool created_dc = false;
- if (!bitmap_context_) {
- created_dc = true;
- GetBitmapContext();
- }
-
- // this should not make a copy of the bits, since we're not doing
- // anything to trigger copy on write
- CGImageRef image = CGBitmapContextCreateImage(bitmap_context_);
- CGRect bounds;
- bounds.origin.x = x;
- bounds.origin.y = y;
- if (src_rect) {
- bounds.size.width = src_rect->size.width;
- bounds.size.height = src_rect->size.height;
- CGImageRef sub_image = CGImageCreateWithImageInRect(image, *src_rect);
- CGContextDrawImage(context, bounds, sub_image);
- CGImageRelease(sub_image);
- } else {
- bounds.size.width = width();
- bounds.size.height = height();
- CGContextDrawImage(context, bounds, image);
- }
- CGImageRelease(image);
-
- if (created_dc)
- ReleaseBitmapContext();
-}
-
SkBaseDevice* BitmapPlatformDevice::onCreateCompatibleDevice(
const CreateInfo& cinfo) {
const SkImageInfo& info = cinfo.fInfo;
diff --git a/skia/ext/bitmap_platform_device_mac.h b/skia/ext/bitmap_platform_device_mac.h
index 33ce214..6c8dc84 100644
--- a/skia/ext/bitmap_platform_device_mac.h
+++ b/skia/ext/bitmap_platform_device_mac.h
@@ -47,10 +47,6 @@
// PlatformDevice overrides
CGContextRef GetBitmapContext() override;
- void DrawToNativeContext(CGContextRef context,
- int x,
- int y,
- const CGRect* src_rect) override;
// SkBaseDevice overrides
void setMatrixClip(const SkMatrix& transform,
diff --git a/skia/ext/bitmap_platform_device_skia.cc b/skia/ext/bitmap_platform_device_skia.cc
index d057913..136706d 100644
--- a/skia/ext/bitmap_platform_device_skia.cc
+++ b/skia/ext/bitmap_platform_device_skia.cc
@@ -55,12 +55,6 @@
return accessBitmap(true).getPixels();
}
-void BitmapPlatformDevice::DrawToNativeContext(
- PlatformSurface surface, int x, int y, const PlatformRect* src_rect) {
- // Should never be called on Android.
- SkASSERT(false);
-}
-
// PlatformCanvas impl
SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque,
diff --git a/skia/ext/bitmap_platform_device_skia.h b/skia/ext/bitmap_platform_device_skia.h
index dfbee56..90a2a9a 100644
--- a/skia/ext/bitmap_platform_device_skia.h
+++ b/skia/ext/bitmap_platform_device_skia.h
@@ -38,8 +38,6 @@
virtual ~BitmapPlatformDevice();
virtual PlatformSurface BeginPlatformPaint() override;
- virtual void DrawToNativeContext(PlatformSurface surface, int x, int y,
- const PlatformRect* src_rect) override;
protected:
virtual SkBaseDevice* onCreateCompatibleDevice(const CreateInfo& info)
diff --git a/skia/ext/bitmap_platform_device_win.cc b/skia/ext/bitmap_platform_device_win.cc
index 71bb800..0f16694 100644
--- a/skia/ext/bitmap_platform_device_win.cc
+++ b/skia/ext/bitmap_platform_device_win.cc
@@ -55,6 +55,15 @@
namespace skia {
+void DrawToNativeContext(SkCanvas* canvas, HDC hdc, int x, int y,
+ const RECT* src_rect) {
+ PlatformDevice* platform_device = GetPlatformDevice(GetTopDevice(*canvas));
+ if (platform_device)
+ platform_device->DrawToHDC(hdc, x, y, src_rect);
+}
+
+void PlatformDevice::DrawToHDC(HDC, int x, int y, const RECT* src_rect) {}
+
HDC BitmapPlatformDevice::GetBitmapDC() {
if (!hdc_) {
hdc_ = CreateCompatibleDC(NULL);
@@ -202,8 +211,8 @@
SetMatrixClip(transform, region);
}
-void BitmapPlatformDevice::DrawToNativeContext(HDC dc, int x, int y,
- const RECT* src_rect) {
+void BitmapPlatformDevice::DrawToHDC(HDC dc, int x, int y,
+ const RECT* src_rect) {
bool created_dc = !IsBitmapDCCreated();
HDC source_dc = BeginPlatformPaint();
diff --git a/skia/ext/bitmap_platform_device_win.h b/skia/ext/bitmap_platform_device_win.h
index 9e32de9..1b60018 100644
--- a/skia/ext/bitmap_platform_device_win.h
+++ b/skia/ext/bitmap_platform_device_win.h
@@ -50,14 +50,13 @@
virtual PlatformSurface BeginPlatformPaint() override;
virtual void EndPlatformPaint() override;
- virtual void DrawToNativeContext(HDC dc, int x, int y,
- const RECT* src_rect) override;
-
// Loads the given transform and clipping region into the HDC. This is
// overridden from SkBaseDevice.
virtual void setMatrixClip(const SkMatrix& transform, const SkRegion& region,
const SkClipStack&) override;
+ void DrawToHDC(HDC dc, int x, int y, const RECT* src_rect) override;
+
protected:
// Flushes the Windows device context so that the pixel data can be accessed
// directly by Skia. Overridden from SkBaseDevice, this is called when Skia
diff --git a/skia/ext/platform_canvas.cc b/skia/ext/platform_canvas.cc
index 6699b8b..9235967 100644
--- a/skia/ext/platform_canvas.cc
+++ b/skia/ext/platform_canvas.cc
@@ -32,13 +32,6 @@
platform_device->EndPlatformPaint();
}
-void DrawToNativeContext(SkCanvas* canvas, PlatformSurface context, int x,
- int y, const PlatformRect* src_rect) {
- PlatformDevice* platform_device = GetPlatformDevice(GetTopDevice(*canvas));
- if (platform_device)
- platform_device->DrawToNativeContext(context, x, y, src_rect);
-}
-
void MakeOpaque(SkCanvas* canvas, int x, int y, int width, int height) {
if (width <= 0 || height <= 0)
return;
diff --git a/skia/ext/platform_canvas.h b/skia/ext/platform_canvas.h
index 85ad85e..75458b5 100644
--- a/skia/ext/platform_canvas.h
+++ b/skia/ext/platform_canvas.h
@@ -43,6 +43,14 @@
bool is_opaque,
HANDLE shared_section,
OnFailureType failure_type);
+
+ // Draws the top layer of the canvas into the specified HDC. Only works
+ // with a PlatformCanvas with a BitmapPlatformDevice.
+ SK_API void DrawToNativeContext(SkCanvas* canvas,
+ HDC hdc,
+ int x,
+ int y,
+ const RECT* src_rect);
#elif defined(__APPLE__)
SK_API SkCanvas* CreatePlatformCanvas(CGContextRef context,
int width,
@@ -113,15 +121,6 @@
// return NULL PlatformSurface.
SK_API bool SupportsPlatformPaint(const SkCanvas* canvas);
-// Draws into the a native platform surface, |context|. Forwards to
-// DrawToNativeContext on a PlatformDevice instance bound to the top device.
-// If no PlatformDevice instance is bound, is a no-operation.
-SK_API void DrawToNativeContext(SkCanvas* canvas,
- PlatformSurface context,
- int x,
- int y,
- const PlatformRect* src_rect);
-
// Sets the opacity of each pixel in the specified region to be opaque.
SK_API void MakeOpaque(SkCanvas* canvas, int x, int y, int width, int height);
diff --git a/skia/ext/platform_device.h b/skia/ext/platform_device.h
index 7e77ff1..8486102 100644
--- a/skia/ext/platform_device.h
+++ b/skia/ext/platform_device.h
@@ -113,14 +113,6 @@
// Finish a previous call to beginPlatformPaint.
virtual void EndPlatformPaint();
- // Draws to the given screen DC, if the bitmap DC doesn't exist, this will
- // temporarily create it. However, if you have created the bitmap DC, it will
- // be more efficient if you don't free it until after this call so it doesn't
- // have to be created twice. If src_rect is null, then the entirety of the
- // source device will be copied.
- virtual void DrawToNativeContext(PlatformSurface surface, int x, int y,
- const PlatformRect* src_rect) = 0;
-
// Returns true if GDI operations can be used for drawing into the bitmap.
virtual bool SupportsPlatformPaint();
@@ -132,6 +124,14 @@
// Loads a SkRegion into the GDI context.
static void LoadClippingRegionToDC(HDC context, const SkRegion& region,
const SkMatrix& transformation);
+
+ // Draws to the given screen DC, if the bitmap DC doesn't exist, this will
+ // temporarily create it. However, if you have created the bitmap DC, it will
+ // be more efficient if you don't free it until after this call so it doesn't
+ // have to be created twice. If src_rect is null, then the entirety of the
+ // source device will be copied.
+ virtual void DrawToHDC(HDC, int x, int y, const RECT* src_rect);
+
#elif defined(OS_MACOSX)
// Loads a SkPath into the CG context. The path can there after be used for
// clipping or as a stroke.
diff --git a/skia/ext/platform_device_win.cc b/skia/ext/platform_device_win.cc
index f44e66e..ef48fbd 100644
--- a/skia/ext/platform_device_win.cc
+++ b/skia/ext/platform_device_win.cc
@@ -60,10 +60,6 @@
// Flushing will be done in onAccessBitmap.
}
-void PlatformDevice::DrawToNativeContext(PlatformSurface surface, int x, int y,
- const PlatformRect* src_rect) {
-}
-
// static
bool PlatformDevice::LoadPathToDC(HDC context, const SkPath& path) {
switch (path.getFillType()) {
diff --git a/skia/ext/vector_platform_device_emf_win.cc b/skia/ext/vector_platform_device_emf_win.cc
index 1271b16..85795b6 100644
--- a/skia/ext/vector_platform_device_emf_win.cc
+++ b/skia/ext/vector_platform_device_emf_win.cc
@@ -684,11 +684,6 @@
LoadClipRegion();
}
-void VectorPlatformDeviceEmf::DrawToNativeContext(HDC dc, int x, int y,
- const RECT* src_rect) {
- SkASSERT(false);
-}
-
void VectorPlatformDeviceEmf::LoadClipRegion() {
SkMatrix t;
t.reset();
diff --git a/skia/ext/vector_platform_device_emf_win.h b/skia/ext/vector_platform_device_emf_win.h
index 8d5b393..81b92af 100644
--- a/skia/ext/vector_platform_device_emf_win.h
+++ b/skia/ext/vector_platform_device_emf_win.h
@@ -32,8 +32,7 @@
// PlatformDevice methods
virtual PlatformSurface BeginPlatformPaint() override;
- virtual void DrawToNativeContext(HDC dc, int x, int y,
- const RECT* src_rect) override;
+
// SkBaseDevice methods.
virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) override;
virtual void drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
diff --git a/third_party/boringssl/boringssl.gypi b/third_party/boringssl/boringssl.gypi
index 35dfff5..af009d7 100644
--- a/third_party/boringssl/boringssl.gypi
+++ b/third_party/boringssl/boringssl.gypi
@@ -281,7 +281,6 @@
'src/crypto/x509v3/x509v3_error.c',
'src/ssl/d1_both.c',
'src/ssl/d1_clnt.c',
- 'src/ssl/d1_enc.c',
'src/ssl/d1_lib.c',
'src/ssl/d1_meth.c',
'src/ssl/d1_pkt.c',
diff --git a/third_party/cython/rules.gni b/third_party/cython/rules.gni
index 3938110..53125fe 100644
--- a/third_party/cython/rules.gni
+++ b/third_party/cython/rules.gni
@@ -63,6 +63,9 @@
if (defined(invoker.additional_sources)) {
sources += invoker.additional_sources
}
+ if (defined(invoker.configs)) {
+ configs += invoker.configs
+ }
all_dependent_configs = [ ":$config_name" ]
}
}
@@ -91,6 +94,9 @@
python_binary_module_sources(sources_target_name) {
visibility = target_visibility
sources = invoker.sources
+ if (defined(invoker.configs)) {
+ configs = invoker.configs
+ }
}
shared_library(shared_library_name) {
diff --git a/third_party/mesa/BUILD.gn b/third_party/mesa/BUILD.gn
index 4989a37..0b1f828 100644
--- a/third_party/mesa/BUILD.gn
+++ b/third_party/mesa/BUILD.gn
@@ -619,12 +619,13 @@
configs = []
configs = [ ":mesa_internal_config" ] + previous_configs
- cflags = []
-
if (is_clang) {
- cflags += [ "-Wno-absolute-value" ]
+ # Mesa triggers some of these Clang warnings.
+ configs -= [ "//build/config/clang:extra_warnings" ]
}
+ cflags = []
+
if (is_android && !is_clang) {
# Disable sincos() optimization to avoid a linker error
# since Android's math library doesn't have sincos().
diff --git a/third_party/mesa/mesa.gyp b/third_party/mesa/mesa.gyp
index 3db0d4c..056eb40 100644
--- a/third_party/mesa/mesa.gyp
+++ b/third_party/mesa/mesa.gyp
@@ -132,7 +132,6 @@
'variables': {
'clang_warning_flags': [
'-Wno-tautological-constant-out-of-range-compare',
- '-Wno-mismatched-tags', # Fixed upstream.
],
'clang_warning_flags_unset': [
# Don't warn about string->bool used in asserts.
@@ -270,8 +269,6 @@
'variables': {
'clang_warning_flags': [
'-Wno-tautological-constant-out-of-range-compare',
- '-Wno-absolute-value', # Fires on st_atom_array.c, might be a bug
- '-Wno-mismatched-tags', # Fixed upstream.
],
'clang_warning_flags_unset': [
# Don't warn about string->bool used in asserts.
diff --git a/third_party/protobuf/README.chromium b/third_party/protobuf/README.chromium
index 92391f6..8e51806 100644
--- a/third_party/protobuf/README.chromium
+++ b/third_party/protobuf/README.chromium
@@ -34,4 +34,7 @@
Revision 573 was cherry-picked from upstream.
The `&file->options() != NULL &&` was removed from descriptor.cc
References to `vector` were changed to `std::vector` in extension_set.h
-and unknown_field_set.h
\ No newline at end of file
+and unknown_field_set.h
+
+GetEmptyString() and GoogleOnceInit() have been uninlined, for a large savings
+in binary size.
diff --git a/third_party/protobuf/src/google/protobuf/generated_message_util.cc b/third_party/protobuf/src/google/protobuf/generated_message_util.cc
index 794be35..92882d7 100644
--- a/third_party/protobuf/src/google/protobuf/generated_message_util.cc
+++ b/third_party/protobuf/src/google/protobuf/generated_message_util.cc
@@ -54,6 +54,11 @@
empty_string_ = new std::string();
}
+const ::std::string& GetEmptyString() {
+ GoogleOnceInit(&empty_string_once_init_, &InitEmptyString);
+ return *empty_string_;
+}
+
} // namespace internal
} // namespace protobuf
} // namespace google
diff --git a/third_party/protobuf/src/google/protobuf/generated_message_util.h b/third_party/protobuf/src/google/protobuf/generated_message_util.h
index 098f321..6e4669c 100644
--- a/third_party/protobuf/src/google/protobuf/generated_message_util.h
+++ b/third_party/protobuf/src/google/protobuf/generated_message_util.h
@@ -67,10 +67,7 @@
LIBPROTOBUF_EXPORT void InitEmptyString();
-LIBPROTOBUF_EXPORT inline const ::std::string& GetEmptyString() {
- GoogleOnceInit(&empty_string_once_init_, &InitEmptyString);
- return *empty_string_;
-}
+LIBPROTOBUF_EXPORT const ::std::string& GetEmptyString();
// Defined in generated_message_reflection.cc -- not actually part of the lite
// library.
diff --git a/third_party/protobuf/src/google/protobuf/stubs/once.cc b/third_party/protobuf/src/google/protobuf/stubs/once.cc
index 1e24b85..2363622 100644
--- a/third_party/protobuf/src/google/protobuf/stubs/once.cc
+++ b/third_party/protobuf/src/google/protobuf/stubs/once.cc
@@ -93,6 +93,13 @@
}
}
+void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()) {
+ if (internal::Acquire_Load(once) != ONCE_STATE_DONE) {
+ internal::FunctionClosure0 func(init_func, false);
+ GoogleOnceInitImpl(once, &func);
+ }
+}
+
} // namespace protobuf
} // namespace google
diff --git a/third_party/protobuf/src/google/protobuf/stubs/once.h b/third_party/protobuf/src/google/protobuf/stubs/once.h
index 7fbc117..9f1c5fc 100644
--- a/third_party/protobuf/src/google/protobuf/stubs/once.h
+++ b/third_party/protobuf/src/google/protobuf/stubs/once.h
@@ -121,12 +121,8 @@
LIBPROTOBUF_EXPORT
void GoogleOnceInitImpl(ProtobufOnceType* once, Closure* closure);
-inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()) {
- if (internal::Acquire_Load(once) != ONCE_STATE_DONE) {
- internal::FunctionClosure0 func(init_func, false);
- GoogleOnceInitImpl(once, &func);
- }
-}
+LIBPROTOBUF_EXPORT
+void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)());
template <typename Arg>
inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)(Arg*),
diff --git a/ui/compositor/compositor.h b/ui/compositor/compositor.h
index bbed8ec..a937886 100644
--- a/ui/compositor/compositor.h
+++ b/ui/compositor/compositor.h
@@ -243,6 +243,7 @@
void Layout() override;
void ApplyViewportDeltas(const gfx::Vector2d& inner_delta,
const gfx::Vector2d& outer_delta,
+ const gfx::Vector2dF& elastic_overscroll_delta,
float page_scale,
float top_controls_delta) override {}
void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
diff --git a/ui/gl/gl_bindings_skia_in_process.cc b/ui/gl/gl_bindings_skia_in_process.cc
index cfcb7a3..5ce7821 100644
--- a/ui/gl/gl_bindings_skia_in_process.cc
+++ b/ui/gl/gl_bindings_skia_in_process.cc
@@ -318,6 +318,11 @@
glGetShaderiv(shader, pname, params);
}
+GLvoid StubGLGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
+ GLint *range, GLint *precision) {
+ glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+}
+
const GLubyte* StubGLGetString(GLenum name) {
return glGetString(name);
}
@@ -675,6 +680,7 @@
functions->fGetProgramiv = StubGLGetProgramiv;
functions->fGetShaderInfoLog = StubGLGetShaderInfoLog;
functions->fGetShaderiv = StubGLGetShaderiv;
+ functions->fGetShaderPrecisionFormat = StubGLGetShaderPrecisionFormat;
functions->fGetString = StubGLGetString;
functions->fGetTexLevelParameteriv = StubGLGetTexLevelParameteriv;
functions->fGetUniformLocation = StubGLGetUniformLocation;
diff --git a/ui/gl/gl_surface_egl.cc b/ui/gl/gl_surface_egl.cc
index 3a453b6..4018834 100644
--- a/ui/gl/gl_surface_egl.cc
+++ b/ui/gl/gl_surface_egl.cc
@@ -395,12 +395,12 @@
return false;
}
- EGLint surfaceVal;
- EGLBoolean retVal = eglQuerySurface(GetDisplay(),
- surface_,
- EGL_POST_SUB_BUFFER_SUPPORTED_NV,
- &surfaceVal);
- supports_post_sub_buffer_ = (surfaceVal && retVal) == EGL_TRUE;
+ if (gfx::g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
+ EGLint surfaceVal;
+ EGLBoolean retVal = eglQuerySurface(
+ GetDisplay(), surface_, EGL_POST_SUB_BUFFER_SUPPORTED_NV, &surfaceVal);
+ supports_post_sub_buffer_ = (surfaceVal && retVal) == EGL_TRUE;
+ }
if (sync_provider)
vsync_provider_.reset(sync_provider.release());
