gpu: Add SequenceId for identifying sync point sequences.

gpu/ipc/service/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.
 
 #include "gpu/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 16 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
-#include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
@@ skipping 10 matching lines @@
 const int64_t kPreemptWaitTimeMs = 2 * kVsyncIntervalMs;
 
 // Once we trigger a preemption, the maximum duration that we will wait
 // before clearing the preemption.
 const int64_t kMaxPreemptTimeMs = kVsyncIntervalMs;
 
 // Stop the preemption once the time for the longest pending IPC drops
 // below this threshold.
 const int64_t kStopPreemptThresholdMs = kVsyncIntervalMs;
 
+CommandBufferId GenerateCommandBufferId(int channel_id, int32_t route_id) {
+  return CommandBufferId::FromUnsafeValue(
+      (static_cast<uint64_t>(channel_id) << 32) | route_id);
+}
+
 }  // anonymous namespace
 
 scoped_refptr<GpuChannelMessageQueue> GpuChannelMessageQueue::Create(
-    int32_t stream_id,
-    GpuStreamPriority stream_priority,
     GpuChannel* channel,
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const scoped_refptr<PreemptionFlag>& preempting_flag,
-    const scoped_refptr<PreemptionFlag>& preempted_flag,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    scoped_refptr<PreemptionFlag> preempting_flag,
+    scoped_refptr<PreemptionFlag> preempted_flag,
     SyncPointManager* sync_point_manager) {
-  return new GpuChannelMessageQueue(stream_id, stream_priority, channel,
-                                    io_task_runner, preempting_flag,
-                                    preempted_flag, sync_point_manager);
-}
-
-scoped_refptr<SyncPointOrderData>
-GpuChannelMessageQueue::GetSyncPointOrderData() {
-  return sync_point_order_data_;
+  return new GpuChannelMessageQueue(
+      channel, std::move(io_task_runner), std::move(preempting_flag),
+      std::move(preempted_flag), sync_point_manager);
 }
 
 GpuChannelMessageQueue::GpuChannelMessageQueue(
-    int32_t stream_id,
-    GpuStreamPriority stream_priority,
     GpuChannel* channel,
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const scoped_refptr<PreemptionFlag>& preempting_flag,
-    const scoped_refptr<PreemptionFlag>& preempted_flag,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    scoped_refptr<PreemptionFlag> preempting_flag,
+    scoped_refptr<PreemptionFlag> preempted_flag,
     SyncPointManager* sync_point_manager)
-    : stream_id_(stream_id),
-      stream_priority_(stream_priority),
-      enabled_(true),
+    : enabled_(true),
       scheduled_(true),
       channel_(channel),
       preemption_state_(IDLE),
       max_preemption_time_(
           base::TimeDelta::FromMilliseconds(kMaxPreemptTimeMs)),
       timer_(new base::OneShotTimer),
-      sync_point_order_data_(SyncPointOrderData::Create()),
-      io_task_runner_(io_task_runner),
-      preempting_flag_(preempting_flag),
-      preempted_flag_(preempted_flag),
+      sync_point_order_data_(sync_point_manager->CreateSyncPointOrderData()),
+      io_task_runner_(std::move(io_task_runner)),
+      preempting_flag_(std::move(preempting_flag)),
+      preempted_flag_(std::move(preempted_flag)),
       sync_point_manager_(sync_point_manager) {
-  timer_->SetTaskRunner(io_task_runner);
+  timer_->SetTaskRunner(io_task_runner_);
   io_thread_checker_.DetachFromThread();
 }
 
 GpuChannelMessageQueue::~GpuChannelMessageQueue() {
   DCHECK(!enabled_);
   DCHECK(channel_messages_.empty());
 }
 
 void GpuChannelMessageQueue::Disable() {
   {
     base::AutoLock auto_lock(channel_lock_);
     DCHECK(enabled_);
     enabled_ = false;
   }
 
   // We guarantee that the queues will no longer be modified after enabled_
   // is set to false, it is now safe to modify the queue without the lock.
   // All public facing modifying functions check enabled_ while all
   // private modifying functions DCHECK(enabled_) to enforce this.
   while (!channel_messages_.empty()) {
     const IPC::Message& msg = channel_messages_.front()->message;
     if (msg.is_sync()) {
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&msg);
       reply->set_reply_error();
       channel_->Send(reply);
     }
     channel_messages_.pop_front();
   }
 
