gpu: introduce glSetStreamTextureSizeCHROMIUM(GLuint texture, GLint stream_id, GLsizei width, GLsiz…

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 <set>
 #include <utility>
 
@@ skipping 889 matching lines @@
 
   gles2::QueryManager::Query* query = query_manager_->GetQuery(query_id);
   if (!query)
     callback.Run();
   else
     query->AddCallback(callback);
 }
 
 void InProcessCommandBuffer::SetSurfaceVisible(bool visible) {}
 
-uint32 InProcessCommandBuffer::CreateStreamTexture(uint32 texture_id) {
+int32 InProcessCommandBuffer::CreateStreamTexture(uint32 texture_id) {
   base::WaitableEvent completion(true, false);
-  uint32 stream_id = 0;
-  base::Callback<uint32(void)> task =
+  int32 stream_id = 0;
+  base::Callback<int32(void)> task =
       base::Bind(&InProcessCommandBuffer::CreateStreamTextureOnGpuThread,
-                 base::Unretained(this),
-                 texture_id);
+                 base::Unretained(this), texture_id);
   QueueTask(
-      base::Bind(&RunTaskWithResult<uint32>, task, &stream_id, &completion));
+      base::Bind(&RunTaskWithResult<int32>, task, &stream_id, &completion));
   completion.Wait();
   return stream_id;
 }
 
+void InProcessCommandBuffer::SetStreamTextureSize(uint32 texture_id,
+                                                  int32 stream_id,
+                                                  size_t width,
+                                                  size_t height) {
+  QueueTask(base::Bind(&InProcessCommandBuffer::SetStreamTextureSizeOnGpuThread,
+                       base::Unretained(this), texture_id, stream_id, width,
+                       height));
+}
+
 void InProcessCommandBuffer::SetLock(base::Lock*) {
 }
 
 bool InProcessCommandBuffer::IsGpuChannelLost() {
   // There is no such channel to lose for in-process contexts. This only
   // makes sense for out-of-process command buffers.
   return false;
 }
 
 CommandBufferNamespace InProcessCommandBuffer::GetNamespaceID() const {
@@ skipping 36 matching lines @@
 
   sync_point_client_->Wait(release_state.get(), sync_token.release_count(),
                            WrapCallback(callback));
 }
 
 bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
     const SyncToken* sync_token) {
   return false;
 }
 
-uint32 InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
+int32 InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
     uint32 client_texture_id) {
 #if defined(OS_ANDROID)
   return stream_texture_manager_->CreateStreamTexture(
       client_texture_id, decoder_->GetContextGroup()->texture_manager());
 #else
   return 0;
 #endif
 }
 
+void InProcessCommandBuffer::SetStreamTextureSizeOnGpuThread(
+    uint32 client_texture_id,
+    int32 stream_id,
+    size_t width,
+    size_t height) {
+#if defined(OS_ANDROID)
+  stream_texture_manager_->SetStreamTextureSize(
+      client_texture_id, stream_id, width, height,
+      decoder_->GetContextGroup()->texture_manager());
+#endif
+}
+
 gpu::error::Error InProcessCommandBuffer::GetLastError() {
   CheckSequencedThread();
   return last_state_.error;
 }
 
 bool InProcessCommandBuffer::Initialize() {
   NOTREACHED();
   return false;
 }
 
@@ skipping 27 matching lines @@
       base::Bind(&RunOnTargetThread, base::Passed(&scoped_callback));
   base::Closure wrapped_callback =
       base::Bind(&PostCallback, base::ThreadTaskRunnerHandle::IsSet()
                                     ? base::ThreadTaskRunnerHandle::Get()
                                     : nullptr,
                  callback_on_client_thread);
   return wrapped_callback;
 }
 
 #if defined(OS_ANDROID)
-scoped_refptr<gfx::SurfaceTexture>
-InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
+scoped_refptr<gfx::SurfaceTexture> InProcessCommandBuffer::GetSurfaceTexture(
+    int32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 GpuInProcessThread::GpuInProcessThread(SyncPointManager* sync_point_manager)
     : base::Thread("GpuThread"), sync_point_manager_(sync_point_manager) {
   Start();
 }
 
@@ skipping 35 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu