src/content/common/gpu/gpu_channel.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #if defined(OS_WIN)
   6 #include <windows.h>
   7 #endif
   8
   9 #include "content/common/gpu/gpu_channel.h"
  10
  11 #include <queue>
  12 #include <vector>
  13
  14 #include "base/bind.h"
  15 #include "base/command_line.h"
  16 #include "base/debug/trace_event.h"
  17 #include "base/message_loop/message_loop_proxy.h"
  18 #include "base/stl_util.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/timer/timer.h"
  21 #include "content/common/gpu/devtools_gpu_agent.h"
  22 #include "content/common/gpu/gpu_channel_manager.h"
  23 #include "content/common/gpu/gpu_messages.h"
  24 #include "content/common/gpu/sync_point_manager.h"
  25 #include "content/public/common/content_switches.h"
  26 #include "gpu/command_buffer/common/mailbox.h"
  27 #include "gpu/command_buffer/service/gpu_scheduler.h"
  28 #include "gpu/command_buffer/service/image_manager.h"
  29 #include "gpu/command_buffer/service/mailbox_manager.h"
  30 #include "ipc/ipc_channel.h"
  31 #include "ipc/message_filter.h"
  32 #include "ui/gl/gl_context.h"
  33 #include "ui/gl/gl_image.h"
  34 #include "ui/gl/gl_surface.h"
  35
  36 #if defined(OS_POSIX)
  37 #include "ipc/ipc_channel_posix.h"
  38 #endif
  39
  40 namespace content {
  41 namespace {
  42
  43 // Number of milliseconds between successive vsync. Many GL commands block
  44 // on vsync, so thresholds for preemption should be multiples of this.
  45 const int64 kVsyncIntervalMs = 17;
  46
  47 // Amount of time that we will wait for an IPC to be processed before
  48 // preempting. After a preemption, we must wait this long before triggering
  49 // another preemption.
  50 const int64 kPreemptWaitTimeMs = 2 * kVsyncIntervalMs;
  51
  52 // Once we trigger a preemption, the maximum duration that we will wait
  53 // before clearing the preemption.
  54 const int64 kMaxPreemptTimeMs = kVsyncIntervalMs;
  55
  56 // Stop the preemption once the time for the longest pending IPC drops
  57 // below this threshold.
  58 const int64 kStopPreemptThresholdMs = kVsyncIntervalMs;
  59
  60 }  // anonymous namespace
  61
  62 // This filter does three things:
  63 // - it counts and timestamps each message forwarded to the channel
  64 //   so that we can preempt other channels if a message takes too long to
  65 //   process. To guarantee fairness, we must wait a minimum amount of time
  66 //   before preempting and we limit the amount of time that we can preempt in
  67 //   one shot (see constants above).
  68 // - it handles the GpuCommandBufferMsg_InsertSyncPoint message on the IO
  69 //   thread, generating the sync point ID and responding immediately, and then
  70 //   posting a task to insert the GpuCommandBufferMsg_RetireSyncPoint message
  71 //   into the channel's queue.
  72 // - it generates mailbox names for clients of the GPU process on the IO thread.
  73 class GpuChannelMessageFilter : public IPC::MessageFilter {
  74  public:
  75   GpuChannelMessageFilter(base::WeakPtr<GpuChannel> gpu_channel,
  76                           scoped_refptr<SyncPointManager> sync_point_manager,
  77                           scoped_refptr<base::MessageLoopProxy> message_loop)
  78       : preemption_state_(IDLE),
  79         gpu_channel_(gpu_channel),
  80         sender_(NULL),
  81         sync_point_manager_(sync_point_manager),
  82         message_loop_(message_loop),
  83         messages_forwarded_to_channel_(0),
  84         a_stub_is_descheduled_(false) {}
  85
  86   virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
  87     DCHECK(!sender_);
  88     sender_ = sender;
  89   }
  90
  91   virtual void OnFilterRemoved() OVERRIDE {
  92     DCHECK(sender_);
  93     sender_ = NULL;
  94   }
  95
  96   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
  97     DCHECK(sender_);
  98
  99     bool handled = false;
 100     if (message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) {
 101       // This message should not be sent explicitly by the renderer.
 102       DLOG(ERROR) << "Client should not send "
 103                      "GpuCommandBufferMsg_RetireSyncPoint message";
 104       handled = true;
 105     }
 106
 107     // All other messages get processed by the GpuChannel.
 108     if (!handled) {
 109       messages_forwarded_to_channel_++;
 110       if (preempting_flag_.get())
 111         pending_messages_.push(PendingMessage(messages_forwarded_to_channel_));
 112       UpdatePreemptionState();
 113     }
 114
 115     if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {
 116       uint32 sync_point = sync_point_manager_->GenerateSyncPoint();
 117       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
 118       GpuCommandBufferMsg_InsertSyncPoint::WriteReplyParams(reply, sync_point);
 119       Send(reply);
 120       message_loop_->PostTask(FROM_HERE, base::Bind(
 121           &GpuChannelMessageFilter::InsertSyncPointOnMainThread,
 122           gpu_channel_,
 123           sync_point_manager_,
 124           message.routing_id(),
 125           sync_point));
 126       handled = true;
 127     }
 128     return handled;
 129   }
 130
 131   void MessageProcessed(uint64 messages_processed) {
 132     while (!pending_messages_.empty() &&
 133            pending_messages_.front().message_number <= messages_processed)
 134       pending_messages_.pop();
 135     UpdatePreemptionState();
 136   }
 137
 138   void SetPreemptingFlagAndSchedulingState(
 139       gpu::PreemptionFlag* preempting_flag,
 140       bool a_stub_is_descheduled) {
 141     preempting_flag_ = preempting_flag;
 142     a_stub_is_descheduled_ = a_stub_is_descheduled;
 143   }
 144
 145   void UpdateStubSchedulingState(bool a_stub_is_descheduled) {
 146     a_stub_is_descheduled_ = a_stub_is_descheduled;
 147     UpdatePreemptionState();
 148   }
 149
 150   bool Send(IPC::Message* message) {
 151     return sender_->Send(message);
 152   }
 153
 154  protected:
 155   virtual ~GpuChannelMessageFilter() {}
 156
 157  private:
 158   enum PreemptionState {
 159     // Either there's no other channel to preempt, there are no messages
 160     // pending processing, or we just finished preempting and have to wait
 161     // before preempting again.
 162     IDLE,
 163     // We are waiting kPreemptWaitTimeMs before checking if we should preempt.
 164     WAITING,
 165     // We can preempt whenever any IPC processing takes more than
 166     // kPreemptWaitTimeMs.
 167     CHECKING,
 168     // We are currently preempting (i.e. no stub is descheduled).
 169     PREEMPTING,
 170     // We would like to preempt, but some stub is descheduled.
 171     WOULD_PREEMPT_DESCHEDULED,
 172   };
 173
 174   PreemptionState preemption_state_;
 175
 176   // Maximum amount of time that we can spend in PREEMPTING.
 177   // It is reset when we transition to IDLE.
 178   base::TimeDelta max_preemption_time_;
 179
 180   struct PendingMessage {
 181     uint64 message_number;
 182     base::TimeTicks time_received;
 183
 184     explicit PendingMessage(uint64 message_number)
 185         : message_number(message_number),
 186           time_received(base::TimeTicks::Now()) {
 187     }
 188   };
 189
 190   void UpdatePreemptionState() {
 191     switch (preemption_state_) {
 192       case IDLE:
 193         if (preempting_flag_.get() && !pending_messages_.empty())
 194           TransitionToWaiting();
 195         break;
 196       case WAITING:
 197         // A timer will transition us to CHECKING.
 198         DCHECK(timer_.IsRunning());
 199         break;
 200       case CHECKING:
 201         if (!pending_messages_.empty()) {
 202           base::TimeDelta time_elapsed =
 203               base::TimeTicks::Now() - pending_messages_.front().time_received;
 204           if (time_elapsed.InMilliseconds() < kPreemptWaitTimeMs) {
 205             // Schedule another check for when the IPC may go long.
 206             timer_.Start(
 207                 FROM_HERE,
 208                 base::TimeDelta::FromMilliseconds(kPreemptWaitTimeMs) -
 209                     time_elapsed,
 210                 this, &GpuChannelMessageFilter::UpdatePreemptionState);
 211           } else {
 212             if (a_stub_is_descheduled_)
 213               TransitionToWouldPreemptDescheduled();
 214             else
 215               TransitionToPreempting();
 216           }
 217         }
 218         break;
 219       case PREEMPTING:
 220         // A TransitionToIdle() timer should always be running in this state.
 221         DCHECK(timer_.IsRunning());
 222         if (a_stub_is_descheduled_)
 223           TransitionToWouldPreemptDescheduled();
 224         else
 225           TransitionToIdleIfCaughtUp();
 226         break;
 227       case WOULD_PREEMPT_DESCHEDULED:
 228         // A TransitionToIdle() timer should never be running in this state.
 229         DCHECK(!timer_.IsRunning());
 230         if (!a_stub_is_descheduled_)
 231           TransitionToPreempting();
 232         else
 233           TransitionToIdleIfCaughtUp();
 234         break;
 235       default:
 236         NOTREACHED();
 237     }
 238   }
 239
 240   void TransitionToIdleIfCaughtUp() {
 241     DCHECK(preemption_state_ == PREEMPTING ||
 242            preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
 243     if (pending_messages_.empty()) {
 244       TransitionToIdle();
 245     } else {
 246       base::TimeDelta time_elapsed =
 247           base::TimeTicks::Now() - pending_messages_.front().time_received;
 248       if (time_elapsed.InMilliseconds() < kStopPreemptThresholdMs)
 249         TransitionToIdle();
 250     }
 251   }
 252
 253   void TransitionToIdle() {
 254     DCHECK(preemption_state_ == PREEMPTING ||
 255            preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
 256     // Stop any outstanding timer set to force us from PREEMPTING to IDLE.
 257     timer_.Stop();
 258
 259     preemption_state_ = IDLE;
 260     preempting_flag_->Reset();
 261     TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
 262
 263     UpdatePreemptionState();
 264   }
 265
 266   void TransitionToWaiting() {
 267     DCHECK_EQ(preemption_state_, IDLE);
 268     DCHECK(!timer_.IsRunning());
 269
 270     preemption_state_ = WAITING;
 271     timer_.Start(
 272         FROM_HERE,
 273         base::TimeDelta::FromMilliseconds(kPreemptWaitTimeMs),
 274         this, &GpuChannelMessageFilter::TransitionToChecking);
 275   }
 276
 277   void TransitionToChecking() {
 278     DCHECK_EQ(preemption_state_, WAITING);
 279     DCHECK(!timer_.IsRunning());
 280
 281     preemption_state_ = CHECKING;
 282     max_preemption_time_ = base::TimeDelta::FromMilliseconds(kMaxPreemptTimeMs);
 283     UpdatePreemptionState();
 284   }
 285
 286   void TransitionToPreempting() {
 287     DCHECK(preemption_state_ == CHECKING ||
 288            preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
 289     DCHECK(!a_stub_is_descheduled_);
 290
 291     // Stop any pending state update checks that we may have queued
 292     // while CHECKING.
 293     if (preemption_state_ == CHECKING)
 294       timer_.Stop();
 295
 296     preemption_state_ = PREEMPTING;
 297     preempting_flag_->Set();
 298     TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 1);
 299
 300     timer_.Start(
 301        FROM_HERE,
 302        max_preemption_time_,
 303        this, &GpuChannelMessageFilter::TransitionToIdle);
 304
 305     UpdatePreemptionState();
 306   }
 307
 308   void TransitionToWouldPreemptDescheduled() {
 309     DCHECK(preemption_state_ == CHECKING ||
 310            preemption_state_ == PREEMPTING);
 311     DCHECK(a_stub_is_descheduled_);
 312
 313     if (preemption_state_ == CHECKING) {
 314       // Stop any pending state update checks that we may have queued
 315       // while CHECKING.
 316       timer_.Stop();
 317     } else {
 318       // Stop any TransitionToIdle() timers that we may have queued
 319       // while PREEMPTING.
 320       timer_.Stop();
 321       max_preemption_time_ = timer_.desired_run_time() - base::TimeTicks::Now();
 322       if (max_preemption_time_ < base::TimeDelta()) {
 323         TransitionToIdle();
 324         return;
 325       }
 326     }
 327
 328     preemption_state_ = WOULD_PREEMPT_DESCHEDULED;
 329     preempting_flag_->Reset();
 330     TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
 331
 332     UpdatePreemptionState();
 333   }
 334
 335   static void InsertSyncPointOnMainThread(
 336       base::WeakPtr<GpuChannel> gpu_channel,
 337       scoped_refptr<SyncPointManager> manager,
 338       int32 routing_id,
 339       uint32 sync_point) {
 340     // This function must ensure that the sync point will be retired. Normally
 341     // we'll find the stub based on the routing ID, and associate the sync point
 342     // with it, but if that fails for any reason (channel or stub already
 343     // deleted, invalid routing id), we need to retire the sync point
 344     // immediately.
 345     if (gpu_channel) {
 346       GpuCommandBufferStub* stub = gpu_channel->LookupCommandBuffer(routing_id);
 347       if (stub) {
 348         stub->AddSyncPoint(sync_point);
 349         GpuCommandBufferMsg_RetireSyncPoint message(routing_id, sync_point);
 350         gpu_channel->OnMessageReceived(message);
 351         return;
 352       } else {
 353         gpu_channel->MessageProcessed();
 354       }
 355     }
 356     manager->RetireSyncPoint(sync_point);
 357   }
 358
 359   // NOTE: this weak pointer is never dereferenced on the IO thread, it's only
 360   // passed through - therefore the WeakPtr assumptions are respected.
 361   base::WeakPtr<GpuChannel> gpu_channel_;
 362   IPC::Sender* sender_;
 363   scoped_refptr<SyncPointManager> sync_point_manager_;
 364   scoped_refptr<base::MessageLoopProxy> message_loop_;
 365   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 366
 367   std::queue<PendingMessage> pending_messages_;
 368
 369   // Count of the number of IPCs forwarded to the GpuChannel.
 370   uint64 messages_forwarded_to_channel_;
 371
 372   base::OneShotTimer<GpuChannelMessageFilter> timer_;
 373
 374   bool a_stub_is_descheduled_;
 375 };
 376
 377 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
 378                        GpuWatchdog* watchdog,
 379                        gfx::GLShareGroup* share_group,
 380                        gpu::gles2::MailboxManager* mailbox,
 381                        int client_id,
 382                        bool software)
 383     : gpu_channel_manager_(gpu_channel_manager),
 384       messages_processed_(0),
 385       client_id_(client_id),
 386       share_group_(share_group ? share_group : new gfx::GLShareGroup),
 387       mailbox_manager_(mailbox ? mailbox : new gpu::gles2::MailboxManager),
 388       image_manager_(new gpu::gles2::ImageManager),
 389       watchdog_(watchdog),
 390       software_(software),
 391       handle_messages_scheduled_(false),
 392       currently_processing_message_(NULL),
 393       weak_factory_(this),
 394       num_stubs_descheduled_(0) {
 395   DCHECK(gpu_channel_manager);
 396   DCHECK(client_id);
 397
 398   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
 399   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 400   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
 401 }
 402
 403 GpuChannel::~GpuChannel() {
 404   STLDeleteElements(&deferred_messages_);
 405   if (preempting_flag_.get())
 406     preempting_flag_->Reset();
 407 }
 408
 409 void GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
 410                       base::WaitableEvent* shutdown_event) {
 411   DCHECK(!channel_.get());
 412
 413   // Map renderer ID to a (single) channel to that process.
 414   channel_ = IPC::SyncChannel::Create(channel_id_,
 415                                       IPC::Channel::MODE_SERVER,
 416                                       this,
 417                                       io_message_loop,
 418                                       false,
 419                                       shutdown_event);
 420
 421   filter_ =
 422       new GpuChannelMessageFilter(weak_factory_.GetWeakPtr(),
 423                                   gpu_channel_manager_->sync_point_manager(),
 424                                   base::MessageLoopProxy::current());
 425   io_message_loop_ = io_message_loop;
 426   channel_->AddFilter(filter_.get());
 427
 428   devtools_gpu_agent_.reset(new DevToolsGpuAgent(this));
 429 }
 430
 431 std::string GpuChannel::GetChannelName() {
 432   return channel_id_;
 433 }
 434
 435 #if defined(OS_POSIX)
 436 int GpuChannel::TakeRendererFileDescriptor() {
 437   if (!channel_) {
 438     NOTREACHED();
 439     return -1;
 440   }
 441   return channel_->TakeClientFileDescriptor();
 442 }
 443 #endif  // defined(OS_POSIX)
 444
 445 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
 446   if (log_messages_) {
 447     DVLOG(1) << "received message @" << &message << " on channel @" << this
 448              << " with type " << message.type();
 449   }
 450
 451   if (message.type() == GpuCommandBufferMsg_WaitForTokenInRange::ID ||
 452       message.type() == GpuCommandBufferMsg_WaitForGetOffsetInRange::ID) {
 453     // Move Wait commands to the head of the queue, so the renderer
 454     // doesn't have to wait any longer than necessary.
 455     deferred_messages_.push_front(new IPC::Message(message));
 456   } else {
 457     deferred_messages_.push_back(new IPC::Message(message));
 458   }
 459
 460   OnScheduled();
 461
 462   return true;
 463 }
 464
 465 void GpuChannel::OnChannelError() {
 466   gpu_channel_manager_->RemoveChannel(client_id_);
 467 }
 468
 469 bool GpuChannel::Send(IPC::Message* message) {
 470   // The GPU process must never send a synchronous IPC message to the renderer
 471   // process. This could result in deadlock.
 472   DCHECK(!message->is_sync());
 473   if (log_messages_) {
 474     DVLOG(1) << "sending message @" << message << " on channel @" << this
 475              << " with type " << message->type();
 476   }
 477
 478   if (!channel_) {
 479     delete message;
 480     return false;
 481   }
 482
 483   return channel_->Send(message);
 484 }
 485
 486 void GpuChannel::RequeueMessage() {
 487   DCHECK(currently_processing_message_);
 488   deferred_messages_.push_front(
 489       new IPC::Message(*currently_processing_message_));
 490   messages_processed_--;
 491   currently_processing_message_ = NULL;
 492 }
 493
 494 void GpuChannel::OnScheduled() {
 495   if (handle_messages_scheduled_)
 496     return;
 497   // Post a task to handle any deferred messages. The deferred message queue is
 498   // not emptied here, which ensures that OnMessageReceived will continue to
 499   // defer newly received messages until the ones in the queue have all been
 500   // handled by HandleMessage. HandleMessage is invoked as a
 501   // task to prevent reentrancy.
 502   base::MessageLoop::current()->PostTask(
 503       FROM_HERE,
 504       base::Bind(&GpuChannel::HandleMessage, weak_factory_.GetWeakPtr()));
 505   handle_messages_scheduled_ = true;
 506 }
 507
 508 void GpuChannel::StubSchedulingChanged(bool scheduled) {
 509   bool a_stub_was_descheduled = num_stubs_descheduled_ > 0;
 510   if (scheduled) {
 511     num_stubs_descheduled_--;
 512     OnScheduled();
 513   } else {
 514     num_stubs_descheduled_++;
 515   }
 516   DCHECK_LE(num_stubs_descheduled_, stubs_.size());
 517   bool a_stub_is_descheduled = num_stubs_descheduled_ > 0;
 518
 519   if (a_stub_is_descheduled != a_stub_was_descheduled) {
 520     if (preempting_flag_.get()) {
 521       io_message_loop_->PostTask(
 522           FROM_HERE,
 523           base::Bind(&GpuChannelMessageFilter::UpdateStubSchedulingState,
 524                      filter_,
 525                      a_stub_is_descheduled));
 526     }
 527   }
 528 }
 529
 530 CreateCommandBufferResult GpuChannel::CreateViewCommandBuffer(
 531     const gfx::GLSurfaceHandle& window,
 532     int32 surface_id,
 533     const GPUCreateCommandBufferConfig& init_params,
 534     int32 route_id) {
 535   TRACE_EVENT1("gpu",
 536                "GpuChannel::CreateViewCommandBuffer",
 537                "surface_id",
 538                surface_id);
 539
 540   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 541
 542   // Virtualize compositor contexts on OS X to prevent performance regressions
 543   // when enabling FCM.
 544   // http://crbug.com/180463
 545   bool use_virtualized_gl_context = false;
 546 #if defined(OS_MACOSX)
 547   use_virtualized_gl_context = true;
 548 #endif
 549
 550   scoped_ptr<GpuCommandBufferStub> stub(
 551       new GpuCommandBufferStub(this,
 552                                share_group,
 553                                window,
 554                                mailbox_manager_.get(),
 555                                image_manager_.get(),
 556                                gfx::Size(),
 557                                disallowed_features_,
 558                                init_params.attribs,
 559                                init_params.gpu_preference,
 560                                use_virtualized_gl_context,
 561                                route_id,
 562                                surface_id,
 563                                watchdog_,
 564                                software_,
 565                                init_params.active_url));
 566   if (preempted_flag_.get())
 567     stub->SetPreemptByFlag(preempted_flag_);
 568   if (!router_.AddRoute(route_id, stub.get())) {
 569     DLOG(ERROR) << "GpuChannel::CreateViewCommandBuffer(): "
 570                    "failed to add route";
 571     return CREATE_COMMAND_BUFFER_FAILED_AND_CHANNEL_LOST;
 572   }
 573   stubs_.AddWithID(stub.release(), route_id);
 574   return CREATE_COMMAND_BUFFER_SUCCEEDED;
 575 }
 576
 577 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32 route_id) {
 578   return stubs_.Lookup(route_id);
 579 }
 580
 581 void GpuChannel::CreateImage(
 582     gfx::PluginWindowHandle window,
 583     int32 image_id,
 584     gfx::Size* size) {
 585   TRACE_EVENT1("gpu",
 586                "GpuChannel::CreateImage",
 587                "image_id",
 588                image_id);
 589
 590   *size = gfx::Size();
 591
 592   if (image_manager_->LookupImage(image_id)) {
 593     LOG(ERROR) << "CreateImage failed, image_id already in use.";
 594     return;
 595   }
 596
 597   scoped_refptr<gfx::GLImage> image = gfx::GLImage::CreateGLImage(window);
 598   if (!image.get())
 599     return;
 600
 601   image_manager_->AddImage(image.get(), image_id);
 602   *size = image->GetSize();
 603 }
 604
 605 void GpuChannel::DeleteImage(int32 image_id) {
 606   TRACE_EVENT1("gpu",
 607                "GpuChannel::DeleteImage",
 608                "image_id",
 609                image_id);
 610
 611   image_manager_->RemoveImage(image_id);
 612 }
 613
 614 void GpuChannel::LoseAllContexts() {
 615   gpu_channel_manager_->LoseAllContexts();
 616 }
 617
 618 void GpuChannel::MarkAllContextsLost() {
 619   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
 620        !it.IsAtEnd(); it.Advance()) {
 621     it.GetCurrentValue()->MarkContextLost();
 622   }
 623 }
 624
 625 bool GpuChannel::AddRoute(int32 route_id, IPC::Listener* listener) {
 626   return router_.AddRoute(route_id, listener);
 627 }
 628
 629 void GpuChannel::RemoveRoute(int32 route_id) {
 630   router_.RemoveRoute(route_id);
 631 }
 632
 633 gpu::PreemptionFlag* GpuChannel::GetPreemptionFlag() {
 634   if (!preempting_flag_.get()) {
 635     preempting_flag_ = new gpu::PreemptionFlag;
 636     io_message_loop_->PostTask(
 637         FROM_HERE, base::Bind(
 638             &GpuChannelMessageFilter::SetPreemptingFlagAndSchedulingState,
 639             filter_, preempting_flag_, num_stubs_descheduled_ > 0));
 640   }
 641   return preempting_flag_.get();
 642 }
 643
 644 void GpuChannel::SetPreemptByFlag(
 645     scoped_refptr<gpu::PreemptionFlag> preempted_flag) {
 646   preempted_flag_ = preempted_flag;
 647
 648   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
 649        !it.IsAtEnd(); it.Advance()) {
 650     it.GetCurrentValue()->SetPreemptByFlag(preempted_flag_);
 651   }
 652 }
 653
 654 void GpuChannel::OnDestroy() {
 655   TRACE_EVENT0("gpu", "GpuChannel::OnDestroy");
 656   gpu_channel_manager_->RemoveChannel(client_id_);
 657 }
 658
 659 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
 660   bool handled = true;
 661   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
 662     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateOffscreenCommandBuffer,
 663                         OnCreateOffscreenCommandBuffer)
 664     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
 665                         OnDestroyCommandBuffer)
 666     IPC_MESSAGE_HANDLER(GpuChannelMsg_DevToolsStartEventsRecording,
 667                         OnDevToolsStartEventsRecording)
 668     IPC_MESSAGE_HANDLER(GpuChannelMsg_DevToolsStopEventsRecording,
 669                         OnDevToolsStopEventsRecording)
 670     IPC_MESSAGE_UNHANDLED(handled = false)
 671   IPC_END_MESSAGE_MAP()
 672   DCHECK(handled) << msg.type();
 673   return handled;
 674 }
 675
 676 void GpuChannel::HandleMessage() {
 677   handle_messages_scheduled_ = false;
 678   if (deferred_messages_.empty())
 679     return;
 680
 681   bool should_fast_track_ack = false;
 682   IPC::Message* m = deferred_messages_.front();
 683   GpuCommandBufferStub* stub = stubs_.Lookup(m->routing_id());
 684
 685   do {
 686     if (stub) {
 687       if (!stub->IsScheduled())
 688         return;
 689       if (stub->IsPreempted()) {
 690         OnScheduled();
 691         return;
 692       }
 693     }
 694
 695     scoped_ptr<IPC::Message> message(m);
 696     deferred_messages_.pop_front();
 697     bool message_processed = true;
 698
 699     currently_processing_message_ = message.get();
 700     bool result;
 701     if (message->routing_id() == MSG_ROUTING_CONTROL)
 702       result = OnControlMessageReceived(*message);
 703     else
 704       result = router_.RouteMessage(*message);
 705     currently_processing_message_ = NULL;
 706
 707     if (!result) {
 708       // Respond to sync messages even if router failed to route.
 709       if (message->is_sync()) {
 710         IPC::Message* reply = IPC::SyncMessage::GenerateReply(&*message);
 711         reply->set_reply_error();
 712         Send(reply);
 713       }
 714     } else {
 715       // If the command buffer becomes unscheduled as a result of handling the
 716       // message but still has more commands to process, synthesize an IPC
 717       // message to flush that command buffer.
 718       if (stub) {
 719         if (stub->HasUnprocessedCommands()) {
 720           deferred_messages_.push_front(new GpuCommandBufferMsg_Rescheduled(
 721               stub->route_id()));
 722           message_processed = false;
 723         }
 724       }
 725     }
 726     if (message_processed)
 727       MessageProcessed();
 728
 729     // We want the EchoACK following the SwapBuffers to be sent as close as
 730     // possible, avoiding scheduling other channels in the meantime.
 731     should_fast_track_ack = false;
 732     if (!deferred_messages_.empty()) {
 733       m = deferred_messages_.front();
 734       stub = stubs_.Lookup(m->routing_id());
 735       should_fast_track_ack =
 736           (m->type() == GpuCommandBufferMsg_Echo::ID) &&
 737           stub && stub->IsScheduled();
 738     }
 739   } while (should_fast_track_ack);
 740
 741   if (!deferred_messages_.empty()) {
 742     OnScheduled();
 743   }
 744 }
 745
 746 void GpuChannel::OnCreateOffscreenCommandBuffer(
 747     const gfx::Size& size,
 748     const GPUCreateCommandBufferConfig& init_params,
 749     int32 route_id,
 750     bool* succeeded) {
 751   TRACE_EVENT0("gpu", "GpuChannel::OnCreateOffscreenCommandBuffer");
 752   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 753
 754   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
 755       this,
 756       share_group,
 757       gfx::GLSurfaceHandle(),
 758       mailbox_manager_.get(),
 759       image_manager_.get(),
 760       size,
 761       disallowed_features_,
 762       init_params.attribs,
 763       init_params.gpu_preference,
 764       false,
 765       route_id,
 766       0,
 767       watchdog_,
 768       software_,
 769       init_params.active_url));
 770   if (preempted_flag_.get())
 771     stub->SetPreemptByFlag(preempted_flag_);
 772   if (!router_.AddRoute(route_id, stub.get())) {
 773     DLOG(ERROR) << "GpuChannel::OnCreateOffscreenCommandBuffer(): "
 774                    "failed to add route";
 775     *succeeded = false;
 776     return;
 777   }
 778   stubs_.AddWithID(stub.release(), route_id);
 779   TRACE_EVENT1("gpu", "GpuChannel::OnCreateOffscreenCommandBuffer",
 780                "route_id", route_id);
 781   *succeeded = true;
 782 }
 783
 784 void GpuChannel::OnDestroyCommandBuffer(int32 route_id) {
 785   TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer",
 786                "route_id", route_id);
 787
 788   GpuCommandBufferStub* stub = stubs_.Lookup(route_id);
 789   if (!stub)
 790     return;
 791   bool need_reschedule = (stub && !stub->IsScheduled());
 792   router_.RemoveRoute(route_id);
 793   stubs_.Remove(route_id);
 794   // In case the renderer is currently blocked waiting for a sync reply from the
 795   // stub, we need to make sure to reschedule the GpuChannel here.
 796   if (need_reschedule) {
 797     // This stub won't get a chance to reschedule, so update the count now.
 798     StubSchedulingChanged(true);
 799   }
 800 }
 801
 802 void GpuChannel::OnDevToolsStartEventsRecording(int32 route_id,
 803                                                 bool* succeeded) {
 804   *succeeded = devtools_gpu_agent_->StartEventsRecording(route_id);
 805 }
 806
 807 void GpuChannel::OnDevToolsStopEventsRecording() {
 808   devtools_gpu_agent_->StopEventsRecording();
 809 }
 810
 811 void GpuChannel::MessageProcessed() {
 812   messages_processed_++;
 813   if (preempting_flag_.get()) {
 814     io_message_loop_->PostTask(
 815         FROM_HERE,
 816         base::Bind(&GpuChannelMessageFilter::MessageProcessed,
 817                    filter_,
 818                    messages_processed_));
 819   }
 820 }
 821
 822 void GpuChannel::CacheShader(const std::string& key,
 823                              const std::string& shader) {
 824   gpu_channel_manager_->Send(
 825       new GpuHostMsg_CacheShader(client_id_, key, shader));
 826 }
 827
 828 void GpuChannel::AddFilter(IPC::MessageFilter* filter) {
 829   channel_->AddFilter(filter);
 830 }
 831
 832 void GpuChannel::RemoveFilter(IPC::MessageFilter* filter) {
 833   channel_->RemoveFilter(filter);
 834 }
 835
 836 uint64 GpuChannel::GetMemoryUsage() {
 837   uint64 size = 0;
 838   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
 839        !it.IsAtEnd(); it.Advance()) {
 840     size += it.GetCurrentValue()->GetMemoryUsage();
 841   }
 842   return size;
 843 }
 844
 845 }  // namespace content