-  sync_point_order_data_->Destroy();
-  sync_point_order_data_ = nullptr;
+  if (sync_point_order_data_) {
+    sync_point_order_data_->Destroy();
+    sync_point_order_data_ = nullptr;
+  }
 
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuChannelMessageQueue::DisableIO, this));
 }
 
 void GpuChannelMessageQueue::DisableIO() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   timer_ = nullptr;
 }
 
 bool GpuChannelMessageQueue::IsScheduled() const {
   base::AutoLock lock(channel_lock_);
   return scheduled_;
 }
 
-void GpuChannelMessageQueue::OnRescheduled(bool scheduled) {
+void GpuChannelMessageQueue::SetScheduled(bool scheduled) {
   base::AutoLock lock(channel_lock_);
   DCHECK(enabled_);
   if (scheduled_ == scheduled)
     return;
   scheduled_ = scheduled;
   if (scheduled)
-    channel_->PostHandleMessage(this);
+    channel_->PostHandleMessage();
   if (preempting_flag_) {
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GpuChannelMessageQueue::UpdatePreemptionState, this));
   }
 }
 
-uint32_t GpuChannelMessageQueue::GetUnprocessedOrderNum() const {
-  return sync_point_order_data_->unprocessed_order_num();
-}
-
-uint32_t GpuChannelMessageQueue::GetProcessedOrderNum() const {
-  return sync_point_order_data_->processed_order_num();
-}
-
 bool GpuChannelMessageQueue::PushBackMessage(const IPC::Message& message) {
   base::AutoLock auto_lock(channel_lock_);
   if (enabled_) {
     if (message.type() == GpuCommandBufferMsg_WaitForTokenInRange::ID ||
         message.type() == GpuCommandBufferMsg_WaitForGetOffsetInRange::ID) {
       channel_->PostHandleOutOfOrderMessage(message);
       return true;
     }
 
-    uint32_t order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber(
-        sync_point_manager_);
+    uint32_t order_num =
+        sync_point_order_data_->GenerateUnprocessedOrderNumber();
     std::unique_ptr<GpuChannelMessage> msg(
         new GpuChannelMessage(message, order_num, base::TimeTicks::Now()));
 
     if (channel_messages_.empty()) {
       DCHECK(scheduled_);
-      channel_->PostHandleMessage(this);
+      channel_->PostHandleMessage();
     }
 
     channel_messages_.push_back(std::move(msg));
 
     if (preempting_flag_)
       UpdatePreemptionStateHelper();
 
     return true;
   }
   return false;
 }
 
 const GpuChannelMessage* GpuChannelMessageQueue::BeginMessageProcessing() {
   base::AutoLock auto_lock(channel_lock_);
   DCHECK(enabled_);
   // If we have been preempted by another channel, just post a task to wake up.
   if (preempted_flag_ && preempted_flag_->IsSet()) {
-    channel_->PostHandleMessage(this);
+    channel_->PostHandleMessage();
     return nullptr;
   }
   if (channel_messages_.empty())
     return nullptr;
   sync_point_order_data_->BeginProcessingOrderNumber(
       channel_messages_.front()->order_number);
   return channel_messages_.front().get();
 }
 
 void GpuChannelMessageQueue::PauseMessageProcessing() {
   base::AutoLock auto_lock(channel_lock_);
   DCHECK(!channel_messages_.empty());
 
   // If we have been preempted by another channel, just post a task to wake up.
   if (scheduled_)
-    channel_->PostHandleMessage(this);
+    channel_->PostHandleMessage();
 
   sync_point_order_data_->PauseProcessingOrderNumber(
       channel_messages_.front()->order_number);
 }
 
 void GpuChannelMessageQueue::FinishMessageProcessing() {
   base::AutoLock auto_lock(channel_lock_);
   DCHECK(!channel_messages_.empty());
   DCHECK(scheduled_);
 
   sync_point_order_data_->FinishProcessingOrderNumber(
       channel_messages_.front()->order_number);
   channel_messages_.pop_front();
 
   if (!channel_messages_.empty())
-    channel_->PostHandleMessage(this);
+    channel_->PostHandleMessage();
 
   if (preempting_flag_) {
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GpuChannelMessageQueue::UpdatePreemptionState, this));
   }
 }
 
 void GpuChannelMessageQueue::UpdatePreemptionState() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
