Support stream textures with the synchronous compositor

gpu/command_buffer/service/in_process_command_buffer.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/in_process_command_buffer.h"
 
 #include <queue>
 #include <utility>
 
 #include <GLES2/gl2.h>
@@ skipping 16 matching lines @@
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
 
+#if defined(OS_ANDROID)
+#include "gpu/command_buffer/service/stream_texture_manager_in_process_android.h"
+#include "ui/gl/android/surface_texture_bridge.h"
+#endif
+
 namespace gpu {
 
 namespace {
 
 static base::LazyInstance<std::set<InProcessCommandBuffer*> >
     g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_use_virtualized_gl_context = false;
 static bool g_uses_explicit_scheduling = false;
 
@@ skipping 324 matching lines @@
         context_group = *it;
         DCHECK(context_group->share_resources_);
         context_lost_ = context_group->IsContextLost();
         break;
       }
     }
     if (!context_group)
       share_group = new gfx::GLShareGroup;
   }
 
+  StreamTextureManager* stream_texture_manager = NULL;
+#if defined(OS_ANDROID)
+  stream_texture_manager = stream_texture_manager_ =
+      context_group ? context_group->stream_texture_manager_.get()
+                    : new StreamTextureManagerInProcess;
+#endif
+
   bool bind_generates_resource = false;
   decoder_.reset(gles2::GLES2Decoder::Create(
       context_group ? context_group->decoder_->GetContextGroup()
-                    : new gles2::ContextGroup(
-                          NULL, NULL, NULL, NULL, bind_generates_resource)));
+                    : new gles2::ContextGroup(NULL,
+                                              NULL,
+                                              NULL,
+                                              stream_texture_manager,
+                                              bind_generates_resource)));
 
   gpu_scheduler_.reset(
       new GpuScheduler(command_buffer.get(), decoder_.get(), decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler_.get())));
   command_buffer_ = command_buffer.Pass();
 
   decoder_->set_engine(gpu_scheduler_.get());
 
   if (!surface_) {
@@ skipping 331 matching lines @@
   // ownership.
   scoped_ptr<base::Closure> scoped_callback(new base::Closure(callback));
   base::Closure callback_on_client_thread =
       base::Bind(&RunOnTargetThread, base::Passed(&scoped_callback));
   base::Closure wrapped_callback =
       base::Bind(&PostCallback, base::MessageLoopProxy::current(),
                  callback_on_client_thread);
   return wrapped_callback;
 }
 
+#if defined(OS_ANDROID)
+scoped_refptr<gfx::SurfaceTextureBridge>
+InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
+  DCHECK(stream_texture_manager_);
+  return stream_texture_manager_->GetSurfaceTexture(stream_id);
+}
+#endif
+
 // static
 void InProcessCommandBuffer::EnableVirtualizedContext() {
   g_use_virtualized_gl_context = true;
 }
 
 // static
 void InProcessCommandBuffer::SetScheduleCallback(
     const base::Closure& callback) {
   DCHECK(!g_uses_explicit_scheduling);
   DCHECK(!SchedulerClientBase::HasClients());
   g_uses_explicit_scheduling = true;
   g_gpu_queue.Get().SetScheduleCallback(callback);
 }
 
 // static
 void InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread() {
   g_gpu_queue.Get().RunTasks();
 }
 
 }  // namespace gpu