[Android] Upstream all the IPC communications/handlings for stream texture

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 13 matching lines @@
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ui/gl/gl_context.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"
+#endif
+
 namespace {
 // This filter does two things:
 // - it counts the number of messages coming in on the channel
 // - it handles the GpuCommandBufferMsg_InsertSyncPoint message on the IO
 //   thread, generating the sync point ID and responding immediately, and then
 //   posting a task to insert the GpuCommandBufferMsg_RetireSyncPoint message
 //   into the channel's queue.
 class SyncPointMessageFilter : public IPC::ChannelProxy::MessageFilter {
  public:
   // Takes ownership of gpu_channel (see below).
@@ skipping 112 matching lines @@
       processed_get_state_fast_(false),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   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 content::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 205 matching lines @@
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_CreateOffscreenCommandBuffer,
                                     OnCreateOffscreenCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_DestroyCommandBuffer,
                                     OnDestroyCommandBuffer)
+#if defined(OS_ANDROID)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_RegisterStreamTextureProxy,
+                        OnRegisterStreamTextureProxy)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_EstablishStreamTexture,
+                        OnEstablishStreamTexture)
+#endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
 void GpuChannel::HandleMessage() {
   handle_messages_scheduled_ = false;
 
   if (!deferred_messages_.empty()) {
@@ skipping 98 matching lines @@
     // 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)
       OnScheduled();
   }
 
   if (reply_message)
     Send(reply_message);
 }
 
+#if defined(OS_ANDROID)
+void GpuChannel::OnRegisterStreamTextureProxy(
+    int32 stream_id,  const gfx::Size& initial_size, 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, initial_size, *route_id);
+}
+
+void GpuChannel::OnEstablishStreamTexture(
+    int32 stream_id, content::SurfaceTexturePeer::SurfaceTextureTarget type,
+    int32 primary_id, int32 secondary_id) {
+  stream_texture_manager_->EstablishStreamTexture(
+      stream_id, type, primary_id, secondary_id);
+}
+#endif
+