@@ skipping 179 matching lines @@
   DCHECK(preempting_flag_);
   channel_lock_.AssertAcquired();
   DCHECK(preemption_state_ == CHECKING || preemption_state_ == PREEMPTING);
   DCHECK(!scheduled_);
 
   preemption_state_ = WOULD_PREEMPT_DESCHEDULED;
   preempting_flag_->Reset();
   TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
 }
 
-GpuChannelMessageFilter::GpuChannelMessageFilter()
-    : channel_(nullptr), peer_pid_(base::kNullProcessId) {}
+GpuChannelMessageFilter::GpuChannelMessageFilter(
+    scoped_refptr<GpuChannelMessageQueue> message_queue)
+    : message_queue_(std::move(message_queue)),
+      channel_(nullptr),
+      peer_pid_(base::kNullProcessId) {}
 
 GpuChannelMessageFilter::~GpuChannelMessageFilter() {}
 
 void GpuChannelMessageFilter::OnFilterAdded(IPC::Channel* channel) {
   DCHECK(!channel_);
   channel_ = channel;
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     filter->OnFilterAdded(channel_);
   }
 }
@@ skipping 36 matching lines @@
 }
 
 void GpuChannelMessageFilter::RemoveChannelFilter(
     scoped_refptr<IPC::MessageFilter> filter) {
   if (channel_)
     filter->OnFilterRemoved();
   channel_filters_.erase(
       std::find(channel_filters_.begin(), channel_filters_.end(), filter));
 }
 
-// This gets called from the main thread and assumes that all messages which
-// lead to creation of a new route are synchronous messages.
-// TODO(sunnyps): Create routes (and streams) on the IO thread so that we can
-// make the CreateCommandBuffer/VideoDecoder/VideoEncoder messages asynchronous.
-void GpuChannelMessageFilter::AddRoute(
-    int32_t route_id,
-    const scoped_refptr<GpuChannelMessageQueue>& queue) {
-  base::AutoLock lock(routes_lock_);
-  routes_.insert(std::make_pair(route_id, queue));
-}
-
-void GpuChannelMessageFilter::RemoveRoute(int32_t route_id) {
-  base::AutoLock lock(routes_lock_);
-  routes_.erase(route_id);
-}
-
 bool GpuChannelMessageFilter::OnMessageReceived(const IPC::Message& message) {
   DCHECK(channel_);
 
   if (message.should_unblock() || message.is_reply())
     return MessageErrorHandler(message, "Unexpected message type");
 
   if (message.type() == GpuChannelMsg_Nop::ID) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     Send(reply);
     return true;
   }
 
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     if (filter->OnMessageReceived(message))
       return true;
   }
 
-  scoped_refptr<GpuChannelMessageQueue> message_queue =
-      LookupStreamByRoute(message.routing_id());
-
-  if (!message_queue)
-    return MessageErrorHandler(message, "Could not find message queue");
-
-  if (!message_queue->PushBackMessage(message))
+  if (!message_queue_->PushBackMessage(message))
     return MessageErrorHandler(message, "Channel destroyed");
 
   return true;
 }
 
 bool GpuChannelMessageFilter::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
-scoped_refptr<GpuChannelMessageQueue>
-GpuChannelMessageFilter::LookupStreamByRoute(int32_t route_id) {
-  base::AutoLock lock(routes_lock_);
-  auto it = routes_.find(route_id);
-  if (it != routes_.end())
-    return it->second;
-  return nullptr;
-}
-
 bool GpuChannelMessageFilter::MessageErrorHandler(const IPC::Message& message,
                                                   const char* error_msg) {
   DLOG(ERROR) << error_msg;
   if (message.is_sync()) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     reply->set_reply_error();
     Send(reply);
   }
   return true;
 }
