Revert of ui: Move GLImage::BindTexImage fallback from GLImage implementations to GLES2CmdDecoder.

content/common/gpu/stream_texture_android.cc

 // 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 "content/common/gpu/stream_texture_android.h"
 
 #include "base/bind.h"
 #include "content/common/android/surface_texture_peer.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_messages.h"
@@ skipping 27 matching lines @@
 
     // TODO: Ideally a valid image id was returned to the client so that
     // it could then call glBindTexImage2D() for doing the following.
     scoped_refptr<gfx::GLImage> gl_image(
         new StreamTexture(owner_stub, stream_id, texture->service_id()));
     gfx::Size size = gl_image->GetSize();
     texture_manager->SetTarget(texture, GL_TEXTURE_EXTERNAL_OES);
     texture_manager->SetLevelInfo(texture, GL_TEXTURE_EXTERNAL_OES, 0, GL_RGBA,
                                   size.width(), size.height(), 1, 0, GL_RGBA,
                                   GL_UNSIGNED_BYTE, gfx::Rect(size));
-    texture_manager->SetLevelImage(texture, GL_TEXTURE_EXTERNAL_OES, 0,
-                                   gl_image.get(),
-                                   gpu::gles2::Texture::UNBOUND);
+    texture_manager->SetLevelImage(
+        texture, GL_TEXTURE_EXTERNAL_OES, 0, gl_image.get());
     return true;
   }
 
   return false;
 }
 
 StreamTexture::StreamTexture(GpuCommandBufferStub* owner_stub,
                              int32 route_id,
                              uint32 texture_id)
     : surface_texture_(gfx::SurfaceTexture::Create(texture_id)),
       size_(0, 0),
       has_valid_frame_(false),
       has_pending_frame_(false),
       owner_stub_(owner_stub),
       route_id_(route_id),
       has_listener_(false),
-      texture_id_(texture_id),
       weak_factory_(this) {
   owner_stub->AddDestructionObserver(this);
   memset(current_matrix_, 0, sizeof(current_matrix_));
   owner_stub->channel()->AddRoute(route_id, this);
   surface_texture_->SetFrameAvailableCallback(base::Bind(
       &StreamTexture::OnFrameAvailable, weak_factory_.GetWeakPtr()));
 }
 
 StreamTexture::~StreamTexture() {
   if (owner_stub_) {
     owner_stub_->RemoveDestructionObserver(this);
     owner_stub_->channel()->RemoveRoute(route_id_);
   }
 }
 
 void StreamTexture::OnWillDestroyStub() {
   owner_stub_->RemoveDestructionObserver(this);
   owner_stub_->channel()->RemoveRoute(route_id_);
   owner_stub_ = NULL;
 
   // If the owner goes away, there is no need to keep the SurfaceTexture around.
   // The GL texture will keep working regardless with the currently bound frame.
   surface_texture_ = NULL;
 }
 
 void StreamTexture::Destroy(bool have_context) {
   NOTREACHED();
 }
 
-bool StreamTexture::CopyTexImage(unsigned target) {
-  DCHECK_EQ(target, static_cast<unsigned>(GL_TEXTURE_EXTERNAL_OES));
-
+void StreamTexture::WillUseTexImage() {
   if (!owner_stub_ || !surface_texture_.get())
-    return true;
+    return;
 
   if (has_pending_frame_) {
     scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
     bool needs_make_current =
         !owner_stub_->decoder()->GetGLContext()->IsCurrent(NULL);
     // On Android we should not have to perform a real context switch here when
     // using virtual contexts.
     DCHECK(!needs_make_current || !owner_stub_->decoder()
                                        ->GetContextGroup()
                                        ->feature_info()
@@ skipping 13 matching lines @@
       // it, we have to keep the state intact in *that* context also.
       const gpu::gles2::ContextState* state =
           owner_stub_->decoder()->GetContextState();
       const gpu::gles2::TextureUnit& active_unit =
           state->texture_units[state->active_texture_unit];
       glBindTexture(GL_TEXTURE_EXTERNAL_OES,
                     active_unit.bound_texture_external_oes.get()
                         ? active_unit.bound_texture_external_oes->service_id()
                         : 0);
     }
-
-    TextureManager* texture_manager =
-        owner_stub_->decoder()->GetContextGroup()->texture_manager();
-    gpu::gles2::Texture* texture =
-        texture_manager->GetTextureForServiceId(texture_id_);
-    if (texture) {
-      // By setting image state to UNBOUND instead of COPIED we ensure that
-      // CopyTexImage() is called each time the surface texture is used for
-      // drawing.
-      texture->SetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0, this,
-                             gpu::gles2::Texture::UNBOUND);
-    }
   }
 
   if (has_listener_ && has_valid_frame_) {
     float mtx[16];
     surface_texture_->GetTransformMatrix(mtx);
 
     // Only query the matrix once we have bound a valid frame.
     if (memcmp(current_matrix_, mtx, sizeof(mtx)) != 0) {
       memcpy(current_matrix_, mtx, sizeof(mtx));
 
       GpuStreamTextureMsg_MatrixChanged_Params params;
       memcpy(&params.m00, mtx, sizeof(mtx));
       owner_stub_->channel()->Send(
           new GpuStreamTextureMsg_MatrixChanged(route_id_, params));
     }
   }
-
-  return true;
 }
 
 void StreamTexture::OnFrameAvailable() {
   has_pending_frame_ = true;
   if (has_listener_ && owner_stub_) {
     owner_stub_->channel()->Send(
         new GpuStreamTextureMsg_FrameAvailable(route_id_));
   }
 }
 
@@ skipping 57 matching lines @@
   return false;
 }
 
 void StreamTexture::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                                  uint64_t process_tracing_id,
                                  const std::string& dump_name) {
   // TODO(ericrk): Add OnMemoryDump for GLImages. crbug.com/514914
 }
 
 }  // namespace content