Remove StreamTextureManager

content/common/gpu/gpu_channel.cc

 // 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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 20 matching lines @@
 #include "ipc/ipc_channel_proxy.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 #if defined(OS_ANDROID)
-#include "content/common/gpu/stream_texture_manager_android.h"
+#include "content/common/android/surface_texture_peer.h"
+#include "ui/gl/android/gl_image_stream.h"
 #endif
 
 namespace content {
 namespace {
 
 // Number of milliseconds between successive vsync. Many GL commands block
 // on vsync, so thresholds for preemption should be multiples of this.
 const int64 kVsyncIntervalMs = 17;
 
 // Amount of time that we will wait for an IPC to be processed before
@@ skipping 397 matching lines @@
       weak_factory_(this),
       num_stubs_descheduled_(0) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
-#if defined(OS_ANDROID)
-  stream_texture_manager_.reset(new StreamTextureManagerAndroid(this));
-#endif
 }
 
 
 bool GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
                       base::WaitableEvent* shutdown_event) {
   DCHECK(!channel_.get());
 
   // Map renderer ID to a (single) channel to that process.
   channel_.reset(new IPC::SyncChannel(
       channel_id_,
@@ skipping 421 matching lines @@
   stubs_.Remove(route_id);
   // In case the renderer is currently blocked waiting for a sync reply from the
   // stub, we need to make sure to reschedule the GpuChannel here.
   if (need_reschedule) {
     // This stub won't get a chance to reschedule, so update the count now.
     StubSchedulingChanged(true);
   }
 }
 
 #if defined(OS_ANDROID)
+namespace {
+
+void SendFrameAvailable(const base::WeakPtr<GpuChannel>& channel,
+                        int32 route_id) {
+  if (channel)
+    channel->Send(new GpuStreamTextureMsg_FrameAvailable(route_id));
+}
+
+void SendMatrixChanged(const base::WeakPtr<GpuChannel>& channel,
+                       int32 route_id,
+                       const gfx::GLImageStream::Matrix& matrix) {
+  if (channel) {
+    GpuStreamTextureMsg_MatrixChanged_Params params;
+    memcpy(&params.m00, matrix.components, sizeof(matrix.components));
+    channel->Send(new GpuStreamTextureMsg_MatrixChanged(route_id, params));
+  }
+}
+
+}  // anonymous namespace
+
 void GpuChannel::OnRegisterStreamTextureProxy(
     int32 stream_id, int32* route_id) {
-  // Note that route_id is only used for notifications sent out from here.
-  // StreamTextureManager owns all texture objects and for incoming messages
-  // it finds the correct object based on stream_id.
   *route_id = GenerateRouteID();
-  stream_texture_manager_->RegisterStreamTextureProxy(stream_id, *route_id);
+  scoped_refptr<gfx::GLImage> image(image_manager_->LookupImage(stream_id));
+  if (!image)
+    return;
+
+  scoped_refptr<gfx::GLImageStream> stream(image->AsGLImageStream());
+  if (!stream)
+    return;
+
+  base::Closure frame_callback =
+      base::Bind(&SendFrameAvailable, weak_factory_.GetWeakPtr(), *route_id);
+  gfx::GLImageStream::MatrixChangedCallBack matrix_callback =
+      base::Bind(&SendMatrixChanged, weak_factory_.GetWeakPtr(), *route_id);
+
+  stream->SetMatrixChangedCallback(matrix_callback);
+  stream->SetFrameAvailableCallback(frame_callback);
 }
 
 void GpuChannel::OnEstablishStreamTexture(
     int32 stream_id, int32 primary_id, int32 secondary_id) {
-  stream_texture_manager_->EstablishStreamTexture(
-      stream_id, primary_id, secondary_id);
+  scoped_refptr<gfx::GLImage> image(image_manager_->LookupImage(stream_id));
+  if (!image)
+    return;
+
+  scoped_refptr<gfx::GLImageStream> stream(image->AsGLImageStream());
+  if (!stream)
+    return;
+
+  SurfaceTexturePeer::GetInstance()->EstablishSurfaceTexturePeer(
+      renderer_pid(),
+      stream->GetSurfaceTexture(),
+      primary_id,
+      secondary_id);
 }
 
 void GpuChannel::OnSetStreamTextureSize(
     int32 stream_id, const gfx::Size& size) {
-  stream_texture_manager_->SetStreamTextureSize(stream_id, size);
+  scoped_refptr<gfx::GLImage> image(image_manager_->LookupImage(stream_id));
+  if (!image)
+    return;
+
+  scoped_refptr<gfx::GLImageStream> stream(image->AsGLImageStream());
+  if (!stream)
+    return;
+
+  stream->SetSize(size);
 }
 #endif
 
 void GpuChannel::OnCollectRenderingStatsForSurface(
     int32 surface_id, GpuRenderingStats* stats) {
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
     int texture_upload_count =
         it.GetCurrentValue()->decoder()->GetTextureUploadCount();
     base::TimeDelta total_texture_upload_time =
@@ skipping 24 matching lines @@
   }
 }
 
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->Send(
       new GpuHostMsg_CacheShader(client_id_, key, shader));
 }
 
 }  // namespace content