@@ skipping 28 matching lines @@
       io_task_runner_(io_task_runner),
       share_group_(share_group),
       mailbox_manager_(mailbox),
       watchdog_(watchdog),
       allow_view_command_buffers_(allow_view_command_buffers),
       allow_real_time_streams_(allow_real_time_streams),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
-  filter_ = new GpuChannelMessageFilter();
+  message_queue_ =
+      GpuChannelMessageQueue::Create(this, io_task_runner, preempting_flag,
+                                     preempted_flag, sync_point_manager);
 
-  scoped_refptr<GpuChannelMessageQueue> control_queue =
-      CreateStream(GPU_STREAM_DEFAULT, GpuStreamPriority::HIGH);
-  AddRouteToStream(MSG_ROUTING_CONTROL, GPU_STREAM_DEFAULT);
+  filter_ = new GpuChannelMessageFilter(message_queue_);
 }
 
 GpuChannel::~GpuChannel() {
   // Clear stubs first because of dependencies.
   stubs_.clear();
 
-  for (auto& kv : streams_)
-    kv.second->Disable();
+  message_queue_->Disable();
 
   if (preempting_flag_.get())
     preempting_flag_->Reset();
 }
 
 IPC::ChannelHandle GpuChannel::Init(base::WaitableEvent* shutdown_event) {
   DCHECK(shutdown_event);
   DCHECK(!channel_);
 
   mojo::MessagePipe pipe;
@@ skipping 12 matching lines @@
 
 base::WeakPtr<GpuChannel> GpuChannel::AsWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 base::ProcessId GpuChannel::GetClientPID() const {
   DCHECK_NE(peer_pid_, base::kNullProcessId);
   return peer_pid_;
 }
 
-uint32_t GpuChannel::GetProcessedOrderNum() const {
-  uint32_t processed_order_num = 0;
-  for (auto& kv : streams_) {
-    processed_order_num =
-        std::max(processed_order_num, kv.second->GetProcessedOrderNum());
-  }
-  return processed_order_num;
-}
-
-uint32_t GpuChannel::GetUnprocessedOrderNum() const {
-  uint32_t unprocessed_order_num = 0;
-  for (auto& kv : streams_) {
-    unprocessed_order_num =
-        std::max(unprocessed_order_num, kv.second->GetUnprocessedOrderNum());
-  }
-  return unprocessed_order_num;
-}
-
 bool GpuChannel::OnMessageReceived(const IPC::Message& msg) {
   // All messages should be pushed to channel_messages_ and handled separately.
   NOTREACHED();
   return false;
 }
 
 void GpuChannel::OnChannelConnected(int32_t peer_pid) {
   peer_pid_ = peer_pid;
 }
 
@@ skipping 10 matching lines @@
            << " with type " << message->type();
 
   if (!channel_) {
     delete message;
     return false;
   }
 
   return channel_->Send(message);
 }
 
-void GpuChannel::OnStreamRescheduled(int32_t stream_id, bool scheduled) {
-  scoped_refptr<GpuChannelMessageQueue> queue = LookupStream(stream_id);
-  DCHECK(queue);
-  queue->OnRescheduled(scheduled);
+void GpuChannel::OnCommandBufferScheduled(GpuCommandBufferStub* stub) {
+  message_queue_->SetScheduled(true);
+  // TODO(sunnyps): Enable gpu scheduler task queue for stub's sequence.
+}
+
+void GpuChannel::OnCommandBufferDescheduled(GpuCommandBufferStub* stub) {
+  message_queue_->SetScheduled(false);
+  // TODO(sunnyps): Disable gpu scheduler task queue for stub's sequence.
 }
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32_t route_id) {
   auto it = stubs_.find(route_id);
   if (it == stubs_.end())
     return nullptr;
 
   return it->second.get();
 }
 
 void GpuChannel::LoseAllContexts() {
   gpu_channel_manager_->LoseAllContexts();
 }
 
 void GpuChannel::MarkAllContextsLost() {
   for (auto& kv : stubs_)
     kv.second->MarkContextLost();
 }
 
 bool GpuChannel::AddRoute(int32_t route_id,
-                          int32_t stream_id,
+                          SequenceId sequence_id,
                           IPC::Listener* listener) {
-  if (router_.AddRoute(route_id, listener)) {
-    AddRouteToStream(route_id, stream_id);
-    return true;
-  }
-  return false;
+  // TODO(sunnyps): Add route id to sequence id mapping to filter.
+  return router_.AddRoute(route_id, listener);
 }
 
 void GpuChannel::RemoveRoute(int32_t route_id) {
   router_.RemoveRoute(route_id);
-  RemoveRouteFromStream(route_id);
 }
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateCommandBuffer,
                         OnCreateCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
                         OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_GetDriverBugWorkArounds,
                         OnGetDriverBugWorkArounds)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-scoped_refptr<SyncPointOrderData> GpuChannel::GetSyncPointOrderData(
-    int32_t stream_id) {
-  auto it = streams_.find(stream_id);
-  DCHECK(it != streams_.end());
-  DCHECK(it->second);
-  return it->second->GetSyncPointOrderData();
-}
-
-void GpuChannel::PostHandleMessage(
-    const scoped_refptr<GpuChannelMessageQueue>& queue) {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&GpuChannel::HandleMessage,
-                                    weak_factory_.GetWeakPtr(), queue));
+void GpuChannel::PostHandleMessage() {
+  task_runner_->PostTask(FROM_HERE, base::Bind(&GpuChannel::HandleMessage,
+                                               weak_factory_.GetWeakPtr()));
 }
 
 void GpuChannel::PostHandleOutOfOrderMessage(const IPC::Message& msg) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&GpuChannel::HandleOutOfOrderMessage,
                                     weak_factory_.GetWeakPtr(), msg));
 }
 
