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