gpu: Remove async texture uploads.

This removes the usage of async texture uploads from cc/
and all support for it from the GPU service.

Follow up changes will provide significant cleanup and
some performance improvements in cc/ as a result of this.

BUG=499372
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1186393004

Cr-Commit-Position: refs/heads/master@{#345908}

119 files changed, 105 insertions, 6731 deletions

diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 43ae5e4..c136a6d 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -360,8 +360,6 @@ component("cc") {
     "raster/gpu_tile_task_worker_pool.h",
     "raster/one_copy_tile_task_worker_pool.cc",
     "raster/one_copy_tile_task_worker_pool.h",
-    "raster/pixel_buffer_tile_task_worker_pool.cc",
-    "raster/pixel_buffer_tile_task_worker_pool.h",
     "raster/raster_buffer.cc",
     "raster/raster_buffer.h",
     "raster/scoped_gpu_raster.cc",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 288fdc7..9a6e610 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -418,8 +418,6 @@
         'raster/gpu_tile_task_worker_pool.h',
         'raster/one_copy_tile_task_worker_pool.cc',
         'raster/one_copy_tile_task_worker_pool.h',
-        'raster/pixel_buffer_tile_task_worker_pool.cc',
-        'raster/pixel_buffer_tile_task_worker_pool.h',
         'raster/raster_buffer.cc',
         'raster/raster_buffer.h',
         'raster/scoped_gpu_raster.cc',
diff --git a/cc/layers/picture_layer_unittest.cc b/cc/layers/picture_layer_unittest.cc
index 8cace5e..8c397b4f 100644
--- a/cc/layers/picture_layer_unittest.cc
+++ b/cc/layers/picture_layer_unittest.cc
@@ -126,7 +126,6 @@ TEST(PictureLayerTest, NonMonotonicSourceFrameNumber) {
   LayerTreeSettings settings;
   settings.single_thread_proxy_scheduler = false;
   settings.use_zero_copy = true;
-  settings.use_one_copy = false;
 
   FakeLayerTreeHostClient host_client1(FakeLayerTreeHostClient::DIRECT_3D);
   FakeLayerTreeHostClient host_client2(FakeLayerTreeHostClient::DIRECT_3D);
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index ebbe7dd..f9bdb71 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -121,7 +121,6 @@ class ScrollbarLayerTest : public testing::Test {
   ScrollbarLayerTest() : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {
     layer_tree_settings_.single_thread_proxy_scheduler = false;
     layer_tree_settings_.use_zero_copy = true;
-    layer_tree_settings_.use_one_copy = false;
 
     LayerTreeHost::InitParams params;
     params.client = &fake_client_;
diff --git a/cc/raster/pixel_buffer_tile_task_worker_pool.cc b/cc/raster/pixel_buffer_tile_task_worker_pool.cc
deleted file mode 100644
index d965135..0000000
--- a/cc/raster/pixel_buffer_tile_task_worker_pool.cc
+++ /dev/null
@@ -1,755 +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/raster/pixel_buffer_tile_task_worker_pool.h"
-
-#include <algorithm>
-
-#include "base/containers/stack_container.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "cc/debug/traced_value.h"
-#include "cc/raster/raster_buffer.h"
-#include "cc/resources/platform_color.h"
-#include "cc/resources/resource.h"
-#include "gpu/command_buffer/client/gles2_interface.h"
-
-namespace cc {
-namespace {
-
-class RasterBufferImpl : public RasterBuffer {
- public:
-  RasterBufferImpl(ResourceProvider* resource_provider,
-                   const Resource* resource)
-      : resource_provider_(resource_provider),
-        resource_(resource),
-        memory_(NULL),
-        stride_(0) {
-    resource_provider_->AcquirePixelBuffer(resource_->id());
-    memory_ = resource_provider_->MapPixelBuffer(resource_->id(), &stride_);
-  }
-
-  ~RasterBufferImpl() override {
-    resource_provider_->ReleasePixelBuffer(resource_->id());
-  }
-
-  // Overridden from RasterBuffer:
-  void Playback(const RasterSource* raster_source,
-                const gfx::Rect& raster_full_rect,
-                const gfx::Rect& raster_dirty_rect,
-                uint64_t new_content_id,
-                float scale,
-                bool include_images) override {
-    if (!memory_)
-      return;
-
-    // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides.
-    DCHECK_GE(stride_, 0);
-    TileTaskWorkerPool::PlaybackToMemory(
-        memory_, resource_->format(), resource_->size(),
-        static_cast<size_t>(stride_), raster_source, raster_full_rect,
-        raster_full_rect, scale, include_images);
-  }
-
- private:
-  ResourceProvider* resource_provider_;
-  const Resource* resource_;
-  uint8_t* memory_;
-  int stride_;
-
-  DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
-};
-
-const int kCheckForCompletedRasterTasksDelayMs = 6;
-
-const size_t kMaxScheduledRasterTasks = 48;
-
-typedef base::StackVector<RasterTask*, kMaxScheduledRasterTasks>
-    RasterTaskVector;
-
-TaskSetCollection NonEmptyTaskSetsFromTaskCounts(const size_t* task_counts) {
-  TaskSetCollection task_sets;
-  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
-    if (task_counts[task_set])
-      task_sets[task_set] = true;
-  }
-  return task_sets;
-}
-
-void AddTaskSetsToTaskCounts(size_t* task_counts,
-                             const TaskSetCollection& task_sets) {
-  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
-    if (task_sets[task_set])
-      task_counts[task_set]++;
-  }
-}
-
-void RemoveTaskSetsFromTaskCounts(size_t* task_counts,
-                                  const TaskSetCollection& task_sets) {
-  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
-    if (task_sets[task_set])
-      task_counts[task_set]--;
-  }
-}
-
-}  // namespace
-
-PixelBufferTileTaskWorkerPool::RasterTaskState::RasterTaskState(
-    RasterTask* task,
-    const TaskSetCollection& task_sets)
-    : type(UNSCHEDULED), task(task), task_sets(task_sets) {
-}
-
-// static
-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<TileTaskWorkerPool>(new PixelBufferTileTaskWorkerPool(
-      task_runner, task_graph_runner, context_provider, resource_provider,
-      max_transfer_buffer_usage_bytes));
-}
-
-PixelBufferTileTaskWorkerPool::PixelBufferTileTaskWorkerPool(
-    base::SequencedTaskRunner* task_runner,
-    TaskGraphRunner* task_graph_runner,
-    ContextProvider* context_provider,
-    ResourceProvider* resource_provider,
-    size_t max_transfer_buffer_usage_bytes)
-    : task_runner_(task_runner),
-      task_graph_runner_(task_graph_runner),
-      namespace_token_(task_graph_runner->GetNamespaceToken()),
-      context_provider_(context_provider),
-      resource_provider_(resource_provider),
-      shutdown_(false),
-      scheduled_raster_task_count_(0u),
-      bytes_pending_upload_(0u),
-      max_bytes_pending_upload_(max_transfer_buffer_usage_bytes),
-      has_performed_uploads_since_last_flush_(false),
-      check_for_completed_raster_task_notifier_(
-          task_runner,
-          base::Bind(
-              &PixelBufferTileTaskWorkerPool::CheckForCompletedRasterTasks,
-              base::Unretained(this)),
-          base::TimeDelta::FromMilliseconds(
-              kCheckForCompletedRasterTasksDelayMs)),
-      task_set_finished_weak_ptr_factory_(this) {
-  DCHECK(context_provider_);
-  std::fill(task_counts_, task_counts_ + kNumberOfTaskSets, 0);
-}
-
-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());
-  DCHECK_EQ(0u, completed_image_decode_tasks_.size());
-  DCHECK(NonEmptyTaskSetsFromTaskCounts(task_counts_).none());
-}
-
-TileTaskRunner* PixelBufferTileTaskWorkerPool::AsTileTaskRunner() {
-  return this;
-}
-
-void PixelBufferTileTaskWorkerPool::SetClient(TileTaskRunnerClient* client) {
-  client_ = client;
-}
-
-void PixelBufferTileTaskWorkerPool::Shutdown() {
-  TRACE_EVENT0("cc", "PixelBufferTileTaskWorkerPool::Shutdown");
-
-  shutdown_ = true;
-
-  TaskGraph empty;
-  task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
-  task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-
-  CheckForCompletedRasterizerTasks();
-  CheckForCompletedUploads();
-
-  check_for_completed_raster_task_notifier_.Shutdown();
-
-  for (RasterTaskState::Vector::iterator it = raster_task_states_.begin();
-       it != raster_task_states_.end(); ++it) {
-    RasterTaskState& state = *it;
-
-    // All unscheduled tasks need to be canceled.
-    if (state.type == RasterTaskState::UNSCHEDULED) {
-      completed_raster_tasks_.push_back(state.task);
-      state.type = RasterTaskState::COMPLETED;
-    }
-  }
-  DCHECK_EQ(completed_raster_tasks_.size(), raster_task_states_.size());
-}
-
-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);
-
-  should_notify_client_if_no_tasks_are_pending_.set();
-  std::fill(task_counts_, task_counts_ + kNumberOfTaskSets, 0);
-
-  // Update raster task state and remove items from old queue.
-  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.
-    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(),
-                     RasterTaskState::TaskComparator(task));
-    if (state_it != raster_task_states_.end()) {
-      RasterTaskState& state = *state_it;
-
-      state.task_sets = item.task_sets;
-      // |raster_tasks_required_for_activation_count| accounts for all tasks
-      // that need to complete before we can send a "ready to activate" signal.
-      // Tasks that have already completed should not be part of this count.
-      if (state.type != RasterTaskState::COMPLETED)
-        AddTaskSetsToTaskCounts(task_counts_, item.task_sets);
-
-      continue;
-    }
-
-    DCHECK(!task->HasBeenScheduled());
-    raster_task_states_.push_back(RasterTaskState(task, item.task_sets));
-    AddTaskSetsToTaskCounts(task_counts_, item.task_sets);
-  }
-
-  // Determine what tasks in old queue need to be canceled.
-  for (TileTaskQueue::Item::Vector::const_iterator it =
-           raster_tasks_.items.begin();
-       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(),
-                     RasterTaskState::TaskComparator(task));
-    // We've already processed completion if we can't find a RasterTaskState for
-    // this task.
-    if (state_it == raster_task_states_.end())
-      continue;
-
-    RasterTaskState& state = *state_it;
-
-    // Unscheduled task can be canceled.
-    if (state.type == RasterTaskState::UNSCHEDULED) {
-      DCHECK(!task->HasBeenScheduled());
-      DCHECK(std::find(completed_raster_tasks_.begin(),
-                       completed_raster_tasks_.end(),
-                       task) == completed_raster_tasks_.end());
-      completed_raster_tasks_.push_back(task);
-      state.type = RasterTaskState::COMPLETED;
-    }
-
-    // No longer in any task set.
-    state.task_sets.reset();
-  }
-
-  raster_tasks_.Swap(queue);
-
-  // Check for completed tasks when ScheduleTasks() is called as
-  // priorities might have changed and this maximizes the number
-  // of top priority tasks that are scheduled.
-  CheckForCompletedRasterizerTasks();
-  CheckForCompletedUploads();
-  FlushUploads();
-
-  // Schedule new tasks.
-  ScheduleMoreTasks();
-
-  // Reschedule check for completed raster tasks.
-  check_for_completed_raster_task_notifier_.Schedule();
-
-  TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, StateName(),
-                               "state", StateAsValue());
-}
-
-void PixelBufferTileTaskWorkerPool::CheckForCompletedTasks() {
-  TRACE_EVENT0("cc", "PixelBufferTileTaskWorkerPool::CheckForCompletedTasks");
-
-  CheckForCompletedRasterizerTasks();
-  CheckForCompletedUploads();
-  FlushUploads();
-
-  for (TileTask::Vector::const_iterator it =
-           completed_image_decode_tasks_.begin();
-       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) {
-    RasterTask* task = it->get();
-    RasterTaskState::Vector::iterator state_it =
-        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);
-
-    std::swap(*state_it, raster_task_states_.back());
-    raster_task_states_.pop_back();
-
-    task->RunReplyOnOriginThread();
-  }
-  completed_raster_tasks_.clear();
-}
-
-ResourceFormat PixelBufferTileTaskWorkerPool::GetResourceFormat() const {
-  return resource_provider_->memory_efficient_texture_format();
-}
-
-bool PixelBufferTileTaskWorkerPool::GetResourceRequiresSwizzle() const {
-  return !PlatformColor::SameComponentOrder(GetResourceFormat());
-}
-
-scoped_ptr<RasterBuffer> PixelBufferTileTaskWorkerPool::AcquireBufferForRaster(
-    const Resource* resource,
-    uint64_t resource_content_id,
-    uint64_t previous_content_id) {
-  return make_scoped_ptr<RasterBuffer>(
-      new RasterBufferImpl(resource_provider_, resource));
-}
-
-void PixelBufferTileTaskWorkerPool::ReleaseBufferForRaster(
-    scoped_ptr<RasterBuffer> buffer) {
-  // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
-}
-
-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]);
-
-  // There's no need to call CheckForCompletedRasterTasks() if the client has
-  // already been notified.
-  if (!should_notify_client_if_no_tasks_are_pending_[task_set])
-    return;
-  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
-  // notified.
-  CheckForCompletedRasterTasks();
-}
-
-void PixelBufferTileTaskWorkerPool::FlushUploads() {
-  if (!has_performed_uploads_since_last_flush_)
-    return;
-
-  context_provider_->ContextGL()->ShallowFlushCHROMIUM();
-  has_performed_uploads_since_last_flush_ = false;
-}
-
-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(),
-                        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);
-
-    // Uploads complete in the order they are issued.
-    if (!resource_provider_->DidSetPixelsComplete(task->resource()->id()))
-      break;
-
-    tasks_with_completed_uploads.push_back(task);
-    raster_tasks_with_pending_upload_.pop_front();
-  }
-
-  DCHECK(client_);
-  TaskSetCollection tasks_that_should_be_forced_to_complete =
-      client_->TasksThatShouldBeForcedToComplete();
-  bool should_force_some_uploads_to_complete =
-      shutdown_ || tasks_that_should_be_forced_to_complete.any();
-
-  if (should_force_some_uploads_to_complete) {
-    RasterTask::Vector tasks_with_uploads_to_force;
-    RasterTaskDeque::iterator it = raster_tasks_with_pending_upload_.begin();
-    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(),
-                       RasterTaskState::TaskComparator(task));
-      DCHECK(state_it != raster_task_states_.end());
-      const RasterTaskState& state = *state_it;
-
-      // Force all uploads to complete for which the client requests to do so.
-      // During shutdown, force all pending uploads to complete.
-      if (shutdown_ ||
-          (state.task_sets & tasks_that_should_be_forced_to_complete).any()) {
-        tasks_with_uploads_to_force.push_back(task);
-        tasks_with_completed_uploads.push_back(task);
-        it = raster_tasks_with_pending_upload_.erase(it);
-        continue;
-      }
-
-      ++it;
-    }
-
-    // Force uploads in reverse order. Since forcing can cause a wait on
-    // 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) {
-      RasterTask* task = it->get();
-
-      resource_provider_->ForceSetPixelsToComplete(task->resource()->id());
-      has_performed_uploads_since_last_flush_ = true;
-    }
-  }
-
-  // Release shared memory and move tasks with completed uploads
-  // to |completed_raster_tasks_|.
-  for (RasterTask::Vector::const_iterator it =
-           tasks_with_completed_uploads.begin();
-       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(),
-                     RasterTaskState::TaskComparator(task));
-    DCHECK(state_it != raster_task_states_.end());
-    RasterTaskState& state = *state_it;
-
-    // We can use UncheckedSizeInBytes here, since these tasks come from tiles,
-    // the size of which is controlled by the compositor.
-    bytes_pending_upload_ -= ResourceUtil::UncheckedSizeInBytes<size_t>(
-        task->resource()->size(), task->resource()->format());
-
-    task->WillComplete();
-    task->CompleteOnOriginThread(this);
-    task->DidComplete();
-
-    DCHECK(std::find(completed_raster_tasks_.begin(),
-                     completed_raster_tasks_.end(),
-                     task) == completed_raster_tasks_.end());
-    completed_raster_tasks_.push_back(task);
-    state.type = RasterTaskState::COMPLETED;
-    // Triggers if the current task belongs to a set that should be empty.
-    DCHECK((state.task_sets & ~NonEmptyTaskSetsFromTaskCounts(task_counts_))
-               .none());
-    RemoveTaskSetsFromTaskCounts(task_counts_, state.task_sets);
-  }
-}
-
-void PixelBufferTileTaskWorkerPool::CheckForCompletedRasterTasks() {
-  TRACE_EVENT0("cc",
-               "PixelBufferTileTaskWorkerPool::CheckForCompletedRasterTasks");
-
-  // Since this function can be called directly, cancel any pending checks.
-  check_for_completed_raster_task_notifier_.Cancel();
-
-  DCHECK(should_notify_client_if_no_tasks_are_pending_.any());
-
-  CheckForCompletedRasterizerTasks();
-  CheckForCompletedUploads();
-  FlushUploads();
-
-  // Determine what client notifications to generate.
-  TaskSetCollection will_notify_client_that_no_tasks_are_pending =
-      should_notify_client_if_no_tasks_are_pending_ &
-      ~task_set_finished_tasks_pending_ & ~PendingTasks();
-
-  // Adjust the need to generate notifications before scheduling more tasks.
-  should_notify_client_if_no_tasks_are_pending_ &=
-      ~will_notify_client_that_no_tasks_are_pending;
-
-  scheduled_raster_task_count_ = 0;
-  if (PendingRasterTaskCount())
-    ScheduleMoreTasks();
-
-  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.
-  if (PendingTasks().any())
-    check_for_completed_raster_task_notifier_.Schedule();
-
-  if (should_notify_client_if_no_tasks_are_pending_.none())
-    TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
-
-  // Generate client notifications.
-  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_->DidFinishRunningTileTasks(task_set);
-    }
-  }
-}
-
-void PixelBufferTileTaskWorkerPool::ScheduleMoreTasks() {
-  TRACE_EVENT0("cc", "PixelBufferTileTaskWorkerPool::ScheduleMoreTasks");
-
-  RasterTaskVector tasks[kNumberOfTaskSets];
-
-  size_t priority = kTileTaskPriorityBase;
-
-  graph_.Reset();
-
-  size_t bytes_pending_upload = bytes_pending_upload_;
-  TaskSetCollection did_throttle_raster_tasks;
-  size_t scheduled_raster_task_count = 0;
-
-  for (TileTaskQueue::Item::Vector::const_iterator it =
-           raster_tasks_.items.begin();
-       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(),
-                     RasterTaskState::TaskComparator(task));
-    if (state_it == raster_task_states_.end())
-      continue;
-
-    RasterTaskState& state = *state_it;
-
-    // Skip task if completed.
-    if (state.type == RasterTaskState::COMPLETED) {
-      DCHECK(std::find(completed_raster_tasks_.begin(),
-                       completed_raster_tasks_.end(),
-                       task) != completed_raster_tasks_.end());
-      continue;
-    }
-
-    // All raster tasks need to be throttled by bytes of pending uploads,
-    // but if it's the only task allow it to complete no matter what its size,
-    // to prevent starvation of the task queue.
-    size_t new_bytes_pending_upload = bytes_pending_upload;
-    // We can use UncheckedSizeInBytes here, since these tasks come from tiles,
-    // the size of which is controlled by the compositor.
-    new_bytes_pending_upload += ResourceUtil::UncheckedSizeInBytes<size_t>(
-        task->resource()->size(), task->resource()->format());
-    if (new_bytes_pending_upload > max_bytes_pending_upload_ &&
-        bytes_pending_upload) {
-      did_throttle_raster_tasks |= item.task_sets;
-      continue;
-    }
-
-    // If raster has finished, just update |bytes_pending_upload|.
-    if (state.type == RasterTaskState::UPLOADING) {
-      DCHECK(!task->HasCompleted());
-      bytes_pending_upload = new_bytes_pending_upload;
-      continue;
-    }
-
-    // Throttle raster tasks based on kMaxScheduledRasterTasks.
-    if (scheduled_raster_task_count >= kMaxScheduledRasterTasks) {
-      did_throttle_raster_tasks |= item.task_sets;
-      continue;
-    }
-
-    // Update |bytes_pending_upload| now that task has cleared all
-    // throttling limits.
-    bytes_pending_upload = new_bytes_pending_upload;
-
-    DCHECK(state.type == RasterTaskState::UNSCHEDULED ||
-           state.type == RasterTaskState::SCHEDULED);
-    state.type = RasterTaskState::SCHEDULED;
-
-    InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
-
-    ++scheduled_raster_task_count;
-    for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
-      if (item.task_sets[task_set])
-        tasks[task_set].container().push_back(task);
-    }
-  }
-
-  // Cancel existing OnTaskSetFinished callbacks.
-  task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
-
-  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 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_task_set_finished_tasks[task_set] = CreateTaskSetFinishedTask(
-          task_runner_.get(),
-          base::Bind(&PixelBufferTileTaskWorkerPool::OnTaskSetFinished,
-                     task_set_finished_weak_ptr_factory_.GetWeakPtr(),
-                     task_set));
-      task_set_finished_tasks_pending_[task_set] = true;
-      InsertNodeForTask(&graph_, new_task_set_finished_tasks[task_set].get(),
-                        kTaskSetFinishedTaskPriorityBase + task_set,
-                        scheduled_task_counts[task_set]);
-      for (RasterTaskVector::ContainerType::const_iterator it =
-               tasks[task_set].container().begin();
-           it != tasks[task_set].container().end(); ++it) {
-        graph_.edges.push_back(
-            TaskGraph::Edge(*it, new_task_set_finished_tasks[task_set].get()));
-      }
-    }
-  }
-
-  DCHECK_LE(scheduled_raster_task_count, PendingRasterTaskCount());
-
-  ScheduleTasksOnOriginThread(this, &graph_);
-  task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
-
-  scheduled_raster_task_count_ = scheduled_raster_task_count;
-
-  std::copy(new_task_set_finished_tasks,
-            new_task_set_finished_tasks + kNumberOfTaskSets,
-            task_set_finished_tasks_);
-}
-
-size_t PixelBufferTileTaskWorkerPool::PendingRasterTaskCount() const {
-  size_t 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 PixelBufferTileTaskWorkerPool::PendingTasks() const {
-  return NonEmptyTaskSetsFromTaskCounts(task_counts_);
-}
-
-const char* PixelBufferTileTaskWorkerPool::StateName() const {
-  if (scheduled_raster_task_count_)
-    return "rasterizing";
-  if (PendingRasterTaskCount())
-    return "throttled";
-  if (!raster_tasks_with_pending_upload_.empty())
-    return "waiting_for_uploads";
-
-  return "finishing";
-}
-
-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) {
-    TileTask* task = static_cast<TileTask*>(it->get());
-
-    RasterTask* raster_task = task->AsRasterTask();
-    if (!raster_task) {
-      task->WillComplete();
-      task->CompleteOnOriginThread(this);
-      task->DidComplete();
-
-      completed_image_decode_tasks_.push_back(task);
-      continue;
-    }
-
-    RasterTaskState::Vector::iterator state_it =
-        std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
-                     RasterTaskState::TaskComparator(raster_task));
-    DCHECK(state_it != raster_task_states_.end());
-
-    RasterTaskState& state = *state_it;
-    DCHECK_EQ(RasterTaskState::SCHEDULED, state.type);
-
-    resource_provider_->UnmapPixelBuffer(raster_task->resource()->id());
-
-    if (!raster_task->HasFinishedRunning()) {
-      // When priorites change, a raster task can be canceled as a result of
-      // no longer being of high enough priority to fit in our throttled
-      // raster task budget. The task has not yet completed in this case.
-      raster_task->WillComplete();
-      raster_task->CompleteOnOriginThread(this);
-      raster_task->DidComplete();
-
-      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;
-      }
-
-      DCHECK(std::find(completed_raster_tasks_.begin(),
-                       completed_raster_tasks_.end(),
-                       raster_task) == completed_raster_tasks_.end());
-      completed_raster_tasks_.push_back(raster_task);
-      state.type = RasterTaskState::COMPLETED;
-      // Triggers if the current task belongs to a set that should be empty.
-      DCHECK((state.task_sets & ~NonEmptyTaskSetsFromTaskCounts(task_counts_))
-                 .none());
-      RemoveTaskSetsFromTaskCounts(task_counts_, state.task_sets);
-      continue;
-    }
-
-    resource_provider_->BeginSetPixels(raster_task->resource()->id());
-    has_performed_uploads_since_last_flush_ = true;
-
-    // We can use UncheckedSizeInBytes here, since these tasks come from tiles,
-    // the size of which is controlled by the compositor.
-    bytes_pending_upload_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
-        raster_task->resource()->size(), raster_task->resource()->format());
-    raster_tasks_with_pending_upload_.push_back(raster_task);
-    state.type = RasterTaskState::UPLOADING;
-  }
-  completed_tasks_.clear();
-}
-
-scoped_refptr<base::trace_event::ConvertableToTraceFormat>
-PixelBufferTileTaskWorkerPool::StateAsValue() const {
-  scoped_refptr<base::trace_event::TracedValue> state =
-      new base::trace_event::TracedValue();
-  state->SetInteger("completed_count",
-                    static_cast<int>(completed_raster_tasks_.size()));
-  state->BeginArray("pending_count");
-  for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set)
-    state->AppendInteger(static_cast<int>(task_counts_[task_set]));
-  state->EndArray();
-  state->SetInteger("pending_upload_count",
-                    static_cast<int>(raster_tasks_with_pending_upload_.size()));
-  state->BeginDictionary("throttle_state");
-  ThrottleStateAsValueInto(state.get());
-  state->EndDictionary();
-  return state;
-}
-
-void PixelBufferTileTaskWorkerPool::ThrottleStateAsValueInto(
-    base::trace_event::TracedValue* throttle_state) const {
-  throttle_state->SetInteger(
-      "bytes_available_for_upload",
-      static_cast<int>(max_bytes_pending_upload_ - bytes_pending_upload_));
-  throttle_state->SetInteger("bytes_pending_upload",
-                             static_cast<int>(bytes_pending_upload_));
-  throttle_state->SetInteger("scheduled_raster_task_count",
-                             static_cast<int>(scheduled_raster_task_count_));
-}
-
-}  // namespace cc
diff --git a/cc/raster/pixel_buffer_tile_task_worker_pool.h b/cc/raster/pixel_buffer_tile_task_worker_pool.h
deleted file mode 100644
index 2c6aeb9..0000000
--- a/cc/raster/pixel_buffer_tile_task_worker_pool.h
+++ /dev/null
@@ -1,146 +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_RASTER_PIXEL_BUFFER_TILE_TASK_WORKER_POOL_H_
-#define CC_RASTER_PIXEL_BUFFER_TILE_TASK_WORKER_POOL_H_
-
-#include <deque>
-#include <vector>
-
-#include "base/memory/weak_ptr.h"
-#include "base/values.h"
-#include "cc/base/delayed_unique_notifier.h"
-#include "cc/output/context_provider.h"
-#include "cc/raster/tile_task_runner.h"
-#include "cc/raster/tile_task_worker_pool.h"
-
-namespace base {
-namespace trace_event {
-class ConvertableToTraceFormat;
-class TracedValue;
-}
-}
-
-namespace cc {
-class ResourceProvider;
-
-class CC_EXPORT PixelBufferTileTaskWorkerPool : public TileTaskWorkerPool,
-                                                public TileTaskRunner,
-                                                public TileTaskClient {
- public:
-  ~PixelBufferTileTaskWorkerPool() override;
-
-  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 TileTaskWorkerPool:
-  TileTaskRunner* AsTileTaskRunner() override;
-
-  // Overridden from TileTaskRunner:
-  void SetClient(TileTaskRunnerClient* client) override;
-  void Shutdown() override;
-  void ScheduleTasks(TileTaskQueue* queue) override;
-  void CheckForCompletedTasks() override;
-  ResourceFormat GetResourceFormat() const override;
-  bool GetResourceRequiresSwizzle() const override;
-
-  // Overridden from TileTaskClient:
-  scoped_ptr<RasterBuffer> AcquireBufferForRaster(
-      const Resource* resource,
-      uint64_t resource_content_id,
-      uint64_t previous_content_id) override;
-  void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
-
- private:
-  struct RasterTaskState {
-    class TaskComparator {
-     public:
-      explicit TaskComparator(const RasterTask* task) : task_(task) {}
-
-      bool operator()(const RasterTaskState& state) const {
-        return state.task == task_;
-      }
-
-     private:
-      const RasterTask* task_;
-    };
-
-    typedef std::vector<RasterTaskState> Vector;
-
-    RasterTaskState(RasterTask* task, const TaskSetCollection& task_sets);
-
-    enum { UNSCHEDULED, SCHEDULED, UPLOADING, COMPLETED } type;
-    RasterTask* task;
-    TaskSetCollection task_sets;
-  };
-
-  typedef std::deque<scoped_refptr<RasterTask>> RasterTaskDeque;
-
-  PixelBufferTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
-                                TaskGraphRunner* task_graph_runner,
-                                ContextProvider* context_provider,
-                                ResourceProvider* resource_provider,
-                                size_t max_transfer_buffer_usage_bytes);
-
-  void OnTaskSetFinished(TaskSet task_set);
-  void FlushUploads();
-  void CheckForCompletedUploads();
-  void CheckForCompletedRasterTasks();
-  void ScheduleMoreTasks();
-  size_t PendingRasterTaskCount() const;
-  TaskSetCollection PendingTasks() const;
-  void CheckForCompletedRasterizerTasks();
-
-  const char* StateName() const;
-  scoped_refptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
-      const;
-  void ThrottleStateAsValueInto(
-      base::trace_event::TracedValue* throttle_state) const;
-
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
-  TaskGraphRunner* task_graph_runner_;
-  const NamespaceToken namespace_token_;
-  TileTaskRunnerClient* client_;
-  ContextProvider* context_provider_;
-  ResourceProvider* resource_provider_;
-
-  bool shutdown_;
-
-  TileTaskQueue raster_tasks_;
-  RasterTaskState::Vector raster_task_states_;
-  RasterTaskDeque raster_tasks_with_pending_upload_;
-  RasterTask::Vector completed_raster_tasks_;
-  TileTask::Vector completed_image_decode_tasks_;
-
-  size_t scheduled_raster_task_count_;
-  size_t task_counts_[kNumberOfTaskSets];
-  size_t bytes_pending_upload_;
-  size_t max_bytes_pending_upload_;
-  bool has_performed_uploads_since_last_flush_;
-
-  TaskSetCollection should_notify_client_if_no_tasks_are_pending_;
-  TaskSetCollection task_set_finished_tasks_pending_;
-
-  DelayedUniqueNotifier check_for_completed_raster_task_notifier_;
-
-  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<PixelBufferTileTaskWorkerPool>
-      task_set_finished_weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(PixelBufferTileTaskWorkerPool);
-};
-
-}  // namespace cc
-
-#endif  // CC_RASTER_PIXEL_BUFFER_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/raster/tile_task_worker_pool_perftest.cc b/cc/raster/tile_task_worker_pool_perftest.cc
index 1262ace..76fc9c3c 100644
--- a/cc/raster/tile_task_worker_pool_perftest.cc
+++ b/cc/raster/tile_task_worker_pool_perftest.cc
@@ -12,7 +12,6 @@
 #include "cc/raster/gpu_rasterizer.h"
 #include "cc/raster/gpu_tile_task_worker_pool.h"
 #include "cc/raster/one_copy_tile_task_worker_pool.h"
-#include "cc/raster/pixel_buffer_tile_task_worker_pool.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/tile_task_runner.h"
 #include "cc/raster/zero_copy_tile_task_worker_pool.h"
@@ -114,7 +113,6 @@ class PerfContextProvider : public ContextProvider {
 };
 
 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,
@@ -250,13 +248,6 @@ class TileTaskWorkerPoolPerfTest
   // 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(
@@ -414,8 +405,6 @@ class TileTaskWorkerPoolPerfTest
 
   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:
@@ -461,14 +450,12 @@ TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAndExecuteTasks) {
   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));
+INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolPerfTests,
+                        TileTaskWorkerPoolPerfTest,
+                        ::testing::Values(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 {
diff --git a/cc/raster/tile_task_worker_pool_unittest.cc b/cc/raster/tile_task_worker_pool_unittest.cc
index bf2a82a..0f81473 100644
--- a/cc/raster/tile_task_worker_pool_unittest.cc
+++ b/cc/raster/tile_task_worker_pool_unittest.cc
@@ -18,7 +18,6 @@
 #include "cc/raster/gpu_rasterizer.h"
 #include "cc/raster/gpu_tile_task_worker_pool.h"
 #include "cc/raster/one_copy_tile_task_worker_pool.h"
-#include "cc/raster/pixel_buffer_tile_task_worker_pool.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/tile_task_runner.h"
 #include "cc/raster/zero_copy_tile_task_worker_pool.h"
@@ -39,16 +38,10 @@
 namespace cc {
 namespace {
 
-const size_t kMaxTransferBufferUsageBytes = 10000U;
 const size_t kMaxBytesPerCopyOperation = 1000U;
 const size_t kMaxStagingBuffers = 32U;
 
-// A resource of this dimension^2 * 4 must be greater than the above transfer
-// buffer constant.
-const size_t kLargeResourceDimension = 1000U;
-
 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,
@@ -151,13 +144,6 @@ class TileTaskWorkerPoolTest
   // Overridden from testing::Test:
   void SetUp() override {
     switch (GetParam()) {
-      case TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER:
-        Create3dOutputSurfaceAndResourceProvider();
-        tile_task_worker_pool_ = PixelBufferTileTaskWorkerPool::Create(
-            base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
-            context_provider_.get(), resource_provider_.get(),
-            kMaxTransferBufferUsageBytes);
-        break;
       case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
         Create3dOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
@@ -395,30 +381,6 @@ TEST_P(TileTaskWorkerPoolTest, FalseThrottling) {
   RunMessageLoopUntilAllTasksHaveCompleted();
 }
 
-TEST_P(TileTaskWorkerPoolTest, LargeResources) {
-  gfx::Size size(kLargeResourceDimension, kLargeResourceDimension);
-
-  {
-    // Verify a resource of this size is larger than the transfer buffer.
-    scoped_ptr<ScopedResource> resource(
-        ScopedResource::Create(resource_provider_.get()));
-    resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
-                       RGBA_8888);
-    EXPECT_GE(ResourceUtil::UncheckedSizeInBytes<size_t>(resource->size(),
-                                                         resource->format()),
-              kMaxTransferBufferUsageBytes);
-  }
-
-  AppendTask(0u, size);
-  AppendTask(1u, size);
-  AppendTask(2u, size);
-  ScheduleTasks();
-
-  // This will time out if a resource that is larger than the throttle limit
-  // never gets scheduled.
-  RunMessageLoopUntilAllTasksHaveCompleted();
-}
-
 TEST_P(TileTaskWorkerPoolTest, LostContext) {
   LoseContext(output_surface_->context_provider());
   LoseContext(output_surface_->worker_context_provider());
@@ -449,14 +411,12 @@ TEST_P(TileTaskWorkerPoolTest, ScheduleEmptyStillTriggersCallback) {
   EXPECT_TRUE(completed_task_sets_[ALL]);
 }
 
-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));
+INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests,
+                        TileTaskWorkerPoolTest,
+                        ::testing::Values(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/resource_provider.cc b/cc/resources/resource_provider.cc
index 848524f..e9082bbd 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -217,8 +217,6 @@ ResourceProvider::Resource::Resource(GLuint texture_id,
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
-      pending_set_pixels(false),
-      set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(false),
@@ -260,8 +258,6 @@ ResourceProvider::Resource::Resource(uint8_t* pixels,
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
-      pending_set_pixels(false),
-      set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(!!bitmap),
@@ -304,8 +300,6 @@ ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
       locked_for_write(false),
       lost(false),
       marked_for_deletion(false),
-      pending_set_pixels(false),
-      set_pixels_completion_forced(false),
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(true),
@@ -545,7 +539,7 @@ void ResourceProvider::DeleteResource(ResourceId id) {
   Resource* resource = &it->second;
   DCHECK(!resource->marked_for_deletion);
   DCHECK_EQ(resource->imported_count, 0);
-  DCHECK(resource->pending_set_pixels || !resource->locked_for_write);
+  DCHECK(!resource->locked_for_write);
 
   if (resource->exported_count > 0 || resource->lock_for_read_count > 0 ||
       !ReadLockFenceHasPassed(resource)) {
@@ -669,7 +663,6 @@ void ResourceProvider::CopyToResource(ResourceId id,
     dest.writePixels(source_info, image, image_stride, 0, 0);
   } else {
     DCHECK(resource->gl_id);
-    DCHECK(!resource->pending_set_pixels);
     DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
@@ -707,10 +700,8 @@ ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
 
 const ResourceProvider::Resource* ResourceProvider::LockForRead(ResourceId id) {
   Resource* resource = GetResource(id);
-  DCHECK(!resource->locked_for_write ||
-         resource->set_pixels_completion_forced) <<
-      "locked for write: " << resource->locked_for_write <<
-      " pixels completion forced: " << resource->set_pixels_completion_forced;
+  DCHECK(!resource->locked_for_write) << "locked for write: "
+                                      << resource->locked_for_write;
   DCHECK_EQ(resource->exported_count, 0);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
@@ -1467,106 +1458,6 @@ void ResourceProvider::DeleteAndReturnUnusedResourcesToChild(
   }
 }
 
-void ResourceProvider::AcquirePixelBuffer(ResourceId id) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::AcquirePixelBuffer");
-
-  Resource* resource = GetResource(id);
-  DCHECK(resource->origin == Resource::INTERNAL);
-  DCHECK_EQ(resource->exported_count, 0);
-  DCHECK(!resource->image_id);
-  DCHECK_NE(ETC1, resource->format);
-
-  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, resource->type);
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-  if (!resource->gl_pixel_buffer_id)
-    resource->gl_pixel_buffer_id = buffer_id_allocator_->NextId();
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-                 resource->gl_pixel_buffer_id);
-  size_t resource_bytes = ResourceUtil::UncheckedSizeInBytesAligned<size_t>(
-      resource->size, resource->format);
-  gl->BufferData(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, resource_bytes, NULL,
-                 GL_DYNAMIC_DRAW);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
-}
-
-void ResourceProvider::ReleasePixelBuffer(ResourceId id) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::ReleasePixelBuffer");
-
-  Resource* resource = GetResource(id);
-  DCHECK(resource->origin == Resource::INTERNAL);
-  DCHECK_EQ(resource->exported_count, 0);
-  DCHECK(!resource->image_id);
-
-  // The pixel buffer can be released while there is a pending "set pixels"
-  // if completion has been forced. Any shared memory associated with this
-  // pixel buffer will not be freed until the waitAsyncTexImage2DCHROMIUM
-  // command has been processed on the service side. It is also safe to
-  // reuse any query id associated with this resource before they complete
-  // as each new query has a unique submit count.
-  if (resource->pending_set_pixels) {
-    DCHECK(resource->set_pixels_completion_forced);
-    resource->pending_set_pixels = false;
-    resource->locked_for_write = false;
-  }
-
-  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, resource->type);
-  if (!resource->gl_pixel_buffer_id)
-    return;
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-                 resource->gl_pixel_buffer_id);
-  gl->BufferData(
-      GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0, NULL, GL_DYNAMIC_DRAW);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
-}
-
-uint8_t* ResourceProvider::MapPixelBuffer(ResourceId id, int* stride) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::MapPixelBuffer");
-
-  Resource* resource = GetResource(id);
-  DCHECK(resource->origin == Resource::INTERNAL);
-  DCHECK_EQ(resource->exported_count, 0);
-  DCHECK(!resource->image_id);
-
-  *stride = 0;
-  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, resource->type);
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-  DCHECK(resource->gl_pixel_buffer_id);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-                 resource->gl_pixel_buffer_id);
-  uint8_t* image = static_cast<uint8_t*>(gl->MapBufferCHROMIUM(
-      GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, GL_WRITE_ONLY));
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
-  // Buffer is required to be 4-byte aligned.
-  CHECK(!(reinterpret_cast<intptr_t>(image) & 3));
-  return image;
-}
-
-void ResourceProvider::UnmapPixelBuffer(ResourceId id) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::UnmapPixelBuffer");
-
-  Resource* resource = GetResource(id);
-  DCHECK(resource->origin == Resource::INTERNAL);
-  DCHECK_EQ(resource->exported_count, 0);
-  DCHECK(!resource->image_id);
-
-  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, resource->type);
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-  DCHECK(resource->gl_pixel_buffer_id);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-                 resource->gl_pixel_buffer_id);
-  gl->UnmapBufferCHROMIUM(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
-}
-
 GLenum ResourceProvider::BindForSampling(ResourceId resource_id,
                                          GLenum unit,
                                          GLenum filter) {
@@ -1576,7 +1467,7 @@ GLenum ResourceProvider::BindForSampling(ResourceId resource_id,
   DCHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->lock_for_read_count);
-  DCHECK(!resource->locked_for_write || resource->set_pixels_completion_forced);
+  DCHECK(!resource->locked_for_write);
 
   ScopedSetActiveTexture scoped_active_tex(gl, unit);
   GLenum target = resource->target;
@@ -1593,115 +1484,6 @@ GLenum ResourceProvider::BindForSampling(ResourceId resource_id,
   return target;
 }
 
-void ResourceProvider::BeginSetPixels(ResourceId id) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::BeginSetPixels");
-
-  Resource* resource = GetResource(id);
-  DCHECK(!resource->pending_set_pixels);
-
-  LazyCreate(resource);
-  DCHECK(resource->origin == Resource::INTERNAL);
-  DCHECK(resource->gl_id || resource->allocated);
-  DCHECK(ReadLockFenceHasPassed(resource));
-  DCHECK(!resource->image_id);
-
-  bool allocate = !resource->allocated;
-  resource->allocated = true;
-  LockForWrite(id);
-
-  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, resource->type);
-  DCHECK(resource->gl_id);
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-  DCHECK(resource->gl_pixel_buffer_id);
-  DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
-  gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-                 resource->gl_pixel_buffer_id);
-  if (!resource->gl_upload_query_id)
-    gl->GenQueriesEXT(1, &resource->gl_upload_query_id);
-  gl->BeginQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
-                    resource->gl_upload_query_id);
-  if (allocate) {
-    gl->AsyncTexImage2DCHROMIUM(GL_TEXTURE_2D,
-                                0, /* level */
-                                GLInternalFormat(resource->format),
-                                resource->size.width(),
-                                resource->size.height(),
-                                0, /* border */
-                                GLDataFormat(resource->format),
-                                GLDataType(resource->format),
-                                NULL);
-  } else {
-    gl->AsyncTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
-                                   0, /* level */
-                                   0, /* x */
-                                   0, /* y */
-                                   resource->size.width(),
-                                   resource->size.height(),
-                                   GLDataFormat(resource->format),
-                                   GLDataType(resource->format),
-                                   NULL);
-  }
-  gl->EndQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM);
-  gl->BindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
-
-  resource->pending_set_pixels = true;
-  resource->set_pixels_completion_forced = false;
-}
-
-void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::ForceSetPixelsToComplete");
-
-  Resource* resource = GetResource(id);
-
-  DCHECK(resource->locked_for_write);
-  DCHECK(resource->pending_set_pixels);
-  DCHECK(!resource->set_pixels_completion_forced);
-
-  if (resource->gl_id) {
-    GLES2Interface* gl = ContextGL();
-    gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
-    gl->WaitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D);
-    gl->BindTexture(GL_TEXTURE_2D, 0);
-  }
-
-  resource->set_pixels_completion_forced = true;
-}
-
-bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "ResourceProvider::DidSetPixelsComplete");
-
-  Resource* resource = GetResource(id);
-
-  DCHECK(resource->locked_for_write);
-  DCHECK(resource->pending_set_pixels);
-
-  if (resource->gl_id) {
-    GLES2Interface* gl = ContextGL();
-    DCHECK(gl);
-    DCHECK(resource->gl_upload_query_id);
-    GLuint complete = 1;
-    gl->GetQueryObjectuivEXT(
-        resource->gl_upload_query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &complete);
-    if (!complete)
-      return false;
-  }
-
-  resource->pending_set_pixels = false;
-  UnlockForWrite(resource);
-
-  // Async set pixels commands are not necessarily processed in-sequence with
-  // drawing commands. Read lock fences are required to ensure that async
-  // commands don't access the resource while used for drawing.
-  resource->read_lock_fences_enabled = true;
-
-  return true;
-}
-
 void ResourceProvider::CreateForTesting(ResourceId id) {
   LazyCreate(GetResource(id));
 }
diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
index 8b7ccd8..99947e5 100644
--- a/cc/resources/resource_provider.h
+++ b/cc/resources/resource_provider.h
@@ -497,8 +497,6 @@ class CC_EXPORT ResourceProvider
     bool locked_for_write : 1;
     bool lost : 1;
     bool marked_for_deletion : 1;
-    bool pending_set_pixels : 1;
-    bool set_pixels_completion_forced : 1;
     bool allocated : 1;
     bool read_lock_fences_enabled : 1;
     bool has_shared_bitmap_id : 1;
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index 7c65b73..12075b5 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -3231,25 +3231,6 @@ TEST_P(ResourceProviderTest, TextureAllocation) {
   resource_provider->DeleteResource(id);
 
   Mock::VerifyAndClearExpectations(context);
-
-  // Same for async version.
-  id = resource_provider->CreateResource(
-      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
-  resource_provider->AcquirePixelBuffer(id);
-
-  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
-  EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
-      .Times(1);
-  resource_provider->BeginSetPixels(id);
-  ASSERT_TRUE(resource_provider->DidSetPixelsComplete(id));
-
-  resource_provider->ReleasePixelBuffer(id);
-
-  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
-  resource_provider->DeleteResource(id);
-
-  Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, TextureAllocationHint) {
@@ -3361,129 +3342,6 @@ TEST_P(ResourceProviderTest, TextureAllocationHint_BGRA) {
   }
 }
 
-TEST_P(ResourceProviderTest, PixelBuffer_GLTexture) {
-  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
-    return;
-  scoped_ptr<AllocationTrackingContext3D> context_owned(
-      new StrictMock<AllocationTrackingContext3D>);
-  AllocationTrackingContext3D* context = context_owned.get();
-
-  FakeOutputSurfaceClient output_surface_client;
-  scoped_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(context_owned.Pass()));
-  CHECK(output_surface->BindToClient(&output_surface_client));
-
-  gfx::Size size(2, 2);
-  ResourceFormat format = RGBA_8888;
-  ResourceId id = 0;
-  int texture_id = 123;
-
-  scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1,
-      use_image_texture_targets_));
-
-  id = resource_provider->CreateResource(
-      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
-  resource_provider->AcquirePixelBuffer(id);
-
-  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
-  EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
-      .Times(1);
-  resource_provider->BeginSetPixels(id);
-
-  EXPECT_TRUE(resource_provider->DidSetPixelsComplete(id));
-
-  resource_provider->ReleasePixelBuffer(id);
-
-  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
-  resource_provider->DeleteResource(id);
-
-  Mock::VerifyAndClearExpectations(context);
-}
-
-TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
-  // Only for GL textures.
-  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
-    return;
-  scoped_ptr<AllocationTrackingContext3D> context_owned(
-      new StrictMock<AllocationTrackingContext3D>);
-  AllocationTrackingContext3D* context = context_owned.get();
-
-  FakeOutputSurfaceClient output_surface_client;
-  scoped_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(context_owned.Pass()));
-  CHECK(output_surface->BindToClient(&output_surface_client));
-
-  gfx::Size size(2, 2);
-  ResourceFormat format = RGBA_8888;
-  ResourceId id = 0;
-  int texture_id = 123;
-
-  scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1,
-      use_image_texture_targets_));
-
-  id = resource_provider->CreateResource(
-      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
-  resource_provider->AcquirePixelBuffer(id);
-
-  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
-  EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
-      .Times(1);
-  resource_provider->BeginSetPixels(id);
-
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
-  EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
-  resource_provider->ForceSetPixelsToComplete(id);
-
-  resource_provider->ReleasePixelBuffer(id);
-
-  EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
-  resource_provider->DeleteResource(id);
-
-  Mock::VerifyAndClearExpectations(context);
-}
-
-TEST_P(ResourceProviderTest, PixelBufferLostContext) {
-  scoped_ptr<AllocationTrackingContext3D> context_owned(
-      new NiceMock<AllocationTrackingContext3D>);
-  AllocationTrackingContext3D* context = context_owned.get();
-
-  FakeOutputSurfaceClient output_surface_client;
-  scoped_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(context_owned.Pass()));
-  CHECK(output_surface->BindToClient(&output_surface_client));
-
-  gfx::Size size(2, 2);
-  ResourceFormat format = RGBA_8888;
-  ResourceId id = 0;
-  int texture_id = 123;
-
-  scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, false, 1,
-      use_image_texture_targets_));
-
-  EXPECT_CALL(*context, NextTextureId()).WillRepeatedly(Return(texture_id));
-
-  id = resource_provider->CreateResource(
-      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
-  context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
-                               GL_INNOCENT_CONTEXT_RESET_ARB);
-
-  resource_provider->AcquirePixelBuffer(id);
-  int stride;
-  void* buffer = resource_provider->MapPixelBuffer(id, &stride);
-  EXPECT_FALSE(buffer);
-  resource_provider->UnmapPixelBuffer(id);
-  Mock::VerifyAndClearExpectations(context);
-}
-
 TEST_P(ResourceProviderTest, Image_GLTexture) {
   // Only for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index f844d8a..6ea1b02 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc
@@ -9,7 +9,6 @@
 #include "cc/raster/gpu_rasterizer.h"
 #include "cc/raster/gpu_tile_task_worker_pool.h"
 #include "cc/raster/one_copy_tile_task_worker_pool.h"
-#include "cc/raster/pixel_buffer_tile_task_worker_pool.h"
 #include "cc/raster/tile_task_worker_pool.h"
 #include "cc/raster/zero_copy_tile_task_worker_pool.h"
 #include "cc/resources/resource_pool.h"
@@ -28,7 +27,6 @@ bool IsTestCaseSupported(PixelResourceTestCase test_case) {
     case GL_ZERO_COPY_RECT_DRAW:
     case GL_ONE_COPY_2D_STAGING_2D_DRAW:
     case GL_ONE_COPY_RECT_STAGING_2D_DRAW:
-    case GL_ASYNC_UPLOAD_2D_DRAW:
       return true;
     case GL_ZERO_COPY_EXTERNAL_DRAW:
     case GL_ONE_COPY_EXTERNAL_STAGING_2D_DRAW:
@@ -103,11 +101,6 @@ void LayerTreeHostPixelResourceTest::InitializeFromTestCase(
       draw_texture_target_ = GL_TEXTURE_EXTERNAL_OES;
       resource_pool_option_ = ZERO_COPY_TILE_TASK_WORKER_POOL;
       return;
-    case GL_ASYNC_UPLOAD_2D_DRAW:
-      test_type_ = PIXEL_TEST_GL;
-      draw_texture_target_ = GL_TEXTURE_2D;
-      resource_pool_option_ = PIXEL_BUFFER_TILE_TASK_WORKER_POOL;
-      return;
   }
   NOTREACHED();
 }
@@ -125,7 +118,6 @@ void LayerTreeHostPixelResourceTest::CreateResourceAndTileTaskWorkerPool(
   ContextProvider* context_provider =
       host_impl->output_surface()->context_provider();
   ResourceProvider* resource_provider = host_impl->resource_provider();
-  size_t max_transfer_buffer_usage_bytes = 1024u * 1024u * 60u;
   int max_bytes_per_copy_operation = 1024 * 1024;
   int max_staging_buffers = 32;
 
@@ -170,16 +162,6 @@ void LayerTreeHostPixelResourceTest::CreateResourceAndTileTaskWorkerPool(
           task_runner, task_graph_runner(), context_provider, resource_provider,
           max_bytes_per_copy_operation, false, max_staging_buffers);
       break;
-    case PIXEL_BUFFER_TILE_TASK_WORKER_POOL:
-      EXPECT_TRUE(context_provider);
-      EXPECT_EQ(PIXEL_TEST_GL, test_type_);
-      *resource_pool = ResourcePool::Create(resource_provider, task_runner,
-                                            draw_texture_target_);
-
-      *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
-          task_runner, task_graph_runner(), 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 8c3242a..3e52169 100644
--- a/cc/test/layer_tree_pixel_resource_test.h
+++ b/cc/test/layer_tree_pixel_resource_test.h
@@ -27,7 +27,6 @@ enum PixelResourceTestCase {
   GL_ZERO_COPY_2D_DRAW,
   GL_ZERO_COPY_RECT_DRAW,
   GL_ZERO_COPY_EXTERNAL_DRAW,
-  GL_ASYNC_UPLOAD_2D_DRAW,
 };
 
 class LayerTreeHostPixelResourceTest : public LayerTreePixelTest {
@@ -47,8 +46,7 @@ class LayerTreeHostPixelResourceTest : public LayerTreePixelTest {
     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,
+    ONE_COPY_TILE_TASK_WORKER_POOL
   };
 
  protected:
@@ -62,19 +60,14 @@ class LayerTreeHostPixelResourceTest : public LayerTreePixelTest {
   PixelResourceTestCase test_case_;
 };
 
-#define INSTANTIATE_PIXEL_RESOURCE_TEST_CASE_P(framework_name) \
-  INSTANTIATE_TEST_CASE_P(                                     \
-      PixelResourceTest,                                       \
-      framework_name,                                          \
-      ::testing::Values(SOFTWARE,                              \
-                        GL_GPU_RASTER_2D_DRAW,                 \
-                        GL_ONE_COPY_2D_STAGING_2D_DRAW,        \
-                        GL_ONE_COPY_RECT_STAGING_2D_DRAW,      \
-                        GL_ONE_COPY_EXTERNAL_STAGING_2D_DRAW,  \
-                        GL_ZERO_COPY_2D_DRAW,                  \
-                        GL_ZERO_COPY_RECT_DRAW,                \
-                        GL_ZERO_COPY_EXTERNAL_DRAW,            \
-                        GL_ASYNC_UPLOAD_2D_DRAW))
+#define INSTANTIATE_PIXEL_RESOURCE_TEST_CASE_P(framework_name)             \
+  INSTANTIATE_TEST_CASE_P(                                                 \
+      PixelResourceTest, framework_name,                                   \
+      ::testing::Values(                                                   \
+          SOFTWARE, GL_GPU_RASTER_2D_DRAW, GL_ONE_COPY_2D_STAGING_2D_DRAW, \
+          GL_ONE_COPY_RECT_STAGING_2D_DRAW,                                \
+          GL_ONE_COPY_EXTERNAL_STAGING_2D_DRAW, GL_ZERO_COPY_2D_DRAW,      \
+          GL_ZERO_COPY_RECT_DRAW, GL_ZERO_COPY_EXTERNAL_DRAW))
 
 class ParameterizedPixelResourceTest
     : public LayerTreeHostPixelResourceTest,
diff --git a/cc/test/test_gles2_interface.cc b/cc/test/test_gles2_interface.cc
index 38b1d20..4b03ac8 100644
--- a/cc/test/test_gles2_interface.cc
+++ b/cc/test/test_gles2_interface.cc
@@ -266,39 +266,6 @@ void TestGLES2Interface::RenderbufferStorage(GLenum target,
   test_context_->renderbufferStorage(target, internalformat, width, height);
 }
 
-void TestGLES2Interface::AsyncTexImage2DCHROMIUM(GLenum target,
-                                                 GLint level,
-                                                 GLenum internalformat,
-                                                 GLsizei width,
-                                                 GLsizei height,
-                                                 GLint border,
-                                                 GLenum format,
-                                                 GLenum type,
-                                                 const void* pixels) {
-  test_context_->asyncTexImage2DCHROMIUM(target,
-                                         level,
-                                         internalformat,
-                                         width,
-                                         height,
-                                         border,
-                                         format,
-                                         type,
-                                         pixels);
-}
-
-void TestGLES2Interface::AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                                    GLint level,
-                                                    GLint xoffset,
-                                                    GLint yoffset,
-                                                    GLsizei width,
-                                                    GLsizei height,
-                                                    GLenum format,
-                                                    GLenum type,
-                                                    const void* pixels) {
-  test_context_->asyncTexSubImage2DCHROMIUM(
-      target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
 void TestGLES2Interface::CompressedTexImage2D(GLenum target,
                                               GLint level,
                                               GLenum internalformat,
@@ -311,10 +278,6 @@ void TestGLES2Interface::CompressedTexImage2D(GLenum target,
       target, level, internalformat, width, height, border, image_size, data);
 }
 
-void TestGLES2Interface::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
-  test_context_->waitAsyncTexImage2DCHROMIUM(target);
-}
-
 GLuint TestGLES2Interface::CreateImageCHROMIUM(ClientBuffer buffer,
                                                GLsizei width,
                                                GLsizei height,
diff --git a/cc/test/test_gles2_interface.h b/cc/test/test_gles2_interface.h
index 6f501bf..5a36b5c 100644
--- a/cc/test/test_gles2_interface.h
+++ b/cc/test/test_gles2_interface.h
@@ -97,24 +97,6 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
                                    GLuint plane) override;
   void TexParameteri(GLenum target, GLenum pname, GLint param) override;
 
-  void AsyncTexImage2DCHROMIUM(GLenum target,
-                               GLint level,
-                               GLenum internalformat,
-                               GLsizei width,
-                               GLsizei height,
-                               GLint border,
-                               GLenum format,
-                               GLenum type,
-                               const void* pixels) override;
-  void AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                  GLint level,
-                                  GLint xoffset,
-                                  GLint yoffset,
-                                  GLsizei width,
-                                  GLsizei height,
-                                  GLenum format,
-                                  GLenum type,
-                                  const void* pixels) override;
   void CompressedTexImage2D(GLenum target,
                             GLint level,
                             GLenum internalformat,
@@ -123,7 +105,6 @@ class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
                             GLint border,
                             GLsizei image_size,
                             const void* data) override;
-  void WaitAsyncTexImage2DCHROMIUM(GLenum target) override;
   GLuint CreateImageCHROMIUM(ClientBuffer buffer,
                              GLsizei width,
                              GLsizei height,
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 5a1d2c6..543d5f8 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -58,7 +58,6 @@
 #include "cc/raster/gpu_rasterizer.h"
 #include "cc/raster/gpu_tile_task_worker_pool.h"
 #include "cc/raster/one_copy_tile_task_worker_pool.h"
-#include "cc/raster/pixel_buffer_tile_task_worker_pool.h"
 #include "cc/raster/tile_task_worker_pool.h"
 #include "cc/raster/zero_copy_tile_task_worker_pool.h"
 #include "cc/resources/memory_history.h"
@@ -130,29 +129,6 @@ void DidVisibilityChange(LayerTreeHostImpl* id, bool visible) {
   TRACE_EVENT_ASYNC_END0("cc", "LayerTreeHostImpl::SetVisible", id);
 }
 
-size_t GetMaxTransferBufferUsageBytes(
-    const ContextProvider::Capabilities& context_capabilities,
-    double refresh_rate) {
-  // We want to make sure the default transfer buffer size is equal to the
-  // amount of data that can be uploaded by the compositor to avoid stalling
-  // the pipeline.
-  // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
-  const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
-
-  // We need to upload at least enough work to keep the GPU process busy until
-  // the next time it can handle a request to start more uploads from the
-  // compositor. We assume that it will pick up any sent upload requests within
-  // the time of a vsync, since the browser will want to swap a frame within
-  // that time interval, and then uploads should have a chance to be processed.
-  size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
-  size_t max_transfer_buffer_usage_bytes =
-      ms_per_frame * kMaxBytesUploadedPerMs;
-
-  // The context may request a lower limit based on the device capabilities.
-  return std::min(context_capabilities.max_transfer_buffer_usage_bytes,
-                  max_transfer_buffer_usage_bytes);
-}
-
 size_t GetDefaultMemoryAllocationLimit() {
   // TODO(ccameron): (http://crbug.com/137094) This 64MB default is a straggler
   // from the old texture manager and is just to give us a default memory
@@ -259,8 +235,6 @@ LayerTreeHostImpl::LayerTreeHostImpl(
   }
 
   DCHECK(proxy_->IsImplThread());
-  DCHECK_IMPLIES(settings.use_one_copy, !settings.use_zero_copy);
-  DCHECK_IMPLIES(settings.use_zero_copy, !settings.use_one_copy);
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
@@ -2134,35 +2108,17 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     return;
   }
 
-  if (settings_.use_one_copy) {
-    *resource_pool = ResourcePool::Create(resource_provider_.get(),
-                                          GetTaskRunner(), GL_TEXTURE_2D);
-
-    int max_copy_texture_chromium_size =
-        context_provider->ContextCapabilities()
-            .gpu.max_copy_texture_chromium_size;
-
-    *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
-        GetTaskRunner(), task_graph_runner, context_provider,
-        resource_provider_.get(), max_copy_texture_chromium_size,
-        settings_.use_persistent_map_for_gpu_memory_buffers,
-        settings_.max_staging_buffers);
-    return;
-  }
-
-  // Synchronous single-threaded mode depends on tiles being ready to
-  // draw when raster is complete.  Therefore, it must use one of zero
-  // copy, software raster, or GPU raster (in the branches above).
-  DCHECK(!is_synchronous_single_threaded_);
-
   *resource_pool = ResourcePool::Create(resource_provider_.get(),
                                         GetTaskRunner(), GL_TEXTURE_2D);
 
-  *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
-      GetTaskRunner(), task_graph_runner_, context_provider,
-      resource_provider_.get(),
-      GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
-                                     settings_.renderer_settings.refresh_rate));
+  int max_copy_texture_chromium_size = context_provider->ContextCapabilities()
+                                           .gpu.max_copy_texture_chromium_size;
+
+  *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
+      GetTaskRunner(), task_graph_runner, context_provider,
+      resource_provider_.get(), max_copy_texture_chromium_size,
+      settings_.use_persistent_map_for_gpu_memory_buffers,
+      settings_.max_staging_buffers);
 }
 
 void LayerTreeHostImpl::RecordMainFrameTiming(
diff --git a/cc/trees/layer_tree_host_pixeltest_blending.cc b/cc/trees/layer_tree_host_pixeltest_blending.cc
index 3a7feef..688c9fb 100644
--- a/cc/trees/layer_tree_host_pixeltest_blending.cc
+++ b/cc/trees/layer_tree_host_pixeltest_blending.cc
@@ -277,7 +277,7 @@ class LayerTreeHostBlendingPixelTest : public LayerTreeHostPixelResourceTest {
 };
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_GL) {
-  RunBlendingWithRootPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW);
+  RunBlendingWithRootPixelTestType(GL_ZERO_COPY_RECT_DRAW);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_Software) {
@@ -289,7 +289,7 @@ TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithBackgroundFilter) {
   const int kLaneHeight = kLaneWidth;
   const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth;
   const int kRootHeight = 2 * kLaneWidth + kLaneHeight;
-  InitializeFromTestCase(GL_ASYNC_UPLOAD_2D_DRAW);
+  InitializeFromTestCase(GL_ZERO_COPY_RECT_DRAW);
 
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSOrange);
@@ -314,7 +314,7 @@ TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithBackgroundFilter) {
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_GL) {
-  RunBlendingWithTransparentPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW);
+  RunBlendingWithTransparentPixelTestType(GL_ZERO_COPY_RECT_DRAW);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_Software) {
@@ -323,7 +323,7 @@ TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_Software) {
 
 // Tests for render passes
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"), 0);
 }
 
@@ -333,7 +333,7 @@ TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_Software) {
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing);
 }
@@ -345,7 +345,7 @@ TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_Software) {
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMask_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks);
 }
@@ -357,7 +357,7 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMaskAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing);
 }
@@ -370,7 +370,7 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseColorMatrix);
 }
@@ -382,7 +382,7 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix);
 }
@@ -396,7 +396,7 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix);
 }
@@ -410,7 +410,7 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
@@ -424,20 +424,20 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 
 // Tests for render passes forcing shaders for all the blend modes.
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShaders_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShadersAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMask_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kForceShaders);
 }
@@ -451,7 +451,7 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kForceShaders);
 }
@@ -465,21 +465,21 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix | kForceShaders);
 }
@@ -494,7 +494,7 @@ TEST_F(LayerTreeHostBlendingPixelTest,
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrixAA_GL) {
   RunBlendingWithRenderPass(
-      GL_ASYNC_UPLOAD_2D_DRAW,
+      GL_ZERO_COPY_RECT_DRAW,
       FILE_PATH_LITERAL("blending_render_pass_mask.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
diff --git a/cc/trees/layer_tree_host_pixeltest_masks.cc b/cc/trees/layer_tree_host_pixeltest_masks.cc
index 0b48a0b..eda8023 100644
--- a/cc/trees/layer_tree_host_pixeltest_masks.cc
+++ b/cc/trees/layer_tree_host_pixeltest_masks.cc
@@ -371,8 +371,7 @@ INSTANTIATE_TEST_CASE_P(PixelResourceTest,
                                           GL_ONE_COPY_EXTERNAL_STAGING_2D_DRAW,
                                           GL_ZERO_COPY_2D_DRAW,
                                           GL_ZERO_COPY_RECT_DRAW,
-                                          GL_ZERO_COPY_EXTERNAL_DRAW,
-                                          GL_ASYNC_UPLOAD_2D_DRAW));
+                                          GL_ZERO_COPY_EXTERNAL_DRAW));
 
 TEST_P(LayerTreeHostMasksForBackgroundFiltersPixelTest,
        MaskOfLayerWithBackgroundFilter) {
diff --git a/cc/trees/layer_tree_host_pixeltest_synchronous.cc b/cc/trees/layer_tree_host_pixeltest_synchronous.cc
index a5286a2..f61703f 100644
--- a/cc/trees/layer_tree_host_pixeltest_synchronous.cc
+++ b/cc/trees/layer_tree_host_pixeltest_synchronous.cc
@@ -22,7 +22,6 @@ class LayerTreeHostSynchronousPixelTest : public LayerTreePixelTest {
     LayerTreePixelTest::InitializeSettings(settings);
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
-    settings->use_one_copy = false;
   }
 
   void BeginTest() override {
diff --git a/cc/trees/layer_tree_host_pixeltest_tiles.cc b/cc/trees/layer_tree_host_pixeltest_tiles.cc
index e4f52cd..9259ca3 100644
--- a/cc/trees/layer_tree_host_pixeltest_tiles.cc
+++ b/cc/trees/layer_tree_host_pixeltest_tiles.cc
@@ -31,12 +31,10 @@ class LayerTreeHostTilesPixelTest : public LayerTreePixelTest {
     settings->use_display_lists = true;
     switch (raster_mode_) {
       case PARTIAL_ONE_COPY:
-        settings->use_one_copy = true;
         settings->use_zero_copy = false;
         settings->use_persistent_map_for_gpu_memory_buffers = true;
         break;
       case FULL_ONE_COPY:
-        settings->use_one_copy = true;
         settings->use_zero_copy = false;
         settings->use_persistent_map_for_gpu_memory_buffers = false;
         break;
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 8e569a5..b2c10ef 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -1774,7 +1774,6 @@ class LayerTreeHostTestCompositeImmediatelyStateTransitions
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
-    settings->use_one_copy = false;
   }
 
   void BeginTest() override {
@@ -3760,55 +3759,6 @@ class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestUpdateLayerInEmptyViewport);
 
-class LayerTreeHostTestMaxTransferBufferUsageBytes : public LayerTreeHostTest {
- protected:
-  void InitializeSettings(LayerTreeSettings* settings) override {
-    // Testing async uploads.
-    settings->use_zero_copy = false;
-    settings->use_one_copy = false;
-  }
-
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
-    scoped_refptr<TestContextProvider> context_provider =
-        TestContextProvider::Create();
-    context_provider->SetMaxTransferBufferUsageBytes(512 * 512);
-    if (delegating_renderer())
-      return FakeOutputSurface::CreateDelegating3d(context_provider);
-    else
-      return FakeOutputSurface::Create3d(context_provider);
-  }
-
-  void SetupTree() override {
-    client_.set_fill_with_nonsolid_color(true);
-    scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
-    root_layer->SetBounds(gfx::Size(1024, 1024));
-    root_layer->SetIsDrawable(true);
-
-    layer_tree_host()->SetRootLayer(root_layer);
-    LayerTreeHostTest::SetupTree();
-  }
-
-  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
-
-  void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    TestWebGraphicsContext3D* context = TestContext();
-
-    // Expect that the transfer buffer memory used is equal to the
-    // MaxTransferBufferUsageBytes value set in CreateOutputSurface.
-    EXPECT_EQ(512 * 512u, context->max_used_transfer_buffer_usage_bytes());
-    EndTest();
-  }
-
-  void AfterTest() override {}
-
- private:
-  FakeContentLayerClient client_;
-};
-
-// Impl-side painting is a multi-threaded compositor feature.
-MULTI_THREAD_TEST_F(LayerTreeHostTestMaxTransferBufferUsageBytes);
-
 class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     : public LayerTreeHostTest {
  protected:
@@ -4799,7 +4749,6 @@ class LayerTreeHostTestSynchronousCompositeSwapPromise
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
-    settings->use_one_copy = false;
   }
 
   void BeginTest() override {
@@ -5103,10 +5052,6 @@ MULTI_THREAD_TEST_F(LayerTreeHostTestCrispUpAfterPinchEnds);
 class LayerTreeHostTestCrispUpAfterPinchEndsWithOneCopy
     : public LayerTreeHostTestCrispUpAfterPinchEnds {
  protected:
-  void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->use_one_copy = true;
-  }
-
   scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     scoped_ptr<TestWebGraphicsContext3D> context3d =
         TestWebGraphicsContext3D::Create();
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index e8e26ca..7c766fe 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -391,7 +391,6 @@ class MultipleCompositeDoesNotCreateOutputSurface
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
-    settings->use_one_copy = false;
   }
 
   void RequestNewOutputSurface() override {
@@ -431,7 +430,6 @@ class FailedCreateDoesNotCreateExtraOutputSurface
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
-    settings->use_one_copy = false;
   }
 
   void RequestNewOutputSurface() override {
@@ -485,7 +483,6 @@ class LayerTreeHostContextTestCommitAfterDelayedOutputSurface
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
-    settings->use_one_copy = false;
   }
 
   void RequestNewOutputSurface() override {
@@ -528,7 +525,6 @@ class LayerTreeHostContextTestAvoidUnnecessaryComposite
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
-    settings->use_one_copy = false;
   }
 
   void RequestNewOutputSurface() override {
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index 177741b..c9b4a30 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -57,7 +57,6 @@ LayerTreeSettings::LayerTreeSettings()
       skewport_extrapolation_limit_in_content_pixels(2000),
       max_memory_for_prepaint_percentage(100),
       strict_layer_property_change_checking(false),
-      use_one_copy(true),
       use_zero_copy(false),
       use_persistent_map_for_gpu_memory_buffers(false),
       enable_elastic_overscroll(false),
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index 506dfb4..4501c6a 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -72,7 +72,6 @@ class CC_EXPORT LayerTreeSettings {
   int skewport_extrapolation_limit_in_content_pixels;
   size_t max_memory_for_prepaint_percentage;
   bool strict_layer_property_change_checking;
-  bool use_one_copy;
   bool use_zero_copy;
   bool use_persistent_map_for_gpu_memory_buffers;
   bool enable_elastic_overscroll;
diff --git a/chrome/app/generated_resources.grd b/chrome/app/generated_resources.grd
index 3a648c9..394e2d9 100644
--- a/chrome/app/generated_resources.grd
+++ b/chrome/app/generated_resources.grd
@@ -6232,12 +6232,6 @@ Keep your key file in a safe place. You will need it to create new versions of y
           If enabled, the renderer delegates compositing to the browser, merging both compositing passes.
         </message>
       </if>
-      <message name="IDS_FLAGS_DISABLE_ONE_COPY_NAME" desc="Name of about:flags option for one-copy rasterizer.">
-        Disable one-copy rasterizer
-      </message>
-      <message name="IDS_FLAGS_DISABLE_ONE_COPY_DESCRIPTION" desc="Description of about:flags option for one-copy rasterizer.">
-        If disabled, raster threads won't write to GPU memory.
-      </message>
       <message name="IDS_FLAGS_ENABLE_ZERO_COPY_NAME" desc="Name of about:flags option for zero-copy rasterizer.">
         Enable zero-copy rasterizer
       </message>
diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc
index f490127..498ba0c 100644
--- a/chrome/browser/about_flags.cc
+++ b/chrome/browser/about_flags.cc
@@ -1422,11 +1422,6 @@ const Experiment kExperiments[] = {
      // Java-only switch: ContentSwitches.ENABLE_ACCESSIBILITY_SCRIPT_INJECTION.
      SINGLE_VALUE_TYPE("enable-accessibility-script-injection")},
 #endif
-    {"disable-one-copy",
-     IDS_FLAGS_DISABLE_ONE_COPY_NAME,
-     IDS_FLAGS_DISABLE_ONE_COPY_DESCRIPTION,
-     kOsAll,
-     SINGLE_VALUE_TYPE(switches::kDisableOneCopy)},
     {"enable-zero-copy",
      IDS_FLAGS_ENABLE_ZERO_COPY_NAME,
      IDS_FLAGS_ENABLE_ZERO_COPY_DESCRIPTION,
diff --git a/chrome/browser/chromeos/login/chrome_restart_request.cc b/chrome/browser/chromeos/login/chrome_restart_request.cc
index 53eec4c..d3ea728 100644
--- a/chrome/browser/chromeos/login/chrome_restart_request.cc
+++ b/chrome/browser/chromeos/login/chrome_restart_request.cc
@@ -83,7 +83,6 @@ void DeriveCommandLine(const GURL& start_url,
     ::switches::kDisableGpuRasterization,
     ::switches::kDisableLowResTiling,
     ::switches::kDisableMediaSource,
-    ::switches::kDisableOneCopy,
     ::switches::kDisablePersistentGpuMemoryBuffer,
     ::switches::kDisablePreferCompositingToLCDText,
     ::switches::kDisablePrefixedEncryptedMedia,
diff --git a/components/html_viewer/web_layer_tree_view_impl.cc b/components/html_viewer/web_layer_tree_view_impl.cc
index 3d3b88c..ca9e51a 100644
--- a/components/html_viewer/web_layer_tree_view_impl.cc
+++ b/components/html_viewer/web_layer_tree_view_impl.cc
@@ -39,7 +39,6 @@ WebLayerTreeViewImpl::WebLayerTreeViewImpl(
 
   settings.use_image_texture_targets = std::vector<unsigned>(
       static_cast<size_t>(gfx::BufferFormat::LAST) + 1, GL_TEXTURE_2D);
-  settings.use_one_copy = true;
   // TODO(jam): use multiple compositor raster threads and set gather_pixel_refs
   // accordingly (see content).
 
diff --git a/content/browser/gpu/compositor_util.cc b/content/browser/gpu/compositor_util.cc
index bf10085..9fe88b1c 100644
--- a/content/browser/gpu/compositor_util.cc
+++ b/content/browser/gpu/compositor_util.cc
@@ -191,14 +191,6 @@ int NumberOfRendererRasterThreads() {
 
   int num_raster_threads = num_processors / 2;
 
-  // Async uploads is used when neither zero-copy nor one-copy is enabled and
-  // it uses its own thread, so reduce the number of raster threads when async
-  // uploads is in use.
-  bool async_uploads_is_used =
-      !IsZeroCopyUploadEnabled() && !IsOneCopyUploadEnabled();
-  if (async_uploads_is_used)
-    --num_raster_threads;
-
 #if defined(OS_ANDROID)
   // Limit the number of raster threads to 1 on Android.
   // TODO(reveman): Remove this when we have a better mechanims to prevent
@@ -222,15 +214,6 @@ int NumberOfRendererRasterThreads() {
                                     kMaxRasterThreads);
 }
 
-bool IsOneCopyUploadEnabled() {
-  if (IsZeroCopyUploadEnabled())
-    return false;
-
-  const base::CommandLine& command_line =
-      *base::CommandLine::ForCurrentProcess();
-  return !command_line.HasSwitch(switches::kDisableOneCopy);
-}
-
 bool IsZeroCopyUploadEnabled() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
diff --git a/content/browser/gpu/compositor_util.h b/content/browser/gpu/compositor_util.h
index 8bffb5b..9a309e8 100644
--- a/content/browser/gpu/compositor_util.h
+++ b/content/browser/gpu/compositor_util.h
@@ -20,10 +20,6 @@ CONTENT_EXPORT bool IsPropertyTreeVerificationEnabled();
 // Returns true if delegated-renderer is on (via flags, or platform default).
 CONTENT_EXPORT bool IsDelegatedRendererEnabled();
 
-// Returns true if one-copy uploads is on (via flags, or platform default).
-// Only one of one-copy and zero-copy can be enabled at a time.
-CONTENT_EXPORT bool IsOneCopyUploadEnabled();
-
 // Returns true if zero-copy uploads is on (via flags, or platform default).
 // Only one of one-copy and zero-copy can be enabled at a time.
 CONTENT_EXPORT bool IsZeroCopyUploadEnabled();
diff --git a/content/browser/renderer_host/compositor_impl_android.cc b/content/browser/renderer_host/compositor_impl_android.cc
index b5ee3fa..146e041 100644
--- a/content/browser/renderer_host/compositor_impl_android.cc
+++ b/content/browser/renderer_host/compositor_impl_android.cc
@@ -447,7 +447,6 @@ void CompositorImpl::CreateLayerTreeHost() {
   settings.renderer_settings.allow_antialiasing = false;
   settings.renderer_settings.highp_threshold_min = 2048;
   settings.use_zero_copy = true;
-  settings.use_one_copy = false;
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   settings.initial_debug_state.SetRecordRenderingStats(
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index 290ba9a..553bddf 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -1144,12 +1144,8 @@ static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {
         base::IntToString(msaa_sample_count));
   }
 
-  DCHECK_IMPLIES(IsZeroCopyUploadEnabled(), !IsOneCopyUploadEnabled());
-  DCHECK_IMPLIES(IsOneCopyUploadEnabled(), !IsZeroCopyUploadEnabled());
   if (IsZeroCopyUploadEnabled())
     command_line->AppendSwitch(switches::kEnableZeroCopy);
-  if (!IsOneCopyUploadEnabled())
-    command_line->AppendSwitch(switches::kDisableOneCopy);
   if (IsPersistentGpuMemoryBufferEnabled())
     command_line->AppendSwitch(switches::kEnablePersistentGpuMemoryBuffer);
 
diff --git a/content/public/common/content_switches.cc b/content/public/common/content_switches.cc
index b0df697..f8f4ccf 100644
--- a/content/public/common/content_switches.cc
+++ b/content/public/common/content_switches.cc
@@ -195,9 +195,6 @@ const char kDisableNativeGpuMemoryBuffers[] =
 // Disables the Web Notification and the Push APIs.
 const char kDisableNotifications[]          = "disable-notifications";
 
-// Disable rasterizer that writes directly to GPU memory.
-const char kDisableOneCopy[]                = "disable-one-copy";
-
 // Disable Pepper3D.
 const char kDisablePepper3d[]               = "disable-pepper-3d";
 
diff --git a/content/public/common/content_switches.h b/content/public/common/content_switches.h
index 991c718..43f2ef4 100644
--- a/content/public/common/content_switches.h
+++ b/content/public/common/content_switches.h
@@ -67,7 +67,6 @@ CONTENT_EXPORT extern const char kDisableMediaSource[];
 CONTENT_EXPORT extern const char kDisableNamespaceSandbox[];
 CONTENT_EXPORT extern const char kDisableNativeGpuMemoryBuffers[];
 CONTENT_EXPORT extern const char kDisableNotifications[];
-CONTENT_EXPORT extern const char kDisableOneCopy[];
 extern const char kDisablePepper3d[];
 CONTENT_EXPORT extern const char kDisablePermissionsAPI[];
 CONTENT_EXPORT extern const char kDisablePersistentGpuMemoryBuffer[];
diff --git a/content/renderer/gpu/compositor_dependencies.h b/content/renderer/gpu/compositor_dependencies.h
index 4c81865..534732d 100644
--- a/content/renderer/gpu/compositor_dependencies.h
+++ b/content/renderer/gpu/compositor_dependencies.h
@@ -39,7 +39,6 @@ class CompositorDependencies {
   virtual bool IsLcdTextEnabled() = 0;
   virtual bool IsDistanceFieldTextEnabled() = 0;
   virtual bool IsZeroCopyEnabled() = 0;
-  virtual bool IsOneCopyEnabled() = 0;
   virtual bool IsPersistentGpuMemoryBufferEnabled() = 0;
   virtual bool IsElasticOverscrollEnabled() = 0;
   virtual std::vector<unsigned> GetImageTextureTargets() = 0;
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index 9f7c528..33d277a 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -302,7 +302,6 @@ void RenderWidgetCompositor::Initialize() {
   settings.use_distance_field_text =
       compositor_deps_->IsDistanceFieldTextEnabled();
   settings.use_zero_copy = compositor_deps_->IsZeroCopyEnabled();
-  settings.use_one_copy = compositor_deps_->IsOneCopyEnabled();
   settings.use_persistent_map_for_gpu_memory_buffers =
       compositor_deps_->IsPersistentGpuMemoryBufferEnabled();
   settings.enable_elastic_overscroll =
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index e10b26b..5ce43bb 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -652,7 +652,6 @@ void RenderThreadImpl::Init() {
       !command_line.HasSwitch(cc::switches::kDisableThreadedAnimation);
 
   is_zero_copy_enabled_ = command_line.HasSwitch(switches::kEnableZeroCopy);
-  is_one_copy_enabled_ = !command_line.HasSwitch(switches::kDisableOneCopy);
   is_persistent_gpu_memory_buffer_enabled_ =
       command_line.HasSwitch(switches::kEnablePersistentGpuMemoryBuffer);
 
@@ -1483,10 +1482,6 @@ bool RenderThreadImpl::IsZeroCopyEnabled() {
   return is_zero_copy_enabled_;
 }
 
-bool RenderThreadImpl::IsOneCopyEnabled() {
-  return is_one_copy_enabled_;
-}
-
 bool RenderThreadImpl::IsPersistentGpuMemoryBufferEnabled() {
   return is_persistent_gpu_memory_buffer_enabled_;
 }
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index a7b2c74..0cfe620 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -193,7 +193,6 @@ class CONTENT_EXPORT RenderThreadImpl
   bool IsLcdTextEnabled() override;
   bool IsDistanceFieldTextEnabled() override;
   bool IsZeroCopyEnabled() override;
-  bool IsOneCopyEnabled() override;
   bool IsPersistentGpuMemoryBufferEnabled() override;
   bool IsElasticOverscrollEnabled() override;
   std::vector<unsigned> GetImageTextureTargets() override;
diff --git a/content/test/fake_compositor_dependencies.cc b/content/test/fake_compositor_dependencies.cc
index 64be534..045dcee 100644
--- a/content/test/fake_compositor_dependencies.cc
+++ b/content/test/fake_compositor_dependencies.cc
@@ -42,10 +42,6 @@ bool FakeCompositorDependencies::IsZeroCopyEnabled() {
   return true;
 }
 
-bool FakeCompositorDependencies::IsOneCopyEnabled() {
-  return false;
-}
-
 bool FakeCompositorDependencies::IsPersistentGpuMemoryBufferEnabled() {
   return false;
 }
diff --git a/content/test/fake_compositor_dependencies.h b/content/test/fake_compositor_dependencies.h
index 464cbd3..4786d54 100644
--- a/content/test/fake_compositor_dependencies.h
+++ b/content/test/fake_compositor_dependencies.h
@@ -25,7 +25,6 @@ class FakeCompositorDependencies : public CompositorDependencies {
   bool IsLcdTextEnabled() override;
   bool IsDistanceFieldTextEnabled() override;
   bool IsZeroCopyEnabled() override;
-  bool IsOneCopyEnabled() override;
   bool IsPersistentGpuMemoryBufferEnabled() override;
   bool IsElasticOverscrollEnabled() override;
   std::vector<unsigned> GetImageTextureTargets() override;
diff --git a/gpu/BUILD.gn b/gpu/BUILD.gn
index 1f7f5fe..7d1f4c5 100644
--- a/gpu/BUILD.gn
+++ b/gpu/BUILD.gn
@@ -171,10 +171,6 @@ test("gpu_unittests") {
     "command_buffer/common/id_allocator_test.cc",
     "command_buffer/common/trace_event.h",
     "command_buffer/common/unittest_main.cc",
-    "command_buffer/service/async_pixel_transfer_delegate_mock.cc",
-    "command_buffer/service/async_pixel_transfer_delegate_mock.h",
-    "command_buffer/service/async_pixel_transfer_manager_mock.cc",
-    "command_buffer/service/async_pixel_transfer_manager_mock.h",
     "command_buffer/service/buffer_manager_unittest.cc",
     "command_buffer/service/cmd_parser_test.cc",
     "command_buffer/service/command_buffer_service_unittest.cc",
@@ -196,7 +192,6 @@ test("gpu_unittests") {
     "command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h",
     "command_buffer/service/gles2_cmd_decoder_unittest_3.cc",
     "command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h",
-    "command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc",
     "command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc",
     "command_buffer/service/gles2_cmd_decoder_unittest_base.cc",
     "command_buffer/service/gles2_cmd_decoder_unittest_base.h",
diff --git a/gpu/GLES2/gl2chromium_autogen.h b/gpu/GLES2/gl2chromium_autogen.h
index a16804f..26a8650 100644
--- a/gpu/GLES2/gl2chromium_autogen.h
+++ b/gpu/GLES2/gl2chromium_autogen.h
@@ -325,11 +325,6 @@
 #define glReleaseTexImage2DCHROMIUM GLES2_GET_FUN(ReleaseTexImage2DCHROMIUM)
 #define glTraceBeginCHROMIUM GLES2_GET_FUN(TraceBeginCHROMIUM)
 #define glTraceEndCHROMIUM GLES2_GET_FUN(TraceEndCHROMIUM)
-#define glAsyncTexSubImage2DCHROMIUM GLES2_GET_FUN(AsyncTexSubImage2DCHROMIUM)
-#define glAsyncTexImage2DCHROMIUM GLES2_GET_FUN(AsyncTexImage2DCHROMIUM)
-#define glWaitAsyncTexImage2DCHROMIUM GLES2_GET_FUN(WaitAsyncTexImage2DCHROMIUM)
-#define glWaitAllAsyncTexImage2DCHROMIUM \
-  GLES2_GET_FUN(WaitAllAsyncTexImage2DCHROMIUM)
 #define glDiscardFramebufferEXT GLES2_GET_FUN(DiscardFramebufferEXT)
 #define glLoseContextCHROMIUM GLES2_GET_FUN(LoseContextCHROMIUM)
 #define glInsertSyncPointCHROMIUM GLES2_GET_FUN(InsertSyncPointCHROMIUM)
diff --git a/gpu/GLES2/gl2extchromium.h b/gpu/GLES2/gl2extchromium.h
index 77f0d9f..157458c 100644
--- a/gpu/GLES2/gl2extchromium.h
+++ b/gpu/GLES2/gl2extchromium.h
@@ -374,9 +374,6 @@ typedef void (GL_APIENTRYP PFNGLBLITFRAMEBUFFERCHROMIUMPROC) (GLint srcX0, GLint
 #ifndef GL_CHROMIUM_async_pixel_transfers
 #define GL_CHROMIUM_async_pixel_transfers 1
 
-#ifndef GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM
-#define GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM 0x6005
-#endif
 #ifndef GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM
 #define GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM 0x6006
 #endif
diff --git a/gpu/blink/webgraphicscontext3d_impl.cc b/gpu/blink/webgraphicscontext3d_impl.cc
index 30fa260..8fe23ee 100644
--- a/gpu/blink/webgraphicscontext3d_impl.cc
+++ b/gpu/blink/webgraphicscontext3d_impl.cc
@@ -966,16 +966,6 @@ DELEGATE_TO_GL_2R(mapBufferCHROMIUM, MapBufferCHROMIUM, WGC3Denum, WGC3Denum,
 DELEGATE_TO_GL_1R(unmapBufferCHROMIUM, UnmapBufferCHROMIUM, WGC3Denum,
                   WGC3Dboolean)
 
-DELEGATE_TO_GL_9(asyncTexImage2DCHROMIUM, AsyncTexImage2DCHROMIUM, WGC3Denum,
-                 WGC3Dint, WGC3Denum, WGC3Dsizei, WGC3Dsizei, WGC3Dint,
-                 WGC3Denum, WGC3Denum, const void*)
-DELEGATE_TO_GL_9(asyncTexSubImage2DCHROMIUM, AsyncTexSubImage2DCHROMIUM,
-                 WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
-                 WGC3Dsizei, WGC3Denum, WGC3Denum, const void*)
-
-DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
-                 WGC3Denum)
-
 DELEGATE_TO_GL_2(drawBuffersEXT, DrawBuffersEXT, WGC3Dsizei, const WGC3Denum*)
 
 DELEGATE_TO_GL_4(drawArraysInstancedANGLE, DrawArraysInstancedANGLE, WGC3Denum,
diff --git a/gpu/blink/webgraphicscontext3d_impl.h b/gpu/blink/webgraphicscontext3d_impl.h
index f3d03d3..74391ba 100644
--- a/gpu/blink/webgraphicscontext3d_impl.h
+++ b/gpu/blink/webgraphicscontext3d_impl.h
@@ -600,27 +600,6 @@ class GPU_BLINK_EXPORT WebGraphicsContext3DImpl
                                   blink::WGC3Denum access);
   virtual blink::WGC3Dboolean unmapBufferCHROMIUM(blink::WGC3Denum target);
 
-  // Async pixel transfer functions.
-  virtual void asyncTexImage2DCHROMIUM(blink::WGC3Denum target,
-                                       blink::WGC3Dint level,
-                                       blink::WGC3Denum internalformat,
-                                       blink::WGC3Dsizei width,
-                                       blink::WGC3Dsizei height,
-                                       blink::WGC3Dint border,
-                                       blink::WGC3Denum format,
-                                       blink::WGC3Denum type,
-                                       const void* pixels);
-  virtual void asyncTexSubImage2DCHROMIUM(blink::WGC3Denum target,
-                                          blink::WGC3Dint level,
-                                          blink::WGC3Dint xoffset,
-                                          blink::WGC3Dint yoffset,
-                                          blink::WGC3Dsizei width,
-                                          blink::WGC3Dsizei height,
-                                          blink::WGC3Denum format,
-                                          blink::WGC3Denum type,
-                                          const void* pixels);
-  virtual void waitAsyncTexImage2DCHROMIUM(blink::WGC3Denum target);
-
   // GL_EXT_draw_buffers
   virtual void drawBuffersEXT(blink::WGC3Dsizei n,
                               const blink::WGC3Denum* bufs);
diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index bc1e9e4..d75f6c4 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1260,7 +1260,6 @@ _NAMED_TYPE_INFO = {
       'GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT',
       'GL_COMMANDS_ISSUED_CHROMIUM',
       'GL_LATENCY_QUERY_CHROMIUM',
-      'GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM',
       'GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM',
       'GL_COMMANDS_COMPLETED_CHROMIUM',
     ],
@@ -4032,51 +4031,6 @@ _FUNCTION_INFO = {
     'extension': True,
     'chromium': True,
   },
-  'AsyncTexImage2DCHROMIUM': {
-    'type': 'Manual',
-    'data_transfer_methods': ['shm'],
-    'client_test': False,
-    'cmd_args': 'GLenumTextureTarget target, GLint level, '
-        'GLintTextureInternalFormat internalformat, '
-        'GLsizei width, GLsizei height, '
-        'GLintTextureBorder border, '
-        'GLenumTextureFormat format, GLenumPixelType type, '
-        'const void* pixels, '
-        'uint32_t async_upload_token, '
-        'void* sync_data',
-    'extension': True,
-    'chromium': True,
-    'trace_level': 2,
-  },
-  'AsyncTexSubImage2DCHROMIUM': {
-    'type': 'Manual',
-    'data_transfer_methods': ['shm'],
-    'client_test': False,
-    'cmd_args': 'GLenumTextureTarget target, GLint level, '
-        'GLint xoffset, GLint yoffset, '
-        'GLsizei width, GLsizei height, '
-        'GLenumTextureFormat format, GLenumPixelType type, '
-        'const void* data, '
-        'uint32_t async_upload_token, '
-        'void* sync_data',
-    'extension': True,
-    'chromium': True,
-    'trace_level': 2,
-  },
-  'WaitAsyncTexImage2DCHROMIUM': {
-    'type': 'Manual',
-    'client_test': False,
-    'extension': True,
-    'chromium': True,
-    'trace_level': 1,
-  },
-  'WaitAllAsyncTexImage2DCHROMIUM': {
-    'type': 'Manual',
-    'client_test': False,
-    'extension': True,
-    'chromium': True,
-    'trace_level': 1,
-  },
   'DiscardFramebufferEXT': {
     'type': 'PUTn',
     'count': 1,
diff --git a/gpu/command_buffer/client/buffer_tracker_unittest.cc b/gpu/command_buffer/client/buffer_tracker_unittest.cc
index e8d4d81..c1ed0b6 100644
--- a/gpu/command_buffer/client/buffer_tracker_unittest.cc
+++ b/gpu/command_buffer/client/buffer_tracker_unittest.cc
@@ -43,11 +43,6 @@ class MockClientCommandBufferImpl : public MockClientCommandBuffer {
   bool context_lost_;
 };
 
-namespace {
-void EmptyPoll() {
-}
-}
-
 class BufferTrackerTest : public testing::Test {
  protected:
   static const int32 kNumCommandEntries = 400;
@@ -58,8 +53,8 @@ class BufferTrackerTest : public testing::Test {
     command_buffer_.reset(new MockClientCommandBufferImpl());
     helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
     helper_->Initialize(kCommandBufferSizeBytes);
-    mapped_memory_.reset(new MappedMemoryManager(
-        helper_.get(), base::Bind(&EmptyPoll), MappedMemoryManager::kNoLimit));
+    mapped_memory_.reset(
+        new MappedMemoryManager(helper_.get(), MappedMemoryManager::kNoLimit));
     buffer_tracker_.reset(new BufferTracker(mapped_memory_.get()));
   }
 
diff --git a/gpu/command_buffer/client/fenced_allocator.cc b/gpu/command_buffer/client/fenced_allocator.cc
index bb89886..726fe7d 100644
--- a/gpu/command_buffer/client/fenced_allocator.cc
+++ b/gpu/command_buffer/client/fenced_allocator.cc
@@ -32,12 +32,8 @@ const FencedAllocator::Offset FencedAllocator::kInvalidOffset;
 const unsigned int FencedAllocator::kAllocAlignment;
 #endif
 
-FencedAllocator::FencedAllocator(unsigned int size,
-                                 CommandBufferHelper* helper,
-                                 const base::Closure& poll_callback)
-    : helper_(helper),
-      poll_callback_(poll_callback),
-      bytes_in_use_(0) {
+FencedAllocator::FencedAllocator(unsigned int size, CommandBufferHelper* helper)
+    : helper_(helper), bytes_in_use_(0) {
   Block block = { FREE, 0, RoundDown(size), kUnusedToken };
   blocks_.push_back(block);
 }
@@ -216,9 +212,6 @@ FencedAllocator::BlockIndex FencedAllocator::WaitForTokenAndFreeBlock(
 
 // Frees any blocks pending a token for which the token has been read.
 void FencedAllocator::FreeUnused() {
-  // Free any potential blocks that has its lifetime handled outside.
-  poll_callback_.Run();
-
   for (unsigned int i = 0; i < blocks_.size();) {
     Block& block = blocks_[i];
     if (block.state == FREE_PENDING_TOKEN &&
diff --git a/gpu/command_buffer/client/fenced_allocator.h b/gpu/command_buffer/client/fenced_allocator.h
index c19fbbd..95dccce 100644
--- a/gpu/command_buffer/client/fenced_allocator.h
+++ b/gpu/command_buffer/client/fenced_allocator.h
@@ -40,9 +40,7 @@ class GPU_EXPORT FencedAllocator {
 
   // Creates a FencedAllocator. Note that the size of the buffer is passed, but
   // not its base address: everything is handled as offsets into the buffer.
-  FencedAllocator(unsigned int size,
-                  CommandBufferHelper *helper,
-                  const base::Closure& poll_callback);
+  FencedAllocator(unsigned int size, CommandBufferHelper* helper);
 
   ~FencedAllocator();
 
@@ -146,7 +144,6 @@ class GPU_EXPORT FencedAllocator {
   Offset AllocInBlock(BlockIndex index, unsigned int size);
 
   CommandBufferHelper *helper_;
-  base::Closure poll_callback_;
   Container blocks_;
   size_t bytes_in_use_;
 
@@ -159,10 +156,8 @@ class FencedAllocatorWrapper {
  public:
   FencedAllocatorWrapper(unsigned int size,
                          CommandBufferHelper* helper,
-                         const base::Closure& poll_callback,
                          void* base)
-      : allocator_(size, helper, poll_callback),
-        base_(base) { }
+      : allocator_(size, helper), base_(base) {}
 
   // Allocates a block of memory. If the buffer is out of directly available
   // memory, this function may wait until memory that was freed "pending a
diff --git a/gpu/command_buffer/client/fenced_allocator_test.cc b/gpu/command_buffer/client/fenced_allocator_test.cc
index d5b3437..94faf0c 100644
--- a/gpu/command_buffer/client/fenced_allocator_test.cc
+++ b/gpu/command_buffer/client/fenced_allocator_test.cc
@@ -80,11 +80,6 @@ class BaseFencedAllocatorTest : public testing::Test {
 const unsigned int BaseFencedAllocatorTest::kBufferSize;
 #endif
 
-namespace {
-void EmptyPoll() {
-}
-}
-
 // Test fixture for FencedAllocator test - Creates a FencedAllocator, using a
 // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling
 // it directly, not through the RPC mechanism), making sure Noops are ignored
@@ -93,9 +88,7 @@ class FencedAllocatorTest : public BaseFencedAllocatorTest {
  protected:
   void SetUp() override {
     BaseFencedAllocatorTest::SetUp();
-    allocator_.reset(new FencedAllocator(kBufferSize,
-                                         helper_.get(),
-                                         base::Bind(&EmptyPoll)));
+    allocator_.reset(new FencedAllocator(kBufferSize, helper_.get()));
   }
 
   void TearDown() override {
@@ -390,63 +383,6 @@ TEST_F(FencedAllocatorTest, TestGetLargestFreeOrPendingSize) {
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSize());
 }
 
-class FencedAllocatorPollTest : public BaseFencedAllocatorTest {
- public:
-  static const unsigned int kAllocSize = 128;
-
-  MOCK_METHOD0(MockedPoll, void());
-
- protected:
-  virtual void TearDown() {
-    // If the GpuScheduler posts any tasks, this forces them to run.
-    base::MessageLoop::current()->RunUntilIdle();
-
-    BaseFencedAllocatorTest::TearDown();
-  }
-};
-
-TEST_F(FencedAllocatorPollTest, TestPoll) {
-  scoped_ptr<FencedAllocator> allocator(
-      new FencedAllocator(kBufferSize,
-                          helper_.get(),
-                          base::Bind(&FencedAllocatorPollTest::MockedPoll,
-                                     base::Unretained(this))));
-
-  FencedAllocator::Offset mem1 = allocator->Alloc(kAllocSize);
-  FencedAllocator::Offset mem2 = allocator->Alloc(kAllocSize);
-  EXPECT_NE(mem1, FencedAllocator::kInvalidOffset);
-  EXPECT_NE(mem2, FencedAllocator::kInvalidOffset);
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 2);
-
-  // Check that no-op Poll doesn't affect the state.
-  EXPECT_CALL(*this, MockedPoll()).RetiresOnSaturation();
-  allocator->FreeUnused();
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 2);
-
-  // Check that freeing in Poll works.
-  base::Closure free_mem1_closure =
-      base::Bind(&FencedAllocator::Free,
-                 base::Unretained(allocator.get()),
-                 mem1);
-  EXPECT_CALL(*this, MockedPoll())
-      .WillOnce(InvokeWithoutArgs(&free_mem1_closure, &base::Closure::Run))
-      .RetiresOnSaturation();
-  allocator->FreeUnused();
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 1);
-
-  // Check that freeing still works.
-  EXPECT_CALL(*this, MockedPoll()).RetiresOnSaturation();
-  allocator->Free(mem2);
-  allocator->FreeUnused();
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), 0u);
-
-  allocator.reset();
-}
-
 // Test fixture for FencedAllocatorWrapper test - Creates a
 // FencedAllocatorWrapper, using a CommandBufferHelper with a mock
 // AsyncAPIInterface for its interface (calling it directly, not through the
@@ -464,7 +400,6 @@ class FencedAllocatorWrapperTest : public BaseFencedAllocatorTest {
         kBufferSize, kAllocAlignment)));
     allocator_.reset(new FencedAllocatorWrapper(kBufferSize,
                                                 helper_.get(),
-                                                base::Bind(&EmptyPoll),
                                                 buffer_.get()));
   }
 
diff --git a/gpu/command_buffer/client/gles2_c_lib_autogen.h b/gpu/command_buffer/client/gles2_c_lib_autogen.h
index 989c500..0e43ae7 100644
--- a/gpu/command_buffer/client/gles2_c_lib_autogen.h
+++ b/gpu/command_buffer/client/gles2_c_lib_autogen.h
@@ -1470,37 +1470,6 @@ void GL_APIENTRY GLES2TraceBeginCHROMIUM(const char* category_name,
 void GL_APIENTRY GLES2TraceEndCHROMIUM() {
   gles2::GetGLContext()->TraceEndCHROMIUM();
 }
-void GL_APIENTRY GLES2AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                                 GLint level,
-                                                 GLint xoffset,
-                                                 GLint yoffset,
-                                                 GLsizei width,
-                                                 GLsizei height,
-                                                 GLenum format,
-                                                 GLenum type,
-                                                 const void* data) {
-  gles2::GetGLContext()->AsyncTexSubImage2DCHROMIUM(
-      target, level, xoffset, yoffset, width, height, format, type, data);
-}
-void GL_APIENTRY GLES2AsyncTexImage2DCHROMIUM(GLenum target,
-                                              GLint level,
-                                              GLenum internalformat,
-                                              GLsizei width,
-                                              GLsizei height,
-                                              GLint border,
-                                              GLenum format,
-                                              GLenum type,
-                                              const void* pixels) {
-  gles2::GetGLContext()->AsyncTexImage2DCHROMIUM(target, level, internalformat,
-                                                 width, height, border, format,
-                                                 type, pixels);
-}
-void GL_APIENTRY GLES2WaitAsyncTexImage2DCHROMIUM(GLenum target) {
-  gles2::GetGLContext()->WaitAsyncTexImage2DCHROMIUM(target);
-}
-void GL_APIENTRY GLES2WaitAllAsyncTexImage2DCHROMIUM() {
-  gles2::GetGLContext()->WaitAllAsyncTexImage2DCHROMIUM();
-}
 void GL_APIENTRY GLES2DiscardFramebufferEXT(GLenum target,
                                             GLsizei count,
                                             const GLenum* attachments) {
@@ -2740,23 +2709,6 @@ extern const NameToFunc g_gles2_function_table[] = {
         reinterpret_cast<GLES2FunctionPointer>(glTraceEndCHROMIUM),
     },
     {
-        "glAsyncTexSubImage2DCHROMIUM",
-        reinterpret_cast<GLES2FunctionPointer>(glAsyncTexSubImage2DCHROMIUM),
-    },
-    {
-        "glAsyncTexImage2DCHROMIUM",
-        reinterpret_cast<GLES2FunctionPointer>(glAsyncTexImage2DCHROMIUM),
-    },
-    {
-        "glWaitAsyncTexImage2DCHROMIUM",
-        reinterpret_cast<GLES2FunctionPointer>(glWaitAsyncTexImage2DCHROMIUM),
-    },
-    {
-        "glWaitAllAsyncTexImage2DCHROMIUM",
-        reinterpret_cast<GLES2FunctionPointer>(
-            glWaitAllAsyncTexImage2DCHROMIUM),
-    },
-    {
         "glDiscardFramebufferEXT",
         reinterpret_cast<GLES2FunctionPointer>(glDiscardFramebufferEXT),
     },
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index 249e8a4..d31d0d8 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -2728,65 +2728,6 @@ void TraceEndCHROMIUM() {
   }
 }
 
-void AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                GLint level,
-                                GLint xoffset,
-                                GLint yoffset,
-                                GLsizei width,
-                                GLsizei height,
-                                GLenum format,
-                                GLenum type,
-                                uint32_t data_shm_id,
-                                uint32_t data_shm_offset,
-                                uint32_t async_upload_token,
-                                uint32_t sync_data_shm_id,
-                                uint32_t sync_data_shm_offset) {
-  gles2::cmds::AsyncTexSubImage2DCHROMIUM* c =
-      GetCmdSpace<gles2::cmds::AsyncTexSubImage2DCHROMIUM>();
-  if (c) {
-    c->Init(target, level, xoffset, yoffset, width, height, format, type,
-            data_shm_id, data_shm_offset, async_upload_token, sync_data_shm_id,
-            sync_data_shm_offset);
-  }
-}
-
-void AsyncTexImage2DCHROMIUM(GLenum target,
-                             GLint level,
-                             GLint internalformat,
-                             GLsizei width,
-                             GLsizei height,
-                             GLenum format,
-                             GLenum type,
-                             uint32_t pixels_shm_id,
-                             uint32_t pixels_shm_offset,
-                             uint32_t async_upload_token,
-                             uint32_t sync_data_shm_id,
-                             uint32_t sync_data_shm_offset) {
-  gles2::cmds::AsyncTexImage2DCHROMIUM* c =
-      GetCmdSpace<gles2::cmds::AsyncTexImage2DCHROMIUM>();
-  if (c) {
-    c->Init(target, level, internalformat, width, height, format, type,
-            pixels_shm_id, pixels_shm_offset, async_upload_token,
-            sync_data_shm_id, sync_data_shm_offset);
-  }
-}
-
-void WaitAsyncTexImage2DCHROMIUM(GLenum target) {
-  gles2::cmds::WaitAsyncTexImage2DCHROMIUM* c =
-      GetCmdSpace<gles2::cmds::WaitAsyncTexImage2DCHROMIUM>();
-  if (c) {
-    c->Init(target);
-  }
-}
-
-void WaitAllAsyncTexImage2DCHROMIUM() {
-  gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM* c =
-      GetCmdSpace<gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM>();
-  if (c) {
-    c->Init();
-  }
-}
-
 void DiscardFramebufferEXTImmediate(GLenum target,
                                     GLsizei count,
                                     const GLenum* attachments) {
diff --git a/gpu/command_buffer/client/gles2_implementation.cc b/gpu/command_buffer/client/gles2_implementation.cc
index 31d94f1..5635f26 100644
--- a/gpu/command_buffer/client/gles2_implementation.cc
+++ b/gpu/command_buffer/client/gles2_implementation.cc
@@ -103,10 +103,6 @@ GLES2Implementation::GLES2Implementation(
       bound_uniform_buffer_(0),
       bound_pixel_pack_transfer_buffer_id_(0),
       bound_pixel_unpack_transfer_buffer_id_(0),
-      async_upload_token_(0),
-      async_upload_sync_(NULL),
-      async_upload_sync_shm_id_(0),
-      async_upload_sync_shm_offset_(0),
       error_bits_(0),
       debug_(false),
       lose_context_when_out_of_memory_(lose_context_when_out_of_memory),
@@ -158,15 +154,7 @@ bool GLES2Implementation::Initialize(
     return false;
   }
 
-  mapped_memory_.reset(
-      new MappedMemoryManager(
-          helper_,
-          base::Bind(&GLES2Implementation::PollAsyncUploads,
-                     // The mapped memory manager is owned by |this| here, and
-                     // since its destroyed before before we destroy ourselves
-                     // we don't need extra safety measures for this closure.
-                     base::Unretained(this)),
-          mapped_memory_limit));
+  mapped_memory_.reset(new MappedMemoryManager(helper_, mapped_memory_limit));
 
   unsigned chunk_size = 2 * 1024 * 1024;
   if (mapped_memory_limit != kNoLimit) {
@@ -252,13 +240,6 @@ GLES2Implementation::~GLES2Implementation() {
 
   buffer_tracker_.reset();
 
-  FreeAllAsyncUploadBuffers();
-
-  if (async_upload_sync_) {
-    mapped_memory_->Free(async_upload_sync_);
-    async_upload_sync_ = NULL;
-  }
-
   // Make sure the commands make it the service.
   WaitForCmd();
 }
@@ -300,7 +281,6 @@ void GLES2Implementation::FreeUnusedSharedMemory() {
 }
 
 void GLES2Implementation::FreeEverything() {
-  FreeAllAsyncUploadBuffers();
   WaitForCmd();
   query_tracker_->Shrink();
   FreeUnusedSharedMemory();
@@ -1965,17 +1945,8 @@ void GLES2Implementation::BufferSubData(
 
 void GLES2Implementation::RemoveTransferBuffer(BufferTracker::Buffer* buffer) {
   int32 token = buffer->last_usage_token();
-  uint32 async_token = buffer->last_async_upload_token();
 
-  if (async_token) {
-    if (HasAsyncUploadTokenPassed(async_token)) {
-      buffer_tracker_->Free(buffer);
-    } else {
-      detached_async_upload_memory_.push_back(
-          std::make_pair(buffer->address(), async_token));
-      buffer_tracker_->Unmanage(buffer);
-    }
-  } else if (token) {
+  if (token) {
     if (helper_->HasTokenPassed(token))
       buffer_tracker_->Free(buffer);
     else
@@ -4912,7 +4883,6 @@ void GLES2Implementation::BeginQueryEXT(GLenum target, GLuint id) {
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
     case GL_LATENCY_QUERY_CHROMIUM:
-    case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     case GL_GET_ERROR_QUERY_CHROMIUM:
       break;
@@ -5314,12 +5284,6 @@ void* GLES2Implementation::MapBufferCHROMIUM(GLuint target, GLenum access) {
         return NULL;
       }
       break;
-    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
-      if (access != GL_WRITE_ONLY) {
-        SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
-        return NULL;
-      }
-      break;
     default:
       SetGLError(
           GL_INVALID_ENUM, "glMapBufferCHROMIUM", "invalid target");
@@ -5340,10 +5304,6 @@ void* GLES2Implementation::MapBufferCHROMIUM(GLuint target, GLenum access) {
     return NULL;
   }
   // Here we wait for previous transfer operations to be finished.
-  // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work
-  // with this method of synchronization. Until this is fixed,
-  // MapBufferCHROMIUM will not block even if the transfer is not ready
-  // for these calls.
   if (buffer->last_usage_token()) {
     helper_->WaitForToken(buffer->last_usage_token());
     buffer->set_last_usage_token(0);
@@ -5380,207 +5340,6 @@ GLboolean GLES2Implementation::UnmapBufferCHROMIUM(GLuint target) {
   return true;
 }
 
-bool GLES2Implementation::EnsureAsyncUploadSync() {
-  if (async_upload_sync_)
-    return true;
-
-  int32 shm_id;
-  unsigned int shm_offset;
-  void* mem = mapped_memory_->Alloc(sizeof(AsyncUploadSync),
-                                    &shm_id,
-                                    &shm_offset);
-  if (!mem)
-    return false;
-
-  async_upload_sync_shm_id_ = shm_id;
-  async_upload_sync_shm_offset_ = shm_offset;
-  async_upload_sync_ = static_cast<AsyncUploadSync*>(mem);
-  async_upload_sync_->Reset();
-
-  return true;
-}
-
-uint32 GLES2Implementation::NextAsyncUploadToken() {
-  async_upload_token_++;
-  if (async_upload_token_ == 0)
-    async_upload_token_++;
-  return async_upload_token_;
-}
-
-void GLES2Implementation::PollAsyncUploads() {
-  if (!async_upload_sync_)
-    return;
-
-  if (helper_->IsContextLost()) {
-    DetachedAsyncUploadMemoryList::iterator it =
-        detached_async_upload_memory_.begin();
-    while (it != detached_async_upload_memory_.end()) {
-      mapped_memory_->Free(it->first);
-      it = detached_async_upload_memory_.erase(it);
-    }
-    return;
-  }
-
-  DetachedAsyncUploadMemoryList::iterator it =
-      detached_async_upload_memory_.begin();
-  while (it != detached_async_upload_memory_.end()) {
-    if (HasAsyncUploadTokenPassed(it->second)) {
-      mapped_memory_->Free(it->first);
-      it = detached_async_upload_memory_.erase(it);
-    } else {
-      break;
-    }
-  }
-}
-
-void GLES2Implementation::FreeAllAsyncUploadBuffers() {
-  // Free all completed unmanaged async uploads buffers.
-  PollAsyncUploads();
-
-  // Synchronously free rest of the unmanaged async upload buffers.
-  if (!detached_async_upload_memory_.empty()) {
-    WaitAllAsyncTexImage2DCHROMIUMHelper();
-    WaitForCmd();
-    PollAsyncUploads();
-  }
-}
-
-void GLES2Implementation::AsyncTexImage2DCHROMIUM(
-    GLenum target, GLint level, GLenum internalformat, GLsizei width,
-    GLsizei height, GLint border, GLenum format, GLenum type,
-    const void* pixels) {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
-      << width << ", " << height << ", " << border << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
-  if (level < 0 || height < 0 || width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
-    return;
-  }
-  if (border != 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "border != 0");
-    return;
-  }
-  uint32 size;
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
-  if (!GLES2Util::ComputeImageDataSizes(
-          width, height, 1, format, type, unpack_alignment_, &size,
-          &unpadded_row_size, &padded_row_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "image size too large");
-    return;
-  }
-
-  // If there's no data/buffer just issue the AsyncTexImage2D
-  if (!pixels && !bound_pixel_unpack_transfer_buffer_id_) {
-    helper_->AsyncTexImage2DCHROMIUM(
-       target, level, internalformat, width, height, format, type,
-       0, 0, 0, 0, 0);
-    return;
-  }
-
-  if (!EnsureAsyncUploadSync()) {
-    SetGLError(GL_OUT_OF_MEMORY, "glTexImage2D", "out of memory");
-    return;
-  }
-
-  // Otherwise, async uploads require a transfer buffer to be bound.
-  // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
-  // the buffer before the transfer is finished. (Currently such
-  // synchronization has to be handled manually.)
-  GLuint offset = ToGLuint(pixels);
-  BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
-      bound_pixel_unpack_transfer_buffer_id_,
-      "glAsyncTexImage2DCHROMIUM", offset, size);
-  if (buffer && buffer->shm_id() != -1) {
-    uint32 async_token = NextAsyncUploadToken();
-    buffer->set_last_async_upload_token(async_token);
-    helper_->AsyncTexImage2DCHROMIUM(
-        target, level, internalformat, width, height, format, type,
-        buffer->shm_id(), buffer->shm_offset() + offset,
-        async_token,
-        async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
-  }
-}
-
-void GLES2Implementation::AsyncTexSubImage2DCHROMIUM(
-    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
-    GLsizei height, GLenum format, GLenum type, const void* pixels) {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glAsyncTexSubImage2DCHROMIUM("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << xoffset << ", " << yoffset << ", "
-      << width << ", " << height << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
-  if (level < 0 || height < 0 || width < 0) {
-    SetGLError(
-        GL_INVALID_VALUE, "glAsyncTexSubImage2DCHROMIUM", "dimension < 0");
-    return;
-  }
-
-  uint32 size;
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
-  if (!GLES2Util::ComputeImageDataSizes(
-        width, height, 1, format, type, unpack_alignment_, &size,
-        &unpadded_row_size, &padded_row_size)) {
-    SetGLError(
-        GL_INVALID_VALUE, "glAsyncTexSubImage2DCHROMIUM", "size to large");
-    return;
-  }
-
-  if (!EnsureAsyncUploadSync()) {
-    SetGLError(GL_OUT_OF_MEMORY, "glTexImage2D", "out of memory");
-    return;
-  }
-
-  // Async uploads require a transfer buffer to be bound.
-  // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
-  // the buffer before the transfer is finished. (Currently such
-  // synchronization has to be handled manually.)
-  GLuint offset = ToGLuint(pixels);
-  BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
-      bound_pixel_unpack_transfer_buffer_id_,
-      "glAsyncTexSubImage2DCHROMIUM", offset, size);
-  if (buffer && buffer->shm_id() != -1) {
-    uint32 async_token = NextAsyncUploadToken();
-    buffer->set_last_async_upload_token(async_token);
-    helper_->AsyncTexSubImage2DCHROMIUM(
-        target, level, xoffset, yoffset, width, height, format, type,
-        buffer->shm_id(), buffer->shm_offset() + offset,
-        async_token,
-        async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
-  }
-}
-
-void GLES2Implementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glWaitAsyncTexImage2DCHROMIUM("
-      << GLES2Util::GetStringTextureTarget(target) << ")");
-  helper_->WaitAsyncTexImage2DCHROMIUM(target);
-  CheckGLError();
-}
-
-void GLES2Implementation::WaitAllAsyncTexImage2DCHROMIUMHelper() {
-  helper_->WaitAllAsyncTexImage2DCHROMIUM();
-}
-
-void GLES2Implementation::WaitAllAsyncTexImage2DCHROMIUM() {
-  GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix()
-      << "] glWaitAllAsyncTexImage2DCHROMIUM()");
-  WaitAllAsyncTexImage2DCHROMIUMHelper();
-  CheckGLError();
-}
-
 GLuint GLES2Implementation::InsertSyncPointCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertSyncPointCHROMIUM");
diff --git a/gpu/command_buffer/client/gles2_implementation.h b/gpu/command_buffer/client/gles2_implementation.h
index e77b4e2..ed83329 100644
--- a/gpu/command_buffer/client/gles2_implementation.h
+++ b/gpu/command_buffer/client/gles2_implementation.h
@@ -629,32 +629,6 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   // a token.
   void RemoveTransferBuffer(BufferTracker::Buffer* buffer);
 
-  // Returns true if the async upload token has passed.
-  //
-  // NOTE: This will detect wrapped async tokens by checking if the most
-  // significant  bit of async token to check is 1 but the last read is 0, i.e.
-  // the uint32 wrapped.
-  bool HasAsyncUploadTokenPassed(uint32 token) const {
-    return async_upload_sync_->HasAsyncUploadTokenPassed(token);
-  }
-
-  // Get the next async upload token.
-  uint32 NextAsyncUploadToken();
-
-  // Ensure that the shared memory used for synchronizing async upload tokens
-  // has been mapped.
-  //
-  // Returns false on error, true on success.
-  bool EnsureAsyncUploadSync();
-
-  // Checks the last read asynchronously upload token and frees any unmanaged
-  // transfer buffer that has its async token passed.
-  void PollAsyncUploads();
-
-  // Free every async upload buffer. If some async upload buffer is still in use
-  // wait for them to finish before freeing.
-  void FreeAllAsyncUploadBuffers();
-
   bool GetBoundPixelTransferBuffer(
       GLenum target, const char* function_name, GLuint* buffer_id);
   BufferTracker::Buffer* GetBoundPixelUnpackTransferBufferIfValid(
@@ -750,18 +724,6 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   GLuint bound_pixel_pack_transfer_buffer_id_;
   GLuint bound_pixel_unpack_transfer_buffer_id_;
 
-  // The current asynchronous pixel buffer upload token.
-  uint32 async_upload_token_;
-
-  // The shared memory used for synchronizing asynchronous upload tokens.
-  AsyncUploadSync* async_upload_sync_;
-  int32 async_upload_sync_shm_id_;
-  unsigned int async_upload_sync_shm_offset_;
-
-  // Unmanaged pixel transfer buffer memory pending asynchronous upload token.
-  typedef std::list<std::pair<void*, uint32> > DetachedAsyncUploadMemoryList;
-  DetachedAsyncUploadMemoryList detached_async_upload_memory_;
-
   // Client side management for vertex array objects. Needed to correctly
   // track client side arrays.
   scoped_ptr<VertexArrayObjectManager> vertex_array_object_manager_;
diff --git a/gpu/command_buffer/client/gles2_implementation_autogen.h b/gpu/command_buffer/client/gles2_implementation_autogen.h
index 64bfdf4..c0e5370 100644
--- a/gpu/command_buffer/client/gles2_implementation_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_autogen.h
@@ -1019,30 +1019,6 @@ void TraceBeginCHROMIUM(const char* category_name,
 
 void TraceEndCHROMIUM() override;
 
-void AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                GLint level,
-                                GLint xoffset,
-                                GLint yoffset,
-                                GLsizei width,
-                                GLsizei height,
-                                GLenum format,
-                                GLenum type,
-                                const void* data) override;
-
-void AsyncTexImage2DCHROMIUM(GLenum target,
-                             GLint level,
-                             GLenum internalformat,
-                             GLsizei width,
-                             GLsizei height,
-                             GLint border,
-                             GLenum format,
-                             GLenum type,
-                             const void* pixels) override;
-
-void WaitAsyncTexImage2DCHROMIUM(GLenum target) override;
-
-void WaitAllAsyncTexImage2DCHROMIUM() override;
-
 void DiscardFramebufferEXT(GLenum target,
                            GLsizei count,
                            const GLenum* attachments) override;
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest.cc b/gpu/command_buffer/client/gles2_implementation_unittest.cc
index f47b931..52937a59 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest.cc
+++ b/gpu/command_buffer/client/gles2_implementation_unittest.cc
@@ -2646,15 +2646,6 @@ TEST_F(GLES2ImplementationTest, TextureInvalidArguments) {
 
   ClearCommands();
 
-  gl_->AsyncTexImage2DCHROMIUM(
-      kTarget, kLevel, kFormat, kWidth, kHeight, kInvalidBorder, kFormat, kType,
-      NULL);
-
-  EXPECT_TRUE(NoCommandsWritten());
-  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
-
-  ClearCommands();
-
   // Checking for CompressedTexImage2D argument validation is a bit tricky due
   // to (runtime-detected) compression formats. Try to infer the error with an
   // aux check.
diff --git a/gpu/command_buffer/client/gles2_interface_autogen.h b/gpu/command_buffer/client/gles2_interface_autogen.h
index 815b995..e152138 100644
--- a/gpu/command_buffer/client/gles2_interface_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_autogen.h
@@ -757,26 +757,6 @@ virtual void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) = 0;
 virtual void TraceBeginCHROMIUM(const char* category_name,
                                 const char* trace_name) = 0;
 virtual void TraceEndCHROMIUM() = 0;
-virtual void AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                        GLint level,
-                                        GLint xoffset,
-                                        GLint yoffset,
-                                        GLsizei width,
-                                        GLsizei height,
-                                        GLenum format,
-                                        GLenum type,
-                                        const void* data) = 0;
-virtual void AsyncTexImage2DCHROMIUM(GLenum target,
-                                     GLint level,
-                                     GLenum internalformat,
-                                     GLsizei width,
-                                     GLsizei height,
-                                     GLint border,
-                                     GLenum format,
-                                     GLenum type,
-                                     const void* pixels) = 0;
-virtual void WaitAsyncTexImage2DCHROMIUM(GLenum target) = 0;
-virtual void WaitAllAsyncTexImage2DCHROMIUM() = 0;
 virtual void DiscardFramebufferEXT(GLenum target,
                                    GLsizei count,
                                    const GLenum* attachments) = 0;
diff --git a/gpu/command_buffer/client/gles2_interface_stub_autogen.h b/gpu/command_buffer/client/gles2_interface_stub_autogen.h
index 060dbf3..2bb37f3 100644
--- a/gpu/command_buffer/client/gles2_interface_stub_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_stub_autogen.h
@@ -733,26 +733,6 @@ void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) override;
 void TraceBeginCHROMIUM(const char* category_name,
                         const char* trace_name) override;
 void TraceEndCHROMIUM() override;
-void AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                GLint level,
-                                GLint xoffset,
-                                GLint yoffset,
-                                GLsizei width,
-                                GLsizei height,
-                                GLenum format,
-                                GLenum type,
-                                const void* data) override;
-void AsyncTexImage2DCHROMIUM(GLenum target,
-                             GLint level,
-                             GLenum internalformat,
-                             GLsizei width,
-                             GLsizei height,
-                             GLint border,
-                             GLenum format,
-                             GLenum type,
-                             const void* pixels) override;
-void WaitAsyncTexImage2DCHROMIUM(GLenum target) override;
-void WaitAllAsyncTexImage2DCHROMIUM() override;
 void DiscardFramebufferEXT(GLenum target,
                            GLsizei count,
                            const GLenum* attachments) 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 5797b54..b4a3e58 100644
--- a/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h
@@ -1002,26 +1002,6 @@ void GLES2InterfaceStub::ReleaseTexImage2DCHROMIUM(GLenum /* target */,
 void GLES2InterfaceStub::TraceBeginCHROMIUM(const char* /* category_name */,
                                             const char* /* trace_name */) {}
 void GLES2InterfaceStub::TraceEndCHROMIUM() {}
-void GLES2InterfaceStub::AsyncTexSubImage2DCHROMIUM(GLenum /* target */,
-                                                    GLint /* level */,
-                                                    GLint /* xoffset */,
-                                                    GLint /* yoffset */,
-                                                    GLsizei /* width */,
-                                                    GLsizei /* height */,
-                                                    GLenum /* format */,
-                                                    GLenum /* type */,
-                                                    const void* /* data */) {}
-void GLES2InterfaceStub::AsyncTexImage2DCHROMIUM(GLenum /* target */,
-                                                 GLint /* level */,
-                                                 GLenum /* internalformat */,
-                                                 GLsizei /* width */,
-                                                 GLsizei /* height */,
-                                                 GLint /* border */,
-                                                 GLenum /* format */,
-                                                 GLenum /* type */,
-                                                 const void* /* pixels */) {}
-void GLES2InterfaceStub::WaitAsyncTexImage2DCHROMIUM(GLenum /* target */) {}
-void GLES2InterfaceStub::WaitAllAsyncTexImage2DCHROMIUM() {}
 void GLES2InterfaceStub::DiscardFramebufferEXT(
     GLenum /* target */,
     GLsizei /* count */,
diff --git a/gpu/command_buffer/client/gles2_trace_implementation_autogen.h b/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
index 6f6551d..1d0842f 100644
--- a/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
+++ b/gpu/command_buffer/client/gles2_trace_implementation_autogen.h
@@ -733,26 +733,6 @@ void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) override;
 void TraceBeginCHROMIUM(const char* category_name,
                         const char* trace_name) override;
 void TraceEndCHROMIUM() override;
-void AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                GLint level,
-                                GLint xoffset,
-                                GLint yoffset,
-                                GLsizei width,
-                                GLsizei height,
-                                GLenum format,
-                                GLenum type,
-                                const void* data) override;
-void AsyncTexImage2DCHROMIUM(GLenum target,
-                             GLint level,
-                             GLenum internalformat,
-                             GLsizei width,
-                             GLsizei height,
-                             GLint border,
-                             GLenum format,
-                             GLenum type,
-                             const void* pixels) override;
-void WaitAsyncTexImage2DCHROMIUM(GLenum target) override;
-void WaitAllAsyncTexImage2DCHROMIUM() override;
 void DiscardFramebufferEXT(GLenum target,
                            GLsizei count,
                            const GLenum* attachments) 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 33234093..cfee942 100644
--- a/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h
@@ -2142,47 +2142,6 @@ void GLES2TraceImplementation::TraceEndCHROMIUM() {
   gl_->TraceEndCHROMIUM();
 }
 
-void GLES2TraceImplementation::AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                                          GLint level,
-                                                          GLint xoffset,
-                                                          GLint yoffset,
-                                                          GLsizei width,
-                                                          GLsizei height,
-                                                          GLenum format,
-                                                          GLenum type,
-                                                          const void* data) {
-  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
-                                "GLES2Trace::AsyncTexSubImage2DCHROMIUM");
-  gl_->AsyncTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
-                                  height, format, type, data);
-}
-
-void GLES2TraceImplementation::AsyncTexImage2DCHROMIUM(GLenum target,
-                                                       GLint level,
-                                                       GLenum internalformat,
-                                                       GLsizei width,
-                                                       GLsizei height,
-                                                       GLint border,
-                                                       GLenum format,
-                                                       GLenum type,
-                                                       const void* pixels) {
-  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::AsyncTexImage2DCHROMIUM");
-  gl_->AsyncTexImage2DCHROMIUM(target, level, internalformat, width, height,
-                               border, format, type, pixels);
-}
-
-void GLES2TraceImplementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
-  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
-                                "GLES2Trace::WaitAsyncTexImage2DCHROMIUM");
-  gl_->WaitAsyncTexImage2DCHROMIUM(target);
-}
-
-void GLES2TraceImplementation::WaitAllAsyncTexImage2DCHROMIUM() {
-  TRACE_EVENT_BINARY_EFFICIENT0("gpu",
-                                "GLES2Trace::WaitAllAsyncTexImage2DCHROMIUM");
-  gl_->WaitAllAsyncTexImage2DCHROMIUM();
-}
-
 void GLES2TraceImplementation::DiscardFramebufferEXT(
     GLenum target,
     GLsizei count,
diff --git a/gpu/command_buffer/client/mapped_memory.cc b/gpu/command_buffer/client/mapped_memory.cc
index 34a3c1a..d798ada 100644
--- a/gpu/command_buffer/client/mapped_memory.cc
+++ b/gpu/command_buffer/client/mapped_memory.cc
@@ -27,20 +27,17 @@ base::StaticAtomicSequenceNumber g_next_mapped_memory_manager_tracing_id;
 
 MemoryChunk::MemoryChunk(int32 shm_id,
                          scoped_refptr<gpu::Buffer> shm,
-                         CommandBufferHelper* helper,
-                         const base::Closure& poll_callback)
+                         CommandBufferHelper* helper)
     : shm_id_(shm_id),
       shm_(shm),
-      allocator_(shm->size(), helper, poll_callback, shm->memory()) {}
+      allocator_(shm->size(), helper, shm->memory()) {}
 
 MemoryChunk::~MemoryChunk() {}
 
 MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper,
-                                         const base::Closure& poll_callback,
                                          size_t unused_memory_reclaim_limit)
     : chunk_size_multiple_(FencedAllocator::kAllocAlignment),
       helper_(helper),
-      poll_callback_(poll_callback),
       allocated_memory_(0),
       max_free_bytes_(unused_memory_reclaim_limit),
       max_allocated_bytes_(kNoLimit),
@@ -121,7 +118,7 @@ void* MappedMemoryManager::Alloc(
   if (id  < 0)
     return NULL;
   DCHECK(shm.get());
-  MemoryChunk* mc = new MemoryChunk(id, shm, helper_, poll_callback_);
+  MemoryChunk* mc = new MemoryChunk(id, shm, helper_);
   allocated_memory_ += mc->GetSize();
   chunks_.push_back(mc);
   void* mem = mc->Alloc(size);
diff --git a/gpu/command_buffer/client/mapped_memory.h b/gpu/command_buffer/client/mapped_memory.h
index 852519b..aad8647 100644
--- a/gpu/command_buffer/client/mapped_memory.h
+++ b/gpu/command_buffer/client/mapped_memory.h
@@ -24,8 +24,7 @@ class GPU_EXPORT MemoryChunk {
  public:
   MemoryChunk(int32_t shm_id,
               scoped_refptr<gpu::Buffer> shm,
-              CommandBufferHelper* helper,
-              const base::Closure& poll_callback);
+              CommandBufferHelper* helper);
   ~MemoryChunk();
 
   // Gets the size of the largest free block that is available without waiting.
@@ -130,7 +129,6 @@ class GPU_EXPORT MappedMemoryManager
   // |unused_memory_reclaim_limit|: When exceeded this causes pending memory
   // to be reclaimed before allocating more memory.
   MappedMemoryManager(CommandBufferHelper* helper,
-                      const base::Closure& poll_callback,
                       size_t unused_memory_reclaim_limit);
 
   ~MappedMemoryManager() override;
@@ -208,7 +206,6 @@ class GPU_EXPORT MappedMemoryManager
   // size a chunk is rounded up to.
   unsigned int chunk_size_multiple_;
   CommandBufferHelper* helper_;
-  base::Closure poll_callback_;
   MemoryChunkVector chunks_;
   size_t allocated_memory_;
   size_t max_free_bytes_;
diff --git a/gpu/command_buffer/client/mapped_memory_unittest.cc b/gpu/command_buffer/client/mapped_memory_unittest.cc
index 86051c9..73da176 100644
--- a/gpu/command_buffer/client/mapped_memory_unittest.cc
+++ b/gpu/command_buffer/client/mapped_memory_unittest.cc
@@ -78,11 +78,6 @@ class MappedMemoryTestBase : public testing::Test {
 const unsigned int MappedMemoryTestBase::kBufferSize;
 #endif
 
-namespace {
-void EmptyPoll() {
-}
-}
-
 // Test fixture for MemoryChunk test - Creates a MemoryChunk, using a
 // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling
 // it directly, not through the RPC mechanism), making sure Noops are ignored
@@ -95,10 +90,7 @@ class MemoryChunkTest : public MappedMemoryTestBase {
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
     shared_memory->CreateAndMapAnonymous(kBufferSize);
     buffer_ = MakeBufferFromSharedMemory(shared_memory.Pass(), kBufferSize);
-    chunk_.reset(new MemoryChunk(kShmId,
-                                 buffer_,
-                                 helper_.get(),
-                                 base::Bind(&EmptyPoll)));
+    chunk_.reset(new MemoryChunk(kShmId, buffer_, helper_.get()));
   }
 
   void TearDown() override {
@@ -157,8 +149,8 @@ class MappedMemoryManagerTest : public MappedMemoryTestBase {
  protected:
   void SetUp() override {
     MappedMemoryTestBase::SetUp();
-    manager_.reset(new MappedMemoryManager(
-        helper_.get(), base::Bind(&EmptyPoll), MappedMemoryManager::kNoLimit));
+    manager_.reset(
+        new MappedMemoryManager(helper_.get(), MappedMemoryManager::kNoLimit));
   }
 
   void TearDown() override {
@@ -312,8 +304,7 @@ TEST_F(MappedMemoryManagerTest, ChunkSizeMultiple) {
 TEST_F(MappedMemoryManagerTest, UnusedMemoryLimit) {
   const unsigned int kChunkSize = 2048;
   // Reset the manager with a memory limit.
-  manager_.reset(new MappedMemoryManager(
-      helper_.get(), base::Bind(&EmptyPoll), kChunkSize));
+  manager_.reset(new MappedMemoryManager(helper_.get(), kChunkSize));
   manager_->set_chunk_size_multiple(kChunkSize);
 
   // Allocate one chunk worth of memory.
@@ -344,8 +335,7 @@ TEST_F(MappedMemoryManagerTest, UnusedMemoryLimit) {
 TEST_F(MappedMemoryManagerTest, MemoryLimitWithReuse) {
   const unsigned int kSize = 1024;
   // Reset the manager with a memory limit.
-  manager_.reset(new MappedMemoryManager(
-      helper_.get(), base::Bind(&EmptyPoll), kSize));
+  manager_.reset(new MappedMemoryManager(helper_.get(), kSize));
   const unsigned int kChunkSize = 2 * 1024;
   manager_->set_chunk_size_multiple(kChunkSize);
 
@@ -397,8 +387,7 @@ TEST_F(MappedMemoryManagerTest, MemoryLimitWithReuse) {
 TEST_F(MappedMemoryManagerTest, MaxAllocationTest) {
   const unsigned int kSize = 1024;
   // Reset the manager with a memory limit.
-  manager_.reset(new MappedMemoryManager(
-      helper_.get(), base::Bind(&EmptyPoll), kSize));
+  manager_.reset(new MappedMemoryManager(helper_.get(), kSize));
 
   const size_t kLimit = 512;
   manager_->set_chunk_size_multiple(kLimit);
@@ -442,55 +431,4 @@ TEST_F(MappedMemoryManagerTest, MaxAllocationTest) {
   manager_->Free(mem4);
 }
 
-namespace {
-void Poll(MappedMemoryManagerTest *test, std::list<void*>* list) {
-  std::list<void*>::iterator it = list->begin();
-  while (it != list->end()) {
-    void* address = *it;
-    test->manager()->Free(address);
-    it = list->erase(it);
-  }
-}
-}
-
-TEST_F(MappedMemoryManagerTest, Poll) {
-  std::list<void*> unmanaged_memory_list;
-
-  const unsigned int kSize = 1024;
-  // Reset the manager with a memory limit.
-  manager_.reset(new MappedMemoryManager(
-      helper_.get(),
-      base::Bind(&Poll, this, &unmanaged_memory_list),
-      kSize));
-
-  // Allocate kSize bytes. Don't add the address to
-  // the unmanaged memory list, so that it won't be free:ed just yet.
-  int32 id1;
-  unsigned int offset1;
-  void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
-  EXPECT_EQ(manager_->bytes_in_use(), kSize);
-
-  // Allocate kSize more bytes, and make sure we grew.
-  int32 id2;
-  unsigned int offset2;
-  void* mem2 = manager_->Alloc(kSize, &id2, &offset2);
-  EXPECT_EQ(manager_->bytes_in_use(), kSize * 2);
-
-  // Make the unmanaged buffer be released next time FreeUnused() is called
-  // in MappedMemoryManager/FencedAllocator. This happens for example when
-  // allocating new memory.
-  unmanaged_memory_list.push_back(mem1);
-
-  // Allocate kSize more bytes. This should poll unmanaged memory, which now
-  // should free the previously allocated unmanaged memory.
-  int32 id3;
-  unsigned int offset3;
-  void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
-  EXPECT_EQ(manager_->bytes_in_use(), kSize * 2);
-
-  manager_->Free(mem2);
-  manager_->Free(mem3);
-  EXPECT_EQ(manager_->bytes_in_use(), static_cast<size_t>(0));
-}
-
 }  // namespace gpu
diff --git a/gpu/command_buffer/client/query_tracker.cc b/gpu/command_buffer/client/query_tracker.cc
index a258f93..b4016fd 100644
--- a/gpu/command_buffer/client/query_tracker.cc
+++ b/gpu/command_buffer/client/query_tracker.cc
@@ -133,7 +133,6 @@ void QueryTracker::Query::Begin(GLES2Implementation* gl) {
       // tell service about id, shared memory and count
       gl->helper()->BeginQueryEXT(target(), id(), shm_id(), shm_offset());
       break;
-    case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     default:
       // tell service about id, shared memory and count
@@ -189,7 +188,6 @@ bool QueryTracker::Query::CheckResultsAvailable(
           //DCHECK(info_.sync->result >= client_begin_time_us_);
           result_ = info_.sync->result - client_begin_time_us_;
           break;
-        case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
         case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
         default:
           result_ = info_.sync->result;
diff --git a/gpu/command_buffer/client/query_tracker_unittest.cc b/gpu/command_buffer/client/query_tracker_unittest.cc
index cba94d1..93c2cbe 100644
--- a/gpu/command_buffer/client/query_tracker_unittest.cc
+++ b/gpu/command_buffer/client/query_tracker_unittest.cc
@@ -21,11 +21,6 @@
 namespace gpu {
 namespace gles2 {
 
-namespace {
-void EmptyPoll() {
-}
-}
-
 class QuerySyncManagerTest : public testing::Test {
  protected:
   static const int32 kNumCommandEntries = 400;
@@ -36,8 +31,8 @@ class QuerySyncManagerTest : public testing::Test {
     command_buffer_.reset(new MockClientCommandBuffer());
     helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
     helper_->Initialize(kCommandBufferSizeBytes);
-    mapped_memory_.reset(new MappedMemoryManager(
-        helper_.get(), base::Bind(&EmptyPoll), MappedMemoryManager::kNoLimit));
+    mapped_memory_.reset(
+        new MappedMemoryManager(helper_.get(), MappedMemoryManager::kNoLimit));
     sync_manager_.reset(new QuerySyncManager(mapped_memory_.get()));
   }
 
@@ -90,8 +85,8 @@ class QueryTrackerTest : public testing::Test {
     command_buffer_.reset(new MockClientCommandBuffer());
     helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
     helper_->Initialize(kCommandBufferSizeBytes);
-    mapped_memory_.reset(new MappedMemoryManager(
-        helper_.get(), base::Bind(&EmptyPoll), MappedMemoryManager::kNoLimit));
+    mapped_memory_.reset(
+        new MappedMemoryManager(helper_.get(), MappedMemoryManager::kNoLimit));
     query_tracker_.reset(new QueryTracker(mapped_memory_.get()));
   }
 
diff --git a/gpu/command_buffer/cmd_buffer_functions.txt b/gpu/command_buffer/cmd_buffer_functions.txt
index 04ae93a..d9f8515 100644
--- a/gpu/command_buffer/cmd_buffer_functions.txt
+++ b/gpu/command_buffer/cmd_buffer_functions.txt
@@ -304,10 +304,6 @@ GL_APICALL void         GL_APIENTRY glBindTexImage2DCHROMIUM (GLenumTextureBindT
 GL_APICALL void         GL_APIENTRY glReleaseTexImage2DCHROMIUM (GLenumTextureBindTarget target, GLint imageId);
 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);
-GL_APICALL void         GL_APIENTRY glWaitAsyncTexImage2DCHROMIUM (GLenumTextureTarget target);
-GL_APICALL void         GL_APIENTRY glWaitAllAsyncTexImage2DCHROMIUM (void);
 GL_APICALL void         GL_APIENTRY glDiscardFramebufferEXT (GLenum target, GLsizei count, const GLenum* attachments);
 GL_APICALL void         GL_APIENTRY glLoseContextCHROMIUM (GLenumResetStatus current, GLenumResetStatus other);
 GL_APICALL GLuint       GL_APIENTRY glInsertSyncPointCHROMIUM (void);
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index 6270b69..69a0d5e 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -13349,287 +13349,6 @@ static_assert(sizeof(TraceEndCHROMIUM) == 4,
 static_assert(offsetof(TraceEndCHROMIUM, header) == 0,
               "offset of TraceEndCHROMIUM header should be 0");
 
-struct AsyncTexSubImage2DCHROMIUM {
-  typedef AsyncTexSubImage2DCHROMIUM ValueType;
-  static const CommandId kCmdId = kAsyncTexSubImage2DCHROMIUM;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLenum _target,
-            GLint _level,
-            GLint _xoffset,
-            GLint _yoffset,
-            GLsizei _width,
-            GLsizei _height,
-            GLenum _format,
-            GLenum _type,
-            uint32_t _data_shm_id,
-            uint32_t _data_shm_offset,
-            uint32_t _async_upload_token,
-            uint32_t _sync_data_shm_id,
-            uint32_t _sync_data_shm_offset) {
-    SetHeader();
-    target = _target;
-    level = _level;
-    xoffset = _xoffset;
-    yoffset = _yoffset;
-    width = _width;
-    height = _height;
-    format = _format;
-    type = _type;
-    data_shm_id = _data_shm_id;
-    data_shm_offset = _data_shm_offset;
-    async_upload_token = _async_upload_token;
-    sync_data_shm_id = _sync_data_shm_id;
-    sync_data_shm_offset = _sync_data_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLenum _target,
-            GLint _level,
-            GLint _xoffset,
-            GLint _yoffset,
-            GLsizei _width,
-            GLsizei _height,
-            GLenum _format,
-            GLenum _type,
-            uint32_t _data_shm_id,
-            uint32_t _data_shm_offset,
-            uint32_t _async_upload_token,
-            uint32_t _sync_data_shm_id,
-            uint32_t _sync_data_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_target, _level, _xoffset, _yoffset, _width, _height, _format,
-               _type, _data_shm_id, _data_shm_offset, _async_upload_token,
-               _sync_data_shm_id, _sync_data_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-  int32_t level;
-  int32_t xoffset;
-  int32_t yoffset;
-  int32_t width;
-  int32_t height;
-  uint32_t format;
-  uint32_t type;
-  uint32_t data_shm_id;
-  uint32_t data_shm_offset;
-  uint32_t async_upload_token;
-  uint32_t sync_data_shm_id;
-  uint32_t sync_data_shm_offset;
-};
-
-static_assert(sizeof(AsyncTexSubImage2DCHROMIUM) == 56,
-              "size of AsyncTexSubImage2DCHROMIUM should be 56");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, header) == 0,
-              "offset of AsyncTexSubImage2DCHROMIUM header should be 0");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, target) == 4,
-              "offset of AsyncTexSubImage2DCHROMIUM target should be 4");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, level) == 8,
-              "offset of AsyncTexSubImage2DCHROMIUM level should be 8");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, xoffset) == 12,
-              "offset of AsyncTexSubImage2DCHROMIUM xoffset should be 12");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, yoffset) == 16,
-              "offset of AsyncTexSubImage2DCHROMIUM yoffset should be 16");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, width) == 20,
-              "offset of AsyncTexSubImage2DCHROMIUM width should be 20");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, height) == 24,
-              "offset of AsyncTexSubImage2DCHROMIUM height should be 24");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, format) == 28,
-              "offset of AsyncTexSubImage2DCHROMIUM format should be 28");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, type) == 32,
-              "offset of AsyncTexSubImage2DCHROMIUM type should be 32");
-static_assert(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_id) == 36,
-              "offset of AsyncTexSubImage2DCHROMIUM data_shm_id should be 36");
-static_assert(
-    offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_offset) == 40,
-    "offset of AsyncTexSubImage2DCHROMIUM data_shm_offset should be 40");
-static_assert(
-    offsetof(AsyncTexSubImage2DCHROMIUM, async_upload_token) == 44,
-    "offset of AsyncTexSubImage2DCHROMIUM async_upload_token should be 44");
-static_assert(
-    offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_id) == 48,
-    "offset of AsyncTexSubImage2DCHROMIUM sync_data_shm_id should be 48");
-static_assert(
-    offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_offset) == 52,
-    "offset of AsyncTexSubImage2DCHROMIUM sync_data_shm_offset should be 52");
-
-struct AsyncTexImage2DCHROMIUM {
-  typedef AsyncTexImage2DCHROMIUM ValueType;
-  static const CommandId kCmdId = kAsyncTexImage2DCHROMIUM;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLenum _target,
-            GLint _level,
-            GLint _internalformat,
-            GLsizei _width,
-            GLsizei _height,
-            GLenum _format,
-            GLenum _type,
-            uint32_t _pixels_shm_id,
-            uint32_t _pixels_shm_offset,
-            uint32_t _async_upload_token,
-            uint32_t _sync_data_shm_id,
-            uint32_t _sync_data_shm_offset) {
-    SetHeader();
-    target = _target;
-    level = _level;
-    internalformat = _internalformat;
-    width = _width;
-    height = _height;
-    format = _format;
-    type = _type;
-    pixels_shm_id = _pixels_shm_id;
-    pixels_shm_offset = _pixels_shm_offset;
-    async_upload_token = _async_upload_token;
-    sync_data_shm_id = _sync_data_shm_id;
-    sync_data_shm_offset = _sync_data_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLenum _target,
-            GLint _level,
-            GLint _internalformat,
-            GLsizei _width,
-            GLsizei _height,
-            GLenum _format,
-            GLenum _type,
-            uint32_t _pixels_shm_id,
-            uint32_t _pixels_shm_offset,
-            uint32_t _async_upload_token,
-            uint32_t _sync_data_shm_id,
-            uint32_t _sync_data_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_target, _level, _internalformat, _width, _height, _format,
-               _type, _pixels_shm_id, _pixels_shm_offset, _async_upload_token,
-               _sync_data_shm_id, _sync_data_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-  int32_t level;
-  int32_t internalformat;
-  int32_t width;
-  int32_t height;
-  uint32_t format;
-  uint32_t type;
-  uint32_t pixels_shm_id;
-  uint32_t pixels_shm_offset;
-  uint32_t async_upload_token;
-  uint32_t sync_data_shm_id;
-  uint32_t sync_data_shm_offset;
-  static const int32_t border = 0;
-};
-
-static_assert(sizeof(AsyncTexImage2DCHROMIUM) == 52,
-              "size of AsyncTexImage2DCHROMIUM should be 52");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, header) == 0,
-              "offset of AsyncTexImage2DCHROMIUM header should be 0");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, target) == 4,
-              "offset of AsyncTexImage2DCHROMIUM target should be 4");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, level) == 8,
-              "offset of AsyncTexImage2DCHROMIUM level should be 8");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, internalformat) == 12,
-              "offset of AsyncTexImage2DCHROMIUM internalformat should be 12");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, width) == 16,
-              "offset of AsyncTexImage2DCHROMIUM width should be 16");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, height) == 20,
-              "offset of AsyncTexImage2DCHROMIUM height should be 20");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, format) == 24,
-              "offset of AsyncTexImage2DCHROMIUM format should be 24");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, type) == 28,
-              "offset of AsyncTexImage2DCHROMIUM type should be 28");
-static_assert(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_id) == 32,
-              "offset of AsyncTexImage2DCHROMIUM pixels_shm_id should be 32");
-static_assert(
-    offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_offset) == 36,
-    "offset of AsyncTexImage2DCHROMIUM pixels_shm_offset should be 36");
-static_assert(
-    offsetof(AsyncTexImage2DCHROMIUM, async_upload_token) == 40,
-    "offset of AsyncTexImage2DCHROMIUM async_upload_token should be 40");
-static_assert(
-    offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_id) == 44,
-    "offset of AsyncTexImage2DCHROMIUM sync_data_shm_id should be 44");
-static_assert(
-    offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_offset) == 48,
-    "offset of AsyncTexImage2DCHROMIUM sync_data_shm_offset should be 48");
-
-struct WaitAsyncTexImage2DCHROMIUM {
-  typedef WaitAsyncTexImage2DCHROMIUM ValueType;
-  static const CommandId kCmdId = kWaitAsyncTexImage2DCHROMIUM;
-  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(GLenum _target) {
-    SetHeader();
-    target = _target;
-  }
-
-  void* Set(void* cmd, GLenum _target) {
-    static_cast<ValueType*>(cmd)->Init(_target);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-};
-
-static_assert(sizeof(WaitAsyncTexImage2DCHROMIUM) == 8,
-              "size of WaitAsyncTexImage2DCHROMIUM should be 8");
-static_assert(offsetof(WaitAsyncTexImage2DCHROMIUM, header) == 0,
-              "offset of WaitAsyncTexImage2DCHROMIUM header should be 0");
-static_assert(offsetof(WaitAsyncTexImage2DCHROMIUM, target) == 4,
-              "offset of WaitAsyncTexImage2DCHROMIUM target should be 4");
-
-struct WaitAllAsyncTexImage2DCHROMIUM {
-  typedef WaitAllAsyncTexImage2DCHROMIUM ValueType;
-  static const CommandId kCmdId = kWaitAllAsyncTexImage2DCHROMIUM;
-  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() { SetHeader(); }
-
-  void* Set(void* cmd) {
-    static_cast<ValueType*>(cmd)->Init();
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-};
-
-static_assert(sizeof(WaitAllAsyncTexImage2DCHROMIUM) == 4,
-              "size of WaitAllAsyncTexImage2DCHROMIUM should be 4");
-static_assert(offsetof(WaitAllAsyncTexImage2DCHROMIUM, header) == 0,
-              "offset of WaitAllAsyncTexImage2DCHROMIUM header should be 0");
-
 struct DiscardFramebufferEXTImmediate {
   typedef DiscardFramebufferEXTImmediate ValueType;
   static const CommandId kCmdId = kDiscardFramebufferEXTImmediate;
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 28cf3c68..bd4d764 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -4721,84 +4721,6 @@ TEST_F(GLES2FormatTest, TraceEndCHROMIUM) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, AsyncTexSubImage2DCHROMIUM) {
-  cmds::AsyncTexSubImage2DCHROMIUM& cmd =
-      *GetBufferAs<cmds::AsyncTexSubImage2DCHROMIUM>();
-  void* next_cmd = cmd.Set(
-      &cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
-      static_cast<GLint>(13), static_cast<GLint>(14), static_cast<GLsizei>(15),
-      static_cast<GLsizei>(16), static_cast<GLenum>(17),
-      static_cast<GLenum>(18), static_cast<uint32_t>(19),
-      static_cast<uint32_t>(20), static_cast<uint32_t>(21),
-      static_cast<uint32_t>(22), static_cast<uint32_t>(23));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::AsyncTexSubImage2DCHROMIUM::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
-  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
-  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
-  EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
-  EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
-  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
-  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
-  EXPECT_EQ(static_cast<uint32_t>(19), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(20), cmd.data_shm_offset);
-  EXPECT_EQ(static_cast<uint32_t>(21), cmd.async_upload_token);
-  EXPECT_EQ(static_cast<uint32_t>(22), cmd.sync_data_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(23), cmd.sync_data_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
-TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
-  cmds::AsyncTexImage2DCHROMIUM& cmd =
-      *GetBufferAs<cmds::AsyncTexImage2DCHROMIUM>();
-  void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
-              static_cast<GLint>(13), static_cast<GLsizei>(14),
-              static_cast<GLsizei>(15), static_cast<GLenum>(16),
-              static_cast<GLenum>(17), static_cast<uint32_t>(18),
-              static_cast<uint32_t>(19), static_cast<uint32_t>(20),
-              static_cast<uint32_t>(21), static_cast<uint32_t>(22));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::AsyncTexImage2DCHROMIUM::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
-  EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
-  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
-  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
-  EXPECT_EQ(static_cast<GLenum>(16), cmd.format);
-  EXPECT_EQ(static_cast<GLenum>(17), cmd.type);
-  EXPECT_EQ(static_cast<uint32_t>(18), cmd.pixels_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_offset);
-  EXPECT_EQ(static_cast<uint32_t>(20), cmd.async_upload_token);
-  EXPECT_EQ(static_cast<uint32_t>(21), cmd.sync_data_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(22), cmd.sync_data_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
-TEST_F(GLES2FormatTest, WaitAsyncTexImage2DCHROMIUM) {
-  cmds::WaitAsyncTexImage2DCHROMIUM& cmd =
-      *GetBufferAs<cmds::WaitAsyncTexImage2DCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::WaitAsyncTexImage2DCHROMIUM::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
-TEST_F(GLES2FormatTest, WaitAllAsyncTexImage2DCHROMIUM) {
-  cmds::WaitAllAsyncTexImage2DCHROMIUM& cmd =
-      *GetBufferAs<cmds::WaitAllAsyncTexImage2DCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32_t>(cmds::WaitAllAsyncTexImage2DCHROMIUM::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DiscardFramebufferEXTImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLenum data[] = {
diff --git a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
index 540bd4e..010dac0 100644
--- a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
@@ -292,35 +292,31 @@
   OP(ReleaseTexImage2DCHROMIUM)                /* 533 */ \
   OP(TraceBeginCHROMIUM)                       /* 534 */ \
   OP(TraceEndCHROMIUM)                         /* 535 */ \
-  OP(AsyncTexSubImage2DCHROMIUM)               /* 536 */ \
-  OP(AsyncTexImage2DCHROMIUM)                  /* 537 */ \
-  OP(WaitAsyncTexImage2DCHROMIUM)              /* 538 */ \
-  OP(WaitAllAsyncTexImage2DCHROMIUM)           /* 539 */ \
-  OP(DiscardFramebufferEXTImmediate)           /* 540 */ \
-  OP(LoseContextCHROMIUM)                      /* 541 */ \
-  OP(InsertSyncPointCHROMIUM)                  /* 542 */ \
-  OP(WaitSyncPointCHROMIUM)                    /* 543 */ \
-  OP(DrawBuffersEXTImmediate)                  /* 544 */ \
-  OP(DiscardBackbufferCHROMIUM)                /* 545 */ \
-  OP(ScheduleOverlayPlaneCHROMIUM)             /* 546 */ \
-  OP(SwapInterval)                             /* 547 */ \
-  OP(FlushDriverCachesCHROMIUM)                /* 548 */ \
-  OP(MatrixLoadfCHROMIUMImmediate)             /* 549 */ \
-  OP(MatrixLoadIdentityCHROMIUM)               /* 550 */ \
-  OP(GenPathsCHROMIUM)                         /* 551 */ \
-  OP(DeletePathsCHROMIUM)                      /* 552 */ \
-  OP(IsPathCHROMIUM)                           /* 553 */ \
-  OP(PathCommandsCHROMIUM)                     /* 554 */ \
-  OP(PathParameterfCHROMIUM)                   /* 555 */ \
-  OP(PathParameteriCHROMIUM)                   /* 556 */ \
-  OP(PathStencilFuncCHROMIUM)                  /* 557 */ \
-  OP(StencilFillPathCHROMIUM)                  /* 558 */ \
-  OP(StencilStrokePathCHROMIUM)                /* 559 */ \
-  OP(CoverFillPathCHROMIUM)                    /* 560 */ \
-  OP(CoverStrokePathCHROMIUM)                  /* 561 */ \
-  OP(StencilThenCoverFillPathCHROMIUM)         /* 562 */ \
-  OP(StencilThenCoverStrokePathCHROMIUM)       /* 563 */ \
-  OP(BlendBarrierKHR)                          /* 564 */
+  OP(DiscardFramebufferEXTImmediate)           /* 536 */ \
+  OP(LoseContextCHROMIUM)                      /* 537 */ \
+  OP(InsertSyncPointCHROMIUM)                  /* 538 */ \
+  OP(WaitSyncPointCHROMIUM)                    /* 539 */ \
+  OP(DrawBuffersEXTImmediate)                  /* 540 */ \
+  OP(DiscardBackbufferCHROMIUM)                /* 541 */ \
+  OP(ScheduleOverlayPlaneCHROMIUM)             /* 542 */ \
+  OP(SwapInterval)                             /* 543 */ \
+  OP(FlushDriverCachesCHROMIUM)                /* 544 */ \
+  OP(MatrixLoadfCHROMIUMImmediate)             /* 545 */ \
+  OP(MatrixLoadIdentityCHROMIUM)               /* 546 */ \
+  OP(GenPathsCHROMIUM)                         /* 547 */ \
+  OP(DeletePathsCHROMIUM)                      /* 548 */ \
+  OP(IsPathCHROMIUM)                           /* 549 */ \
+  OP(PathCommandsCHROMIUM)                     /* 550 */ \
+  OP(PathParameterfCHROMIUM)                   /* 551 */ \
+  OP(PathParameteriCHROMIUM)                   /* 552 */ \
+  OP(PathStencilFuncCHROMIUM)                  /* 553 */ \
+  OP(StencilFillPathCHROMIUM)                  /* 554 */ \
+  OP(StencilStrokePathCHROMIUM)                /* 555 */ \
+  OP(CoverFillPathCHROMIUM)                    /* 556 */ \
+  OP(CoverStrokePathCHROMIUM)                  /* 557 */ \
+  OP(StencilThenCoverFillPathCHROMIUM)         /* 558 */ \
+  OP(StencilThenCoverStrokePathCHROMIUM)       /* 559 */ \
+  OP(BlendBarrierKHR)                          /* 560 */
 
 enum CommandId {
   kStartPoint = cmd::kLastCommonId,  // All GLES2 commands start after this.
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
index 02c925b..2af659e 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
@@ -1027,9 +1027,6 @@ static const GLES2Util::EnumToString enum_to_string_table[] = {
         0x8E7D, "GL_MAX_PATCH_VERTICES_EXT",
     },
     {
-        0x6005, "GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM",
-    },
-    {
         0x9105, "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES",
     },
     {
@@ -4139,8 +4136,6 @@ std::string GLES2Util::GetStringQueryTarget(uint32_t value) {
        "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT"},
       {GL_COMMANDS_ISSUED_CHROMIUM, "GL_COMMANDS_ISSUED_CHROMIUM"},
       {GL_LATENCY_QUERY_CHROMIUM, "GL_LATENCY_QUERY_CHROMIUM"},
-      {GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
-       "GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM"},
       {GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM,
        "GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM"},
       {GL_COMMANDS_COMPLETED_CHROMIUM, "GL_COMMANDS_COMPLETED_CHROMIUM"},
diff --git a/gpu/command_buffer/service/BUILD.gn b/gpu/command_buffer/service/BUILD.gn
index 1acdb1b..825b856 100644
--- a/gpu/command_buffer/service/BUILD.gn
+++ b/gpu/command_buffer/service/BUILD.gn
@@ -24,22 +24,6 @@ source_set("service_sources") {
   ]
 
   sources = [
-    "async_pixel_transfer_delegate.cc",
-    "async_pixel_transfer_delegate.h",
-    "async_pixel_transfer_manager.cc",
-    "async_pixel_transfer_manager.h",
-    "async_pixel_transfer_manager_android.cc",
-    "async_pixel_transfer_manager_idle.cc",
-    "async_pixel_transfer_manager_idle.h",
-    "async_pixel_transfer_manager_linux.cc",
-    "async_pixel_transfer_manager_mac.cc",
-    "async_pixel_transfer_manager_share_group.cc",
-    "async_pixel_transfer_manager_share_group.h",
-    "async_pixel_transfer_manager_stub.cc",
-    "async_pixel_transfer_manager_stub.h",
-    "async_pixel_transfer_manager_sync.cc",
-    "async_pixel_transfer_manager_sync.h",
-    "async_pixel_transfer_manager_win.cc",
     "buffer_manager.cc",
     "buffer_manager.h",
     "cmd_buffer_engine.h",
@@ -167,13 +151,6 @@ source_set("service_sources") {
     "//ui/gl",
   ]
 
-  if (is_win || is_android || (is_linux && use_x11)) {
-    sources += [
-      "async_pixel_transfer_manager_egl.cc",
-      "async_pixel_transfer_manager_egl.h",
-    ]
-  }
-
   if (is_mac) {
     # Required by gles2_cmd_decoder.cc on Mac.
     libs = [
diff --git a/gpu/command_buffer/service/async_pixel_transfer_delegate.cc b/gpu/command_buffer/service/async_pixel_transfer_delegate.cc
deleted file mode 100644
index 201026b..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_delegate.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-
-namespace gpu {
-
-AsyncMemoryParams::AsyncMemoryParams(scoped_refptr<Buffer> buffer,
-                    uint32 data_offset,
-                    uint32 data_size)
-    : buffer_(buffer), data_offset_(data_offset), data_size_(data_size) {
-  DCHECK(buffer_.get());
-  DCHECK(buffer_->memory());
-}
-
-AsyncMemoryParams::~AsyncMemoryParams() {
-}
-
-AsyncPixelTransferUploadStats::AsyncPixelTransferUploadStats()
-    : texture_upload_count_(0) {}
-
-AsyncPixelTransferUploadStats::~AsyncPixelTransferUploadStats() {}
-
-void AsyncPixelTransferUploadStats::AddUpload(base::TimeDelta transfer_time) {
-  base::AutoLock scoped_lock(lock_);
-  texture_upload_count_++;
-  total_texture_upload_time_ += transfer_time;
-}
-
-int AsyncPixelTransferUploadStats::GetStats(
-    base::TimeDelta* total_texture_upload_time) {
-  base::AutoLock scoped_lock(lock_);
-  if (total_texture_upload_time)
-    *total_texture_upload_time = total_texture_upload_time_;
-  return texture_upload_count_;
-}
-
-AsyncPixelTransferDelegate::AsyncPixelTransferDelegate() {}
-
-AsyncPixelTransferDelegate::~AsyncPixelTransferDelegate() {}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_delegate.h b/gpu/command_buffer/service/async_pixel_transfer_delegate.h
deleted file mode 100644
index b41bcd5..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_delegate.h
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_H_
-
-#include "base/basictypes.h"
-#include "base/callback.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/synchronization/lock.h"
-#include "base/time/time.h"
-#include "gpu/command_buffer/common/buffer.h"
-#include "gpu/gpu_export.h"
-#include "ui/gl/gl_bindings.h"
-
-namespace base {
-class SharedMemory;
-}
-
-namespace gpu {
-
-struct AsyncTexImage2DParams {
-  GLenum target;
-  GLint level;
-  GLenum internal_format;
-  GLsizei width;
-  GLsizei height;
-  GLint border;
-  GLenum format;
-  GLenum type;
-};
-
-struct AsyncTexSubImage2DParams {
-  GLenum target;
-  GLint level;
-  GLint xoffset;
-  GLint yoffset;
-  GLsizei width;
-  GLsizei height;
-  GLenum format;
-  GLenum type;
-};
-
-class AsyncMemoryParams {
- public:
-  AsyncMemoryParams(scoped_refptr<Buffer> buffer,
-                    uint32 data_offset,
-                    uint32 data_size);
-  ~AsyncMemoryParams();
-
-  scoped_refptr<Buffer> buffer() const { return buffer_; }
-  uint32 data_size() const { return data_size_; }
-  uint32 data_offset() const { return data_offset_; }
-  void* GetDataAddress() const {
-    return buffer_->GetDataAddress(data_offset_, data_size_);
-  }
-
- private:
-  scoped_refptr<Buffer> buffer_;
-  uint32 data_offset_;
-  uint32 data_size_;
-};
-
-class AsyncPixelTransferUploadStats
-    : public base::RefCountedThreadSafe<AsyncPixelTransferUploadStats> {
- public:
-  AsyncPixelTransferUploadStats();
-
-  void AddUpload(base::TimeDelta transfer_time);
-  int GetStats(base::TimeDelta* total_texture_upload_time);
-
- private:
-  friend class base::RefCountedThreadSafe<AsyncPixelTransferUploadStats>;
-
-  ~AsyncPixelTransferUploadStats();
-
-  int texture_upload_count_;
-  base::TimeDelta total_texture_upload_time_;
-  base::Lock lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferUploadStats);
-};
-
-class GPU_EXPORT AsyncPixelTransferDelegate {
- public:
-  virtual ~AsyncPixelTransferDelegate();
-
-  // The callback occurs on the caller thread, once the texture is
-  // safe/ready to be used.
-  virtual void AsyncTexImage2D(
-      const AsyncTexImage2DParams& tex_params,
-      const AsyncMemoryParams& mem_params,
-      const base::Closure& bind_callback) = 0;
-
-  virtual void AsyncTexSubImage2D(
-      const AsyncTexSubImage2DParams& tex_params,
-      const AsyncMemoryParams& mem_params) = 0;
-
-  // Returns true if there is a transfer in progress.
-  virtual bool TransferIsInProgress() = 0;
-
-  // Block until the specified transfer completes.
-  virtual void WaitForTransferCompletion() = 0;
-
- protected:
-  AsyncPixelTransferDelegate();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegate);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_H_
-
diff --git a/gpu/command_buffer/service/async_pixel_transfer_delegate_mock.cc b/gpu/command_buffer/service/async_pixel_transfer_delegate_mock.cc
deleted file mode 100644
index 8e2d75f..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_delegate_mock.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-
-namespace gpu {
-
-MockAsyncPixelTransferDelegate::MockAsyncPixelTransferDelegate() {
-}
-
-MockAsyncPixelTransferDelegate::~MockAsyncPixelTransferDelegate() {
-  Destroy();
-}
-
-}  // namespace gpu
-
diff --git a/gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h b/gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h
deleted file mode 100644
index 9d28730..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_MOCK
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_MOCK
-
-#include "base/basictypes.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace gpu {
-
-class MockAsyncPixelTransferDelegate : public AsyncPixelTransferDelegate {
- public:
-  MockAsyncPixelTransferDelegate();
-  virtual ~MockAsyncPixelTransferDelegate();
-
-  // Called in ~MockAsyncPixelTransferDelegate.
-  MOCK_METHOD0(Destroy, void());
-
-  // Implement AsyncPixelTransferDelegate.
-  MOCK_METHOD3(AsyncTexImage2D,
-               void(const AsyncTexImage2DParams& tex_params,
-                    const AsyncMemoryParams& mem_params,
-                    const base::Closure& bind_callback));
-  MOCK_METHOD2(AsyncTexSubImage2D,
-               void(const AsyncTexSubImage2DParams& tex_params,
-                    const AsyncMemoryParams& mem_params));
-  MOCK_METHOD0(TransferIsInProgress, bool());
-  MOCK_METHOD0(WaitForTransferCompletion, void());
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockAsyncPixelTransferDelegate);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_DELEGATE_MOCK
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager.cc b/gpu/command_buffer/service/async_pixel_transfer_manager.cc
deleted file mode 100644
index efc893a..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager.cc
+++ /dev/null
@@ -1,87 +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 "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-
-namespace gpu {
-
-AsyncPixelTransferCompletionObserver::AsyncPixelTransferCompletionObserver() {}
-
-AsyncPixelTransferCompletionObserver::~AsyncPixelTransferCompletionObserver() {}
-
-AsyncPixelTransferManager::AsyncPixelTransferManager() {}
-
-AsyncPixelTransferManager::~AsyncPixelTransferManager() {
-  if (manager_)
-    manager_->RemoveObserver(this);
-
-  for (TextureToDelegateMap::iterator ref = delegate_map_.begin();
-       ref != delegate_map_.end();
-       ref++) {
-    ref->first->RemoveObserver();
-  }
-}
-
-void AsyncPixelTransferManager::Initialize(gles2::TextureManager* manager) {
-  manager_ = manager;
-  manager_->AddObserver(this);
-}
-
-AsyncPixelTransferDelegate*
-AsyncPixelTransferManager::CreatePixelTransferDelegate(
-    gles2::TextureRef* ref,
-    const AsyncTexImage2DParams& define_params) {
-  DCHECK(!GetPixelTransferDelegate(ref));
-  AsyncPixelTransferDelegate* delegate =
-      CreatePixelTransferDelegateImpl(ref, define_params);
-  delegate_map_[ref] = make_linked_ptr(delegate);
-  ref->AddObserver();
-  return delegate;
-}
-
-AsyncPixelTransferDelegate*
-AsyncPixelTransferManager::GetPixelTransferDelegate(
-    gles2::TextureRef* ref) {
-  TextureToDelegateMap::iterator it = delegate_map_.find(ref);
-  if (it == delegate_map_.end()) {
-    return NULL;
-  } else {
-    return it->second.get();
-  }
-}
-
-void AsyncPixelTransferManager::ClearPixelTransferDelegateForTest(
-    gles2::TextureRef* ref) {
-  TextureToDelegateMap::iterator it = delegate_map_.find(ref);
-  if (it != delegate_map_.end()) {
-    delegate_map_.erase(it);
-    ref->RemoveObserver();
-  }
-}
-
-bool AsyncPixelTransferManager::AsyncTransferIsInProgress(
-    gles2::TextureRef* ref) {
-  AsyncPixelTransferDelegate* delegate = GetPixelTransferDelegate(ref);
-  return delegate && delegate->TransferIsInProgress();
-}
-
-void AsyncPixelTransferManager::OnTextureManagerDestroying(
-    gles2::TextureManager* manager) {
-  // TextureManager should outlive AsyncPixelTransferManager.
-  NOTREACHED();
-  manager_ = NULL;
-}
-
-void AsyncPixelTransferManager::OnTextureRefDestroying(
-    gles2::TextureRef* texture) {
-  TextureToDelegateMap::iterator it = delegate_map_.find(texture);
-  if (it != delegate_map_.end()) {
-    delegate_map_.erase(it);
-    texture->RemoveObserver();
-  }
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager.h b/gpu/command_buffer/service/async_pixel_transfer_manager.h
deleted file mode 100644
index 3f52e1e..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager.h
+++ /dev/null
@@ -1,110 +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 GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_H_
-
-#include <set>
-
-#include "base/basictypes.h"
-#include "base/callback.h"
-#include "base/containers/hash_tables.h"
-#include "base/memory/linked_ptr.h"
-#include "base/memory/ref_counted.h"
-#include "gpu/command_buffer/service/texture_manager.h"
-#include "gpu/gpu_export.h"
-
-namespace gfx {
-class GLContext;
-}
-
-namespace gpu {
-class AsyncPixelTransferDelegate;
-class AsyncMemoryParams;
-struct AsyncTexImage2DParams;
-
-class AsyncPixelTransferCompletionObserver
-    : public base::RefCountedThreadSafe<AsyncPixelTransferCompletionObserver> {
- public:
-  AsyncPixelTransferCompletionObserver();
-
-  virtual void DidComplete(const AsyncMemoryParams& mem_params) = 0;
-
- protected:
-  virtual ~AsyncPixelTransferCompletionObserver();
-
- private:
-  friend class base::RefCountedThreadSafe<AsyncPixelTransferCompletionObserver>;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferCompletionObserver);
-};
-
-class GPU_EXPORT AsyncPixelTransferManager
-    : public gles2::TextureManager::DestructionObserver {
- public:
-  static AsyncPixelTransferManager* Create(gfx::GLContext* context);
-
-  ~AsyncPixelTransferManager() override;
-
-  void Initialize(gles2::TextureManager* texture_manager);
-
-  virtual void BindCompletedAsyncTransfers() = 0;
-
-  // There's no guarantee that callback will run on the caller thread.
-  virtual void AsyncNotifyCompletion(
-      const AsyncMemoryParams& mem_params,
-      AsyncPixelTransferCompletionObserver* observer) = 0;
-
-  virtual uint32 GetTextureUploadCount() = 0;
-  virtual base::TimeDelta GetTotalTextureUploadTime() = 0;
-
-  // ProcessMorePendingTransfers() will be called at a good time
-  // to process a small amount of pending transfer work while
-  // NeedsProcessMorePendingTransfers() returns true. Implementations
-  // that can't dispatch work to separate threads should use
-  // this to avoid blocking the caller thread inappropriately.
-  virtual void ProcessMorePendingTransfers() = 0;
-  virtual bool NeedsProcessMorePendingTransfers() = 0;
-
-  // Wait for all AsyncTex(Sub)Image2D uploads to finish before returning.
-  virtual void WaitAllAsyncTexImage2D() = 0;
-
-  AsyncPixelTransferDelegate* CreatePixelTransferDelegate(
-      gles2::TextureRef* ref,
-      const AsyncTexImage2DParams& define_params);
-
-  AsyncPixelTransferDelegate* GetPixelTransferDelegate(
-      gles2::TextureRef* ref);
-
-  void ClearPixelTransferDelegateForTest(gles2::TextureRef* ref);
-
-  bool AsyncTransferIsInProgress(gles2::TextureRef* ref);
-
-  // gles2::TextureRef::DestructionObserver implementation:
-  void OnTextureManagerDestroying(gles2::TextureManager* manager) override;
-  void OnTextureRefDestroying(gles2::TextureRef* texture) override;
-
- protected:
-  AsyncPixelTransferManager();
-
- private:
-  gles2::TextureManager* manager_;
-
-  typedef base::hash_map<gles2::TextureRef*,
-                         linked_ptr<AsyncPixelTransferDelegate> >
-      TextureToDelegateMap;
-  TextureToDelegateMap delegate_map_;
-
-  // A factory method called by CreatePixelTransferDelegate that is overriden
-  // by each implementation.
-  virtual AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
-      gles2::TextureRef* ref,
-      const AsyncTexImage2DParams& define_params) = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferManager);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_H_
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_android.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_android.cc
deleted file mode 100644
index 9b6b7e2..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_android.cc
+++ /dev/null
@@ -1,118 +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 "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-#include "base/command_line.h"
-#include "base/sys_info.h"
-#include "base/trace_event/trace_event.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_egl.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_stub.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_sync.h"
-#include "gpu/command_buffer/service/gpu_switches.h"
-#include "ui/gl/gl_context.h"
-#include "ui/gl/gl_implementation.h"
-
-namespace gpu {
-namespace {
-
-enum GpuType {
-  GPU_BROADCOM,
-  GPU_IMAGINATION,
-  GPU_NVIDIA_ES31,
-  GPU_ADRENO_420,
-  GPU_OTHER,
-};
-
-std::string MakeString(const char* s) {
-  return std::string(s ? s : "");
-}
-
-GpuType GetGpuType() {
-  const std::string vendor = MakeString(
-      reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
-  const std::string renderer = MakeString(
-      reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
-  const std::string version = MakeString(
-      reinterpret_cast<const char*>(glGetString(GL_VERSION)));
-
-  if (vendor.find("Broadcom") != std::string::npos)
-    return GPU_BROADCOM;
-
-  if (vendor.find("Imagination") != std::string::npos)
-    return GPU_IMAGINATION;
-
-  if (vendor.find("NVIDIA") != std::string::npos &&
-      version.find("OpenGL ES 3.1") != std::string::npos) {
-    return GPU_NVIDIA_ES31;
-  }
-
-  if (vendor.find("Qualcomm") != std::string::npos &&
-      renderer.find("Adreno (TM) 420") != std::string::npos) {
-    return GPU_ADRENO_420;
-  }
-
-  return GPU_OTHER;
-}
-
-bool AllowTransferThreadForGpu() {
-  GpuType gpu = GetGpuType();
-  return gpu != GPU_BROADCOM && gpu != GPU_IMAGINATION &&
-         gpu != GPU_NVIDIA_ES31 && gpu != GPU_ADRENO_420;
-}
-
-}
-
-// We only used threaded uploads when we can:
-// - Create EGLImages out of OpenGL textures (EGL_KHR_gl_texture_2D_image)
-// - Bind EGLImages to OpenGL textures (GL_OES_EGL_image)
-// - Use fences (to test for upload completion).
-// - The heap size is large enough.
-// TODO(kaanb|epenner): Remove the IsImagination() check pending the
-// resolution of crbug.com/249147
-// TODO(kaanb|epenner): Remove the IsLowEndDevice() check pending the
-// resolution of crbug.com/271929
-AsyncPixelTransferManager* AsyncPixelTransferManager::Create(
-    gfx::GLContext* context) {
-  DCHECK(context->IsCurrent(NULL));
-  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
-
-  // Threaded mailbox uses EGLImage which conflicts with EGL uploader.
-  // The spec only allows one EGL image per sibling group, but currently the
-  // image handle cannot be shared between the threaded mailbox code and
-  // AsyncPixelTransferManagerEGL.
-  bool uses_threaded_mailboxes =
-      cl->HasSwitch(switches::kEnableThreadedTextureMailboxes);
-  // TexImage2D orphans the EGLImage used for threaded mailbox sharing.
-  bool use_teximage2d_over_texsubimage2d = !uses_threaded_mailboxes;
-  switch (gfx::GetGLImplementation()) {
-    case gfx::kGLImplementationEGLGLES2:
-      DCHECK(context);
-      if (!base::SysInfo::IsLowEndDevice() &&
-          context->HasExtension("EGL_KHR_fence_sync") &&
-          context->HasExtension("EGL_KHR_image") &&
-          context->HasExtension("EGL_KHR_image_base") &&
-          context->HasExtension("EGL_KHR_gl_texture_2D_image") &&
-          context->HasExtension("GL_OES_EGL_image") &&
-          !uses_threaded_mailboxes && AllowTransferThreadForGpu()) {
-        TRACE_EVENT0("gpu", "AsyncPixelTransferManager_CreateWithThread");
-        return new AsyncPixelTransferManagerEGL;
-      }
-      return new AsyncPixelTransferManagerIdle(
-          use_teximage2d_over_texsubimage2d);
-    case gfx::kGLImplementationOSMesaGL: {
-      TRACE_EVENT0("gpu", "AsyncPixelTransferManager_CreateIdle");
-      return new AsyncPixelTransferManagerIdle(
-          use_teximage2d_over_texsubimage2d);
-    }
-    case gfx::kGLImplementationMockGL:
-      return new AsyncPixelTransferManagerStub;
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_egl.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_egl.cc
deleted file mode 100644
index 6e1c3e7..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_egl.cc
+++ /dev/null
@@ -1,733 +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 "gpu/command_buffer/service/async_pixel_transfer_manager_egl.h"
-
-#include <list>
-#include <string>
-
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_synthetic_delay.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-#include "ui/gl/gl_context.h"
-#include "ui/gl/gl_surface_egl.h"
-#include "ui/gl/scoped_binders.h"
-
-namespace gpu {
-
-namespace {
-
-bool CheckErrors(const char* file, int line) {
-  EGLint eglerror;
-  GLenum glerror;
-  bool success = true;
-  while ((eglerror = eglGetError()) != EGL_SUCCESS) {
-     LOG(ERROR) << "Async transfer EGL error at "
-                << file << ":" << line << " " << eglerror;
-     success = false;
-  }
-  while ((glerror = glGetError()) != GL_NO_ERROR) {
-     LOG(ERROR) << "Async transfer OpenGL error at "
-                << file << ":" << line << " " << glerror;
-     success = false;
-  }
-  return success;
-}
-#define CHECK_GL() CheckErrors(__FILE__, __LINE__)
-
-const char kAsyncTransferThreadName[] = "AsyncTransferThread";
-
-// Regular glTexImage2D call.
-void DoTexImage2D(const AsyncTexImage2DParams& tex_params, void* data) {
-  glTexImage2D(
-      GL_TEXTURE_2D, tex_params.level, tex_params.internal_format,
-      tex_params.width, tex_params.height,
-      tex_params.border, tex_params.format, tex_params.type, data);
-}
-
-// Regular glTexSubImage2D call.
-void DoTexSubImage2D(const AsyncTexSubImage2DParams& tex_params, void* data) {
-  glTexSubImage2D(
-      GL_TEXTURE_2D, tex_params.level,
-      tex_params.xoffset, tex_params.yoffset,
-      tex_params.width, tex_params.height,
-      tex_params.format, tex_params.type, data);
-}
-
-// Full glTexSubImage2D call, from glTexImage2D params.
-void DoFullTexSubImage2D(const AsyncTexImage2DParams& tex_params, void* data) {
-  glTexSubImage2D(
-      GL_TEXTURE_2D, tex_params.level,
-      0, 0, tex_params.width, tex_params.height,
-      tex_params.format, tex_params.type, data);
-}
-
-void SetGlParametersForEglImageTexture() {
-  // These params are needed for EGLImage creation to succeed on several
-  // Android devices. I couldn't find this requirement in the EGLImage
-  // extension spec, but several devices fail without it.
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-}
-
-void PerformNotifyCompletion(
-    AsyncMemoryParams mem_params,
-    scoped_refptr<AsyncPixelTransferCompletionObserver> observer) {
-  TRACE_EVENT0("gpu", "PerformNotifyCompletion");
-  observer->DidComplete(mem_params);
-}
-
-class TransferThread : public base::Thread {
- public:
-  TransferThread() : base::Thread(kAsyncTransferThreadName) {
-    base::Thread::Options options;
-#if defined(OS_ANDROID)
-    options.priority = base::ThreadPriority::BACKGROUND;
-#endif
-    StartWithOptions(options);
-  }
-  ~TransferThread() override { Stop(); }
-
-  void Init() override {
-    gfx::GLShareGroup* share_group = NULL;
-    surface_ = new gfx::PbufferGLSurfaceEGL(gfx::Size(1, 1));
-    surface_->Initialize();
-    context_ = gfx::GLContext::CreateGLContext(
-        share_group, surface_.get(), gfx::PreferDiscreteGpu);
-    bool is_current = context_->MakeCurrent(surface_.get());
-    DCHECK(is_current);
-  }
-
-  void CleanUp() override {
-    surface_ = NULL;
-    context_->ReleaseCurrent(surface_.get());
-    context_ = NULL;
-  }
-
- private:
-  scoped_refptr<gfx::GLContext> context_;
-  scoped_refptr<gfx::GLSurface> surface_;
-
-  DISALLOW_COPY_AND_ASSIGN(TransferThread);
-};
-
-base::LazyInstance<TransferThread>
-    g_transfer_thread = LAZY_INSTANCE_INITIALIZER;
-
-base::SingleThreadTaskRunner* transfer_task_runner() {
-  return g_transfer_thread.Pointer()->task_runner().get();
-}
-
-// Class which holds async pixel transfers state (EGLImage).
-// The EGLImage is accessed by either thread, but everything
-// else accessed only on the main thread.
-class TransferStateInternal
-    : public base::RefCountedThreadSafe<TransferStateInternal> {
- public:
-  TransferStateInternal(GLuint texture_id,
-                        const AsyncTexImage2DParams& define_params,
-                        bool wait_for_uploads,
-                        bool wait_for_creation,
-                        bool use_image_preserved)
-      : texture_id_(texture_id),
-        thread_texture_id_(0),
-        transfer_completion_(true, true),
-        egl_image_(EGL_NO_IMAGE_KHR),
-        wait_for_uploads_(wait_for_uploads),
-        wait_for_creation_(wait_for_creation),
-        use_image_preserved_(use_image_preserved) {
-    define_params_ = define_params;
-  }
-
-  bool TransferIsInProgress() {
-    return !transfer_completion_.IsSignaled();
-  }
-
-  void BindTransfer() {
-    TRACE_EVENT2("gpu", "BindAsyncTransfer glEGLImageTargetTexture2DOES",
-                 "width", define_params_.width,
-                 "height", define_params_.height);
-    DCHECK(texture_id_);
-    if (EGL_NO_IMAGE_KHR == egl_image_)
-      return;
-
-    glBindTexture(GL_TEXTURE_2D, texture_id_);
-    glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, egl_image_);
-    bind_callback_.Run();
-
-    DCHECK(CHECK_GL());
-  }
-
-  void CreateEglImage(GLuint texture_id) {
-    TRACE_EVENT0("gpu", "eglCreateImageKHR");
-    DCHECK(texture_id);
-    DCHECK_EQ(egl_image_, EGL_NO_IMAGE_KHR);
-
-    EGLDisplay egl_display = eglGetCurrentDisplay();
-    EGLContext egl_context = eglGetCurrentContext();
-    EGLenum egl_target = EGL_GL_TEXTURE_2D_KHR;
-    EGLClientBuffer egl_buffer =
-        reinterpret_cast<EGLClientBuffer>(texture_id);
-
-    EGLint image_preserved = use_image_preserved_ ? EGL_TRUE : EGL_FALSE;
-    EGLint egl_attrib_list[] = {
-        EGL_GL_TEXTURE_LEVEL_KHR, 0, // mip-level.
-        EGL_IMAGE_PRESERVED_KHR, image_preserved,
-        EGL_NONE
-    };
-    egl_image_ = eglCreateImageKHR(
-        egl_display,
-        egl_context,
-        egl_target,
-        egl_buffer,
-        egl_attrib_list);
-
-    DLOG_IF(ERROR, EGL_NO_IMAGE_KHR == egl_image_)
-        << "eglCreateImageKHR failed";
-  }
-
-  void CreateEglImageOnUploadThread() {
-    CreateEglImage(thread_texture_id_);
-  }
-
-  void CreateEglImageOnMainThreadIfNeeded() {
-    if (egl_image_ == EGL_NO_IMAGE_KHR) {
-      CreateEglImage(texture_id_);
-      if (wait_for_creation_) {
-        TRACE_EVENT0("gpu", "glFinish creation");
-        glFinish();
-      }
-    }
-  }
-
-  void WaitForLastUpload() {
-    // This glFinish is just a safe-guard for if uploads have some
-    // GPU action that needs to occur. We could use fences and try
-    // to do this less often. However, on older drivers fences are
-    // not always reliable (eg. Mali-400 just blocks forever).
-    if (wait_for_uploads_) {
-      TRACE_EVENT0("gpu", "glFinish");
-      glFinish();
-    }
-  }
-
-  void MarkAsTransferIsInProgress() {
-    TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
-    transfer_completion_.Reset();
-  }
-
-  void MarkAsCompleted() {
-    TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
-    transfer_completion_.Signal();
-  }
-
-  void WaitForTransferCompletion() {
-    TRACE_EVENT0("gpu", "WaitForTransferCompletion");
-    // TODO(backer): Deschedule the channel rather than blocking the main GPU
-    // thread (crbug.com/240265).
-    transfer_completion_.Wait();
-  }
-
-  void PerformAsyncTexImage2D(
-      AsyncTexImage2DParams tex_params,
-      AsyncMemoryParams mem_params,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
-    TRACE_EVENT2("gpu",
-                 "PerformAsyncTexImage",
-                 "width",
-                 tex_params.width,
-                 "height",
-                 tex_params.height);
-    DCHECK(!thread_texture_id_);
-    DCHECK_EQ(0, tex_params.level);
-    if (EGL_NO_IMAGE_KHR != egl_image_) {
-      MarkAsCompleted();
-      return;
-    }
-
-    void* data = mem_params.GetDataAddress();
-
-    base::TimeTicks begin_time;
-    if (texture_upload_stats.get())
-      begin_time = base::TimeTicks::Now();
-
-    {
-      TRACE_EVENT0("gpu", "glTexImage2D no data");
-      glGenTextures(1, &thread_texture_id_);
-      glActiveTexture(GL_TEXTURE0);
-      glBindTexture(GL_TEXTURE_2D, thread_texture_id_);
-
-      SetGlParametersForEglImageTexture();
-
-      // If we need to use image_preserved, we pass the data with
-      // the allocation. Otherwise we use a NULL allocation to
-      // try to avoid any costs associated with creating the EGLImage.
-      if (use_image_preserved_)
-        DoTexImage2D(tex_params, data);
-      else
-        DoTexImage2D(tex_params, NULL);
-    }
-
-    CreateEglImageOnUploadThread();
-
-    {
-      TRACE_EVENT0("gpu", "glTexSubImage2D with data");
-
-      // If we didn't use image_preserved, we haven't uploaded
-      // the data yet, so we do this with a full texSubImage.
-      if (!use_image_preserved_)
-        DoFullTexSubImage2D(tex_params, data);
-    }
-
-    WaitForLastUpload();
-    MarkAsCompleted();
-
-    DCHECK(CHECK_GL());
-    if (texture_upload_stats.get()) {
-      texture_upload_stats->AddUpload(base::TimeTicks::Now() - begin_time);
-    }
-  }
-
-  void PerformAsyncTexSubImage2D(
-      AsyncTexSubImage2DParams tex_params,
-      AsyncMemoryParams mem_params,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
-    TRACE_EVENT2("gpu",
-                 "PerformAsyncTexSubImage2D",
-                 "width",
-                 tex_params.width,
-                 "height",
-                 tex_params.height);
-
-    DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
-    DCHECK_EQ(0, tex_params.level);
-
-    void* data = mem_params.GetDataAddress();
-
-    base::TimeTicks begin_time;
-    if (texture_upload_stats.get())
-      begin_time = base::TimeTicks::Now();
-
-    if (!thread_texture_id_) {
-      TRACE_EVENT0("gpu", "glEGLImageTargetTexture2DOES");
-      glGenTextures(1, &thread_texture_id_);
-      glActiveTexture(GL_TEXTURE0);
-      glBindTexture(GL_TEXTURE_2D, thread_texture_id_);
-      glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, egl_image_);
-    } else {
-      glActiveTexture(GL_TEXTURE0);
-      glBindTexture(GL_TEXTURE_2D, thread_texture_id_);
-    }
-    {
-      TRACE_EVENT0("gpu", "glTexSubImage2D");
-      DoTexSubImage2D(tex_params, data);
-    }
-    WaitForLastUpload();
-    MarkAsCompleted();
-
-    DCHECK(CHECK_GL());
-    if (texture_upload_stats.get()) {
-      texture_upload_stats->AddUpload(base::TimeTicks::Now() - begin_time);
-    }
-  }
-
- protected:
-  friend class base::RefCountedThreadSafe<TransferStateInternal>;
-  friend class gpu::AsyncPixelTransferDelegateEGL;
-
-  static void DeleteTexture(GLuint id) {
-    glDeleteTextures(1, &id);
-  }
-
-  virtual ~TransferStateInternal() {
-    if (egl_image_ != EGL_NO_IMAGE_KHR) {
-      EGLDisplay display = eglGetCurrentDisplay();
-      eglDestroyImageKHR(display, egl_image_);
-    }
-    if (thread_texture_id_) {
-      transfer_task_runner()->PostTask(
-          FROM_HERE, base::Bind(&DeleteTexture, thread_texture_id_));
-    }
-  }
-
-  // The 'real' texture.
-  GLuint texture_id_;
-
-  // The EGLImage sibling on the upload thread.
-  GLuint thread_texture_id_;
-
-  // Definition params for texture that needs binding.
-  AsyncTexImage2DParams define_params_;
-
-  // Indicates that an async transfer is in progress.
-  base::WaitableEvent transfer_completion_;
-
-  // It would be nice if we could just create a new EGLImage for
-  // every upload, but I found that didn't work, so this stores
-  // one for the lifetime of the texture.
-  EGLImageKHR egl_image_;
-
-  // Callback to invoke when AsyncTexImage2D is complete
-  // and the client can safely use the texture. This occurs
-  // during BindCompletedAsyncTransfers().
-  base::Closure bind_callback_;
-
-  // Customize when we block on fences (these are work-arounds).
-  bool wait_for_uploads_;
-  bool wait_for_creation_;
-  bool use_image_preserved_;
-};
-
-}  // namespace
-
-// Class which handles async pixel transfers using EGLImageKHR and another
-// upload thread
-class AsyncPixelTransferDelegateEGL
-    : public AsyncPixelTransferDelegate,
-      public base::SupportsWeakPtr<AsyncPixelTransferDelegateEGL> {
- public:
-  AsyncPixelTransferDelegateEGL(
-      AsyncPixelTransferManagerEGL::SharedState* shared_state,
-      GLuint texture_id,
-      const AsyncTexImage2DParams& define_params);
-  ~AsyncPixelTransferDelegateEGL() override;
-
-  void BindTransfer() { state_->BindTransfer(); }
-
-  // Implement AsyncPixelTransferDelegate:
-  void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
-                       const AsyncMemoryParams& mem_params,
-                       const base::Closure& bind_callback) override;
-  void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
-                          const AsyncMemoryParams& mem_params) override;
-  bool TransferIsInProgress() override;
-  void WaitForTransferCompletion() override;
-
- private:
-  // Returns true if a work-around was used.
-  bool WorkAroundAsyncTexImage2D(
-      const AsyncTexImage2DParams& tex_params,
-      const AsyncMemoryParams& mem_params,
-      const base::Closure& bind_callback);
-  bool WorkAroundAsyncTexSubImage2D(
-      const AsyncTexSubImage2DParams& tex_params,
-      const AsyncMemoryParams& mem_params);
-
-  // A raw pointer is safe because the SharedState is owned by the Manager,
-  // which owns this Delegate.
-  AsyncPixelTransferManagerEGL::SharedState* shared_state_;
-  scoped_refptr<TransferStateInternal> state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateEGL);
-};
-
-AsyncPixelTransferDelegateEGL::AsyncPixelTransferDelegateEGL(
-    AsyncPixelTransferManagerEGL::SharedState* shared_state,
-    GLuint texture_id,
-    const AsyncTexImage2DParams& define_params)
-    : shared_state_(shared_state) {
-  // We can't wait on uploads on imagination (it can take 200ms+).
-  // In practice, they are complete when the CPU glTexSubImage2D completes.
-  bool wait_for_uploads = !shared_state_->is_imagination;
-
-  // Qualcomm runs into texture corruption problems if the same texture is
-  // uploaded to with both async and normal uploads. Synchronize after EGLImage
-  // creation on the main thread as a work-around.
-  bool wait_for_creation = shared_state_->is_qualcomm;
-
-  // Qualcomm has a race when using image_preserved=FALSE,
-  // which can result in black textures even after the first upload.
-  // Since using FALSE is mainly for performance (to avoid layout changes),
-  // but Qualcomm itself doesn't seem to get any performance benefit,
-  // we just using image_preservedd=TRUE on Qualcomm as a work-around.
-  bool use_image_preserved =
-      shared_state_->is_qualcomm || shared_state_->is_imagination;
-
-  state_ = new TransferStateInternal(texture_id,
-                                   define_params,
-                                   wait_for_uploads,
-                                   wait_for_creation,
-                                   use_image_preserved);
-}
-
-AsyncPixelTransferDelegateEGL::~AsyncPixelTransferDelegateEGL() {}
-
-bool AsyncPixelTransferDelegateEGL::TransferIsInProgress() {
-  return state_->TransferIsInProgress();
-}
-
-void AsyncPixelTransferDelegateEGL::WaitForTransferCompletion() {
-  if (state_->TransferIsInProgress()) {
-    state_->WaitForTransferCompletion();
-    DCHECK(!state_->TransferIsInProgress());
-  }
-}
-
-void AsyncPixelTransferDelegateEGL::AsyncTexImage2D(
-    const AsyncTexImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params,
-    const base::Closure& bind_callback) {
-  if (WorkAroundAsyncTexImage2D(tex_params, mem_params, bind_callback))
-    return;
-
-  DCHECK(!state_->TransferIsInProgress());
-  DCHECK_EQ(state_->egl_image_, EGL_NO_IMAGE_KHR);
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
-  DCHECK_EQ(tex_params.level, 0);
-
-  // Mark the transfer in progress and save the late bind
-  // callback, so we can notify the client when it is bound.
-  shared_state_->pending_allocations.push_back(AsWeakPtr());
-  state_->bind_callback_ = bind_callback;
-
-  // Mark the transfer in progress.
-  state_->MarkAsTransferIsInProgress();
-
-  // Duplicate the shared memory so there is no way we can get
-  // a use-after-free of the raw pixels.
-  transfer_task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&TransferStateInternal::PerformAsyncTexImage2D, state_,
-                 tex_params, mem_params, shared_state_->texture_upload_stats));
-
-  DCHECK(CHECK_GL());
-}
-
-void AsyncPixelTransferDelegateEGL::AsyncTexSubImage2D(
-    const AsyncTexSubImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params) {
-  TRACE_EVENT2("gpu", "AsyncTexSubImage2D",
-               "width", tex_params.width,
-               "height", tex_params.height);
-  if (WorkAroundAsyncTexSubImage2D(tex_params, mem_params))
-    return;
-  DCHECK(!state_->TransferIsInProgress());
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
-  DCHECK_EQ(tex_params.level, 0);
-
-  // Mark the transfer in progress.
-  state_->MarkAsTransferIsInProgress();
-
-  // If this wasn't async allocated, we don't have an EGLImage yet.
-  // Create the EGLImage if it hasn't already been created.
-  state_->CreateEglImageOnMainThreadIfNeeded();
-
-  // Duplicate the shared memory so there are no way we can get
-  // a use-after-free of the raw pixels.
-  transfer_task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&TransferStateInternal::PerformAsyncTexSubImage2D, state_,
-                 tex_params, mem_params, shared_state_->texture_upload_stats));
-
-  DCHECK(CHECK_GL());
-}
-
-namespace {
-bool IsPowerOfTwo (unsigned int x) {
-  return ((x != 0) && !(x & (x - 1)));
-}
-
-bool IsMultipleOfEight(unsigned int x) {
-  return (x & 7) == 0;
-}
-
-bool DimensionsSupportImgFastPath(int width, int height) {
-  // Multiple of eight, but not a power of two.
-  return IsMultipleOfEight(width) &&
-         IsMultipleOfEight(height) &&
-         !(IsPowerOfTwo(width) &&
-           IsPowerOfTwo(height));
-}
-}  // namespace
-
-// It is very difficult to stream uploads on Imagination GPUs:
-// - glTexImage2D defers a swizzle/stall until draw-time
-// - glTexSubImage2D will sleep for 16ms on a good day, and 100ms
-//   or longer if OpenGL is in heavy use by another thread.
-// The one combination that avoids these problems requires:
-// a.) Allocations/Uploads must occur on different threads/contexts.
-// b.) Texture size must be non-power-of-two.
-// When using a+b, uploads will be incorrect/corrupt unless:
-// c.) Texture size must be a multiple-of-eight.
-//
-// To achieve a.) we allocate synchronously on the main thread followed
-// by uploading on the upload thread. When b/c are not true we fall back
-// on purely synchronous allocation/upload on the main thread.
-
-bool AsyncPixelTransferDelegateEGL::WorkAroundAsyncTexImage2D(
-    const AsyncTexImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params,
-    const base::Closure& bind_callback) {
-  if (!shared_state_->is_imagination)
-    return false;
-
-  // On imagination we allocate synchronously all the time, even
-  // if the dimensions support fast uploads. This is for part a.)
-  // above, so allocations occur on a different thread/context as uploads.
-  void* data = mem_params.GetDataAddress();
-  SetGlParametersForEglImageTexture();
-
-  {
-    TRACE_EVENT0("gpu", "glTexImage2D with data");
-    DoTexImage2D(tex_params, data);
-  }
-
-  // The allocation has already occured, so mark it as finished
-  // and ready for binding.
-  CHECK(!state_->TransferIsInProgress());
-
-  // If the dimensions support fast async uploads, create the
-  // EGLImage for future uploads. The late bind should not
-  // be needed since the EGLImage was created from the main thread
-  // texture, but this is required to prevent an imagination driver crash.
-  if (DimensionsSupportImgFastPath(tex_params.width, tex_params.height)) {
-    state_->CreateEglImageOnMainThreadIfNeeded();
-    shared_state_->pending_allocations.push_back(AsWeakPtr());
-    state_->bind_callback_ = bind_callback;
-  }
-
-  DCHECK(CHECK_GL());
-  return true;
-}
-
-bool AsyncPixelTransferDelegateEGL::WorkAroundAsyncTexSubImage2D(
-    const AsyncTexSubImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params) {
-  if (!shared_state_->is_imagination)
-    return false;
-
-  // If the dimensions support fast async uploads, we can use the
-  // normal async upload path for uploads.
-  if (DimensionsSupportImgFastPath(tex_params.width, tex_params.height))
-    return false;
-
-  // Fall back on a synchronous stub as we don't have a known fast path.
-  // Also, older ICS drivers crash when we do any glTexSubImage2D on the
-  // same thread. To work around this we do glTexImage2D instead. Since
-  // we didn't create an EGLImage for this texture (see above), this is
-  // okay, but it limits this API to full updates for now.
-  DCHECK(!state_->egl_image_);
-  DCHECK_EQ(tex_params.xoffset, 0);
-  DCHECK_EQ(tex_params.yoffset, 0);
-  DCHECK_EQ(state_->define_params_.width, tex_params.width);
-  DCHECK_EQ(state_->define_params_.height, tex_params.height);
-  DCHECK_EQ(state_->define_params_.level, tex_params.level);
-  DCHECK_EQ(state_->define_params_.format, tex_params.format);
-  DCHECK_EQ(state_->define_params_.type, tex_params.type);
-
-  void* data = mem_params.GetDataAddress();
-  base::TimeTicks begin_time;
-  if (shared_state_->texture_upload_stats.get())
-    begin_time = base::TimeTicks::Now();
-  {
-    TRACE_EVENT0("gpu", "glTexSubImage2D");
-    // Note we use define_params_ instead of tex_params.
-    // The DCHECKs above verify this is always the same.
-    DoTexImage2D(state_->define_params_, data);
-  }
-  if (shared_state_->texture_upload_stats.get()) {
-    shared_state_->texture_upload_stats
-        ->AddUpload(base::TimeTicks::Now() - begin_time);
-  }
-
-  DCHECK(CHECK_GL());
-  return true;
-}
-
-AsyncPixelTransferManagerEGL::SharedState::SharedState()
-    // TODO(reveman): Skip this if --enable-gpu-benchmarking is not present.
-    : texture_upload_stats(new AsyncPixelTransferUploadStats) {
-  const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
-  if (vendor) {
-    is_imagination =
-        std::string(vendor).find("Imagination") != std::string::npos;
-    is_qualcomm = std::string(vendor).find("Qualcomm") != std::string::npos;
-  }
-}
-
-AsyncPixelTransferManagerEGL::SharedState::~SharedState() {}
-
-AsyncPixelTransferManagerEGL::AsyncPixelTransferManagerEGL() {}
-
-AsyncPixelTransferManagerEGL::~AsyncPixelTransferManagerEGL() {}
-
-void AsyncPixelTransferManagerEGL::BindCompletedAsyncTransfers() {
-  scoped_ptr<gfx::ScopedTextureBinder> texture_binder;
-
-  while(!shared_state_.pending_allocations.empty()) {
-    if (!shared_state_.pending_allocations.front().get()) {
-      shared_state_.pending_allocations.pop_front();
-      continue;
-    }
-    AsyncPixelTransferDelegateEGL* delegate =
-        shared_state_.pending_allocations.front().get();
-    // Terminate early, as all transfers finish in order, currently.
-    if (delegate->TransferIsInProgress())
-      break;
-
-    if (!texture_binder)
-      texture_binder.reset(new gfx::ScopedTextureBinder(GL_TEXTURE_2D, 0));
-
-    // If the transfer is finished, bind it to the texture
-    // and remove it from pending list.
-    delegate->BindTransfer();
-    shared_state_.pending_allocations.pop_front();
-  }
-}
-
-void AsyncPixelTransferManagerEGL::AsyncNotifyCompletion(
-    const AsyncMemoryParams& mem_params,
-    AsyncPixelTransferCompletionObserver* observer) {
-  // Post a PerformNotifyCompletion task to the upload thread. This task
-  // will run after all async transfers are complete.
-  transfer_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&PerformNotifyCompletion, mem_params,
-                            make_scoped_refptr(observer)));
-}
-
-uint32 AsyncPixelTransferManagerEGL::GetTextureUploadCount() {
-  return shared_state_.texture_upload_stats->GetStats(NULL);
-}
-
-base::TimeDelta AsyncPixelTransferManagerEGL::GetTotalTextureUploadTime() {
-  base::TimeDelta total_texture_upload_time;
-  shared_state_.texture_upload_stats->GetStats(&total_texture_upload_time);
-  return total_texture_upload_time;
-}
-
-void AsyncPixelTransferManagerEGL::ProcessMorePendingTransfers() {
-}
-
-bool AsyncPixelTransferManagerEGL::NeedsProcessMorePendingTransfers() {
-  return false;
-}
-
-void AsyncPixelTransferManagerEGL::WaitAllAsyncTexImage2D() {
-  if (shared_state_.pending_allocations.empty())
-    return;
-
-  AsyncPixelTransferDelegateEGL* delegate =
-      shared_state_.pending_allocations.back().get();
-  if (delegate)
-    delegate->WaitForTransferCompletion();
-}
-
-AsyncPixelTransferDelegate*
-AsyncPixelTransferManagerEGL::CreatePixelTransferDelegateImpl(
-    gles2::TextureRef* ref,
-    const AsyncTexImage2DParams& define_params) {
-  return new AsyncPixelTransferDelegateEGL(
-      &shared_state_, ref->service_id(), define_params);
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_egl.h b/gpu/command_buffer/service/async_pixel_transfer_manager_egl.h
deleted file mode 100644
index 0b74216..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_egl.h
+++ /dev/null
@@ -1,58 +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 GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_EGL_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_EGL_H_
-
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-#include "base/memory/ref_counted.h"
-
-namespace gpu {
-class AsyncPixelTransferDelegateEGL;
-class AsyncPixelTransferUploadStats;
-
-class AsyncPixelTransferManagerEGL : public AsyncPixelTransferManager {
- public:
-  AsyncPixelTransferManagerEGL();
-  ~AsyncPixelTransferManagerEGL() override;
-
-  // AsyncPixelTransferManager implementation:
-  void BindCompletedAsyncTransfers() override;
-  void AsyncNotifyCompletion(
-      const AsyncMemoryParams& mem_params,
-      AsyncPixelTransferCompletionObserver* observer) override;
-  uint32 GetTextureUploadCount() override;
-  base::TimeDelta GetTotalTextureUploadTime() override;
-  void ProcessMorePendingTransfers() override;
-  bool NeedsProcessMorePendingTransfers() override;
-  void WaitAllAsyncTexImage2D() override;
-
-  // State shared between Managers and Delegates.
-  struct SharedState {
-    SharedState();
-    ~SharedState();
-
-    scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats;
-    bool is_imagination;
-    bool is_qualcomm;
-    typedef std::list<base::WeakPtr<AsyncPixelTransferDelegateEGL> >
-        TransferQueue;
-    TransferQueue pending_allocations;
-  };
-
- private:
-  // AsyncPixelTransferManager implementation:
-  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
-      gles2::TextureRef* ref,
-      const AsyncTexImage2DParams& define_params) override;
-
-  SharedState shared_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferManagerEGL);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_EGL_H_
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc
deleted file mode 100644
index b555ebb..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc
+++ /dev/null
@@ -1,334 +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 "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
-
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/memory/weak_ptr.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_synthetic_delay.h"
-#include "ui/gl/scoped_binders.h"
-
-namespace gpu {
-
-namespace {
-
-static uint64 g_next_pixel_transfer_state_id = 1;
-
-void PerformNotifyCompletion(
-    AsyncMemoryParams mem_params,
-    scoped_refptr<AsyncPixelTransferCompletionObserver> observer) {
-  TRACE_EVENT0("gpu", "PerformNotifyCompletion");
-  observer->DidComplete(mem_params);
-}
-
-}  // namespace
-
-// Class which handles async pixel transfers in a platform
-// independent way.
-class AsyncPixelTransferDelegateIdle
-    : public AsyncPixelTransferDelegate,
-      public base::SupportsWeakPtr<AsyncPixelTransferDelegateIdle> {
- public:
-  typedef base::Callback<GLuint()> TextureIdCallback;
-  AsyncPixelTransferDelegateIdle(
-      AsyncPixelTransferManagerIdle::SharedState* state,
-      const TextureIdCallback& texture_id_callback,
-      const AsyncTexImage2DParams& define_params);
-  ~AsyncPixelTransferDelegateIdle() override;
-
-  // Implement AsyncPixelTransferDelegate:
-  void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
-                       const AsyncMemoryParams& mem_params,
-                       const base::Closure& bind_callback) override;
-  void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
-                          const AsyncMemoryParams& mem_params) override;
-  bool TransferIsInProgress() override;
-  void WaitForTransferCompletion() override;
-
- private:
-  void PerformAsyncTexImage2D(AsyncTexImage2DParams tex_params,
-                              AsyncMemoryParams mem_params,
-                              const base::Closure& bind_callback);
-  void PerformAsyncTexSubImage2D(AsyncTexSubImage2DParams tex_params,
-                                 AsyncMemoryParams mem_params);
-
-  uint64 id_;
-  TextureIdCallback texture_id_callback_;
-  bool transfer_in_progress_;
-  AsyncTexImage2DParams define_params_;
-
-  // Safe to hold a raw pointer because SharedState is owned by the Manager
-  // which owns the Delegate.
-  AsyncPixelTransferManagerIdle::SharedState* shared_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateIdle);
-};
-
-AsyncPixelTransferDelegateIdle::AsyncPixelTransferDelegateIdle(
-    AsyncPixelTransferManagerIdle::SharedState* shared_state,
-    const TextureIdCallback& texture_id_callback,
-    const AsyncTexImage2DParams& define_params)
-    : id_(g_next_pixel_transfer_state_id++),
-      texture_id_callback_(texture_id_callback),
-      transfer_in_progress_(false),
-      define_params_(define_params),
-      shared_state_(shared_state) {}
-
-AsyncPixelTransferDelegateIdle::~AsyncPixelTransferDelegateIdle() {}
-
-void AsyncPixelTransferDelegateIdle::AsyncTexImage2D(
-    const AsyncTexImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params,
-    const base::Closure& bind_callback) {
-  TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
-
-  shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
-      id_,
-      this,
-      base::Bind(&AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D,
-                 AsWeakPtr(),
-                 tex_params,
-                 mem_params,
-                 bind_callback)));
-
-  transfer_in_progress_ = true;
-}
-
-void AsyncPixelTransferDelegateIdle::AsyncTexSubImage2D(
-    const AsyncTexSubImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params) {
-  TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
-
-  shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
-      id_,
-      this,
-      base::Bind(&AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D,
-                 AsWeakPtr(),
-                 tex_params,
-                 mem_params)));
-
-  transfer_in_progress_ = true;
-}
-
-bool  AsyncPixelTransferDelegateIdle::TransferIsInProgress() {
-  return transfer_in_progress_;
-}
-
-void AsyncPixelTransferDelegateIdle::WaitForTransferCompletion() {
-  for (std::list<AsyncPixelTransferManagerIdle::Task>::iterator iter =
-           shared_state_->tasks.begin();
-       iter != shared_state_->tasks.end();
-       ++iter) {
-    if (iter->transfer_id != id_)
-      continue;
-
-    (*iter).task.Run();
-    shared_state_->tasks.erase(iter);
-    break;
-  }
-
-  shared_state_->ProcessNotificationTasks();
-}
-
-void AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D(
-    AsyncTexImage2DParams tex_params,
-    AsyncMemoryParams mem_params,
-    const base::Closure& bind_callback) {
-  TRACE_EVENT2("gpu", "PerformAsyncTexImage2D",
-               "width", tex_params.width,
-               "height", tex_params.height);
-
-  void* data = mem_params.GetDataAddress();
-
-  base::TimeTicks begin_time(base::TimeTicks::Now());
-  gfx::ScopedTextureBinder texture_binder(tex_params.target,
-                                          texture_id_callback_.Run());
-
-  {
-    TRACE_EVENT0("gpu", "glTexImage2D");
-    glTexImage2D(
-        tex_params.target,
-        tex_params.level,
-        tex_params.internal_format,
-        tex_params.width,
-        tex_params.height,
-        tex_params.border,
-        tex_params.format,
-        tex_params.type,
-        data);
-  }
-
-  TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
-  transfer_in_progress_ = false;
-  shared_state_->texture_upload_count++;
-  shared_state_->total_texture_upload_time +=
-      base::TimeTicks::Now() - begin_time;
-
-  // The texture is already fully bound so just call it now.
-  bind_callback.Run();
-}
-
-void AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D(
-    AsyncTexSubImage2DParams tex_params,
-    AsyncMemoryParams mem_params) {
-  TRACE_EVENT2("gpu", "PerformAsyncTexSubImage2D",
-               "width", tex_params.width,
-               "height", tex_params.height);
-
-  void* data = mem_params.GetDataAddress();
-
-  base::TimeTicks begin_time(base::TimeTicks::Now());
-  gfx::ScopedTextureBinder texture_binder(tex_params.target,
-                                          texture_id_callback_.Run());
-
-  if (shared_state_->use_teximage2d_over_texsubimage2d &&
-      tex_params.xoffset == 0 &&
-      tex_params.yoffset == 0 &&
-      tex_params.target == define_params_.target &&
-      tex_params.level  == define_params_.level &&
-      tex_params.width  == define_params_.width &&
-      tex_params.height == define_params_.height) {
-    TRACE_EVENT0("gpu", "glTexImage2D");
-    glTexImage2D(
-        define_params_.target,
-        define_params_.level,
-        define_params_.internal_format,
-        define_params_.width,
-        define_params_.height,
-        define_params_.border,
-        tex_params.format,
-        tex_params.type,
-        data);
-  } else {
-    TRACE_EVENT0("gpu", "glTexSubImage2D");
-    glTexSubImage2D(
-        tex_params.target,
-        tex_params.level,
-        tex_params.xoffset,
-        tex_params.yoffset,
-        tex_params.width,
-        tex_params.height,
-        tex_params.format,
-        tex_params.type,
-        data);
-  }
-
-  TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
-  transfer_in_progress_ = false;
-  shared_state_->texture_upload_count++;
-  shared_state_->total_texture_upload_time +=
-      base::TimeTicks::Now() - begin_time;
-}
-
-AsyncPixelTransferManagerIdle::Task::Task(
-    uint64 transfer_id,
-    AsyncPixelTransferDelegate* delegate,
-    const base::Closure& task)
-    : transfer_id(transfer_id),
-      delegate(delegate),
-      task(task) {
-}
-
-AsyncPixelTransferManagerIdle::Task::~Task() {}
-
-AsyncPixelTransferManagerIdle::SharedState::SharedState(
-    bool use_teximage2d_over_texsubimage2d)
-    : use_teximage2d_over_texsubimage2d(use_teximage2d_over_texsubimage2d),
-      texture_upload_count(0) {
-}
-
-AsyncPixelTransferManagerIdle::SharedState::~SharedState() {}
-
-void AsyncPixelTransferManagerIdle::SharedState::ProcessNotificationTasks() {
-  while (!tasks.empty()) {
-    // Stop when we reach a pixel transfer task.
-    if (tasks.front().transfer_id)
-      return;
-
-    tasks.front().task.Run();
-    tasks.pop_front();
-  }
-}
-
-AsyncPixelTransferManagerIdle::AsyncPixelTransferManagerIdle(
-    bool use_teximage2d_over_texsubimage2d)
-    : shared_state_(use_teximage2d_over_texsubimage2d) {
-}
-
-AsyncPixelTransferManagerIdle::~AsyncPixelTransferManagerIdle() {}
-
-void AsyncPixelTransferManagerIdle::BindCompletedAsyncTransfers() {
-  // Everything is already bound.
-}
-
-void AsyncPixelTransferManagerIdle::AsyncNotifyCompletion(
-    const AsyncMemoryParams& mem_params,
-    AsyncPixelTransferCompletionObserver* observer) {
-  if (shared_state_.tasks.empty()) {
-    observer->DidComplete(mem_params);
-    return;
-  }
-
-  shared_state_.tasks.push_back(
-      Task(0,  // 0 transfer_id for notification tasks.
-           NULL,
-           base::Bind(
-               &PerformNotifyCompletion,
-               mem_params,
-               make_scoped_refptr(observer))));
-}
-
-uint32 AsyncPixelTransferManagerIdle::GetTextureUploadCount() {
-  return shared_state_.texture_upload_count;
-}
-
-base::TimeDelta AsyncPixelTransferManagerIdle::GetTotalTextureUploadTime() {
-  return shared_state_.total_texture_upload_time;
-}
-
-void AsyncPixelTransferManagerIdle::ProcessMorePendingTransfers() {
-  if (shared_state_.tasks.empty())
-    return;
-
-  // First task should always be a pixel transfer task.
-  DCHECK(shared_state_.tasks.front().transfer_id);
-  shared_state_.tasks.front().task.Run();
-  shared_state_.tasks.pop_front();
-
-  shared_state_.ProcessNotificationTasks();
-}
-
-bool AsyncPixelTransferManagerIdle::NeedsProcessMorePendingTransfers() {
-  return !shared_state_.tasks.empty();
-}
-
-void AsyncPixelTransferManagerIdle::WaitAllAsyncTexImage2D() {
-  if (shared_state_.tasks.empty())
-    return;
-
-  const Task& task = shared_state_.tasks.back();
-  if (task.delegate)
-    task.delegate->WaitForTransferCompletion();
-}
-
-AsyncPixelTransferDelegate*
-AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
-    gles2::TextureRef* ref,
-    const AsyncTexImage2DParams& define_params) {
-  return new AsyncPixelTransferDelegateIdle(
-      &shared_state_,
-      // Not directly passing texture_ref->service_id here because it can change
-      // if avoid_egl_image_target_texture_reuse workaround is in effect.
-      // Unretained is safe because AsyncPixelTransferManager observes
-      // TextureRef destruction and destroys the delegate before TextureRef
-      // is destroyed.
-      base::Bind(&gles2::TextureRef::service_id, base::Unretained(ref)),
-      define_params);
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.h b/gpu/command_buffer/service/async_pixel_transfer_manager_idle.h
deleted file mode 100644
index 41a77b3..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_idle.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_IDLE_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_IDLE_H_
-
-#include <list>
-
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-namespace gpu {
-
-class AsyncPixelTransferManagerIdle : public AsyncPixelTransferManager {
- public:
-  explicit AsyncPixelTransferManagerIdle(
-      bool use_teximage2d_over_texsubimage2d);
-  ~AsyncPixelTransferManagerIdle() override;
-
-  // AsyncPixelTransferManager implementation:
-  void BindCompletedAsyncTransfers() override;
-  void AsyncNotifyCompletion(
-      const AsyncMemoryParams& mem_params,
-      AsyncPixelTransferCompletionObserver* observer) override;
-  uint32 GetTextureUploadCount() override;
-  base::TimeDelta GetTotalTextureUploadTime() override;
-  void ProcessMorePendingTransfers() override;
-  bool NeedsProcessMorePendingTransfers() override;
-  void WaitAllAsyncTexImage2D() override;
-
-  struct Task {
-    Task(uint64 transfer_id,
-         AsyncPixelTransferDelegate* delegate,
-         const base::Closure& task);
-    ~Task();
-
-    // This is non-zero if pixel transfer task.
-    uint64 transfer_id;
-
-    AsyncPixelTransferDelegate* delegate;
-
-    base::Closure task;
-  };
-
-  // State shared between Managers and Delegates.
-  struct SharedState {
-    explicit SharedState(bool use_teximage2d_over_texsubimage2d);
-    ~SharedState();
-    void ProcessNotificationTasks();
-
-    const bool use_teximage2d_over_texsubimage2d;
-    int texture_upload_count;
-    base::TimeDelta total_texture_upload_time;
-    std::list<Task> tasks;
-  };
-
- private:
-  // AsyncPixelTransferManager implementation:
-  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
-      gles2::TextureRef* ref,
-      const AsyncTexImage2DParams& define_params) override;
-
-  SharedState shared_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferManagerIdle);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_IDLE_H_
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_linux.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_linux.cc
deleted file mode 100644
index b0cc463..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_linux.cc
+++ /dev/null
@@ -1,40 +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 "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-#include "base/command_line.h"
-#include "base/trace_event/trace_event.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_stub.h"
-#include "gpu/command_buffer/service/gpu_switches.h"
-#include "ui/gl/gl_implementation.h"
-
-namespace gpu {
-
-AsyncPixelTransferManager* AsyncPixelTransferManager::Create(
-    gfx::GLContext* context) {
-  TRACE_EVENT0("gpu", "AsyncPixelTransferManager::Create");
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableShareGroupAsyncTextureUpload)) {
-    DCHECK(context);
-    return static_cast<AsyncPixelTransferManager*> (
-        new AsyncPixelTransferManagerShareGroup(context));
-  }
-
-  switch (gfx::GetGLImplementation()) {
-    case gfx::kGLImplementationOSMesaGL:
-    case gfx::kGLImplementationDesktopGL:
-    case gfx::kGLImplementationEGLGLES2:
-      return new AsyncPixelTransferManagerIdle(true);
-    case gfx::kGLImplementationMockGL:
-      return new AsyncPixelTransferManagerStub;
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_mac.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_mac.cc
deleted file mode 100644
index 6d8562f..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_mac.cc
+++ /dev/null
@@ -1,31 +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 "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-#include "base/trace_event/trace_event.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_stub.h"
-#include "ui/gl/gl_implementation.h"
-
-namespace gpu {
-
-AsyncPixelTransferManager* AsyncPixelTransferManager::Create(
-    gfx::GLContext* context) {
-  TRACE_EVENT0("gpu", "AsyncPixelTransferManager::Create");
-  switch (gfx::GetGLImplementation()) {
-    case gfx::kGLImplementationOSMesaGL:
-    case gfx::kGLImplementationDesktopGL:
-    case gfx::kGLImplementationDesktopGLCoreProfile:
-    case gfx::kGLImplementationAppleGL:
-      return new AsyncPixelTransferManagerIdle(true);
-    case gfx::kGLImplementationMockGL:
-      return new AsyncPixelTransferManagerStub;
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_mock.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_mock.cc
deleted file mode 100644
index 84e95e3..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_mock.cc
+++ /dev/null
@@ -1,15 +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 "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace gpu {
-
-MockAsyncPixelTransferManager::MockAsyncPixelTransferManager() {}
-
-MockAsyncPixelTransferManager::~MockAsyncPixelTransferManager() {}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_mock.h b/gpu/command_buffer/service/async_pixel_transfer_manager_mock.h
deleted file mode 100644
index 3bc8b6b..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_mock.h
+++ /dev/null
@@ -1,39 +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 GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_TEST_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_TEST_H_
-
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace gpu {
-
-class MockAsyncPixelTransferManager : public AsyncPixelTransferManager {
- public:
-  MockAsyncPixelTransferManager();
-  virtual ~MockAsyncPixelTransferManager();
-
-  // AsyncPixelTransferManager implementation:
-  MOCK_METHOD0(BindCompletedAsyncTransfers, void());
-  MOCK_METHOD2(AsyncNotifyCompletion,
-      void(const AsyncMemoryParams& mem_params,
-           AsyncPixelTransferCompletionObserver* observer));
-  MOCK_METHOD0(GetTextureUploadCount, uint32());
-  MOCK_METHOD0(GetTotalTextureUploadTime, base::TimeDelta());
-  MOCK_METHOD0(ProcessMorePendingTransfers, void());
-  MOCK_METHOD0(NeedsProcessMorePendingTransfers, bool());
-  MOCK_METHOD0(WaitAllAsyncTexImage2D, void());
-  MOCK_METHOD2(
-      CreatePixelTransferDelegateImpl,
-      AsyncPixelTransferDelegate*(gles2::TextureRef* ref,
-                                  const AsyncTexImage2DParams& define_params));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockAsyncPixelTransferManager);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_TEST_H_
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
deleted file mode 100644
index 86eb718..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
+++ /dev/null
@@ -1,549 +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 "gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h"
-
-#include <list>
-
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "base/synchronization/cancellation_flag.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_checker.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_synthetic_delay.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-#include "ui/gl/gl_bindings.h"
-#include "ui/gl/gl_context.h"
-#include "ui/gl/gl_surface.h"
-#include "ui/gl/gpu_preference.h"
-#include "ui/gl/scoped_binders.h"
-
-namespace gpu {
-
-namespace {
-
-const char kAsyncTransferThreadName[] = "AsyncTransferThread";
-
-void PerformNotifyCompletion(
-    AsyncMemoryParams mem_params,
-    scoped_refptr<AsyncPixelTransferCompletionObserver> observer) {
-  TRACE_EVENT0("gpu", "PerformNotifyCompletion");
-  observer->DidComplete(mem_params);
-}
-
-// TODO(backer): Factor out common thread scheduling logic from the EGL and
-// ShareGroup implementations. http://crbug.com/239889
-class TransferThread : public base::Thread {
- public:
-  TransferThread()
-      : base::Thread(kAsyncTransferThreadName),
-        initialized_(false) {
-    base::Thread::Options options;
-#if defined(OS_ANDROID) || defined(OS_LINUX)
-    options.priority = base::ThreadPriority::BACKGROUND;
-#endif
-    StartWithOptions(options);
-  }
-
-  ~TransferThread() override {
-    // The only instance of this class was declared leaky.
-    NOTREACHED();
-  }
-
-  void InitializeOnMainThread(gfx::GLContext* parent_context) {
-    TRACE_EVENT0("gpu", "TransferThread::InitializeOnMainThread");
-    if (initialized_)
-      return;
-
-    base::WaitableEvent wait_for_init(true, false);
-    task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&TransferThread::InitializeOnTransferThread,
-                   base::Unretained(this), base::Unretained(parent_context),
-                   &wait_for_init));
-    wait_for_init.Wait();
-  }
-
-  void CleanUp() override {
-    surface_ = NULL;
-    context_ = NULL;
-  }
-
- private:
-  bool initialized_;
-
-  scoped_refptr<gfx::GLSurface> surface_;
-  scoped_refptr<gfx::GLContext> context_;
-
-  void InitializeOnTransferThread(gfx::GLContext* parent_context,
-                                   base::WaitableEvent* caller_wait) {
-    TRACE_EVENT0("gpu", "InitializeOnTransferThread");
-
-    if (!parent_context) {
-      LOG(ERROR) << "No parent context provided.";
-      caller_wait->Signal();
-      return;
-    }
-
-    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(1, 1));
-    if (!surface_.get()) {
-      LOG(ERROR) << "Unable to create GLSurface";
-      caller_wait->Signal();
-      return;
-    }
-
-    // TODO(backer): This is coded for integrated GPUs. For discrete GPUs
-    // we would probably want to use a PBO texture upload for a true async
-    // upload (that would hopefully be optimized as a DMA transfer by the
-    // driver).
-    context_ = gfx::GLContext::CreateGLContext(parent_context->share_group(),
-                                               surface_.get(),
-                                               gfx::PreferIntegratedGpu);
-    if (!context_.get()) {
-      LOG(ERROR) << "Unable to create GLContext.";
-      caller_wait->Signal();
-      return;
-    }
-
-    context_->MakeCurrent(surface_.get());
-    initialized_ = true;
-    caller_wait->Signal();
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(TransferThread);
-};
-
-base::LazyInstance<TransferThread>::Leaky
-    g_transfer_thread = LAZY_INSTANCE_INITIALIZER;
-
-base::SingleThreadTaskRunner* transfer_task_runner() {
-  return g_transfer_thread.Pointer()->task_runner().get();
-}
-
-class PendingTask : public base::RefCountedThreadSafe<PendingTask> {
- public:
-  explicit PendingTask(const base::Closure& task)
-      : task_(task), task_pending_(true, false) {}
-
-  bool TryRun() {
-    // This is meant to be called on the main thread where the texture
-    // is already bound.
-    DCHECK(checker_.CalledOnValidThread());
-    if (task_lock_.Try()) {
-      // Only run once.
-      if (!task_.is_null())
-        task_.Run();
-      task_.Reset();
-
-      task_lock_.Release();
-      task_pending_.Signal();
-      return true;
-    }
-    return false;
-  }
-
-  void BindAndRun(GLuint texture_id) {
-    // This is meant to be called on the upload thread where we don't have to
-    // restore the previous texture binding.
-    DCHECK(!checker_.CalledOnValidThread());
-    base::AutoLock locked(task_lock_);
-    if (!task_.is_null()) {
-      glBindTexture(GL_TEXTURE_2D, texture_id);
-      task_.Run();
-      task_.Reset();
-      glBindTexture(GL_TEXTURE_2D, 0);
-      // Flush for synchronization between threads.
-      glFlush();
-      task_pending_.Signal();
-    }
-  }
-
-  void Cancel() {
-    base::AutoLock locked(task_lock_);
-    task_.Reset();
-    task_pending_.Signal();
-  }
-
-  bool TaskIsInProgress() {
-    return !task_pending_.IsSignaled();
-  }
-
-  void WaitForTask() {
-    task_pending_.Wait();
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<PendingTask>;
-
-  virtual ~PendingTask() {}
-
-  base::ThreadChecker checker_;
-
-  base::Lock task_lock_;
-  base::Closure task_;
-  base::WaitableEvent task_pending_;
-
-  DISALLOW_COPY_AND_ASSIGN(PendingTask);
-};
-
-// Class which holds async pixel transfers state.
-// The texture_id is accessed by either thread, but everything
-// else accessed only on the main thread.
-class TransferStateInternal
-    : public base::RefCountedThreadSafe<TransferStateInternal> {
- public:
-  TransferStateInternal(GLuint texture_id,
-                        const AsyncTexImage2DParams& define_params)
-      : texture_id_(texture_id), define_params_(define_params) {}
-
-  bool TransferIsInProgress() {
-    return pending_upload_task_.get() &&
-           pending_upload_task_->TaskIsInProgress();
-  }
-
-  void BindTransfer() {
-    TRACE_EVENT2("gpu", "BindAsyncTransfer",
-                 "width", define_params_.width,
-                 "height", define_params_.height);
-    DCHECK(texture_id_);
-
-    glBindTexture(GL_TEXTURE_2D, texture_id_);
-    bind_callback_.Run();
-  }
-
-  void WaitForTransferCompletion() {
-    TRACE_EVENT0("gpu", "WaitForTransferCompletion");
-    DCHECK(pending_upload_task_.get());
-    if (!pending_upload_task_->TryRun()) {
-      pending_upload_task_->WaitForTask();
-    }
-    pending_upload_task_ = NULL;
-  }
-
-  void CancelUpload() {
-    TRACE_EVENT0("gpu", "CancelUpload");
-    if (pending_upload_task_.get())
-      pending_upload_task_->Cancel();
-    pending_upload_task_ = NULL;
-  }
-
-  void ScheduleAsyncTexImage2D(
-      const AsyncTexImage2DParams tex_params,
-      const AsyncMemoryParams mem_params,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats,
-      const base::Closure& bind_callback) {
-    TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
-    pending_upload_task_ = new PendingTask(base::Bind(
-        &TransferStateInternal::PerformAsyncTexImage2D,
-        this,
-        tex_params,
-        mem_params,
-        texture_upload_stats));
-    transfer_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&PendingTask::BindAndRun, pending_upload_task_,
-                              texture_id_));
-
-    // Save the late bind callback, so we can notify the client when it is
-    // bound.
-    bind_callback_ = bind_callback;
-  }
-
-  void ScheduleAsyncTexSubImage2D(
-      AsyncTexSubImage2DParams tex_params,
-      AsyncMemoryParams mem_params,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
-    TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
-    pending_upload_task_ = new PendingTask(base::Bind(
-        &TransferStateInternal::PerformAsyncTexSubImage2D,
-        this,
-        tex_params,
-        mem_params,
-        texture_upload_stats));
-    transfer_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&PendingTask::BindAndRun, pending_upload_task_,
-                              texture_id_));
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<TransferStateInternal>;
-
-  virtual ~TransferStateInternal() {
-  }
-
-  void PerformAsyncTexImage2D(
-      AsyncTexImage2DParams tex_params,
-      AsyncMemoryParams mem_params,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
-    TRACE_EVENT2("gpu",
-                 "PerformAsyncTexImage",
-                 "width",
-                 tex_params.width,
-                 "height",
-                 tex_params.height);
-    DCHECK_EQ(0, tex_params.level);
-
-    base::TimeTicks begin_time;
-    if (texture_upload_stats.get())
-      begin_time = base::TimeTicks::Now();
-
-    void* data = mem_params.GetDataAddress();
-
-    {
-      TRACE_EVENT0("gpu", "glTexImage2D");
-      glTexImage2D(GL_TEXTURE_2D,
-                   tex_params.level,
-                   tex_params.internal_format,
-                   tex_params.width,
-                   tex_params.height,
-                   tex_params.border,
-                   tex_params.format,
-                   tex_params.type,
-                   data);
-      TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
-    }
-
-    if (texture_upload_stats.get()) {
-      texture_upload_stats->AddUpload(base::TimeTicks::Now() - begin_time);
-    }
-  }
-
-  void PerformAsyncTexSubImage2D(
-      AsyncTexSubImage2DParams tex_params,
-      AsyncMemoryParams mem_params,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
-    TRACE_EVENT2("gpu",
-                 "PerformAsyncTexSubImage2D",
-                 "width",
-                 tex_params.width,
-                 "height",
-                 tex_params.height);
-    DCHECK_EQ(0, tex_params.level);
-
-    base::TimeTicks begin_time;
-    if (texture_upload_stats.get())
-      begin_time = base::TimeTicks::Now();
-
-    void* data = mem_params.GetDataAddress();
-    {
-      TRACE_EVENT0("gpu", "glTexSubImage2D");
-      glTexSubImage2D(GL_TEXTURE_2D,
-                      tex_params.level,
-                      tex_params.xoffset,
-                      tex_params.yoffset,
-                      tex_params.width,
-                      tex_params.height,
-                      tex_params.format,
-                      tex_params.type,
-                      data);
-      TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
-    }
-
-    if (texture_upload_stats.get()) {
-      texture_upload_stats->AddUpload(base::TimeTicks::Now() - begin_time);
-    }
-  }
-
-  scoped_refptr<PendingTask> pending_upload_task_;
-
-  GLuint texture_id_;
-
-  // Definition params for texture that needs binding.
-  AsyncTexImage2DParams define_params_;
-
-  // Callback to invoke when AsyncTexImage2D is complete
-  // and the client can safely use the texture. This occurs
-  // during BindCompletedAsyncTransfers().
-  base::Closure bind_callback_;
-};
-
-}  // namespace
-
-class AsyncPixelTransferDelegateShareGroup
-    : public AsyncPixelTransferDelegate,
-      public base::SupportsWeakPtr<AsyncPixelTransferDelegateShareGroup> {
- public:
-  AsyncPixelTransferDelegateShareGroup(
-      AsyncPixelTransferManagerShareGroup::SharedState* shared_state,
-      GLuint texture_id,
-      const AsyncTexImage2DParams& define_params);
-  ~AsyncPixelTransferDelegateShareGroup() override;
-
-  void BindTransfer() { state_->BindTransfer(); }
-
-  // Implement AsyncPixelTransferDelegate:
-  void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
-                       const AsyncMemoryParams& mem_params,
-                       const base::Closure& bind_callback) override;
-  void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
-                          const AsyncMemoryParams& mem_params) override;
-  bool TransferIsInProgress() override;
-  void WaitForTransferCompletion() override;
-
- private:
-  // A raw pointer is safe because the SharedState is owned by the Manager,
-  // which owns this Delegate.
-  AsyncPixelTransferManagerShareGroup::SharedState* shared_state_;
-  scoped_refptr<TransferStateInternal> state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateShareGroup);
-};
-
-AsyncPixelTransferDelegateShareGroup::AsyncPixelTransferDelegateShareGroup(
-    AsyncPixelTransferManagerShareGroup::SharedState* shared_state,
-    GLuint texture_id,
-    const AsyncTexImage2DParams& define_params)
-    : shared_state_(shared_state),
-      state_(new TransferStateInternal(texture_id, define_params)) {}
-
-AsyncPixelTransferDelegateShareGroup::~AsyncPixelTransferDelegateShareGroup() {
-  TRACE_EVENT0("gpu", " ~AsyncPixelTransferDelegateShareGroup");
-  state_->CancelUpload();
-}
-
-bool AsyncPixelTransferDelegateShareGroup::TransferIsInProgress() {
-  return state_->TransferIsInProgress();
-}
-
-void AsyncPixelTransferDelegateShareGroup::WaitForTransferCompletion() {
-  if (state_->TransferIsInProgress()) {
-    state_->WaitForTransferCompletion();
-    DCHECK(!state_->TransferIsInProgress());
-  }
-
-  // Fast track the BindTransfer, if applicable.
-  for (AsyncPixelTransferManagerShareGroup::SharedState::TransferQueue::iterator
-           iter = shared_state_->pending_allocations.begin();
-       iter != shared_state_->pending_allocations.end();
-       ++iter) {
-    if (iter->get() != this)
-      continue;
-
-    shared_state_->pending_allocations.erase(iter);
-    BindTransfer();
-    break;
-  }
-}
-
-void AsyncPixelTransferDelegateShareGroup::AsyncTexImage2D(
-    const AsyncTexImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params,
-    const base::Closure& bind_callback) {
-  DCHECK(!state_->TransferIsInProgress());
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
-  DCHECK_EQ(tex_params.level, 0);
-
-  shared_state_->pending_allocations.push_back(AsWeakPtr());
-  state_->ScheduleAsyncTexImage2D(tex_params,
-                                  mem_params,
-                                  shared_state_->texture_upload_stats,
-                                  bind_callback);
-}
-
-void AsyncPixelTransferDelegateShareGroup::AsyncTexSubImage2D(
-    const AsyncTexSubImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params) {
-  TRACE_EVENT2("gpu", "AsyncTexSubImage2D",
-               "width", tex_params.width,
-               "height", tex_params.height);
-  DCHECK(!state_->TransferIsInProgress());
-  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
-  DCHECK_EQ(tex_params.level, 0);
-
-  state_->ScheduleAsyncTexSubImage2D(
-      tex_params, mem_params, shared_state_->texture_upload_stats);
-}
-
-AsyncPixelTransferManagerShareGroup::SharedState::SharedState()
-    // TODO(reveman): Skip this if --enable-gpu-benchmarking is not present.
-    : texture_upload_stats(new AsyncPixelTransferUploadStats) {}
-
-AsyncPixelTransferManagerShareGroup::SharedState::~SharedState() {}
-
-AsyncPixelTransferManagerShareGroup::AsyncPixelTransferManagerShareGroup(
-    gfx::GLContext* context) {
-  g_transfer_thread.Pointer()->InitializeOnMainThread(context);
-}
-
-AsyncPixelTransferManagerShareGroup::~AsyncPixelTransferManagerShareGroup() {}
-
-void AsyncPixelTransferManagerShareGroup::BindCompletedAsyncTransfers() {
-  scoped_ptr<gfx::ScopedTextureBinder> texture_binder;
-
-  while (!shared_state_.pending_allocations.empty()) {
-    if (!shared_state_.pending_allocations.front().get()) {
-      shared_state_.pending_allocations.pop_front();
-      continue;
-    }
-    AsyncPixelTransferDelegateShareGroup* delegate =
-        shared_state_.pending_allocations.front().get();
-    // Terminate early, as all transfers finish in order, currently.
-    if (delegate->TransferIsInProgress())
-      break;
-
-    if (!texture_binder)
-      texture_binder.reset(new gfx::ScopedTextureBinder(GL_TEXTURE_2D, 0));
-
-    // Used to set tex info from the gles2 cmd decoder once upload has
-    // finished (it'll bind the texture and call a callback).
-    delegate->BindTransfer();
-
-    shared_state_.pending_allocations.pop_front();
-  }
-}
-
-void AsyncPixelTransferManagerShareGroup::AsyncNotifyCompletion(
-    const AsyncMemoryParams& mem_params,
-    AsyncPixelTransferCompletionObserver* observer) {
-  // Post a PerformNotifyCompletion task to the upload thread. This task
-  // will run after all async transfers are complete.
-  transfer_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&PerformNotifyCompletion, mem_params,
-                            make_scoped_refptr(observer)));
-}
-
-uint32 AsyncPixelTransferManagerShareGroup::GetTextureUploadCount() {
-  return shared_state_.texture_upload_stats->GetStats(NULL);
-}
-
-base::TimeDelta
-AsyncPixelTransferManagerShareGroup::GetTotalTextureUploadTime() {
-  base::TimeDelta total_texture_upload_time;
-  shared_state_.texture_upload_stats->GetStats(&total_texture_upload_time);
-  return total_texture_upload_time;
-}
-
-void AsyncPixelTransferManagerShareGroup::ProcessMorePendingTransfers() {
-}
-
-bool AsyncPixelTransferManagerShareGroup::NeedsProcessMorePendingTransfers() {
-  return false;
-}
-
-void AsyncPixelTransferManagerShareGroup::WaitAllAsyncTexImage2D() {
-  if (shared_state_.pending_allocations.empty())
-    return;
-
-  AsyncPixelTransferDelegateShareGroup* delegate =
-      shared_state_.pending_allocations.back().get();
-  if (delegate)
-    delegate->WaitForTransferCompletion();
-}
-
-AsyncPixelTransferDelegate*
-AsyncPixelTransferManagerShareGroup::CreatePixelTransferDelegateImpl(
-    gles2::TextureRef* ref,
-    const AsyncTexImage2DParams& define_params) {
-  return new AsyncPixelTransferDelegateShareGroup(
-      &shared_state_, ref->service_id(), define_params);
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h
deleted file mode 100644
index 081fcc4..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.h
+++ /dev/null
@@ -1,60 +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 GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_SHARE_GROUP_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_SHARE_GROUP_H_
-
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-#include "base/memory/ref_counted.h"
-
-namespace gfx {
-class GLContext;
-}
-
-namespace gpu {
-class AsyncPixelTransferDelegateShareGroup;
-class AsyncPixelTransferUploadStats;
-
-class AsyncPixelTransferManagerShareGroup : public AsyncPixelTransferManager {
- public:
-  explicit AsyncPixelTransferManagerShareGroup(gfx::GLContext* context);
-  ~AsyncPixelTransferManagerShareGroup() override;
-
-  // AsyncPixelTransferManager implementation:
-  void BindCompletedAsyncTransfers() override;
-  void AsyncNotifyCompletion(
-      const AsyncMemoryParams& mem_params,
-      AsyncPixelTransferCompletionObserver* observer) override;
-  uint32 GetTextureUploadCount() override;
-  base::TimeDelta GetTotalTextureUploadTime() override;
-  void ProcessMorePendingTransfers() override;
-  bool NeedsProcessMorePendingTransfers() override;
-  void WaitAllAsyncTexImage2D() override;
-
-  // State shared between Managers and Delegates.
-  struct SharedState {
-    SharedState();
-    ~SharedState();
-
-    scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats;
-    typedef std::list<base::WeakPtr<AsyncPixelTransferDelegateShareGroup> >
-        TransferQueue;
-    TransferQueue pending_allocations;
-  };
-
- private:
-  // AsyncPixelTransferManager implementation:
-  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
-      gles2::TextureRef* ref,
-      const AsyncTexImage2DParams& define_params) override;
-
-  SharedState shared_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferManagerShareGroup);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_SHARE_GROUP_H_
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_stub.cc
deleted file mode 100644
index a2fbc8e..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.cc
+++ /dev/null
@@ -1,89 +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 "gpu/command_buffer/service/async_pixel_transfer_manager_stub.h"
-
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-
-namespace gpu {
-
-class AsyncPixelTransferDelegateStub : public AsyncPixelTransferDelegate {
- public:
-  AsyncPixelTransferDelegateStub();
-  ~AsyncPixelTransferDelegateStub() override;
-
-  // Implement AsyncPixelTransferDelegate:
-  void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
-                       const AsyncMemoryParams& mem_params,
-                       const base::Closure& bind_callback) override;
-  void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
-                          const AsyncMemoryParams& mem_params) override;
-  bool TransferIsInProgress() override;
-  void WaitForTransferCompletion() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateStub);
-};
-
-AsyncPixelTransferDelegateStub::AsyncPixelTransferDelegateStub() {}
-
-AsyncPixelTransferDelegateStub::~AsyncPixelTransferDelegateStub() {}
-
-void AsyncPixelTransferDelegateStub::AsyncTexImage2D(
-    const AsyncTexImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params,
-    const base::Closure& bind_callback) {
-  bind_callback.Run();
-}
-
-void AsyncPixelTransferDelegateStub::AsyncTexSubImage2D(
-    const AsyncTexSubImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params) {
-}
-
-bool AsyncPixelTransferDelegateStub::TransferIsInProgress() {
-  return false;
-}
-
-void AsyncPixelTransferDelegateStub::WaitForTransferCompletion() {}
-
-AsyncPixelTransferManagerStub::AsyncPixelTransferManagerStub() {}
-
-AsyncPixelTransferManagerStub::~AsyncPixelTransferManagerStub() {}
-
-void AsyncPixelTransferManagerStub::BindCompletedAsyncTransfers() {
-}
-
-void AsyncPixelTransferManagerStub::AsyncNotifyCompletion(
-    const AsyncMemoryParams& mem_params,
-    AsyncPixelTransferCompletionObserver* observer) {
-  observer->DidComplete(mem_params);
-}
-
-uint32 AsyncPixelTransferManagerStub::GetTextureUploadCount() {
-  return 0;
-}
-
-base::TimeDelta AsyncPixelTransferManagerStub::GetTotalTextureUploadTime() {
-  return base::TimeDelta();
-}
-
-void AsyncPixelTransferManagerStub::ProcessMorePendingTransfers() {
-}
-
-bool AsyncPixelTransferManagerStub::NeedsProcessMorePendingTransfers() {
-  return false;
-}
-
-void AsyncPixelTransferManagerStub::WaitAllAsyncTexImage2D() {
-}
-
-AsyncPixelTransferDelegate*
-AsyncPixelTransferManagerStub::CreatePixelTransferDelegateImpl(
-    gles2::TextureRef* ref,
-    const AsyncTexImage2DParams& define_params) {
-  return new AsyncPixelTransferDelegateStub();
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.h b/gpu/command_buffer/service/async_pixel_transfer_manager_stub.h
deleted file mode 100644
index f8ced57..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_stub.h
+++ /dev/null
@@ -1,39 +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 GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_STUB_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_STUB_H_
-
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-namespace gpu {
-
-class AsyncPixelTransferManagerStub : public AsyncPixelTransferManager {
- public:
-  AsyncPixelTransferManagerStub();
-  ~AsyncPixelTransferManagerStub() override;
-
-  // AsyncPixelTransferManager implementation:
-  void BindCompletedAsyncTransfers() override;
-  void AsyncNotifyCompletion(
-      const AsyncMemoryParams& mem_params,
-      AsyncPixelTransferCompletionObserver* observer) override;
-  uint32 GetTextureUploadCount() override;
-  base::TimeDelta GetTotalTextureUploadTime() override;
-  void ProcessMorePendingTransfers() override;
-  bool NeedsProcessMorePendingTransfers() override;
-  void WaitAllAsyncTexImage2D() override;
-
- private:
-  // AsyncPixelTransferManager implementation:
-  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
-      gles2::TextureRef* ref,
-      const AsyncTexImage2DParams& define_params) override;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferManagerStub);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_STUB_H_
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_sync.cc
deleted file mode 100644
index 589598b..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.cc
+++ /dev/null
@@ -1,139 +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 "gpu/command_buffer/service/async_pixel_transfer_manager_sync.h"
-
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-
-namespace gpu {
-
-// Class which handles async pixel transfers synchronously.
-class AsyncPixelTransferDelegateSync : public AsyncPixelTransferDelegate {
- public:
-  explicit AsyncPixelTransferDelegateSync(
-      AsyncPixelTransferManagerSync::SharedState* shared_state);
-  ~AsyncPixelTransferDelegateSync() override;
-
-  // Implement AsyncPixelTransferDelegate:
-  void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
-                       const AsyncMemoryParams& mem_params,
-                       const base::Closure& bind_callback) override;
-  void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
-                          const AsyncMemoryParams& mem_params) override;
-  bool TransferIsInProgress() override;
-  void WaitForTransferCompletion() override;
-
- private:
-  // Safe to hold a raw pointer because SharedState is owned by the Manager
-  // which owns the Delegate.
-  AsyncPixelTransferManagerSync::SharedState* shared_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateSync);
-};
-
-AsyncPixelTransferDelegateSync::AsyncPixelTransferDelegateSync(
-    AsyncPixelTransferManagerSync::SharedState* shared_state)
-    : shared_state_(shared_state) {}
-
-AsyncPixelTransferDelegateSync::~AsyncPixelTransferDelegateSync() {}
-
-void AsyncPixelTransferDelegateSync::AsyncTexImage2D(
-    const AsyncTexImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params,
-    const base::Closure& bind_callback) {
-  // Save the define params to return later during deferred
-  // binding of the transfer texture.
-  void* data = mem_params.GetDataAddress();
-  base::TimeTicks begin_time(base::TimeTicks::Now());
-  glTexImage2D(
-      tex_params.target,
-      tex_params.level,
-      tex_params.internal_format,
-      tex_params.width,
-      tex_params.height,
-      tex_params.border,
-      tex_params.format,
-      tex_params.type,
-      data);
-  shared_state_->texture_upload_count++;
-  shared_state_->total_texture_upload_time +=
-      base::TimeTicks::Now() - begin_time;
-  // The texture is already fully bound so just call it now.
-  bind_callback.Run();
-}
-
-void AsyncPixelTransferDelegateSync::AsyncTexSubImage2D(
-    const AsyncTexSubImage2DParams& tex_params,
-    const AsyncMemoryParams& mem_params) {
-  void* data = mem_params.GetDataAddress();
-  base::TimeTicks begin_time(base::TimeTicks::Now());
-  glTexSubImage2D(
-      tex_params.target,
-      tex_params.level,
-      tex_params.xoffset,
-      tex_params.yoffset,
-      tex_params.width,
-      tex_params.height,
-      tex_params.format,
-      tex_params.type,
-      data);
-  shared_state_->texture_upload_count++;
-  shared_state_->total_texture_upload_time +=
-      base::TimeTicks::Now() - begin_time;
-}
-
-bool AsyncPixelTransferDelegateSync::TransferIsInProgress() {
-  // Already done.
-  return false;
-}
-
-void AsyncPixelTransferDelegateSync::WaitForTransferCompletion() {
-  // Already done.
-}
-
-AsyncPixelTransferManagerSync::SharedState::SharedState()
-    : texture_upload_count(0) {}
-
-AsyncPixelTransferManagerSync::SharedState::~SharedState() {}
-
-AsyncPixelTransferManagerSync::AsyncPixelTransferManagerSync() {}
-
-AsyncPixelTransferManagerSync::~AsyncPixelTransferManagerSync() {}
-
-void AsyncPixelTransferManagerSync::BindCompletedAsyncTransfers() {
-  // Everything is already bound.
-}
-
-void AsyncPixelTransferManagerSync::AsyncNotifyCompletion(
-    const AsyncMemoryParams& mem_params,
-    AsyncPixelTransferCompletionObserver* observer) {
-  observer->DidComplete(mem_params);
-}
-
-uint32 AsyncPixelTransferManagerSync::GetTextureUploadCount() {
-  return shared_state_.texture_upload_count;
-}
-
-base::TimeDelta AsyncPixelTransferManagerSync::GetTotalTextureUploadTime() {
-  return shared_state_.total_texture_upload_time;
-}
-
-void AsyncPixelTransferManagerSync::ProcessMorePendingTransfers() {
-}
-
-bool AsyncPixelTransferManagerSync::NeedsProcessMorePendingTransfers() {
-  return false;
-}
-
-void AsyncPixelTransferManagerSync::WaitAllAsyncTexImage2D() {
-}
-
-AsyncPixelTransferDelegate*
-AsyncPixelTransferManagerSync::CreatePixelTransferDelegateImpl(
-    gles2::TextureRef* ref,
-    const AsyncTexImage2DParams& define_params) {
-  return new AsyncPixelTransferDelegateSync(&shared_state_);
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.h b/gpu/command_buffer/service/async_pixel_transfer_manager_sync.h
deleted file mode 100644
index b965d6f..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_sync.h
+++ /dev/null
@@ -1,50 +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 GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_SYNC_H_
-#define GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_SYNC_H_
-
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-namespace gpu {
-
-class AsyncPixelTransferManagerSync : public AsyncPixelTransferManager {
- public:
-  AsyncPixelTransferManagerSync();
-  ~AsyncPixelTransferManagerSync() override;
-
-  // AsyncPixelTransferManager implementation:
-  void BindCompletedAsyncTransfers() override;
-  void AsyncNotifyCompletion(
-      const AsyncMemoryParams& mem_params,
-      AsyncPixelTransferCompletionObserver* observer) override;
-  uint32 GetTextureUploadCount() override;
-  base::TimeDelta GetTotalTextureUploadTime() override;
-  void ProcessMorePendingTransfers() override;
-  bool NeedsProcessMorePendingTransfers() override;
-  void WaitAllAsyncTexImage2D() override;
-
-  // State shared between Managers and Delegates.
-  struct SharedState {
-    SharedState();
-    ~SharedState();
-
-    int texture_upload_count;
-    base::TimeDelta total_texture_upload_time;
-  };
-
- private:
-  // AsyncPixelTransferManager implementation:
-  AsyncPixelTransferDelegate* CreatePixelTransferDelegateImpl(
-      gles2::TextureRef* ref,
-      const AsyncTexImage2DParams& define_params) override;
-
-  SharedState shared_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferManagerSync);
-};
-
-}  // namespace gpu
-
-#endif  // GPU_COMMAND_BUFFER_SERVICE_ASYNC_PIXEL_TRANSFER_MANAGER_SYNC_H_
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_win.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_win.cc
deleted file mode 100644
index dc106e8..0000000
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_win.cc
+++ /dev/null
@@ -1,30 +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 "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-
-#include "base/trace_event/trace_event.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_stub.h"
-#include "ui/gl/gl_implementation.h"
-
-namespace gpu {
-
-AsyncPixelTransferManager* AsyncPixelTransferManager::Create(
-    gfx::GLContext* context) {
-  TRACE_EVENT0("gpu", "AsyncPixelTransferManager::Create");
-  switch (gfx::GetGLImplementation()) {
-    case gfx::kGLImplementationOSMesaGL:
-    case gfx::kGLImplementationDesktopGL:
-    case gfx::kGLImplementationEGLGLES2:
-      return new AsyncPixelTransferManagerIdle(true);
-    case gfx::kGLImplementationMockGL:
-      return new AsyncPixelTransferManagerStub;
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-}
-
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index d41bbee..805cd70 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -29,8 +29,6 @@
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/mailbox.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
@@ -562,28 +560,6 @@ struct FenceCallback {
   scoped_ptr<gfx::GLFence> fence;
 };
 
-class AsyncUploadTokenCompletionObserver
-    : public AsyncPixelTransferCompletionObserver {
- public:
-  explicit AsyncUploadTokenCompletionObserver(uint32 async_upload_token)
-      : async_upload_token_(async_upload_token) {
-  }
-
-  void DidComplete(const AsyncMemoryParams& mem_params) override {
-    DCHECK(mem_params.buffer().get());
-    void* data = mem_params.GetDataAddress();
-    AsyncUploadSync* sync = static_cast<AsyncUploadSync*>(data);
-    sync->SetAsyncUploadToken(async_upload_token_);
-  }
-
- private:
-  ~AsyncUploadTokenCompletionObserver() override {}
-
-  uint32 async_upload_token_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncUploadTokenCompletionObserver);
-};
-
 // }  // anonymous namespace.
 
 // static
@@ -712,10 +688,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
   void SetShaderCacheCallback(const ShaderCacheCallback& callback) override;
   void SetWaitSyncPointCallback(const WaitSyncPointCallback& callback) override;
 
-  AsyncPixelTransferManager* GetAsyncPixelTransferManager() override;
-  void ResetAsyncPixelTransferManagerForTest() override;
-  void SetAsyncPixelTransferManagerForTest(
-      AsyncPixelTransferManager* manager) override;
   void SetIgnoreCachedStateForTest(bool ignore) override;
   void ProcessFinishedAsyncTransfers();
 
@@ -800,13 +772,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
   bool GenPathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool DeletePathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
 
-  // Helper for async upload token completion notification callback.
-  base::Closure AsyncUploadTokenCompletionClosure(uint32 async_upload_token,
-                                                  uint32 sync_data_shm_id,
-                                                  uint32 sync_data_shm_offset);
-
-
-
   // Workarounds
   void OnFboChanged() const;
   void OnUseFramebuffer() const;
@@ -1033,14 +998,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
       GLenum type,
       const void * data);
 