-void GpuChannel::HandleMessage(
-    const scoped_refptr<GpuChannelMessageQueue>& message_queue) {
+void GpuChannel::HandleMessage() {
   const GpuChannelMessage* channel_msg =
-      message_queue->BeginMessageProcessing();
+      message_queue_->BeginMessageProcessing();
   if (!channel_msg)
     return;
 
   const IPC::Message& msg = channel_msg->message;
   int32_t routing_id = msg.routing_id();
   GpuCommandBufferStub* stub = LookupCommandBuffer(routing_id);
 
   DCHECK(!stub || stub->IsScheduled());
 
   DVLOG(1) << "received message @" << &msg << " on channel @" << this
            << " with type " << msg.type();
 
   HandleMessageHelper(msg);
 
   // If we get descheduled or yield while processing a message.
-  if ((stub && stub->HasUnprocessedCommands()) ||
-      !message_queue->IsScheduled()) {
+  if (stub && (stub->HasUnprocessedCommands() || !stub->IsScheduled())) {
     DCHECK((uint32_t)GpuCommandBufferMsg_AsyncFlush::ID == msg.type() ||
            (uint32_t)GpuCommandBufferMsg_WaitSyncToken::ID == msg.type());
-    message_queue->PauseMessageProcessing();
+    DCHECK_EQ(stub->IsScheduled(), message_queue_->IsScheduled());
+    message_queue_->PauseMessageProcessing();
   } else {
-    message_queue->FinishMessageProcessing();
+    message_queue_->FinishMessageProcessing();
   }
 }
 
 void GpuChannel::HandleMessageHelper(const IPC::Message& msg) {
   int32_t routing_id = msg.routing_id();
 
   bool handled = false;
   if (routing_id == MSG_ROUTING_CONTROL) {
     handled = OnControlMessageReceived(msg);
   } else {
@@ skipping 12 matching lines @@
 }
 
 void GpuChannel::HandleOutOfOrderMessage(const IPC::Message& msg) {
   HandleMessageHelper(msg);
 }
 
 void GpuChannel::HandleMessageForTesting(const IPC::Message& msg) {
   HandleMessageHelper(msg);
 }
 
-scoped_refptr<GpuChannelMessageQueue> GpuChannel::CreateStream(
-    int32_t stream_id,
-    GpuStreamPriority stream_priority) {
-  DCHECK(streams_.find(stream_id) == streams_.end());
-  scoped_refptr<GpuChannelMessageQueue> queue = GpuChannelMessageQueue::Create(
-      stream_id, stream_priority, this, io_task_runner_,
-      (stream_id == GPU_STREAM_DEFAULT) ? preempting_flag_ : nullptr,
-      preempted_flag_, sync_point_manager_);
-  streams_.insert(std::make_pair(stream_id, queue));
-  streams_to_num_routes_.insert(std::make_pair(stream_id, 0));
-  return queue;
-}
-
-scoped_refptr<GpuChannelMessageQueue> GpuChannel::LookupStream(
-    int32_t stream_id) {
-  auto stream_it = streams_.find(stream_id);
-  if (stream_it != streams_.end())
-    return stream_it->second;
-  return nullptr;
-}
-
-void GpuChannel::DestroyStreamIfNecessary(
-    const scoped_refptr<GpuChannelMessageQueue>& queue) {
-  int32_t stream_id = queue->stream_id();
-  if (streams_to_num_routes_[stream_id] == 0) {
-    queue->Disable();
-    streams_to_num_routes_.erase(stream_id);
-    streams_.erase(stream_id);
-  }
-}
-
-void GpuChannel::AddRouteToStream(int32_t route_id, int32_t stream_id) {
-  DCHECK(streams_.find(stream_id) != streams_.end());
-  DCHECK(routes_to_streams_.find(route_id) == routes_to_streams_.end());
-  streams_to_num_routes_[stream_id]++;
-  routes_to_streams_.insert(std::make_pair(route_id, stream_id));
-  filter_->AddRoute(route_id, streams_[stream_id]);
-}
-
-void GpuChannel::RemoveRouteFromStream(int32_t route_id) {
-  DCHECK(routes_to_streams_.find(route_id) != routes_to_streams_.end());
-  int32_t stream_id = routes_to_streams_[route_id];
-  DCHECK(streams_.find(stream_id) != streams_.end());
-  routes_to_streams_.erase(route_id);
-  streams_to_num_routes_[stream_id]--;
-  filter_->RemoveRoute(route_id);
-  DestroyStreamIfNecessary(streams_[stream_id]);
-}
-
 #if defined(OS_ANDROID)
 const GpuCommandBufferStub* GpuChannel::GetOneStub() const {
   for (const auto& kv : stubs_) {
     const GpuCommandBufferStub* stub = kv.second.get();
     if (stub->decoder() && !stub->decoder()->WasContextLost())
       return stub;
   }
   return nullptr;
 }
 #endif
@@ skipping 28 matching lines @@
       !allow_view_command_buffers_) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): attempt to create a "
                    "view context on a non-priviledged channel";
     return nullptr;
   }
 
   int32_t share_group_id = init_params.share_group_id;
   GpuCommandBufferStub* share_group = LookupCommandBuffer(share_group_id);
 
   if (!share_group && share_group_id != MSG_ROUTING_NONE) {
-    DLOG(ERROR)
-        << "GpuChannel::CreateCommandBuffer(): invalid share group id";
+    DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): invalid share group id";
     return nullptr;
   }
 
-  int32_t stream_id = init_params.stream_id;
-  if (share_group && stream_id != share_group->stream_id()) {
-    DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): stream id does not "
-                   "match share group stream id";
-    return nullptr;
-  }

[piman, 2017/03/17 19:12:38]

I think we should keep this check (or eventually replace it with a sequence_id
check), but we're in a bad state if 2 contexts in the same share group are not
in the same sequence.

[sunnyps, 2017/03/17 21:48:23]

Added stream id check back. There's a unit test for this, which was failing.

-
   GpuStreamPriority stream_priority = init_params.stream_priority;
   if (!allow_real_time_streams_ &&
       stream_priority == GpuStreamPriority::REAL_TIME) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): real time stream "
                    "priority not allowed";
     return nullptr;
   }
 
   if (share_group && !share_group->decoder()) {
     // This should catch test errors where we did not Initialize the
     // share_group's CommandBuffer.
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): shared context was "
                    "not initialized";
     return nullptr;
   }
 
   if (share_group && share_group->decoder()->WasContextLost()) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): shared context was "
                    "already lost";
     return nullptr;
   }
 
-  scoped_refptr<GpuChannelMessageQueue> queue = LookupStream(stream_id);
-  if (!queue)
-    queue = CreateStream(stream_id, stream_priority);
+  CommandBufferId command_buffer_id =
+      GenerateCommandBufferId(client_id_, route_id);
+
+  // TODO(sunnyps): Lookup sequence id using stream id to sequence id map.
+  SequenceId sequence_id = message_queue_->sequence_id();
 
   std::unique_ptr<GpuCommandBufferStub> stub(GpuCommandBufferStub::Create(
-      this, share_group, init_params, route_id, std::move(shared_state_shm)));
+      this, share_group, init_params, command_buffer_id, sequence_id, route_id,
+      std::move(shared_state_shm)));
 
-  if (!stub) {
-    DestroyStreamIfNecessary(queue);
-    return nullptr;
-  }
-
-  if (!AddRoute(route_id, stream_id, stub.get())) {
-    DestroyStreamIfNecessary(queue);
+  if (!AddRoute(route_id, sequence_id, stub.get())) {
     DLOG(ERROR) << "GpuChannel::CreateCommandBuffer(): failed to add route";
     return nullptr;
   }
 
   return stub;
 }
 
 void GpuChannel::OnDestroyCommandBuffer(int32_t route_id) {
-  TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer",
-               "route_id", route_id);
+  TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer", "route_id",
+               route_id);
 
   std::unique_ptr<GpuCommandBufferStub> stub;
   auto it = stubs_.find(route_id);
   if (it != stubs_.end()) {
     stub = std::move(it->second);
     stubs_.erase(it);
   }
   // In case the renderer is currently blocked waiting for a sync reply from the
   // stub, we need to make sure to reschedule the correct stream here.
   if (stub && !stub->IsScheduled()) {
-    // This stub won't get a chance to reschedule the stream so do that now.
-    OnStreamRescheduled(stub->stream_id(), true);
+    // This stub won't get a chance to be scheduled so do that now.
+    OnCommandBufferScheduled(stub.get());
   }
 
   RemoveRoute(route_id);
 }
 
 void GpuChannel::OnGetDriverBugWorkArounds(
     std::vector<std::string>* gpu_driver_bug_workarounds) {
   gpu_driver_bug_workarounds->clear();
 #define GPU_OP(type, name)                                     \
   if (gpu_channel_manager_->gpu_driver_bug_workarounds().name) \
     gpu_driver_bug_workarounds->push_back(#name);
   GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
 #undef GPU_OP
 }
 
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->delegate()->StoreShaderToDisk(client_id_, key, shader);
 }
 
 void GpuChannel::AddFilter(IPC::MessageFilter* filter) {
   io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&GpuChannelMessageFilter::AddChannelFilter,
-                            filter_, make_scoped_refptr(filter)));
+      FROM_HERE, base::Bind(&GpuChannelMessageFilter::AddChannelFilter, filter_,
+                            make_scoped_refptr(filter)));
 }
 
 void GpuChannel::RemoveFilter(IPC::MessageFilter* filter) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuChannelMessageFilter::RemoveChannelFilter,
                             filter_, make_scoped_refptr(filter)));
 }
 
 uint64_t GpuChannel::GetMemoryUsage() {
   // Collect the unique memory trackers in use by the |stubs_|.
@@ skipping 37 matching lines @@
 
       return manager->gpu_memory_buffer_factory()
           ->AsImageFactory()
           ->CreateImageForGpuMemoryBuffer(handle, size, format, internalformat,
                                           client_id_, surface_handle);
     }
   }
 }
 
 }  // namespace gpu