Make stream_id internal to StreamTextureHost.

content/renderer/gpu/stream_texture_host_android.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.
 
 #include "content/renderer/gpu/stream_texture_host_android.h"
 
+#include "base/unguessable_token.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace content {
 
-StreamTextureHost::StreamTextureHost(scoped_refptr<gpu::GpuChannelHost> channel)
-    : stream_id_(0),
+StreamTextureHost::StreamTextureHost(scoped_refptr<gpu::GpuChannelHost> channel,
+                                     int32_t route_id)
+    : route_id_(route_id),
       listener_(NULL),
       channel_(std::move(channel)),
       weak_ptr_factory_(this) {
   DCHECK(channel_);
 }
 
 StreamTextureHost::~StreamTextureHost() {
-  if (channel_.get() && stream_id_)
-    channel_->RemoveRoute(stream_id_);
+  if (channel_.get() && route_id_)
+    channel_->RemoveRoute(route_id_);
 }
 
-bool StreamTextureHost::BindToCurrentThread(int32_t stream_id,
-                                            Listener* listener) {
+bool StreamTextureHost::BindToCurrentThread(Listener* listener) {
   listener_ = listener;
-  if (channel_.get() && stream_id && !stream_id_) {
-    stream_id_ = stream_id;
-    channel_->AddRoute(stream_id, weak_ptr_factory_.GetWeakPtr());
-    channel_->Send(new GpuStreamTextureMsg_StartListening(stream_id));
+  if (channel_.get() && route_id_) {
+    channel_->AddRoute(route_id_, weak_ptr_factory_.GetWeakPtr());
+    channel_->Send(new GpuStreamTextureMsg_StartListening(route_id_));
     return true;
   }
 
   return false;
 }
 
 bool StreamTextureHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(StreamTextureHost, message)
     IPC_MESSAGE_HANDLER(GpuStreamTextureMsg_FrameAvailable,
                         OnFrameAvailable);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   return handled;
 }
 
 void StreamTextureHost::OnChannelError() {
 }
 
 void StreamTextureHost::OnFrameAvailable() {
   if (listener_)
     listener_->OnFrameAvailable();
 }
 
+void StreamTextureHost::EstablishPeer(int player_id, int frame_id) {
+  if (route_id_) {
+    channel_->Send(
+        new GpuStreamTextureMsg_EstablishPeer(route_id_, frame_id, player_id));

[Ken Russell (switch to Gerrit), 2016/10/10 23:34:24]

Not knowing this API, it seems strange that the frame_id would be part of
establishing the stream texture's peer, since presumably it changes all the time
and presumably the StreamTexture and its peer don't.

[sivag, 2016/10/12 11:25:33]

its used to get the MediaPlayer from the manager
and set the videosurface. Need to check if we can avoid 
that.

https://cs.chromium.org/chromium/src/content/browser/media/android/browser_me...

+  }
+}
+
+void StreamTextureHost::SetStreamTextureSize(const gfx::Size& size) {
+  if (route_id_)
+    channel_->Send(new GpuStreamTextureMsg_SetSize(route_id_, size));
+}
+
+void StreamTextureHost::ForwardStreamTextureForSurfaceRequest(
+    const base::UnguessableToken& request_token) {
+  if (route_id_) {
+    channel_->Send(new GpuStreamTextureMsg_ForwardForSurfaceRequest(
+        route_id_, request_token));
+  }
+}
+
 }  // namespace content