-  // Extra validation for async tex(Sub)Image2D.
-  bool ValidateAsyncTransfer(
-      const char* function_name,
-      TextureRef* texture_ref,
-      GLenum target,
-      GLint level,
-      const void * data);
-
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
       GLenum target,
@@ -2004,8 +1961,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
 
   ShaderCacheCallback shader_cache_callback_;
 
-  scoped_ptr<AsyncPixelTransferManager> async_pixel_transfer_manager_;
-
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
   bool back_buffer_has_depth_;
@@ -3074,10 +3029,6 @@ bool GLES2DecoderImpl::Initialize(
   if (!offscreen)
     context_->SetSafeToForceGpuSwitch();
 
-  async_pixel_transfer_manager_.reset(
-      AsyncPixelTransferManager::Create(context.get()));
-  async_pixel_transfer_manager_->Initialize(texture_manager());
-
   if (workarounds().gl_clear_broken) {
     DCHECK(!clear_framebuffer_blit_.get());
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glClearWorkaroundInit");
@@ -3635,13 +3586,6 @@ void GLES2DecoderImpl::ProcessFinishedAsyncTransfers() {
   ProcessPendingReadPixels(false);
   if (engine() && query_manager_.get())
     query_manager_->ProcessPendingTransferQueries();
-
-  // TODO(epenner): Is there a better place to do this?
-  // This needs to occur before we execute any batch of commands
-  // from the client, as the client may have recieved an async
-  // completion while issuing those commands.
-  // "DidFlushStart" would be ideal if we had such a callback.
-  async_pixel_transfer_manager_->BindCompletedAsyncTransfers();
 }
 
 static void RebindCurrentFramebuffer(
@@ -3992,20 +3936,6 @@ void GLES2DecoderImpl::SetWaitSyncPointCallback(
   wait_sync_point_callback_ = callback;
 }
 
-AsyncPixelTransferManager*
-    GLES2DecoderImpl::GetAsyncPixelTransferManager() {
-  return async_pixel_transfer_manager_.get();
-}
-
-void GLES2DecoderImpl::ResetAsyncPixelTransferManagerForTest() {
-  async_pixel_transfer_manager_.reset();
-}
-
-void GLES2DecoderImpl::SetAsyncPixelTransferManagerForTest(
-    AsyncPixelTransferManager* manager) {
-  async_pixel_transfer_manager_ = make_scoped_ptr(manager);
-}
-
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
   TextureRef* texture_ref = texture_manager()->GetTexture(client_texture_id);
@@ -4017,13 +3947,11 @@ bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
 }
 
 uint32 GLES2DecoderImpl::GetTextureUploadCount() {
-  return texture_state_.texture_upload_count +
-         async_pixel_transfer_manager_->GetTextureUploadCount();
+  return texture_state_.texture_upload_count;
 }
 
 base::TimeDelta GLES2DecoderImpl::GetTotalTextureUploadTime() {
-  return texture_state_.total_texture_upload_time +
-         async_pixel_transfer_manager_->GetTotalTextureUploadTime();
+  return texture_state_.total_texture_upload_time;
 }
 
 base::TimeDelta GLES2DecoderImpl::GetTotalProcessingCommandsTime() {
@@ -4168,10 +4096,6 @@ void GLES2DecoderImpl::Destroy(bool have_context) {
   fragment_translator_ = NULL;
   vertex_translator_ = NULL;
 
-  // Should destroy the transfer manager before the texture manager held
-  // by the context group.
-  async_pixel_transfer_manager_.reset();
-
   // Destroy the GPU Tracer which may own some in process GPU Timings.
   if (gpu_tracer_) {
     gpu_tracer_->Destroy(have_context);
@@ -10584,12 +10508,6 @@ void GLES2DecoderImpl::DoCopyTexSubImage2D(
         GL_INVALID_VALUE, "glCopyTexSubImage2D", "bad dimensions.");
     return;
   }
-  if (async_pixel_transfer_manager_->AsyncTransferIsInProgress(texture_ref)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glCopyTexSubImage2D", "async upload pending for texture");
-    return;
-  }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
@@ -10746,12 +10664,6 @@ bool GLES2DecoderImpl::ValidateTexSubImage2D(
         function_name, "type does not match type of texture.");
     return false;
   }
-  if (async_pixel_transfer_manager_->AsyncTransferIsInProgress(texture_ref)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        function_name, "async upload pending for texture");
-    return false;
-  }
   if (!texture->ValidForTexture(
           target, level, xoffset, yoffset, 0, width, height, 1, type)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "bad dimensions.");
@@ -12017,17 +11929,12 @@ void GLES2DecoderImpl::ProcessPendingReadPixels(bool did_finish) {
 
 bool GLES2DecoderImpl::HasMoreIdleWork() {
   return !pending_readpixel_fences_.empty() ||
-      async_pixel_transfer_manager_->NeedsProcessMorePendingTransfers() ||
-      gpu_tracer_->HasTracesToProcess();
+         gpu_tracer_->HasTracesToProcess();
 }
 
 void GLES2DecoderImpl::PerformIdleWork() {
   gpu_tracer_->ProcessTraces();
   ProcessPendingReadPixels(false);
-  if (!async_pixel_transfer_manager_->NeedsProcessMorePendingTransfers())
-    return;
-  async_pixel_transfer_manager_->ProcessMorePendingTransfers();
-  ProcessFinishedAsyncTransfers();
 }
 
 error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32 immediate_data_size,
@@ -12042,7 +11949,6 @@ error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32 immediate_data_size,
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
     case GL_LATENCY_QUERY_CHROMIUM:
-    case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     case GL_GET_ERROR_QUERY_CHROMIUM:
       break;
@@ -14052,312 +13958,6 @@ void GLES2DecoderImpl::DoMatrixLoadIdentityCHROMIUM(GLenum matrix_mode) {
   glMatrixLoadIdentityEXT(matrix_mode);
 }
 
-bool GLES2DecoderImpl::ValidateAsyncTransfer(
-    const char* function_name,
-    TextureRef* texture_ref,
-    GLenum target,
-    GLint level,
-    const void * data) {
-  // We only support async uploads to 2D textures for now.
-  if (GL_TEXTURE_2D != target) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
-    return false;
-  }
-  // We only support uploads to level zero for now.
-  if (level != 0) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "level != 0");
-    return false;
-  }
-  // A transfer buffer must be bound, even for asyncTexImage2D.
-  if (data == NULL) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name, "buffer == 0");
-    return false;
-  }
-  // We only support one async transfer in progress.
-  if (!texture_ref ||
-      async_pixel_transfer_manager_->AsyncTransferIsInProgress(texture_ref)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        function_name, "transfer already in progress");
-    return false;
-  }
-  return true;
-}
-
-base::Closure GLES2DecoderImpl::AsyncUploadTokenCompletionClosure(
-    uint32 async_upload_token,
-    uint32 sync_data_shm_id,
-    uint32 sync_data_shm_offset) {
-  scoped_refptr<gpu::Buffer> buffer = GetSharedMemoryBuffer(sync_data_shm_id);
-  if (!buffer.get() ||
-      !buffer->GetDataAddress(sync_data_shm_offset, sizeof(AsyncUploadSync)))
-    return base::Closure();
-
-  AsyncMemoryParams mem_params(buffer,
-                               sync_data_shm_offset,
-                               sizeof(AsyncUploadSync));
-
-  scoped_refptr<AsyncUploadTokenCompletionObserver> observer(
-      new AsyncUploadTokenCompletionObserver(async_upload_token));
-
-  return base::Bind(
-      &AsyncPixelTransferManager::AsyncNotifyCompletion,
-      base::Unretained(GetAsyncPixelTransferManager()),
-      mem_params,
-      observer);
-}
-
-error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::AsyncTexImage2DCHROMIUM& c =
-      *static_cast<const gles2::cmds::AsyncTexImage2DCHROMIUM*>(cmd_data);
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM");
-  GLenum target = static_cast<GLenum>(c.target);
-  GLint level = static_cast<GLint>(c.level);
-  GLenum internal_format = static_cast<GLenum>(c.internalformat);
-  GLsizei width = static_cast<GLsizei>(c.width);
-  GLsizei height = static_cast<GLsizei>(c.height);
-  GLint border = static_cast<GLint>(c.border);
-  GLenum format = static_cast<GLenum>(c.format);
-  GLenum type = static_cast<GLenum>(c.type);
-  uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
-  uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
-  uint32 pixels_size;
-  uint32 async_upload_token = static_cast<uint32>(c.async_upload_token);
-  uint32 sync_data_shm_id = static_cast<uint32>(c.sync_data_shm_id);
-  uint32 sync_data_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
-
-  base::ScopedClosureRunner scoped_completion_callback;
-  if (async_upload_token) {
-    base::Closure completion_closure =
-        AsyncUploadTokenCompletionClosure(async_upload_token,
-                                          sync_data_shm_id,
-                                          sync_data_shm_offset);
-    if (completion_closure.is_null())
-      return error::kInvalidArguments;
-
-    scoped_completion_callback.Reset(completion_closure);
-  }
-
-  // TODO(epenner): Move this and copies of this memory validation
-  // into ValidateTexImage2D step.
-  if (!GLES2Util::ComputeImageDataSizes(
-      width, height, 1, format, type, state_.unpack_alignment, &pixels_size,
-      NULL, NULL)) {
-    return error::kOutOfBounds;
-  }
-  const void* pixels = NULL;
-  if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
-    pixels = GetSharedMemoryAs<const void*>(
-        pixels_shm_id, pixels_shm_offset, pixels_size);
-    if (!pixels) {
-      return error::kOutOfBounds;
-    }
-  }
-
-  TextureManager::DoTexImageArguments args = {
-    target, level, internal_format, width, height, 1, border, format, type,
-    pixels, pixels_size, TextureManager::DoTexImageArguments::kTexImage2D };
-  TextureRef* texture_ref;
-  // All the normal glTexSubImage2D validation.
-  if (!texture_manager()->ValidateTexImage(
-      &state_, "glAsyncTexImage2DCHROMIUM", args, &texture_ref)) {
-    return error::kNoError;
-  }
-
-  // Extra async validation.
-  Texture* texture = texture_ref->texture();
-  if (!ValidateAsyncTransfer(
-      "glAsyncTexImage2DCHROMIUM", texture_ref, target, level, pixels))
-    return error::kNoError;
-
-  // Don't allow async redefinition of a textures.
-  if (texture->IsDefined()) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glAsyncTexImage2DCHROMIUM", "already defined");
-    return error::kNoError;
-  }
-
-  if (!EnsureGPUMemoryAvailable(pixels_size)) {
-    LOCAL_SET_GL_ERROR(
-        GL_OUT_OF_MEMORY, "glAsyncTexImage2DCHROMIUM", "out of memory");
-    return error::kNoError;
-  }
-
-  // Setup the parameters.
-  AsyncTexImage2DParams tex_params = {
-      target, level, static_cast<GLenum>(internal_format),
-      width, height, border, format, type};
-  AsyncMemoryParams mem_params(
-      GetSharedMemoryBuffer(c.pixels_shm_id), c.pixels_shm_offset, pixels_size);
-
-  // Set up the async state if needed, and make the texture
-  // immutable so the async state stays valid. The level info
-  // is set up lazily when the transfer completes.
-  AsyncPixelTransferDelegate* delegate =
-      async_pixel_transfer_manager_->CreatePixelTransferDelegate(texture_ref,
-                                                                 tex_params);
-  texture->SetImmutable(true);
-
-  delegate->AsyncTexImage2D(
-      tex_params,
-      mem_params,
-      base::Bind(&TextureManager::SetLevelInfoFromParams,
-                 // The callback is only invoked if the transfer delegate still
-                 // exists, which implies through manager->texture_ref->state
-                 // ownership that both of these pointers are valid.
-                 base::Unretained(texture_manager()),
-                 base::Unretained(texture_ref),
-                 tex_params));
-  return error::kNoError;
-}
-
-error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::AsyncTexSubImage2DCHROMIUM& c =
-      *static_cast<const gles2::cmds::AsyncTexSubImage2DCHROMIUM*>(cmd_data);
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
-  GLenum target = static_cast<GLenum>(c.target);
-  GLint level = static_cast<GLint>(c.level);
-  GLint xoffset = static_cast<GLint>(c.xoffset);
-  GLint yoffset = static_cast<GLint>(c.yoffset);
-  GLsizei width = static_cast<GLsizei>(c.width);
-  GLsizei height = static_cast<GLsizei>(c.height);
-  GLenum format = static_cast<GLenum>(c.format);
-  GLenum type = static_cast<GLenum>(c.type);
-  uint32 async_upload_token = static_cast<uint32>(c.async_upload_token);
-  uint32 sync_data_shm_id = static_cast<uint32>(c.sync_data_shm_id);
-  uint32 sync_data_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
-
-  base::ScopedClosureRunner scoped_completion_callback;
-  if (async_upload_token) {
-    base::Closure completion_closure =
-        AsyncUploadTokenCompletionClosure(async_upload_token,
-                                          sync_data_shm_id,
-                                          sync_data_shm_offset);
-    if (completion_closure.is_null())
-      return error::kInvalidArguments;
-
-    scoped_completion_callback.Reset(completion_closure);
-  }
-
-  // TODO(epenner): Move this and copies of this memory validation
-  // into ValidateTexSubImage2D step.
-  uint32 data_size;
-  if (!GLES2Util::ComputeImageDataSizes(
-      width, height, 1, format, type, state_.unpack_alignment, &data_size,
-      NULL, NULL)) {
-    return error::kOutOfBounds;
-  }
-  const void* pixels = GetSharedMemoryAs<const void*>(
-      c.data_shm_id, c.data_shm_offset, data_size);
-
-  // All the normal glTexSubImage2D validation.
-  error::Error error = error::kNoError;
-  if (!ValidateTexSubImage2D(&error, "glAsyncTexSubImage2DCHROMIUM",
-      target, level, xoffset, yoffset, width, height, format, type, pixels)) {
-    return error;
-  }
-
-  // Extra async validation.
-  TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
-      &state_, target);
-  Texture* texture = texture_ref->texture();
-  if (!ValidateAsyncTransfer(
-         "glAsyncTexSubImage2DCHROMIUM", texture_ref, target, level, pixels))
-    return error::kNoError;
-
-  // Guarantee async textures are always 'cleared' as follows:
-  // - AsyncTexImage2D can not redefine an existing texture
-  // - AsyncTexImage2D must initialize the entire image via non-null buffer.
-  // - AsyncTexSubImage2D clears synchronously if not already cleared.
-  // - Textures become immutable after an async call.
-  // This way we know in all cases that an async texture is always clear.
-  if (!texture->SafeToRenderFrom()) {
-    if (!texture_manager()->ClearTextureLevel(this, texture_ref,
-                                              target, level)) {
-      LOCAL_SET_GL_ERROR(
-          GL_OUT_OF_MEMORY,
-          "glAsyncTexSubImage2DCHROMIUM", "dimensions too big");
-      return error::kNoError;
-    }
-  }
-
-  // Setup the parameters.
-  AsyncTexSubImage2DParams tex_params = {target, level, xoffset, yoffset,
-                                              width, height, format, type};
-  AsyncMemoryParams mem_params(
-      GetSharedMemoryBuffer(c.data_shm_id), c.data_shm_offset, data_size);
-  AsyncPixelTransferDelegate* delegate =
-      async_pixel_transfer_manager_->GetPixelTransferDelegate(texture_ref);
-  if (!delegate) {
-    // TODO(epenner): We may want to enforce exclusive use
-    // of async APIs in which case this should become an error,
-    // (the texture should have been async defined).
-    AsyncTexImage2DParams define_params = {target, level,
-                                                0, 0, 0, 0, 0, 0};
-    texture->GetLevelSize(
-        target, level, &define_params.width, &define_params.height, nullptr);
-    texture->GetLevelType(
-        target, level, &define_params.type, &define_params.internal_format);
-    // Set up the async state if needed, and make the texture
-    // immutable so the async state stays valid.
-    delegate = async_pixel_transfer_manager_->CreatePixelTransferDelegate(
-        texture_ref, define_params);
-    texture->SetImmutable(true);
-  }
-
-  delegate->AsyncTexSubImage2D(tex_params, mem_params);
-  return error::kNoError;
-}
-
-error::Error GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::WaitAsyncTexImage2DCHROMIUM& c =
-      *static_cast<const gles2::cmds::WaitAsyncTexImage2DCHROMIUM*>(cmd_data);
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM");
-  GLenum target = static_cast<GLenum>(c.target);
-
-  if (GL_TEXTURE_2D != target) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_ENUM, "glWaitAsyncTexImage2DCHROMIUM", "target");
-    return error::kNoError;
-  }
-  TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
-      &state_, target);
-  if (!texture_ref) {
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_OPERATION,
-          "glWaitAsyncTexImage2DCHROMIUM", "unknown texture");
-    return error::kNoError;
-  }
-  AsyncPixelTransferDelegate* delegate =
-      async_pixel_transfer_manager_->GetPixelTransferDelegate(texture_ref);
-  if (!delegate) {
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_OPERATION,
-          "glWaitAsyncTexImage2DCHROMIUM", "No async transfer started");
-    return error::kNoError;
-  }
-  delegate->WaitForTransferCompletion();
-  ProcessFinishedAsyncTransfers();
-  return error::kNoError;
-}
-
-error::Error GLES2DecoderImpl::HandleWaitAllAsyncTexImage2DCHROMIUM(
-    uint32 immediate_data_size,
-    const void* data) {
-  TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM");
-
-  GetAsyncPixelTransferManager()->WaitAllAsyncTexImage2D();
-  ProcessFinishedAsyncTransfers();
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniformBlockBinding(
     uint32_t immediate_data_size, const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.h b/gpu/command_buffer/service/gles2_cmd_decoder.h
index 79ecb2c..be24077 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.h
@@ -30,7 +30,6 @@ class Size;
 
 namespace gpu {
 
-class AsyncPixelTransferManager;
 struct Mailbox;
 
 namespace gles2 {
@@ -201,12 +200,6 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
   virtual void SetResizeCallback(
       const base::Callback<void(gfx::Size, float)>& callback) = 0;
 
-  // Interface to performing async pixel transfers.
-  virtual AsyncPixelTransferManager* GetAsyncPixelTransferManager() = 0;
-  virtual void ResetAsyncPixelTransferManagerForTest() = 0;
-  virtual void SetAsyncPixelTransferManagerForTest(
-      AsyncPixelTransferManager* manager) = 0;
-
   // Get the service texture ID corresponding to a client texture ID.
   // If no such record is found then return false.
   virtual bool GetServiceTextureId(uint32 client_texture_id,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
index 0c71d48..2f79a3d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
@@ -83,13 +83,6 @@ class MockGLES2Decoder : public GLES2Decoder {
   MOCK_METHOD0(GetValuebufferManager, gpu::gles2::ValuebufferManager*());
   MOCK_METHOD1(
       SetResizeCallback, void(const base::Callback<void(gfx::Size, float)>&));
-  MOCK_METHOD0(GetAsyncPixelTransferDelegate,
-      AsyncPixelTransferDelegate*());
-  MOCK_METHOD0(GetAsyncPixelTransferManager,
-      AsyncPixelTransferManager*());
-  MOCK_METHOD0(ResetAsyncPixelTransferManagerForTest, void());
-  MOCK_METHOD1(SetAsyncPixelTransferManagerForTest,
-      void(AsyncPixelTransferManager*));
   MOCK_METHOD1(SetIgnoreCachedStateForTest, void(bool ignore));
   MOCK_METHOD1(SetAllowExit, void(bool allow));
   MOCK_METHOD3(DoCommand, error::Error(unsigned int command,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index fcf39ed..b66d675 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -8,9 +8,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
@@ -569,7 +566,6 @@ struct QueryType {
 const QueryType kQueryTypes[] = {
     {GL_COMMANDS_ISSUED_CHROMIUM, false},
     {GL_LATENCY_QUERY_CHROMIUM, false},
-    {GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM, false},
     {GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, false},
     {GL_GET_ERROR_QUERY_CHROMIUM, false},
     {GL_COMMANDS_COMPLETED_CHROMIUM, false},
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 3f4f390..4c7afcc 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
@@ -456,14 +456,6 @@ TEST_P(GLES2DecoderTest3, IsValuebufferCHROMIUMInvalidArgsBadSharedMemoryId) {
 // TODO(gman): TraceBeginCHROMIUM
 
 // TODO(gman): TraceEndCHROMIUM
-// TODO(gman): AsyncTexSubImage2DCHROMIUM
-
-// TODO(gman): AsyncTexImage2DCHROMIUM
-
-// TODO(gman): WaitAsyncTexImage2DCHROMIUM
-
-// TODO(gman): WaitAllAsyncTexImage2DCHROMIUM
-
 // TODO(gman): LoseContextCHROMIUM
 // TODO(gman): InsertSyncPointCHROMIUM
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc
deleted file mode 100644
index 168740e..0000000
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc
+++ /dev/null
@@ -1,388 +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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
-
-#include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
-#include "gpu/command_buffer/common/gles2_cmd_format.h"
-#include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/common/id_allocator.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
-#include "gpu/command_buffer/service/cmd_buffer_engine.h"
-#include "gpu/command_buffer/service/context_group.h"
-#include "gpu/command_buffer/service/context_state.h"
-#include "gpu/command_buffer/service/gl_surface_mock.h"
-#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
-
-#include "gpu/command_buffer/service/gpu_switches.h"
-#include "gpu/command_buffer/service/image_manager.h"
-#include "gpu/command_buffer/service/mailbox_manager.h"
-#include "gpu/command_buffer/service/mocks.h"
-#include "gpu/command_buffer/service/program_manager.h"
-#include "gpu/command_buffer/service/test_helper.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/gl/gl_implementation.h"
-#include "ui/gl/gl_mock.h"
-#include "ui/gl/gl_surface_stub.h"
-
-#if !defined(GL_DEPTH24_STENCIL8)
-#define GL_DEPTH24_STENCIL8 0x88F0
-#endif
-
-using ::gfx::MockGLInterface;
-using ::testing::_;
-using ::testing::DoAll;
-using ::testing::InSequence;
-using ::testing::Invoke;
-using ::testing::MatcherCast;
-using ::testing::Mock;
-using ::testing::Pointee;
-using ::testing::Return;
-using ::testing::SaveArg;
-using ::testing::SetArrayArgument;
-using ::testing::SetArgumentPointee;
-using ::testing::SetArgPointee;
-using ::testing::StrEq;
-using ::testing::StrictMock;
-
-namespace gpu {
-namespace gles2 {
-
-using namespace cmds;
-
-TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
-  InitState init;
-  init.extensions = "GL_CHROMIUM_async_pixel_transfers";
-  init.bind_generates_resource = true;
-  InitDecoder(init);
-
-  // Set up the texture.
-  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-  TextureRef* texture_ref = GetTexture(client_texture_id_);
-  Texture* texture = texture_ref->texture();
-
-  // Set a mock Async delegate
-  StrictMock<gpu::MockAsyncPixelTransferManager>* manager =
-      new StrictMock<gpu::MockAsyncPixelTransferManager>;
-  manager->Initialize(group().texture_manager());
-  decoder_->SetAsyncPixelTransferManagerForTest(manager);
-  StrictMock<gpu::MockAsyncPixelTransferDelegate>* delegate = NULL;
-
-  // Tex(Sub)Image2D upload commands.
-  AsyncTexImage2DCHROMIUM teximage_cmd;
-  teximage_cmd.Init(GL_TEXTURE_2D,
-                    0,
-                    GL_RGBA,
-                    8,
-                    8,
-                    GL_RGBA,
-                    GL_UNSIGNED_BYTE,
-                    kSharedMemoryId,
-                    kSharedMemoryOffset,
-                    0,
-                    0,
-                    0);
-  AsyncTexSubImage2DCHROMIUM texsubimage_cmd;
-  texsubimage_cmd.Init(GL_TEXTURE_2D,
-                       0,
-                       0,
-                       0,
-                       8,
-                       8,
-                       GL_RGBA,
-                       GL_UNSIGNED_BYTE,
-                       kSharedMemoryId,
-                       kSharedMemoryOffset,
-                       0,
-                       0,
-                       0);
-  WaitAsyncTexImage2DCHROMIUM wait_cmd;
-  wait_cmd.Init(GL_TEXTURE_2D);
-  WaitAllAsyncTexImage2DCHROMIUM wait_all_cmd;
-  wait_all_cmd.Init();
-
-  // No transfer state exists initially.
-  EXPECT_FALSE(
-      decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-          texture_ref));
-
-  base::Closure bind_callback;
-
-  // AsyncTexImage2D
-  {
-    // Create transfer state since it doesn't exist.
-    EXPECT_EQ(texture_ref->num_observers(), 0);
-    EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
-        .WillOnce(Return(
-            delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _))
-        .WillOnce(SaveArg<2>(&bind_callback))
-        .RetiresOnSaturation();
-    // Command succeeds.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_EQ(
-        delegate,
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-    EXPECT_TRUE(texture->IsImmutable());
-    // The texture is safe but the level has not been defined yet.
-    EXPECT_TRUE(texture->SafeToRenderFrom());
-    GLsizei width, height;
-    EXPECT_FALSE(
-        texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
-    EXPECT_EQ(texture_ref->num_observers(), 1);
-  }
-  {
-    // Async redefinitions are not allowed!
-    // Command fails.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
-    EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
-    EXPECT_EQ(
-        delegate,
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-    EXPECT_TRUE(texture->IsImmutable());
-    EXPECT_TRUE(texture->SafeToRenderFrom());
-  }
-
-  // Binding/defining of the async transfer
-  {
-    // TODO(epenner): We should check that the manager gets the
-    // BindCompletedAsyncTransfers() call, which is required to
-    // guarantee the delegate calls the bind callback.
-
-    // Simulate the bind callback from the delegate.
-    bind_callback.Run();
-
-    // After the bind callback is run, the texture is safe,
-    // and has the right size etc.
-    EXPECT_TRUE(texture->SafeToRenderFrom());
-    GLsizei width, height;
-    EXPECT_TRUE(
-        texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
-    EXPECT_EQ(width, 8);
-    EXPECT_EQ(height, 8);
-  }
-
-  // AsyncTexSubImage2D
-  EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
-  decoder_->GetAsyncPixelTransferManager()->ClearPixelTransferDelegateForTest(
-      texture_ref);
-  EXPECT_EQ(texture_ref->num_observers(), 0);
-  texture->SetImmutable(false);
-  {
-    // Create transfer state since it doesn't exist.
-    EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
-        .WillOnce(Return(
-            delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*delegate, AsyncTexSubImage2D(_, _)).RetiresOnSaturation();
-    // Command succeeds.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_EQ(
-        delegate,
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-    EXPECT_TRUE(texture->IsImmutable());
-    EXPECT_TRUE(texture->SafeToRenderFrom());
-  }
-  {
-    // No transfer is in progress.
-    EXPECT_CALL(*delegate, TransferIsInProgress())
-        .WillOnce(Return(false))  // texSubImage validation
-        .WillOnce(Return(false))  // async validation
-        .RetiresOnSaturation();
-    EXPECT_CALL(*delegate, AsyncTexSubImage2D(_, _)).RetiresOnSaturation();
-    // Command succeeds.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_EQ(
-        delegate,
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-    EXPECT_TRUE(texture->IsImmutable());
-    EXPECT_TRUE(texture->SafeToRenderFrom());
-  }
-  {
-    // A transfer is still in progress!
-    EXPECT_CALL(*delegate, TransferIsInProgress())
-        .WillOnce(Return(true))
-        .RetiresOnSaturation();
-    // No async call, command fails.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
-    EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
-    EXPECT_EQ(
-        delegate,
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-    EXPECT_TRUE(texture->IsImmutable());
-    EXPECT_TRUE(texture->SafeToRenderFrom());
-  }
-
-  // Delete delegate on DeleteTexture.
-  {
-    EXPECT_EQ(texture_ref->num_observers(), 1);
-    EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
-    DoDeleteTexture(client_texture_id_, kServiceTextureId);
-    EXPECT_FALSE(
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-    texture = NULL;
-    texture_ref = NULL;
-    delegate = NULL;
-  }
-
-  // WaitAsyncTexImage2D
-  {
-    // Get a fresh texture since the existing texture cannot be respecified
-    // asynchronously and AsyncTexSubImage2D does not involve binding.
-    EXPECT_CALL(*gl_, GenTextures(1, _))
-        .WillOnce(SetArgumentPointee<1>(kServiceTextureId));
-    DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-    texture_ref = GetTexture(client_texture_id_);
-    texture = texture_ref->texture();
-    texture->SetImmutable(false);
-    // Create transfer state since it doesn't exist.
-    EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
-        .WillOnce(Return(
-            delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _)).RetiresOnSaturation();
-    // Start async transfer.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_EQ(
-        delegate,
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-
-    EXPECT_TRUE(texture->IsImmutable());
-    // Wait for completion.
-    EXPECT_CALL(*delegate, WaitForTransferCompletion());
-    EXPECT_CALL(*manager, BindCompletedAsyncTransfers());
-    EXPECT_EQ(error::kNoError, ExecuteCmd(wait_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  }
-
-  // WaitAllAsyncTexImage2D
-  EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
-  DoDeleteTexture(client_texture_id_, kServiceTextureId);
-  EXPECT_FALSE(
-      decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-          texture_ref));
-  texture = NULL;
-  texture_ref = NULL;
-  delegate = NULL;
-  {
-    // Get a fresh texture since the existing texture cannot be respecified
-    // asynchronously and AsyncTexSubImage2D does not involve binding.
-    EXPECT_CALL(*gl_, GenTextures(1, _))
-        .WillOnce(SetArgumentPointee<1>(kServiceTextureId));
-    DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-    texture_ref = GetTexture(client_texture_id_);
-    texture = texture_ref->texture();
-    texture->SetImmutable(false);
-    // Create transfer state since it doesn't exist.
-    EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
-        .WillOnce(Return(
-            delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _)).RetiresOnSaturation();
-    // Start async transfer.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_EQ(
-        delegate,
-        decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-            texture_ref));
-
-    EXPECT_TRUE(texture->IsImmutable());
-    // Wait for completion of all uploads.
-    EXPECT_CALL(*manager, WaitAllAsyncTexImage2D()).RetiresOnSaturation();
-    EXPECT_CALL(*manager, BindCompletedAsyncTransfers());
-    EXPECT_EQ(error::kNoError, ExecuteCmd(wait_all_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  }
-
-  // Remove PixelTransferManager before the decoder destroys.
-  EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
-  decoder_->ResetAsyncPixelTransferManagerForTest();
-  manager = NULL;
-}
-
-TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
-  InitState init;
-  init.extensions = "GL_CHROMIUM_async_pixel_transfers";
-  init.bind_generates_resource = true;
-  InitDecoder(init);
-
-  // Set up the texture.
-  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-  TextureRef* texture_ref = GetTexture(client_texture_id_);
-
-  // Set a mock Async delegate.
-  StrictMock<gpu::MockAsyncPixelTransferManager>* manager =
-      new StrictMock<gpu::MockAsyncPixelTransferManager>;
-  manager->Initialize(group().texture_manager());
-  decoder_->SetAsyncPixelTransferManagerForTest(manager);
-  StrictMock<gpu::MockAsyncPixelTransferDelegate>* delegate = NULL;
-
-  AsyncTexImage2DCHROMIUM teximage_cmd;
-  teximage_cmd.Init(GL_TEXTURE_2D,
-                    0,
-                    GL_RGBA,
-                    8,
-                    8,
-                    GL_RGBA,
-                    GL_UNSIGNED_BYTE,
-                    kSharedMemoryId,
-                    kSharedMemoryOffset,
-                    0,
-                    0,
-                    0);
-
-  // No transfer delegate exists initially.
-  EXPECT_FALSE(
-      decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-          texture_ref));
-
-  // Create delegate on AsyncTexImage2D.
-  {
-    EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
-        .WillOnce(Return(
-            delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
-        .RetiresOnSaturation();
-    EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _)).RetiresOnSaturation();
-
-    // Command succeeds.
-    EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  }
-
-  // Delegate is cached.
-  EXPECT_EQ(delegate,
-            decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
-                texture_ref));
-
-  // Delete delegate on manager teardown.
-  {
-    EXPECT_EQ(texture_ref->num_observers(), 1);
-    EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
-    decoder_->ResetAsyncPixelTransferManagerForTest();
-    manager = NULL;
-
-    // Texture ref still valid.
-    EXPECT_EQ(texture_ref, GetTexture(client_texture_id_));
-    EXPECT_EQ(texture_ref->num_observers(), 0);
-  }
-}
-
-}  // namespace gles2
-}  // namespace gpu
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
index cd39253..e854f53 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
@@ -8,9 +8,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc
index 3578b5b..b1ddbba 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc
@@ -8,9 +8,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc
index 579e84b..932e851 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc
@@ -8,9 +8,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
index 685f30d..fafe2b9 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
@@ -8,9 +8,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
index 9c3d775..f22d269 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
@@ -8,9 +8,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
index d688bc3..3f09fc2 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
@@ -9,9 +9,6 @@
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/id_allocator.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
index d2a089d..04a3ea5 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
@@ -505,7 +505,6 @@ static const GLenum valid_query_target_table[] = {
     GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
     GL_COMMANDS_ISSUED_CHROMIUM,
     GL_LATENCY_QUERY_CHROMIUM,
-    GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
     GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM,
     GL_COMMANDS_COMPLETED_CHROMIUM,
 };
diff --git a/gpu/command_buffer/service/query_manager.cc b/gpu/command_buffer/service/query_manager.cc
index a269f35..a228ae0 100644
--- a/gpu/command_buffer/service/query_manager.cc
+++ b/gpu/command_buffer/service/query_manager.cc
@@ -12,10 +12,10 @@
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gpu_timing.h"
@@ -23,137 +23,6 @@
 namespace gpu {
 namespace gles2 {
 
-namespace {
-
-class AsyncPixelTransferCompletionObserverImpl
-    : public AsyncPixelTransferCompletionObserver {
- public:
-  AsyncPixelTransferCompletionObserverImpl(base::subtle::Atomic32 submit_count)
-      : submit_count_(submit_count), cancelled_(false) {}
-
-  void Cancel() {
-    base::AutoLock locked(lock_);
-    cancelled_ = true;
-  }
-
-  void DidComplete(const AsyncMemoryParams& mem_params) override {
-    base::AutoLock locked(lock_);
-    if (!cancelled_) {
-      DCHECK(mem_params.buffer().get());
-      void* data = mem_params.GetDataAddress();
-      QuerySync* sync = static_cast<QuerySync*>(data);
-      base::subtle::Release_Store(&sync->process_count, submit_count_);
-    }
-  }
-
- private:
-  ~AsyncPixelTransferCompletionObserverImpl() override {}
-
-  base::subtle::Atomic32 submit_count_;
-
-  base::Lock lock_;
-  bool cancelled_;
-
-  DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferCompletionObserverImpl);
-};
-
-class AsyncPixelTransfersCompletedQuery
-    : public QueryManager::Query,
-      public base::SupportsWeakPtr<AsyncPixelTransfersCompletedQuery> {
- public:
-  AsyncPixelTransfersCompletedQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
-
-  bool Begin() override;
-  bool End(base::subtle::Atomic32 submit_count) override;
-  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
-  void Pause() override;
-  void Resume() override;
-  bool Process(bool did_finish) override;
-  void Destroy(bool have_context) override;
-
- protected:
-  ~AsyncPixelTransfersCompletedQuery() override;
-
-  scoped_refptr<AsyncPixelTransferCompletionObserverImpl> observer_;
-};
-
-AsyncPixelTransfersCompletedQuery::AsyncPixelTransfersCompletedQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset) {
-}
-
-bool AsyncPixelTransfersCompletedQuery::Begin() {
-  MarkAsActive();
-  return true;
-}
-
-void AsyncPixelTransfersCompletedQuery::Pause() {
-  MarkAsPaused();
-}
-
-void AsyncPixelTransfersCompletedQuery::Resume() {
-  MarkAsActive();
-}
-
-bool AsyncPixelTransfersCompletedQuery::End(
-    base::subtle::Atomic32 submit_count) {
-  // Get the real shared memory since it might need to be duped to prevent
-  // use-after-free of the memory.
-  scoped_refptr<Buffer> buffer =
-      manager()->decoder()->GetSharedMemoryBuffer(shm_id());
-  if (!buffer.get())
-    return false;
-  AsyncMemoryParams mem_params(buffer, shm_offset(), sizeof(QuerySync));
-  if (!mem_params.GetDataAddress())
-    return false;
-
-  observer_ = new AsyncPixelTransferCompletionObserverImpl(submit_count);
-
-  // Ask AsyncPixelTransferDelegate to run completion callback after all
-  // previous async transfers are done. No guarantee that callback is run
-  // on the current thread.
-  manager()->decoder()->GetAsyncPixelTransferManager()->AsyncNotifyCompletion(
-      mem_params, observer_.get());
-
-  return AddToPendingTransferQueue(submit_count);
-}
-
-bool AsyncPixelTransfersCompletedQuery::QueryCounter(
-    base::subtle::Atomic32 submit_count) {
-  NOTREACHED();
-  return false;
-}
-
-bool AsyncPixelTransfersCompletedQuery::Process(bool did_finish) {
-  QuerySync* sync = manager()->decoder()->GetSharedMemoryAs<QuerySync*>(
-      shm_id(), shm_offset(), sizeof(*sync));
-  if (!sync)
-    return false;
-
-  // Check if completion callback has been run. sync->process_count atomicity
-  // is guaranteed as this is already used to notify client of a completed
-  // query.
-  if (base::subtle::Acquire_Load(&sync->process_count) != submit_count())
-    return true;
-
-  UnmarkAsPending();
-  return true;
-}
-
-void AsyncPixelTransfersCompletedQuery::Destroy(bool /* have_context */) {
-  if (!IsDeleted()) {
-    MarkAsDeleted();
-  }
-}
-
-AsyncPixelTransfersCompletedQuery::~AsyncPixelTransfersCompletedQuery() {
-  if (observer_.get())
-    observer_->Cancel();
-}
-
-}  // namespace
-
 class AllSamplesPassedQuery : public QueryManager::Query {
  public:
   AllSamplesPassedQuery(
@@ -820,11 +689,6 @@ QueryManager::Query* QueryManager::CreateQuery(
     case GL_LATENCY_QUERY_CHROMIUM:
       query = new CommandLatencyQuery(this, target, shm_id, shm_offset);
       break;
-    case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
-      // Currently async pixel transfer delegates only support uploads.
-      query = new AsyncPixelTransfersCompletedQuery(
-          this, target, shm_id, shm_offset);
-      break;
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
       query = new AsyncReadPixelsCompletedQuery(
           this, target, shm_id, shm_offset);
diff --git a/gpu/command_buffer/service/texture_manager.h b/gpu/command_buffer/service/texture_manager.h
index 976213b..a255ad4 100644
--- a/gpu/command_buffer/service/texture_manager.h
+++ b/gpu/command_buffer/service/texture_manager.h
@@ -13,7 +13,6 @@
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
-#include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/gpu_export.h"
@@ -679,15 +678,6 @@ class GPU_EXPORT TextureManager : public base::trace_event::MemoryDumpProvider {
                     GLenum type,
                     const gfx::Rect& cleared_rect);
 
-  // Adapter to call above function.
-  void SetLevelInfoFromParams(TextureRef* ref,
-                              const gpu::AsyncTexImage2DParams& params) {
-    SetLevelInfo(ref, params.target, params.level, params.internal_format,
-                 params.width, params.height, 1 /* depth */, params.border,
-                 params.format, params.type,
-                 gfx::Rect(params.width, params.height) /* cleared_rect */);
-  }
-
   Texture* Produce(TextureRef* ref);
 
   // Maps an existing texture into the texture manager, at a given client ID.
diff --git a/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc b/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc
index 6072177..a0e4d54 100644
--- a/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc
+++ b/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc
@@ -304,10 +304,6 @@ TEST_F(GLVirtualContextsTest, VirtualQueries) {
   const GLenum query_targets[] = {
     GL_ANY_SAMPLES_PASSED_EXT,
     GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
-    // TODO(dyen): (http://crbug.com/514124) Figure out a way to test this,
-    // the function AsyncPixelTransferManagerEGL::AsyncNotifyCompletion
-    // completes asynchronously.
-    // GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
     GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM,
     GL_COMMANDS_COMPLETED_CHROMIUM,
     GL_COMMANDS_ISSUED_CHROMIUM,
diff --git a/gpu/command_buffer_service.gypi b/gpu/command_buffer_service.gypi
index 699480e..4735332 100644
--- a/gpu/command_buffer_service.gypi
+++ b/gpu/command_buffer_service.gypi
@@ -26,22 +26,6 @@
     '<(angle_path)/src/angle.gyp:translator',
   ],
   'sources': [
-    'command_buffer/service/async_pixel_transfer_delegate.cc',
-    'command_buffer/service/async_pixel_transfer_delegate.h',
-    'command_buffer/service/async_pixel_transfer_manager.cc',
-    'command_buffer/service/async_pixel_transfer_manager.h',
-    'command_buffer/service/async_pixel_transfer_manager_android.cc',
-    'command_buffer/service/async_pixel_transfer_manager_idle.cc',
-    'command_buffer/service/async_pixel_transfer_manager_idle.h',
-    'command_buffer/service/async_pixel_transfer_manager_linux.cc',
-    'command_buffer/service/async_pixel_transfer_manager_mac.cc',
-    'command_buffer/service/async_pixel_transfer_manager_share_group.cc',
-    'command_buffer/service/async_pixel_transfer_manager_share_group.h',
-    'command_buffer/service/async_pixel_transfer_manager_stub.cc',
-    'command_buffer/service/async_pixel_transfer_manager_stub.h',
-    'command_buffer/service/async_pixel_transfer_manager_sync.cc',
-    'command_buffer/service/async_pixel_transfer_manager_sync.h',
-    'command_buffer/service/async_pixel_transfer_manager_win.cc',
     'command_buffer/service/buffer_manager.cc',
     'command_buffer/service/buffer_manager.h',
     'command_buffer/service/cmd_buffer_engine.h',
@@ -156,11 +140,5 @@
         ],
       },
     }],
-    ['OS in ("win", "android") or (OS == "linux" and use_x11 == 1)', {
-      'sources': [
-        'command_buffer/service/async_pixel_transfer_manager_egl.cc',
-        'command_buffer/service/async_pixel_transfer_manager_egl.h',
-      ],
-    }],
   ],
 }
diff --git a/gpu/gpu.gyp b/gpu/gpu.gyp
index bbc4fae..225d5fa 100644
--- a/gpu/gpu.gyp
+++ b/gpu/gpu.gyp
@@ -195,10 +195,6 @@
         'command_buffer/common/id_allocator_test.cc',
         'command_buffer/common/trace_event.h',
         'command_buffer/common/unittest_main.cc',
-        'command_buffer/service/async_pixel_transfer_delegate_mock.cc',
-        'command_buffer/service/async_pixel_transfer_delegate_mock.h',
-        'command_buffer/service/async_pixel_transfer_manager_mock.cc',
-        'command_buffer/service/async_pixel_transfer_manager_mock.h',
         'command_buffer/service/buffer_manager_unittest.cc',
         'command_buffer/service/cmd_parser_test.cc',
         'command_buffer/service/command_buffer_service_unittest.cc',
@@ -220,7 +216,6 @@
         'command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h',
         'command_buffer/service/gles2_cmd_decoder_unittest_3.cc',
         'command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h',
-        'command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc',
         'command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc',
         'command_buffer/service/gles2_cmd_decoder_unittest_base.cc',
         'command_buffer/service/gles2_cmd_decoder_unittest_base.h',
diff --git a/mojo/gpu/mojo_gles2_impl_autogen.cc b/mojo/gpu/mojo_gles2_impl_autogen.cc
index a3529b1..55e8ba6 100644
--- a/mojo/gpu/mojo_gles2_impl_autogen.cc
+++ b/mojo/gpu/mojo_gles2_impl_autogen.cc
@@ -1605,34 +1605,6 @@ void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
 void MojoGLES2Impl::TraceEndCHROMIUM() {
   NOTREACHED() << "Unimplemented TraceEndCHROMIUM.";
 }
-void MojoGLES2Impl::AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                               GLint level,
-                                               GLint xoffset,
-                                               GLint yoffset,
-                                               GLsizei width,
-                                               GLsizei height,
-                                               GLenum format,
-                                               GLenum type,
-                                               const void* data) {
-  NOTREACHED() << "Unimplemented AsyncTexSubImage2DCHROMIUM.";
-}
-void MojoGLES2Impl::AsyncTexImage2DCHROMIUM(GLenum target,
-                                            GLint level,
-                                            GLenum internalformat,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLint border,
-                                            GLenum format,
-                                            GLenum type,
-                                            const void* pixels) {
-  NOTREACHED() << "Unimplemented AsyncTexImage2DCHROMIUM.";
-}
-void MojoGLES2Impl::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
-  NOTREACHED() << "Unimplemented WaitAsyncTexImage2DCHROMIUM.";
-}
-void MojoGLES2Impl::WaitAllAsyncTexImage2DCHROMIUM() {
-  NOTREACHED() << "Unimplemented WaitAllAsyncTexImage2DCHROMIUM.";
-}
 void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
                                           GLsizei count,
                                           const GLenum* attachments) {
diff --git a/mojo/gpu/mojo_gles2_impl_autogen.h b/mojo/gpu/mojo_gles2_impl_autogen.h
index 8b6b866..0d1047b 100644
--- a/mojo/gpu/mojo_gles2_impl_autogen.h
+++ b/mojo/gpu/mojo_gles2_impl_autogen.h
@@ -760,26 +760,6 @@ class MojoGLES2Impl : public gpu::gles2::GLES2Interface {
   void TraceBeginCHROMIUM(const char* category_name,
                           const char* trace_name) override;
   void TraceEndCHROMIUM() override;
-  void AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                  GLint level,
-                                  GLint xoffset,
-                                  GLint yoffset,
-                                  GLsizei width,
-                                  GLsizei height,
-                                  GLenum format,
-                                  GLenum type,
-                                  const void* data) override;
-  void AsyncTexImage2DCHROMIUM(GLenum target,
-                               GLint level,
-                               GLenum internalformat,
-                               GLsizei width,
-                               GLsizei height,
-                               GLint border,
-                               GLenum format,
-                               GLenum type,
-                               const void* pixels) override;
-  void WaitAsyncTexImage2DCHROMIUM(GLenum target) override;
-  void WaitAllAsyncTexImage2DCHROMIUM() override;
   void DiscardFramebufferEXT(GLenum target,
                              GLsizei count,
                              const GLenum* attachments) override;
diff --git a/ui/compositor/compositor.cc b/ui/compositor/compositor.cc
index 3a07860..26fc074 100644
--- a/ui/compositor/compositor.cc
+++ b/ui/compositor/compositor.cc
@@ -136,7 +136,6 @@ Compositor::Compositor(ui::ContextFactory* context_factory,
   settings.use_display_lists = true;
 
   settings.use_zero_copy = IsUIZeroCopyEnabled();
-  settings.use_one_copy = IsUIOneCopyEnabled();
 
   settings.renderer_settings.use_rgba_4444_textures =
       command_line->HasSwitch(switches::kUIEnableRGBA4444Textures);
diff --git a/ui/compositor/compositor_switches.cc b/ui/compositor/compositor_switches.cc
index 888242d..8a5fb98 100644
--- a/ui/compositor/compositor_switches.cc
+++ b/ui/compositor/compositor_switches.cc
@@ -34,9 +34,4 @@ bool IsUIZeroCopyEnabled() {
   return command_line.HasSwitch(switches::kUIEnableZeroCopy);
 }
 
-bool IsUIOneCopyEnabled() {
-  // One-copy is on by default unless zero copy is enabled.
-  return !IsUIZeroCopyEnabled();
-}
-
 }  // namespace ui
diff --git a/ui/compositor/compositor_switches.h b/ui/compositor/compositor_switches.h
index 3223af7..683f055 100644
--- a/ui/compositor/compositor_switches.h
+++ b/ui/compositor/compositor_switches.h
@@ -21,7 +21,6 @@ COMPOSITOR_EXPORT extern const char kUIShowPaintRects[];
 namespace ui {
 
 bool IsUIZeroCopyEnabled();
-bool IsUIOneCopyEnabled();
 
 }  // namespace ui
 
diff --git a/ui/gl/gl_bindings.h b/ui/gl/gl_bindings.h
index cbd224a..0972598 100644
--- a/ui/gl/gl_bindings.h
+++ b/ui/gl/gl_bindings.h
@@ -126,7 +126,6 @@
 #define GL_LATENCY_QUERY_CHROMIUM                        0x6007
 
 /* GL_CHROMIUM_async_pixel_transfers */
-#define GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM         0x6005
 #define GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM           0x6006
 
 // GL_CHROMIUM_sync_query
diff --git a/ui/gl/gl_enums_implementation_autogen.h b/ui/gl/gl_enums_implementation_autogen.h
index 77114d6..de370da 100644
--- a/ui/gl/gl_enums_implementation_autogen.h
+++ b/ui/gl/gl_enums_implementation_autogen.h
@@ -1027,9 +1027,6 @@ static const GLEnums::EnumToString enum_to_string_table[] = {
         0x8E7D, "GL_MAX_PATCH_VERTICES_EXT",
     },
     {
-        0x6005, "GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM",
-    },
-    {
         0x9105, "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES",
     },
     {