android: Remove in-process video path

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 <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 29 matching lines @@
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_image_shared_memory.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.h"
-#endif
-
 #if defined(OS_WIN)
 #include <windows.h>
 #include "base/process/process_handle.h"
 #endif
 
 namespace gpu {
 
 namespace {
 
 base::StaticAtomicSequenceNumber g_next_command_buffer_id;
@@ skipping 270 matching lines @@
   if (!command_buffer->Initialize()) {
     LOG(ERROR) << "Could not initialize command buffer.";
     DestroyOnGpuThread();
     return false;
   }
 
   gl_share_group_ = params.context_group
                         ? params.context_group->gl_share_group_
                         : service_->share_group();
 
-#if defined(OS_ANDROID)
-  stream_texture_manager_.reset(new StreamTextureManagerInProcess);
-#endif
-
   bool bind_generates_resource = false;
   decoder_.reset(gles2::GLES2Decoder::Create(
       params.context_group
           ? params.context_group->decoder_->GetContextGroup()
           : new gles2::ContextGroup(service_->gpu_preferences(),
                                     service_->mailbox_manager(), NULL,
                                     service_->shader_translator_cache(),
                                     service_->framebuffer_completeness_cache(),
                                     NULL, service_->subscription_ref_set(),
                                     service_->pending_valuebuffer_state(),
@@ skipping 118 matching lines @@
     decoder_.reset();
   }
   context_ = nullptr;
   surface_ = nullptr;
   sync_point_client_ = nullptr;
   if (sync_point_order_data_) {
     sync_point_order_data_->Destroy();
     sync_point_order_data_ = nullptr;
   }
   gl_share_group_ = nullptr;
-#if defined(OS_ANDROID)
-  stream_texture_manager_.reset();
-#endif
 
   return true;
 }
 
 void InProcessCommandBuffer::CheckSequencedThread() {
   DCHECK(!sequence_checker_ ||
          sequence_checker_->CalledOnValidSequencedThread());
 }
 
 void InProcessCommandBuffer::OnContextLostOnGpuThread() {
@@ skipping 486 matching lines @@
                        base::Unretained(this),
                        sync_token,
                        WrapCallback(callback)));
 }
 
 bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
     const SyncToken* sync_token) {
   return sync_token->namespace_id() == GetNamespaceID();
 }
 
-uint32_t InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
-    uint32_t client_texture_id) {
-#if defined(OS_ANDROID)
-  return stream_texture_manager_->CreateStreamTexture(
-      client_texture_id, decoder_->GetContextGroup()->texture_manager());
-#else
-  return 0;
-#endif
-}
-
 gpu::error::Error InProcessCommandBuffer::GetLastError() {
   CheckSequencedThread();
   return last_state_.error;
 }
 
 bool InProcessCommandBuffer::Initialize() {
   NOTREACHED();
   return false;
 }
 
@@ skipping 26 matching lines @@
   base::Closure callback_on_client_thread =
       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_t stream_id) {
-  DCHECK(stream_texture_manager_);
-  return stream_texture_manager_->GetSurfaceTexture(stream_id);
-}
-
-uint32_t InProcessCommandBuffer::CreateStreamTexture(uint32_t texture_id) {
-  base::WaitableEvent completion(true, false);
-  uint32_t stream_id = 0;
-  base::Callback<uint32_t(void)> task =
-      base::Bind(&InProcessCommandBuffer::CreateStreamTextureOnGpuThread,
-                 base::Unretained(this), texture_id);
-  QueueTask(
-      base::Bind(&RunTaskWithResult<uint32_t>, task, &stream_id, &completion));
-  completion.Wait();
-  return stream_id;
-}
-#endif
-
 GpuInProcessThread::GpuInProcessThread(SyncPointManager* sync_point_manager)
     : base::Thread("GpuThread"), sync_point_manager_(sync_point_manager) {
   Start();
 }
 
 GpuInProcessThread::~GpuInProcessThread() {
   Stop();
 }
 
 void GpuInProcessThread::AddRef() const {
@@ skipping 32 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu