Revert of Move AW renderer compositor context to gpu thread

gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc

 // 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"
@@ skipping 165 matching lines @@
     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_);
 
-  if (shared_state_->use_teximage2d_over_texsubimage2d &&
-      tex_params.xoffset == 0 &&
+  // If it's a full texture update, use glTexImage2D as it's faster.
+  // TODO(epenner): Make this configurable (http://crbug.com/259924)
+  if (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,
@@ skipping 28 matching lines @@
     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()
+    : 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()
+  : shared_state_() {
 }
 
 AsyncPixelTransferManagerIdle::~AsyncPixelTransferManagerIdle() {}
 
 void AsyncPixelTransferManagerIdle::BindCompletedAsyncTransfers() {
   // Everything is already bound.
 }
 
 void AsyncPixelTransferManagerIdle::AsyncNotifyCompletion(
     const AsyncMemoryParams& mem_params,
@@ skipping 48 matching lines @@
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateIdle(&shared_state_,
                                             ref->service_id(),
                                             define_params);
 }
 
 }  // namespace gpu