Revert of Refactor content/common/gpu into gpu/ipc/service

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 <string.h>
+
+#include "base/bind.h"
+#include "base/strings/stringize_macros.h"
+#include "content/common/gpu/gpu_channel.h"
+#include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/context_state.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "gpu/command_buffer/service/texture_manager.h"
+#include "gpu/ipc/common/android/surface_texture_peer.h"
+#include "gpu/ipc/common/gpu_messages.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_helper.h"
+#include "ui/gl/scoped_binders.h"
+#include "ui/gl/scoped_make_current.h"
+
+namespace content {
+
+using gpu::gles2::ContextGroup;
+using gpu::gles2::GLES2Decoder;
+using gpu::gles2::TextureManager;
+using gpu::gles2::TextureRef;
+
+// static
+bool StreamTexture::Create(GpuCommandBufferStub* owner_stub,
+                           uint32_t client_texture_id,
+                           int stream_id) {
+  GLES2Decoder* decoder = owner_stub->decoder();
+  TextureManager* texture_manager =
+      decoder->GetContextGroup()->texture_manager();
+  TextureRef* texture = texture_manager->GetTexture(client_texture_id);
+
+  if (texture && (!texture->texture()->target() ||
+                  texture->texture()->target() == GL_TEXTURE_EXTERNAL_OES)) {
+
+    // TODO: Ideally a valid image id was returned to the client so that
+    // it could then call glBindTexImage2D() for doing the following.
+    scoped_refptr<gpu::gles2::GLStreamTextureImage> 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->SetLevelStreamTextureImage(
+        texture, GL_TEXTURE_EXTERNAL_OES, 0, gl_image.get(),
+        gpu::gles2::Texture::UNBOUND);
+    return true;
+  }
+
+  return false;
+}
+
+StreamTexture::StreamTexture(GpuCommandBufferStub* owner_stub,
+                             int32_t route_id,
+                             uint32_t texture_id)
+    : surface_texture_(gfx::SurfaceTexture::Create(texture_id)),
+      size_(0, 0),
+      has_pending_frame_(false),
+      owner_stub_(owner_stub),
+      route_id_(route_id),
+      has_listener_(false),
+      texture_id_(texture_id),
+      framebuffer_(0),
+      vertex_shader_(0),
+      fragment_shader_(0),
+      program_(0),
+      vertex_buffer_(0),
+      u_xform_location_(-1),
+      weak_factory_(this) {
+  owner_stub->AddDestructionObserver(this);
+  memset(current_matrix_, 0, sizeof(current_matrix_));
+  owner_stub->channel()->AddRoute(route_id, owner_stub->stream_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_);
+  }
+}
+
+// gpu::gles2::GLStreamTextureMatrix implementation
+void StreamTexture::GetTextureMatrix(float xform[16]) {
+  UpdateTexImage();
+  surface_texture_->GetTransformMatrix(xform);
+}
+
+void StreamTexture::OnWillDestroyStub() {
+  owner_stub_->RemoveDestructionObserver(this);
+  owner_stub_->channel()->RemoveRoute(route_id_);
+
+  if (framebuffer_) {
+    scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current(MakeStubCurrent());
+
+    glDeleteProgram(program_);
+    glDeleteShader(vertex_shader_);
+    glDeleteShader(fragment_shader_);
+    glDeleteBuffersARB(1, &vertex_buffer_);
+    glDeleteFramebuffersEXT(1, &framebuffer_);
+    program_ = 0;
+    vertex_shader_ = 0;
+    fragment_shader_ = 0;
+    vertex_buffer_ = 0;
+    framebuffer_ = 0;
+    u_xform_location_ = -1;
+  }
+
+  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();
+}
+
+scoped_ptr<ui::ScopedMakeCurrent> StreamTexture::MakeStubCurrent() {
+  scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
+  bool needs_make_current =
+      !owner_stub_->decoder()->GetGLContext()->IsCurrent(NULL);
+  if (needs_make_current) {
+    scoped_make_current.reset(new ui::ScopedMakeCurrent(
+        owner_stub_->decoder()->GetGLContext(), owner_stub_->surface()));
+  }
+  return scoped_make_current;
+}
+
+void StreamTexture::UpdateTexImage() {
+  DCHECK(surface_texture_.get());
+  DCHECK(owner_stub_);
+
+  if (!has_pending_frame_) return;
+
+  scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current(MakeStubCurrent());
+
+  surface_texture_->UpdateTexImage();
+
+  has_pending_frame_ = false;
+
+  if (scoped_make_current.get()) {
+    // UpdateTexImage() implies glBindTexture().
+    // The cmd decoder takes care of restoring the binding for this GLImage as
+    // far as the current context is concerned, but if we temporarily change
+    // 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);
+  }
+}
+
+bool StreamTexture::CopyTexImage(unsigned target) {
+  if (target != GL_TEXTURE_EXTERNAL_OES)
+    return false;
+
+  if (!owner_stub_ || !surface_texture_.get())
+    return true;
+
+  GLint texture_id;
+  glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texture_id);
+
+  // The following code only works if we're being asked to copy into
+  // |texture_id_|. Copying into a different texture is not supported.
+  // On some devices GL_TEXTURE_BINDING_EXTERNAL_OES is not supported as
+  // glGetIntegerv() parameter. In this case the value of |texture_id| will be
+  // zero and we assume that it is properly bound to |texture_id_|.
+  if (texture_id > 0 && static_cast<unsigned>(texture_id) != texture_id_)
+    return false;
+
+  UpdateTexImage();
+
+  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->SetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES, 0, this,
+                                        gpu::gles2::Texture::UNBOUND);
+  }
+
+  return true;
+}
+
+void StreamTexture::OnFrameAvailable() {
+  has_pending_frame_ = true;
+  if (has_listener_ && owner_stub_) {
+    owner_stub_->channel()->Send(
+        new GpuStreamTextureMsg_FrameAvailable(route_id_));
+  }
+}
+
+gfx::Size StreamTexture::GetSize() {
+  return size_;
+}
+
+unsigned StreamTexture::GetInternalFormat() {
+  return GL_RGBA;
+}
+
+bool StreamTexture::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(StreamTexture, message)
+    IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_StartListening, OnStartListening)
+    IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_EstablishPeer, OnEstablishPeer)
+    IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_SetSize, OnSetSize)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  DCHECK(handled);
+  return handled;
+}
+
+void StreamTexture::OnStartListening() {
+  DCHECK(!has_listener_);
+  has_listener_ = true;
+}
+
+void StreamTexture::OnEstablishPeer(int32_t primary_id, int32_t secondary_id) {
+  if (!owner_stub_)
+    return;
+
+  base::ProcessHandle process = owner_stub_->channel()->GetClientPID();
+
+  gpu::SurfaceTexturePeer::GetInstance()->EstablishSurfaceTexturePeer(
+      process, surface_texture_, primary_id, secondary_id);
+}
+
+bool StreamTexture::BindTexImage(unsigned target) {
+  NOTREACHED();
+  return false;
+}
+
+void StreamTexture::ReleaseTexImage(unsigned target) {
+  NOTREACHED();
+}
+
+bool StreamTexture::CopyTexSubImage(unsigned target,
+                                    const gfx::Point& offset,
+                                    const gfx::Rect& rect) {
+  return false;
+}
+
+bool StreamTexture::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                                         int z_order,
+                                         gfx::OverlayTransform transform,
+                                         const gfx::Rect& bounds_rect,
+                                         const gfx::RectF& crop_rect) {
+  NOTREACHED();
+  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