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());